Add missing gclient dependencies to .gitignore.

Fix the format of many directories so they don't show up in git status anymore.
Run dos2unix on *.cc, caught many inconsistent and CRLF files.

TBR=evan
TEST=still build, git status shows nothing
BUG=none

Review URL: http://codereview.chromium.org/211010


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@26441 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 606 insertions, 606 deletions

diff --git a/o3d/plugin/cross/texture_static_glue.cc b/o3d/plugin/cross/texture_static_glue.cc
index b5cf995..a3da6ef 100644
--- a/o3d/plugin/cross/texture_static_glue.cc
+++ b/o3d/plugin/cross/texture_static_glue.cc
@@ -1,606 +1,606 @@
-/*

- * Copyright 2009, Google Inc.

- * All rights reserved.

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions are

- * met:

- *

- *     * Redistributions of source code must retain the above copyright

- * notice, this list of conditions and the following disclaimer.

- *     * Redistributions in binary form must reproduce the above

- * copyright notice, this list of conditions and the following disclaimer

- * in the documentation and/or other materials provided with the

- * distribution.

- *     * Neither the name of Google Inc. nor the names of its

- * contributors may be used to endorse or promote products derived from

- * this software without specific prior written permission.

- *

- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- */

-

-#include <vector>

-#include "core/cross/pointer_utils.h"

-#include "core/cross/error.h"

-#include "core/cross/math_utilities.h"

-#include "core/cross/texture.h"

-#include "core/cross/image_utils.h"

-

