This fixes a number of things that are warnings in the Mac compiler....

core/cross/gl/texture_gl.cc

 /*
  * 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.
@@ skipping 117 matching lines @@
       } else {
         // TODO: we need to convert DXT3 -> RGBA8 but keep around the
         // pixels so that we can read them back (we won't try to convert back
         // to DXTC).
         LOG(ERROR) << "DXT5 compressed textures not supported yet.";
         *internal_format = 0;
         *data_type = GL_BYTE;
         return 0;
       }
     }
+    case Texture::UNKNOWN_FORMAT:
+      break;
   }
   // failed to find a matching format
   LOG(ERROR) << "Unrecognized Texture format type.";
   *internal_format = 0;
   *data_type = 0;
   return 0;
 }
 
 // Updates a GL image from a bitmap, rescaling if necessary.
 static bool UpdateGLImageFromBitmap(GLenum target,
@@ skipping 114 matching lines @@
                 bitmap.width(),
                 bitmap.height(),
                 bitmap.format(),
                 bitmap.num_mipmaps(),
                 bitmap.CheckAlphaIsOne(),
                 resize_to_pot,
                 enable_render_surfaces),
       renderer_(static_cast<RendererGL*>(
           service_locator->GetService<Renderer>())),
       gl_texture_(texture),
-      has_levels_(0),
-      backing_bitmap_(Bitmap::Ref(new Bitmap(service_locator))) {
+      backing_bitmap_(Bitmap::Ref(new Bitmap(service_locator))),
+      has_levels_(0) {
   DLOG(INFO) << "Texture2DGL Construct from GLint";
   DCHECK_NE(format(), Texture::UNKNOWN_FORMAT);
 }
 
 // Creates a new texture object from scratch.
 Texture2DGL* Texture2DGL::Create(ServiceLocator* service_locator,
                                  Bitmap *bitmap,
                                  bool enable_render_surfaces) {
   DLOG(INFO) << "Texture2DGL Create";
   DCHECK_NE(bitmap->format(), Texture::UNKNOWN_FORMAT);
@@ skipping 64 matching lines @@
       memset(texture->backing_bitmap_->image_data(), 0,
              texture->backing_bitmap_->GetTotalSize());
       texture->has_levels_ = (1 << bitmap->num_mipmaps()) - 1;
     }
   }
   CHECK_GL_ERROR();
   return texture;
 }
 
 void Texture2DGL::UpdateBackedMipLevel(unsigned int level) {
-  DCHECK_LT(level, levels());
+  DCHECK_LT(static_cast<int>(level), levels());
   DCHECK(backing_bitmap_->image_data());
-  DCHECK_EQ(backing_bitmap_->width(), width());
-  DCHECK_EQ(backing_bitmap_->height(), height());
+  DCHECK_EQ(backing_bitmap_->width(), static_cast<unsigned int>(width()));
+  DCHECK_EQ(backing_bitmap_->height(), static_cast<unsigned int>(height()));
   DCHECK_EQ(backing_bitmap_->format(), format());
   DCHECK(HasLevel(level));
   glBindTexture(GL_TEXTURE_2D, gl_texture_);
   UpdateGLImageFromBitmap(GL_TEXTURE_2D, level, TextureCUBE::FACE_POSITIVE_X,
                           *backing_bitmap_.Get(), resize_to_pot_);
 }
 
 Texture2DGL::~Texture2DGL() {
   DLOG(INFO) << "Texture2DGL Destruct";
   if (gl_texture_) {
@@ skipping 15 matching lines @@
         << " on Texture \"" << name();
     return false;
   }
   if (IsLocked(level)) {
     O3D_ERROR(service_locator())
         << "Level " << level << " of texture \"" << name()
         << "\" is already locked.";
     return false;
   }
   if (!backing_bitmap_->image_data()) {
-    DCHECK_EQ(has_levels_, 0);
+    DCHECK_EQ(has_levels_, 0u);
     backing_bitmap_->Allocate(format(), width(), height(), levels(), false);
   }
   *data = backing_bitmap_->GetMipData(level, TextureCUBE::FACE_POSITIVE_X);
   if (!HasLevel(level)) {
     // TODO: add some API so we don't have to copy back the data if we
     // will rewrite it all.
     DCHECK(!resize_to_pot_);
     GLenum gl_internal_format = 0;
     GLenum gl_data_type = 0;
     GLenum gl_format = GLFormatFromO3DFormat(format(),
@@ skipping 190 matching lines @@
       }
     }
   }
   CHECK_GL_ERROR();
   DLOG(INFO) << "Created cube map texture (GLuint=" << gl_texture << ")";
   return texture;
 }
 
 void TextureCUBEGL::UpdateBackedMipLevel(unsigned int level,
                                          TextureCUBE::CubeFace face) {
-  DCHECK_LT(level, levels());
+  DCHECK_LT(static_cast<int>(level), levels());
   DCHECK(backing_bitmap_->image_data());
   DCHECK(backing_bitmap_->is_cubemap());
-  DCHECK_EQ(backing_bitmap_->width(), edge_length());
-  DCHECK_EQ(backing_bitmap_->height(), edge_length());
+  DCHECK_EQ(backing_bitmap_->width(), static_cast<unsigned int>(edge_length()));
+  DCHECK_EQ(backing_bitmap_->height(),
+            static_cast<unsigned int>(edge_length()));
   DCHECK_EQ(backing_bitmap_->format(), format());
   DCHECK(HasLevel(level, face));
   glBindTexture(GL_TEXTURE_2D, gl_texture_);
   UpdateGLImageFromBitmap(kCubemapFaceList[face], level, face,
                           *backing_bitmap_.Get(),
                           resize_to_pot_);
 }
 
 RenderSurface::Ref TextureCUBEGL::GetRenderSurface(TextureCUBE::CubeFace face,
                                                    int mip_level,
@@ skipping 42 matching lines @@
   }
   if (IsLocked(level, face)) {
     O3D_ERROR(service_locator())
         << "Level " << level << " Face " << face
         << " of texture \"" << name()
         << "\" is already locked.";
     return false;
   }
   if (!backing_bitmap_->image_data()) {
     for (unsigned int i = 0; i < 6; ++i) {
-      DCHECK_EQ(has_levels_[i], 0);
+      DCHECK_EQ(has_levels_[i], 0u);
     }
     backing_bitmap_->Allocate(format(), edge_length(), edge_length(),
                              levels(), true);
   }
   *data = backing_bitmap_->GetMipData(level, face);
   GLenum gl_target = kCubemapFaceList[face];
   if (!HasLevel(level, face)) {
     // TODO: add some API so we don't have to copy back the data if we
     // will rewrite it all.
     DCHECK(!resize_to_pot_);
@@ skipping 47 matching lines @@
   }
   CHECK_GL_ERROR();
   return false;
 }
 
 const Texture::RGBASwizzleIndices& TextureCUBEGL::GetABGR32FSwizzleIndices() {
   return g_gl_abgr32f_swizzle_indices;
 }
 
 }  // namespace o3d