-namespace {

-

-void SetRectCheck(o3d::Texture* self,

-                  void* data,

-                  int pitch,

-                  int destination_x,

-                  int destination_y,

-                  int texture_width,

-                  int texture_height,

-                  int source_width,

-                  int source_height,

-                  const std::vector<float>& values) {

-  unsigned num_components;

-  unsigned swizzle[4] = {2, 1, 0, 3};

-  switch (self->format()) {

-    case o3d::Texture::XRGB8:

-      num_components = 3;

-      break;

-    case o3d::Texture::R32F:

-      swizzle[0] = 0;

-      num_components = 1;

-      break;

-    case o3d::Texture::ARGB8:

-    case o3d::Texture::ABGR16F:

-      num_components = 4;

-      break;

-    case o3d::Texture::ABGR32F: {

-      num_components = 4;

-      const o3d::Texture::RGBASwizzleIndices& indices =

-         self->GetABGR32FSwizzleIndices();

-      for (int ii = 0; ii < 4; ++ii) {

-        swizzle[ii] = indices[ii];

-      }

-      break;

-    }

-    default:

-      DCHECK(false);

-      return;

-  }

-

-  // clip

-  int source_x = 0;

-  int source_y = 0;

-  int copy_width = source_width;

-  int copy_height = source_height;

-

-  if (destination_x < 0) {

-    copy_width += destination_x;

-    source_x -= destination_x;

-    destination_x = 0;

-  }

-  if (destination_x + copy_width > static_cast<int>(texture_width)) {

-    copy_width -= destination_x + copy_width - texture_width;

-  }

-

-  if (destination_y < 0) {

-    copy_height += destination_y;

-    source_y -= destination_y;

-    destination_y = 0;

-  }

-  if (destination_y + copy_height > static_cast<int>(texture_height)) {

-    copy_height -= destination_y + copy_height - texture_height;

-  }

-

-  if (copy_width <= 0 || copy_height <= 0) {

-    return;

-  }

-

-  const float* source =

-      &values[0] +

-      (source_y * source_width + source_x) * num_components;

-  unsigned source_stride = (source_width - copy_width) * num_components;

-  switch (self->format()) {

-    case o3d::Texture::ABGR16F: {

-      uint16* dest_line =

-          static_cast<uint16*>(data) +

-          (destination_y * texture_width + destination_x) * num_components;

-      for (; copy_height > 0; --copy_height) {

-        uint16* destination = dest_line;

-        for (int xx = 0; xx < copy_width; ++xx) {

-          for (unsigned element = 0; element < num_components; ++element) {

-            destination[element] = Vectormath::Aos::FloatToHalf(

-                source[swizzle[element]]);

-          }

-          destination += num_components;

-          source += num_components;

-        }

-        dest_line = o3d::AddPointerOffset<uint16*>(dest_line, pitch);

-        source += source_stride;

-      }

-      break;

-    }

-    case o3d::Texture::R32F:

-    case o3d::Texture::ABGR32F: {

-      float* dest_line =

-        static_cast<float*>(data) +

-        (destination_y * texture_width + destination_x) * num_components;

-      for (; copy_height > 0; --copy_height) {

-        float* destination = dest_line;

-        for (int xx = 0; xx < copy_width; ++xx) {

-          for (unsigned element = 0; element < num_components; ++element) {

-            destination[element] = source[swizzle[element]];

-          }

-          destination += num_components;

-          source += num_components;

-        }

-        dest_line = o3d::AddPointerOffset<float*>(dest_line, pitch);

-        source += source_stride;

-      }

-      break;

-    }

-    default: {

-      uint8* dest_line =

-          static_cast<uint8*>(data) +

-         (destination_y * texture_width + destination_x) * 4;

-      for (; copy_height > 0; --copy_height) {

-        uint8* destination = dest_line;

-        for (int xx = 0; xx < copy_width; ++xx) {

-          destination[0] = static_cast<unsigned char>(

-              source[swizzle[0]] * 255.0f);

-          destination[1] = static_cast<unsigned char>(

-              source[swizzle[1]] * 255.0f);

-          destination[2] = static_cast<unsigned char>(

-              source[swizzle[2]] * 255.0f);

-          destination[3] = (num_components == 4) ?

-              static_cast<unsigned char>(source[swizzle[3]] * 255.0f) : 255;

-          destination += 4;

-          source += num_components;

-        }

-        dest_line = o3d::AddPointerOffset<uint8*>(dest_line, pitch);

-        source += source_stride;

-      }

-      break;

-    }

-  }

-}

-

-void SetRectCheck2D(o3d::Texture2D* self,

-                    int level,

-                    int destination_x,

-                    int destination_y,

-                    int source_width,

-                    const std::vector<float>& values,

-                    bool check_needed) {

-  if (level < 0 || level >= self->levels()) {

-    O3D_ERROR(self->service_locator())

-        << "level (" << level << " out of range";

-    return;

-  }

-  if (values.empty() || source_width <= 0) {

-    return;

-  }

-  unsigned num_values = values.size();

-  unsigned texture_width = std::max(self->width() >> level, 1);

-  unsigned texture_height = std::max(self->height() >> level, 1);

-  unsigned num_components;

-  switch (self->format()) {

-    case o3d::Texture::XRGB8:

-      num_components = 3;

-      break;

-    case o3d::Texture::R32F:

-      num_components = 1;

-      break;

-    case o3d::Texture::ARGB8:

-    case o3d::Texture::ABGR16F:

-      num_components = 4;

-      break;

-    case o3d::Texture::ABGR32F: {

-      num_components = 4;

-      break;

-    }

-    default:

-      O3D_ERROR(self->service_locator())

-        << "Texture::Set not supported for this type of texture";

-      return;

-  }

-  if (num_values % num_components != 0) {

-    O3D_ERROR(self->service_locator())

-      << "The number of elements passed in must be a multiple of "

-      << num_components;

-  }

-  unsigned num_elements = num_values / num_components;

-  if (num_elements % source_width != 0) {

-    O3D_ERROR(self->service_locator())

-      << "The number of elements passed in must be a multiple of the "

-      << "width";

-    return;

-  }

-  unsigned source_height = num_elements / source_width;

-  if (check_needed) {

-    unsigned needed = num_components * texture_width * texture_height;

-    if (num_values != needed) {

-      O3D_ERROR(self->service_locator())

-        << "needed " << needed << " values but " << num_values

-        << " passed in.";

-      return;

-    }

-  }

-  o3d::Texture2D::LockHelper helper(self, level, o3d::Texture::kWriteOnly);

-  void* data = helper.GetData();

-  if (!data) {

-    O3D_ERROR(self->service_locator()) << "could not lock texture";

-    return;

-  }

-

-  SetRectCheck(self, data, helper.pitch(),

-               destination_x, destination_y,

-               texture_width, texture_height,

-               source_width, source_height,

-               values);

-}

-

-void SetRectCheckCUBE(o3d::TextureCUBE* self,

-                      o3d::TextureCUBE::CubeFace face,

-                      int level,

-                      int destination_x,

-                      int destination_y,

-                      int source_width,

-                      const std::vector<float>& values,

-                      bool check_needed) {

-  if (level < 0 || level >= self->levels()) {

-    O3D_ERROR(self->service_locator())

-        << "level (" << level << " out of range";

-    return;

-  }

-  if (values.empty() || source_width <= 0) {

-    return;

-  }

-  unsigned num_values = values.size();

-  unsigned texture_width = std::max(self->edge_length() >> level, 1);

-  unsigned texture_height = texture_width;

-  unsigned num_components;

-  switch (self->format()) {

-    case o3d::Texture::XRGB8:

-      num_components = 3;

-      break;

-    case o3d::Texture::R32F:

-      num_components = 1;

-      break;

-    case o3d::Texture::ARGB8:

-    case o3d::Texture::ABGR16F:

-      num_components = 4;

-      break;

-    case o3d::Texture::ABGR32F: {

-      num_components = 4;

-      break;

-    }

-    default:

-      O3D_ERROR(self->service_locator())

-        << "Texture::Set not supported for this type of texture";

-      return;

-  }

-  if (num_values % num_components != 0) {

-    O3D_ERROR(self->service_locator())

-      << "The number of elements passed in must be a multiple of "

-      << num_components;

-  }

-  unsigned num_elements = num_values / num_components;

-  if (num_elements % source_width != 0) {

-    O3D_ERROR(self->service_locator())

-      << "The number of elements passed in must be a multiple of the "

-      << "width";

-    return;

-  }

-  unsigned source_height = num_elements / source_width;

-  if (check_needed) {

-    unsigned needed = num_components * texture_width * texture_height;

-    if (num_values != needed) {

-      O3D_ERROR(self->service_locator())

-        << "needed " << needed << " values but " << num_values

-        << " passed in.";

-      return;

-    }

-  }

-  o3d::TextureCUBE::LockHelper helper(

-      self, face, level, o3d::Texture::kWriteOnly);

-  void* data = helper.GetData();

-  if (!data) {

-    O3D_ERROR(self->service_locator()) << "could not lock texture";

-    return;

-  }

-

-  SetRectCheck(self, data, helper.pitch(),

-               destination_x, destination_y,

-               texture_width, texture_height,

-               source_width, source_height,

-               values);

-}

-

-// Assumes dst points to width * height * num_components floats.

-void GetRect(o3d::Texture* self,

-             const void* src_data,

-             int src_pitch,

-             int x,

-             int y,

-             int width,

-             int height,

-             float* dst) {

-  unsigned num_components;

-  unsigned swizzle[4] = {2, 1, 0, 3};

-  switch (self->format()) {

-    case o3d::Texture::XRGB8:

-      num_components = 3;

-      break;

-    case o3d::Texture::R32F:

-      swizzle[0] = 0;

-      num_components = 1;

-      break;

-    case o3d::Texture::ARGB8:

-    case o3d::Texture::ABGR16F:

-      num_components = 4;

-      break;

-    case o3d::Texture::ABGR32F: {

-      num_components = 4;

-      const o3d::Texture::RGBASwizzleIndices& indices =

-         self->GetABGR32FSwizzleIndices();

-      for (int ii = 0; ii < 4; ++ii) {

-        swizzle[ii] = indices[ii];

-      }

-      break;

-    }

-    default:

-      DCHECK(false);

-      return;

-  }

-

-  switch (self->format()) {

-    case o3d::Texture::ABGR16F: {

-      uint16* src_line = o3d::PointerFromVoidPointer<uint16*>(

-          src_data,

-          (y * src_pitch)) + x * num_components;

-      for (; height > 0; --height) {

-        uint16* src = src_line;

-        for (int xx = 0; xx < width; ++xx) {

-          for (unsigned element = 0; element < num_components; ++element) {

-            dst[swizzle[element]] = Vectormath::Aos::HalfToFloat(src[element]);

-          }

-          dst += num_components;

-          src += num_components;

-        }

-        src_line = o3d::AddPointerOffset<uint16*>(src_line, src_pitch);

-      }

-      break;

-    }

-    case o3d::Texture::R32F:

-    case o3d::Texture::ABGR32F: {

-      float* src_line = o3d::PointerFromVoidPointer<float*>(

-          src_data,

-          (y * src_pitch)) + x * num_components;

-      for (; height > 0; --height) {

-        float* src = src_line;

-        for (int xx = 0; xx < width; ++xx) {

-          for (unsigned element = 0; element < num_components; ++element) {

-            dst[swizzle[element]] = src[element];

-          }

-          dst += num_components;

-          src += num_components;

-        }

-        src_line = o3d::AddPointerOffset<float*>(src_line, src_pitch);

-      }

-      break;

-    }

-    default: {

-      uint8* src_line = o3d::PointerFromVoidPointer<uint8*>(

-          src_data,

-          (y * src_pitch)) + x * num_components;

-      for (; height > 0; --height) {

-        uint8* src = src_line;

-        for (int xx = 0; xx < width; ++xx) {

-          dst[swizzle[0]] = static_cast<float>(src[0]) / 255.0f;

-          dst[swizzle[1]] = static_cast<float>(src[1]) / 255.0f;

-          dst[swizzle[2]] = static_cast<float>(src[2]) / 255.0f;

-          if (num_components == 4) {

-            dst[swizzle[3]] = static_cast<float>(src[3]) / 255.0f;

-          }

-          dst += num_components;

-          src += 4;

-        }

-        src_line = o3d::AddPointerOffset<uint8*>(src_line, src_pitch);

-      }

-      break;

-    }

-  }

-}

-

-}  // anonymous namespace

-

-namespace glue {

-namespace namespace_o3d {

-namespace class_Texture2D {

-

-void userglue_method_SetRect(o3d::Texture2D* self,

-                             int level,

-                             int destination_x,

-                             int destination_y,

-                             int source_width,

-                             const std::vector<float>& values) {

-  SetRectCheck2D(self,

-                 level,

-                 destination_x,

-                 destination_y,

-                 source_width,

-                 values,

-                 false);

-}

-void userglue_method_Set(o3d::Texture2D* self,

-                         int level,

-                         const std::vector<float>& values) {

-  SetRectCheck2D(

-      self, level, 0, 0,

-      o3d::image::ComputeMipDimension(level, self->width()),

-      values, true);

-}

-std::vector<float> userglue_method_GetRect(o3d::Texture2D* self,

-                                           int level,

-                                           int x,

-                                           int y,

-                                           int width,

-                                           int height) {

-  std::vector<float> empty;

-  if (level < 0 || level >= self->levels()) {

-    O3D_ERROR(self->service_locator())

-        << "level (" << level << " out of range";

-    return empty;

-  }

-  if (width <= 0 || height <= 0) {

-    O3D_ERROR(self->service_locator())

-        << "width and height must be positive";

-    return empty;

-  }

-

-  int mip_width =

-      static_cast<int>(o3d::image::ComputeMipDimension(level, self->width()));

-  int mip_height =

-      static_cast<int>(o3d::image::ComputeMipDimension(level, self->height()));

-

-  if (x < 0 || x + width > mip_width || y < 0 || y + height > mip_height) {

-    O3D_ERROR(self->service_locator()) << "area out of range";

-    return empty;

-  }

-

-  unsigned num_components;

-  switch (self->format()) {

-    case o3d::Texture::XRGB8:

-      num_components = 3;

-      break;

-    case o3d::Texture::R32F:

-      num_components = 1;

-      break;

-    case o3d::Texture::ARGB8:

-    case o3d::Texture::ABGR16F:

-      num_components = 4;

-      break;

-    case o3d::Texture::ABGR32F: {

-      num_components = 4;

-      break;

-    }

-    default:

-      O3D_ERROR(self->service_locator())

-        << "Texture::Set not supported for this type of texture";

-      return empty;

-  }

-  o3d::Texture2D::LockHelper helper(self, level, o3d::Texture::kReadOnly);

-  void* data = helper.GetData();

-  if (!data) {

-    O3D_ERROR(self->service_locator()) << "could not lock texture";

-    return empty;

-  }

-

-  std::vector<float> values(width * height * num_components, 0);

-  GetRect(self, data, helper.pitch(), x, y, width, height, &values[0]);

-  return values;

-}

-

-}  // namespace class_Texture2D

-

-namespace class_TextureCUBE {

-

-void userglue_method_SetRect(o3d::TextureCUBE* self,

-                             o3d::TextureCUBE::CubeFace face,

-                             int level,

-                             int destination_x,

-                             int destination_y,

-                             int source_width,

-                             const std::vector<float>& values) {

-  SetRectCheckCUBE(self,

-                   face,

-                   level,

-                   destination_x,

-                   destination_y,

-                   source_width,

-                   values,

-                   false);

-}

-void userglue_method_Set(o3d::TextureCUBE* self,

-                         o3d::TextureCUBE::CubeFace face,

-                         int level,

-                         const std::vector<float>& values) {

-  SetRectCheckCUBE(self, face, level, 0, 0,

-                   o3d::image::ComputeMipDimension(level, self->edge_length()),

-                   values, true);

-}

-std::vector<float> userglue_method_GetRect(o3d::TextureCUBE* self,

-                                           o3d::TextureCUBE::CubeFace face,

-                                           int level,

-                                           int x,

-                                           int y,

-                                           int width,

-                                           int height) {

-  std::vector<float> empty;

-  if (level < 0 || level >= self->levels()) {

-    O3D_ERROR(self->service_locator())

-        << "level (" << level << " out of range";

-    return empty;

-  }

-  if (width <= 0 || height <= 0) {

-    O3D_ERROR(self->service_locator())

-        << "width and height must be positive";

-    return empty;

-  }

-

-  int mip_length = static_cast<int>(o3d::image::ComputeMipDimension(

-      level, self->edge_length()));

-

-  if (x < 0 || x + width > mip_length || y < 0 || y + height > mip_length) {

-    O3D_ERROR(self->service_locator()) << "area out of range";

-    return empty;

-  }

-

-  unsigned num_components;

-  switch (self->format()) {

-    case o3d::Texture::XRGB8:

-      num_components = 3;

-      break;

-    case o3d::Texture::R32F:

-      num_components = 1;

-      break;

-    case o3d::Texture::ARGB8:

-    case o3d::Texture::ABGR16F:

-      num_components = 4;

-      break;

-    case o3d::Texture::ABGR32F: {

-      num_components = 4;

-      break;

-    }

-    default:

-      O3D_ERROR(self->service_locator())

-        << "Texture::Set not supported for this type of texture";

-      return empty;

-  }

-  o3d::TextureCUBE::LockHelper helper(

-      self, face, level, o3d::Texture::kReadOnly);

-  void* data = helper.GetData();

-  if (!data) {

-    O3D_ERROR(self->service_locator()) << "could not lock texture";

-    return empty;

-  }

-

-  std::vector<float> values(width * height * num_components, 0);

-  GetRect(self, data, helper.pitch(), x, y, width, height, &values[0]);

-  return values;

-}

-

-}  // namespace class_TextureCUBE

-

-}  // namespace namespace_o3d

-}  // namespace glue

-

+/*
+ * Copyright 2009, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <vector>
+#include "core/cross/pointer_utils.h"
+#include "core/cross/error.h"
+#include "core/cross/math_utilities.h"
+#include "core/cross/texture.h"
+#include "core/cross/image_utils.h"
+
+namespace {
+
+void SetRectCheck(o3d::Texture* self,
+                  void* data,
+                  int pitch,
+                  int destination_x,
+                  int destination_y,
+                  int texture_width,
+                  int texture_height,
+                  int source_width,
+                  int source_height,
+                  const std::vector<float>& values) {
+  unsigned num_components;
+  unsigned swizzle[4] = {2, 1, 0, 3};
+  switch (self->format()) {
+    case o3d::Texture::XRGB8:
+      num_components = 3;
+      break;
+    case o3d::Texture::R32F:
+      swizzle[0] = 0;
+      num_components = 1;
+      break;
+    case o3d::Texture::ARGB8:
+    case o3d::Texture::ABGR16F:
+      num_components = 4;
+      break;
+    case o3d::Texture::ABGR32F: {
+      num_components = 4;
+      const o3d::Texture::RGBASwizzleIndices& indices =
+         self->GetABGR32FSwizzleIndices();
+      for (int ii = 0; ii < 4; ++ii) {
+        swizzle[ii] = indices[ii];
+      }
+      break;
+    }
+    default:
+      DCHECK(false);
+      return;
+  }
+
+  // clip
+  int source_x = 0;
+  int source_y = 0;
+  int copy_width = source_width;
+  int copy_height = source_height;
+
+  if (destination_x < 0) {
+    copy_width += destination_x;
+    source_x -= destination_x;
+    destination_x = 0;
+  }
+  if (destination_x + copy_width > static_cast<int>(texture_width)) {
+    copy_width -= destination_x + copy_width - texture_width;
+  }
+
+  if (destination_y < 0) {
+    copy_height += destination_y;
+    source_y -= destination_y;
+    destination_y = 0;
+  }
+  if (destination_y + copy_height > static_cast<int>(texture_height)) {
+    copy_height -= destination_y + copy_height - texture_height;
+  }
+
+  if (copy_width <= 0 || copy_height <= 0) {
+    return;
+  }
+
+  const float* source =
+      &values[0] +
+      (source_y * source_width + source_x) * num_components;
+  unsigned source_stride = (source_width - copy_width) * num_components;
+  switch (self->format()) {
+    case o3d::Texture::ABGR16F: {
+      uint16* dest_line =
+          static_cast<uint16*>(data) +
+          (destination_y * texture_width + destination_x) * num_components;
+      for (; copy_height > 0; --copy_height) {
+        uint16* destination = dest_line;
+        for (int xx = 0; xx < copy_width; ++xx) {
+          for (unsigned element = 0; element < num_components; ++element) {
+            destination[element] = Vectormath::Aos::FloatToHalf(
+                source[swizzle[element]]);
+          }
+          destination += num_components;
+          source += num_components;
+        }
+        dest_line = o3d::AddPointerOffset<uint16*>(dest_line, pitch);
+        source += source_stride;
+      }
+      break;
+    }
+    case o3d::Texture::R32F:
+    case o3d::Texture::ABGR32F: {
+      float* dest_line =
+        static_cast<float*>(data) +
+        (destination_y * texture_width + destination_x) * num_components;
+      for (; copy_height > 0; --copy_height) {
+        float* destination = dest_line;
+        for (int xx = 0; xx < copy_width; ++xx) {
+          for (unsigned element = 0; element < num_components; ++element) {
+            destination[element] = source[swizzle[element]];
+          }
+          destination += num_components;
+          source += num_components;
+        }
+        dest_line = o3d::AddPointerOffset<float*>(dest_line, pitch);
+        source += source_stride;
+      }
+      break;
+    }
+    default: {
+      uint8* dest_line =
+          static_cast<uint8*>(data) +
+         (destination_y * texture_width + destination_x) * 4;
+      for (; copy_height > 0; --copy_height) {
+        uint8* destination = dest_line;
+        for (int xx = 0; xx < copy_width; ++xx) {
+          destination[0] = static_cast<unsigned char>(
+              source[swizzle[0]] * 255.0f);
+          destination[1] = static_cast<unsigned char>(
+              source[swizzle[1]] * 255.0f);
+          destination[2] = static_cast<unsigned char>(
+              source[swizzle[2]] * 255.0f);
+          destination[3] = (num_components == 4) ?
+              static_cast<unsigned char>(source[swizzle[3]] * 255.0f) : 255;
+          destination += 4;
+          source += num_components;
+        }
+        dest_line = o3d::AddPointerOffset<uint8*>(dest_line, pitch);
+        source += source_stride;
+      }
+      break;
+    }
+  }
+}
+
+void SetRectCheck2D(o3d::Texture2D* self,
+                    int level,
+                    int destination_x,
+                    int destination_y,
+                    int source_width,
+                    const std::vector<float>& values,
+                    bool check_needed) {
+  if (level < 0 || level >= self->levels()) {
+    O3D_ERROR(self->service_locator())
+        << "level (" << level << " out of range";
+    return;
+  }
+  if (values.empty() || source_width <= 0) {
+    return;
+  }
+  unsigned num_values = values.size();
+  unsigned texture_width = std::max(self->width() >> level, 1);
+  unsigned texture_height = std::max(self->height() >> level, 1);
+  unsigned num_components;
+  switch (self->format()) {
+    case o3d::Texture::XRGB8:
+      num_components = 3;
+      break;
+    case o3d::Texture::R32F:
+      num_components = 1;
+      break;
+    case o3d::Texture::ARGB8:
+    case o3d::Texture::ABGR16F:
+      num_components = 4;
+      break;
+    case o3d::Texture::ABGR32F: {
+      num_components = 4;
+      break;
+    }
+    default:
+      O3D_ERROR(self->service_locator())
+        << "Texture::Set not supported for this type of texture";
+      return;
+  }
+  if (num_values % num_components != 0) {
+    O3D_ERROR(self->service_locator())
+      << "The number of elements passed in must be a multiple of "
+      << num_components;
+  }
+  unsigned num_elements = num_values / num_components;
+  if (num_elements % source_width != 0) {
+    O3D_ERROR(self->service_locator())
+      << "The number of elements passed in must be a multiple of the "
+      << "width";
+    return;
+  }
+  unsigned source_height = num_elements / source_width;
+  if (check_needed) {
+    unsigned needed = num_components * texture_width * texture_height;
+    if (num_values != needed) {
+      O3D_ERROR(self->service_locator())
+        << "needed " << needed << " values but " << num_values
+        << " passed in.";
+      return;
+    }
+  }
+  o3d::Texture2D::LockHelper helper(self, level, o3d::Texture::kWriteOnly);
+  void* data = helper.GetData();
+  if (!data) {
+    O3D_ERROR(self->service_locator()) << "could not lock texture";
+    return;
+  }
+
+  SetRectCheck(self, data, helper.pitch(),
+               destination_x, destination_y,
+               texture_width, texture_height,
+               source_width, source_height,
+               values);
+}
+
+void SetRectCheckCUBE(o3d::TextureCUBE* self,
+                      o3d::TextureCUBE::CubeFace face,
+                      int level,
+                      int destination_x,
+                      int destination_y,
+                      int source_width,
+                      const std::vector<float>& values,
+                      bool check_needed) {
+  if (level < 0 || level >= self->levels()) {
+    O3D_ERROR(self->service_locator())
+        << "level (" << level << " out of range";
+    return;
+  }
+  if (values.empty() || source_width <= 0) {
+    return;
+  }
+  unsigned num_values = values.size();
+  unsigned texture_width = std::max(self->edge_length() >> level, 1);
+  unsigned texture_height = texture_width;
+  unsigned num_components;
+  switch (self->format()) {
+    case o3d::Texture::XRGB8:
+      num_components = 3;
+      break;
+    case o3d::Texture::R32F:
+      num_components = 1;
+      break;
+    case o3d::Texture::ARGB8:
+    case o3d::Texture::ABGR16F:
+      num_components = 4;
+      break;
+    case o3d::Texture::ABGR32F: {
+      num_components = 4;
+      break;
+    }
+    default:
+      O3D_ERROR(self->service_locator())
+        << "Texture::Set not supported for this type of texture";
+      return;
+  }
+  if (num_values % num_components != 0) {
+    O3D_ERROR(self->service_locator())
+      << "The number of elements passed in must be a multiple of "
+      << num_components;
+  }
+  unsigned num_elements = num_values / num_components;
+  if (num_elements % source_width != 0) {
+    O3D_ERROR(self->service_locator())
+      << "The number of elements passed in must be a multiple of the "
+      << "width";
+    return;
+  }
+  unsigned source_height = num_elements / source_width;
+  if (check_needed) {
+    unsigned needed = num_components * texture_width * texture_height;
+    if (num_values != needed) {
+      O3D_ERROR(self->service_locator())
+        << "needed " << needed << " values but " << num_values
+        << " passed in.";
+      return;
+    }
+  }
+  o3d::TextureCUBE::LockHelper helper(
+      self, face, level, o3d::Texture::kWriteOnly);
+  void* data = helper.GetData();
+  if (!data) {
+    O3D_ERROR(self->service_locator()) << "could not lock texture";
+    return;
+  }
+
+  SetRectCheck(self, data, helper.pitch(),
+               destination_x, destination_y,
+               texture_width, texture_height,
+               source_width, source_height,
+               values);
+}
+
+// Assumes dst points to width * height * num_components floats.
+void GetRect(o3d::Texture* self,
+             const void* src_data,
+             int src_pitch,
+             int x,
+             int y,
+             int width,
+             int height,
+             float* dst) {
+  unsigned num_components;
+  unsigned swizzle[4] = {2, 1, 0, 3};
+  switch (self->format()) {
+    case o3d::Texture::XRGB8:
+      num_components = 3;
+      break;
+    case o3d::Texture::R32F:
+      swizzle[0] = 0;
+      num_components = 1;
+      break;
+    case o3d::Texture::ARGB8:
+    case o3d::Texture::ABGR16F:
+      num_components = 4;
+      break;
+    case o3d::Texture::ABGR32F: {
+      num_components = 4;
+      const o3d::Texture::RGBASwizzleIndices& indices =
+         self->GetABGR32FSwizzleIndices();
+      for (int ii = 0; ii < 4; ++ii) {
+        swizzle[ii] = indices[ii];
+      }
+      break;
+    }
+    default:
+      DCHECK(false);
+      return;
+  }
+
+  switch (self->format()) {
+    case o3d::Texture::ABGR16F: {
+      uint16* src_line = o3d::PointerFromVoidPointer<uint16*>(
+          src_data,
+          (y * src_pitch)) + x * num_components;
+      for (; height > 0; --height) {
+        uint16* src = src_line;
+        for (int xx = 0; xx < width; ++xx) {
+          for (unsigned element = 0; element < num_components; ++element) {
+            dst[swizzle[element]] = Vectormath::Aos::HalfToFloat(src[element]);
+          }
+          dst += num_components;
+          src += num_components;
+        }
+        src_line = o3d::AddPointerOffset<uint16*>(src_line, src_pitch);
+      }
+      break;
+    }
+    case o3d::Texture::R32F:
+    case o3d::Texture::ABGR32F: {
+      float* src_line = o3d::PointerFromVoidPointer<float*>(
+          src_data,
+          (y * src_pitch)) + x * num_components;
+      for (; height > 0; --height) {
+        float* src = src_line;
+        for (int xx = 0; xx < width; ++xx) {
+          for (unsigned element = 0; element < num_components; ++element) {
+            dst[swizzle[element]] = src[element];
+          }
+          dst += num_components;
+          src += num_components;
+        }
+        src_line = o3d::AddPointerOffset<float*>(src_line, src_pitch);
+      }
+      break;
+    }
+    default: {
+      uint8* src_line = o3d::PointerFromVoidPointer<uint8*>(
+          src_data,
+          (y * src_pitch)) + x * num_components;
+      for (; height > 0; --height) {
+        uint8* src = src_line;
+        for (int xx = 0; xx < width; ++xx) {
+          dst[swizzle[0]] = static_cast<float>(src[0]) / 255.0f;
+          dst[swizzle[1]] = static_cast<float>(src[1]) / 255.0f;
+          dst[swizzle[2]] = static_cast<float>(src[2]) / 255.0f;
+          if (num_components == 4) {
+            dst[swizzle[3]] = static_cast<float>(src[3]) / 255.0f;
+          }
+          dst += num_components;
+          src += 4;
+        }
+        src_line = o3d::AddPointerOffset<uint8*>(src_line, src_pitch);
+      }
+      break;
+    }
+  }
+}
+
+}  // anonymous namespace
+
+namespace glue {
+namespace namespace_o3d {
+namespace class_Texture2D {
+
+void userglue_method_SetRect(o3d::Texture2D* self,
+                             int level,
+                             int destination_x,
+                             int destination_y,
+                             int source_width,
+                             const std::vector<float>& values) {
+  SetRectCheck2D(self,
+                 level,
+                 destination_x,
+                 destination_y,
+                 source_width,
+                 values,
+                 false);
+}
+void userglue_method_Set(o3d::Texture2D* self,
+                         int level,
+                         const std::vector<float>& values) {
+  SetRectCheck2D(
+      self, level, 0, 0,
+      o3d::image::ComputeMipDimension(level, self->width()),
+      values, true);
+}
+std::vector<float> userglue_method_GetRect(o3d::Texture2D* self,
+                                           int level,
+                                           int x,
+                                           int y,
+                                           int width,
+                                           int height) {
+  std::vector<float> empty;
+  if (level < 0 || level >= self->levels()) {
+    O3D_ERROR(self->service_locator())
+        << "level (" << level << " out of range";
+    return empty;
+  }
+  if (width <= 0 || height <= 0) {
+    O3D_ERROR(self->service_locator())
+        << "width and height must be positive";
+    return empty;
+  }
+
+  int mip_width =
+      static_cast<int>(o3d::image::ComputeMipDimension(level, self->width()));
+  int mip_height =
+      static_cast<int>(o3d::image::ComputeMipDimension(level, self->height()));
+
+  if (x < 0 || x + width > mip_width || y < 0 || y + height > mip_height) {
+    O3D_ERROR(self->service_locator()) << "area out of range";
+    return empty;
+  }
+
+  unsigned num_components;
+  switch (self->format()) {
+    case o3d::Texture::XRGB8:
+      num_components = 3;
+      break;
+    case o3d::Texture::R32F:
+      num_components = 1;
+      break;
+    case o3d::Texture::ARGB8:
+    case o3d::Texture::ABGR16F:
+      num_components = 4;
+      break;
+    case o3d::Texture::ABGR32F: {
+      num_components = 4;
+      break;
+    }
+    default:
+      O3D_ERROR(self->service_locator())
+        << "Texture::Set not supported for this type of texture";
+      return empty;
+  }
+  o3d::Texture2D::LockHelper helper(self, level, o3d::Texture::kReadOnly);
+  void* data = helper.GetData();
+  if (!data) {
+    O3D_ERROR(self->service_locator()) << "could not lock texture";
+    return empty;
+  }
+
+  std::vector<float> values(width * height * num_components, 0);
+  GetRect(self, data, helper.pitch(), x, y, width, height, &values[0]);
+  return values;
+}
+
+}  // namespace class_Texture2D
+
+namespace class_TextureCUBE {
+
+void userglue_method_SetRect(o3d::TextureCUBE* self,
+                             o3d::TextureCUBE::CubeFace face,
+                             int level,
+                             int destination_x,
+                             int destination_y,
+                             int source_width,
+                             const std::vector<float>& values) {
+  SetRectCheckCUBE(self,
+                   face,
+                   level,
+                   destination_x,
+                   destination_y,
+                   source_width,
+                   values,
+                   false);
+}
+void userglue_method_Set(o3d::TextureCUBE* self,
+                         o3d::TextureCUBE::CubeFace face,
+                         int level,
+                         const std::vector<float>& values) {
+  SetRectCheckCUBE(self, face, level, 0, 0,
+                   o3d::image::ComputeMipDimension(level, self->edge_length()),
+                   values, true);
+}
+std::vector<float> userglue_method_GetRect(o3d::TextureCUBE* self,
+                                           o3d::TextureCUBE::CubeFace face,
+                                           int level,
+                                           int x,
+                                           int y,
+                                           int width,
+                                           int height) {
+  std::vector<float> empty;
+  if (level < 0 || level >= self->levels()) {
+    O3D_ERROR(self->service_locator())
+        << "level (" << level << " out of range";
+    return empty;
+  }
+  if (width <= 0 || height <= 0) {
+    O3D_ERROR(self->service_locator())
+        << "width and height must be positive";
+    return empty;
+  }
+
+  int mip_length = static_cast<int>(o3d::image::ComputeMipDimension(
+      level, self->edge_length()));
+
+  if (x < 0 || x + width > mip_length || y < 0 || y + height > mip_length) {
+    O3D_ERROR(self->service_locator()) << "area out of range";
+    return empty;
+  }
+
+  unsigned num_components;
+  switch (self->format()) {
+    case o3d::Texture::XRGB8:
+      num_components = 3;
+      break;
+    case o3d::Texture::R32F:
+      num_components = 1;
+      break;
+    case o3d::Texture::ARGB8:
+    case o3d::Texture::ABGR16F:
+      num_components = 4;
+      break;
+    case o3d::Texture::ABGR32F: {
+      num_components = 4;
+      break;
+    }
+    default:
+      O3D_ERROR(self->service_locator())
+        << "Texture::Set not supported for this type of texture";
+      return empty;
+  }
+  o3d::TextureCUBE::LockHelper helper(
+      self, face, level, o3d::Texture::kReadOnly);
+  void* data = helper.GetData();
+  if (!data) {
+    O3D_ERROR(self->service_locator()) << "could not lock texture";
+    return empty;
+  }
+
+  std::vector<float> values(width * height * num_components, 0);
+  GetRect(self, data, helper.pitch(), x, y, width, height, &values[0]);
+  return values;
+}
+
+}  // namespace class_TextureCUBE
+
+}  // namespace namespace_o3d
+}  // namespace glue
+