This is the O3D source tree's initial commit to the Chromium tree. It

is not built or referenced at all by the chrome build yet, and doesn't 
yet build in it's new home.  We'll change that shortly.

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

53 files changed, 11444 insertions, 0 deletions

diff --git a/o3d/import/build.scons b/o3d/import/build.scons
new file mode 100644
index 0000000..554750b
--- /dev/null
+++ b/o3d/import/build.scons
@@ -0,0 +1,144 @@
+# 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.
+
+
+Import('env')
+env.SConscript('fcollada.scons', exports=['env'])
+
+env.Append(
+  CPPPATH=[
+    env.Dir('$CG_DIR/include'),
+    env.Dir('$COLLADA_DIR'),
+    env.Dir('$COLLADA_DIR/LibXML/include'),
+    env.Dir('$ZLIB_DIR'),
+    # Include path for generated headers.
+    env.Dir('$OBJ_ROOT/compiler/technique'),
+    # Include path for Antlr C runtime headers.
+    env.Dir('$ANTLRLIBC_DIR/include'),
+  ],
+)
+
+# Add renderer-specific includes to the environment.
+env.Append(CPPPATH = env['RENDERER_INCLUDE_PATH'])
+
+if env.Bit('windows'):
+  env.Append(
+      CCFLAGS = [
+          '/Ylo3dImport',
+          '/FIimport/cross/precompile.h',
+      ],
+  )
+  pch, pch_obj = env.PCH('cross/precompile.cc')
+  env['PCH'] = pch
+  env['PCHSTOP'] = 'import/cross/precompile.h'
+else:
+  pch_obj = 'cross/precompile.cc'
+  env.Append(CCFLAGS = [['-include', 'import/cross/precompile.h']])
+
+collada_inputs = [
+  'cross/collada.cc',
+  'cross/collada_zip_archive.cc',
+  'cross/zip_archive.cc',
+  'cross/gz_compressor.cc',
+  'cross/file_output_stream_processor.cc',
+  'cross/tar_generator.cc',
+  'cross/targz_generator.cc',
+]
+
+archive_inputs = [
+  pch_obj,
+
+  'cross/archive_processor.cc',
+  'cross/archive_request.cc',
+  'cross/gz_decompressor.cc',
+  'cross/memory_stream.cc',
+  'cross/raw_data.cc',
+  'cross/tar_processor.cc',
+  'cross/targz_processor.cc',
+]
+
+conditioner_inputs = ['cross/collada_conditioner.cc']
+
+if env.Bit('mac'):
+  conditioner_inputs += [
+    'mac/collada_conditioner_mac.mm',
+  ]
+  FRAMEWORKS = [
+   'Foundation'
+  ]
+
+if env.Bit('windows'):
+  conditioner_inputs += [
+    'win/collada_conditioner_win.cc',
+  ]
+
+if env.Bit('linux'):
+  conditioner_inputs += [
+    'linux/collada_conditioner_linux.cc',
+  ]
+
+# Build a library called 'o3dImport' from the input sources.
+env.ComponentLibrary('o3dImport', collada_inputs)
+
+env.ComponentLibrary('o3dArchive', archive_inputs)
+
+# Build a library that ONLY includes the stubbed-out conditioner code
+# TODO: merge this back into o3dImport as soon as the import
+# lib is no longer needed by the plugin.
+env.ComponentLibrary('o3dImportNoConditioner',
+                     ['cross/collada_conditioner_stub.cc'])
+
+# Build a library that ONLY includes the active conditioner code
+# TODO: merge this back into o3dImport as soon as the import
+# lib is no longer needed by the plugin.
+conditioner_lib = env.ComponentLibrary('o3dImportConditioner',
+                                       conditioner_inputs)
+
+# The conditioner needs these regardless of what renderer we're
+# building for.
+if env.Bit('windows'):
+  env.Requires(conditioner_lib,
+               env.Replicate('$ARTIFACTS_DIR',
+                             ['$CG_DIR/bin/cgc.exe',
+                              '$CG_DIR/bin/cg.dll',
+                              '$CG_DIR/bin/cgGL.dll',
+                              '$GLEW_DIR/bin/glew32.dll',
+                              ]))
+
+if env.Bit('linux'):
+  env.Requires(conditioner_lib,
+               env.Replicate('$ARTIFACTS_DIR', ['$CG_DIR/bin/cgc',
+                                                '$CG_DIR/lib/libCg.so',
+                                                '$CG_DIR/lib/libCgGL.so',
+                                                '$GLEW_DIR/lib/libGLEW.so.1.5',
+                                                ]))
+
+if env.Bit('mac'):
+  env.Requires(conditioner_lib,
+               env.Replicate('$ARTIFACTS_DIR', ['$CG_DIR/bin/cgc']))
diff --git a/o3d/import/cross/archive_processor.cc b/o3d/import/cross/archive_processor.cc
new file mode 100644
index 0000000..f02ef6d
--- /dev/null
+++ b/o3d/import/cross/archive_processor.cc
@@ -0,0 +1,137 @@
+/*
+ * 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 "import/cross/precompile.h"
+
+#include <sys/stat.h>
+
+#include "import/cross/archive_processor.h"
+
+#include "base/logging.h"
+#include "import/cross/memory_buffer.h"
+#include "third_party/zlib/files/zlib.h"
+
+const int kChunkSize = 16384;
+
+namespace o3d {
+
+#ifdef _DEBUG
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// For debugging only, report a zlib or i/o error
+void zerr(int ret) {
+  LOG(ERROR) << "ArchiveProcessor: ";
+
+  switch (ret) {
+    case Z_ERRNO:
+      if (ferror(stdin))
+        LOG(ERROR) << "error reading stdin\n";
+      if (ferror(stdout))
+        LOG(ERROR) << "error writing stdout\n";
+      break;
+    case Z_STREAM_ERROR:
+      LOG(ERROR) << "invalid compression level\n";
+      break;
+    case Z_DATA_ERROR:
+      LOG(ERROR) << "invalid or incomplete deflate data\n";
+      break;
+    case Z_MEM_ERROR:
+      LOG(ERROR) << "out of memory\n";
+      break;
+    case Z_VERSION_ERROR:
+      LOG(ERROR) << "zlib version mismatch!\n";
+      break;
+  }
+}
+#endif  // _DEBUG
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int ArchiveProcessor::ProcessEntireStream(MemoryReadStream *stream) {
+  int result = Z_OK;
+  bool has_error = false;
+
+  // decompress until deflate stream ends or error
+  do {
+    int remaining = stream->GetRemainingByteCount();
+
+    int process_this_time = remaining < kChunkSize ? remaining : kChunkSize;
+    result = ProcessCompressedBytes(stream, process_this_time);
+
+    has_error = (result != Z_OK && result != Z_STREAM_END);
+
+#ifdef _DEBUG
+    if (has_error) {
+      zerr(result);
+    }
+#endif
+  } while (result != Z_STREAM_END && !has_error);
+
+  if (result == Z_STREAM_END) {
+    // if we got to the end of stream, then we're good...
+    result = Z_OK;
+  }
+
+  return result;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int ArchiveProcessor::ProcessFile(const char *filename) {
+  struct stat file_info;
+  int result = stat(filename, &file_info);
+  if (result != 0) return -1;
+
+  int file_length = file_info.st_size;
+  if (file_length == 0) return -1;
+
+  MemoryBuffer<uint8> buffer;
+  buffer.Allocate(file_length);
+  uint8 *p = buffer;
+
+  // Test by reading in a tar.gz file and sending through the
+  // progressive streaming system
+  FILE *fp = fopen(filename, "rb");
+  if (!fp) return -1;  // can't open file!
+  fread(p, sizeof(uint8), file_length, fp);
+  fclose(fp);
+
+  MemoryReadStream stream(p, file_length);
+
+  result = ProcessEntireStream(&stream);
+
+  if (result == Z_STREAM_END) {
+    // if we got to the end of stream, then we're good...
+    result = Z_OK;
+  }
+
+  return result;
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/archive_processor.h b/o3d/import/cross/archive_processor.h
new file mode 100644
index 0000000..9bc5368
--- /dev/null
+++ b/o3d/import/cross/archive_processor.h
@@ -0,0 +1,107 @@
+/*
+ * 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.
+ */
+
+
+#ifndef O3D_IMPORT_CROSS_ARCHIVE_PROCESSOR_H_
+#define O3D_IMPORT_CROSS_ARCHIVE_PROCESSOR_H_
+
+#include <string>
+#include "base/basictypes.h"
+#include "import/cross/memory_stream.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class ArchiveFileInfo {
+ public:
+  ArchiveFileInfo(const std::string &filename, int file_size)
+      : filename_(filename), file_size_(file_size) {}
+
+  virtual ~ArchiveFileInfo() {}
+
+  const std::string &GetFileName() const { return filename_; }
+  int               GetFileSize() const { return file_size_; }
+
+ private:
+  std::string      filename_;
+  int              file_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(ArchiveFileInfo);
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class ArchiveCallbackClient {
+ public:
+  virtual ~ArchiveCallbackClient() {}
+  virtual void ReceiveFileHeader(const ArchiveFileInfo &file_info) = 0;
+  virtual bool ReceiveFileData(MemoryReadStream *stream, int nbytes) = 0;
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class ArchiveProcessor {
+ public:
+  explicit ArchiveProcessor(ArchiveCallbackClient *callback_client) {}
+
+  virtual ~ArchiveProcessor() {}
+
+  // Call to "push" bytes into the processor.  They will be decompressed and
+  // the appropriate callbacks on |callback_client| will happen
+  // as files come in...
+  //
+  // Return values (using zlib error codes):
+  // Z_OK         : Processing was successful - but not yet done
+  // Z_STREAM_END : We're done - archive is completely/successfully processed
+  // any other value indicates an error condition
+  //
+  // Note: even archive formats not based on zlib should use these codes
+  // (Z_OK, Z_STREAM_END)
+  //
+  virtual int     ProcessCompressedBytes(MemoryReadStream *stream,
+                                         size_t bytes_to_process) = 0;
+
+  // Decompresses the complete file archive, making file callbacks as the files
+  // come in...
+  virtual int     ProcessFile(const char *filename);
+
+  // Decompresses the complete archive from memory,
+  // making file callbacks as the files come in...
+  virtual int     ProcessEntireStream(MemoryReadStream *stream);
+
+ protected:
+  DISALLOW_COPY_AND_ASSIGN(ArchiveProcessor);
+};
+
+#ifdef _DEBUG
+// For debugging, report a zlib or i/o error
+extern void zerr(int result);
+#endif
+}  // namespace o3d
+#endif  //  O3D_IMPORT_CROSS_ARCHIVE_PROCESSOR_H_
diff --git a/o3d/import/cross/archive_request.cc b/o3d/import/cross/archive_request.cc
new file mode 100644
index 0000000..86d8a57
--- /dev/null
+++ b/o3d/import/cross/archive_request.cc
@@ -0,0 +1,231 @@
+/*
+ * 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.
+ */
+
+
+// This file contains the definition of the ArchiveRequest class.
+
+#include "import/cross/precompile.h"
+
+#include "import/cross/archive_request.h"
+
+#include "import/cross/targz_processor.h"
+#include "core/cross/pack.h"
+
+#define DEBUG_ARCHIVE_CALLBACKS  0
+
+using glue::DownloadStream;
+
+namespace o3d {
+
+O3D_DEFN_CLASS(ArchiveRequest, ObjectBase);
+
+// NOTE: The file starts with "aaaaaaaa" in the hope that most tar.gz creation
+// utilties can easily sort with this being the file first in the .tgz
+// Otherwise you'll have to manually force it to be the first file.
+const char* ArchiveRequest::O3D_MARKER = "aaaaaaaa.o3d";
+const char* ArchiveRequest::O3D_MARKER_CONTENT = "o3d";
+const size_t ArchiveRequest::O3D_MARKER_CONTENT_LENGTH = 3;
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ArchiveRequest::ArchiveRequest(ServiceLocator* service_locator,
+                               Pack *pack)
+    : ObjectBase(service_locator),
+      pack_(pack),
+      done_(false),
+      success_(false),
+      ready_state_(0),
+      stream_length_(0),
+      bytes_received_(0) {
+  archive_processor_ = new TarGzProcessor(this);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ArchiveRequest::~ArchiveRequest() {
+  delete archive_processor_;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ArchiveRequest *ArchiveRequest::Create(ServiceLocator* service_locator,
+                                       Pack *pack) {
+  ArchiveRequest *request = new ArchiveRequest(service_locator, pack);
+  return request;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void ArchiveRequest::NewStreamCallback(DownloadStream *stream) {
+  // we're starting to stream - make note of the stream length
+  stream_length_ = stream->GetStreamLength();
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int32 ArchiveRequest::WriteReadyCallback(DownloadStream *stream) {
+  // Setting this too high causes Firefox to timeout in the Write callback.
+  return 1024;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int32 ArchiveRequest::WriteCallback(DownloadStream *stream,
+                                    int32 offset,
+                                    int32 length,
+                                    void *data) {
+  // Count the bytes as they stream in
+  bytes_received_ += length;
+
+  MemoryReadStream memory_stream(reinterpret_cast<uint8*>(data), length);
+
+  // Progressively decompress the bytes we've just been given
+  int result =
+      archive_processor_->ProcessCompressedBytes(&memory_stream, length);
+
+  if (result != Z_OK && result != Z_STREAM_END) {
+    stream->Cancel();  // tell the browser to stop downloading
+    set_success(false);
+    set_error("Invalid tar gz file");
+    if (onreadystatechange())
+      onreadystatechange()->Run();  // javascript callback with failure
+  }
+
+  return length;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Loads the Archive file, calls the JS callback to notify success.
+void ArchiveRequest::FinishedCallback(DownloadStream *stream,
+                                      bool success,
+                                      const std::string &filename,
+                                      const std::string &mime_type)  {
+  set_ready_state(ArchiveRequest::STATE_LOADED);
+
+  // Since the standard codes only go far enough to tell us that the download
+  // succeeded, we set the success [and implicitly the done] flags to give the
+  // rest of the story.
+  set_success(success);
+  if (!success) {
+    // I have no idea if an error is already set here but one MUST be set
+    // so let's check
+    set_error("Could not download archive. It could be a permission-related "
+              "issue.");
+  }
+  if (onreadystatechange())
+    onreadystatechange()->Run();
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// ArchiveCallbackClient methods
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void ArchiveRequest::ReceiveFileHeader(const ArchiveFileInfo &file_info) {
+  int file_size = file_info.GetFileSize();
+
+#if DEBUG_ARCHIVE_CALLBACKS
+  printf("\n");
+  printf("-----------------------------------------------------------------\n");
+  printf("File Name: %s\n", file_info.GetFileName().c_str());
+  printf("File Size: %d\n", file_size);
+  printf("-----------------------------------------------------------------\n");
+#endif
+
+  if (file_size > 0) {  // skip over directory entries (with zero file size)
+    // Save filename for when we create our RawData object
+    current_filename_ = file_info.GetFileName();
+
+    temp_buffer_.Allocate(file_size);
+    file_memory_stream_.Assign(static_cast<uint8*>(temp_buffer_),
+                               file_size);
+  }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+bool ArchiveRequest::ReceiveFileData(MemoryReadStream *input_stream,
+                                     int nbytes) {
+  assert(input_stream->GetRemainingByteCount() >= nbytes);
+  assert(file_memory_stream_.GetRemainingByteCount() >= nbytes);
+
+  // Buffer file bytes from |input_stream| to |file_memory_stream_|
+  file_memory_stream_.Write(input_stream->GetDirectMemoryPointer(), nbytes);
+  input_stream->Skip(nbytes);
+
+  // If we've just filled our file temp buffer then callback
+  if (file_memory_stream_.GetRemainingByteCount() == 0) {
+    // We've reached the end of file
+
+    // Check if this is file metadata (extra file attributes) and skip if so
+    // On the Mac, the tar command marks metadata by
+    // pre-pending "._" to the filename
+    bool is_metadata = false;
+    std::string::size_type j = current_filename_.find("._");
+    if (j != std::string::npos) {
+      if (j == 0 || current_filename_[j - 1] == '/') is_metadata = true;
+    }
+
+    // Skip ".DS_Store" file which may be created in Mac-generated archives
+    j = current_filename_.find(".DS_Store");
+    if (j != std::string::npos) {
+      if (j == 0 || current_filename_[j - 1] == '/') is_metadata = true;
+    }
+
+    if (!is_metadata && onfileavailable()) {
+      // keep track of the "current" data object which the callback will use
+      raw_data_ = RawData::Create(service_locator(),
+                                  current_filename_,
+                                  temp_buffer_,
+                                  file_memory_stream_.GetTotalStreamLength() );
+
+      // keeps them all around until the ArchiveRequest goes away
+      raw_data_list_.push_back(raw_data_);
+
+      // If it's the first file is must be the O3D_MARKER or else it's an error.
+      if (raw_data_list_.size() == 1) {
+        if (raw_data_->uri().compare(O3D_MARKER) != 0 ||
+            raw_data_->StringValue().compare(O3D_MARKER_CONTENT) != 0) {
+          set_error(String("Archive '")  + uri_ +
+                    String("' is not intended for O3D. Missing '") +
+                    O3D_MARKER + String("' as first file in archive."));
+          return false;
+        }
+      } else {
+        onfileavailable()->Run();
+      }
+
+      // If data hasn't been discarded (inside callback) then writes out to
+      // temp file so we can get the data back at a later time
+      raw_data_.Get()->Flush();
+
+      // Remove the reference to the raw_data so we don't have undefined
+      // behavior after the callback.
+      raw_data_.Reset();
+    }
+  }
+  return true;
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/archive_request.h b/o3d/import/cross/archive_request.h
new file mode 100644
index 0000000..2a29bde
--- /dev/null
+++ b/o3d/import/cross/archive_request.h
@@ -0,0 +1,203 @@
+/*
+ * 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.
+ */
+
+
+// This file contains the declaration of the ArchiveRequest class.
+
+#ifndef O3D_IMPORT_CROSS_ARCHIVE_REQUEST_H_
+#define O3D_IMPORT_CROSS_ARCHIVE_REQUEST_H_
+
+#include <algorithm>
+#include <string>
+
+#include "base/scoped_ptr.h"
+#include "core/cross/callback.h"
+#include "core/cross/object_base.h"
+#include "core/cross/pack.h"
+#include "import/cross/targz_processor.h"
+#include "import/cross/memory_buffer.h"
+#include "import/cross/memory_stream.h"
+#include "import/cross/raw_data.h"
+#include "plugin/cross/download_stream.h"
+
+namespace o3d {
+
+typedef Closure ArchiveRequestCallback;
+
+// An ArchiveRequest object is used to carry out an asynchronous request
+// for a file to be loaded.
+class ArchiveRequest : public ObjectBase, public ArchiveCallbackClient {
+ public:
+  enum ReadyState {  // These are copied from XMLHttpRequest.
+    STATE_INIT = 0,
+    STATE_OPEN = 1,
+    STATE_SENT = 2,
+    STATE_RECEIVING = 3,
+    STATE_LOADED = 4,
+  };
+
+  // A file by this name must be the first file in the archive otherwise
+  // the archive is rejected. This is a security measure so that O3D
+  // can not be used to open arbitrary .tgz files but only those files someone
+  // has specifically prepared for O3D. This file will not be passed to
+  // the onfileavailable callback.
+  static const char* O3D_MARKER;
+
+  // The contents of the O3D_MARKER file. Arguably the content should not matter
+  // but for the sake of completeness we define the content so there is no
+  // ambiguity.
+  static const char* O3D_MARKER_CONTENT;
+
+  // The size of the O3D_MARKER_CONTENT.
+  static const size_t O3D_MARKER_CONTENT_LENGTH;
+
+ public:
+  typedef SmartPointer<ArchiveRequest> Ref;
+
+  virtual ~ArchiveRequest();
+
+  static ArchiveRequest *Create(ServiceLocator* service_locator,
+                                Pack *pack);
+
+
+  // Streaming callbacks
+  virtual void NewStreamCallback(glue::DownloadStream *stream);
+  virtual int32 WriteReadyCallback(glue::DownloadStream *stream);
+  virtual int32 WriteCallback(glue::DownloadStream *stream,
+                              int32 offset,
+                              int32 length,
+                              void *data);
+
+  virtual void FinishedCallback(glue::DownloadStream *stream,
+                                bool success,
+                                const std::string &filename,
+                                const std::string &mime_type);
+
+  // ArchiveCallbackClient methods
+  virtual void ReceiveFileHeader(const ArchiveFileInfo &file_info);
+  virtual bool ReceiveFileData(MemoryReadStream *stream, int nbytes);
+
+  Pack *pack() {
+    return pack_.Get();  // Set at creation time and never changed.
+  }
+
+  ArchiveRequestCallback *onfileavailable() {
+    return onfileavailable_.get();
+  }
+  void set_onfileavailable(ArchiveRequestCallback *onfileavailable) {
+    onfileavailable_.reset(onfileavailable);
+  }
+
+  ArchiveRequestCallback *onreadystatechange() {
+    return onreadystatechange_.get();
+  }
+  void set_onreadystatechange(ArchiveRequestCallback *onreadystatechange) {
+    onreadystatechange_.reset(onreadystatechange);
+  }
+
+  // returns the "current" data object (used by the callback)
+  RawData *data() {
+    return raw_data_.Get();
+  }
+
+  const String& uri() {
+    return uri_;
+  }
+  void set_uri(const String& uri) {
+    uri_ = uri;
+  }
+
+  bool done() {
+    return done_;
+  }
+
+  bool success() {
+    return success_;
+  }
+  void set_success(bool success) {
+    success_ = success;
+    done_ = true;
+    pack_.Reset(); // Remove pack reference to allow garbage collection of pack.
+  }
+
+  const String& error() const {
+    return error_;
+  }
+  void set_error(const String& error) {
+    error_ = error;
+  }
+
+  int ready_state() {
+    return ready_state_;
+  }
+  void set_ready_state(int state) {
+    ready_state_ = state;
+  }
+
+  int stream_length() {
+    return stream_length_;
+  }
+
+  int bytes_received() {
+    return bytes_received_;
+  }
+
+ protected:
+  ArchiveRequest(ServiceLocator* service_locator, Pack *pack);
+
+  Pack::Ref pack_;
+  scoped_ptr<ArchiveRequestCallback> onreadystatechange_;
+  scoped_ptr<ArchiveRequestCallback> onfileavailable_;
+  String uri_;
+
+  // Request state
+  bool done_;  // Set after completion/failure to indicate success_ is valid.
+  bool success_;  // Set after completion/failure to indicate which it is.
+  int ready_state_;  // Like the XMLHttpRequest variable of the same name.
+  String error_;  // Set after completion on failure.
+
+  TarGzProcessor      *archive_processor_;
+  std::vector<RawData::Ref> raw_data_list_;
+  RawData::Ref        raw_data_;
+  MemoryBuffer<uint8> temp_buffer_;
+  MemoryWriteStream   file_memory_stream_;
+  String              current_filename_;
+
+  int                 stream_length_;   // total length of stream
+  int                 bytes_received_;  // bytes received so far
+
+  O3D_DECL_CLASS(ArchiveRequest, ObjectBase)
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ArchiveRequest);
+};  // ArchiveRequest
+
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_ARCHIVE_REQUEST_H_
diff --git a/o3d/import/cross/collada.cc b/o3d/import/cross/collada.cc
new file mode 100644
index 0000000..a9cc2e1
--- /dev/null
+++ b/o3d/import/cross/collada.cc
@@ -0,0 +1,2713 @@
+/*
+ * 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.
+ */
+
+
+// This file contains functions for importing COLLADA files into O3D.
+#include "import/cross/precompile.h"
+
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/string_util.h"
+#include "core/cross/curve.h"
+#include "core/cross/error.h"
+#include "core/cross/function.h"
+#include "core/cross/ierror_status.h"
+#include "core/cross/math_utilities.h"
+#include "core/cross/matrix4_axis_rotation.h"
+#include "core/cross/matrix4_composition.h"
+#include "core/cross/matrix4_scale.h"
+#include "core/cross/matrix4_translation.h"
+#include "core/cross/pack.h"
+#include "core/cross/param_operation.h"
+#include "core/cross/primitive.h"
+#include "core/cross/skin.h"
+#include "core/cross/stream.h"
+#include "import/cross/collada.h"
+#include "import/cross/collada_conditioner.h"
+#include "import/cross/collada_zip_archive.h"
+#include "utils/cross/file_path_utils.h"
+
+#define COLLADA_NAMESPACE "collada"
+#define COLLADA_NAMESPACE_SEPARATOR "."
+
+// Macro to provide a uniform prefix for all string constants created by
+// COLLADA.
+#define COLLADA_STRING_CONSTANT(value)                  \
+  (COLLADA_NAMESPACE COLLADA_NAMESPACE_SEPARATOR value)
+
+
+namespace o3d {
+
+class TranslationMap : public FCDGeometryIndexTranslationMap {
+};
+
+namespace {
+
+Vector3 FMVector3ToVector3(const FMVector3& fmvector3) {
+  return Vector3(fmvector3.x, fmvector3.y, fmvector3.z);
+}
+
+Vector4 FMVector4ToVector4(const FMVector4& fmvector4) {
+  return Vector4(fmvector4.x, fmvector4.y, fmvector4.z, fmvector4.w);
+}
+
+Float2 FMVector2ToFloat2(const FMVector2& fmvector2) {
+  return Float2(fmvector2.x, fmvector2.y);
+}
+
+Matrix4 FMMatrix44ToMatrix4(const FMMatrix44& fmmatrix44) {
+  return Matrix4(Vector4(fmmatrix44[0][0],
+                         fmmatrix44[0][1],
+                         fmmatrix44[0][2],
+                         fmmatrix44[0][3]),
+                 Vector4(fmmatrix44[1][0],
+                         fmmatrix44[1][1],
+                         fmmatrix44[1][2],
+                         fmmatrix44[1][3]),
+                 Vector4(fmmatrix44[2][0],
+                         fmmatrix44[2][1],
+                         fmmatrix44[2][2],
+                         fmmatrix44[2][3]),
+                 Vector4(fmmatrix44[3][0],
+                         fmmatrix44[3][1],
+                         fmmatrix44[3][2],
+                         fmmatrix44[3][3]));
+}
+}  // anonymous namespace
+
+// Import the given COLLADA file or ZIP file into the given scene.
+// This is the external interface to o3d.
+bool Collada::Import(Pack* pack,
+                     const FilePath& filename,
+                     Transform* parent,
+                     ParamFloat* animation_input,
+                     const Options& options) {
+  Collada collada(pack, options);
+  return collada.ImportFile(filename, parent, animation_input);
+}
+
+bool Collada::Import(Pack* pack,
+                     const String& filename,
+                     Transform* parent,
+                     ParamFloat* animation_input,
+                     const Options& options) {
+  return Collada::Import(pack,
+                         UTF8ToFilePath(filename),
+                         parent,
+                         animation_input,
+                         options);
+}
+
+// Parameters:
+//   pack:      The pack into which the scene objects will be placed.
+// Returns true on success.
+Collada::Collada(Pack* pack, const Options& options)
+    : service_locator_(pack->service_locator()),
+      pack_(pack),
+      options_(options),
+      dummy_effect_(NULL),
+      dummy_material_(NULL),
+      instance_root_(NULL),
+      cull_enabled_(false),
+      cull_front_(false),
+      front_cw_(false),
+      collada_zip_archive_(NULL),
+      unique_filename_counter_(0) {
+}
+
+Collada::~Collada() {
+  delete collada_zip_archive_;
+}
+
+void Collada::ClearData() {
+  textures_.clear();
+  original_data_.clear();
+  effects_.clear();
+  shapes_.clear();
+  skinned_shapes_.clear();
+  materials_.clear();
+  delete collada_zip_archive_;
+  collada_zip_archive_ = NULL;
+  cull_enabled_ = false;
+  cull_front_ = false;
+  front_cw_ = false;
+  delete instance_root_;
+  instance_root_ = NULL;
+  base_path_ = FilePath(FilePath::kCurrentDirectory);
+  unique_filename_counter_ = 0;
+}
+
+std::vector<FilePath> Collada::GetOriginalDataFilenames() const {
+  std::vector<FilePath> result;
+  for (OriginalDataMap::const_iterator iter = original_data_.begin();
+       iter != original_data_.end();
+       ++iter) {
+    result.push_back(iter->first);
+  }
+  return result;
+}
+
+const std::string& Collada::GetOriginalData(const FilePath& filename) const {
+  static const std::string empty;
+  OriginalDataMap::const_iterator entry = original_data_.find(filename);
+  if (entry != original_data_.end()) {
+    return entry->second;
+  } else {
+    return empty;
+  }
+}
+
+// Import the given COLLADA file or ZIP file under the given parent node.
+// Parameters:
+//   filename:        The COLLADA or ZIPped COLLADA file to import.
+//   parent:          The parent node under which the imported nodes will be
+//                    placed. If NULL, nodes will be placed under the
+//                    client's root.
+//   animation_input: The float parameter used as the input to the animation
+//                    (if present). This is usually time. This can be null
+//                    if there is no animation.
+// Returns true on success.
+bool Collada::ImportFile(const FilePath& filename, Transform* parent,
+                         ParamFloat* animation_input) {
+  // Each time we start a new import, we need to clear out data from
+  // the last import (if any).
+  ClearData();
+
+  // Convert the base_path given in the options to an absolute path.
+  base_path_ = options_.base_path;
+  file_util::AbsolutePath(&base_path_);
+
+  bool status = false;
+  if (ZipArchive::IsZipFile(FilePathToUTF8(filename))) {
+    status = ImportZIP(filename, parent, animation_input);
+  } else {
+    status = ImportDAE(filename, parent, animation_input);
+  }
+
+  if (!status) {
+    // TODO: this could probably be the original URI instead of some
+    //     filename in the temp folder.
+    O3D_ERROR(service_locator_) << "Unable to import: "
+                                << FilePathToUTF8(filename).c_str();
+  }
+
+  return status;
+}
+
+// Imports the given ZIP file into the given client.
+// Parameters:  see Import() above.
+// Returns true on success.
+bool Collada::ImportZIP(const FilePath& filename, Transform* parent,
+                        ParamFloat* animation_input) {
+  // This uses minizip, which avoids decompressing the zip archive to a
+  // temp directory...
+  //
+  bool status = false;
+  int result = 0;
+
+  String filename_str = FilePathToUTF8(filename);
+  collada_zip_archive_ = new ColladaZipArchive(filename_str, &result);
+
+  if (result == UNZ_OK) {
+    FCollada::Initialize();
+    FCDocument* doc = FCollada::NewTopDocument();
+
+    if (doc) {
+      std::string model_path = collada_zip_archive_->GetColladaPath().c_str();
+
+      size_t doc_buffer_size = 0;
+      char *doc_buffer = collada_zip_archive_->GetFileData(model_path,
+                                                           &doc_buffer_size);
+
+      if (doc_buffer && doc_buffer_size > 0) {
+        DLOG(INFO) << "Loading Collada model \""
+                   << model_path << "\" from zip file \""
+                   << filename_str << "\"";
+
+        std::wstring model_path_w = UTF8ToWide(model_path);
+
+        bool fc_status = FCollada::LoadDocumentFromMemory(model_path_w.c_str(),
+                                                          doc,
+                                                          doc_buffer,
+                                                          doc_buffer_size);
+
+
+        if (fc_status) {
+          if (options_.condition_document) {
+            ColladaConditioner conditioner(service_locator_);
+            if (conditioner.ConditionDocument(doc, collada_zip_archive_)) {
+              status = ImportDAEDocument(doc,
+                                         fc_status,
+                                         parent,
+                                         animation_input);
+            }
+          } else {
+            status = ImportDAEDocument(doc, fc_status, parent, animation_input);
+          }
+        }
+      }
+      doc->Release();
+    }
+    FCollada::Release();
+  }
+
+  if (!status) {
+    delete collada_zip_archive_;
+    collada_zip_archive_ = NULL;
+  }
+
+  return status;
+}
+
+// Imports the given COLLADA file (.DAE) into the given pack.
+// Parameters:
+//   see Import() above.
+// Returns:
+//  true on success.
+bool Collada::ImportDAE(const FilePath& filename,
+                        Transform* parent,
+                        ParamFloat* animation_input) {
+  if (!parent) {
+    return false;
+  }
+  bool status = false;
+  FCollada::Initialize();
+  FCDocument* doc = FCollada::NewTopDocument();
+  if (doc) {
+    std::wstring filename_w = FilePathToWide(filename);
+    bool fc_status = FCollada::LoadDocumentFromFile(doc, filename_w.c_str());
+    if (options_.condition_document) {
+      ColladaConditioner conditioner(service_locator_);
+      if (conditioner.ConditionDocument(doc, NULL)) {
+        status = ImportDAEDocument(doc, fc_status, parent, animation_input);
+      }
+    } else {
+      status = ImportDAEDocument(doc, fc_status, parent, animation_input);
+    }
+    doc->Release();
+  }
+  FCollada::Release();
+  return status;
+}
+
+// Imports the given FCDocument document (already loaded) into the given pack.
+// Returns:
+//  true on success.
+bool Collada::ImportDAEDocument(FCDocument* doc,
+                                bool fc_status,
+                                Transform* parent,
+                                ParamFloat* animation_input) {
+  if (!parent) {
+    return false;
+  }
+  bool status = false;
+  if (doc) {
+    if (fc_status) {
+      Vector3 up_axis = options_.up_axis;
+      FMVector3 up(up_axis.getX(), up_axis.getY(), up_axis.getZ());
+      // Transform the document to the given up vector
+
+      FCDocumentTools::StandardizeUpAxisAndLength(doc, up);
+
+      // Import all the textures in the file. Even if they are not used by
+      // materials or models the user put them in the file and might need them
+      // at runtime.
+      //
+      // TODO: Add option to skip this step if user just wants what's
+      // actually used by models. The rest of the code already deals with this.
+      FCDImageLibrary* image_library = doc->GetImageLibrary();
+      for (int i = 0; i < image_library->GetEntityCount(); i++) {
+        FCDEntity* entity = image_library->GetEntity(i);
+        LOG_ASSERT(entity);
+        LOG_ASSERT(entity->GetType() == FCDEntity::IMAGE);
+        FCDImage* image = down_cast<FCDImage*>(entity);
+        BuildTextureFromImage(image);
+      }
+
+      // Import all the materials in the file. Even if they are not used by
+      // models the user put them in the file and might need them at runtime.
+      //
+      // TODO: Add option to skip this step if user just wants what's
+      // actually used by models. The rest of the code already deals with this.
+      FCDMaterialLibrary* material_library = doc->GetMaterialLibrary();
+      for (int i = 0; i < material_library->GetEntityCount(); i++) {
+        FCDEntity* entity = material_library->GetEntity(i);
+        LOG_ASSERT(entity);
+        LOG_ASSERT(entity->GetType() == FCDEntity::MATERIAL);
+        FCDMaterial* collada_material = down_cast<FCDMaterial*>(entity);
+        BuildMaterial(doc, collada_material);
+      }
+
+      // Import the scene objects, starting at the root.
+      FCDSceneNode* scene = doc->GetVisualSceneInstance();
+      if (scene) {
+        instance_root_ = CreateInstanceTree(scene);
+        ImportTree(instance_root_, parent, animation_input);
+        ImportTreeInstances(doc, instance_root_);
+        delete instance_root_;
+        instance_root_ = NULL;
+        status = true;
+      }
+    }
+  }
+  return status;
+}
+
+namespace {
+
+Curve::Infinity ConvertInfinity(FUDaeInfinity::Infinity infinity) {
+  switch (infinity) {
+    case FUDaeInfinity::LINEAR :
+      return Curve::LINEAR;
+    case FUDaeInfinity::CYCLE :
+      return Curve::CYCLE;
+    case FUDaeInfinity::CYCLE_RELATIVE :
+      return Curve::CYCLE_RELATIVE;
+    case FUDaeInfinity::OSCILLATE :
+      return Curve::OSCILLATE;
+    default:
+      return Curve::CONSTANT;
+  }
+}
+
+StepCurveKey* BuildStepKey(Curve* curve, FCDAnimationKey* fcd_key,
+                           float output_scale) {
+  StepCurveKey* key = curve->Create<StepCurveKey>();
+  key->SetInput(fcd_key->input);
+  key->SetOutput(fcd_key->output * output_scale);
+  return key;
+}
+
+LinearCurveKey* BuildLinearKey(Curve* curve, FCDAnimationKey* fcd_key,
+                               float output_scale) {
+  LinearCurveKey* key = curve->Create<LinearCurveKey>();
+  key->SetInput(fcd_key->input);
+  key->SetOutput(fcd_key->output * output_scale);
+  return key;
+}
+
+BezierCurveKey* BuildBezierKey(Curve* curve, FCDAnimationKeyBezier* fcd_key,
+                               float output_scale) {
+  BezierCurveKey* key = curve->Create<BezierCurveKey>();
+  key->SetInput(fcd_key->input);
+  key->SetOutput(fcd_key->output * output_scale);
+  Float2 in_tangent = FMVector2ToFloat2(fcd_key->inTangent);
+  in_tangent[1] *= output_scale;
+  key->SetInTangent(in_tangent);
+  Float2 out_tangent = FMVector2ToFloat2(fcd_key->outTangent);
+  out_tangent[1] *= output_scale;
+  key->SetOutTangent(out_tangent);
+  return key;
+}
+
+void BindParams(ParamObject* input_object, const char* input_param_name,
+                ParamObject* output_object, const char* output_param_name) {
+  Param* input_param = input_object->GetUntypedParam(input_param_name);
+  DCHECK(input_param);
+
+  Param* output_param = output_object->GetUntypedParam(output_param_name);
+  DCHECK(output_param);
+
+  bool ok = input_param->Bind(output_param);
+  DCHECK_EQ(ok, true);
+}
+
+void BindParams(ParamObject* input_object, const char* input_param_name,
+                Param* output_param) {
+  Param* input_param = input_object->GetUntypedParam(input_param_name);
+  DCHECK(input_param);
+
+  bool ok = input_param->Bind(output_param);
+  DCHECK_EQ(ok, true);
+}
+
+void BindParams(Param* input_param,
+                ParamObject* output_object, const char* output_param_name) {
+  Param* output_param = output_object->GetUntypedParam(output_param_name);
+  DCHECK(output_param);
+
+  bool ok = input_param->Bind(output_param);
+  DCHECK_EQ(ok, true);
+}
+}  // namespace anonymous
+
+bool Collada::BuildFloatAnimation(ParamFloat* result,
+                                  FCDAnimated* animated,
+                                  const char* qualifier,
+                                  ParamFloat* animation_input,
+                                  float output_scale,
+                                  float default_value) {
+  if (animated != NULL) {
+    FCDAnimationCurve* fcd_curve = animated->FindCurve(qualifier);
+    if (fcd_curve != NULL) {
+      FunctionEval* function_eval = pack_->Create<FunctionEval>();
+      BindParams(function_eval, FunctionEval::kInputParamName, animation_input);
+
+      Curve* curve = pack_->Create<Curve>();
+      function_eval->set_function_object(curve);
+
+      curve->set_pre_infinity(ConvertInfinity(fcd_curve->GetPreInfinity()));
+      curve->set_post_infinity(ConvertInfinity(fcd_curve->GetPostInfinity()));
+
+      for (int i = 0; i != fcd_curve->GetKeyCount(); ++i) {
+        FCDAnimationKey* fcd_key = fcd_curve->GetKey(i);
+        switch (fcd_key->interpolation) {
+          case FUDaeInterpolation::STEP:
+            BuildStepKey(curve, fcd_key, output_scale);
+            break;
+          case FUDaeInterpolation::BEZIER:
+            BuildBezierKey(curve, static_cast<FCDAnimationKeyBezier*>(fcd_key),
+                           output_scale);
+            break;
+          default:
+            BuildLinearKey(curve, fcd_key, output_scale);
+            break;
+        }
+      }
+
+      BindParams(result, function_eval, FunctionEval::kOutputParamName);
+      return true;
+    }
+  }
+
+  result->set_value(default_value * output_scale);
+  return false;
+}
+
+bool Collada::BuildFloat3Animation(ParamFloat3* result, FCDAnimated* animated,
+                                   ParamFloat* animation_input,
+                                   const Float3& default_value) {
+  ParamOp3FloatsToFloat3* to_float3 =
+      pack_->Create<ParamOp3FloatsToFloat3>();
+
+  static const char* const kQualifiers[3] = { ".X", ".Y", ".Z" };
+  static const char* const kInputs[3] = {
+    ParamOp3FloatsToFloat3::kInput0ParamName,
+    ParamOp3FloatsToFloat3::kInput1ParamName,
+    ParamOp3FloatsToFloat3::kInput2ParamName,
+  };
+  bool any_animated = false;
+  for (int i = 0; i != 3; ++i) {
+    ParamFloat* to_float3_input = to_float3->GetParam<ParamFloat>(kInputs[i]);
+    any_animated |= BuildFloatAnimation(to_float3_input,
+                                        animated, kQualifiers[i],
+                                        animation_input, 1.0f,
+                                        default_value[i]);
+  }
+
+  if (any_animated) {
+    BindParams(result, to_float3, ParamOp3FloatsToFloat3::kOutputParamName);
+    return true;
+  } else {
+    pack_->RemoveObject(to_float3);
+    result->set_value(default_value);
+    return false;
+  }
+}
+
+ParamMatrix4* Collada::BuildComposition(FCDTMatrix* transform,
+                                        ParamMatrix4* input_matrix,
+                                        ParamFloat* animation_input) {
+  Matrix4Composition* composition = pack_->Create<Matrix4Composition>();
+  Matrix4 matrix = FMMatrix44ToMatrix4(transform->ToMatrix());
+
+  ParamOp16FloatsToMatrix4* to_matrix4 =
+      pack_->Create<ParamOp16FloatsToMatrix4>();
+  bool any_animated = false;
+  for (int i = 0; i != 16; ++i) {
+    int row = i / 4;
+    int column = i % 4;
+
+    std::stringstream input_name;
+    input_name << "input" << i;
+    ParamFloat* to_matrix4_input = to_matrix4->GetParam<ParamFloat>(
+        input_name.str().c_str());
+
+    std::stringstream qualifier;
+    qualifier <<  "(" << row << ")" << "(" << column << ")";
+    any_animated |= BuildFloatAnimation(to_matrix4_input,
+                                        transform->GetAnimated(),
+                                        qualifier.str().c_str(),
+                                        animation_input, 1.0f,
+                                        matrix[row][column]);
+  }
+
+  if (any_animated) {
+    BindParams(composition, Matrix4Composition::kLocalMatrixParamName,
+               to_matrix4, ParamOp16FloatsToMatrix4::kOutputParamName);
+  } else {
+    pack_->RemoveObject(to_matrix4);
+    composition->set_local_matrix(matrix);
+  }
+
+  BindParams(composition, Matrix4Composition::kInputMatrixParamName,
+             input_matrix);
+  return composition->GetParam<ParamMatrix4>(
+      Matrix4Composition::kOutputMatrixParamName);
+}
+
+ParamMatrix4* Collada::BuildComposition(const Matrix4& matrix,
+                                        ParamMatrix4* input_matrix) {
+  Matrix4Composition* composition = pack_->Create<Matrix4Composition>();
+  composition->set_local_matrix(matrix);
+  BindParams(composition, Matrix4Composition::kInputMatrixParamName,
+             input_matrix);
+  return composition->GetParam<ParamMatrix4>(
+      Matrix4Composition::kOutputMatrixParamName);
+}
+
+ParamMatrix4* Collada::BuildTranslation(FCDTTranslation* transform,
+                                        ParamMatrix4* input_matrix,
+                                        ParamFloat* animation_input) {
+  Matrix4Translation* translation = pack_->Create<Matrix4Translation>();
+
+  ParamFloat3* animated_param = translation->GetParam<ParamFloat3>(
+      Matrix4Translation::kTranslationParamName);
+  Vector3 default_value = FMVector3ToVector3(transform->GetTranslation());
+  BuildFloat3Animation(animated_param, transform->GetAnimated(),
+                       animation_input, Float3(default_value));
+
+  BindParams(translation, Matrix4Composition::kInputMatrixParamName,
+             input_matrix);
+  return translation->GetParam<ParamMatrix4>(
+      Matrix4Composition::kOutputMatrixParamName);
+}
+
+ParamMatrix4* Collada::BuildRotation(FCDTRotation* transform,
+                                     ParamMatrix4* input_matrix,
+                                     ParamFloat* animation_input) {
+  Matrix4AxisRotation* rotation = pack_->Create<Matrix4AxisRotation>();
+
+  ParamFloat3* animated_axis = rotation->GetParam<ParamFloat3>(
+      Matrix4AxisRotation::kAxisParamName);
+  Vector3 default_axis = FMVector3ToVector3(transform->GetAxis());
+  BuildFloat3Animation(animated_axis, transform->GetAnimated(),
+                       animation_input, Float3(default_axis));
+
+  ParamFloat* animated_angle = rotation->GetParam<ParamFloat>(
+      Matrix4AxisRotation::kAngleParamName);
+  float default_angle = transform->GetAngle();
+  BuildFloatAnimation(animated_angle,
+                      transform->GetAnimated(),
+                      ".ANGLE",
+                      animation_input,
+                      o3d::kPi / 180.0f,
+                      default_angle);
+
+  BindParams(rotation, Matrix4Composition::kInputMatrixParamName, input_matrix);
+  return rotation->GetParam<ParamMatrix4>(
+      Matrix4Composition::kOutputMatrixParamName);
+}
+
+ParamMatrix4* Collada::BuildScaling(FCDTScale* transform,
+                                    ParamMatrix4* input_matrix,
+                                    ParamFloat* animation_input) {
+  Matrix4Scale* scaling = pack_->Create<Matrix4Scale>();
+
+  ParamFloat3* animated_param = scaling->GetParam<ParamFloat3>(
+      Matrix4Scale::kScaleParamName);
+  Vector3 default_value = FMVector3ToVector3(transform->GetScale());
+  BuildFloat3Animation(animated_param, transform->GetAnimated(),
+                       animation_input, Float3(default_value));
+
+  BindParams(scaling, Matrix4Composition::kInputMatrixParamName, input_matrix);
+  return scaling->GetParam<ParamMatrix4>(
+      Matrix4Composition::kOutputMatrixParamName);
+}
+
+// Builds a Transform node corresponding to the transform elements of
+// a given node.  All transformations (rotation, translation, scale,
+// etc) are collapsed into a single Transform.
+// Parameters:
+//   node:      The FCollada node whose transforms are replicated.
+// Return value:
+//   The new Transform.
+Transform* Collada::BuildTransform(FCDSceneNode* node,
+                                   Transform* parent_transform,
+                                   ParamFloat* animation_input) {
+  const wchar_t* name = node->GetName().c_str();
+
+  String name_utf8 =  WideToUTF8(name);
+
+  Transform* transform = pack_->Create<Transform>();
+  transform->set_name(name_utf8);
+  transform->SetParent(parent_transform);
+
+  bool any_animated = false;
+  for (size_t i = 0; i < node->GetTransformCount(); i++) {
+    FCDTransform* fcd_transform = node->GetTransform(i);
+    any_animated |= fcd_transform->IsAnimated();
+  }
+
+  if (any_animated) {
+    // At least one of the collada transforms is animated so construct the
+    // transform hierarchy and connect its output to the local_matrix for
+    // this node.
+    ParamMatrix4* input_matrix = NULL;
+    for (size_t i = 0; i < node->GetTransformCount(); i++) {
+      FCDTransform* fcd_transform = node->GetTransform(i);
+      switch (fcd_transform->GetType()) {
+        case FCDTransform::MATRIX :
+          input_matrix = BuildComposition(
+              static_cast<FCDTMatrix*>(fcd_transform),
+              input_matrix, animation_input);
+          break;
+        case FCDTransform::TRANSLATION:
+          input_matrix = BuildTranslation(
+              static_cast<FCDTTranslation*>(fcd_transform),
+              input_matrix, animation_input);
+          break;
+        case FCDTransform::ROTATION:
+          input_matrix = BuildRotation(
+              static_cast<FCDTRotation*>(fcd_transform),
+              input_matrix, animation_input);
+          break;
+        case FCDTransform::SCALE:
+          input_matrix = BuildScaling(
+              static_cast<FCDTScale*>(fcd_transform),
+              input_matrix, animation_input);
+          break;
+        default:
+          input_matrix = BuildComposition(
+              FMMatrix44ToMatrix4(fcd_transform->ToMatrix()),
+              input_matrix);
+          break;
+      }
+    }
+
+    ParamMatrix4* local_matrix_param = transform->GetParam<ParamMatrix4>(
+        Transform::kLocalMatrixParamName);
+    local_matrix_param->Bind(input_matrix);
+  } else {
+    // None of collada transforms are animated so just compute the
+    // overall transform and set it as the value of the local_matrix
+    // for this node. This saves memory and improves performance but
+    // more importantly it will allow JavaScript code to set the value of
+    // the local_matrix directly without first having to unbind it.
+    Matrix4 local_matrix(Matrix4::identity());
+    for (size_t i = 0; i < node->GetTransformCount(); i++) {
+      FCDTransform* fcd_transform = node->GetTransform(i);
+      local_matrix *= FMMatrix44ToMatrix4(fcd_transform->ToMatrix());
+    }
+    transform->set_local_matrix(local_matrix);
+  }
+
+  return transform;
+}
+
+NodeInstance *Collada::CreateInstanceTree(FCDSceneNode *node) {
+  NodeInstance *instance = new NodeInstance(node);
+  NodeInstance::NodeInstanceList &children = instance->children();
+  for (size_t i = 0; i < node->GetChildrenCount(); ++i) {
+    FCDSceneNode *child_node = node->GetChild(i);
+    NodeInstance *child_instance = CreateInstanceTree(child_node);
+    children.push_back(child_instance);
+  }
+  return instance;
+}
+
+NodeInstance *NodeInstance::FindNodeInTree(FCDSceneNode *node) {
+  if (node == node_)
+    return this;
+  for (unsigned int i = 0; i < children_.size(); ++i) {
+    NodeInstance *instance = children_[i]->FindNodeInTree(node);
+    if (instance)
+      return instance;
+  }
+  return NULL;
+}
+
+NodeInstance *Collada::FindNodeInstance(FCDSceneNode *node) {
+  // First try the fast path, in the case where the node is not instanced more
+  // than once.
+  NodeInstance *instance = FindNodeInstanceFast(node);
+  if (!instance) {
+    // If it fails, look in the whole instance tree.
+    instance = instance_root_->FindNodeInTree(node);
+  }
+  return instance;
+}
+
+NodeInstance *Collada::FindNodeInstanceFast(FCDSceneNode *node) {
+  if (node == instance_root_->node())
+    return instance_root_;
+  // If the node is instanced more than once, fail.
+  if (node->GetParentCount() != 1)
+    return NULL;
+  NodeInstance *parent_instance = FindNodeInstanceFast(node->GetParent(0));
+  // Look for self in parent's childrens.
+  return parent_instance->FindNodeShallow(node);
+}
+
+// Recursively imports a tree of nodes from FCollada, rooted at the
+// given node, into the O3D scene.
+// Parameters:
+//   instance:         The root NodeInstance from which to import.
+//   parent_transform: The parent Transform under which the tree will be placed.
+//   animation_input:  The float parameter used as the input to the animation
+//                     (if present). This is usually time. This can be null
+//                     if there is no animation.
+void Collada::ImportTree(NodeInstance *instance,
+                         Transform* parent_transform,
+                         ParamFloat* animation_input) {
+  FCDSceneNode *node = instance->node();
+  Transform* transform = BuildTransform(node, parent_transform,
+                                        animation_input);
+  instance->set_transform(transform);
+
+  // recursively import the rest of the nodes in the tree
+  const NodeInstance::NodeInstanceList &children = instance->children();
+  for (size_t i = 0; i < children.size(); ++i) {
+    ImportTree(children[i], transform, animation_input);
+  }
+}
+
+void Collada::ImportTreeInstances(FCDocument* doc,
+                                  NodeInstance *node_instance) {
+  FCDSceneNode *node = node_instance->node();
+  // recursively import the rest of the nodes in the tree
+  const NodeInstance::NodeInstanceList &children = node_instance->children();
+  for (size_t i = 0; i < children.size(); ++i) {
+    ImportTreeInstances(doc, children[i]);
+  }
+
+  Transform* transform = node_instance->transform();
+  for (size_t i = 0; i < node->GetInstanceCount(); ++i) {
+    FCDEntityInstance* instance = node->GetInstance(i);
+    FCDCamera* camera(NULL);
+    FCDGeometryInstance* geom_instance(NULL);
+
+    LOG_ASSERT(instance != 0);
+    // Import each node based on what kind of entity it is
+    // TODO: add more entity types as they are supported
+    switch (instance->GetEntityType()) {
+      case FCDEntity::CAMERA:
+        // camera entity
+        camera = down_cast<FCDCamera*>(instance->GetEntity());
+        BuildCamera(doc, camera, transform, node);
+        break;
+      case FCDEntity::GEOMETRY: {
+        // geometry entity
+        geom_instance = static_cast<FCDGeometryInstance*>(instance);
+        Shape* shape = GetShape(doc, geom_instance);
+        if (shape) {
+          transform->AddShape(shape);
+        }
+        break;
+      }
+      case FCDEntity::CONTROLLER: {
+        FCDControllerInstance* controller_instance =
+            static_cast<FCDControllerInstance*> (instance);
+        Shape* shape = GetSkinnedShape(doc, controller_instance, node_instance);
+        if (shape) {
+          transform->AddShape(shape);
+        }
+        break;
+      }
+      default:
+        // do nothing
+        break;
+    }
+  }
+}
+
+// Converts an FCollada vertex attribute semantic into an O3D
+// vertex attribute semantic.  Returns the O3D semantic, or
+// UNKNOWN_SEMANTIC on failure.
+static Stream::Semantic C2G3DSemantic(FUDaeGeometryInput::Semantic semantic) {
+  switch (semantic) {
+    case FUDaeGeometryInput::POSITION: return Stream::POSITION;
+    case FUDaeGeometryInput::VERTEX:  return Stream::POSITION;
+    case FUDaeGeometryInput::NORMAL:  return Stream::NORMAL;
+    case FUDaeGeometryInput::TEXTANGENT:  return Stream::TANGENT;
+    case FUDaeGeometryInput::TEXBINORMAL:  return Stream::BINORMAL;
+    case FUDaeGeometryInput::TEXCOORD:  return Stream::TEXCOORD;
+    case FUDaeGeometryInput::COLOR:  return Stream::COLOR;
+    default:  return Stream::UNKNOWN_SEMANTIC;
+  }
+}
+
+// Imports information from a Collada camera node and places it in Params of
+// the transform corresponding to the node it's parented under.
+// Parameters:
+//   doc:                The FCollada document from which to import nodes.
+//   camera:             The FCDCamera node in question
+//   transform:          The O3D Transform on which the camera parameters
+//                       will be created.  It cannot be NULL.
+//   parent_node:        The FCDSceneNode that the parent transform was created
+//                       from.  This node is used to extract possible LookAt
+//                       elements.  It cannot be NULL.
+void Collada::BuildCamera(FCDocument* doc,
+                          FCDCamera* camera,
+                          Transform* transform,
+                          FCDSceneNode* parent_node) {
+  LOG_ASSERT(doc && camera && transform && parent_node);
+
+  // Create a transform node for the camera
+  String camera_name = WideToUTF8(camera->GetName().c_str());
+
+  // Tag this node as a camera
+  ParamString* param_tag = transform->CreateParam<ParamString>(
+      COLLADA_STRING_CONSTANT("tags"));
+
+  // Add more tags when required
+  param_tag->set_value("camera");
+
+  // Create the rest of the params
+
+  // Projection type: either 'orthographic' or 'perspective'
+  ParamString* param_proj_type =
+      transform->CreateParam<ParamString>(
+          COLLADA_STRING_CONSTANT("projectionType"));
+
+  // Aspect ratio
+  float camera_aspect_ratio;
+  ParamFloat* param_proj_aspect_ratio =
+      transform->CreateParam<ParamFloat>(
+          COLLADA_STRING_CONSTANT("projectionAspectRatio"));
+
+  // Near/far z-planes
+  float camera_near_z, camera_far_z;
+  ParamFloat* param_proj_nearz =
+      transform->CreateParam<ParamFloat>(
+          COLLADA_STRING_CONSTANT("projectionNearZ"));
+  ParamFloat* param_proj_farz =
+      transform->CreateParam<ParamFloat>(
+          COLLADA_STRING_CONSTANT("projectionFarZ"));
+
+  // Calculate shared params
+  camera_near_z = camera->GetNearZ();
+  camera_far_z = camera->GetFarZ();
+  param_proj_nearz->set_value(camera_near_z);
+  param_proj_farz->set_value(camera_far_z);
+
+  if (camera->GetProjectionType() == FCDCamera::ORTHOGRAPHIC) {
+    // Orthographic projection
+    param_proj_type->set_value("orthographic");
+
+    // Additional params
+    // Horizontal and vertical magnifications
+    ParamFloat* param_proj_mag_x =
+        transform->CreateParam<ParamFloat>(
+            COLLADA_STRING_CONSTANT("projectionMagX"));
+    ParamFloat* param_proj_mag_y =
+        transform->CreateParam<ParamFloat>(
+            COLLADA_STRING_CONSTANT("projectionMagY"));
+
+    // Find aspect ratio and magnifications
+    float camera_mag_x, camera_mag_y;
+    if (camera->HasHorizontalMag() && camera->HasVerticalMag())
+      camera_aspect_ratio = camera->GetMagY() / camera->GetMagX();
+    else
+      camera_aspect_ratio = camera->GetAspectRatio();
+
+    if (camera->HasHorizontalMag())
+      camera_mag_x = camera->GetMagX();
+    else
+      camera_mag_x = camera->GetMagY() * camera_aspect_ratio;
+
+    if (camera->HasVerticalMag())
+      camera_mag_y = camera->GetMagY();
+    else
+      camera_mag_y = camera->GetMagX() / camera_aspect_ratio;
+
+    // Set the values of the additional params
+    param_proj_mag_x->set_value(camera_mag_x);
+    param_proj_mag_y->set_value(camera_mag_y);
+    param_proj_aspect_ratio->set_value(camera_aspect_ratio);
+  } else if (camera->GetProjectionType() == FCDCamera::PERSPECTIVE) {
+    // Perspective projection
+    param_proj_type->set_value("perspective");
+
+    // Additional params
+    // Vertical field of view
+    ParamFloat* param_proj_fov_y =
+        transform->CreateParam<ParamFloat>(
+            COLLADA_STRING_CONSTANT("perspectiveFovY"));
+
+    // Find aspect ratio and vertical FOV
+    float camera_fov_y;
+    if (camera->HasHorizontalFov() && camera->HasVerticalFov())
+      camera_aspect_ratio = camera->GetFovY() / camera->GetFovX();
+    else
+      camera_aspect_ratio = camera->GetAspectRatio();
+
+    if (camera->HasVerticalFov())
+      camera_fov_y = camera->GetFovY();
+    else
+      camera_fov_y = camera->GetFovX() / camera_aspect_ratio;
+
+    // Set the values of the additional params
+    param_proj_fov_y->set_value(camera_fov_y);
+    param_proj_aspect_ratio->set_value(camera_aspect_ratio);
+  }
+
+  // Search the FCDSceneNode for a LookAt element, extract the eye, target,
+  // and up values and store them as Params on the Transform.  If multiple
+  // LookAt elements are defined under the parent node, we only pick the first
+  // one.
+  for (size_t i = 0; i < parent_node->GetTransformCount(); i++) {
+    FCDTransform* transform_object = parent_node->GetTransform(i);
+    if (transform_object->GetType() == FCDTransform::LOOKAT) {
+      FCDTLookAt* look_at = static_cast<FCDTLookAt*>(transform_object);
+      FMVector3 position = look_at->GetPosition();
+      FMVector3 target = look_at->GetTarget();
+      FMVector3 up = look_at->GetUp();
+
+      // Get the world matrix of the transform above the camera transform.
+      // We use this value to transform the eye, target and up to the world
+      // coordinate system so that they can be used directly to make a camera
+      // view matrix.
+      Matrix4 parent_world = Matrix4::identity();
+      if (transform->parent())
+        parent_world = transform->parent()->GetUpdatedWorldMatrix();
+
+      ParamFloat3* param_eye_position =
+          transform->CreateParam<ParamFloat3>(
+              COLLADA_STRING_CONSTANT("eyePosition"));
+      Vector4 world_eye = parent_world * Point3(position.x,
+                                                position.y,
+                                                position.z);
+      param_eye_position->set_value(Float3(world_eye.getX(),
+                                           world_eye.getY(),
+                                           world_eye.getZ()));
+
+      ParamFloat3* param_target_position =
+          transform->CreateParam<ParamFloat3>(
+              COLLADA_STRING_CONSTANT("targetPosition"));
+      Vector4 world_target = parent_world * Point3(target.x,
+                                                   target.y,
+                                                   target.z);
+      param_target_position->set_value(Float3(world_target.getX(),
+                                              world_target.getY(),
+                                              world_target.getZ()));
+
+      ParamFloat3* param_up_vector =
+          transform->CreateParam<ParamFloat3>(
+              COLLADA_STRING_CONSTANT("upVector"));
+      Vector4 world_up = parent_world * Vector4(up.x, up.y, up.z, 0.0f);
+      param_up_vector->set_value(Float3(world_up.getX(),
+                                        world_up.getY(),
+                                        world_up.getZ()));
+
+      break;
+    }
+  }
+
+}
+
+Shape* Collada::GetShape(FCDocument* doc,
+                         FCDGeometryInstance* geom_instance) {
+  Shape* shape = NULL;
+  FCDGeometry* geom = static_cast<FCDGeometry*>(geom_instance->GetEntity());
+  if (geom) {
+    fm::string geom_id = geom->GetDaeId();
+    shape = shapes_[geom_id.c_str()];
+    if (!shape) {
+      shape = BuildShape(doc, geom_instance, geom, NULL);
+      if (!shape)
+        return NULL;
+      shapes_[geom_id.c_str()] = shape;
+    }
+  }
+  return shape;
+}
+
+Shape* Collada::GetSkinnedShape(FCDocument* doc,
+                                FCDControllerInstance* instance,
+                                NodeInstance *parent_node_instance) {
+  Shape* shape = NULL;
+  FCDController* controller =
+      static_cast<FCDController*>(instance->GetEntity());
+  if (controller && controller->IsSkin()) {
+    fm::string id = controller->GetDaeId();
+    shape = skinned_shapes_[id.c_str()];
+    if (!shape) {
+      shape = BuildSkinnedShape(doc, instance, parent_node_instance);
+      if (!shape)
+        return NULL;
+      skinned_shapes_[id.c_str()] = shape;
+    }
+  }
+  return shape;
+}
+
+// Builds an O3D shape node corresponding to a given FCollada geometry
+// instance.
+// Parameters:
+//   doc:                The FCollada document from which to import nodes.
+//   geom_instance:      The FCollada geometry node to be converted.
+Shape* Collada::BuildShape(FCDocument* doc,
+                           FCDGeometryInstance* geom_instance,
+                           FCDGeometry* geom,
+                           TranslationMap* translationMap) {
+  Shape* shape = NULL;
+  LOG_ASSERT(doc && geom_instance && geom);
+  if (geom && geom->IsMesh()) {
+    String geom_name = WideToUTF8(geom->GetName().c_str());
+    shape = pack_->Create<Shape>();
+    shape->set_name(geom_name);
+    FCDGeometryMesh* mesh = geom->GetMesh();
+    LOG_ASSERT(mesh);
+    FCDGeometryPolygonsTools::Triangulate(mesh);
+    FCDGeometryPolygonsTools::GenerateUniqueIndices(mesh, NULL, translationMap);
+    size_t num_polygons = mesh->GetPolygonsCount();
+    size_t num_indices = mesh->GetFaceVertexCount();
+    if (num_polygons <= 0 || num_indices <= 0) return NULL;
+    FCDGeometrySource* pos_source =
+        mesh->FindSourceByType(FUDaeGeometryInput::POSITION);
+    if (pos_source == NULL) return NULL;
+    size_t num_vertices = pos_source->GetValueCount();
+    size_t num_sources = mesh->GetSourceCount();
+
+    // Create vertex streams corresponding to the COLLADA sources.
+    // These streams are common to all polygon sets in this mesh.
+    // The BuildSkinnedShape code assumes this so if you change it you'll need
+    // to fix BuildSkinnedShape.
+    StreamBank* stream_bank = pack_->Create<StreamBank>();
+    stream_bank->set_name(geom_name);
+
+    int semantic_counts[Stream::TEXCOORD + 1] = { 0, };
+
+    scoped_array<Field*> fields(new Field*[num_sources]);
+
+    VertexBuffer* vertex_buffer = pack_->Create<VertexBuffer>();
+    vertex_buffer->set_name(geom_name);
+
+    // first create all the fields.
+    for (size_t s = 0; s < num_sources; ++s) {
+      FCDGeometrySource* source = mesh->GetSource(s);
+      LOG_ASSERT(source);
+      Stream::Semantic semantic = C2G3DSemantic(source->GetType());
+      LOG_ASSERT(semantic <= Stream::TEXCOORD);
+      if (semantic == Stream::UNKNOWN_SEMANTIC) continue;
+
+      // The call to GenerateUniqueIndices() above should have made
+      // all sources the same length.
+      LOG_ASSERT(source->GetValueCount() == num_vertices);
+
+      int stride = source->GetStride();
+      if (semantic == Stream::COLOR && stride == 4) {
+        fields[s] = vertex_buffer->CreateField(UByteNField::GetApparentClass(),
+                                               stride);
+      } else {
+        fields[s] = vertex_buffer->CreateField(FloatField::GetApparentClass(),
+                                               stride);
+      }
+    }
+
+    if (!vertex_buffer->AllocateElements(num_vertices)) {
+      O3D_ERROR(service_locator_) << "Failed to allocate vertex buffer";
+      return NULL;
+    }
+
+    for (size_t s = 0; s < num_sources; ++s) {
+      FCDGeometrySource* source = mesh->GetSource(s);
+      LOG_ASSERT(source);
+      Stream::Semantic semantic = C2G3DSemantic(source->GetType());
+      LOG_ASSERT(semantic <= Stream::TEXCOORD);
+      if (semantic == Stream::UNKNOWN_SEMANTIC) continue;
+      int stride = source->GetStride();
+
+      const float* source_data = source->GetData();
+      if (semantic == Stream::TANGENT || semantic == Stream::BINORMAL) {
+        // FCollada uses the convention that the tangent points
+        // along -u and the binormal along -v in model space.
+        // Convert to the more common convention where the tangent
+        // points along +u and the binormal along +v. This is what, for
+        // example, tools that convert height maps to normal maps tend to
+        // assume. It is also what the O3D shaders assume.
+        size_t num_values = source->GetDataCount();
+        scoped_array<float>values(new float[num_values]);
+        for (size_t i = 0; i < num_values ; ++i) {
+          values[i] = -source_data[i];
+        }
+        fields[s]->SetFromFloats(&values[0], stride, 0, num_vertices);
+      } else {
+        fields[s]->SetFromFloats(source_data, stride, 0, num_vertices);
+      }
+
+      stream_bank->SetVertexStream(semantic, semantic_counts[semantic],
+                                   fields[s], 0);
+      // NOTE: This doesn't really seem like the correct thing to do but I'm not
+      // sure we have enough info to do the correct thing. The issue is we
+      // need to connect these streams to the shader, the shader needs to know
+      // which streams go with which varying parameters but for the standard
+      // collada materials I don't think any such information is available.
+      ++semantic_counts[semantic];
+    }
+
+    for (size_t p = 0; p < num_polygons; ++p) {
+      FCDGeometryPolygons* polys = mesh->GetPolygons(p);
+      FCDGeometryPolygonsInput* input = polys->GetInput(0);
+
+      size_t size = input->GetIndexCount();
+      size_t vertices_per_primitive = 0;
+      Primitive::PrimitiveType primitive_type;
+      switch (polys->GetPrimitiveType()) {
+        case FCDGeometryPolygons::POLYGONS:
+          vertices_per_primitive = 3;
+          primitive_type = Primitive::TRIANGLELIST;
+          break;
+        case FCDGeometryPolygons::LINES:
+          vertices_per_primitive = 2;
+          primitive_type = Primitive::LINELIST;
+          break;
+        default:
+          // unsupported geometry type; skip it
+          continue;
+      }
+
+      // If there are no vertices, don't make this primitive.
+      if (size == 0) continue;
+
+      // If we don't have a multiple of the verts-per-primitive, bail now.
+      if (size % vertices_per_primitive != 0) {
+        O3D_ERROR(service_locator_) << "Geometry \"" << geom_name
+                                    << "\" contains " << size
+                                    << " vertices, which is not a multiple of "
+                                    << vertices_per_primitive << "; skipped";
+        continue;
+      }
+
+      // Get the material for this polygon set.
+      Material* material = NULL;
+      FCDMaterialInstance* mat_instance = geom_instance->FindMaterialInstance(
+          polys->GetMaterialSemantic());
+      if (mat_instance) {
+        FCDMaterial* collada_material = mat_instance->GetMaterial();
+        material = BuildMaterial(doc, collada_material);
+      }
+      if (!material) {
+        material = GetDummyMaterial();
+      }
+      // Create an index buffer for this group of polygons.
+
+      String primitive_name(geom_name + "|" + material->name());
+
+      IndexBuffer* indexBuffer = pack_->Create<IndexBuffer>();
+      indexBuffer->set_name(primitive_name);
+      if (!indexBuffer->AllocateElements(size)) {
+        O3D_ERROR(service_locator_) << "Failed to allocate index buffer.";
+        return NULL;
+      }
+      indexBuffer->index_field()->SetFromUInt32s(input->GetIndices(), 1, 0,
+                                                 size);
+
+      // Create a primitive for this group of polygons.
+      Primitive* primitive = pack_->Create<Primitive>();
+      primitive->set_name(primitive_name);
+
+      primitive->set_material(material);
+
+      primitive->SetOwner(shape);
+      primitive->set_primitive_type(primitive_type);
+      size_t num_prims = size / vertices_per_primitive;
+      primitive->set_number_primitives(static_cast<unsigned int>(num_prims));
+      primitive->set_number_vertices(static_cast<unsigned int>(num_vertices));
+
+      // Set the index buffer for this primitive.
+      primitive->set_index_buffer(indexBuffer);
+
+      // Set the vertex streams for this primitive to the common set for this
+      // mesh.
+      primitive->set_stream_bank(stream_bank);
+    }
+  }
+  return shape;
+}
+
+Shape* Collada::BuildSkinnedShape(FCDocument* doc,
+                                  FCDControllerInstance* instance,
+                                  NodeInstance *parent_node_instance) {
+  // TODO: Handle chained controllers. Morph->Skin->...
+  Shape* shape = NULL;
+  LOG_ASSERT(doc && instance);
+  FCDController* controller =
+      static_cast<FCDController*>(instance->GetEntity());
+  if (controller && controller->IsSkin()) {
+    FCDSkinController* skin_controller = controller->GetSkinController();
+    TranslationMap translationMap;
+    shape = BuildShape(doc,
+                       instance,
+                       controller->GetBaseGeometry(),
+                       &translationMap);
+    if (!shape) {
+      return NULL;
+    }
+
+    // Convert the translation table to new->old map.
+    size_t num_vertices = 0;
+    std::vector<unsigned> new_to_old_indices;
+    {
+      // walk the map once to figure out the number of vertices.
+      TranslationMap::iterator end = translationMap.end();
+      for (TranslationMap::iterator it = translationMap.begin();
+           it != end;
+           ++it) {
+        num_vertices += it->second.size();
+      }
+
+      // Init our array to UINT_MAX so we can check for collisions
+      new_to_old_indices.resize(num_vertices, UINT_MAX);
+
+      // walk the map again and fill out our remap table.
+      for (TranslationMap::iterator it = translationMap.begin();
+           it != end;
+           ++it) {
+        const UInt32List& intlist = it->second;
+        for (size_t gg = 0; gg < intlist.size(); ++gg) {
+          unsigned new_index = intlist[gg];
+          LOG_ASSERT(new_to_old_indices.at(new_index) == UINT_MAX);
+          new_to_old_indices[new_index] = it->first;
+        }
+      }
+    }
+
+    // There's a BIG assumption here. We assume the first primitive on the shape
+    // has vertex buffers that are shared on all the primitives under this shape
+    // such that we only need to copy the first primitive's vertex buffers to
+    // skin everything. This is actually what was BuildShape was doing at the
+    // time this code was written.
+    const ElementRefArray& elements = shape->GetElementRefs();
+    if (elements.empty() || !elements[0]->IsA(Primitive::GetApparentClass())) {
+      return NULL;
+    }
+    Primitive* primitive = down_cast<Primitive*>(elements[0].Get());
+
+    String controller_name = WideToUTF8(controller->GetName().c_str());
+
+    ParamArray* matrices = pack_->Create<ParamArray>();
+    Skin* skin = pack_->Create<Skin>();
+    skin->set_name(controller_name);
+    SkinEval* skin_eval = pack_->Create<SkinEval>();
+    skin_eval->set_name(controller_name);
+
+    skin_eval->set_skin(skin);
+    skin_eval->set_matrices(matrices);
+
+    // Bind bones to matrices
+    size_t num_bones = instance->GetJointCount();
+    if (num_bones > 0) {
+      matrices->CreateParam<ParamMatrix4>(num_bones - 1);
+      for (size_t ii = 0; ii < num_bones; ++ii) {
+        FCDSceneNode* node = instance->GetJoint(ii);
+        LOG_ASSERT(node);
+        // Note: in case of instancing, the intended instance is ill-defined,
+        // but that is a problem in the Collada document itself. So we'll assume
+        // the file is somewhat well defined.
+        // First we try the single instance case.
+        NodeInstance *node_instance = FindNodeInstanceFast(node);
+        if (!node_instance) {
+          // Second we try nodes underneath the same parent as the controller
+          // instance. Max and Maya seem to do that.
+          node_instance = parent_node_instance->FindNodeInTree(node);
+        }
+        if (!node_instance) {
+          // Third we try in the entire tree.
+          node_instance = instance_root_->FindNodeInTree(node);
+        }
+        if (!node_instance) {
+          String bone_name = WideToUTF8(node->GetName().c_str());
+          O3D_ERROR(service_locator_)
+              << "Could not find node instance for bone " << bone_name.c_str();
+          continue;
+        }
+        Transform* bone = node_instance->transform();
+        LOG_ASSERT(bone);
+        matrices->GetUntypedParam(ii)->Bind(
+            bone->GetUntypedParam(Transform::kWorldMatrixParamName));
+      }
+    }
+
+    Matrix4 bind_shape_matrix(
+        FMMatrix44ToMatrix4(skin_controller->GetBindShapeTransform()));
+    Matrix4 inverse_bind_shape_matrix(inverse(bind_shape_matrix));
+
+    // Get the bind pose inverse matrices
+    LOG_ASSERT(num_bones == skin_controller->GetJointCount());
+    for (size_t ii = 0; ii < num_bones; ++ii) {
+      FCDSkinControllerJoint* joint = skin_controller->GetJoint(ii);
+      skin->SetInverseBindPoseMatrix(
+          ii, FMMatrix44ToMatrix4(joint->GetBindPoseInverse()));
+    }
+
+    // Get Influences.
+    for (size_t ii = 0; ii < num_vertices; ++ii) {
+      unsigned old_index = new_to_old_indices[ii];
+      FCDSkinControllerVertex* vertex =
+          skin_controller->GetVertexInfluence(old_index);
+      Skin::Influences influences;
+      size_t num_influences = vertex->GetPairCount();
+      for (size_t jj = 0; jj < num_influences; ++jj) {
+        FCDJointWeightPair* weight_pair = vertex->GetPair(jj);
+        influences.push_back(Skin::Influence(weight_pair->jointIndex,
+                                             weight_pair->weight));
+      }
+      skin->SetVertexInfluences(ii, influences);
+    }
+
+    Matrix4 matrix(bind_shape_matrix);
+
+    // Copy shape->primitive buffers.
+    StreamBank* stream_bank = primitive->stream_bank();
+    SourceBuffer* buffer = pack_->Create<SourceBuffer>();
+    const StreamParamVector& source_stream_params =
+        stream_bank->vertex_stream_params();
+    std::vector<Field*> new_fields(source_stream_params.size(), NULL);
+    // first make all the fields.
+    for (unsigned ii = 0; ii < source_stream_params.size(); ++ii) {
+      const Stream& source_stream = source_stream_params[ii]->stream();
+      const Field& field = source_stream.field();
+      if (field.IsA(FloatField::GetApparentClass()) &&
+          (field.num_components() == 3 ||
+           field.num_components() == 4)) {
+        switch (source_stream.semantic()) {
+          case Stream::POSITION:
+          case Stream::NORMAL:
+          case Stream::BINORMAL:
+          case Stream::TANGENT: {
+            unsigned num_source_components = field.num_components();
+            unsigned num_source_vertices = source_stream.GetMaxVertices();
+            if (num_source_vertices != num_vertices) {
+              O3D_ERROR(service_locator_)
+                  << "Number of vertices in stream_bank '"
+                  << stream_bank->name().c_str()
+                  << "' does not equal the number of vertices in the Skin '"
+                  << skin->name().c_str() << "'";
+              return NULL;
+            }
+            new_fields[ii] = buffer->CreateField(FloatField::GetApparentClass(),
+                                                 num_source_components);
+          }
+        }
+      }
+    }
+
+    if (!buffer->AllocateElements(num_vertices)) {
+      O3D_ERROR(service_locator_)
+          << "Failed to allocate destination vertex buffer";
+      return NULL;
+    }
+
+    for (unsigned ii = 0; ii < source_stream_params.size(); ++ii) {
+      const Stream& source_stream = source_stream_params[ii]->stream();
+      const Field& field = source_stream.field();
+      if (field.IsA(FloatField::GetApparentClass()) &&
+          (field.num_components() == 3 ||
+           field.num_components() == 4)) {
+        switch (source_stream.semantic()) {
+          case Stream::POSITION:
+          case Stream::NORMAL:
+          case Stream::BINORMAL:
+          case Stream::TANGENT: {
+            unsigned num_source_components = field.num_components();
+            Field* new_field = new_fields[ii];
+
+            std::vector<float> data(num_vertices * num_source_components);
+            field.GetAsFloats(0, &data[0], num_source_components,
+                              num_vertices);
+            // TODO: Remove this matrix multiply. I don't think it is
+            //     needed.
+            for (unsigned vv = 0; vv < num_vertices; ++vv) {
+              float* values = &data[vv * num_source_components];
+              switch (field.num_components()) {
+                case 3: {
+                  if (source_stream.semantic() == Stream::POSITION) {
+                    Vector4 result(matrix * Point3(values[0],
+                                                   values[1],
+                                                   values[2]));
+                    values[0] = result.getElem(0);
+                    values[1] = result.getElem(1);
+                    values[2] = result.getElem(2);
+                  } else {
+                    Vector4 result(matrix * Vector3(values[0],
+                                                    values[1],
+                                                    values[2]));
+                    values[0] = result.getElem(0);
+                    values[1] = result.getElem(1);
+                    values[2] = result.getElem(2);
+                  }
+                  break;
+                }
+                case 4: {
+                  Vector4 result(matrix * Vector4(values[0],
+                                                  values[1],
+                                                  values[2],
+                                                  values[3]));
+                  values[0] = result.getElem(0);
+                  values[1] = result.getElem(1);
+                  values[2] = result.getElem(2);
+                  values[3] = result.getElem(3);
+                  break;
+                }
+              }
+            }
+            new_field->SetFromFloats(&data[0], num_source_components, 0,
+                                     num_vertices);
+            // Bind streams
+            skin_eval->SetVertexStream(source_stream.semantic(),
+                                       source_stream.semantic_index(),
+                                       new_field,
+                                       0);
+            stream_bank->BindStream(skin_eval,
+                                    source_stream.semantic(),
+                                    source_stream.semantic_index());
+            break;
+          }
+        }
+      }
+    }
+  }
+  return shape;
+}
+
+Texture* Collada::BuildTextureFromImage(FCDImage* image) {
+  const fstring filename = image->GetFilename();
+  Texture* tex = textures_[filename.c_str()];
+  if (!tex) {
+    FilePath file_path = WideToFilePath(filename.c_str());
+    FilePath uri = file_path;
+
+    std::string tempfile;
+    if (collada_zip_archive_) {
+      // If we're getting data from a zip archive, then we just strip
+      // the "/" from the beginning of the name, since that represents
+      // the root of the archive, and we can assume all the paths in
+      // the archive are relative to that.
+      if (uri.value()[0] == FILE_PATH_LITERAL('/')) {
+        uri = FilePath(uri.value().substr(1));
+      }
+      // NOTE: We have the opportunity to simply extract a memory
+      // buffer for the image data here, but currently the image loaders expect
+      // to read a file, so we write out a temp file...
+
+      // filename_utf8 points to the name of the file inside the archive
+      // (it doesn't actually live on the filesystem so we make a temp file)
+      if (collada_zip_archive_->GetTempFileFromFile(FilePathToUTF8(file_path),
+                                                    &tempfile)) {
+        file_path = UTF8ToFilePath(tempfile);
+      }
+    } else {
+      GetRelativePathIfPossible(base_path_, uri, &uri);
+    }
+
+    tex = Texture::Ref(
+        pack_->CreateTextureFromFile(FilePathToUTF8(uri),
+                                     file_path,
+                                     Bitmap::UNKNOWN,
+                                     options_.generate_mipmaps));
+    if (tex) {
+      const fstring name(image->GetName());
+      tex->set_name(WideToUTF8(name.c_str()));
+    }
+
+    if (options_.keep_original_data) {
+      // Cache the original data by URI so we can recover it later.
+      std::string contents;
+      file_util::ReadFileToString(file_path, &contents);
+      original_data_[uri] = contents;
+    }
+
+    if (tempfile.size() > 0) ZipArchive::DeleteFile(tempfile);
+    textures_[filename.c_str()] = tex;
+  }
+  return tex;
+}
+
+Texture* Collada::BuildTexture(FCDEffectParameterSurface* surface) {
+  // Create the texture.
+  Texture* tex = NULL;
+  if (surface->GetImageCount() > 0) {
+    FCDImage* image = surface->GetImage(0);
+    tex = BuildTextureFromImage(image);
+  }
+  return tex;
+}
+
+// Sets an O3D parameter value from a given FCollada effect parameter.
+// instance.
+// Parameters:
+//   param_object:       The param_object whose parameter is to be modified.
+//   param_name:         The name of the parameter to be set.
+//   fc_param:           The FCollada effect parameter whose value is used.
+// Returns true on success.
+bool Collada::SetParamFromFCEffectParam(ParamObject* param_object,
+                                        const String &param_name,
+                                        FCDEffectParameter *fc_param) {
+  if (!param_object || !fc_param) return false;
+  FCDEffectParameter::Type type = fc_param->GetType();
+  bool rc = false;
+  if (type == FCDEffectParameter::FLOAT) {
+    FCDEffectParameterFloat* float_param =
+        static_cast<FCDEffectParameterFloat*>(fc_param);
+    ParamFloat* param = param_object->CreateParam<ParamFloat>(param_name);
+    if (param) {
+      param->set_value(float_param->GetValue());
+      rc = true;
+    }
+  } else if (type == FCDEffectParameter::FLOAT2) {
+    FCDEffectParameterFloat2* float2_param =
+        static_cast<FCDEffectParameterFloat2*>(fc_param);
+    FMVector2 v = float2_param->GetValue();
+    ParamFloat2* param = param_object->CreateParam<ParamFloat2>(param_name);
+    if (param) {
+      Float2 f(v.x, v.y);
+      param->set_value(f);
+      rc = true;
+    }
+  } else if (type == FCDEffectParameter::FLOAT3) {
+    FCDEffectParameterFloat3* float3_param =
+        static_cast<FCDEffectParameterFloat3*>(fc_param);
+    FMVector3 v = float3_param->GetValue();
+    ParamFloat3* param = param_object->CreateParam<ParamFloat3>(param_name);
+    if (!param)
+      return false;
+    Float3 f(v.x, v.y, v.z);
+    param->set_value(f);
+    rc = true;
+  } else if (type == FCDEffectParameter::VECTOR) {
+    FCDEffectParameterVector* vector_param =
+        static_cast<FCDEffectParameterVector*>(fc_param);
+    FMVector4 v = vector_param->GetValue();
+    ParamFloat4* param = param_object->CreateParam<ParamFloat4>(param_name);
+    if (param) {
+      Float4 f(v.x, v.y, v.z, v.w);
+      param->set_value(f);
+      rc = true;
+    }
+  } else if (type == FCDEffectParameter::INTEGER) {
+    FCDEffectParameterInt* int_param =
+        static_cast<FCDEffectParameterInt*>(fc_param);
+    ParamInteger* param = param_object->CreateParam<ParamInteger>(param_name);
+    if (param) {
+      param->set_value(int_param->GetValue());
+      rc = true;
+    }
+  } else if (type == FCDEffectParameter::BOOLEAN) {
+    FCDEffectParameterBool* bool_param =
+        static_cast<FCDEffectParameterBool*>(fc_param);
+    ParamBoolean* param = param_object->CreateParam<ParamBoolean>(param_name);
+    if (param) {
+      param->set_value(bool_param->GetValue());
+      rc = true;
+    }
+  } else if (type == FCDEffectParameter::MATRIX) {
+    FCDEffectParameterMatrix* matrix_param =
+        static_cast<FCDEffectParameterMatrix*>(fc_param);
+    ParamMatrix4* param = param_object->CreateParam<ParamMatrix4>(param_name);
+    if (param) {
+      param->set_value(FMMatrix44ToMatrix4(matrix_param->GetValue()));
+      rc = true;
+    }
+  } else if (type == FCDEffectParameter::SAMPLER) {
+    FCDEffectParameterSampler* sampler =
+        static_cast<FCDEffectParameterSampler*>(fc_param);
+    ParamSampler* sampler_param = param_object->CreateParam<ParamSampler>(
+        param_name);
+    if (sampler_param) {
+      Sampler* o3d_sampler = pack_->Create<Sampler>();
+      o3d_sampler->set_name(param_name);
+      sampler_param->set_value(o3d_sampler);
+
+      FCDEffectParameterSurface* surface = sampler->GetSurface();
+      if (surface) {
+        Texture* tex = BuildTexture(surface);
+
+        // Set the texture on the sampler.
+        if (tex) {
+          o3d_sampler->set_texture(tex);
+          rc = true;
+        }
+      }
+      SetSamplerStates(sampler, o3d_sampler);
+    }
+  } else if (type == FCDEffectParameter::SURFACE) {
+    // TODO: This code is here to handle the NV_import profile
+    // exported by Max's DirectX Shader materials, which references
+    // only references texture params (not samplers).  Once we move
+    // completely to using samplers and add sampler blocks to our
+    // collada file then we should eliminate this codepath.
+
+    FCDEffectParameterSurface* surface =
+        static_cast<FCDEffectParameterSurface*>(fc_param);
+
+    Texture* tex = BuildTexture(surface);
+    if (tex) {
+      ParamTexture* param = param_object->CreateParam<ParamTexture>(param_name);
+      if (param) {
+        param->set_value(tex);
+        rc = true;
+      }
+    }
+  }
+  return rc;
+}
+
+Effect* Collada::GetDummyEffect() {
+  if (!dummy_effect_) {
+    // Create a dummy effect, just so we can see something
+    dummy_effect_ = pack_->Create<Effect>();
+    dummy_effect_->set_name(
+        COLLADA_STRING_CONSTANT("substituteForMissingOrBadEffect"));
+    dummy_effect_->LoadFromFXString(
+        "float4x4 worldViewProj : WorldViewProjection;"
+        "float4 vs(float4 v : POSITION ) : POSITION {"
+        "  return mul(v, worldViewProj);"
+        "}"
+        "float4 ps() : COLOR {"
+        "  return float4(1, 0, 1, 1);"
+        "}\n"
+        "// #o3d VertexShaderEntryPoint vs\n"
+        "// #o3d PixelShaderEntryPoint ps\n");
+  }
+  return dummy_effect_;
+}
+
+Material* Collada::GetDummyMaterial() {
+  if (!dummy_material_) {
+    dummy_material_ = pack_->Create<Material>();
+    dummy_material_->set_name(
+        COLLADA_STRING_CONSTANT("substituteForMissingOrBadMaterial"));
+    dummy_material_->set_effect(GetDummyEffect());
+  }
+  return dummy_material_;
+}
+
+static const char* GetLightingType(FCDEffectStandard* std_profile) {
+  FCDEffectStandard::LightingType type = std_profile->GetLightingType();
+  switch (type) {
+    case FCDEffectStandard::CONSTANT:
+      return "constant";
+    case FCDEffectStandard::PHONG:
+      return "phong";
+    case FCDEffectStandard::BLINN:
+      return "blinn";
+    case FCDEffectStandard::LAMBERT:
+      return "lambert";
+    default:
+      return "unknown";
+  }
+}
+
+static FCDEffectProfileFX* FindProfileFX(FCDEffect* effect) {
+  FCDEffectProfile* profile = effect->FindProfile(FUDaeProfileType::HLSL);
+  if (!profile) {
+    profile = effect->FindProfile(FUDaeProfileType::CG);
+    if (!profile) {
+      return NULL;
+    }
+  }
+  return static_cast<FCDEffectProfileFX*>(profile);
+}
+
+Material* Collada::BuildMaterial(FCDocument* doc,
+                                 FCDMaterial* collada_material) {
+  if (!doc || !collada_material) {
+    return NULL;
+  }
+
+  fm::string material_id = collada_material->GetDaeId();
+  Material* material = materials_[material_id.c_str()];
+  if (!material) {
+    Effect* effect = NULL;
+    FCDEffect* collada_effect = collada_material->GetEffect();
+    if (collada_effect) {
+      effect = GetEffect(doc, collada_effect);
+    }
+
+    String collada_material_name = WideToUTF8(
+        collada_material->GetName().c_str());
+    Material* material = pack_->Create<Material>();
+    material->set_name(collada_material_name);
+    material->set_effect(effect);
+    SetParamsFromMaterial(collada_material, material);
+
+    // If this is a COLLADA-FX profile, add the render states from the
+    // COLLADA-FX sections.
+    FCDEffectProfileFX* profile_fx = FindProfileFX(collada_effect);
+    if (profile_fx) {
+      if (profile_fx->GetTechniqueCount() > 0) {
+        FCDEffectTechnique* technique = profile_fx->GetTechnique(0);
+        if (technique->GetPassCount() > 0) {
+          FCDEffectPass* pass = technique->GetPass(0);
+          State* state = pack_->Create<State>();
+          state->set_name("pass_state");
+          cull_enabled_ = cull_front_ = front_cw_ = false;
+          for (size_t i = 0; i < pass->GetRenderStateCount(); ++i) {
+            AddRenderState(pass->GetRenderState(i), state);
+          }
+          material->set_state(state);
+        }
+      }
+    } else {
+      FCDEffectStandard* std_profile = static_cast<FCDEffectStandard *>(
+          collada_effect->FindProfile(FUDaeProfileType::COMMON));
+      if (std_profile) {
+        ParamString* type_tag = material->CreateParam<ParamString>(
+            COLLADA_STRING_CONSTANT("lightingType"));
+        type_tag->set_value(GetLightingType(std_profile));
+      }
+    }
+    materials_[material_id.c_str()] = material;
+  }
+  return material;
+}
+
+Effect* Collada::GetEffect(FCDocument* doc, FCDEffect* collada_effect) {
+  Effect* effect = NULL;
+  fm::string effect_id = collada_effect->GetDaeId();
+  effect = effects_[effect_id.c_str()];
+  if (!effect) {
+    effect = BuildEffect(doc, collada_effect);
+    if (effect) effects_[effect_id.c_str()] = effect;
+  }
+  return effect;
+}
+
+// Builds an O3D effect from a COLLADA effect.  If a COLLADA-FX
+// (Cg/HLSL) effect is present, it will be used and a programmable
+// Effect generated.  If not, an attempt is made to use one of the fixed-
+// function profiles if present (eg., Constant, Lambert).
+// Parameters:
+//   doc:                The FCollada document from which to import nodes.
+//   collada_effect:     The COLLADA effect from which shaders will be taken.
+// Returns:
+//   the newly-created effect, or NULL or error.
+Effect* Collada::BuildEffect(FCDocument* doc, FCDEffect* collada_effect) {
+  if (!doc || !collada_effect) return NULL;
+  // TODO: Remove all of this to be replaced by parsing Collada-FX
+  //    and profile_O3D only.
+  Effect* effect = NULL;
+  FCDEffectProfileFX* profile_fx = FindProfileFX(collada_effect);
+  if (profile_fx) {
+    if (profile_fx->GetCodeCount() > 0) {
+      FCDEffectCode* code = profile_fx->GetCode(0);
+      String effect_string;
+      FilePath file_path;
+      if (code->GetType() == FCDEffectCode::CODE) {
+        fstring code_string = code->GetCode();
+        effect_string = WideToUTF8(code_string.c_str());
+        unique_filename_counter_++;
+        String file_name = "embedded-shader-" +
+                           IntToString(unique_filename_counter_) + ".fx";
+        file_path = FilePath(FILE_PATH_LITERAL("shaders"));
+        file_path.Append(UTF8ToFilePath(file_name));
+      } else if (code->GetType() == FCDEffectCode::INCLUDE) {
+        fstring path = code->GetFilename();
+        file_path = WideToFilePath(path.c_str());
+        if (collada_zip_archive_ && !file_path.empty()) {
+          // Make absolute path be relative to root of archive.
+          if (file_path.value()[0] == FILE_PATH_LITERAL('/')) {
+            file_path = FilePath(file_path.value().substr(1));
+          }
+          size_t effect_data_size;
+          char *effect_data =
+              collada_zip_archive_->GetFileData(FilePathToUTF8(file_path),
+                                                &effect_data_size);
+          if (effect_data) {
+            effect_string = effect_data;
+            free(effect_data);
+          } else {
+            O3D_ERROR(service_locator_)
+                << "Unable to read effect data for effect '"
+                << FilePathToUTF8(file_path) << "'";
+            return NULL;
+          }
+        } else {
+          file_util::ReadFileToString(file_path, &effect_string);
+        }
+      }
+      String collada_effect_name = WideToUTF8(
+          collada_effect->GetName().c_str());
+      effect = pack_->Create<Effect>();
+      effect->set_name(collada_effect_name);
+
+      ParamString* param = effect->CreateParam<ParamString>(
+          O3D_STRING_CONSTANT("uri"));
+      DCHECK(param != NULL);
+      param->set_value(FilePathToUTF8(file_path));
+
+      if (!effect->LoadFromFXString(effect_string)) {
+        pack_->RemoveObject(effect);
+        O3D_ERROR(service_locator_) << "Unable to load effect '"
+                                    << FilePathToUTF8(file_path).c_str()
+                                    << "'";
+        return NULL;
+      }
+      if (options_.keep_original_data) {
+        // Cache the original data by URI so we can recover it later.
+        original_data_[file_path] = effect_string;
+      }
+    }
+  } else {
+    FCDExtra* extra = collada_effect->GetExtra();
+    if (extra && extra->GetTypeCount() > 0) {
+      FCDEType* type = extra->GetType(0);
+      if (type) {
+        FCDETechnique* technique = type->FindTechnique("NV_import");
+        if (technique) {
+          FCDENode* node = technique->FindChildNode("import");
+          if (node) {
+            FCDEAttribute* url_attrib = node->FindAttribute("url");
+            if (url_attrib) {
+              fstring url = url_attrib->GetValue();
+              const FUFileManager* mgr = doc->GetFileManager();
+              LOG_ASSERT(mgr != NULL);
+              FUUri uri = mgr->GetCurrentUri();
+              FUUri effect_uri = uri.Resolve(url_attrib->GetValue());
+              fstring path = effect_uri.GetAbsolutePath();
+
+              String collada_effect_name = WideToUTF8(
+                  collada_effect->GetName().c_str());
+
+              FilePath file_path = WideToFilePath(path.c_str());
+
+              String effect_string;
+
+              if (collada_zip_archive_ && !file_path.empty()) {
+                // Make absolute path be relative to root of archive.
+                if (file_path.value()[0] == FILE_PATH_LITERAL('/')) {
+                  file_path = FilePath(file_path.value().substr(1));
+                }
+                // shader file can be extracted in memory from zip archive
+                // so lets get the data and turn it into a string
+                size_t effect_data_size;
+                char *effect_data =
+                    collada_zip_archive_->GetFileData(FilePathToUTF8(file_path),
+                                                      &effect_data_size);
+                if (effect_data) {
+                  effect_string = effect_data;
+                  free(effect_data);
+                } else {
+                  O3D_ERROR(service_locator_)
+                      << "Unable to read effect data for effect '"
+                      << FilePathToUTF8(file_path) << "'";
+                  return NULL;
+                }
+              } else {
+                file_util::ReadFileToString(file_path, &effect_string);
+              }
+
+              effect = pack_->Create<Effect>();
+              effect->set_name(collada_effect_name);
+
+              ParamString* param = effect->CreateParam<ParamString>(
+                  O3D_STRING_CONSTANT("uri"));
+              DCHECK(param != NULL);
+              param->set_value(FilePathToUTF8(file_path));
+
+              if (!effect->LoadFromFXString(effect_string)) {
+                pack_->RemoveObject(effect);
+                O3D_ERROR(service_locator_) << "Unable to load effect '"
+                                            << FilePathToUTF8(file_path).c_str()
+                                            << "'";
+                return NULL;
+              }
+              if (options_.keep_original_data) {
+                // Cache the original data by URI so we can recover it later.
+                original_data_[file_path] = effect_string;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return effect;
+}
+
+// Gets a typed value from an FCollada state.  T is the type to get,
+// state is the state from which to retrieve the value, and offset is
+// the index into the state's data (in sizeof T objects) at which the
+// value is located.
+template <class T>
+static T GetStateValue(FCDEffectPassState* state, size_t offset) {
+  LOG_ASSERT(offset * sizeof(T) < state->GetDataSize());
+  return *(reinterpret_cast<T*>(state->GetData()) + offset);
+}
+
+// Converts an FCollada blend type into an O3D state blending function.
+// On error, an error string is logged.  "type" is the FCollada type to convert,
+// and "collada" is the Collada importer used for logging errors.
+static State::BlendingFunction ConvertBlendType(
+    ServiceLocator* service_locator,
+    FUDaePassStateBlendType::Type type) {
+  switch (type) {
+    case FUDaePassStateBlendType::ZERO:
+      return State::BLENDFUNC_ZERO;
+    case FUDaePassStateBlendType::ONE:
+      return State::BLENDFUNC_ONE;
+    case FUDaePassStateBlendType::SOURCE_COLOR:
+      return State::BLENDFUNC_SOURCE_COLOR;
+    case FUDaePassStateBlendType::ONE_MINUS_SOURCE_COLOR:
+      return State::BLENDFUNC_INVERSE_SOURCE_COLOR;
+    case FUDaePassStateBlendType::SOURCE_ALPHA:
+      return State::BLENDFUNC_SOURCE_ALPHA;
+    case FUDaePassStateBlendType::ONE_MINUS_SOURCE_ALPHA:
+      return State::BLENDFUNC_INVERSE_SOURCE_ALPHA;
+    case FUDaePassStateBlendType::DESTINATION_ALPHA:
+      return State::BLENDFUNC_DESTINATION_ALPHA;
+    case FUDaePassStateBlendType::ONE_MINUS_DESTINATION_ALPHA:
+      return State::BLENDFUNC_INVERSE_DESTINATION_ALPHA;
+    case FUDaePassStateBlendType::DESTINATION_COLOR:
+      return State::BLENDFUNC_DESTINATION_COLOR;
+    case FUDaePassStateBlendType::ONE_MINUS_DESTINATION_COLOR:
+      return State::BLENDFUNC_INVERSE_DESTINATION_COLOR;
+    case FUDaePassStateBlendType::SOURCE_ALPHA_SATURATE:
+      return State::BLENDFUNC_SOURCE_ALPHA_SATUTRATE;
+    default:
+      O3D_ERROR(service_locator) << "Invalid blend type";
+      return State::BLENDFUNC_ONE;
+  }
+}
+
+// Converts an FCollada blend equation into an O3D state blending
+// equation.  On error, an error string is logged.  "equation" is the
+// FCollada equation to convert, and "collada" is the Collada importer
+// used for logging errors.
+static State::BlendingEquation ConvertBlendEquation(
+    ServiceLocator* service_locator,
+    FUDaePassStateBlendEquation::Equation equation) {
+  switch (equation) {
+    case FUDaePassStateBlendEquation::ADD:
+      return State::BLEND_ADD;
+    case FUDaePassStateBlendEquation::SUBTRACT:
+      return State::BLEND_SUBTRACT;
+    case FUDaePassStateBlendEquation::REVERSE_SUBTRACT:
+      return State::BLEND_REVERSE_SUBTRACT;
+    case FUDaePassStateBlendEquation::MIN:
+      return State::BLEND_MIN;
+    case FUDaePassStateBlendEquation::MAX:
+      return State::BLEND_MAX;
+    default:
+      O3D_ERROR(service_locator) << "Invalid blend equation";
+      return State::BLEND_ADD;
+  }
+}
+
+// Converts an FCollada comparison function into an O3D state blending
+// equation.  On error, an error string is logged.  "function" is the
+// FCollada comparison function to convert, and "collada" is the Collada
+// importer used for logging errors.
+static State::Comparison ConvertComparisonFunction(
+    ServiceLocator* service_locator,
+    FUDaePassStateFunction::Function function) {
+  switch (function) {
+    case FUDaePassStateFunction::NEVER:
+      return State::CMP_NEVER;
+    case FUDaePassStateFunction::LESS:
+      return State::CMP_LESS;
+    case FUDaePassStateFunction::LESS_EQUAL:
+      return State::CMP_LEQUAL;
+    case FUDaePassStateFunction::EQUAL:
+      return State::CMP_EQUAL;
+    case FUDaePassStateFunction::GREATER:
+      return State::CMP_GREATER;
+    case FUDaePassStateFunction::NOT_EQUAL:
+      return State::CMP_NOTEQUAL;
+    case FUDaePassStateFunction::GREATER_EQUAL:
+      return State::CMP_GEQUAL;
+    case FUDaePassStateFunction::ALWAYS:
+      return State::CMP_ALWAYS;
+    default:
+      O3D_ERROR(service_locator) << "Invalid comparison function";
+      return State::CMP_NEVER;
+  }
+}
+
+// Converts an FCollada polygon fill mode into an O3D fill mode.
+// On error, an error string is logged.  "mode" is the FCollada fill
+// mode to convert, and "collada" is the Collada importer used for
+// logging errors.
+static State::Fill ConvertFillMode(ServiceLocator* service_locator,
+                                   FUDaePassStatePolygonMode::Mode mode) {
+  switch (mode) {
+    case FUDaePassStatePolygonMode::POINT:
+      return State::POINT;
+    case FUDaePassStatePolygonMode::LINE:
+      return State::WIREFRAME;
+    case FUDaePassStatePolygonMode::FILL:
+      return State::SOLID;
+    default:
+      O3D_ERROR(service_locator) << "Invalid polygon fill mode";
+      return State::SOLID;
+  }
+}
+
+// Converts an FCollada stencil operation into an O3D stencil operation.
+// On error, an error string is logged.  "operation" is the FCollada operation
+// to convert, and "collada" is the Collada importer used for logging errors.
+static State::StencilOperation ConvertStencilOp(
+    ServiceLocator* service_locator,
+    FUDaePassStateStencilOperation::Operation operation) {
+  switch (operation) {
+    case FUDaePassStateStencilOperation::KEEP:
+      return State::STENCIL_KEEP;
+    case FUDaePassStateStencilOperation::ZERO:
+      return State::STENCIL_ZERO;
+    case FUDaePassStateStencilOperation::REPLACE:
+      return State::STENCIL_REPLACE;
+    case FUDaePassStateStencilOperation::INCREMENT:
+      return State::STENCIL_INCREMENT_SATURATE;
+    case FUDaePassStateStencilOperation::DECREMENT:
+      return State::STENCIL_DECREMENT_SATURATE;
+    case FUDaePassStateStencilOperation::INVERT:
+      return State::STENCIL_INVERT;
+    case FUDaePassStateStencilOperation::INCREMENT_WRAP:
+      return State::STENCIL_INCREMENT;
+    case FUDaePassStateStencilOperation::DECREMENT_WRAP:
+      return State::STENCIL_DECREMENT;
+    default:
+      O3D_ERROR(service_locator) << "Invalid stencil operation";
+      return State::STENCIL_KEEP;
+  }
+}
+
+// Updates the O3D state object's cull mode from the OpenGL-style
+// cull modes used by COLLADA-FX sections.  "state" is the O3D state
+// on which to set the cull mode.  If "cull_front_" is true, the system is
+// culling front-facing polygons, otherwise it's culling back-facing.  If
+// "front_cw_" is true, polygons with clockwise winding are considered
+// front-facing, otherwise counter-clockwise winding is considered
+// front-facing.  if "cull_enabled_" is false, culling is disabled.
+void Collada::UpdateCullingState(State* state) {
+  ParamInteger* face = state->GetStateParam<ParamInteger>(
+      State::kCullModeParamName);
+  if (cull_front_ ^ front_cw_) {
+    face->set_value(cull_enabled_ ? State::CULL_CCW : State::CULL_NONE);
+  } else {
+    face->set_value(cull_enabled_ ? State::CULL_CW : State::CULL_NONE);
+  }
+}
+
+// Sets a boolean state param in an O3D state object.  "state" is the
+// state object, "name" is the name of the state param to set, and "value"
+// is the boolean value.  If the state param does not exist, or is not
+// of the correct type, an assert is logged.
+static void SetBoolState(State* state, const char* name, bool value) {
+  ParamBoolean* param = state->GetStateParam<ParamBoolean>(name);
+  LOG_ASSERT(param);
+  param->set_value(value);
+}
+
+// Sets a floating-point state param in an O3D state object.
+// "state" is the state object, "name" is the name of the state param
+// to set, and "value" is the floating-point value.  If the state
+// param does not exist, or is not of the correct type, an assert
+// is logged.
+static void SetFloatState(State* state, const char* name, float value) {
+  ParamFloat* param = state->GetStateParam<ParamFloat>(name);
+  LOG_ASSERT(param);
+  param->set_value(value);
+}
+
+// Sets a Float4 state param in an O3D state object.  "state" is
+// the state object, "name" is the name of the state param to set, and
+// "value" is the Float4 value.  If the state param does not exist, or
+// is not of the correct type, an assert is logged.
+static void SetFloat4State(State* state,
+                           const char* name,
+                           const Float4& value) {
+  ParamFloat4* param = state->GetStateParam<ParamFloat4>(name);
+  LOG_ASSERT(param);
+  param->set_value(value);
+}
+
+// Sets a integer state param in an O3D state object.  "state" is
+// the state object, "name" is the name of the state param to set, and
+// "value" is the Float4 value.  If the state param does not exist, or
+// is not of the correct type, an assert is logged.
+static void SetIntState(State* state, const char* name, int value) {
+  ParamInteger* param = state->GetStateParam<ParamInteger>(name);
+  LOG_ASSERT(param);
+  param->set_value(value);
+}
+
+// Sets the stencil state params for polygons with clockwise
+// winding.  "state" is the O3D state object in which to set
+// state, "fail", "zfail", and "zpass" are the corresponding stencil
+// settings.
+static void SetCWStencilSettings(State* state,
+                                 State::StencilOperation fail,
+                                 State::StencilOperation zfail,
+                                 State::StencilOperation zpass) {
+  SetIntState(state, State::kStencilFailOperationParamName, fail);
+  SetIntState(state, State::kStencilZFailOperationParamName, zfail);
+  SetIntState(state, State::kStencilPassOperationParamName, zpass);
+}
+
+// Sets the stencil state params for polygons with counter-clockwise
+// winding.  "state" is the O3D state object in which to set
+// state, "fail", "zfail", and "zpass" are the corresponding stencil
+// settings.
+static void SetCCWStencilSettings(State* state,
+                                  State::StencilOperation fail,
+                                  State::StencilOperation zfail,
+                                  State::StencilOperation zpass) {
+  SetIntState(state, State::kCCWStencilFailOperationParamName, fail);
+  SetIntState(state, State::kCCWStencilZFailOperationParamName, zfail);
+  SetIntState(state, State::kCCWStencilPassOperationParamName, zpass);
+}
+
+// Sets the stencil state params for polygons with the given winding
+// order.  "state" is the O3D state object in which to set
+// state, "fail", "zfail", and "zpass" are the corresponding stencil
+// settings.  If "cw" is true, clockwise winding settings will be set,
+// otherwise counter-clockwise winding settings are set.
+static void SetStencilSettings(State* state,
+                               bool cw,
+                               State::StencilOperation fail,
+                               State::StencilOperation zfail,
+                               State::StencilOperation zpass) {
+  if (cw) {
+    SetCWStencilSettings(state, fail, zfail, zpass);
+  } else {
+    SetCCWStencilSettings(state, fail, zfail, zpass);
+  }
+}
+
+// Adds the appropriate O3D state params to the given state object
+// corresponding to a given FCollada Pass State.  If unsupported or
+// invalid states are specified, an error message is set.
+void Collada::AddRenderState(FCDEffectPassState* pass_state, State* state) {
+  switch (pass_state->GetType()) {
+    case FUDaePassState::ALPHA_FUNC: {
+      State::Comparison function = ConvertComparisonFunction(
+          service_locator_,
+          GetStateValue<FUDaePassStateFunction::Function>(pass_state, 0));
+      float value = GetStateValue<float>(pass_state, 1);
+      SetIntState(state, State::kAlphaComparisonFunctionParamName, function);
+      SetFloatState(state, State::kAlphaReferenceParamName, value);
+      break;
+    }
+    case FUDaePassState::BLEND_FUNC: {
+      State::BlendingFunction src = ConvertBlendType(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendType::Type>(pass_state, 0));
+      State::BlendingFunction dest = ConvertBlendType(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendType::Type>(pass_state, 1));
+      SetIntState(state, State::kSourceBlendFunctionParamName, src);
+      SetIntState(state, State::kDestinationBlendFunctionParamName, dest);
+      SetBoolState(state, State::kSeparateAlphaBlendEnableParamName, false);
+      break;
+    }
+    case FUDaePassState::BLEND_FUNC_SEPARATE: {
+      State::BlendingFunction src_rgb = ConvertBlendType(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendType::Type>(pass_state, 0));
+      State::BlendingFunction dest_rgb = ConvertBlendType(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendType::Type>(pass_state, 1));
+      State::BlendingFunction src_alpha = ConvertBlendType(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendType::Type>(pass_state, 2));
+      State::BlendingFunction dest_alpha = ConvertBlendType(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendType::Type>(pass_state, 3));
+      SetIntState(state, State::kSourceBlendFunctionParamName, src_rgb);
+      SetIntState(state, State::kDestinationBlendFunctionParamName, dest_rgb);
+      SetIntState(state, State::kSourceBlendAlphaFunctionParamName, src_alpha);
+      SetIntState(state, State::kDestinationBlendAlphaFunctionParamName,
+                  dest_alpha);
+      SetBoolState(state, State::kSeparateAlphaBlendEnableParamName, true);
+      break;
+    }
+    case FUDaePassState::BLEND_EQUATION: {
+      State::BlendingEquation value = ConvertBlendEquation(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendEquation::Equation>(pass_state, 0));
+      SetIntState(state, State::kBlendEquationParamName, value);
+      SetIntState(state, State::kBlendAlphaEquationParamName, value);
+      break;
+    }
+    case FUDaePassState::BLEND_EQUATION_SEPARATE: {
+      State::BlendingEquation rgb = ConvertBlendEquation(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendEquation::Equation>(pass_state, 0));
+      State::BlendingEquation alpha = ConvertBlendEquation(
+          service_locator_,
+          GetStateValue<FUDaePassStateBlendEquation::Equation>(pass_state, 1));
+      SetIntState(state, State::kBlendEquationParamName, rgb);
+      SetIntState(state, State::kBlendAlphaEquationParamName, alpha);
+      break;
+    }
+    case FUDaePassState::CULL_FACE: {
+      FUDaePassStateFaceType::Type culled_faces =
+          GetStateValue<FUDaePassStateFaceType::Type>(pass_state, 0);
+      switch (culled_faces) {
+        case FUDaePassStateFaceType::FRONT: {
+          cull_front_ = true;
+          break;
+        }
+        case FUDaePassStateFaceType::BACK: {
+          cull_front_ = false;
+          break;
+        }
+        case FUDaePassStateFaceType::FRONT_AND_BACK: {
+          O3D_ERROR(service_locator_)
+              << "FRONT_AND_BACK culling is unsupported";
+          break;
+        }
+      }
+      UpdateCullingState(state);
+      break;
+    }
+    case FUDaePassState::DEPTH_FUNC: {
+      State::Comparison function = ConvertComparisonFunction(
+          service_locator_,
+          GetStateValue<FUDaePassStateFunction::Function>(pass_state, 0));
+      SetIntState(state, State::kZComparisonFunctionParamName, function);
+      break;
+    }
+    case FUDaePassState::FRONT_FACE: {
+      FUDaePassStateFrontFaceType::Type type =
+          GetStateValue<FUDaePassStateFrontFaceType::Type>(pass_state, 0);
+      front_cw_ = type == FUDaePassStateFrontFaceType::CLOCKWISE;
+      break;
+    }
+    case FUDaePassState::POLYGON_MODE: {
+      FUDaePassStateFaceType::Type face =
+          GetStateValue<FUDaePassStateFaceType::Type>(pass_state, 0);
+      State::Fill mode = ConvertFillMode(
+          service_locator_,
+          GetStateValue<FUDaePassStatePolygonMode::Mode>(pass_state, 1));
+      if (face != FUDaePassStateFaceType::FRONT_AND_BACK) {
+        O3D_ERROR(service_locator_)
+            << "Separate polygon fill modes are unsupported";
+      }
+      SetIntState(state, State::kFillModeParamName, mode);
+      break;
+    }
+    case FUDaePassState::STENCIL_FUNC: {
+      State::Comparison func = ConvertComparisonFunction(
+          service_locator_,
+          GetStateValue<FUDaePassStateFunction::Function>(pass_state, 0));
+      uint8 ref = GetStateValue<uint8>(pass_state, 4);
+      uint8 mask = GetStateValue<uint8>(pass_state, 5);
+      SetIntState(state, State::kStencilComparisonFunctionParamName, func);
+      SetIntState(state, State::kStencilReferenceParamName, ref);
+      SetIntState(state, State::kStencilMaskParamName, mask);
+      SetBoolState(state, State::kTwoSidedStencilEnableParamName, false);
+      break;
+    }
+    case FUDaePassState::STENCIL_FUNC_SEPARATE: {
+      State::Comparison front = ConvertComparisonFunction(
+          service_locator_,
+          GetStateValue<FUDaePassStateFunction::Function>(pass_state, 0));
+      State::Comparison back = ConvertComparisonFunction(
+          service_locator_,
+          GetStateValue<FUDaePassStateFunction::Function>(pass_state, 1));
+      uint8 ref = GetStateValue<uint8>(pass_state, 8);
+      uint8 mask = GetStateValue<uint8>(pass_state, 9);
+      SetIntState(state, State::kStencilComparisonFunctionParamName, front);
+      SetIntState(state, State::kCCWStencilComparisonFunctionParamName, back);
+      SetIntState(state, State::kStencilReferenceParamName, ref);
+      SetIntState(state, State::kStencilMaskParamName, mask);
+      SetBoolState(state, State::kTwoSidedStencilEnableParamName, true);
+      break;
+    }
+    case FUDaePassState::STENCIL_OP: {
+      State::StencilOperation fail = ConvertStencilOp(
+          service_locator_,
+          GetStateValue<FUDaePassStateStencilOperation::Operation>(pass_state,
+                                                                   0));
+      State::StencilOperation zfail = ConvertStencilOp(
+          service_locator_,
+          GetStateValue<FUDaePassStateStencilOperation::Operation>(pass_state,
+                                                                   1));
+      State::StencilOperation zpass = ConvertStencilOp(
+          service_locator_,
+          GetStateValue<FUDaePassStateStencilOperation::Operation>(pass_state,
+                                                                   2));
+      SetStencilSettings(state, front_cw_, fail, zfail, zpass);
+      SetBoolState(state, State::kTwoSidedStencilEnableParamName, false);
+      break;
+    }
+    case FUDaePassState::STENCIL_OP_SEPARATE: {
+      FUDaePassStateFaceType::Type type =
+          GetStateValue<FUDaePassStateFaceType::Type>(pass_state, 0);
+      State::StencilOperation fail = ConvertStencilOp(
+          service_locator_,
+          GetStateValue<FUDaePassStateStencilOperation::Operation>(pass_state,
+                                                                   0));
+      State::StencilOperation zfail = ConvertStencilOp(
+          service_locator_,
+          GetStateValue<FUDaePassStateStencilOperation::Operation>(pass_state,
+                                                                   1));
+      State::StencilOperation zpass = ConvertStencilOp(
+          service_locator_,
+          GetStateValue<FUDaePassStateStencilOperation::Operation>(pass_state,
+                                                                   2));
+      switch (type) {
+        case FUDaePassStateFaceType::FRONT:
+          SetStencilSettings(state, front_cw_, fail, zfail, zpass);
+          SetBoolState(state, State::kTwoSidedStencilEnableParamName, true);
+          break;
+        case FUDaePassStateFaceType::BACK:
+          SetStencilSettings(state, !front_cw_, fail, zfail, zpass);
+          SetBoolState(state, State::kTwoSidedStencilEnableParamName, true);
+          break;
+        case FUDaePassStateFaceType::FRONT_AND_BACK:
+          SetStencilSettings(state, front_cw_, fail, zfail, zpass);
+          SetStencilSettings(state, !front_cw_, fail, zfail, zpass);
+          SetBoolState(state, State::kTwoSidedStencilEnableParamName, false);
+          break;
+        default:
+          O3D_ERROR(service_locator_)
+              << "Unknown polygon face mode in STENCIL_OP_SEPARATE";
+          break;
+      }
+      break;
+    }
+    case FUDaePassState::STENCIL_MASK: {
+      uint32 mask = GetStateValue<uint8>(pass_state, 0);
+      SetIntState(state, State::kStencilWriteMaskParamName, mask);
+      break;
+    }
+    case FUDaePassState::STENCIL_MASK_SEPARATE: {
+      O3D_ERROR(service_locator_) << "Separate stencil mask is unsupported";
+      break;
+    }
+    case FUDaePassState::COLOR_MASK: {
+      bool red = GetStateValue<bool>(pass_state, 0);
+      bool green = GetStateValue<bool>(pass_state, 1);
+      bool blue = GetStateValue<bool>(pass_state, 2);
+      bool alpha = GetStateValue<bool>(pass_state, 3);
+      int mask = 0x0;
+      if (red) mask |= 0x1;
+      if (green) mask |= 0x2;
+      if (blue) mask |= 0x4;
+      if (alpha) mask |= 0x8;
+      SetIntState(state, State::kColorWriteEnableParamName, mask);
+      break;
+    }
+    case FUDaePassState::DEPTH_MASK: {
+      bool value = GetStateValue<bool>(pass_state, 0);
+      SetBoolState(state, State::kZWriteEnableParamName, value);
+      break;
+    }
+    case FUDaePassState::POINT_SIZE: {
+      float value = GetStateValue<float>(pass_state, 0);
+      SetFloatState(state, State::kPointSizeParamName, value);
+      break;
+    }
+    case FUDaePassState::POLYGON_OFFSET: {
+      float value1 = GetStateValue<float>(pass_state, 0);
+      float value2 = GetStateValue<float>(pass_state, 1);
+      SetFloatState(state, State::kPolygonOffset1ParamName, value1);
+      SetFloatState(state, State::kPolygonOffset2ParamName, value2);
+      break;
+    }
+    case FUDaePassState::BLEND_COLOR: {
+      FMVector4 value = GetStateValue<FMVector4>(pass_state, 0);
+      Float4 v(value.x, value.y, value.z, value.w);
+      SetFloat4State(state, State::kPolygonOffset1ParamName, v);
+      break;
+    }
+    case FUDaePassState::ALPHA_TEST_ENABLE: {
+      bool value = GetStateValue<bool>(pass_state, 0);
+      SetBoolState(state, State::kAlphaTestEnableParamName, value);
+      break;
+    }
+    case FUDaePassState::BLEND_ENABLE: {
+      bool value = GetStateValue<bool>(pass_state, 0);
+      SetBoolState(state, State::kAlphaBlendEnableParamName, value);
+      break;
+    }
+    case FUDaePassState::CULL_FACE_ENABLE: {
+      cull_enabled_ = GetStateValue<bool>(pass_state, 0);
+      UpdateCullingState(state);
+      break;
+    }
+    case FUDaePassState::DEPTH_TEST_ENABLE: {
+      bool value = GetStateValue<bool>(pass_state, 0);
+      SetBoolState(state, State::kZEnableParamName, value);
+      break;
+    }
+    case FUDaePassState::DITHER_ENABLE: {
+      bool value = GetStateValue<bool>(pass_state, 0);
+      SetBoolState(state, State::kDitherEnableParamName, value);
+      break;
+    }
+    case FUDaePassState::LINE_SMOOTH_ENABLE: {
+      bool value = GetStateValue<bool>(pass_state, 0);
+      SetBoolState(state, State::kLineSmoothEnableParamName, value);
+      break;
+    }
+    case FUDaePassState::STENCIL_TEST_ENABLE: {
+      bool value = GetStateValue<bool>(pass_state, 0);
+      SetBoolState(state, State::kStencilEnableParamName, value);
+      break;
+    }
+  }
+}
+
+// Converts an FCollada texture sampler wrap mode to an O3D Sampler
+// AddressMode.
+static Sampler::AddressMode ConvertSamplerAddressMode(
+    FUDaeTextureWrapMode::WrapMode wrap_mode) {
+  switch (wrap_mode) {
+    case FUDaeTextureWrapMode::WRAP:
+      return Sampler::WRAP;
+    case FUDaeTextureWrapMode::MIRROR:
+      return Sampler::MIRROR;
+    case FUDaeTextureWrapMode::CLAMP:
+      return Sampler::CLAMP;
+    case FUDaeTextureWrapMode::BORDER:
+      return Sampler::BORDER;
+    default:
+      return Sampler::WRAP;
+  }
+}
+
+// Converts an FCollada filter func to an O3D Sampler FilterType.
+// Since the Collada filter spec allows both GL-style combo mag/min filters,
+// and DX-style (separate min/mag/mip filters), this function extracts
+// only the first (min) part of a GL-style filter.
+static Sampler::FilterType ConvertFilterType(
+    FUDaeTextureFilterFunction::FilterFunction filter_function,
+    bool allow_none) {
+  switch (filter_function) {
+    case FUDaeTextureFilterFunction::NEAREST:
+    case FUDaeTextureFilterFunction::NEAREST_MIPMAP_NEAREST:
+    case FUDaeTextureFilterFunction::NEAREST_MIPMAP_LINEAR:
+      return Sampler::POINT;
+    case FUDaeTextureFilterFunction::LINEAR:
+    case FUDaeTextureFilterFunction::LINEAR_MIPMAP_NEAREST:
+    case FUDaeTextureFilterFunction::LINEAR_MIPMAP_LINEAR:
+      return Sampler::LINEAR;
+      // TODO: Once FCollada supports COLLADA v1.5, turn this on:
+      // case FUDaeTextureFilterFunction::ANISOTROPIC:
+      //   return Sampler::ANISOTROPIC;
+    case FUDaeTextureFilterFunction::NONE:
+      return allow_none ? Sampler::NONE : Sampler::LINEAR;
+    default:
+      return Sampler::LINEAR;
+  }
+}
+
+
+// Retrieves the mipmap part of a GL-style filter function.
+// If no mipmap part is specified, it is assumed to be POINT.
+static Sampler::FilterType ConvertMipmapFilter(
+    FUDaeTextureFilterFunction::FilterFunction filter_function) {
+  switch (filter_function) {
+    case FUDaeTextureFilterFunction::NEAREST_MIPMAP_NEAREST:
+    case FUDaeTextureFilterFunction::LINEAR_MIPMAP_NEAREST:
+    case FUDaeTextureFilterFunction::UNKNOWN:
+      return Sampler::POINT;
+    case FUDaeTextureFilterFunction::NEAREST_MIPMAP_LINEAR:
+    case FUDaeTextureFilterFunction::LINEAR_MIPMAP_LINEAR:
+      return Sampler::LINEAR;
+    default:
+      return Sampler::NONE;
+  }
+}
+
+// Sets the texture sampler states on an O3D sampler from the
+// settings found in an FCollada sampler.
+// Parameters:
+//   effect_sampler:       The FCollada sampler.
+//   o3d_sampler:          The O3D sampler object.
+void Collada::SetSamplerStates(FCDEffectParameterSampler* effect_sampler,
+                               Sampler* o3d_sampler) {
+  FUDaeTextureWrapMode::WrapMode wrap_s = effect_sampler->GetWrapS();
+  FUDaeTextureWrapMode::WrapMode wrap_t = effect_sampler->GetWrapT();
+  Texture *texture = o3d_sampler->texture();
+  if (texture && texture->IsA(TextureCUBE::GetApparentClass())) {
+    // Our default is WRAP, but cube maps should use CLAMP
+    if (wrap_s == FUDaeTextureWrapMode::UNKNOWN)
+      wrap_s = FUDaeTextureWrapMode::CLAMP;
+    if (wrap_t == FUDaeTextureWrapMode::UNKNOWN)
+      wrap_t = FUDaeTextureWrapMode::CLAMP;
+  }
+
+  FUDaeTextureFilterFunction::FilterFunction min_filter =
+      effect_sampler->GetMinFilter();
+  FUDaeTextureFilterFunction::FilterFunction mag_filter =
+      effect_sampler->GetMagFilter();
+
+  FUDaeTextureFilterFunction::FilterFunction mip_filter =
+      effect_sampler->GetMipFilter();
+  // TODO: Once FCollada supports COLLADA v1.5, turn this on:
+  // int max_anisotropy = effect_sampler->GetMaxAnisotropy();
+
+  o3d_sampler->set_address_mode_u(ConvertSamplerAddressMode(wrap_s));
+  o3d_sampler->set_address_mode_v(ConvertSamplerAddressMode(wrap_t));
+
+  // The Collada spec allows for both DX-style and GL-style specification
+  // of texture filtering modes.  In DX-style, Min, Mag and Mip filters
+  // are specified separately, and may be Linear, Point or None.
+  // In GL-style, only Min and Mag are specified, with the Mip filter
+  // encoded as a combo setting in the Min filter.  E.g.,
+  // LinearMipmapLinear  => Min Linear, Mip Linear,
+  // LinearMipmapNearest => Min Linear, Mip Point,
+  // Linear              => Min Linear, Mip None (no mipmapping).
+
+  // In order to sort this out, if the Mip filter is "unknown" (missing),
+  // we assume GL-style specification, and extract the Mip setting from
+  // the latter part of the GL-style Min setting.  If the Mip filter is
+  // specified, we assume a DX-style specification, and the three
+  // components are assigned separately.  Any GL-style combo
+  // modes used in DX mode are ignored (only the first part is used).
+
+  o3d_sampler->set_min_filter(ConvertFilterType(min_filter, false));
+  o3d_sampler->set_mag_filter(ConvertFilterType(mag_filter, false));
+
+  // If the mip filter is set to "UNKNOWN", we assume it's a GL-style
+  // mode, and use the 2nd part of the Min filter for the mip type.  Otherwise,
+  // we use the first part.
+  if (mip_filter == FUDaeTextureFilterFunction::UNKNOWN) {
+    o3d_sampler->set_mip_filter(ConvertMipmapFilter(min_filter));
+  } else {
+    o3d_sampler->set_mip_filter(ConvertFilterType(mip_filter, true));
+  }
+
+  // TODO: Once FCollada supports COLLADA v1.5, turn this on:
+  // o3d_sampler->set_max_anisotropy(max_anisotropy);
+}
+
+// Sets the value of a Param on the given ParamObject from an FCollada
+// standard-profile effect parameter.  If the FCollada parameter
+// contains a texture, the sampler_param_name and channel is used to set
+// a Sampler Param in o3d from the surface.  If not, the
+// color_param_name is used to create set a vector Param value.
+// Parameters:
+//   effect_standard:      The fixed-function FCollada effect from which
+//                         to retrieve the parameter value.
+//   param_object:         The ParamObject on which parameters will be set.
+//   color_param_mame:     The name of the param to set, if a vector.
+//   sampler_param_mame:   The name of the param to set, if a texture sampler.
+//   color_param:          The FCollada parameter from which to retrieve the
+//                         new value.
+//   channel:              The texture channel to use (if any).
+void Collada::SetParamFromStandardEffectParam(
+    FCDEffectStandard* effect_standard,
+    ParamObject* param_object,
+    const char* color_param_name,
+    const char* sampler_param_name,
+    FCDEffectParameter* color_param,
+    int channel) {
+  if (effect_standard->GetTextureCount(channel) > 0) {
+    FCDTexture* texture = effect_standard->GetTexture(channel, 0);
+    FCDEffectParameterSampler* sampler = texture->GetSampler();
+    SetParamFromFCEffectParam(param_object, sampler_param_name, sampler);
+  } else if (color_param) {
+    SetParamFromFCEffectParam(param_object, color_param_name, color_param);
+  }
+}
+
+// Sets the values of a ParamObject parameters from a given FCollada material
+// node. If a corresponding ParamObject parameter is not found, the FCollada
+// parameter is ignored.
+// TODO: Should we ignore params not found? Maybe the user wants those for
+//    things other than rendering.
+// Parameters:
+//   material:  The FCollada material node from which to retrieve values.
+//   param_object:     The ParamObject on which parameters will be set.
+void Collada::SetParamsFromMaterial(FCDMaterial* material,
+                                    ParamObject* param_object) {
+  size_t pcount = material->GetEffectParameterCount();
+  // TODO:  This test (for determining if we used the
+  // programmable profile or the fixed-func profile) is not very robust.
+  // Remove this once the Material changes are in.
+  if (pcount > 0) {
+    for (size_t i = 0; i < pcount; ++i) {
+      FCDEffectParameter* p = material->GetEffectParameter(i);
+      LOG_ASSERT(p);
+      String param_name(p->GetReference());
+      // Check for an effect binding
+      FCDEffect* effect = material->GetEffect();
+      FCDEffectProfileFX* profile_fx = FindProfileFX(material->GetEffect());
+      if (profile_fx) {
+        FCDEffectTechnique* technique = profile_fx->GetTechnique(0);
+        if (technique->GetPassCount() > 0) {
+          FCDEffectPass* pass = technique->GetPass(0);
+          for (size_t j = 0; j < pass->GetShaderCount(); ++j) {
+            FCDEffectPassShader* shader = pass->GetShader(j);
+            FCDEffectPassBind* bind =
+                shader->FindBindingReference(p->GetReference());
+            if (bind) {
+              param_name = *bind->symbol;
+              break;
+            }
+          }
+        }
+      }
+      SetParamFromFCEffectParam(param_object, param_name, p);
+    }
+  } else {
+    FCDEffect* effect = material->GetEffect();
+    FCDEffectStandard* effect_standard;
+    if (effect && (effect_standard = static_cast<FCDEffectStandard *>(
+        effect->FindProfile(FUDaeProfileType::COMMON))) != NULL) {
+      SetParamFromStandardEffectParam(effect_standard,
+                                      param_object,
+                                      "emissive",
+                                      "emissiveSampler",
+                                      effect_standard->GetEmissionColorParam(),
+                                      FUDaeTextureChannel::EMISSION);
+      SetParamFromStandardEffectParam(effect_standard,
+                                      param_object,
+                                      "ambient",
+                                      "ambientSampler",
+                                      effect_standard->GetAmbientColorParam(),
+                                      FUDaeTextureChannel::AMBIENT);
+      SetParamFromStandardEffectParam(effect_standard,
+                                      param_object,
+                                      "diffuse",
+                                      "diffuseSampler",
+                                      effect_standard->GetDiffuseColorParam(),
+                                      FUDaeTextureChannel::DIFFUSE);
+      SetParamFromStandardEffectParam(effect_standard,
+                                      param_object,
+                                      "specular",
+                                      "specularSampler",
+                                      effect_standard->GetSpecularColorParam(),
+                                      FUDaeTextureChannel::SPECULAR);
+      SetParamFromStandardEffectParam(effect_standard,
+                                      param_object,
+                                      NULL,
+                                      "bumpSampler",
+                                      NULL,
+                                      FUDaeTextureChannel::BUMP);
+      SetParamFromFCEffectParam(param_object,
+                                "shininess",
+                                effect_standard->GetShininessParam());
+      SetParamFromFCEffectParam(param_object,
+                                "specularFactor",
+                                effect_standard->GetSpecularFactorParam());
+    }
+  }
+}
+}  // namespace o3d
diff --git a/o3d/import/cross/collada.h b/o3d/import/cross/collada.h
new file mode 100644
index 0000000..67538ea
--- /dev/null
+++ b/o3d/import/cross/collada.h
@@ -0,0 +1,438 @@
+/*
+ * 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.
+ */
+
+
+// This file declares functions for importing COLLADA files into O3D.
+
+#ifndef O3D_IMPORT_CROSS_COLLADA_H_
+#define O3D_IMPORT_CROSS_COLLADA_H_
+
+#include <map>
+#include <string>
+#include <vector>
+#include "base/file_path.h"
+#include "core/cross/param.h"
+#include "core/cross/types.h"
+
+class FCDocument;
+class FCDAnimated;
+class FCDCamera;
+class FCDSceneNode;
+class FCDGeometry;
+class FCDGeometryInstance;
+class FCDControllerInstance;
+class FCDMaterial;
+class FCDEffect;
+class FCDEffectStandard;
+class FCDEffectParameter;
+class FCDEffectParameterSampler;
+class FCDEffectParameterSurface;
+class FCDEffectPassState;
+class FCDImage;
+class FCDTMatrix;
+class FCDTTranslation;
+class FCDTRotation;
+class FCDTScale;
+
+class FilePath;
+
+namespace o3d {
+
+class ColladaZipArchive;
+class Effect;
+class IErrorStatus;
+class Material;
+class Pack;
+class ParamObject;
+class Sampler;
+class ShaderBuilderHelper;
+class Shape;
+class State;
+class Texture;
+class Transform;
+class TranslationMap;
+
+// This class keeps an association between a Collada node instance and a
+// transform.
+// This takes ownership of its children NodeInstances.
+class NodeInstance {
+ public:
+  typedef std::vector<NodeInstance *> NodeInstanceList;
+
+  explicit NodeInstance(FCDSceneNode *node) : node_(node), transform_(NULL) {}
+  ~NodeInstance() {
+    for (unsigned int i = 0; i < children_.size(); ++i) {
+      delete children_[i];
+    }
+  }
+
+  // Gets the Collada node associated with this node instance.
+  FCDSceneNode *node() const { return node_; }
+
+  // Gets the Transform associated with this node instance.
+  Transform *transform() const { return transform_; }
+
+  // Sets the Transform associated with this node instance.
+  void set_transform(Transform *transform) { transform_ = transform; }
+
+  // Gets the list of this node instance's children.
+  NodeInstanceList &children() { return children_; }
+
+  // Finds the NodeInstance representing a scene node in the direct children of
+  // this NodeInstance.
+  NodeInstance *FindNodeShallow(FCDSceneNode *node) {
+    for (unsigned int i = 0; i < children_.size(); ++i) {
+      NodeInstance *child = children_[i];
+      if (child->node() == node) return child;
+    }
+    return NULL;
+  }
+
+  // Finds the NodeInstance representing a scene node in the sub-tree starting
+  // at this NodeInstance.
+  NodeInstance *FindNodeInTree(FCDSceneNode *node);
+
+ private:
+  FCDSceneNode *node_;
+  Transform *transform_;
+  std::vector<NodeInstance *> children_;
+};
+
+class Collada {
+ public:
+  struct Options {
+    Options()
+        : generate_mipmaps(true),
+          condition_document(false),
+          keep_original_data(false),
+          up_axis(0.0f, 0.0f, 0.0f),
+          base_path(FilePath::kCurrentDirectory) {}
+    // Whether or not to generate mip-maps on the textures we load.
+    bool generate_mipmaps;
+
+    // Whether or not to retain the original form for textures for later
+    // access by filename.
+    bool keep_original_data;
+
+    // Whether or not to condition documents for o3d as part of
+    // loading them.
+    bool condition_document;
+
+    // What the up-axis of the imported geometry should be.
+    Vector3 up_axis;
+
+    // The base path to use for determining the relative paths for
+    // asset URIs.
+    FilePath base_path;
+  };
+
+  // Use this if you need access to data after the import (as the
+  // converter does).
+  Collada(Pack* pack, const Options& options);
+  virtual ~Collada();
+
+  // Imports the given COLLADA file or ZIP file into the given scene.
+  // This is the external interface to o3d.
+  // Parameters:
+  //   pack:      The pack into which the scene objects will be placed.
+  //   filename:  The COLLADA or ZIPped COLLADA file to import.
+  //   parent:    The parent node under which the imported nodes will be placed.
+  //              If NULL, nodes will be placed under the client's root.
+  //   animation_input: The counter parameter used to control transform
+  //              animation in the collada file.
+  //   options:   The Options structure (see above) that describes any
+  //              desired options.
+  // Returns true on success.
+  static bool Import(Pack* pack,
+                     const FilePath& filename,
+                     Transform* parent,
+                     ParamFloat* animation_input,
+                     const Options& options);
+
+  // Same thing but with String filename.
+  static bool Import(Pack* pack,
+                     const String& filename,
+                     Transform* parent,
+                     ParamFloat* animation_input,
+                     const Options& options);
+
+  // Imports the given COLLADA file or ZIP file into the pack given to
+  // the constructor.
+  bool ImportFile(const FilePath& filename, Transform* parent,
+                  ParamFloat* animation_input);
+
+  // Access to the filenames of the original data for texture and
+  // sound assets imported when ImportFile was called.  These will
+  // only return results after an import if the keep_original_data
+  // option was set to true when the Collada object was created.
+  std::vector<FilePath> GetOriginalDataFilenames() const;
+  const std::string& GetOriginalData(const FilePath& filename) const;
+
+ private:
+  // Imports the given ZIP file into the given pack.
+  bool ImportZIP(const FilePath& filename, Transform* parent,
+                 ParamFloat* animation_input);
+
+  // Imports the given COLLADA file (.DAE) into the current pack.
+  bool ImportDAE(const FilePath& filename,
+                 Transform* parent,
+                 ParamFloat* animation_input);
+
+  // Imports the given FCDocument (already loaded) into the current pack.
+  bool ImportDAEDocument(FCDocument* doc,
+                         bool fc_status,
+                         Transform* parent,
+                         ParamFloat* animation_input);
+
+  // Creates the instance tree corresponding to the collada scene node DAG.
+  // A separate NodeInstance is created every time a particular node is
+  // traversed. The caller must destroy the returned NodeInstance.
+  static NodeInstance *CreateInstanceTree(FCDSceneNode *node);
+
+  // Recursively imports a tree of nodes from FCollada, rooted at the
+  // given node, into the O3D scene.
+  void ImportTree(NodeInstance *instance,
+                  Transform* parent,
+                  ParamFloat* animation_input);
+
+  // Recursively imports a tree of instances (shapes, etc..) from FCollada,
+  // rooted at the given node, into the O3D scene. This is a separate step
+  // from ImportTree because various kinds of instances can reference other
+  // parts of the tree.
+  void ImportTreeInstances(FCDocument* doc,
+                           NodeInstance* instance);
+
+  bool BuildFloatAnimation(ParamFloat* result,
+                           FCDAnimated* animated,
+                           const char* qualifier,
+                           ParamFloat* animation_input,
+                           float output_scale,
+                           float default_value);
+
+  bool BuildFloat3Animation(ParamFloat3* result, FCDAnimated* animated,
+                            ParamFloat* animation_input,
+                            const Float3& default_value);
+
+  ParamMatrix4* BuildComposition(FCDTMatrix* transform,
+                                 ParamMatrix4* input_matrix,
+                                 ParamFloat* animation_input);
+
+  ParamMatrix4* BuildComposition(const Matrix4& matrix,
+                                 ParamMatrix4* input_matrix);
+
+  ParamMatrix4* BuildTranslation(FCDTTranslation* transform,
+                                 ParamMatrix4* input_matrix,
+                                 ParamFloat* animation_input);
+
+  ParamMatrix4* BuildRotation(FCDTRotation* transform,
+                              ParamMatrix4* input_matrix,
+                              ParamFloat* animation_input);
+
+  ParamMatrix4* BuildScaling(FCDTScale* transform,
+                             ParamMatrix4* input_matrix,
+                             ParamFloat* animation_input);
+
+  // Builds a Transform node corresponding to the transform elements of
+  // a given node.  All transformations (rotation, translation, scale,
+  // etc) are collapsed into a single Transform.
+  Transform* BuildTransform(FCDSceneNode* node,
+                            Transform* parent_transform,
+                            ParamFloat* animation_input);
+
+  // Extracts the various camera parameters from a Collada Camera object and
+  // stored them as Params on an O3D Transform.
+  void BuildCamera(FCDocument* doc,
+                   FCDCamera* camera,
+                   Transform* transform,
+                   FCDSceneNode* parent_node);
+
+  // Gets an O3D shape corresponding to a given FCollada geometry instance.
+  // If the Shape does not exist, Builds one.
+  Shape* GetShape(FCDocument* doc,
+                  FCDGeometryInstance* geom_instance);
+
+  // Builds O3D shape corresponding to a given FCollada geometry instance.
+  Shape* BuildShape(FCDocument* doc,
+                    FCDGeometryInstance* geom_instance,
+                    FCDGeometry* geom,
+                    TranslationMap* translationMap);
+
+  // Gets an O3D skinned shape corresponding to a given FCollada controller
+  // instance. If the Shape does not exist, Builds one.
+  Shape* GetSkinnedShape(FCDocument* doc,
+                         FCDControllerInstance* instance,
+                         NodeInstance *parent_node_instance);
+
+  // Builds O3D skinned shape corresponding to a given FCollada controller
+  // instance.
+  Shape* BuildSkinnedShape(FCDocument* doc,
+                           FCDControllerInstance* instance,
+                           NodeInstance *parent_node_instance);
+
+  // Builds an O3D texture corresponding to a given FCollada surface
+  // parameter.
+  Texture* BuildTexture(FCDEffectParameterSurface* surface);
+
+  // Builds an O3D texture corresponding to a given FCDImage.
+  Texture* BuildTextureFromImage(FCDImage* image);
+
+  // Builds an O3D material from a COLLADA effect and material.  If a
+  // COLLADA-FX (Cg/HLSL) effect is present, it will be used and a programmable
+  // Effect generated.  If not, an attempt is made to use one of the fixed-
+  // function profiles if present (eg., Constant, Lambert).
+  Material* BuildMaterial(FCDocument* doc, FCDMaterial* material);
+
+  // Gets an O3D effect correpsonding to a given FCollada effect. If the
+  // effect does not already exist it is created.
+  Effect* GetEffect(FCDocument* doc, FCDEffect* effect);
+
+  // Builds an O3D effect from a COLLADA effect and material.  If a
+  // COLLADA-FX (Cg/HLSL) effect is present, it will be used and a programmable
+  // Effect generated.  If not, an attempt is made to use one of the fixed-
+  // function profiles if present (eg., Constant, Lambert).
+  Effect* BuildEffect(FCDocument* doc, FCDEffect* effect);
+
+  // Copies the texture sampler states from an FCollada sampler to an O3D
+  // sampler.
+  void SetSamplerStates(FCDEffectParameterSampler* effect_sampler,
+                        Sampler* o3d_sampler);
+
+  // Converts the given COLLADA pass state into one or more state
+  // parameters on the given O3D state object.
+  void AddRenderState(FCDEffectPassState* pass_state, State* state);
+
+  // Sets the O3D culling state based on the OpenGL-style states that
+  // COLLADA-FX uses, cached in cull_enabled_, cull_front_ and front_cw_.
+  void UpdateCullingState(State* state);
+
+  // Sets an O3D parameter value from a given FCollada effect parameter.
+  bool SetParamFromFCEffectParam(ParamObject *param_object,
+                                 const String &param_name,
+                                 FCDEffectParameter *fc_param);
+
+  // Sets the value of a Param on the given ParamObject from an FCollada
+  // standard-profile effect parameter.  If the FCollada parameter
+  // contains a texture, the sampler_param_name and channel is used to set
+  // a Sampler Param in o3d from the surface.  If not, the
+  // color_param_name is used to create set a vector Param value.
+  void SetParamFromStandardEffectParam(FCDEffectStandard* effect_standard,
+                                       ParamObject* param_object,
+                                       const char* color_param_name,
+                                       const char* sampler_param_name,
+                                       FCDEffectParameter* color_param,
+                                       int channel);
+
+  // Sets the values of shape parameters from a given FCollada material node.
+  // If a corresponding shape parameter is not found, the FCollada parameter
+  // is ignored.
+  void SetParamsFromMaterial(FCDMaterial* material, ParamObject* param_object);
+
+  // Finds a node instance corresponding to a scene node. Since a particular
+  // scene node can be instanced multiple times, this will return an arbitrary
+  // instance.
+  NodeInstance *FindNodeInstance(FCDSceneNode *node);
+
+  // Finds the node instance corresponding to a scene node if it is not
+  // instanced, by following the only parent of the nodes until it reaches the
+  // root. This will return NULL if the node can't be found, or if the node is
+  // instanced more than once.
+  NodeInstance *FindNodeInstanceFast(FCDSceneNode *node);
+
+  // Clears out any residual data from the last import.  Doesn't
+  // affect the Pack or the options, just intermediate data structures
+  // in this object.
+  void ClearData();
+
+  // Gets a dummy effect or creates one if none exists.
+  Effect* GetDummyEffect();
+
+  // Gets a dummy material or creates one if none exists.
+  Material* GetDummyMaterial();
+
+  ServiceLocator* service_locator_;
+
+  // The object from which error status is retreived.
+  IErrorStatus* error_status_;
+
+  // The Pack into which newly-created nodes will be placed.
+  Pack* pack_;
+
+  // The import options to use;
+  Options options_;
+
+  // The effect used if we can't create an effect.
+  Effect* dummy_effect_;
+
+  // The material used if we can't create a material.
+  Material* dummy_material_;
+
+  // The root of the instance node tree.
+  NodeInstance* instance_root_;
+
+  // A map of the Textures created by the importer, indexed by filename.
+  std::map<const std::wstring, Texture*> textures_;
+
+  // A map containing the original data (still in original format)
+  // used to create the textures, sounds, etc., indexed by filename.
+  typedef std::map<FilePath, std::string> OriginalDataMap;
+  OriginalDataMap original_data_;
+
+  // A map of the Effects created by the importer, indexed by DAE id.
+  std::map<const std::string, Effect*> effects_;
+
+  // A map of the Shapes created by the importer, indexed by DAE id.
+  std::map<const std::string, Shape*> shapes_;
+
+  // A map of the Skinned Shapes created by the importer, indexed by DAE id.
+  std::map<const std::string, Shape*> skinned_shapes_;
+
+  // A map of the Materials created by the importer, indexed by DAE id.
+  std::map<const std::string, Material*> materials_;
+
+  // All the errors accumlated during loading.
+  String errors_;
+
+  // The absolute path to the top of the model hierarchy, to use for
+  // determining the relative paths to other files.
+  FilePath base_path_;
+
+  ColladaZipArchive *collada_zip_archive_;
+  // Some temporaries used by the state importer
+  bool cull_enabled_;
+  bool cull_front_;
+  bool front_cw_;
+
+  int unique_filename_counter_;
+
+  DISALLOW_COPY_AND_ASSIGN(Collada);
+};
+}
+#endif  // O3D_IMPORT_CROSS_COLLADA_H_
diff --git a/o3d/import/cross/collada_conditioner.cc b/o3d/import/cross/collada_conditioner.cc
new file mode 100644
index 0000000..484865f
--- /dev/null
+++ b/o3d/import/cross/collada_conditioner.cc
@@ -0,0 +1,578 @@
+/*
+ * 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 "import/cross/precompile.h"
+
+#include "import/cross/collada_conditioner.h"
+
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/string_util.h"
+#include "compiler/technique/technique_parser.h"
+#include "core/cross/error.h"
+#include "core/cross/types.h"
+#include "import/cross/collada.h"
+#include "import/cross/collada_zip_archive.h"
+#include "utils/cross/file_path_utils.h"
+#include "utils/cross/temporary_file.h"
+
+namespace o3d {
+namespace {
+FUDaeTextureFilterFunction::FilterFunction LookupFilterFunction(
+    const char* name) {
+  struct {
+    const char* name;
+    FUDaeTextureFilterFunction::FilterFunction func;
+  } functions[] = {
+    "None", FUDaeTextureFilterFunction::NONE,
+    "Linear", FUDaeTextureFilterFunction::LINEAR,
+    "Point", FUDaeTextureFilterFunction::NEAREST,  // DX
+    "Nearest", FUDaeTextureFilterFunction::NEAREST,  // GL
+    "LinearMipmapLinear", FUDaeTextureFilterFunction::LINEAR_MIPMAP_LINEAR,
+    "LinearMipmapNearest", FUDaeTextureFilterFunction::LINEAR_MIPMAP_NEAREST,
+    "NearestMipmapNearest", FUDaeTextureFilterFunction::LINEAR_MIPMAP_NEAREST,
+    "NearestMipmapLinear", FUDaeTextureFilterFunction::NEAREST_MIPMAP_LINEAR,
+    // TODO: Once FCollada supports the COLLADA v1.5 spec,
+    // turn this on.
+    // "Anisotropic", FUDaeTextureFilterFunction::ANISOTROPIC,
+  };
+  for (int i = 0; i < sizeof(functions) / sizeof(functions[0]); ++i) {
+    if (!base::strcasecmp(functions[i].name, name)) {
+      return functions[i].func;
+    }
+  }
+  return FUDaeTextureFilterFunction::UNKNOWN;
+}
+
+#undef CLAMP
+
+FUDaeTextureWrapMode::WrapMode LookupWrapMode(const char* name) {
+  struct {
+    const char* name;
+    FUDaeTextureWrapMode::WrapMode mode;
+  } modes[] = {
+    "None", FUDaeTextureWrapMode::NONE,
+    // DX-style names:
+    "Wrap", FUDaeTextureWrapMode::WRAP,
+    "Mirror", FUDaeTextureWrapMode::MIRROR,
+    "Clamp", FUDaeTextureWrapMode::CLAMP,
+    "Border", FUDaeTextureWrapMode::BORDER,
+    // GL-style names:
+    "Repeat", FUDaeTextureWrapMode::WRAP,
+    "MirroredRepeat", FUDaeTextureWrapMode::MIRROR,
+    "ClampToEdge", FUDaeTextureWrapMode::CLAMP,
+    "ClampToBorder", FUDaeTextureWrapMode::BORDER,
+  };
+  for (int i = 0; i < sizeof(modes) / sizeof(modes[0]); ++i) {
+    if (!base::strcasecmp(modes[i].name, name)) {
+      return modes[i].mode;
+    }
+  }
+  return FUDaeTextureWrapMode::UNKNOWN;
+}
+
+FCDEffectParameter* FindParameter(FCDMaterial* material, const char* name) {
+  for (size_t i = 0; i < material->GetEffectParameterCount(); ++i) {
+    FCDEffectParameter* p = material->GetEffectParameter(i);
+    if (!strcmp(p->GetReference(), name)) {
+      return p;
+    }
+  }
+  return NULL;
+}
+
+void SetSamplerStates(const SamplerState& sampler,
+                      FCDEffectParameterSampler* sampler_out) {
+  sampler_out->SetReference(sampler.name.c_str());
+  sampler_out->SetMinFilter(LookupFilterFunction(sampler.min_filter.c_str()));
+  sampler_out->SetMagFilter(LookupFilterFunction(sampler.mag_filter.c_str()));
+  sampler_out->SetMipFilter(LookupFilterFunction(sampler.mip_filter.c_str()));
+  sampler_out->SetWrapS(LookupWrapMode(sampler.address_u.c_str()));
+  sampler_out->SetWrapT(LookupWrapMode(sampler.address_u.c_str()));
+
+  // TODO: Once FCollada supports the COLLADA v1.5 spec, turn this on.
+  // sampler_out->SetMaxAnisotropy(atoi(sampler.max_anisotropy.c_str()));
+}
+
+const PassDeclaration* FindValidTechnique(
+    const TechniqueDeclarationList& technique_list) {
+
+  // Look for a ps2_0/vs2_0 technique, or an arbfp1/arbvp1 technique
+  TechniqueDeclarationList::const_iterator i;
+  for (i = technique_list.begin(); i != technique_list.end(); ++i) {
+    // Skip all multi-pass techniques
+    if (i->pass.size() != 1) continue;
+
+    const PassDeclaration& pass = i->pass[0];
+    if (pass.vertex_shader_profile == "vs_2_0" &&
+        pass.fragment_shader_profile == "ps_2_0" ||
+        pass.vertex_shader_profile == "arbvp1" &&
+        pass.fragment_shader_profile == "arbfp1") {
+      return &pass;
+    }
+  }
+  return NULL;
+}
+
+bool IsColumnMajor(const PassDeclaration* pass) {
+  return pass->vertex_shader_profile == "arbvp1" ||
+      pass->fragment_shader_profile == "arbfp1";
+}
+}  // end anonymous namespace.
+
+ColladaConditioner::ColladaConditioner(ServiceLocator* service_locator)
+    : service_locator_(service_locator) {
+}
+
+ColladaConditioner::~ColladaConditioner() {
+}
+
+bool ColladaConditioner::HandleEmbeddedShaders(FCDEffect* collada_effect,
+                                               FCDEffectProfileFX* profile_fx,
+                                               ColladaZipArchive* archive) {
+  bool found = false;
+  size_t len = profile_fx->GetTechniqueCount();
+  for (size_t j = 0; j < len && !found; ++j) {
+    FCDEffectTechnique* technique = profile_fx->GetTechnique(j);
+    if (!technique) continue;
+    // We only support single-pass effects (for now).
+    if (technique->GetPassCount() != 1) continue;
+    FCDEffectPass* pass = technique->GetPass(0);
+    if (!pass) continue;
+    FCDEffectPassShader* vertex_shader = pass->GetVertexShader();
+    if (!vertex_shader) continue;
+    FCDEffectPassShader* fragment_shader = pass->GetFragmentShader();
+    if (!fragment_shader) continue;
+    // Note:  We ignore the compiler targets in the ColladaFX section,
+    // since they are often wrong (ColladaMAX puts ps 3.0/vs 3.0 in,
+    // regardless of the actual shader), and consult the shader file
+    // itself instead.
+    SamplerStateList sampler_list;
+    FCDEffectCode* code = vertex_shader->GetCode();
+    String shader_source_out;
+    if (code->GetType() == FCDEffectCode::CODE) {
+      fstring code_string = code->GetCode();
+      String shader_source_in(WideToUTF8(code_string.c_str()));
+      FilePath stdin_path(FILE_PATH_LITERAL("<stdin>"));
+      if (RewriteShader(shader_source_in,
+                        &shader_source_out,
+                        stdin_path,
+                        &sampler_list,
+                        NULL,
+                        NULL)) {
+        found = true;
+      }
+      code->SetCode(UTF8ToWide(shader_source_out).c_str());
+    } else if (code->GetType() == FCDEffectCode::INCLUDE) {
+      FilePath file_path(WideToFilePath(code->GetFilename().c_str()));
+      TemporaryFile temp_file;
+      if (!TemporaryFile::Create(&temp_file)) {
+        O3D_ERROR(service_locator_) << "Unable to create temporary file '"
+                                    << FilePathToUTF8(temp_file.path()).c_str()
+                                    << "' for rewriting shader.";
+        return false;
+      }
+      if (!RewriteShaderFile(archive,
+                             file_path,
+                             temp_file.path(),
+                             &sampler_list,
+                             NULL,
+                             NULL)) {
+        return false;
+      }
+
+      // Read the shader from the temp file, and add it to the output map.
+      String shader_source;
+      if (!file_util::ReadFileToString(temp_file.path(), &shader_source)) {
+        O3D_ERROR(service_locator_) << "Unable to read temporary file.";
+        return false;
+      }
+      code->SetCode(UTF8ToWide(shader_source).c_str());
+    }
+  }
+
+  if (!found) {
+    String effect_name = WideToUTF8(collada_effect->GetName().c_str());
+    O3D_ERROR(service_locator_) << "No valid technique found for effect \""
+                                << effect_name << "\".";
+    return false;
+  }
+  return true;
+}
+
+// This non-standard effect technique (NV_import) is the one used by
+// 3ds Max when exporting files using native DX materials, so
+// unfortunately we have to support it.
+bool ColladaConditioner::HandleNVImport(FCDocument* doc,
+                                        FCDEffect* collada_effect,
+                                        const FUUri& original_uri,
+                                        ColladaZipArchive* archive) {
+  FCDExtra* extra = collada_effect->GetExtra();
+  // There is no actual type tag in the XML, but FCollada constructs one
+  // for us anyway.
+  if (extra && extra->GetTypeCount() > 0) {
+    FCDEType* type = extra->GetType(0);
+    if (type) {
+      FCDETechnique* technique = type->FindTechnique("NV_import");
+      if (technique) {
+        FCDENode* node = technique->FindChildNode("import");
+        if (node) {
+          FCDEAttribute* url_attrib = node->FindAttribute("url");
+          if (url_attrib) {
+            FUFileManager* mgr = doc->GetFileManager();
+            DCHECK(mgr != NULL);
+            // Escape any %hex values in the URL, resolve it relative
+            // to the document root, and convert it to an absolute path.
+            fstring url = FUXmlParser::XmlToString(url_attrib->GetValue());
+            FUUri effect_uri = original_uri.Resolve(url);
+            fstring path = effect_uri.GetAbsolutePath();
+
+            FilePath in_filename(WideToFilePath(path.c_str()));
+            TemporaryFile temp_file;
+            if (!TemporaryFile::Create(&temp_file)) {
+              O3D_ERROR(service_locator_) << "Unable to create temporary file.";
+            }
+            SamplerStateList sampler_list;
+            // Check that the file exists; error if not.
+            if (!mgr->FileExists(path)) {
+              O3D_ERROR(service_locator_) << "Shader file \""
+                                          << WideToUTF8(path.c_str()).c_str()
+                                          << "\" does not exist.";
+              return false;
+            }
+
+            String vs_entry;
+            String ps_entry;
+            if (!RewriteShaderFile(archive,
+                                   in_filename,
+                                   temp_file.path(),
+                                   &sampler_list,
+                                   &vs_entry,
+                                   &ps_entry)) {
+              return false;
+            }
+
+            // Create a new HLSL profile to hold the rewritten effect.
+            FCDEffectProfile* profile =
+                collada_effect->AddProfile(FUDaeProfileType::HLSL);
+            FCDEffectProfileFX* profile_fx =
+                down_cast<FCDEffectProfileFX*>(profile);
+            // Move the shader file to the COLLADA-FX section.
+            FCDEffectTechnique* fx_technique = profile_fx->AddTechnique();
+
+            FCDEffectCode* code = profile_fx->AddCode();
+
+            // Read the shader from the temp file, and add it to the
+            // output map.
+            String shader_source;
+            if (!file_util::ReadFileToString(temp_file.path(),
+                                             &shader_source)) {
+              O3D_ERROR(service_locator_) << "Unable to read temporary file.";
+              return false;
+            }
+
+            // Set the embedded code to the rewritten shader.
+            code->SetCode(UTF8ToWide(shader_source).c_str());
+
+            FCDEffectPass* pass = fx_technique->AddPass();
+            FCDEffectPassShader* vertex_shader = pass->AddVertexShader();
+            FCDEffectPassShader* fragment_shader =
+                pass->AddFragmentShader();
+
+            vertex_shader->SetCode(code);
+            vertex_shader->SetName(vs_entry.c_str());
+
+            fragment_shader->SetCode(code);
+            fragment_shader->SetName(ps_entry.c_str());
+
+            // Change the setparams
+            SamplerStateList::const_iterator it;
+            for (it = sampler_list.begin(); it != sampler_list.end(); ++it) {
+              // Create a <sampler> tag.
+              FCDEffectParameterSampler* sampler =
+                  down_cast<FCDEffectParameterSampler*>(
+                      profile->AddEffectParameter(
+                          FCDEffectParameter::SAMPLER));
+              LOG_ASSERT(sampler != 0);
+              // Set the sampler parameters from the ones found in
+              // the FX file.
+              SetSamplerStates(*it, sampler);
+            }
+
+            // For each material which uses this effect,
+            FCDMaterialLibrary* lib = doc->GetMaterialLibrary();
+            for (int i = 0; i < lib->GetEntityCount(); ++i) {
+              FCDMaterial* material = lib->GetEntity(i);
+              LOG_ASSERT(material != 0);
+              if (material->GetEffect() == collada_effect) {
+                // For each sampler in the FX file,
+                SamplerStateList::const_iterator it;
+                for (it = sampler_list.begin();
+                     it != sampler_list.end();
+                     ++it) {
+                  // Create a <sampler> tag.
+                  FCDEffectParameterSampler* sampler =
+                      down_cast<FCDEffectParameterSampler*>(
+                          material->AddEffectParameter(
+                              FCDEffectParameter::SAMPLER));
+                  LOG_ASSERT(sampler != 0);
+                  // Set the sampler states from FX file states
+                  SetSamplerStates(*it, sampler);
+                  // Set this sampler to be a modifier, so it appears
+                  // as a <setparam> tag in the COLLADA file.
+                  sampler->SetModifier();
+                  // Set its surface to be the mapping from the texture
+                  // attribute of the sampler_state in the FX file.
+                  FCDEffectParameter* surface = FindParameter(
+                      material, it->texture.c_str());
+                  if (surface && surface->GetType() ==
+                      FCDEffectParameter::SURFACE) {
+                    sampler->SetSurface(
+                        down_cast<FCDEffectParameterSurface*>(surface));
+                  }
+                }
+              }
+            }
+
+            // Remove the NV_import technique from the COLLADA DOM.
+            technique->Release();
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// Verifies that all shaders conform to O3D's shader language
+// (intersection of Cg and HLSL), and fix the shader and image file URLs
+// to be relative to the output file root.
+bool ColladaConditioner::ConditionDocument(FCDocument* doc,
+                                           ColladaZipArchive* archive) {
+  FUUri original_uri = doc->GetFileUrl();
+  FCDEffectLibrary* effectLibrary = doc->GetEffectLibrary();
+
+  for (size_t i = 0; i < effectLibrary->GetEntityCount(); ++i) {
+    FCDEffect* collada_effect = effectLibrary->GetEntity(i);
+    DCHECK(collada_effect != NULL);
+    FCDEffectProfile* profile =
+        collada_effect->FindProfile(FUDaeProfileType::HLSL);
+    if (!profile) {
+      profile = collada_effect->FindProfile(FUDaeProfileType::CG);
+    }
+    if (profile) {
+      // Handle embedded shaders.
+      FCDEffectProfileFX* profile_fx =
+          static_cast<FCDEffectProfileFX*>(profile);
+      if (!HandleEmbeddedShaders(collada_effect, profile_fx, archive)) {
+        return false;
+      }
+    } else {
+      if (!HandleNVImport(doc, collada_effect, original_uri, archive)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// Rewrites the given shader file to conform to o3d specs.  This
+// function finds a valid ps2.0/vs2.0 or arbvp/fp technique, writes
+// out the entry points in our comment format, and writes out the
+// shader without technique blocks.  Returns false if in_filename
+// can't be opened for reading, out_filename can't be opened for
+// writing, or if the shader is not valid (see RewriteShader).  If the
+// archive is non-NULL, reads its input from the given zip archive
+// instead of from the file system.
+bool ColladaConditioner::RewriteShaderFile(ColladaZipArchive* archive,
+                                           const FilePath& in_filename,
+                                           const FilePath& out_filename,
+                                           SamplerStateList* sampler_list,
+                                           String* vs_entry,
+                                           String* ps_entry) {
+  FilePath input_file = in_filename;
+  TemporaryFile temporary_output_file;
+  TemporaryFile temporary_input_file;
+  if (!TemporaryFile::Create(&temporary_output_file)) {
+    O3D_ERROR(service_locator_) << "Unable to create temporary file.";
+    return false;
+  }
+  if (archive) {
+    if (!TemporaryFile::Create(&temporary_input_file)) {
+      O3D_ERROR(service_locator_) << "Unable to create temporary file.";
+      return false;
+    }
+    input_file = temporary_input_file.path();
+    size_t size = 0;
+    char* contents = archive->GetColladaAssetData(FilePathToUTF8(in_filename),
+                                                  &size);
+    if (file_util::WriteFile(input_file, contents, size) == -1) {
+      O3D_ERROR(service_locator_) << "Unable to write to temporary file.";
+      return false;
+    }
+  }
+  if (!PreprocessShaderFile(input_file, temporary_output_file.path())) {
+    return false;
+  }
+  String shader_source_in;
+  if (!file_util::ReadFileToString(temporary_output_file.path(),
+                                   &shader_source_in)) {
+    O3D_ERROR(service_locator_) << "Unable to read temporary file.";
+    return false;
+  }
+
+  String shader_source_out;
+  if (!RewriteShader(shader_source_in,
+                     &shader_source_out,
+                     in_filename,
+                     sampler_list,
+                     vs_entry,
+                     ps_entry)) {
+    return false;
+  }
+
+  if (file_util::WriteFile(out_filename,
+                           shader_source_out.c_str(),
+                           shader_source_out.size())  == -1) {
+    O3D_ERROR(service_locator_) << "Couldn't write temporary shader file "
+                                << FilePathToUTF8(out_filename).c_str();
+    return false;
+  }
+  return true;
+}
+
+// Rewrites the given shader to conform to o3d specs.
+// This function finds a valid ps2.0/vs2.0 or arbvp/fp technique,
+// strips the technique block from the input shader, and adds the
+// vertex and fragment shader entry points in our comment format.
+// Returns false if no valid technique could be found, or if the
+// resulting shader cannot not be compiled as both HLSL and Cg.
+bool ColladaConditioner::RewriteShader(const String& shader_source_in,
+                                       String* shader_source_out,
+                                       const FilePath& in_filename,
+                                       SamplerStateList* sampler_list,
+                                       String* ps_entry,
+                                       String* vs_entry) {
+  TechniqueDeclarationList technique_list;
+  bool column_major;
+
+  // Parse out the technique block and samplers from the file
+  String error_string;
+  if (!ParseFxString(shader_source_in,
+                     shader_source_out,
+                     sampler_list,
+                     &technique_list,
+                     &error_string)) {
+    O3D_ERROR(service_locator_) << error_string;
+    return false;
+  }
+
+  const PassDeclaration* pass = FindValidTechnique(technique_list);
+
+  if (!pass) {
+    O3D_ERROR(service_locator_)
+        << "Couldn't find compatible technique in effect file \""
+        << FilePathToUTF8(in_filename).c_str() << "\".";
+    return false;
+  }
+
+  if (!CompileHLSL(shader_source_out->c_str(),
+                   pass->vertex_shader_entry,
+                   pass->fragment_shader_entry)) {
+    O3D_ERROR(service_locator_) << "Shader file \""
+                                << FilePathToUTF8(in_filename).c_str()
+                                << "\" could not be compiled as HLSL.\n";
+    return false;
+  }
+
+  if (!CompileCg(in_filename,
+                 shader_source_out->c_str(),
+                 pass->vertex_shader_entry,
+                 pass->fragment_shader_entry)) {
+    O3D_ERROR(service_locator_) << "Shader file \""
+                                << FilePathToUTF8(in_filename).c_str()
+                                << "\" could not be compiled as Cg.\n";
+    return false;
+  }
+
+  if (vs_entry) *vs_entry = pass->vertex_shader_entry;
+  if (ps_entry) *ps_entry = pass->fragment_shader_entry;
+  column_major = IsColumnMajor(pass);
+  *shader_source_out += "// #o3d VertexShaderEntryPoint ";
+  *shader_source_out += pass->vertex_shader_entry + "\n";
+  *shader_source_out += "// #o3d PixelShaderEntryPoint ";
+  *shader_source_out += pass->fragment_shader_entry + "\n";
+  *shader_source_out += "// #o3d MatrixLoadOrder ";
+  *shader_source_out += column_major ? "ColumnMajor" : "RowMajor";
+  *shader_source_out += "\n";
+
+  return true;
+}
+
+bool ColladaConditioner::CompileCg(const FilePath& filename,
+                                   const String& shader_source,
+                                   const String& vs_entry,
+                                   const String& ps_entry) {
+  bool retval = false;
+  String shader_source_cg = shader_source;
+  shader_source_cg +=
+      "technique t {\n"
+      "  pass p {\n"
+      "    VertexShader = compile arbvp1 " + vs_entry + "();\n"
+      "    PixelShader = compile arbfp1 " + ps_entry + "();\n"
+      "  }\n"
+      "};\n";
+
+  // Create a Cg context in which to compile the given .FX file.
+  CGcontext context = cgCreateContext();
+
+  cgGLRegisterStates(context);
+
+  // Create a Cg effect from the FX file.
+  CGeffect effect = cgCreateEffect(context, shader_source_cg.c_str(), NULL);
+  if (!effect || !cgIsEffect(effect) || cgGetError() != CG_NO_ERROR) {
+    const char* errors = cgGetLastListing(context);
+    String message = FilePathToUTF8(filename) + ":\n";
+    if (errors) {
+      message += String(errors) + "\n";
+    } else {
+      message += "Unknown Cg compilation error.\n";
+    }
+    O3D_ERROR(service_locator_) << message;
+  } else {
+    cgDestroyEffect(effect);
+    retval = true;
+  }
+  cgDestroyContext(context);
+  return retval;
+}
+}  // namespace o3d
diff --git a/o3d/import/cross/collada_conditioner.h b/o3d/import/cross/collada_conditioner.h
new file mode 100644
index 0000000..72df84d
--- /dev/null
+++ b/o3d/import/cross/collada_conditioner.h
@@ -0,0 +1,136 @@
+/*
+ * 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.
+ */
+
+
+// This file contains the declarations for the functions in the
+// O3D COLLADA conditioner namespace.  These functions do most of
+// the actual work of conditioning and packagaging a DAE file for use
+// in O3D.
+
+#ifndef O3D_IMPORT_CROSS_COLLADA_CONDITIONER_H_
+#define O3D_IMPORT_CROSS_COLLADA_CONDITIONER_H_
+
+#include "core/cross/types.h"
+#include "compiler/technique/technique_structures.h"
+
+class FCDEffect;
+class FCDEffectProfileFX;
+class FCDocument;
+class FUUri;
+class FilePath;
+
+namespace o3d {
+
+class ColladaZipArchive;
+class ServiceLocator;
+
+class ColladaConditioner {
+ public:
+  explicit ColladaConditioner(ServiceLocator* service_locator);
+  ~ColladaConditioner();
+
+  // This function conditions the given document for use in O3D.  This
+  // mainly includes checking that the referenced shaders compile
+  // against both the Cg (all platforms) and D3D (windows only)
+  // runtimes, and converting the shaders to the common shader
+  // language used by O3D.  The converts all the shaders to inline
+  // "code" shaders instead of "included" shaders.  It also handles
+  // converting "NV_Import" shaders produced by 3dsMax to something
+  // o3d can read.  Returns false on failure.  If archive is non-NULL,
+  // then it attempts to read shader files from the give zip archive
+  // instead of from the disk.
+  bool ConditionDocument(FCDocument* doc, ColladaZipArchive* archive);
+
+  // This takes the given shader file and rewrites it to have the
+  // proper form for O3D.  If the archive parameter is non-NULL, then
+  // the input file is read from the archive instead of from the
+  // regular filesystem.
+  bool RewriteShaderFile(ColladaZipArchive* archive,
+                         const FilePath& in_filename,
+                         const FilePath& out_filename,
+                         SamplerStateList* sampler_list,
+                         String* vs_entry,
+                         String* ps_entry);
+
+  // This test-compiles the given shader source with the HLSL
+  // compiler, if there is one available on the platform.  This
+  // function is implemented separately for each platform.  If there
+  // is no HLSL compiler available on this platform, this function
+  // returns 'true'.
+  bool CompileHLSL(const String& shader_source,
+                   const String& vs_entry,
+                   const String& ps_entry);
+
+  // This test-compiles the given shader source with the Cg compiler,
+  // if there is one available on the platform.  This function is
+  // implemented separately for each platform.  If there is no Cg
+  // compiler available on this platform, this function returns
+  // 'true'.
+  bool CompileCg(const FilePath& filename,
+                 const String& shader_source,
+                 const String& vs_entry,
+                 const String& ps_entry);
+
+ protected:
+  // This preprocesses the given file using the Cgc compiler.  It
+  // doesn't compile the shader, it just preprocesses it.  This is
+  // implemented separately for each platform, since it invokes the
+  // compiler as a separate process.
+  bool PreprocessShaderFile(const FilePath& in_filename,
+                            const FilePath& out_filename);
+
+  // This takes the given COLLADA shader source code and rewrites it
+  // to have the proper form for O3D.  It finds the entry points and
+  // sets vs_entry and ps_entry to what it finds.
+  bool RewriteShader(const String& shader_source_in,
+                     String* shader_source_out,
+                     const FilePath& in_filename,
+                     SamplerStateList* sampler_list,
+                     String* vs_entry,
+                     String* ps_entry);
+
+  // Handle all the embedded shaders in the document.
+  bool HandleEmbeddedShaders(FCDEffect* collada_effect,
+                             FCDEffectProfileFX* profile_fx,
+                             ColladaZipArchive* archive);
+
+  bool HandleNVImport(FCDocument* doc,
+                      FCDEffect* collada_effect,
+                      const FUUri& original_uri,
+                      ColladaZipArchive* archive);
+ private:
+  ServiceLocator* service_locator_;
+
+  DISALLOW_COPY_AND_ASSIGN(ColladaConditioner);
+};
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_COLLADA_CONDITIONER_H_
diff --git a/o3d/import/cross/collada_conditioner_stub.cc b/o3d/import/cross/collada_conditioner_stub.cc
new file mode 100644
index 0000000..6c1be1e
--- /dev/null
+++ b/o3d/import/cross/collada_conditioner_stub.cc
@@ -0,0 +1,90 @@
+/*
+ * 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 "import/cross/precompile.h"
+
+#include "import/cross/collada_conditioner.h"
+
+#include "core/cross/service_locator.h"
+#include "import/cross/collada.h"
+
+namespace o3d {
+ColladaConditioner::ColladaConditioner(ServiceLocator* service_locator)
+    : service_locator_(service_locator) {
+}
+
+ColladaConditioner::~ColladaConditioner() {
+}
+
+bool ColladaConditioner::HandleEmbeddedShaders(FCDEffect* collada_effect,
+                                               FCDEffectProfileFX* profile_fx,
+                                               ColladaZipArchive* archive) {
+  return true;
+}
+
+bool ColladaConditioner::HandleNVImport(FCDocument* doc,
+                                        FCDEffect* collada_effect,
+                                        const FUUri& original_uri,
+                                        ColladaZipArchive* archive) {
+  return true;
+}
+
+bool ColladaConditioner::ConditionDocument(FCDocument* doc,
+                                           ColladaZipArchive* archive) {
+  return true;
+}
+
+bool ColladaConditioner::RewriteShaderFile(ColladaZipArchive* archive,
+                                           const FilePath& in_filename,
+                                           const FilePath& out_filename,
+                                           SamplerStateList* sampler_list,
+                                           String* vs_entry,
+                                           String* ps_entry) {
+  return true;
+}
+
+bool ColladaConditioner::RewriteShader(const String& shader_source_in,
+                                       String* shader_source_out,
+                                       const FilePath& in_filename,
+                                       SamplerStateList* sampler_list,
+                                       String* ps_entry,
+                                       String* vs_entry) {
+  return true;
+}
+
+bool ColladaConditioner::CompileCg(const FilePath& filename,
+                                   const String& shader_source,
+                                   const String& vs_entry,
+                                   const String& ps_entry) {
+  return true;
+}
+}  // namespace o3d
diff --git a/o3d/import/cross/collada_zip_archive.cc b/o3d/import/cross/collada_zip_archive.cc
new file mode 100644
index 0000000..45bc523
--- /dev/null
+++ b/o3d/import/cross/collada_zip_archive.cc
@@ -0,0 +1,80 @@
+/*
+ * 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.
+ */
+
+
+// A basic C++ wrapper for a collada zip file
+// it looks for the first .dae file in the archive and is able to resolve
+// partial pathnames (from the image URI's in the collada file) to files in the
+// archive
+
+#include "base/string_util.h"
+#include "import/cross/collada_zip_archive.h"
+
+using std::vector;
+using std::string;
+
+namespace o3d {
+
+ColladaZipArchive::ColladaZipArchive(const std::string &zip_filename,
+                                     int *result)
+  : ZipArchive(zip_filename, result) {
+  if (result && (*result == UNZ_OK)) {
+    // look through the archive and locate the first file with a .dae extension
+    vector<ZipFileInfo> infolist;
+    GetInformationList(&infolist);
+
+    bool dae_found = false;
+    for (int i = 0; i < infolist.size(); ++i) {
+      const char *name = infolist[i].name.c_str();
+      int length = strlen(name);
+
+      if (length > 4) {
+        const char *suffix = name + length - 4;
+        if (!base::strcasecmp(suffix, ".dae")) {
+          dae_pathname_ = name;
+          dae_directory_ = dae_pathname_;
+          RemoveLastPathComponent(&dae_directory_);
+          dae_found = true;
+          break;
+        }
+      }
+    }
+
+    if (!dae_found && result) *result = -1;
+  }
+}
+
+// Convert paths relative to the collada file to archive paths
+char  *ColladaZipArchive::GetColladaAssetData(const string &filename,
+                                              size_t *size) {
+  return GetRelativeFileData(filename, dae_directory_, size);
+}
+}  // end namespace o3d
diff --git a/o3d/import/cross/collada_zip_archive.h b/o3d/import/cross/collada_zip_archive.h
new file mode 100644
index 0000000..018b3bf
--- /dev/null
+++ b/o3d/import/cross/collada_zip_archive.h
@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+
+// A basic C++ wrapper for a collada zip file
+// it looks for the first .dae file in the archive and is able to resolve
+// partial pathnames (from the URI's in the collada file) to files in the
+// archive
+
+#ifndef O3D_IMPORT_CROSS_COLLADA_ZIP_ARCHIVE_H_
+#define O3D_IMPORT_CROSS_COLLADA_ZIP_ARCHIVE_H_
+
+#include "import/cross/zip_archive.h"
+
+#include <string>
+#include <vector>
+
+namespace o3d {
+
+class ColladaZipArchive : public ZipArchive {
+ public:
+  ColladaZipArchive(const std::string &zip_filename, int *result);
+
+  // |filename| is taken to be relative to the directory containing the
+  // first collada file found in the archive.  It may contain relative path
+  // elements ("../").  These are the types of file references to images
+  // contained in the collada file.
+  //
+  // Extracts a single file and returns a pointer to the file's content.
+  // Returns NULL if |filename| doesn't match any in the archive
+  // or an error occurs.  The caller must call free() on the returned pointer
+  //
+  virtual char  *GetColladaAssetData(const std::string &filename,
+                                     size_t *size);
+
+  const std::string& GetColladaPath() const { return dae_pathname_; }
+  const std::string& GetColladaDirectory() const { return dae_directory_; }
+
+ protected:
+  std::string dae_pathname_;
+  std::string dae_directory_;
+};
+}  // end namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_COLLADA_ZIP_ARCHIVE_H_
diff --git a/o3d/import/cross/file_output_stream_processor.cc b/o3d/import/cross/file_output_stream_processor.cc
new file mode 100644
index 0000000..3983faa
--- /dev/null
+++ b/o3d/import/cross/file_output_stream_processor.cc
@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+
+
+// This file contains the declaration of class FileOutputStreamProcessor.
+
+#include "base/logging.h"
+#include "import/cross/file_output_stream_processor.h"
+
+namespace o3d {
+FileOutputStreamProcessor::FileOutputStreamProcessor(FILE* file)
+    : file_(file) {
+  DCHECK(file != NULL);
+}
+
+int FileOutputStreamProcessor::ProcessBytes(MemoryReadStream *stream,
+                                            size_t bytes_to_process) {
+  size_t num_written = fwrite(stream->GetDirectMemoryPointer(),
+                              1,
+                              bytes_to_process,
+                              file_);
+  return num_written == bytes_to_process ? 0 : -1;
+}
+}  // namespace o3d
diff --git a/o3d/import/cross/file_output_stream_processor.h b/o3d/import/cross/file_output_stream_processor.h
new file mode 100644
index 0000000..3c04562
--- /dev/null
+++ b/o3d/import/cross/file_output_stream_processor.h
@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+
+// This file contains the declaration of class FileOutputStreamProcessor.
+
+#ifndef O3D_IMPORT_CROSS_FILE_OUTPUT_STREAM_PROCESSOR_H_
+#define O3D_IMPORT_CROSS_FILE_OUTPUT_STREAM_PROCESSOR_H_
+
+#include "import/cross/memory_stream.h"
+
+namespace o3d {
+
+// A StringReader accepts binary data and writes it to a file.
+class FileOutputStreamProcessor : public StreamProcessor {
+ public:
+  explicit FileOutputStreamProcessor(FILE* file);
+
+  virtual int ProcessBytes(MemoryReadStream *stream,
+                           size_t bytes_to_process);
+ private:
+  FILE* file_;
+  DISALLOW_COPY_AND_ASSIGN(FileOutputStreamProcessor);
+};
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_FILE_OUTPUT_STREAM_PROCESSOR_H_
diff --git a/o3d/import/cross/gz_compressor.cc b/o3d/import/cross/gz_compressor.cc
new file mode 100644
index 0000000..2352405
--- /dev/null
+++ b/o3d/import/cross/gz_compressor.cc
@@ -0,0 +1,149 @@
+/*
+ * 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.
+ */
+
+//
+// GzCompressor compresses a byte stream using gzip compression
+// calling the client's ProcessBytes() method with the compressed stream
+//
+
+#include "import/cross/gz_compressor.h"
+
+#include <assert.h>
+#include "import/cross/memory_buffer.h"
+#include "import/cross/memory_stream.h"
+#include "third_party/zlib/files/zutil.h"
+
+const size_t kChunkSize = 16384;
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+GzCompressor::GzCompressor(StreamProcessor *callback_client)
+    : callback_client_(callback_client),
+      stream_is_closed_(false) {
+  strm_.zalloc = Z_NULL;
+  strm_.zfree = Z_NULL;
+  strm_.opaque = Z_NULL;
+
+  // Store this, so we can later check if it's OK to start processing
+  init_result_ = deflateInit2(
+      &strm_,
+      Z_DEFAULT_COMPRESSION,
+      Z_DEFLATED,
+      MAX_WBITS + 16,  // 16 means write out gzip header/trailer
+      DEF_MEM_LEVEL,
+      Z_DEFAULT_STRATEGY);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void GzCompressor::Finalize() {
+  if (!stream_is_closed_) {
+    // Flush the compression stream
+    MemoryReadStream stream(NULL, 0);
+    CompressBytes(&stream, 0, true);
+
+    // Deallocate resources
+    deflateEnd(&strm_);
+    stream_is_closed_ = true;
+  }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+GzCompressor::~GzCompressor() {
+  // Finalize() turns out to be a "nop" if the user has already called it
+  Finalize();
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int GzCompressor::ProcessBytes(MemoryReadStream *stream,
+                               size_t bytes_to_process) {
+  // Basic sanity check
+  if (stream->GetDirectMemoryPointer() == NULL || bytes_to_process == 0) {
+    return -1;
+  }
+
+  return CompressBytes(stream, bytes_to_process, false);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int GzCompressor::CompressBytes(MemoryReadStream *stream,
+                                size_t bytes_to_process,
+                                bool flush) {
+  // Don't even bother trying if we didn't get initialized properly
+  if (init_result_ != Z_OK) return init_result_;
+
+  uint8 out[kChunkSize];
+  int result = Z_OK;
+
+  // Don't try to read more than our stream has
+  int remaining = stream->GetRemainingByteCount();
+  if (bytes_to_process > remaining) {
+    return Z_STREAM_ERROR;
+  }
+
+  // Use direct memory access on the MemoryStream object
+  const uint8 *input_data = stream->GetDirectMemoryPointer();
+  stream->Skip(bytes_to_process);
+
+  // Fill out the zlib z_stream struct
+  strm_.avail_in = bytes_to_process;
+  strm_.next_in = const_cast<uint8*>(input_data);
+
+  // We need to flush the stream when we reach the end
+  int flush_code = flush ? Z_FINISH : Z_NO_FLUSH;
+
+  // Run inflate() on input until output buffer not full
+  do {
+    strm_.avail_out = kChunkSize;
+    strm_.next_out = out;
+
+    result = deflate(&strm_, flush_code);
+
+    // error check here - return error codes if necessary
+    assert(result != Z_STREAM_ERROR);  // state not clobbered
+
+    size_t have = kChunkSize - strm_.avail_out;
+
+    // Callback with the compressed byte stream
+    MemoryReadStream decompressed_stream(out, have);
+    if (have > 0 && callback_client_) {
+      int client_result =
+          callback_client_->ProcessBytes(&decompressed_stream, have);
+      if (client_result != 0) {
+        return client_result;  // propagate callback errors
+      }
+    }
+  } while (strm_.avail_out == 0);
+
+  return result;
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/gz_compressor.h b/o3d/import/cross/gz_compressor.h
new file mode 100644
index 0000000..7c88657
--- /dev/null
+++ b/o3d/import/cross/gz_compressor.h
@@ -0,0 +1,72 @@
+/*
+ * 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.
+ */
+
+//
+// GzCompressor compresses a byte stream using gzip compression
+// calling the client's ProcessBytes() method with the compressed stream
+//
+
+#ifndef O3D_IMPORT_CROSS_GZ_COMPRESSOR_H_
+#define O3D_IMPORT_CROSS_GZ_COMPRESSOR_H_
+
+#include "base/basictypes.h"
+#include "third_party/zlib/files/zlib.h"
+#include "import/cross/memory_stream.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class GzCompressor : public StreamProcessor {
+ public:
+  explicit GzCompressor(StreamProcessor *callback_client);
+  virtual ~GzCompressor();
+
+  virtual int ProcessBytes(MemoryReadStream *stream, size_t bytes_to_process);
+
+  // Must call when all bytes to compress have been sent (with ProcessBytes)
+  void Finalize();
+
+ private:
+  int CompressBytes(MemoryReadStream *stream,
+                    size_t bytes_to_process,
+                    bool flush);
+
+  z_stream strm_;  // low-level zlib state
+  int init_result_;
+  bool stream_is_closed_;
+  StreamProcessor *callback_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(GzCompressor);
+};
+
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_GZ_COMPRESSOR_H_
diff --git a/o3d/import/cross/gz_compressor_test.cc b/o3d/import/cross/gz_compressor_test.cc
new file mode 100644
index 0000000..787ab06
--- /dev/null
+++ b/o3d/import/cross/gz_compressor_test.cc
@@ -0,0 +1,161 @@
+/*
+ * 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 <sys/stat.h>
+#include <string>
+
+#include "core/cross/client.h"
+#include "import/cross/memory_stream.h"
+#include "import/cross/memory_buffer.h"
+#include "import/cross/gz_decompressor.h"
+#include "import/cross/gz_compressor.h"
+#include "tests/common/win/testing_common.h"
+#include "tests/common/cross/test_utils.h"
+
+namespace o3d {
+
+class GzCompressorTest : public testing::Test {
+};
+
+using o3d::MemoryReadStream;
+using o3d::MemoryWriteStream;
+using o3d::GzCompressor;
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class for receiving the decompressed byte stream
+class DecompressorClient : public o3d::StreamProcessor {
+ public:
+  explicit DecompressorClient(size_t uncompressed_byte_size)
+      : buffer_(uncompressed_byte_size),
+        write_stream_(buffer_, uncompressed_byte_size) {}
+
+  virtual int     ProcessBytes(MemoryReadStream *stream,
+                               size_t bytes_to_process) {
+    // Make sure the output stream isn't full yet
+    EXPECT_TRUE(write_stream_.GetRemainingByteCount() >= bytes_to_process);
+
+    // Buffer the decompressed bytes
+    const uint8 *p = stream->GetDirectMemoryPointer();
+    stream->Skip(bytes_to_process);
+    write_stream_.Write(p, bytes_to_process);
+
+    return 0;  // return OK
+  }
+
+  void  VerifyDecompressedOutput(uint8 *original_data) {
+    // Make sure we filled up the output buffer
+    EXPECT_EQ(0, write_stream_.GetRemainingByteCount());
+
+    // Verify decompressed data with the original data we fed into the
+    // compressor
+    EXPECT_EQ(0, memcmp(original_data, buffer_, buffer_.GetLength()));
+  }
+
+ private:
+  size_t uncompressed_byte_size_;
+  MemoryBuffer<uint8> buffer_;
+  MemoryWriteStream write_stream_;
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class for receiving the compressed byte stream
+class CompressorClient : public o3d::StreamProcessor {
+ public:
+  explicit CompressorClient(size_t uncompressed_byte_size)
+      : decompressor_client_(uncompressed_byte_size),
+        decompressor_(&decompressor_client_) {
+  };
+
+  virtual int     ProcessBytes(MemoryReadStream *stream,
+                               size_t bytes_to_process) {
+    // We're receiving compressed bytes here, so feed them back into
+    // the decompressor.  Since we're making a compression / decompression
+    // round trip, we should end up with the same (initial) byte stream
+    // we can verify this at the end
+    int result = decompressor_.ProcessBytes(stream, bytes_to_process);
+
+    // Verify the result code:
+    //  zlib FAQ says Z_BUF_ERROR is OK
+    //  and may occur in the middle of decompressing the stream
+    EXPECT_TRUE(result == Z_OK || result == Z_STREAM_END ||
+                result == Z_BUF_ERROR);
+
+    return 0;  // no error
+  }
+
+  void  VerifyDecompressedOutput(uint8 *original_data) {
+    // Send it on to the client, since its the one with the buffered data
+    decompressor_client_.VerifyDecompressedOutput(original_data);
+  }
+
+ private:
+  DecompressorClient decompressor_client_;
+  o3d::GzDecompressor decompressor_;
+};
+
+
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// int main (int argc, const char * argv[]) {
+TEST_F(GzCompressorTest, RoundTripCompressionDecompression) {
+  // We'll compress this file
+  String filepath = *g_program_path + "/archive_files/keyboard.jpg";
+
+  size_t file_length;
+  uint8 *p = test_utils::ReadFile(filepath.c_str(), &file_length);
+  ASSERT_TRUE(p != NULL);
+
+  MemoryReadStream input_file_stream(p, file_length);
+
+  // Gets callbacks with compressed bytes
+  CompressorClient compressor_client(file_length);
+
+  GzCompressor compressor(&compressor_client);
+
+  // Compress the entire file contents.
+  // |compressor_client| will take the compressed byte stream and send it
+  // directly to a decompressor.
+  //
+  // Since we're making a compression / decompression
+  // round trip, we should end up with the same (initial) byte stream
+  // we can verify this at the end by calling VerifyDecompressedOutput()
+  int result = compressor.ProcessBytes(&input_file_stream, file_length);
+  EXPECT_TRUE(result == Z_OK || result == Z_STREAM_END);
+
+  compressor.Finalize();
+
+  compressor_client.VerifyDecompressedOutput(p);
+
+  free(p);
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/gz_decompressor.cc b/o3d/import/cross/gz_decompressor.cc
new file mode 100644
index 0000000..333a999
--- /dev/null
+++ b/o3d/import/cross/gz_decompressor.cc
@@ -0,0 +1,121 @@
+/*
+ * 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.
+ */
+
+//
+// GzDecompressor decompresses a gzip compressed byte stream
+// calling the client's ProcessBytes() method with the uncompressed stream
+//
+
+#include "import/cross/gz_decompressor.h"
+
+#include <assert.h>
+#include "import/cross/memory_stream.h"
+
+const size_t kChunkSize = 16384;
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+GzDecompressor::GzDecompressor(StreamProcessor *callback_client)
+    : callback_client_(callback_client) {
+  // Initialize inflate state
+  strm_.zalloc = Z_NULL;
+  strm_.zfree = Z_NULL;
+  strm_.opaque = Z_NULL;
+  strm_.avail_in = 0;
+  strm_.next_in = Z_NULL;
+
+  // Store this, so we can later check if it's OK to start processing
+  init_result_ = inflateInit2(&strm_, 31);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+GzDecompressor::~GzDecompressor() {
+  inflateEnd(&strm_);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+int GzDecompressor::ProcessBytes(MemoryReadStream *stream,
+                                 size_t bytes_to_process) {
+  // Don't even bother trying if we didn't get initialized properly
+  if (init_result_ != Z_OK) return init_result_;
+
+  uint8 out[kChunkSize];
+  int result;
+  size_t have;
+
+  // Don't try to read more than our stream has
+  int remaining = stream->GetRemainingByteCount();
+  if (bytes_to_process > remaining) {
+    return Z_STREAM_ERROR;  // could have our own error code, but good enough...
+  }
+
+  // Use direct memory access on the MemoryStream object
+  strm_.avail_in = bytes_to_process;
+  strm_.next_in = const_cast<uint8*>(stream->GetDirectMemoryPointer());
+  stream->Skip(bytes_to_process);
+
+  // Run inflate() on input until output buffer not full
+  do {
+    strm_.avail_out = kChunkSize;
+    strm_.next_out = out;
+
+    result = inflate(&strm_, Z_NO_FLUSH);
+
+    // error check here - return error codes if necessary
+    assert(result != Z_STREAM_ERROR);  /* state not clobbered */
+    switch (result) {
+      case Z_NEED_DICT:
+        result = Z_DATA_ERROR;     /* and fall through */
+
+      case Z_DATA_ERROR:
+      case Z_MEM_ERROR:
+        return result;
+    }
+
+    have = kChunkSize - strm_.avail_out;
+
+    // Callback with the decompressed byte stream
+    MemoryReadStream decompressed_stream(out, have);
+    if (callback_client_) {
+      int client_result =
+          callback_client_->ProcessBytes(&decompressed_stream, have);
+      if (client_result != 0) {
+        return client_result;  // propagate callback errors
+      }
+    }
+  } while (strm_.avail_out == 0);
+
+  return result;
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/gz_decompressor.h b/o3d/import/cross/gz_decompressor.h
new file mode 100644
index 0000000..833a7b3
--- /dev/null
+++ b/o3d/import/cross/gz_decompressor.h
@@ -0,0 +1,65 @@
+/*
+ * 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.
+ */
+
+//
+// GzDecompressor decompresses a gzip compressed byte stream
+// calling the client's ProcessBytes() method with the uncompressed stream
+//
+
+#ifndef O3D_IMPORT_CROSS_GZ_DECOMPRESSOR_H_
+#define O3D_IMPORT_CROSS_GZ_DECOMPRESSOR_H_
+
+#include "base/basictypes.h"
+#include "third_party/zlib/files/zlib.h"
+#include "import/cross/memory_stream.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class GzDecompressor : public StreamProcessor {
+ public:
+  explicit GzDecompressor(StreamProcessor *callback_client);
+  virtual ~GzDecompressor();
+
+  virtual int     ProcessBytes(MemoryReadStream *stream,
+                               size_t bytes_to_process);
+
+ private:
+  z_stream         strm_;  // low-level zlib state
+  int              init_result_;
+  StreamProcessor  *callback_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(GzDecompressor);
+};
+
+}  // namespace o3d
+
+#endif  //  O3D_IMPORT_CROSS_GZ_DECOMPRESSOR_H_
diff --git a/o3d/import/cross/gz_decompressor_test.cc b/o3d/import/cross/gz_decompressor_test.cc
new file mode 100644
index 0000000..af45ecd
--- /dev/null
+++ b/o3d/import/cross/gz_decompressor_test.cc
@@ -0,0 +1,142 @@
+/*
+ * 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 <sys/stat.h>
+#include <algorithm>
+
+#include "core/cross/client.h"
+#include "import/cross/gz_decompressor.h"
+#include "import/cross/memory_buffer.h"
+#include "tests/common/win/testing_common.h"
+#include "tests/common/cross/test_utils.h"
+
+using test_utils::ReadFile;
+
+namespace o3d {
+
+class GzDecompressorTest : public testing::Test {
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Receives bytes from the decompressor and buffers them
+//
+class GzTestClient : public StreamProcessor {
+ public:
+  explicit GzTestClient(size_t uncompressed_size) {
+    buffer_.Allocate(uncompressed_size);
+    stream_.Assign(buffer_, uncompressed_size);
+  }
+
+  virtual int     ProcessBytes(MemoryReadStream *input_stream,
+                               size_t bytes_to_process) {
+    // Buffer the uncompressed bytes we're given
+    const uint8 *p = input_stream->GetDirectMemoryPointer();
+    input_stream->Skip(bytes_to_process);
+
+    size_t bytes_written = stream_.Write(p, bytes_to_process);
+    EXPECT_EQ(bytes_written, bytes_to_process);
+
+    return Z_OK;
+  }
+
+  // When we're done decompressing, we can check the results here
+  uint8 *GetResultBuffer() { return buffer_; }
+  size_t GetResultLength() const { return stream_.GetStreamPosition(); }
+
+ private:
+  MemoryBuffer<uint8> buffer_;
+  MemoryWriteStream stream_;
+};
+
+// Loads a tar.gz file, runs it through the processor.
+// In our callbacks, we verify that we receive three files with known contents
+//
+TEST_F(GzDecompressorTest, LoadGzFile) {
+  String compressed_file = *g_program_path + "/archive_files/keyboard.jpg.gz";
+  String uncompressed_file = *g_program_path + "/archive_files/keyboard.jpg";
+
+  // Read the compressed and uncompressed files into memory.
+  // We can then run the decompressor and check it against the expected
+  // uncompressed data...
+  size_t compressed_size;
+  size_t uncompressed_size;
+  uint8 *compressed_data = ReadFile(compressed_file, &compressed_size);
+  uint8 *expected_uncompressed_data =
+      ReadFile(uncompressed_file, &uncompressed_size);
+
+  ASSERT_TRUE(compressed_data != NULL);
+  ASSERT_TRUE(expected_uncompressed_data != NULL);
+
+  // Gets callbacks for the uncompressed data
+  GzTestClient decompressor_client(uncompressed_size);
+
+  // The class we're testing...
+  GzDecompressor decompressor(&decompressor_client);
+
+  // Now that we've read the compressed file into memory, lets
+  // feed it, a chunk at a time, into the decompressor
+  const int kChunkSize = 512;
+
+  MemoryReadStream compressed_stream(compressed_data, compressed_size);
+  size_t bytes_to_process = compressed_size;
+
+  int result = Z_OK;
+  while (bytes_to_process > 0) {
+    size_t bytes_this_time =
+        bytes_to_process < kChunkSize ? bytes_to_process : kChunkSize;
+
+    result = decompressor.ProcessBytes(&compressed_stream, bytes_this_time);
+    EXPECT_TRUE(result == Z_OK || result == Z_STREAM_END);
+
+    bytes_to_process -= bytes_this_time;
+  }
+
+  // When the decompressor has finished it should return Z_STREAM_END
+  EXPECT_TRUE(result == Z_STREAM_END);
+
+  // Now let's verify that what we just decompressed matches exactly
+  // what's in the reference file...
+
+  // First check that the lengths match
+  EXPECT_EQ(decompressor_client.GetResultLength(), uncompressed_size);
+
+  // Now check the data
+  result = memcmp(decompressor_client.GetResultBuffer(),
+                  expected_uncompressed_data,
+                  uncompressed_size);
+  EXPECT_EQ(0, result);
+
+  free(compressed_data);
+  free(expected_uncompressed_data);
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/iarchive_generator.h b/o3d/import/cross/iarchive_generator.h
new file mode 100644
index 0000000..4f662da
--- /dev/null
+++ b/o3d/import/cross/iarchive_generator.h
@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+
+// This file contains the declaration of class IArchiveGenerator.
+
+#ifndef O3D_IMPORT_CROSS_IARCHIVE_GENERATOR_H_
+#define O3D_IMPORT_CROSS_IARCHIVE_GENERATOR_H_
+
+#include "core/cross/types.h"
+
+namespace o3d {
+
+class MemoryReadStream;
+
+class IArchiveGenerator {
+ public:
+  virtual ~IArchiveGenerator() {
+  }
+
+  // Call AddFile() for each file entry, followed by calls to AddFileBytes()
+  // for the file's data
+  virtual void AddFile(const String& file_name,
+                       size_t file_size) = 0;
+
+  // Call with the file's data (after calling AddFile)
+  // may be called one time will all the file's data, or multiple times
+  // until all the data is provided
+  virtual int AddFileBytes(MemoryReadStream* stream, size_t n) = 0;
+};
+
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_IARCHIVE_GENERATOR_H_
diff --git a/o3d/import/cross/memory_buffer.h b/o3d/import/cross/memory_buffer.h
new file mode 100644
index 0000000..8d5640f
--- /dev/null
+++ b/o3d/import/cross/memory_buffer.h
@@ -0,0 +1,78 @@
+/*
+ * 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.
+ */
+
+
+// A MemoryBuffer object represents an array of type T.
+// Please note that T is really intended to be used
+// for integral types (char, int, float, double)
+// It's very useful when used as a stack-based object or
+// member variable, offering a cleaner, more direct alternative,
+// in some cases, to using smart-pointers in conjunction with operator new
+//
+// Example usage:
+//
+// MemoryBuffer<int> buffer(1024);
+// for (int i = 0; i < 1024; ++i) {
+//   buffer[i] = i;
+// }
+
+#ifndef O3D_IMPORT_CROSS_MEMORY_BUFFER_H_
+#define O3D_IMPORT_CROSS_MEMORY_BUFFER_H_
+
+#include <string.h>
+#include <stdlib.h>
+#include <vector>
+
+#include "base/basictypes.h"
+
+// Allocates an array of type T
+
+template <class T>
+class MemoryBuffer {
+ public:
+  MemoryBuffer() {};
+  explicit MemoryBuffer(size_t num_elems) : vector_(num_elems, 0) { }
+
+  void Allocate(size_t num_elems) { AllocateClear(num_elems); }
+  void AllocateClear(size_t num_elems) { vector_.assign(num_elems, 0); }
+  void Deallocate() { vector_.clear(); }
+  void Clear() { AllocateClear(vector_.size()); }  // sets to all zero values
+  void Resize(size_t n) { vector_.resize(n); }
+  size_t GetLength() { return vector_.size(); }
+  operator T *() { return &vector_[0]; }
+
+ private:
+  std::vector<T> vector_;
+
+  DISALLOW_COPY_AND_ASSIGN(MemoryBuffer);
+};
+
+#endif  // O3D_IMPORT_CROSS_MEMORY_BUFFER_H_
diff --git a/o3d/import/cross/memory_buffer_test.cc b/o3d/import/cross/memory_buffer_test.cc
new file mode 100644
index 0000000..59cb721
--- /dev/null
+++ b/o3d/import/cross/memory_buffer_test.cc
@@ -0,0 +1,98 @@
+/*
+ * 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.
+ */
+
+
+// Tests functionality of the MemoryBuffer class
+
+#include "core/cross/client.h"
+#include "tests/common/win/testing_common.h"
+#include "core/cross/error.h"
+#include "import/cross/memory_buffer.h"
+
+namespace o3d {
+
+// Test fixture for RawData testing.
+class MemoryBufferTest : public testing::Test {
+};
+
+// Test RawData
+TEST_F(MemoryBufferTest, Basic) {
+  int i;
+  MemoryBuffer<int> buffer;
+  // Check that initially the buffer is not allocated
+  ASSERT_EQ(0, buffer.GetLength());
+
+  // Allocate and check the length is good
+  const int kBufferLength = 1024;
+  buffer.Allocate(kBufferLength);
+  ASSERT_EQ(kBufferLength, buffer.GetLength());
+
+  // Once allocated, the initial contents should be zero
+  // Check that the buffer contents are zeroed out
+  bool buffer_is_cleared = true;
+  for (i = 0; i < kBufferLength; ++i) {
+    if (buffer[i] != 0) {
+      buffer_is_cleared = false;
+      break;
+    }
+  }
+  ASSERT_TRUE(buffer_is_cleared);
+
+  // Write some values and check that they're OK
+  for (i = 0; i < kBufferLength; ++i) {
+    buffer[i] = i;
+  }
+  bool buffer_values_good = true;
+  for (i = 0; i < kBufferLength; ++i) {
+    if (buffer[i] != i) {
+      buffer_values_good = false;
+      break;
+    }
+  }
+  ASSERT_TRUE(buffer_values_good);
+
+  // Now, clear the buffer and check that it worked
+  buffer.Clear();
+  buffer_is_cleared = true;
+  for (i = 0; i < kBufferLength; ++i) {
+    if (buffer[i] != 0) {
+      buffer_is_cleared = false;
+      break;
+    }
+  }
+  ASSERT_TRUE(buffer_is_cleared);
+
+  // Deallocate the buffer and verify its length
+  buffer.Deallocate();
+  ASSERT_EQ(0, buffer.GetLength());
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/memory_stream.cc b/o3d/import/cross/memory_stream.cc
new file mode 100644
index 0000000..9a4d6c5
--- /dev/null
+++ b/o3d/import/cross/memory_stream.cc
@@ -0,0 +1,401 @@
+/*
+ * 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.
+ */
+
+//
+// MemoryReadStream and MemoryWriteStream are simple stream wrappers around
+// memory buffers.
+
+#include "import/cross/memory_stream.h"
+#include "core/cross/types.h"
+
+#if !defined(IS_LITTLE_ENDIAN) && !defined(IS_BIG_ENDIAN)
+#error "IS_LITTLE_ENDIAN or IS_BIG_ENDIAN must be defined!"
+#endif
+
+namespace o3d {
+
+namespace {
+union Int16Union {
+  uint8 c[2];
+  int16 i;
+};
+
+union UInt16Union {
+  uint8 c[2];
+  uint16 i;
+};
+
+union Int32Union {
+  uint8 c[4];
+  int32 i;
+};
+
+union UInt32Union {
+  uint8 c[4];
+  uint32 i;
+};
+
+union Int32FloatUnion {
+  int32 i;
+  float f;
+};
+
+union UInt32FloatUnion {
+  uint32 i;
+  float f;
+};
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+static int16 SwapInt16(const int16 *value) {
+  // endian-swap two bytes
+  uint8 p[2];
+  const char *q = reinterpret_cast<const char*>(value);
+  p[0] = q[1];
+  p[1] = q[0];
+
+  return *reinterpret_cast<int16*>(p);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+static uint16 SwapUInt16(const uint16 *value) {
+  // endian-swap two bytes
+  uint8 p[2];
+  const char *q = reinterpret_cast<const char*>(value);
+  p[0] = q[1];
+  p[1] = q[0];
+
+  return *reinterpret_cast<const uint16*>(p);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+static int32 SwapInt32(const int32 *value) {
+  // endian-swap four bytes
+  char p[4];
+  const char *q = reinterpret_cast<const char*>(value);
+  p[0] = q[3];
+  p[1] = q[2];
+  p[2] = q[1];
+  p[3] = q[0];
+
+  return *reinterpret_cast<const int32*>(p);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+static uint32 SwapUInt32(const uint32 *value) {
+  // endian-swap four bytes
+  char p[4];
+  const char *q = reinterpret_cast<const char*>(value);
+  p[0] = q[3];
+  p[1] = q[2];
+  p[2] = q[1];
+  p[3] = q[0];
+
+  return *reinterpret_cast<const uint32*>(p);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int16 MemoryReadStream::ReadLittleEndianInt16() {
+  Int16Union u;
+  Read(u.c, 2);
+
+#ifdef IS_BIG_ENDIAN
+  return SwapInt16(&u.i);
+#else
+  return u.i;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+uint16 MemoryReadStream::ReadLittleEndianUInt16() {
+  UInt16Union u;
+  Read(u.c, 2);
+
+#ifdef IS_BIG_ENDIAN
+  return SwapUint16(&u.i);
+#else
+  return u.i;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int16 MemoryReadStream::ReadBigEndianInt16() {
+  Int16Union u;
+  Read(u.c, 2);
+
+#ifdef IS_LITTLE_ENDIAN
+  return SwapInt16(&u.i);
+#else
+  return u.i;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+uint16 MemoryReadStream::ReadBigEndianUInt16() {
+  UInt16Union u;
+  Read(u.c, 2);
+
+#ifdef IS_LITTLE_ENDIAN
+  return SwapUInt16(&u.i);
+#else
+  return u.i;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int32 MemoryReadStream::ReadLittleEndianInt32() {
+  Int32Union u;
+  Read(u.c, 4);
+
+#ifdef IS_BIG_ENDIAN
+  return SwapInt32(&u.i);
+#else
+  return u.i;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+uint32 MemoryReadStream::ReadLittleEndianUInt32() {
+  UInt32Union u;
+  Read(u.c, 4);
+
+#ifdef IS_BIG_ENDIAN
+  return SwapUInt32(&u.i);
+#else
+  return u.i;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int32 MemoryReadStream::ReadBigEndianInt32() {
+  Int32Union u;
+  Read(u.c, 4);
+
+#ifdef IS_LITTLE_ENDIAN
+  return SwapInt32(&u.i);
+#else
+  return u.i;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+uint32 MemoryReadStream::ReadBigEndianUInt32() {
+  UInt32Union u;
+  Read(u.c, 4);
+
+#ifdef IS_LITTLE_ENDIAN
+  return SwapUInt32(&u.i);
+#else
+  return u.i;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+float MemoryReadStream::ReadLittleEndianFloat32() {
+  // Read in as int32 then interpret as float32
+  Int32FloatUnion u;
+  u.i = ReadLittleEndianInt32();
+  return u.f;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+float MemoryReadStream::ReadBigEndianFloat32() {
+  // Read in as int32 then interpret as float32
+  Int32FloatUnion u;
+  u.i = ReadBigEndianInt32();
+  return u.f;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteLittleEndianInt16(int16 i) {
+  Int16Union u;
+
+#ifdef IS_BIG_ENDIAN
+  u.i = SwapInt16(&i);
+#else
+  u.i = i;
+#endif
+
+  Write(u.c, 2);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteLittleEndianUInt16(uint16 i) {
+  UInt16Union u;
+
+#ifdef IS_BIG_ENDIAN
+  u.i = SwapUInt16(&i);
+#else
+  u.i = i;
+#endif
+
+  Write(u.c, 2);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteBigEndianInt16(int16 i) {
+  Int16Union u;
+
+#ifdef IS_LITTLE_ENDIAN
+  u.i = SwapInt16(&i);
+#else
+  u.i = i;
+#endif
+
+  Write(u.c, 2);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteBigEndianUInt16(uint16 i) {
+  UInt16Union u;
+
+#ifdef IS_LITTLE_ENDIAN
+  u.i = SwapUInt16(&i);
+#else
+  u.i = i;
+#endif
+
+  Write(u.c, 2);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteLittleEndianInt32(int32 i) {
+  Int32Union u;
+
+#ifdef IS_BIG_ENDIAN
+  u.i = SwapInt32(&i);
+#else
+  u.i = i;
+#endif
+
+  Write(u.c, 4);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteLittleEndianUInt32(uint32 i) {
+  UInt32Union u;
+
+#ifdef IS_BIG_ENDIAN
+  u.i = SwapUInt32(&i);
+#else
+  u.i = i;
+#endif
+
+  Write(u.c, 4);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteBigEndianInt32(int32 i) {
+  Int32Union u;
+
+#ifdef IS_LITTLE_ENDIAN
+  u.i = SwapInt32(&i);
+#else
+  u.i = i;
+#endif
+
+  Write(u.c, 4);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteBigEndianUInt32(uint32 i) {
+  UInt32Union u;
+
+#ifdef IS_LITTLE_ENDIAN
+  u.i = SwapUInt32(&i);
+#else
+  u.i = i;
+#endif
+
+  Write(u.c, 4);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteLittleEndianFloat32(float f) {
+  // Interpret byte-pattern of f as int32 and write out
+  Int32FloatUnion u;
+  u.f = f;
+  WriteLittleEndianInt32(u.i);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void MemoryWriteStream::WriteBigEndianFloat32(float f) {
+  // Interpret byte-pattern of f as int32 and write out
+  Int32FloatUnion u;
+  u.f = f;
+  WriteBigEndianInt32(u.i);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// A couple of useful utility functions
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Returns the bytes pointed to by |value| as little-endian 16
+int16 MemoryReadStream::GetLittleEndianInt16(const int16 *value) {
+#ifdef IS_BIG_ENDIAN
+  return SwapInt16(value);
+#else
+  return *value;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Returns the bytes pointed to by |value| as little-endian 16
+uint16 MemoryReadStream::GetLittleEndianUInt16(const uint16 *value) {
+#ifdef IS_BIG_ENDIAN
+  return SwapUInt16(value);
+#else
+  return *value;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Returns the bytes pointed to by |value| as little-endian 32
+int32 MemoryReadStream::GetLittleEndianInt32(const int32 *value) {
+#ifdef IS_BIG_ENDIAN
+  return SwapInt32(value);
+#else
+  return *value;
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Returns the bytes pointed to by |value| as little-endian 32
+uint32 MemoryReadStream::GetLittleEndianUInt32(const uint32 *value) {
+#ifdef IS_BIG_ENDIAN
+  return SwapUint32(value);
+#else
+  return *value;
+#endif
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/memory_stream.h b/o3d/import/cross/memory_stream.h
new file mode 100644
index 0000000..00585b6
--- /dev/null
+++ b/o3d/import/cross/memory_stream.h
@@ -0,0 +1,276 @@
+/*
+ * 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.
+ */
+
+//
+// MemoryReadStream and MemoryWriteStream are simple stream wrappers around
+// memory buffers.  Their constructers take a pointer to the memory and
+// the length of the buffer.  They are useful for pipeline based processing
+// of byte-streams.
+//
+// MemoryReadStream maintains its stream position
+// and can be read with the Read() method, returning the number of bytes
+// read (similar to fread()).
+//
+// MemoryWriteStream maintains its stream position
+// and can be written with the Write() method, returning the number of bytes
+// actually written (similar to fwrite()).
+
+#ifndef O3D_IMPORT_CROSS_MEMORY_STREAM_H_
+#define O3D_IMPORT_CROSS_MEMORY_STREAM_H_
+
+#include <string.h>
+#include "base/basictypes.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class MemoryReadStream {
+ public:
+  MemoryReadStream(const uint8 *memory, size_t n)
+      : memory_(memory), length_(n), read_index_(0) {}
+
+  // Explicit copy constructor
+  MemoryReadStream(const MemoryReadStream &stream)
+      : memory_(stream.memory_),
+        length_(stream.length_),
+        read_index_(stream.read_index_) {}
+
+  virtual ~MemoryReadStream() {}
+
+  // Similar to fread(), will try to copy |n| bytes to address |p|
+  // (copies fewer bytes if the stream doesn't have enough data)
+  // returns the number of bytes copied
+  virtual size_t Read(void *p, size_t n) {
+    size_t remaining = GetRemainingByteCount();
+    size_t bytes_to_read = (n < remaining) ? n : remaining;
+    memcpy(p, memory_ + read_index_, bytes_to_read);
+    read_index_ += bytes_to_read;
+    return bytes_to_read;
+  }
+
+  // Attempts to read a complete object of type T
+  // returns |true| on success
+  template<typename T>
+  bool ReadAs(T *p) {
+    size_t bytes_read = this->Read(reinterpret_cast<char*>(p),
+                                   sizeof(T));
+    return (bytes_read == sizeof(T));
+  }
+
+  // Reads the next byte in the stream (if there are any left)
+  // If the stream has run dry (is empty) then returns 0
+  // To check number of bytes available, call GetRemainingByteCount()
+  virtual uint8 ReadByte() {
+    if (read_index_ >= length_) return 0;
+
+    uint8 byte = memory_[read_index_];
+    read_index_++;
+
+    return byte;
+  }
+
+  // 16 and 32bit integer reading for both little and big endian
+  int16 ReadLittleEndianInt16();
+  uint16 ReadLittleEndianUInt16();
+  int16 ReadBigEndianInt16();
+  uint16 ReadBigEndianUInt16();
+  int32 ReadLittleEndianInt32();
+  uint32 ReadLittleEndianUInt32();
+  int32 ReadBigEndianInt32();
+  uint32 ReadBigEndianUInt32();
+
+  // IEEE 32-bit float reading (little and big endian)
+  float ReadLittleEndianFloat32();
+  float ReadBigEndianFloat32();
+
+  // Returns the number of bytes left in the stream (which can be read)
+  size_t GetRemainingByteCount() {
+    return length_ - read_index_;
+  };
+
+  // Returns |true| if the read position is at end-of-stream
+  // (no more bytes left to read)
+  bool EndOfStream() { return GetRemainingByteCount() == 0; }
+
+  // Instead of calling Read(), this gives direct access to the data
+  // without a memcpy().
+  // Calling GetRemainingByteCount() will give the number of remaining bytes
+  // starting at this address...
+  const uint8 *GetDirectMemoryPointer() { return memory_ + read_index_; }
+
+  // Same as GetDirectMemoryPointer() but returns pointer of desired type
+  template <typename T>
+  T *GetDirectMemoryPointerAs() {
+    return reinterpret_cast<T*>(GetDirectMemoryPointer());
+  };
+
+  // Advances the read position by |n| bytes
+  void Skip(size_t n) {
+    size_t remaining = GetRemainingByteCount();
+    read_index_ += (n < remaining) ? n : remaining;
+  }
+
+  // Changes the read position to the given byte offset.
+  // This allows random access into the stream similar to fseek()
+  bool Seek(size_t seek_pos) {
+    bool valid = (seek_pos >= 0 && seek_pos <= length_);
+    if (valid) {
+      read_index_ = seek_pos;
+    }
+    return valid;
+  }
+
+  // Returns the total number of bytes in the stream
+  size_t GetTotalStreamLength() const { return length_; }
+
+
+  // Returns the byte position (offset from start of stream)
+  // this is effectively the number of bytes which have, so far,
+  // been read
+  size_t GetStreamPosition() const { return read_index_; }
+
+  // utility methods (swaps the value if necessary)
+  static int16 GetLittleEndianInt16(const int16 *value);
+  static uint16 GetLittleEndianUInt16(const uint16 *value);
+  static int32 GetLittleEndianInt32(const int32 *value);
+  static uint32 GetLittleEndianUInt32(const uint32 *value);
+
+ protected:
+  const uint8 *memory_;
+  size_t read_index_;
+  size_t length_;
+
+  // Disallow assignment
+  void operator=(const MemoryReadStream&);
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class MemoryWriteStream {
+ public:
+  // May be completely initialized by calling Assign()
+  MemoryWriteStream() : memory_(NULL), write_index_(0), length_(0) {}
+
+  MemoryWriteStream(uint8 *memory, size_t n)
+      : memory_(memory), length_(n), write_index_(0) {}
+
+  // Explicit copy constructor
+  MemoryWriteStream(const MemoryWriteStream &stream)
+      : memory_(stream.memory_),
+        length_(stream.length_),
+        write_index_(stream.write_index_) {}
+
+  virtual ~MemoryWriteStream() {}
+
+  // In the case where the default constructor was used, this is useful
+  // to assign a pointer to memory and a length in bytes.
+  void Assign(uint8 *memory, size_t n) {
+    memory_ = memory;
+    length_ = n;
+    write_index_ = 0;
+  }
+
+  // Changes the write position to the given byte offset.
+  // This allows random access into the stream similar to fseek()
+  bool Seek(size_t seek_pos) {
+    bool valid = (seek_pos >= 0 && seek_pos <= length_);
+    if (valid) {
+      write_index_ = seek_pos;
+    }
+    return valid;
+  }
+
+  // Similar to fwrite(), will try to copy |n| bytes from address |p|
+  // (copies fewer bytes if the stream doesn't have enough data)
+  // returns the number of bytes copied
+  virtual size_t Write(const void *p, size_t n) {
+    size_t remaining = GetRemainingByteCount();
+    size_t bytes_to_write = (n < remaining) ? n : remaining;
+    memcpy(memory_ + write_index_, p, bytes_to_write);
+    write_index_ += bytes_to_write;
+    return bytes_to_write;
+  }
+
+  void WriteByte(uint8 byte) {
+    Write(&byte, 1);
+  }
+
+  // 16 and 32bit integer writing for both little and big endian
+  void WriteLittleEndianInt16(int16 i);
+  void WriteLittleEndianUInt16(uint16 i);
+  void WriteBigEndianInt16(int16 i);
+  void WriteBigEndianUInt16(uint16 i);
+  void WriteLittleEndianInt32(int32 i);
+  void WriteLittleEndianUInt32(uint32 i);
+  void WriteBigEndianInt32(int32 i);
+  void WriteBigEndianUInt32(uint32 i);
+
+  // IEEE 32-bit float writing (little and big endian)
+  void WriteLittleEndianFloat32(float f);
+  void WriteBigEndianFloat32(float f);
+
+  // Returns the number of bytes left in the stream (which can be written)
+  size_t GetRemainingByteCount() {
+    return length_ - write_index_;
+  };
+
+  // Returns |true| if the read position is at end-of-stream
+  // (no more bytes left to read)
+  bool EndOfStream() { return GetRemainingByteCount() == 0; }
+
+  // Returns the total number of bytes in the stream
+  size_t GetTotalStreamLength() const { return length_; }
+
+  // Returns the byte position (offset from start of stream)
+  // this is effectively the number of bytes which have, so far,
+  // been written
+  size_t GetStreamPosition() const { return write_index_; }
+
+ protected:
+  uint8 *memory_;
+  size_t write_index_;
+  size_t length_;
+
+  // Disallow assignment
+  void operator=(const MemoryWriteStream&);
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Abstract interface to process a memory stream
+class StreamProcessor {
+ public:
+  virtual ~StreamProcessor() {}
+  virtual int ProcessBytes(MemoryReadStream *stream,
+                           size_t bytes_to_process) = 0;
+};
+
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_MEMORY_STREAM_H_
diff --git a/o3d/import/cross/memory_stream_test.cc b/o3d/import/cross/memory_stream_test.cc
new file mode 100644
index 0000000..a02fcca
--- /dev/null
+++ b/o3d/import/cross/memory_stream_test.cc
@@ -0,0 +1,320 @@
+/*
+ * 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.
+ */
+
+
+// Tests functionality of the MemoryReadStream and MemoryWriteStream
+// classes
+
+#include "core/cross/client.h"
+#include "tests/common/win/testing_common.h"
+#include "core/cross/error.h"
+#include "import/cross/memory_buffer.h"
+#include "import/cross/memory_stream.h"
+#include "core/cross/types.h"
+
+#if !defined(IS_LITTLE_ENDIAN) && !defined(IS_BIG_ENDIAN)
+#error "IS_LITTLE_ENDIAN or IS_BIG_ENDIAN must be defined!"
+#endif
+
+namespace o3d {
+
+static char *kTestString =
+    "Tests functionality of the MemoryReadStream and MemoryWriteStream classes";
+
+// Test fixture for MemoryReadStream and MemoryWriteStream.
+class MemoryStreamTest : public testing::Test {
+};
+
+// Test reading from a buffer using MemoryReadStream
+TEST_F(MemoryStreamTest, Read) {
+  int i;
+
+  // Put a test string in a memory buffer
+  const int kStringLength = strlen(kTestString);
+  MemoryBuffer<uint8> buffer(kStringLength);
+
+  for (i = 0; i < kStringLength; ++i) {
+    buffer[i] = kTestString[i];
+  }
+
+  // Now, create a read stream on that buffer and verify that it reads
+  // correctly...
+  MemoryReadStream read_stream(buffer, buffer.GetLength());
+
+  EXPECT_EQ(buffer.GetLength(), read_stream.GetTotalStreamLength());
+  EXPECT_EQ(kStringLength, read_stream.GetTotalStreamLength());
+
+  // Read one byte at a time and verify
+  uint8 c;
+  for (i = 0; i < kStringLength; ++i) {
+    c = read_stream.ReadByte();
+    EXPECT_EQ(c, kTestString[i]);
+  }
+  // Read an extra byte and verify it's zero
+  c = read_stream.ReadByte();
+  EXPECT_EQ(c, 0);
+
+  // Now, create a 2nd read stream
+  MemoryReadStream read_stream2(buffer, buffer.GetLength());
+  // Get direct memory access and check the pointer is correct
+  const uint8 *p = read_stream2.GetDirectMemoryPointer();
+  EXPECT_EQ(const_cast<uint8*>(p), static_cast<uint8*>(buffer));
+
+  // Test the Read() method
+
+  // First read 5 bytes
+  MemoryBuffer<uint8> read_buffer(kStringLength);
+  int bytes_read = read_stream2.Read(read_buffer, 5);
+
+  // Verify bytes read, stream position and remaining byte count
+  EXPECT_EQ(5, bytes_read);
+  EXPECT_EQ(5, read_stream2.GetStreamPosition());
+  EXPECT_EQ(kStringLength - 5, read_stream2.GetRemainingByteCount());
+
+  // Next read the remaining bytes
+  bytes_read = read_stream2.Read(read_buffer + 5, kStringLength - 5);
+  EXPECT_EQ(kStringLength - 5, bytes_read);
+
+  // Make sure we read the correct data
+  EXPECT_EQ(0, memcmp(read_buffer, buffer, kStringLength));
+
+  // Try to read some more, even though we're at stream end
+  bytes_read = read_stream2.Read(read_buffer, 1000);
+  EXPECT_EQ(0, bytes_read);  // make sure no bytes were read
+
+  // Now, create a 3rd read stream
+  MemoryReadStream read_stream3(buffer, buffer.GetLength());
+
+  // Let's test the Skip() method
+  read_stream3.Skip(6);  // skip over the first 6 bytes
+
+  // Read three bytes in a row and verify
+  uint8 c1 = read_stream3.ReadByte();
+  uint8 c2 = read_stream3.ReadByte();
+  uint8 c3 = read_stream3.ReadByte();
+  EXPECT_EQ('f', c1);
+  EXPECT_EQ('u', c2);
+  EXPECT_EQ('n', c3);
+}
+
+// Test Writing to a buffer using MemoryWriteStream
+TEST_F(MemoryStreamTest, Write) {
+  // Create a write stream without assigning it to memory yet
+  MemoryWriteStream empty_stream;
+
+  // Verfify length is zero
+  EXPECT_EQ(0, empty_stream.GetTotalStreamLength());
+
+  // Now, assign it to the string (OK, we can't really write to
+  // this memory, but we're just checking the API here
+  const int kStringLength = strlen(kTestString);
+  empty_stream.Assign(reinterpret_cast<uint8*>(kTestString), kStringLength);
+
+  // Sanity check on length, position, remaining
+  EXPECT_EQ(kStringLength, empty_stream.GetTotalStreamLength());
+  EXPECT_EQ(0, empty_stream.GetStreamPosition());
+  EXPECT_EQ(kStringLength, empty_stream.GetRemainingByteCount());
+
+  // Create a write stream on a buffer we can write to
+  MemoryBuffer<uint8> buffer(kStringLength);
+  MemoryWriteStream write_stream(buffer, buffer.GetLength());
+  EXPECT_EQ(buffer.GetLength(), kStringLength);
+
+  // Write 5 bytes
+  uint8 *p = reinterpret_cast<uint8*>(kTestString);
+  int bytes_written = write_stream.Write(p, 5);
+  EXPECT_EQ(5, bytes_written);
+  EXPECT_EQ(5, write_stream.GetStreamPosition());
+  EXPECT_EQ(kStringLength - 5, write_stream.GetRemainingByteCount());
+
+  // Write the remaining bytes in the string
+  bytes_written = write_stream.Write(p + 5, kStringLength - 5);
+  EXPECT_EQ(kStringLength - 5, bytes_written);
+  EXPECT_EQ(kStringLength, write_stream.GetStreamPosition());
+  EXPECT_EQ(0, write_stream.GetRemainingByteCount());
+
+  // Verify we wrote the correct data
+  EXPECT_EQ(0, memcmp(buffer, kTestString, kStringLength));
+
+  // Try to write some more even though the buffer is full
+  bytes_written = write_stream.Write(p, kStringLength);
+  EXPECT_EQ(0, bytes_written);
+}
+
+// Basic sanity check for endian writing/reading
+TEST_F(MemoryStreamTest, EndianSanity16) {
+  // Sanity check int16
+  MemoryBuffer<int16> buffer16(2);
+  int16 *p = buffer16;
+  uint8 *p8 = reinterpret_cast<uint8*>(p);
+  MemoryWriteStream write_stream(p8, sizeof(int16) * 2);
+
+  int16 value = 0x1234;
+  write_stream.WriteLittleEndianInt16(value);
+  write_stream.WriteBigEndianInt16(value);
+
+  // Verify that the bytes are in the correct order
+  uint8 low_byte = value & 0xff;
+  uint8 high_byte = value >> 8;
+
+  // validate little-endian
+  EXPECT_EQ(low_byte, p8[0]);
+  EXPECT_EQ(high_byte, p8[1]);
+
+  // validate big-endian
+  EXPECT_EQ(high_byte, p8[2]);
+  EXPECT_EQ(low_byte, p8[3]);
+}
+
+// Basic sanity check for endian writing/reading
+TEST_F(MemoryStreamTest, EndianSanity32) {
+  // Sanity check int32
+  MemoryBuffer<int32> buffer32(2);
+  int32 *p = buffer32;
+  uint8 *p8 = reinterpret_cast<uint8*>(p);
+  MemoryWriteStream write_stream(p8, sizeof(int32) * 2);
+
+  int32 value = 0x12345678;
+  write_stream.WriteLittleEndianInt32(value);
+  write_stream.WriteBigEndianInt32(value);
+
+  // Verify that the bytes are in the correct order
+  uint8 byte1 = value & 0xff;
+  uint8 byte2 = (value >> 8) & 0xff;
+  uint8 byte3 = (value >> 16) & 0xff;
+  uint8 byte4 = (value >> 24) & 0xff;
+
+  // validate little-endian
+  EXPECT_EQ(byte1, p8[0]);
+  EXPECT_EQ(byte2, p8[1]);
+  EXPECT_EQ(byte3, p8[2]);
+  EXPECT_EQ(byte4, p8[3]);
+
+  // validate big-endian
+  EXPECT_EQ(byte4, p8[4]);
+  EXPECT_EQ(byte3, p8[5]);
+  EXPECT_EQ(byte2, p8[6]);
+  EXPECT_EQ(byte1, p8[7]);
+}
+
+// Basic sanity check for endian writing/reading
+TEST_F(MemoryStreamTest, EndianSanityFloat32) {
+  // Sanity check int32
+  MemoryBuffer<float> buffer32(2);
+  float *p = buffer32;
+  uint8 *p8 = reinterpret_cast<uint8*>(p);
+  MemoryWriteStream write_stream(p8, sizeof(int32) * 2);
+
+  float value = 3.14159;
+  write_stream.WriteLittleEndianFloat32(value);
+  write_stream.WriteBigEndianFloat32(value);
+
+  // Verify that the bytes are in the correct order
+  int32 ivalue = *reinterpret_cast<int32*>(&value);  // interpret float as int32
+  uint8 byte1 = ivalue & 0xff;
+  uint8 byte2 = (ivalue >> 8) & 0xff;
+  uint8 byte3 = (ivalue >> 16) & 0xff;
+  uint8 byte4 = (ivalue >> 24) & 0xff;
+
+  // validate little-endian
+  EXPECT_EQ(byte1, p8[0]);
+  EXPECT_EQ(byte2, p8[1]);
+  EXPECT_EQ(byte3, p8[2]);
+  EXPECT_EQ(byte4, p8[3]);
+
+  // validate big-endian
+  EXPECT_EQ(byte4, p8[4]);
+  EXPECT_EQ(byte3, p8[5]);
+  EXPECT_EQ(byte2, p8[6]);
+  EXPECT_EQ(byte1, p8[7]);
+}
+
+// Write then read int16, int32, and float32 little/big endian values
+TEST_F(MemoryStreamTest, Endian) {
+  const int16 kValue1 = 13243;
+  const int32 kValue2 = 2393043;
+  const float kValue3 = -0.039483;
+  const int16 kValue4 = -3984;
+  const float kValue5 = 1234.5678;
+  const uint8 kValue6 = 5;  // write a single byte to make things interesting
+  const int32 kValue7 = -3920393;
+
+  size_t total_size = sizeof(kValue1) +
+                      sizeof(kValue2) +
+                      sizeof(kValue3) +
+                      sizeof(kValue4) +
+                      sizeof(kValue5) +
+                      sizeof(kValue6) +
+                      sizeof(kValue7);
+
+  MemoryBuffer<uint8> buffer(total_size);
+
+  // write the values to the buffer
+  uint8 *p8 = buffer;
+  MemoryWriteStream write_stream(p8, total_size);
+
+  write_stream.WriteLittleEndianInt16(kValue1);
+  write_stream.WriteBigEndianInt32(kValue2);
+  write_stream.WriteLittleEndianFloat32(kValue3);
+  write_stream.WriteBigEndianInt16(kValue4);
+  write_stream.WriteBigEndianFloat32(kValue5);
+  write_stream.Write(&kValue6, 1);
+  write_stream.WriteLittleEndianInt32(kValue7);
+
+  // now read them back in and verify
+  int16 read_value1;
+  int32 read_value2;
+  float read_value3;
+  int16 read_value4;
+  float read_value5;
+  uint8 read_value6;
+  int32 read_value7;
+  MemoryReadStream read_stream(p8, total_size);
+
+  read_value1 = read_stream.ReadLittleEndianInt16();
+  read_value2 = read_stream.ReadBigEndianInt32();
+  read_value3 = read_stream.ReadLittleEndianFloat32();
+  read_value4 = read_stream.ReadBigEndianInt16();
+  read_value5 = read_stream.ReadBigEndianFloat32();
+  read_stream.Read(&read_value6, 1);
+  read_value7 = read_stream.ReadLittleEndianInt32();
+
+  // Validate
+  EXPECT_EQ(read_value1, kValue1);
+  EXPECT_EQ(read_value2, kValue2);
+  EXPECT_EQ(read_value3, kValue3);
+  EXPECT_EQ(read_value4, kValue4);
+  EXPECT_EQ(read_value5, kValue5);
+  EXPECT_EQ(read_value6, kValue6);
+  EXPECT_EQ(read_value7, kValue7);
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/precompile.cc b/o3d/import/cross/precompile.cc
new file mode 100644
index 0000000..8a70235
--- /dev/null
+++ b/o3d/import/cross/precompile.cc
@@ -0,0 +1,33 @@
+/*
+ * 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 "import/cross/precompile.h"
diff --git a/o3d/import/cross/precompile.h b/o3d/import/cross/precompile.h
new file mode 100644
index 0000000..e1daa2b
--- /dev/null
+++ b/o3d/import/cross/precompile.h
@@ -0,0 +1,99 @@
+/*
+ * 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.
+ */
+
+
+#ifndef O3D_IMPORT_CROSS_PRECOMPILE_H_
+#define O3D_IMPORT_CROSS_PRECOMPILE_H_
+
+#ifdef OS_WIN
+#include <windows.h>
+#include <shellapi.h>
+#include <stdlib.h>
+#include <d3dx9.h>
+#endif
+
+#ifdef __cplusplus
+
+#include <Cg/cg.h>
+#include <Cg/cgGL.h>
+#include <FCollada.h>
+#include <FCDocument/FCDocument.h>
+#include <FCDocument/FCDocumentTools.h>
+#include <FCDocument/FCDAnimated.h>
+#include <FCDocument/FCDAnimationCurve.h>
+#include <FCDocument/FCDAnimationKey.h>
+#include <FCDocument/FCDEffect.h>
+#include <FCDocument/FCDEffectCode.h>
+#include <FCDocument/FCDEffectParameter.h>
+#include <FCDocument/FCDEffectParameterSurface.h>
+#include <FCDocument/FCDEffectParameterSampler.h>
+#include <FCDocument/FCDEffectPass.h>
+#include <FCDocument/FCDEffectPassShader.h>
+#include <FCDocument/FCDEffectPassState.h>
+#include <FCDocument/FCDEffectProfile.h>
+#include <FCDocument/FCDEffectProfileFX.h>
+#include <FCDocument/FCDEffectStandard.h>
+#include <FCDocument/FCDEffectTechnique.h>
+#include <FCDocument/FCDExtra.h>
+#include <FCDocument/FCDEntity.h>
+#include <FCDocument/FCDImage.h>
+#include <FCDocument/FCDMaterial.h>
+#include <FCDocument/FCDMaterialInstance.h>
+#include <FCDocument/FCDLibrary.h>
+#include <FCDocument/FCDSceneNode.h>
+#include <FCDocument/FCDCamera.h>
+#include <FCDocument/FCDGeometry.h>
+#include <FCDocument/FCDGeometryInstance.h>
+#include <FCDocument/FCDGeometryMesh.h>
+#include <FCDocument/FCDGeometryPolygons.h>
+#include <FCDocument/FCDGeometryPolygonsInput.h>
+#include <FCDocument/FCDGeometryPolygonsTools.h>
+#include <FCDocument/FCDGeometrySource.h>
+#include <FCDocument/FCDController.h>
+#include <FCDocument/FCDControllerInstance.h>
+#include <FCDocument/FCDSkinController.h>
+#include <FCDocument/FCDTexture.h>
+#include <FCDocument/FCDTransform.h>
+#include <FUtils/FUFileManager.h>
+#include <FUtils/FUUri.h>
+#include <FUtils/FUXmlParser.h>
+
+#ifndef OS_WIN
+#include <vector>
+using std::min;
+using std::max;
+#endif
+
+#include <sstream>
+
+#endif  // __cplusplus
+
+#endif  // O3D_IMPORT_CROSS_PRECOMPILE_H_
diff --git a/o3d/import/cross/raw_data.cc b/o3d/import/cross/raw_data.cc
new file mode 100644
index 0000000..067ff70
--- /dev/null
+++ b/o3d/import/cross/raw_data.cc
@@ -0,0 +1,343 @@
+/*
+ * 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.
+ */
+
+
+// This file contains implementation for raw-data which may be used
+// by the progressive streaming archive system
+
+#include "import/cross/raw_data.h"
+#include "base/file_util.h"
+
+#ifdef OS_MACOSX
+#include <CoreFoundation/CoreFoundation.h>
+#endif
+
+#ifdef OS_WIN
+#include <rpc.h>
+#endif
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// RawData class
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+O3D_DEFN_CLASS(RawData, ParamObject);
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+RawData::RawData(ServiceLocator* service_locator,
+                 const String &uri,
+                 const void *data,
+                 size_t length)
+    : ParamObject(service_locator), uri_(uri) {
+  // make private copy of data
+  data_.reset(new uint8[length]);
+  length_ = length;
+  memcpy(data_.get(), data, length);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+RawData::Ref RawData::Create(ServiceLocator* service_locator,
+                             const String &uri,
+                             const void *data,
+                             size_t length) {
+  return RawData::Ref(new RawData(service_locator, uri, data, length));
+}
+
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+RawData::~RawData() {
+  Discard();
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+const uint8 *RawData::GetData() const {
+  // Return data immediately if we have it
+  if (data_.get()) {
+    return data_.get();
+  }
+
+  // We need to load the data from the cache file
+  if (temp_filepath_.empty()) {
+    DLOG(ERROR) << "cannot retrieve data object - it has been released";
+    return NULL;
+  }
+
+  FILE *tempfile = file_util::OpenFile(temp_filepath_, "rb");
+  if (!tempfile) {
+    DLOG(ERROR) << "cached data file cannot be opened";
+    return NULL;
+  }
+
+  data_.reset(new uint8[length_]);
+  size_t bytes_read = fread(data_.get(), 1, length_, tempfile);
+
+  if (bytes_read != length_) {
+    DLOG(ERROR) << "error reading cached data file";
+    data_.reset();
+  }
+
+  file_util::CloseFile(tempfile);
+
+  return data_.get();
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+namespace {
+
+// Simple UTF8 validation.
+// Params:
+//   data: RawData to validate.
+//   utf8_length: pointer to size_t to receieve length of UTF8 data.
+// Returns:
+//   the start of the UTF-8 string or NULL if not valid UTF-8.
+const char* GetValidUTF8(const RawData& data, size_t* utf8_length) {
+  DCHECK(utf8_length);
+  const uint8* s = data.GetDataAs<const uint8>(0);
+  if (!s) {
+    return NULL;
+  }
+  size_t length = data.GetLength();
+
+  // Check for BOM and skip it.
+  if (length >= 3 && s[0] == 0xEF && s[1] == 0xBB && s[2] == 0xBF) {
+    length -= 3;
+    s += 3;
+  }
+
+  const uint8* start = s;
+  *utf8_length = length;
+
+  while (length) {
+    uint8 c = *s++;
+    if (c >= 0x80) {
+      // It's a multi-byte character
+      if (c >= 0xC2 && c <= 0xF4) {
+        uint32 codepoint;
+        int remaining_code_length = 0;
+        if ((c & 0xE0) == 0xC0) {
+          codepoint = c & 0x1F;
+          remaining_code_length = 1;
+        } else if ((c & 0xF0) == 0xE0) {
+          codepoint = c & 0x0F;
+          remaining_code_length = 2;
+        } else if ((c & 0xF8) == 0xF0) {
+          codepoint = c & 0x07;
+          remaining_code_length = 3;
+        }
+        if (remaining_code_length == 0 || remaining_code_length > length) {
+          // Not valid UTF-8
+          return NULL;
+        }
+        length -= remaining_code_length;
+        for (int cc = 0; cc < remaining_code_length; ++cc) {
+          c = *s++;
+          if ((c & 0xC0) != 0x80) {
+            // Not valid UTF-8
+            return NULL;
+          }
+          codepoint = (codepoint << 6) | (c & 0x3F);
+        }
+        if (codepoint >= 0xD800 && codepoint < 0xDFFF) {
+          // Not valid UTF-8
+          return NULL;
+        }
+      } else {
+        // Not valid UTF.
+        return NULL;
+      }
+    } else if (c == 0x00) {
+      // It's NULL, not UTF-8
+      return NULL;
+    }
+    --length;
+  }
+  return reinterpret_cast<const char*>(start);
+};
+
+}  // anonymous namespace
+
+String RawData::StringValue() const {
+  // NOTE: Originally it was thought to only allow certain extensions.
+  // Unfortunately it's not clear what list of extensions are valid. The list of
+  // extensions that might be useful to an application is nearly infinite (.txt,
+  // .json, .xml, .ini, .csv, .php, .js, .html, .css .xsl, .dae, etc.) So,
+  // instead we validate the string is valid UTF-8 AND that there are no NULLs
+  // in the string.
+  size_t length;
+  const char* utf8 = GetValidUTF8(*this, &length);
+  if (!utf8) {
+    O3D_ERROR(service_locator()) << "RawData is not valid UTF-8 string";
+  } else {
+    return String (utf8, length);
+  }
+  return String();
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void RawData::Flush() {
+  // Only create the temp file if it doesn't already exist
+  if (data_.get() && temp_filepath_.empty()) {
+    if (GetTempFilePathFromURI(uri_, &temp_filepath_)) {
+      FILE *tempfile = file_util::OpenFile(temp_filepath_, "wb");
+
+      if (tempfile) {
+        fwrite(data_.get(), 1, GetLength(), tempfile);
+        file_util::CloseFile(tempfile);
+
+        // Now that the data is cached, free it
+        data_.reset();
+      } else {
+        DLOG(ERROR) << "error creating cached data file";
+        temp_filepath_ = FilePath();
+      }
+    }
+  }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+const FilePath& RawData::GetTempFilePath() {
+  Flush();  // writes temp file if it's not already written
+  return temp_filepath_;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void RawData::Discard() {
+  data_.reset();
+  DeleteTempFile();
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+bool RawData::IsOffsetLengthValid(size_t offset, size_t length) const {
+  if (offset + length < offset) {
+    O3D_ERROR(service_locator()) << "overflow";
+    return false;
+  }
+  if (offset + length > length_) {
+    O3D_ERROR(service_locator()) << "illegal data offset or size";
+    return false;
+  }
+  return true;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void RawData::DeleteTempFile() {
+  if (!temp_filepath_.empty()) {
+    file_util::Delete(temp_filepath_, false);
+    temp_filepath_ = FilePath();
+  }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+static String GetUUIDString() {
+#ifdef OS_WIN
+  // now generate a GUID
+  UUID guid = {0};
+  UuidCreate(&guid);
+
+  // and format into a wide-string
+  char guid_string[37];
+  snprintf(
+      guid_string, sizeof(guid_string) / sizeof(guid_string[0]),
+      "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+      guid.Data1, guid.Data2, guid.Data3,
+      guid.Data4[0], guid.Data4[1], guid.Data4[2],
+      guid.Data4[3], guid.Data4[4], guid.Data4[5],
+      guid.Data4[6], guid.Data4[7]);
+
+  return guid_string;
+#endif
+
+#ifdef OS_MACOSX
+  CFUUIDRef uuid = CFUUIDCreate(NULL);
+  CFStringRef uuid_string_ref = CFUUIDCreateString(NULL, uuid);
+  CFRelease(uuid);
+
+  char uuid_string[64];
+  uuid_string[0] = 0;  // null-terminate, in case CFStringGetCString() fails
+  CFStringGetCString(uuid_string_ref,
+                     uuid_string,
+                     sizeof(uuid_string),
+                     kCFStringEncodingUTF8);
+  CFRelease(uuid_string_ref);
+
+
+  return uuid_string;
+#endif
+
+#ifdef OS_LINUX
+  static unsigned int index = 0;
+  char uuid[18] = {0};
+  unsigned int pid = getpid();
+  snprintf(uuid, 18, "%08x-%08x", pid, index++);
+  return String(uuid);
+#endif
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+bool RawData::GetTempFilePathFromURI(const String &uri,
+                                     FilePath *temp_fullpath) {
+  if (!temp_fullpath) return false;
+
+  // We use a UUID here to avoid any possible collisions with other tempfiles
+  // which have been or will be written sharing the same basic name
+
+  FilePath temp_path;
+  if (!file_util::GetTempDir(&temp_path)) {
+    return false;
+  }
+
+  String uuid_string = GetUUIDString();
+
+  // format the temp file basename
+  String filename;
+
+  // try to retain the original file suffix (.jpg, etc.)
+  int dot_position = uri.rfind('.');
+  if (dot_position != std::string::npos) {
+    filename = uuid_string + uri.substr(dot_position);
+  } else {
+    filename = uuid_string;
+  }
+
+  // Construct the full pathname
+  FilePath fullpath = temp_path;
+  fullpath = fullpath.AppendASCII(filename);
+
+  if (temp_fullpath) *temp_fullpath = fullpath;
+
+  return true;
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/raw_data.h b/o3d/import/cross/raw_data.h
new file mode 100644
index 0000000..8012efd
--- /dev/null
+++ b/o3d/import/cross/raw_data.h
@@ -0,0 +1,119 @@
+/*
+ * 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.
+ */
+
+
+// This file contains implementation for raw-data which is used
+// by the progressive streaming archive system
+//
+// A RawData object is just a pointer to some memory of a given length.
+// This data may represent string data, image data, audio data, etc..
+
+#ifndef O3D_IMPORT_CROSS_RAW_DATA_H_
+#define O3D_IMPORT_CROSS_RAW_DATA_H_
+
+#include "base/file_path.h"
+#include "base/scoped_ptr.h"
+#include "core/cross/error.h"
+#include "core/cross/param_object.h"
+#include "core/cross/param.h"
+#include "core/cross/types.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class RawData : public ParamObject {
+ public:
+  typedef SmartPointer<RawData> Ref;
+
+  static RawData::Ref Create(ServiceLocator* service_locator,
+                             const String &uri,
+                             const void *data,
+                             size_t length);
+
+  virtual ~RawData();
+
+  const uint8 *GetData() const;
+
+  template <typename T>
+  const T* GetDataAs(size_t offset) const {
+    return reinterpret_cast<const T*>(GetData() + offset);
+  };
+
+  size_t GetLength() const { return length_; }
+
+  String StringValue() const;
+
+  const String& uri() const { return uri_; }
+  void set_uri(const String& uri) { uri_ = uri; }
+
+  // If the data is still around
+  // (ie, Discard has not been called), then, if it has not been written
+  // to a temp file write it to a temp file
+  void Flush();
+
+  // calls Flush() if necessary and returns the path to the temp file
+  // if Discard() has already been called then returns an "empty" FilePath
+  const FilePath& GetTempFilePath();
+
+  // deletes the data which means IF the data is in memory it is
+  // freed. If there is a temp file it is deleted.
+  void Discard();
+
+  bool IsOffsetLengthValid(size_t offset, size_t length) const;
+
+ private:
+  String uri_;
+  mutable scoped_array<uint8> data_;
+  size_t length_;
+  FilePath temp_filepath_;
+
+  // Deletes temp file if it exists
+  void DeleteTempFile();
+
+  RawData(ServiceLocator* service_locator,
+          const String &uri,
+          const void *data,
+          size_t length);
+
+  friend class IClassManager;
+  friend class Pack;
+
+  // Returns |true| on success
+  bool GetTempFilePathFromURI(const String &uri,
+                              FilePath *temp_fullpath);
+
+  O3D_DECL_CLASS(RawData, ParamObject)
+  DISALLOW_COPY_AND_ASSIGN(RawData);
+};
+
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_RAW_DATA_H_
diff --git a/o3d/import/cross/raw_data_test.cc b/o3d/import/cross/raw_data_test.cc
new file mode 100644
index 0000000..b1ccc5dd
--- /dev/null
+++ b/o3d/import/cross/raw_data_test.cc
@@ -0,0 +1,196 @@
+/*
+ * 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.
+ */
+
+
+// Tests functionality of the RawData class
+
+#include "core/cross/client.h"
+#include "tests/common/win/testing_common.h"
+#include "core/cross/error.h"
+#include "import/cross/memory_buffer.h"
+#include "import/cross/raw_data.h"
+
+namespace o3d {
+
+// Test fixture for RawData testing.
+class RawDataTest : public testing::Test {
+};
+
+// Test RawData
+TEST_F(RawDataTest, Basic) {
+  String uri("test_filename");
+  const int kBufferLength = 1024;
+
+  // Create a buffer and initialize it will some values
+  MemoryBuffer<uint8> buffer(kBufferLength);
+  for (int i = 0; i < kBufferLength; i++) {
+    buffer[i] = i % 256;
+  }
+
+
+  RawData::Ref ref = RawData::Create(g_service_locator,
+                                     uri,
+                                     buffer,
+                                     buffer.GetLength() );
+  RawData *raw_data = ref;
+
+  // Check that it got created.
+  ASSERT_TRUE(raw_data != NULL);
+
+  // Now, let's make sure it got the data length correct
+  ASSERT_EQ(raw_data->GetLength(), buffer.GetLength());
+
+  // Check the contents are correct
+  ASSERT_EQ(0, memcmp(raw_data->GetData(), buffer, buffer.GetLength()));
+
+  // Check that the uri is correct
+  ASSERT_EQ(raw_data->uri(), uri);
+}
+
+namespace {
+
+struct TestData {
+  const uint8* data;
+  size_t length;
+  bool valid;
+  size_t offset;
+};
+
+} // anonymous namespace
+
+TEST_F(RawDataTest, StringValue) {
+  // A BOM in the front (valid)
+  static const uint8 data_0[] = {
+    0xEF,
+    0xBB,
+    0xBF,
+    0x65,
+    0x66,
+    0x65,
+    0x67,
+  };
+
+  // A null in the string (invalid)
+  static const uint8 data_1[] = {
+    0x65,
+    0x66,
+    0x00,
+    0x67,
+  };
+
+  // A valid string
+  static const uint8 data_2[] = {
+    0x65,
+    0x66,
+    0x65,
+    0x67,
+  };
+
+  // Null at the end (invalid)
+  static const uint8 data_3[] = {
+    0x65,
+    0x66,
+    0x65,
+    0x67,
+    0x00,
+  };
+
+  // A badly formed utf-8 like string (invalid)
+  static const uint8 data_4[] = {
+    0xE9,
+    0xBE,
+    0xE0,
+  };
+
+  // A badly formed utf-8 like string (invalid)
+  static const uint8 data_5[] = {
+    0xC1,
+    0x65,
+    0x66,
+  };
+
+  // A badly formed utf-8 like string (invalid)
+  static const uint8 data_6[] = {
+    0x65,
+    0x66,
+    0xF4,
+  };
+
+  // A valid multi-byte utf-8 string (valid)
+  static const uint8 data_7[] = {
+    0xE9,
+    0xBE,
+    0x8D,
+    0xF0,
+    0x90,
+    0x90,
+    0x92,
+  };
+
+  // A UTF-8 but in D800-DFFF range
+  static const uint8 data_8[] = {
+    0xED,
+    0xA0,
+    0xA1,
+  };
+
+  TestData test_datas[] = {
+    { &data_0[0], arraysize(data_0), true, 3, },
+    { &data_1[0], arraysize(data_1), false, },
+    { &data_2[0], arraysize(data_2), true, },
+    { &data_3[0], arraysize(data_3), false, },
+    { &data_4[0], arraysize(data_4), false, },
+    { &data_5[0], arraysize(data_5), false, },
+    { &data_6[0], arraysize(data_6), false, },
+    { &data_7[0], arraysize(data_7), true, },
+    { &data_8[0], arraysize(data_8), false, },
+  };
+
+  for (unsigned ii = 0; ii < arraysize(test_datas); ++ii) {
+    TestData& test_data = test_datas[ii];
+    RawData::Ref raw_data = RawData::Create(g_service_locator,
+                                            "test",
+                                            test_data.data,
+                                            test_data.length);
+    String str(raw_data->StringValue());
+    if (test_data.valid) {
+      size_t test_length = test_data.length - test_data.offset;
+      const char* test_string = reinterpret_cast<const char*>(test_data.data +
+                                                              test_data.offset);
+      EXPECT_EQ(str.size(), test_length);
+      EXPECT_EQ(str.compare(0, test_length, test_string, test_length), 0);
+    } else {
+      EXPECT_TRUE(str.empty());
+    }
+  }
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/tar_generator.cc b/o3d/import/cross/tar_generator.cc
new file mode 100644
index 0000000..019ec0e
--- /dev/null
+++ b/o3d/import/cross/tar_generator.cc
@@ -0,0 +1,195 @@
+/*
+ * 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 "import/cross/memory_buffer.h"
+#include "import/cross/tar_generator.h"
+
+using std::string;
+
+namespace o3d {
+
+const int kMaxFilenameSize        = 100;
+
+const int kFileNameOffset         = 0;
+const int kFileModeOffset         = 100;
+const int kUserIDOffset           = 108;
+const int kGroupIDOffset          = 116;
+const int kFileSizeOffset         = 124;
+const int kModifyTimeOffset       = 136;
+const int kHeaderCheckSumOffset   = 148;
+const int kLinkFlagOffset         = 156;
+const int kMagicOffset            = 257;
+const int kUserNameOffset         = 265;
+const int kGroupNameOffset        = 297;
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarGenerator::AddFile(const String &file_name, size_t file_size) {
+  AddDirectoryEntryIfNeeded(file_name);
+  AddEntry(file_name, file_size, false);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarGenerator::AddDirectory(const String &file_name) {
+  AddEntry(file_name, 0, true);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// We keep a map so we add a particular directory entry only once
+void TarGenerator::AddDirectoryEntryIfNeeded(const String &file_name) {
+  string::size_type index = file_name.find_last_of('/');
+
+  if (index != string::npos) {
+    String dir_name = file_name.substr(0, index + 1);  // keep the '/' at end
+    if (!directory_map_[dir_name]) {
+      directory_map_[dir_name] = true;
+      AddDirectory(dir_name);
+    }
+  }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarGenerator::AddEntry(const String &file_name,
+                            size_t file_size,
+                            bool is_directory) {
+  // first write out last data block from last file (if any)
+  FlushDataBuffer(true);
+
+  // next fill out a tar header
+  MemoryBuffer<uint8> header(TAR_HEADER_SIZE);  // initializes header to zeroes
+
+  // leave room for NULL-termination
+  uint8 *h = header;
+  char *p = reinterpret_cast<char*>(h);
+
+  // File name
+  strncpy(p, file_name.c_str(), kMaxFilenameSize - 1);
+
+  // File mode
+  snprintf(p + kFileModeOffset, 8, "%07o", is_directory ? 0755 : 0644);
+
+  // UserID
+  snprintf(p + kUserIDOffset, 8, "%07o", 0765);
+
+  // GroupID
+  snprintf(p + kGroupIDOffset, 8, "%07o", 0204);
+
+  // File size
+  snprintf(p + kFileSizeOffset, 12, "%011o", file_size);
+
+  // Modification time
+  // TODO: write the correct current time here...
+  snprintf(p + kModifyTimeOffset, 12, "%07o", 011131753141);
+
+  // Initialize Header checksum so check sum can be computed
+  // by ComputeCheckSum() which will fill in the value here
+  memset(p + kHeaderCheckSumOffset, 32, 8);
+
+  // We only support ordinary files and directories, which is fine
+  // for our use case
+  int link_flag = is_directory ? '5' : '0';
+  p[kLinkFlagOffset] = link_flag;
+
+  // Magic offset
+  snprintf(p + kMagicOffset, 8, "ustar  ");
+
+  // User name
+  snprintf(p + kUserNameOffset, 32, "guest");
+
+  // Group name
+  snprintf(p + kGroupNameOffset, 32, "staff");
+
+
+  // This has to be done at the end
+  ComputeCheckSum(header);
+
+  if (callback_client_) {
+    MemoryReadStream stream(header, TAR_HEADER_SIZE);
+    callback_client_->ProcessBytes(&stream, TAR_HEADER_SIZE);
+  }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarGenerator::ComputeCheckSum(uint8 *header) {
+  unsigned int checksum = 0;
+  for (int i = 0; i < TAR_HEADER_SIZE; ++i) {
+    checksum += header[i];
+  }
+  snprintf(reinterpret_cast<char*>(header + kHeaderCheckSumOffset),
+           8, "%06o\0\0", checksum);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int TarGenerator::AddFileBytes(MemoryReadStream *stream, size_t n) {
+  if (callback_client_) {
+    FlushDataBuffer(false);  // flush any old data sitting around
+
+    // we'll directly write as much of the data as we can, writing full blocks
+    int nblocks = n / TAR_BLOCK_SIZE;
+    size_t direct_bytes_to_write = nblocks * TAR_BLOCK_SIZE;
+    if (direct_bytes_to_write > 0) {
+      callback_client_->ProcessBytes(stream, direct_bytes_to_write);
+    }
+
+    // now, buffer the remainder (less than TAR_BLOCK_SIZE)
+    size_t remainder = n - direct_bytes_to_write;
+
+    const uint8 *p = stream->GetDirectMemoryPointer();
+    data_buffer_stream_.Write(p, remainder);
+    stream->Skip(remainder);
+  }
+
+  return 0;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarGenerator::FlushDataBuffer(bool flush_padding_zeroes) {
+  size_t buffered_bytes = data_buffer_stream_.GetStreamPosition();
+  if (buffered_bytes > 0 && callback_client_) {
+    // write out the complete data block (which may be zero padded at the end)
+    size_t bytes_to_flush =
+        flush_padding_zeroes ? TAR_BLOCK_SIZE : buffered_bytes;
+
+    MemoryReadStream stream(data_block_buffer_, bytes_to_flush);
+    callback_client_->ProcessBytes(&stream, bytes_to_flush);
+
+    // get ready to start buffering next data block
+    data_block_buffer_.Clear();
+    data_buffer_stream_.Seek(0);
+  }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarGenerator::Finalize() {
+  FlushDataBuffer(true);
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/tar_generator.h b/o3d/import/cross/tar_generator.h
new file mode 100644
index 0000000..1468849
--- /dev/null
+++ b/o3d/import/cross/tar_generator.h
@@ -0,0 +1,125 @@
+/*
+ * 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.
+ */
+
+//
+// TarGenerator generates a tar byte stream (uncompressed).
+//
+// A tar byte stream consists of a series of file headers, each followed by
+// the actual file data.  Each file header starts on a block-aligned offset
+// with the blocksize 512.  The start of data for each file is also
+// block-aligned.  Zero-padding is added at the end of the file's data,
+// if necessary to block-align...
+//
+// The normal usage is to call the AddFile() method for each file to add to the
+// archive, then make one or more calls to AddFileBytes() to give the file's
+// data.  Then repeat this sequence for each file to be added.  When done,
+// call Finalize().
+
+#ifndef O3D_IMPORT_CROSS_TAR_GENERATOR_H_
+#define O3D_IMPORT_CROSS_TAR_GENERATOR_H_
+
+#include <map>
+#include <string>
+#include "base/basictypes.h"
+#include "core/cross/types.h"
+#include "import/cross/memory_buffer.h"
+#include "import/cross/memory_stream.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class TarGenerator {
+ public:
+  explicit TarGenerator(StreamProcessor *callback_client)
+      : callback_client_(callback_client),
+        data_block_buffer_(TAR_BLOCK_SIZE),  // initialized to zeroes
+        data_buffer_stream_(data_block_buffer_, TAR_BLOCK_SIZE) {}
+
+  virtual ~TarGenerator() { Finalize(); }
+
+  // Call AddFile() for each file entry, followed by calls to AddFileBytes()
+  // for the file's data
+  virtual void AddFile(const String &file_name,
+                       size_t file_size);
+
+  // Call to "push" bytes to be processed - our client will get called back
+  // with the byte stream, with files rounded up to the nearest block size
+  // (with zero padding)
+  virtual int AddFileBytes(MemoryReadStream *stream, size_t n);
+
+  // Must call this after all files and file data have been written
+  virtual void Finalize();
+
+ private:
+  void AddEntry(const String &file_name,
+                size_t file_size,
+                bool is_directory);
+
+  void AddDirectory(const String &file_name);
+  void AddDirectoryEntryIfNeeded(const String &file_name);
+
+  // Checksum for each header
+  void ComputeCheckSum(uint8 *header);
+
+  // flushes buffered file data to the client callback
+  // if |flush_padding_zeroes| is |true| then flush a complete block
+  // with zero padding even if less was buffered
+  void FlushDataBuffer(bool flush_padding_zeroes);
+
+  enum {TAR_HEADER_SIZE = 512};
+  enum {TAR_BLOCK_SIZE = 512};
+
+  StreamProcessor *callback_client_;
+
+  // Buffers file data here - file data is in multiples of TAR_BLOCK_SIZE
+  MemoryBuffer<uint8> data_block_buffer_;
+  MemoryWriteStream data_buffer_stream_;
+
+  // We use DirectoryMap to keep track of which directories we've already
+  // written out headers for.  The client doesn't need to explicitly
+  // add the directory entries.  Instead, the files will be stripped to their
+  // base path and entries added for the directories as needed...
+  struct StrCmp {
+    bool operator()(const std::string &s1, const std::string &s2) const {
+      return strcmp(s1.c_str(), s2.c_str()) < 0;
+    }
+  };
+
+  typedef std::map<const std::string, bool, StrCmp>  DirectoryMap;
+
+  DirectoryMap directory_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(TarGenerator);
+};
+
+}  // namespace o3d
+
+#endif  //  O3D_IMPORT_CROSS_TAR_GENERATOR_H_
diff --git a/o3d/import/cross/tar_generator_test.cc b/o3d/import/cross/tar_generator_test.cc
new file mode 100644
index 0000000..0e45b8d
--- /dev/null
+++ b/o3d/import/cross/tar_generator_test.cc
@@ -0,0 +1,386 @@
+/*
+ * 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 "core/cross/client.h"
+#include "import/cross/memory_buffer.h"
+#include "import/cross/memory_stream.h"
+#include "import/cross/tar_generator.h"
+#include "tests/common/win/testing_common.h"
+#include "tests/common/cross/test_utils.h"
+
+namespace o3d {
+
+using o3d::StreamProcessor;
+using o3d::MemoryReadStream;
+using o3d::MemoryWriteStream;
+using o3d::TarGenerator;
+
+class TarGeneratorTest : public testing::Test {
+};
+
+const int kBlockSize              = 512;
+
+const int kMaxFilenameSize        = 100;
+
+const int kFileNameOffset         = 0;
+const int kFileModeOffset         = 100;
+const int kUserIDOffset           = 108;
+const int kGroupIDOffset          = 116;
+const int kFileSizeOffset         = 124;
+const int kModifyTimeOffset       = 136;
+const int kHeaderCheckSumOffset   = 148;
+const int kLinkFlagOffset         = 156;
+const int kMagicOffset            = 257;
+const int kUserNameOffset         = 265;
+const int kGroupNameOffset        = 297;
+
+const char *kDirName1 = "test/apples/";
+const char *kDirName2 = "test/oranges/";
+const char *kFileName1 = "test/apples/file1";
+const char *kFileName2 = "test/apples/file2";
+const char *kFileName3 = "test/oranges/file3";
+
+// The first file is less than one block in size
+const char *kFileContents1 =
+    "The cellphone is the world’s most ubiquitous computer.\n"
+    "The four billion cellphones in use around the globe carry personal\n"
+    "information, provide access to the Web and are being used more and more\n"
+    "to navigate the real world. And as cellphones change how we live,\n"
+    "computer scientists say, they are also changing\n"
+    "how we think about information\n";
+
+// The 2nd file takes two blocks
+const char *kFileContents2 =
+    "From Hong Kong to eastern Europe to Wall Street, financial gloom was\n"
+    "everywhere on Tuesday.\n"
+    "Stock markets around the world staggered lower. In New York,\n"
+    "the Dow fell more than 3 percent, coming within sight of its worst\n"
+    "levels since the credit crisis erupted. Financial shares were battered.\n"
+    "And rattled investors clamored to buy rainy-day investments like gold\n"
+    "and Treasury debt. It was a global wave of selling spurred by rising\n"
+    "worries about how banks, automakers — entire countries — would fare\n"
+    "in a deepening global downturn.\n"
+    "'Nobody believes it’s going get better yet,' said Howard Silverblatt,\n"
+    "senior index analyst at Standard & Poor’s. 'Do you see that light at\n"
+    "the end of the tunnel? Any kind of light? Right now, it’s not there'\n"
+    "yet.\n";
+
+// The 3rd file takes one block
+const char *kFileContents3 = "nothing much here...\n";
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Receives the tar bytestream from the TarGenerator.
+// We validate the bytestream as it comes in...
+//
+class CallbackClient : public StreamProcessor {
+ public:
+  // states for state machine, with each state representing one
+  // received block of the tar stream.
+  // The blocks can be either headers (for directories and files)
+  // or data blocks (zero padded at the end to make a full block)
+  enum ValidationState {
+    VALIDATE_DIRECTORY_HEADER1,  // header 1 is directory so no file data
+    VALIDATE_FILE_HEADER1,
+    VALIDATE_FILE_DATA1,         // 1st file takes one block
+    VALIDATE_FILE_HEADER2,
+    VALIDATE_FILE_DATA2_BLOCK1,  // 2nd file takes two blocks
+    VALIDATE_FILE_DATA2_BLOCK2,
+    VALIDATE_DIRECTORY_HEADER2,  // 3rd file is in another directory
+    VALIDATE_FILE_HEADER3,
+    VALIDATE_FILE_DATA3,
+    FINISHED
+  };
+
+  CallbackClient()
+      : state_(VALIDATE_DIRECTORY_HEADER1),
+        total_bytes_received_(0),
+        memory_block_(kBlockSize),
+        write_stream_(memory_block_, kBlockSize) {
+  }
+
+  virtual int     ProcessBytes(MemoryReadStream *stream,
+                               size_t bytes_to_process);
+
+  size_t          GetTotalBytesReceived() { return total_bytes_received_; }
+  int             GetState() { return state_; }
+
+ private:
+  bool            IsOctalDigit(uint8 c);
+  bool            IsOctalString(uint8 *p);
+  unsigned int    ComputeCheckSum(uint8 *header);
+
+  void            ValidateData(uint8 *header, const char *file_contents);
+
+  void            ValidateHeader(uint8 *header,
+                                 const char *file_name,
+                                 size_t file_length);
+
+  // For debugging
+  void            DumpMemoryBlock(uint8 *block);
+
+  int                 state_;
+  size_t              total_bytes_received_;
+  MemoryBuffer<uint8> memory_block_;
+  MemoryWriteStream   write_stream_;
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int CallbackClient::ProcessBytes(MemoryReadStream *stream,
+                                 size_t bytes_to_process) {
+  total_bytes_received_ += bytes_to_process;
+
+  while (bytes_to_process > 0) {
+    size_t remaining = write_stream_.GetRemainingByteCount();
+
+    size_t bytes_this_time =
+        bytes_to_process < remaining ? bytes_to_process : remaining;
+
+    const uint8 *p = stream->GetDirectMemoryPointer();
+    stream->Skip(bytes_this_time);
+
+    write_stream_.Write(p, bytes_this_time);
+
+    // our block buffer is full, so validate it according to our state
+    // machine
+    if (write_stream_.GetRemainingByteCount() == 0) {
+      // DumpMemoryBlock(memory_block_);  // uncomment for debugging
+
+      switch (state_) {
+        case VALIDATE_DIRECTORY_HEADER1:
+          ValidateHeader(memory_block_, kDirName1, 0);
+          break;
+
+        case VALIDATE_FILE_HEADER1:
+          ValidateHeader(memory_block_, kFileName1, strlen(kFileContents1));
+          break;
+
+        case VALIDATE_FILE_DATA1:
+          ValidateData(memory_block_, kFileContents1);
+          break;
+
+        case VALIDATE_FILE_HEADER2:
+          ValidateHeader(memory_block_, kFileName2, strlen(kFileContents2));
+          break;
+
+        case VALIDATE_FILE_DATA2_BLOCK1:
+          // file2 data is larger than one one block, so we'll verify
+          // the two blocks are correct
+          ValidateData(memory_block_, kFileContents2);
+          break;
+
+        case VALIDATE_FILE_DATA2_BLOCK2:
+          ValidateData(memory_block_, kFileContents2 + kBlockSize);
+          break;
+
+        case VALIDATE_DIRECTORY_HEADER2:
+          ValidateHeader(memory_block_, kDirName2, 0);
+          break;
+
+        case VALIDATE_FILE_HEADER3:
+          ValidateHeader(memory_block_, kFileName3, strlen(kFileContents3));
+          break;
+
+        case VALIDATE_FILE_DATA3:
+          ValidateData(memory_block_, kFileContents3);
+          break;
+
+        case FINISHED:
+          break;
+      }
+
+      // Advance to the next state
+      ++state_;
+
+      // So next time we write, we start at beginning of buffer
+      write_stream_.Seek(0);
+    }
+
+    bytes_to_process -= bytes_this_time;
+  }
+
+  return 0;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+bool CallbackClient::IsOctalDigit(uint8 c) {
+  return (c >= '0' && c <= '7');
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+bool CallbackClient::IsOctalString(uint8 *p) {
+  while (IsOctalDigit(*p)) ++p;
+  return *p == 0;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+unsigned int CallbackClient::ComputeCheckSum(uint8 *header) {
+  unsigned int checksum = 0;
+  for (int i = 0; i < kBlockSize; ++i) {
+    uint8 value = header[i];
+    if (i >= kHeaderCheckSumOffset && i < kHeaderCheckSumOffset + 8) {
+      value = 32;  // treat checksum itself as ' '
+    }
+    checksum += value;
+  }
+  return checksum;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// for now |file_contents| must be less than a block size...
+void CallbackClient::ValidateData(uint8 *header,
+                                  const char *file_contents) {
+  // only check up to one block size worth of data
+  int zero_pad_start_index = strlen(file_contents);
+  if (zero_pad_start_index > kBlockSize) zero_pad_start_index = kBlockSize;
+
+  if (zero_pad_start_index <= kBlockSize) {
+    // file data must match
+    uint8 *p = memory_block_;
+    EXPECT_EQ(0, strncmp(file_contents, (const char*)p, kBlockSize));
+
+    // check that zero padding is there
+    bool zero_padding_good = true;
+    for (int i = zero_pad_start_index; i < kBlockSize; ++i) {
+      if (memory_block_[i] != 0) {
+        zero_padding_good = false;
+        break;
+      }
+    }
+    EXPECT_TRUE(zero_padding_good);
+  }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void CallbackClient::ValidateHeader(uint8 *header,
+                                    const char *file_name,
+                                    size_t file_length) {
+  // Validate file name
+  EXPECT_EQ(0,
+            strcmp(reinterpret_cast<char*>(header) + kFileNameOffset,
+                   file_name));
+
+  // Validate length
+  int length_in_header;
+  sscanf((const char*)header + kFileSizeOffset, "%o", &length_in_header);
+  EXPECT_EQ(file_length, length_in_header);
+
+
+  EXPECT_EQ(0, header[kMaxFilenameSize - 1]);
+
+  EXPECT_TRUE(IsOctalString(header + kFileModeOffset));
+  EXPECT_EQ(0, header[kFileModeOffset + 7]);
+
+  EXPECT_TRUE(IsOctalString(header + kUserIDOffset));
+  EXPECT_EQ(0, header[kUserIDOffset + 7]);
+
+  EXPECT_TRUE(IsOctalString(header + kGroupIDOffset));
+  EXPECT_EQ(0, header[kGroupIDOffset + 7]);
+
+  EXPECT_TRUE(IsOctalString(header + kFileSizeOffset));
+  EXPECT_EQ(0, header[kFileSizeOffset + 11]);
+
+  EXPECT_TRUE(IsOctalString(header + kModifyTimeOffset));
+  EXPECT_EQ(0, header[kModifyTimeOffset + 11]);
+
+  EXPECT_TRUE(IsOctalString(header + kHeaderCheckSumOffset));
+  EXPECT_EQ(0, header[kHeaderCheckSumOffset + 6]);
+
+  // For now we only have directories '5' or normal files '0'
+  int link_flag = header[kLinkFlagOffset];
+  EXPECT_TRUE(link_flag == '0' || link_flag == '5');
+
+  EXPECT_EQ(0, strcmp((const char*)header + kMagicOffset, "ustar  "));
+
+  EXPECT_EQ(0, header[kUserNameOffset + 31]);
+  EXPECT_EQ(0, header[kGroupNameOffset + 31]);
+
+  // Validate checksum
+  int checksum = ComputeCheckSum(header);
+  int header_checksum;
+  sscanf((const char*)header + kHeaderCheckSumOffset, "%o", &header_checksum);
+
+  EXPECT_EQ(checksum, header_checksum);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// For debugging purposes
+void CallbackClient::DumpMemoryBlock(uint8 *block) {
+  for (int i = 0; i < kBlockSize; ++i) {
+    if ((i % 16) == 0) printf("\n");
+    char c = block[i];
+    if (c == 0) {
+      c = '.';
+    }
+    printf("%c", c);
+  }
+  printf("\n");
+}
+
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Creates a tar file with three files in two directories
+//
+TEST_F(TarGeneratorTest, CreateSimpleArchive) {
+  CallbackClient client;
+  TarGenerator generator(&client);
+
+  const int kFileLength1 = strlen(kFileContents1);
+  const int kFileLength2 = strlen(kFileContents2);
+  const int kFileLength3 = strlen(kFileContents3);
+
+  generator.AddFile(kFileName1, kFileLength1);
+  MemoryReadStream file1_stream(reinterpret_cast<const uint8*>(kFileContents1),
+                                kFileLength1);
+  generator.AddFileBytes(&file1_stream, kFileLength1);
+
+  generator.AddFile(kFileName2, kFileLength2);
+  MemoryReadStream file2_stream(reinterpret_cast<const uint8*>(kFileContents2),
+                                kFileLength2);
+  generator.AddFileBytes(&file2_stream, kFileLength2);
+
+  generator.AddFile(kFileName3, kFileLength3);
+  MemoryReadStream file3_stream(reinterpret_cast<const uint8*>(kFileContents3),
+                                kFileLength3);
+  generator.AddFileBytes(&file3_stream, kFileLength3);
+
+  generator.Finalize();
+
+  // Verify that the tar byte stream produced is exactly divisible by
+  // the block size
+  size_t bytes_received = client.GetTotalBytesReceived();
+  EXPECT_EQ(0, bytes_received % kBlockSize);
+
+  // Make sure the state machine is in the expected state
+  EXPECT_EQ(CallbackClient::FINISHED, client.GetState());
+}
+
+}  // namespace
diff --git a/o3d/import/cross/tar_processor.cc b/o3d/import/cross/tar_processor.cc
new file mode 100644
index 0000000..bb1d9b8
--- /dev/null
+++ b/o3d/import/cross/tar_processor.cc
@@ -0,0 +1,144 @@
+/*
+ * 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.
+ */
+
+//
+// TarProcessor processes a tar byte stream (uncompressed).
+
+#include "base/logging.h"
+#include "import/cross/tar_processor.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int TarProcessor::ProcessBytes(MemoryReadStream *stream, size_t n) {
+  // Keep processing the byte-stream until we've consumed all we're given
+  //
+  size_t bytes_to_consume = n;
+
+  while (bytes_to_consume > 0) {
+    // First see if we have any more header bytes to read
+    if (header_bytes_read_ < TAR_HEADER_SIZE) {
+      // Read header bytes
+      size_t header_bytes_remaining = TAR_HEADER_SIZE - header_bytes_read_;
+      size_t bytes_to_read = std::min(bytes_to_consume, header_bytes_remaining);
+      size_t bytes_read =
+          stream->Read(reinterpret_cast<uint8*>(header_ + header_bytes_read_),
+                       bytes_to_read);
+      if (bytes_read != bytes_to_read) {
+        return -1;
+      }
+
+      header_bytes_read_ += bytes_to_read;
+      bytes_to_consume -= bytes_to_read;
+
+      if (header_bytes_read_ == TAR_HEADER_SIZE) {
+        const char *filename = (const char *)header_;
+
+        // The tar format stupidly represents size_teger values as
+        // octal strings!!
+        size_t file_size = 0;
+        sscanf(header_ + 124, "%o", &file_size);
+
+        // Only callback client if this is a "real" header
+        // (filename is not NULL)
+        // Extra zero-padding can be added by the gzip compression
+        // (at end of archive), so ignore these ones.
+        //
+        // Also, ignore entries for directories (which have zero size)
+        if (header_[0] != 0 && file_size > 0) {
+          ArchiveFileInfo info(filename, file_size);
+          callback_client_->ReceiveFileHeader(info);
+        } else if (header_[0] == 0) {
+          // If filename is NULL due to zero-padding then file size
+          // should also be NULL
+          assert(file_size == 0);
+        }
+
+        // Round filesize up to nearest block size
+        file_bytes_to_read_ =
+            (file_size + TAR_BLOCK_SIZE - 1) & ~(TAR_BLOCK_SIZE - 1);
+
+        // Our client doesn't want to be bothered with the block padding,
+        // so only send him the actual file bytes
+        client_file_bytes_to_read_ = file_size;
+      }
+    }
+
+    if (bytes_to_consume > 0) {
+      // Looks like we have some left-over bytes past the header
+      // -- size_terpret as file bytes
+      if (client_file_bytes_to_read_ > 0) {
+        // Callback to client with some file data
+
+        // Use a copy of the stream in case the client doesn't read
+        // the amount they're supposed to
+        MemoryReadStream client_read_stream(*stream);
+
+        size_t client_bytes_this_time =
+            std::min(bytes_to_consume, client_file_bytes_to_read_);
+
+        if (!callback_client_->ReceiveFileData(&client_read_stream,
+                                               client_bytes_this_time)) {
+          return -1;
+        }
+
+        client_file_bytes_to_read_ -= client_bytes_this_time;
+        file_bytes_to_read_ -= client_bytes_this_time;
+
+        // Advance stream the amount the client should have consumed
+        stream->Skip(client_bytes_this_time);
+
+        bytes_to_consume -= client_bytes_this_time;
+      }
+
+      // Now, check if we have any padding bytes (up to block size)
+      // past the file data
+      if (bytes_to_consume > 0) {
+        size_t bytes_to_skip = std::min(bytes_to_consume, file_bytes_to_read_);
+        stream->Skip(bytes_to_skip);
+        file_bytes_to_read_ -= bytes_to_skip;
+        bytes_to_consume -= bytes_to_skip;
+      }
+
+      if (file_bytes_to_read_ == 0) {
+        // We've read all of the file data,
+        // so now expect the next file header
+
+        // setting to 0 makes us want more header bytes
+        header_bytes_read_ = 0;
+      }
+    }
+  }
+
+  return 0;
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/tar_processor.h b/o3d/import/cross/tar_processor.h
new file mode 100644
index 0000000..e680e47
--- /dev/null
+++ b/o3d/import/cross/tar_processor.h
@@ -0,0 +1,91 @@
+/*
+ * 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.
+ */
+
+//
+// TarProcessor processes a tar byte stream (uncompressed).
+//
+// A tar byte stream consists of a series of file headers, each followed by
+// the actual file data.  Each file header starts on a block-aligned offset
+// with the blocksize 512.  The start of data for each file is also
+// block-aligned.
+//
+// As a TarProcessor receives bytes, it calls the client
+// callback method ReceiveFileHeader() when each complete file header has been
+// received.  Then the client's ReceiveFileData() will be called (possibly
+// repeatedly) as the file's data is received.  This is repeated until all of
+// the files in the archive have been processed.
+
+#ifndef O3D_IMPORT_CROSS_TAR_PROCESSOR_H_
+#define O3D_IMPORT_CROSS_TAR_PROCESSOR_H_
+
+#include "base/basictypes.h"
+#include "import/cross/memory_stream.h"
+#include "import/cross/archive_processor.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class TarProcessor : public StreamProcessor {
+ public:
+  explicit TarProcessor(ArchiveCallbackClient *callback_client)
+      : callback_client_(callback_client),
+        header_bytes_read_(0),
+        file_bytes_to_read_(0) {}
+
+  virtual ~TarProcessor() {}
+
+  // Call to "push" bytes to be processed - the appropriate callback will get
+  // called when we have enough data
+  virtual int ProcessBytes(MemoryReadStream *stream, size_t n);
+
+ private:
+  enum {TAR_HEADER_SIZE = 512};
+  enum {TAR_BLOCK_SIZE = 512};
+
+  ArchiveCallbackClient  *callback_client_;
+  size_t                  header_bytes_read_;
+  char                   header_[TAR_HEADER_SIZE];
+
+  // Initialized to total number of file bytes,
+  // including zero padding up to block size
+  // We read this many bytes to get to the next header
+  size_t                 file_bytes_to_read_;
+
+  // Initialized to the actual file size (not counting zero-padding) - keeps
+  // track of number of bytes the client needs to read for the current file
+  size_t                 client_file_bytes_to_read_;
+
+  DISALLOW_COPY_AND_ASSIGN(TarProcessor);
+};
+
+}  // namespace o3d
+
+#endif  //  O3D_IMPORT_CROSS_TAR_PROCESSOR_H_
diff --git a/o3d/import/cross/tar_processor_test.cc b/o3d/import/cross/tar_processor_test.cc
new file mode 100644
index 0000000..120aef3
--- /dev/null
+++ b/o3d/import/cross/tar_processor_test.cc
@@ -0,0 +1,151 @@
+/*
+ * 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 "core/cross/client.h"
+#include "import/cross/targz_processor.h"
+#include "tests/common/win/testing_common.h"
+#include "tests/common/cross/test_utils.h"
+
+namespace o3d {
+
+class TarProcessorTest : public testing::Test {
+};
+
+// We verify that the tar file contains exactly these filenames
+static const char *kFilename1 = "test/file1";
+static const char *kFilename2 = "test/file2";
+static const char *kFilename3 = "test/file3";
+
+// With each file having these exact contents
+#define kFileContents1 "the cat in the hat\n"
+#define kFileContents2 "abracadabra\n"
+#define kFileContents3 "I think therefore I am\n"
+
+// we should receive these (and exactly these bytes in this order)
+static const char *kConcatenatedContents =
+    kFileContents1  kFileContents2  kFileContents3;
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class TarTestClient : public ArchiveCallbackClient {
+ public:
+  explicit TarTestClient() : file_count_(0), index_(0) {}
+  // ArchiveCallbackClient methods
+  virtual void ReceiveFileHeader(const ArchiveFileInfo &file_info);
+  virtual bool ReceiveFileData(MemoryReadStream *stream, int nbytes);
+
+  int GetFileCount() const { return file_count_; }
+  size_t GetNumTotalBytesReceived() const { return index_; }
+
+ private:
+  int file_count_;
+  int index_;
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarTestClient::ReceiveFileHeader(const ArchiveFileInfo &file_info) {
+  // We get called one time for each file in the archive
+
+  // Check that the filenames match our expectation
+  switch (file_count_) {
+    case 0:
+      EXPECT_TRUE(!strcmp(kFilename1, file_info.GetFileName().c_str()));
+      break;
+    case 1:
+      EXPECT_TRUE(!strcmp(kFilename2, file_info.GetFileName().c_str()));
+      break;
+    case 2:
+      EXPECT_TRUE(!strcmp(kFilename3, file_info.GetFileName().c_str()));
+      break;
+  }
+
+  file_count_++;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+bool TarTestClient::ReceiveFileData(MemoryReadStream *stream, int nbytes) {
+  const char *p = reinterpret_cast<const char*>(
+      stream->GetDirectMemoryPointer());
+
+  // Note: ReceiveFileData() may be called multiple times for each file, until
+  // the complete file contents have been given...
+
+  // We're receiving three file, one after the other
+  // The bytes we receive are the concatenated contents of the three files
+  // (with calls to ReceiveFileHeader() separating each one)
+  //
+  EXPECT_TRUE(index_ + nbytes <= strlen(kConcatenatedContents));
+  EXPECT_TRUE(!strncmp(kConcatenatedContents + index_, p, nbytes));
+
+  index_ += nbytes;
+
+  return true;
+}
+
+// Loads a tar file, runs it through the processor.
+// In our callbacks, we verify that we receive three files with known contents
+//
+TEST_F(TarProcessorTest, LoadTarFile) {
+  String filepath = *g_program_path + "/archive_files/test1.tar";
+
+  // Read the test tar file into memory
+  size_t file_size;
+  uint8 *tar_data = test_utils::ReadFile(filepath, &file_size);
+  ASSERT_TRUE(tar_data != NULL);
+
+  // Gets header and file data callbacks
+  TarTestClient callback_client;
+
+  // The class we're testing...
+  TarProcessor tar_processor(&callback_client);
+
+  // Now that we've read the compressed file into memory, lets
+  // feed it, a chunk at a time, into the tar_processor
+  const int kChunkSize = 32;
+
+  MemoryReadStream tar_stream(tar_data, file_size);
+  size_t bytes_to_process = file_size;
+
+  int result = Z_OK;
+  while (bytes_to_process > 0) {
+    size_t bytes_this_time =
+        bytes_to_process < kChunkSize ? bytes_to_process : kChunkSize;
+
+    result = tar_processor.ProcessBytes(&tar_stream, bytes_this_time);
+    EXPECT_TRUE(result == Z_OK);
+
+    bytes_to_process -= bytes_this_time;
+  }
+
+  free(tar_data);
+}
+
+}  // namespace
diff --git a/o3d/import/cross/targz_generator.cc b/o3d/import/cross/targz_generator.cc
new file mode 100644
index 0000000..02cb5b3
--- /dev/null
+++ b/o3d/import/cross/targz_generator.cc
@@ -0,0 +1,72 @@
+/*
+ * 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 "import/cross/memory_buffer.h"
+#include "import/cross/targz_generator.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+TarGzGenerator::TarGzGenerator(StreamProcessor *callback_client)
+    : gz_compressor_(callback_client), tar_generator_(this) {
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarGzGenerator::AddFile(const String &file_name, size_t file_size) {
+  tar_generator_.AddFile(file_name, file_size);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int TarGzGenerator::AddFileBytes(MemoryReadStream *stream, size_t n) {
+  return tar_generator_.AddFileBytes(stream, n);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int TarGzGenerator::AddFileBytes(const uint8 *data, size_t n) {
+  MemoryReadStream stream(data, n);
+  return AddFileBytes(&stream, n);
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void TarGzGenerator::Finalize() {
+  tar_generator_.Finalize();
+  gz_compressor_.Finalize();
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+int TarGzGenerator::ProcessBytes(MemoryReadStream *stream,
+                                 size_t bytes_to_process) {
+  // pass bytestream from tar generator to the compressor
+  return gz_compressor_.ProcessBytes(stream, bytes_to_process);
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/targz_generator.h b/o3d/import/cross/targz_generator.h
new file mode 100644
index 0000000..fd58c86
--- /dev/null
+++ b/o3d/import/cross/targz_generator.h
@@ -0,0 +1,91 @@
+/*
+ * 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.
+ */
+
+//
+// TarGzGenerator generates a "tar.gz" byte stream.
+// In other words, given a series of files, it will first create a tar archive
+// from them, then apply gzip compression.
+// This would be equivalent to using the "tar cf" command followed by "gzip"
+//
+// The normal usage is to call the AddFile() method for each file to add to the
+// archive, then make one or more calls to AddFileBytes() to give the file's
+// data.  Then repeat this sequence for each file to be added.  When done,
+// call Finalize().
+
+#ifndef O3D_IMPORT_CROSS_TARGZ_GENERATOR_H_
+#define O3D_IMPORT_CROSS_TARGZ_GENERATOR_H_
+
+#include <string>
+#include "base/basictypes.h"
+#include "core/cross/types.h"
+#include "import/cross/gz_compressor.h"
+#include "import/cross/iarchive_generator.h"
+#include "import/cross/memory_stream.h"
+#include "import/cross/tar_generator.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class TarGzGenerator : public StreamProcessor, public IArchiveGenerator {
+ public:
+  // |callback_client| receives the tar.gz byte stream
+  explicit TarGzGenerator(StreamProcessor *callback_client);
+
+  // Call AddFile() for each file entry, followed by calls to AddFileBytes()
+  // for the file's data
+  void AddFile(const String &file_name,
+               size_t file_size);
+
+  // Call with the file's data (after calling AddFile)
+  // may be called one time with all the file's data, or multiple times
+  // until all the data is provided
+  int AddFileBytes(MemoryReadStream *stream, size_t n);
+  int AddFileBytes(const uint8 *data, size_t n);
+
+  // Must call this after all files and file data have been written
+  virtual void Finalize();
+
+ private:
+  // StreamProcessor method:
+  // Receives the tar bytestream from the TarGenerator.
+  // It then feeds this into the GzCompressor
+  virtual int ProcessBytes(MemoryReadStream *stream,
+                           size_t bytes_to_process);
+
+  GzCompressor gz_compressor_;
+  TarGenerator tar_generator_;
+
+  DISALLOW_COPY_AND_ASSIGN(TarGzGenerator);
+};
+
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_TARGZ_GENERATOR_H_
diff --git a/o3d/import/cross/targz_generator_test.cc b/o3d/import/cross/targz_generator_test.cc
new file mode 100644
index 0000000..8715933
--- /dev/null
+++ b/o3d/import/cross/targz_generator_test.cc
@@ -0,0 +1,166 @@
+/*
+ * 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 <string>
+
+#include "base/file_util.h"
+#include "core/cross/client.h"
+#include "import/cross/memory_stream.h"
+#include "import/cross/targz_generator.h"
+#include "tests/common/cross/test_utils.h"
+#include "tests/common/win/testing_common.h"
+#include "utils/cross/file_path_utils.h"
+
+// Define to generate a new golden file for the archive test.  Don't
+// leave this enabled, as it may affect the results of the test.
+#undef GENERATE_GOLDEN
+
+namespace o3d {
+
+class TarGzGeneratorTest : public testing::Test {
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class TarGzTestClient : public StreamProcessor {
+ public:
+  explicit TarGzTestClient(size_t reference_size)
+      : compressed_data_(reference_size),
+        write_stream_(compressed_data_, reference_size) {
+  };
+
+  virtual int     ProcessBytes(MemoryReadStream *stream,
+                               size_t bytes_to_process) {
+    // Simply buffer up the tar.gz bytes
+    // When we've gotten them all our Validate() method will be called
+    const uint8 *p = stream->GetDirectMemoryPointer();
+    stream->Skip(bytes_to_process);
+
+    size_t remaining = write_stream_.GetRemainingByteCount();
+    EXPECT_TRUE(bytes_to_process <= remaining);
+
+    write_stream_.Write(p, bytes_to_process);
+
+    return 0;
+  }
+
+  // Checks that the data from the reference tar.gz file matches the tar.gz
+  // stream we just ge5nerated
+  void            Validate(uint8 *reference_data) {
+    uint8 *received_data = compressed_data_;
+
+    // on Windows the platform field is different than our reference file
+    received_data[9] = 3;  // Force platform in header to 'UNIX'.
+
+    EXPECT_EQ(0, memcmp(reference_data,
+                        received_data,
+                        compressed_data_.GetLength()));
+  }
+
+#if defined(GENERATE_GOLDEN)
+  char* received_data() {
+    uint8 *data = compressed_data_;
+    data[9] = 3;  // Force platform in header to 'UNIX'.
+    return reinterpret_cast<char*>(data);
+  }
+
+  int received_data_length() {
+    return compressed_data_.GetLength();
+  }
+#endif
+
+ private:
+  MemoryBuffer<uint8>  compressed_data_;
+  MemoryWriteStream    write_stream_;
+
+  DISALLOW_COPY_AND_ASSIGN(TarGzTestClient);
+};
+
+// Generates a tar.gz archive (in memory) containing three files (image, audio,
+// shader) in three separate directories.  The generated archive is then
+// compared with a reference tar.gz file which is known to be correct.
+//
+TEST_F(TarGzGeneratorTest, GenerateTarGz) {
+  String targz_reference_file = *g_program_path + "/archive_files/test2.tar.gz";
+  String image_file = *g_program_path + "/archive_files/keyboard.jpg";
+  String audio_file = *g_program_path + "/archive_files/perc.aif";
+  String shader_file = *g_program_path + "/archive_files/BumpReflect.fx";
+
+  size_t targz_reference_size;
+  size_t image_size;
+  size_t audio_size;
+  size_t shader_size;
+
+  // Read the test files into memory
+  uint8 *targz_data =
+      test_utils::ReadFile(targz_reference_file, &targz_reference_size);
+  uint8 *image_data = test_utils::ReadFile(image_file, &image_size);
+  uint8 *audio_data = test_utils::ReadFile(audio_file, &audio_size);
+  uint8 *shader_data = test_utils::ReadFile(shader_file, &shader_size);
+  ASSERT_TRUE(targz_data != NULL);
+  ASSERT_TRUE(image_data != NULL);
+  ASSERT_TRUE(audio_data != NULL);
+  ASSERT_TRUE(shader_data != NULL);
+
+  ASSERT_NE(0, targz_reference_size);
+
+  TarGzTestClient test_client(targz_reference_size);
+  TarGzGenerator targz_generator(&test_client);
+
+  targz_generator.AddFile("test/images/keyboard.jpg", image_size);
+  targz_generator.AddFileBytes(image_data, image_size);
+
+  targz_generator.AddFile("test/audio/perc.aif", audio_size);
+  targz_generator.AddFileBytes(audio_data, audio_size);
+
+  targz_generator.AddFile("test/shaders/BumpReflect.fx", shader_size);
+  targz_generator.AddFileBytes(shader_data, shader_size);
+
+  targz_generator.Finalize();
+
+#if defined(GENERATE_GOLDEN)
+  std::string new_golden_file = *g_program_path +
+                                "/archive_files/new_golden_test2.tar.gz";
+  file_util::WriteFile(UTF8ToFilePath(new_golden_file),
+                       test_client.received_data(),
+                       test_client.received_data_length());
+
+#endif
+
+  test_client.Validate(targz_data);
+
+  free(targz_data);
+  free(image_data);
+  free(audio_data);
+  free(shader_data);
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/targz_processor.cc b/o3d/import/cross/targz_processor.cc
new file mode 100644
index 0000000..a2a4ba8
--- /dev/null
+++ b/o3d/import/cross/targz_processor.cc
@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+//
+// TarGzProcessor processes a gzipped tar stream (tar.gz)
+// compressed byte stream
+//
+
+#include "import/cross/targz_processor.h"
+
+#include <assert.h>
+#include "import/cross/memory_stream.h"
+
+#define CHUNK 16384
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The |gz_decompressor_| processes a compressed byte stream, calling back
+// into |tar_processor_| with the decompressed byte stream
+// Finally, |tar_processor_| calls back to |callback_client| with file header
+// and file data callbacks...
+//
+TarGzProcessor::TarGzProcessor(ArchiveCallbackClient *callback_client)
+    : ArchiveProcessor(callback_client),
+      tar_processor_(callback_client),
+      gz_decompressor_(&tar_processor_) {
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+int TarGzProcessor::ProcessCompressedBytes(MemoryReadStream *stream,
+                                           size_t bytes_to_process) {
+  int result = gz_decompressor_.ProcessBytes(stream, bytes_to_process);
+  return result;
+}
+
+}  // namespace o3d
diff --git a/o3d/import/cross/targz_processor.h b/o3d/import/cross/targz_processor.h
new file mode 100644
index 0000000..56b5427
--- /dev/null
+++ b/o3d/import/cross/targz_processor.h
@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+//
+// TarGzProcessor processes a gzipped tar stream (tar.gz)
+// compressed byte stream
+//
+
+#ifndef O3D_IMPORT_CROSS_TARGZ_PROCESSOR_H_
+#define O3D_IMPORT_CROSS_TARGZ_PROCESSOR_H_
+
+#include "base/basictypes.h"
+#include "import/cross/archive_processor.h"
+#include "import/cross/gz_decompressor.h"
+#include "import/cross/tar_processor.h"
+
+#include "third_party/zlib/files/zlib.h"
+
+namespace o3d {
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class TarGzProcessor : public ArchiveProcessor {
+ public:
+  explicit TarGzProcessor(ArchiveCallbackClient *callback_client);
+
+  virtual int     ProcessCompressedBytes(MemoryReadStream *stream,
+                                         size_t bytes_to_process);
+
+ private:
+  TarProcessor   tar_processor_;
+  GzDecompressor gz_decompressor_;
+
+  DISALLOW_COPY_AND_ASSIGN(TarGzProcessor);
+};
+
+}  // namespace o3d
+
+#endif  // O3D_IMPORT_CROSS_TARGZ_PROCESSOR_H_
diff --git a/o3d/import/cross/targz_processor_test.cc b/o3d/import/cross/targz_processor_test.cc
new file mode 100644
index 0000000..fd98f27
--- /dev/null
+++ b/o3d/import/cross/targz_processor_test.cc
@@ -0,0 +1,142 @@
+/*
+ * 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 "core/cross/client.h"
+#include "import/cross/targz_processor.h"
+#include "tests/common/win/testing_common.h"
+
+namespace o3d {
+
+class TarGzProcessorTest : public testing::Test {
+};
+
+// We verify that the tar.gz file contains exactly these filenames
+const char *kFilename1 = "test/file1";
+const char *kFilename2 = "test/file2";
+const char *kFilename3 = "test/file3";
+
+// With each file having these exact contents
+#define kFileContents1 "the cat in the hat\n"
+#define kFileContents2 "abracadabra\n"
+#define kFileContents3 "I think therefore I am\n"
+
+// we should receive these (and exactly these bytes in this order)
+const char *kConcatenatedContents =
+    kFileContents1  kFileContents2  kFileContents3;
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class ArchiveTestClient : public ArchiveCallbackClient {
+ public:
+  explicit ArchiveTestClient() : file_count_(0), index_(0) {}
+  // ArchiveCallbackClient methods
+  virtual void ReceiveFileHeader(const ArchiveFileInfo &file_info);
+  virtual bool ReceiveFileData(MemoryReadStream *stream, int nbytes);
+
+  int GetFileCount() const { return file_count_; }
+  size_t GetNumTotalBytesReceived() const { return index_; }
+
+ private:
+  int file_count_;
+  int index_;
+};
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void ArchiveTestClient::ReceiveFileHeader(const ArchiveFileInfo &file_info) {
+  // We get called one time for each file in the archive
+
+  // Check that the filenames match our expectation
+  switch (file_count_) {
+    case 0:
+      EXPECT_TRUE(!strcmp(kFilename1, file_info.GetFileName().c_str()));
+      break;
+    case 1:
+      EXPECT_TRUE(!strcmp(kFilename2, file_info.GetFileName().c_str()));
+      break;
+    case 2:
+      EXPECT_TRUE(!strcmp(kFilename3, file_info.GetFileName().c_str()));
+      break;
+  }
+
+  file_count_++;
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+bool ArchiveTestClient::ReceiveFileData(MemoryReadStream *stream, int nbytes) {
+  const char *p = reinterpret_cast<const char*>(
+      stream->GetDirectMemoryPointer());
+
+  // Note: ReceiveFileData() may be called multiple times for each file, until
+  // the complete file contents have been given...
+
+  // We're receiving three file, one after the other
+  // The bytes we receive are the concatenated contents of the three files
+  // (with calls to ReceiveFileHeader() separating each one)
+  //
+  EXPECT_TRUE(index_ + nbytes <= strlen(kConcatenatedContents));
+  EXPECT_TRUE(!strncmp(kConcatenatedContents + index_, p, nbytes));
+
+  index_ += nbytes;
+
+  return true;
+}
+
+// Loads a tar.gz file, runs it through the processor.
+// In our callbacks, we verify that we receive three files with known contents
+//
+TEST_F(TarGzProcessorTest, LoadTarGzFile) {
+  String filepath = *g_program_path + "/archive_files/test1.tar.gz";
+
+  ArchiveTestClient test_callback_client;
+
+  TarGzProcessor processor(&test_callback_client);
+  int result = processor.ProcessFile(filepath.c_str());
+  EXPECT_EQ(Z_OK, result);
+
+  EXPECT_EQ(3, test_callback_client.GetFileCount());
+  EXPECT_EQ(strlen(kConcatenatedContents),
+            test_callback_client.GetNumTotalBytesReceived());
+}
+
+// Tries to load something with a tar.gz extension, but which isn't
+// really a tar.gz and contains random text
+//
+TEST_F(TarGzProcessorTest, LoadBogusTarGzFile) {
+  String filepath = *g_program_path + "/archive_files/bogus.tar.gz";
+
+  ArchiveTestClient test_callback_client;
+
+  TarGzProcessor processor(&test_callback_client);
+  int result = processor.ProcessFile(filepath.c_str());
+  EXPECT_TRUE(result != Z_OK);
+}
+
+}  // namespace
diff --git a/o3d/import/cross/zip_archive.cc b/o3d/import/cross/zip_archive.cc
new file mode 100644
index 0000000..275722f
--- /dev/null
+++ b/o3d/import/cross/zip_archive.cc
@@ -0,0 +1,876 @@
+/*
+ * 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.
+ */
+
+
+// A basic C++ wrapper for a zip file
+// Adapted from miniunz.c from minizip open source code by Gilles Vollant.
+// Copyright (C) 1998-2005 Gilles Vollant
+
+#include "import/cross/zip_archive.h"
+
+#include "base/basictypes.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#ifdef OS_POSIX
+#include <unistd.h>
+#include <utime.h>
+#include <sys/stat.h>
+#else
+#include <direct.h>
+#include <io.h>
+#include <rpc.h>
+#endif
+
+using std::vector;
+using std::string;
+
+#ifndef ALLOW_USER_QUERY
+#define ALLOW_USER_QUERY      0   // 1: ask before overwriting files
+#endif
+
+#ifndef DEBUGLOG_DESTINATION
+#define DEBUGLOG_DESTINATION  0   // 0: no debug output   1: output to stdout
+#endif
+
+#if DEBUGLOG_DESTINATION == 1
+#define DEBUGLOG(...) printf(__VA_ARGS__)
+#else
+#define DEBUGLOG(...)
+#endif
+
+
+#define CASESENSITIVITY (1)  // activate case sensitivity
+#define WRITEBUFFERSIZE (8192)
+#define MAXFILENAME (1024)
+
+// Creates a basic C++ wrapper for a zip file
+ZipArchive::ZipArchive(const std::string &zip_filename, int *result)
+    : zip_filename_(zip_filename), zip_file_ref_(0) {
+  const char *zip_filename_c = zip_filename_.c_str();
+  char filename_try[MAXFILENAME + 16] = "";
+  strncpy(filename_try, zip_filename_c, MAXFILENAME - 1);
+
+  // strncpy doesn't append the trailing NULL if the string is too long.
+  filename_try[MAXFILENAME] = '\0';
+
+  zip_file_ref_ = unzOpen(zip_filename_c);
+
+  // try appending .zip if |zip_filename| as given wasn't found
+  if (zip_file_ref_ == NULL) {
+    strcat(filename_try, ".zip");
+    zip_file_ref_ = unzOpen(filename_try);
+  }
+
+  if (zip_file_ref_ == NULL) {
+    DEBUGLOG("Cannot open %s or %s.zip\n", zip_filename_c, zip_filename_c);
+    if (result) {
+      *result = 1;
+      return;
+    }
+  }
+  DEBUGLOG("%s opened\n", filename_try);
+
+  *result = UNZ_OK;
+}
+
+ZipArchive::~ZipArchive() {
+  unzClose(zip_file_ref_);
+  zip_file_ref_ = 0;
+}
+
+// The returned filenames should adhere to the zip archive spec
+// (UTF8 with '/' as the path separator)
+// If the zip file is badly constructed then this assumption may be invalid.
+// The filenames will contain a leading '/', with '/' indicating the "root"
+// of the zip archive (as if the zip archive were a filesystem)
+//
+int ZipArchive::GetInformationList(vector<ZipFileInfo> *infolist) {
+  if (!infolist) return -1;
+
+  unz_global_info gi;
+  int result = unzGetGlobalInfo(zip_file_ref_, &gi);
+
+  if (result == UNZ_OK) {
+    unzGoToFirstFile(zip_file_ref_);
+
+    for (uLong i = 0; i < gi.number_entry; ++i) {
+      // get the info for this entry
+      char filename_inzip[MAXFILENAME];  // MAX_PATH
+      ZipFileInfo file_info;
+      result = unzGetCurrentFileInfo(zip_file_ref_,
+                                     &file_info,
+                                     filename_inzip,
+                                     sizeof(filename_inzip),
+                                     NULL,
+                                     0,
+                                     NULL,
+                                     0);
+
+      file_info.name = "/" + string(filename_inzip);
+      infolist->push_back(file_info);
+
+      if ((i + 1) < gi.number_entry) {
+        result = unzGoToNextFile(zip_file_ref_);
+        if (result != UNZ_OK) {
+          DEBUGLOG("error %d with zipfile in unzGoToNextFile\n", result);
+          break;
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+// Returns information for |filename| in |*info|
+// returns 0 if successful
+// |filename| is expected to have a leading '/' (as is returned by
+// GetInformationList() )
+//
+int ZipArchive::GetFileInfo(const string &filename, ZipFileInfo *info) {
+  if (!info) return -1;
+
+  unzGoToFirstFile(zip_file_ref_);
+  unzFile uf = zip_file_ref_;
+
+  string actual_filename;
+  GetActualFilename(filename, &actual_filename);
+
+  if (unzLocateFile(uf, actual_filename.c_str(), CASESENSITIVITY) != UNZ_OK) {
+    DEBUGLOG("file %s not found in the zipfile\n", actual_filename.c_str());
+    return 2;
+  }
+
+  // get the info for this entry
+  char filename_inzip[MAXFILENAME];
+  int result = unzGetCurrentFileInfo(uf,
+                                     info,
+                                     filename_inzip,
+                                     sizeof(filename_inzip),
+                                     NULL,
+                                     0,
+                                     NULL,
+                                     0);
+
+  info->name = "/" + string(filename_inzip);
+
+  return result;
+}
+
+// Extracts the entire archive to disk
+int ZipArchive::Extract() {
+  const char *filename_to_extract = NULL;
+  const char *password = NULL;
+
+  int opt_do_extract = 1;
+  int opt_do_extract_withoutpath = 0;
+  int opt_overwrite = 0;
+  int opt_extractdir = 0;
+  const char *dirname = NULL;
+
+  if (opt_do_extract == 1) {
+    if (opt_extractdir && chdir(dirname)) {
+      DEBUGLOG("Error changing into %s, aborting\n", dirname);
+      exit(-1);
+    }
+
+    if (filename_to_extract == NULL) {
+      return DoExtract(opt_do_extract_withoutpath,
+                       opt_overwrite,
+                       password);
+    } else {
+      return ExtractOneFile(filename_to_extract,
+                            opt_do_extract_withoutpath,
+                            opt_overwrite,
+                            password);
+    }
+  }
+
+  unzCloseCurrentFile(zip_file_ref_);
+}
+
+// Extracts a single file to disk
+int ZipArchive::ExtractOneFile(const string &filename,
+                               int opt_extract_without_path,
+                               int opt_overwrite,
+                               const char *password) {
+  string actual_filename;
+  GetActualFilename(filename, &actual_filename);
+
+  unzGoToFirstFile(zip_file_ref_);
+  if (unzLocateFile(zip_file_ref_,
+                    actual_filename.c_str(),
+                    CASESENSITIVITY) != UNZ_OK) {
+    DEBUGLOG("file %s not found in the zipfile\n", actual_filename.c_str());
+    return 2;
+  }
+
+  if (ExtractCurrentFile(&opt_extract_without_path,
+                         &opt_overwrite,
+                         password) == UNZ_OK) {
+    return UNZ_OK;
+  } else {
+    return 1;
+  }
+}
+
+
+// Extracts a single file and returns a pointer to the file's content.
+// Returns NULL if |filename| doesn't match any in the archive
+// or an error occurs.  The caller must call free() on the returned pointer
+char  *ZipArchive::GetFileData(const string &filename, size_t *size) {
+  string actual_filename;
+  GetActualFilename(filename, &actual_filename);
+
+  unzFile uf = zip_file_ref_;
+
+  unzGoToFirstFile(uf);
+  if (unzLocateFile(uf, actual_filename.c_str(), CASESENSITIVITY) != UNZ_OK) {
+    DEBUGLOG("file %s not found in the zipfile\n", actual_filename.c_str());
+    return NULL;
+  }
+
+  // determine the size of the uncompressed file
+  unz_file_info file_info;
+  char filename_inzip[MAXFILENAME];
+  int result = unzGetCurrentFileInfo(uf,
+                                     &file_info,
+                                     filename_inzip,
+                                     sizeof(filename_inzip),
+                                     NULL,
+                                     0,
+                                     NULL,
+                                     0);
+
+  if (result != UNZ_OK) return NULL;
+
+  if (size) *size = file_info.uncompressed_size;
+
+  result = unzOpenCurrentFilePassword(uf, NULL);
+
+  char *buffer;
+
+  if (result == UNZ_OK) {
+    const int kBufferChunkSize = 32768;
+    void *temp_buffer = malloc(kBufferChunkSize);
+
+    // allocate one extra byte so we can NULL terminate
+    // but don't report this extra byte in the |size| we return
+    // NULL terminating is useful if the data retrieved is to be interpreted
+    // as string data and doesn't harm anything else
+    buffer = reinterpret_cast<char*>(malloc(file_info.uncompressed_size + 1));
+    buffer[file_info.uncompressed_size] = 0;
+    int buffer_index = 0;
+
+    int nbytes;
+    do {
+      nbytes = unzReadCurrentFile(uf, temp_buffer, kBufferChunkSize);
+      if (nbytes < 0) {
+        DEBUGLOG("error %d with zipfile in unzReadCurrentFile\n", result);
+        result = -1;
+        break;
+      }
+      if (nbytes > 0) {
+        // check that we're not exceeding the expected uncompressed size!
+        if (buffer_index + nbytes > file_info.uncompressed_size) {
+          result = -2;
+          break;
+        }
+        memcpy(buffer + buffer_index, temp_buffer, nbytes);
+        buffer_index += nbytes;
+      }
+    } while (nbytes > 0);
+
+    free(temp_buffer);
+
+    if (result == UNZ_OK) {
+      result = unzCloseCurrentFile(uf);
+    }
+  }
+
+  if (result != UNZ_OK) {
+    free(buffer);
+    buffer = NULL;
+  }
+
+  return buffer;
+}
+
+// Convert paths relative to |root_path| to archive paths
+// The |root_path| should start with '/' and should be an actual
+// directory in the zip archive.
+//
+char  *ZipArchive::GetRelativeFileData(const string &relative_path,
+                                       const string &root_path,
+                                       size_t *size) {
+  string converted_filename(relative_path);
+  ConvertRelativeToAbsolutePath(&converted_filename, root_path);
+
+  return GetFileData(converted_filename, size);
+}
+
+// private/protected methods
+//
+#ifdef OS_MACOSX
+#pragma mark -
+#endif
+
+int ZipArchive::ExtractCurrentFile(const int *popt_extract_without_path,
+                                   int *popt_overwrite,
+                                   const char *password) {
+  int result = UNZ_OK;
+
+  unz_file_info file_info;
+  char filename_inzip[MAXFILENAME];
+  result = unzGetCurrentFileInfo(zip_file_ref_,
+                                 &file_info,
+                                 filename_inzip,
+                                 sizeof(filename_inzip),
+                                 NULL,
+                                 0,
+                                 NULL,
+                                 0);
+
+  if (result != UNZ_OK) {
+    DEBUGLOG("error %d with zipfile in unzGetCurrentFileInfo\n", result);
+    return result;
+  }
+
+  DEBUGLOG("ExtractCurrentFile: %s\n", filename_inzip);
+
+  uInt size_buf = WRITEBUFFERSIZE;
+  void *buf = malloc(size_buf);
+
+  char *filename_withoutpath;
+  char *p;
+  p = filename_withoutpath = filename_inzip;
+  while ((*p) != '\0') {
+    if (((*p) == '/') || ((*p) == '\\'))
+      filename_withoutpath = p + 1;
+    p++;
+  }
+
+  if ((*filename_withoutpath) == '\0') {
+    if ((*popt_extract_without_path) == 0) {
+      DEBUGLOG("creating directory: %s\n", filename_inzip);
+      MyMkDir(filename_inzip);
+    }
+  } else {
+    char *write_filename;
+    int skip = 0;
+
+    if ((*popt_extract_without_path) == 0) {
+      write_filename = filename_inzip;
+    } else {
+      write_filename = filename_withoutpath;
+    }
+
+    result = unzOpenCurrentFilePassword(zip_file_ref_, password);
+    if (result != UNZ_OK) {
+      DEBUGLOG("error %d with zipfile in unzOpenCurrentFilePassword\n", result);
+    }
+
+#if ALLOW_USER_QUERY
+    if (((*popt_overwrite) == 0) && (result == UNZ_OK)) {
+      char rep = 0;
+      FILE* ftestexist;
+      ftestexist = fopen(write_filename, "rb");
+
+      if (ftestexist != NULL) {
+        fclose(ftestexist);
+
+        do {
+          char answer[128];
+          int ret;
+
+          DEBUGLOG("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",
+                   write_filename);
+
+          ret = scanf("%1s", answer);
+          if (ret != 1) {
+            exit(EXIT_FAILURE);
+          }
+          rep = answer[0];
+          if ((rep >= 'a') && (rep <= 'z'))
+            rep -= 0x20;
+        }
+        while ((rep != 'Y') && (rep != 'N') && (rep != 'A'));
+      }
+
+      if (rep == 'N')
+        skip = 1;
+
+      if (rep == 'A')
+        *popt_overwrite = 1;
+    }
+#endif  // ALLOW_USER_QUERY
+
+    FILE *fout = NULL;
+    if ((skip == 0) && (result == UNZ_OK)) {
+      DEBUGLOG("fopen: %s\n", write_filename);
+
+      fout = fopen(write_filename, "wb");
+
+      // some zipfiles don't contain directory alone before file
+      if ((fout == NULL) && ((*popt_extract_without_path) == 0) &&
+          (filename_withoutpath != reinterpret_cast<char*>(filename_inzip))) {
+        char c = *(filename_withoutpath - 1);
+        *(filename_withoutpath-1) = '\0';
+        MakeDir(write_filename);
+        *(filename_withoutpath - 1) = c;
+        fout = fopen(write_filename, "wb");
+      }
+
+      if (fout == NULL) {
+        DEBUGLOG("error opening %s\n", write_filename);
+      }
+    }
+
+    if (fout != NULL) {
+      DEBUGLOG(" extracting: %s\n", write_filename);
+
+      do {
+        result = unzReadCurrentFile(zip_file_ref_, buf, size_buf);
+
+        if (result < 0) {
+          DEBUGLOG("error %d with zipfile in unzReadCurrentFile\n", result);
+          break;
+        }
+
+        if (result > 0)
+          if (fwrite(buf, result, 1, fout) != 1) {
+            DEBUGLOG("error in writing extracted file\n");
+            result = UNZ_ERRNO;
+            break;
+          }
+      } while (result > 0);
+
+      if (fout) {
+        fclose(fout);
+      }
+
+      if (result == 0) {
+        ChangeFileDate(write_filename,
+                       file_info.dosDate,
+                       file_info.tmu_date);
+      }
+    }
+
+    if (result == UNZ_OK) {
+      result = unzCloseCurrentFile(zip_file_ref_);
+      if (result != UNZ_OK) {
+        DEBUGLOG("error %d with zipfile in unzCloseCurrentFile\n", result);
+      }
+    } else {
+      unzCloseCurrentFile(zip_file_ref_);  // don't lose the error
+    }
+  }
+
+  free(buf);
+  return result;
+}
+
+int ZipArchive::DoExtract(int opt_extract_without_path,
+                          int opt_overwrite,
+                          const char *password) {
+  unz_global_info gi;
+  int result = unzGetGlobalInfo(zip_file_ref_, &gi);
+
+  if (result != UNZ_OK)
+    DEBUGLOG("error %d with zipfile in unzGetGlobalInfo \n", result);
+
+  for (uLong i = 0; i < gi.number_entry; ++i) {
+    if (ExtractCurrentFile(&opt_extract_without_path,
+                           &opt_overwrite,
+                           password) != UNZ_OK)
+      break;
+
+    if ((i + 1) < gi.number_entry) {
+      result = unzGoToNextFile(zip_file_ref_);
+      if (result != UNZ_OK) {
+        DEBUGLOG("error %d with zipfile in unzGoToNextFile\n", result);
+        break;
+      }
+    }
+  }
+
+  return UNZ_OK;
+}
+
+// ChangeFileDate : change the date/time of a file
+// filename : the filename of the file where date/time must be modified
+// dosdate : the new date at the MSDos format (4 bytes)
+// tmu_date : the SAME new date at the tm_unz format
+void ZipArchive::ChangeFileDate(const char *filename,
+                                uLong dosdate,
+                                tm_unz tmu_date) {
+#if 0  // don't need or want this for now
+#ifdef WIN32
+  HANDLE hFile;
+  FILETIME ftm, ftLocal, ftCreate, ftLastAcc, ftLastWrite;
+
+  hFile = CreateFile(filename, GENERIC_READ | GENERIC_WRITE,
+                     0, NULL, OPEN_EXISTING, 0, NULL);
+  GetFileTime(hFile, &ftCreate, &ftLastAcc, &ftLastWrite);
+  DosDateTimeToFileTime((WORD)(dosdate>>16), (WORD)dosdate, &ftLocal);
+  LocalFileTimeToFileTime(&ftLocal, &ftm);
+  SetFileTime(hFile, &ftm, &ftLastAcc, &ftm);
+  CloseHandle(hFile);
+#else
+#ifdef unix
+  struct utimbuf ut;
+  struct tm newdate;
+  newdate.tm_sec = tmu_date.tm_sec;
+  newdate.tm_min = tmu_date.tm_min;
+  newdate.tm_hour = tmu_date.tm_hour;
+  newdate.tm_mday = tmu_date.tm_mday;
+  newdate.tm_mon = tmu_date.tm_mon;
+
+  if (tmu_date.tm_year > 1900)
+    newdate.tm_year = tmu_date.tm_year - 1900;
+  else
+    newdate.tm_year = tmu_date.tm_year;
+
+  newdate.tm_isdst = -1;
+
+  ut.actime = ut.modtime = mktime(&newdate);
+  utime(filename, &ut);
+#endif
+#endif
+#endif
+}
+
+
+int ZipArchive::MyMkDir(const char *dirname) {
+  int ret = 0;
+#ifdef WIN32
+  ret = mkdir(dirname);
+#else
+#ifdef unix
+  ret = mkdir(dirname, 0775);
+#endif
+#endif
+  return ret;
+}
+
+int ZipArchive::MakeDir(const char *newdir) {
+  int  len = static_cast<int>(strlen(newdir));
+
+  if (len <= 0)
+    return 0;
+
+  char *buffer = reinterpret_cast<char*>(malloc(len + 1));
+  strcpy(buffer, newdir);
+
+  if (buffer[len - 1] == '/') {
+    buffer[len - 1] = '\0';
+  }
+
+  if (MyMkDir(buffer) == 0) {
+    free(buffer);
+    return 1;
+  }
+
+  char *p = buffer + 1;
+  while (1) {
+    while (*p && *p != '\\' && *p != '/')
+      p++;
+
+    char hold = *p;
+    *p = 0;
+
+    if ((MyMkDir(buffer) == -1) && (errno == ENOENT)) {
+      DEBUGLOG("couldn't create directory %s\n", buffer);
+      free(buffer);
+      return 0;
+    }
+
+    if (hold == 0)
+      break;
+
+    *p++ = hold;
+  }
+
+  free(buffer);
+  return 1;
+}
+
+
+// Prints information about the given zip archive
+int ZipArchive::Print() {
+  unzGoToFirstFile(zip_file_ref_);
+
+  unz_global_info gi;
+  int result = unzGetGlobalInfo(zip_file_ref_, &gi);
+  if (result != UNZ_OK) {
+    printf("error %d with zipfile in unzGetGlobalInfo \n", result);
+  } else {
+    printf(" Length  Method   Size  Ratio   Date    Time   CRC-32     Name\n");
+    printf(" ------  ------   ----  -----   ----    ----   ------     ----\n");
+
+    for (int i = 0; i < gi.number_entry; ++i) {
+      char filename_inzip[MAXFILENAME];
+      ZipFileInfo file_info;
+      result = unzGetCurrentFileInfo(zip_file_ref_,
+                                     &file_info,
+                                     filename_inzip,
+                                     sizeof(filename_inzip),
+                                     NULL,
+                                     0,
+                                     NULL,
+                                     0);
+
+      if (result != UNZ_OK) {
+        DEBUGLOG("error %d with zipfile in unzGetCurrentFileInfo\n", result);
+        break;
+      }
+
+      file_info.name = filename_inzip;
+      file_info.Print(false);
+
+      if ((i + 1) < gi.number_entry) {
+        result = unzGoToNextFile(zip_file_ref_);
+        if (result != UNZ_OK) {
+          DEBUGLOG("error %d with zipfile in unzGoToNextFile\n", result);
+          break;
+        }
+      }
+    }
+
+    DEBUGLOG("\n");
+  }
+
+  return result;
+}
+
+// Prints information about the given file
+void  ZipFileInfo::Print(bool print_header) {
+  if (print_header) {
+    printf(" Length  Method   Size  Ratio   Date    Time   CRC-32     Name\n");
+    printf(" ------  ------   ----  -----   ----    ----   ------     ----\n");
+  }
+
+  uLong ratio = 0;
+  if (uncompressed_size > 0) {
+    ratio = (compressed_size * 100) / uncompressed_size;
+  }
+
+  // display a '*' if the file is encrypted
+  char charCrypt = ' ';
+  if ((flag & 1) != 0) {
+    charCrypt = '*';
+  }
+
+  const char *string_method;
+  if (compression_method == 0) {
+    string_method = "Stored";
+  } else {
+    if (compression_method == Z_DEFLATED) {
+      uInt iLevel = (uInt)((flag & 0x6) / 2);
+      if (iLevel == 0) {
+        string_method = "Defl:N";
+      } else if (iLevel == 1) {
+        string_method = "Defl:X";
+      } else if ((iLevel == 2) || (iLevel == 3)) {
+        string_method = "Defl:F";  // 2:fast , 3 : extra fast
+      }
+    } else {
+      string_method = "Unkn. ";
+    }
+  }
+
+  printf("%7lu  %6s%c%7lu %3lu%%  %2.2lu-%2.2lu-%2.2lu  "
+         "%2.2lu:%2.2lu  %8.8lx   %s\n",
+         uncompressed_size,
+         string_method,
+         charCrypt,
+         compressed_size,
+         ratio,
+         (uLong)tmu_date.tm_mon + 1,
+         (uLong)tmu_date.tm_mday,
+         (uLong)tmu_date.tm_year % 100,
+         (uLong)tmu_date.tm_hour,
+         (uLong)tmu_date.tm_min,
+         (uLong)crc, name.c_str());
+}
+
+bool ZipArchive::IsZipFile(const std::string& filename) {
+  int result;
+  // If we can open it, it's a zip file.
+  ZipArchive archive(filename, &result);
+  return result == UNZ_OK;
+}
+
+#ifdef OS_MACOSX
+#pragma mark -
+#endif
+
+// assumes |path| is UTF8 with '/' as the path separator
+void ZipArchive::RemoveLastPathComponent(string *path) {
+  // This gets rid of trailing slashes, if any.
+  int length = path->size();
+  while ((*path)[length - 1] == '/' && length > 0) {
+    path->resize(length - 1);
+    length = path->size();
+  }
+
+  string::size_type index = path->find_last_of('/');
+
+  if (index == string::npos) {
+    *path = "";
+  } else {
+    path->resize(index + 1);  // keep a trailing '/'
+  }
+}
+
+// This assumes |path| is UTF8 with '/' as the path separator normally
+// it should be a relative IETF URI path
+void ZipArchive::ConvertRelativeToAbsolutePath(string *rel_path,
+                                               const string &root_path) {
+  string base_path(root_path);
+  string path(*rel_path);
+
+  if (!path.empty() && path[0] == '/') {
+    // Path is already absolute.
+    return;
+  } else {
+    while (path.size() >= 2 && path[0] == '.' && path[1] == '/') {
+      path = path.substr(2);  // strip off leading ./'s
+    }
+
+    while (path.find("../") == 0) {
+      path = path.substr(3);  // strip off a leading ../
+      RemoveLastPathComponent(&base_path); // strip off a base dir element.
+    }
+
+    *rel_path = base_path + path;
+  }
+}
+
+// This removes leading '/' which is the form that the minizip library
+// likes.  The public ZipArchive API expects pathnames to have the
+// leading '/' treating the zip archive as a file-system rooted at '/'
+void ZipArchive::GetActualFilename(const string &filename,
+                                   string *actual_filename) {
+  if (filename.find('/') == 0) {
+    *actual_filename = filename.substr(1);
+  } else {
+    *actual_filename = filename;
+  }
+}
+
+bool ZipArchive::GetTempFileFromFile(const string &filename,
+                                     string *temp_filename) {
+  if (!temp_filename) return false;
+
+  size_t data_size;
+  char *data = GetFileData(filename, &data_size);
+
+  if (data) {
+#ifdef OS_WIN
+    // get the temp directory
+    char temp_path[MAX_PATH];
+    if (!GetTempPathA(MAX_PATH, temp_path)) {
+      return false;
+    }
+
+    // now generate a GUID
+    UUID guid = {0};
+    UuidCreate(&guid);
+
+    // and format into a wide-string
+    char guid_string[37];
+    snprintf(
+        guid_string, sizeof(guid_string) / sizeof(guid_string[0]),
+        "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+        guid.Data1, guid.Data2, guid.Data3,
+        guid.Data4[0], guid.Data4[1], guid.Data4[2],
+        guid.Data4[3], guid.Data4[4], guid.Data4[5],
+        guid.Data4[6], guid.Data4[7]);
+
+    // format a complete file path for the temp file
+    char fullpath[MAX_PATH];
+
+    int dot_position = filename.rfind('.');
+    if (dot_position != string::npos) {
+      // try to retain the original file suffix (.jpg, etc.)
+      snprintf(fullpath, MAX_PATH, "%s%s%s",
+               temp_path,
+               guid_string,
+               filename.substr(dot_position).c_str());
+    } else {
+      snprintf(fullpath, MAX_PATH, "%s\\%s",
+               temp_path,
+               guid_string);
+    }
+
+    FILE *tempfile = fopen(fullpath, "wb");
+
+    if (tempfile) {
+      fwrite(data, 1, data_size, tempfile);
+      fclose(tempfile);
+      *temp_filename = fullpath;
+    } else {
+      return false;
+    }
+
+#else
+    // get just the final path component
+    int pos = filename.rfind('/');
+    if (pos != string::npos) {
+      // TODO : need to get "proper" temp dir for user
+      // TODO : need to append GUID to filename
+      std::string tmp = "/tmp/" + filename.substr(pos + 1);
+      FILE *fp = fopen(tmp.c_str(), "w");
+
+      if (fp) {
+        fwrite(data, 1, data_size, fp);
+        fclose(fp);
+        *temp_filename = tmp;
+      } else {
+        return false;
+      }
+    }
+#endif
+  }
+
+  return true;
+}
+
+void ZipArchive::DeleteFile(const string &filename) {
+  unlink(filename.c_str());
+}
diff --git a/o3d/import/cross/zip_archive.h b/o3d/import/cross/zip_archive.h
new file mode 100644
index 0000000..4c55539
--- /dev/null
+++ b/o3d/import/cross/zip_archive.h
@@ -0,0 +1,216 @@
+/*
+ * 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.
+ */
+
+
+// A basic C++ wrapper for a zip file
+// Adapted from miniunz.c from minizip open source code by Gilles Vollant.
+
+/*
+  Copyright (C) 1998-2005 Gilles Vollant
+
+  This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
+  WinZip, InfoZip tools and compatible.
+  Multi volume ZipFile (span) are not supported.
+  Encryption compatible with pkzip 2.04g only supported
+  Old compressions used by old PKZip 1.x are not supported
+
+  For uncompress .zip file, look at unzip.h
+
+
+  I WAIT FEEDBACK at mail info@winimage.com
+  Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
+
+  Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+  claim that you wrote the original software. If you use this software
+  in a product, an acknowledgment in the product documentation would be
+  appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+  misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+*/
+
+
+/* Examples Usages:
+
+   int result;
+   ZipArchive archive("test.zip", &result);
+
+   if (result == UNZ_OK) {
+   archive.Print();
+
+   vector<ZipFileInfo> infolist;
+   archive.GetInformationList(&infolist);
+
+   // get all file information and print all file names
+   for (int i = 0; i < infolist.size(); ++i) {
+   printf("[%d] %s\n", i + 1, infolist[i].name.c_str() );
+   }
+
+   // can get information based on file name in the archive
+   // print information about the first file
+   if (infolist.size() > 0) {
+   ZipFileInfo info;
+   result = archive.GetFileInfo(infolist[0].name, &info);
+
+   if (result == UNZ_OK) {
+   info.Print(true);
+   }
+   }
+
+
+   size_t data_size;
+   char *data = archive.GetFileData(infolist[0].name, &data_size);
+   printf("data = %p : data_size = %d\n", data, data_size);
+*/
+
+#ifndef O3D_IMPORT_CROSS_ZIP_ARCHIVE_H_
+#define O3D_IMPORT_CROSS_ZIP_ARCHIVE_H_
+
+#include <string>
+#include <vector>
+
+#ifdef OS_MACOSX
+#define unix
+#endif
+
+#include "third_party/zlib/files/contrib/minizip/unzip.h"
+
+// structure containing the unz_file_info information plus the file name
+struct ZipFileInfo : public unz_file_info {
+  std::string name;
+
+  void  Print(bool print_header);  // prints info to stdout
+};
+
+class ZipArchive {
+ public:
+  // Returns UNZ_OK in |result| on success
+  ZipArchive(const std::string &zip_filename, int *result);
+  virtual ~ZipArchive();
+
+  // The returned filenames should adhere to the zip archive spec
+  // (UTF8 with '/' as the path separator)
+  // If the zip file is badly constructed then this assumption may be invalid.
+  // returns UNZ_OK on success
+  int  GetInformationList(std::vector<ZipFileInfo> *infolist);
+
+  // Returns information for |filename| in |*info|
+  // returns UNZ_OK if successful
+  virtual int GetFileInfo(const std::string &filename, ZipFileInfo *info);
+
+  // Extracts a single file and returns a pointer to the file's content.
+  // Returns NULL if |filename| doesn't match any in the archive
+  // or an error occurs.  The caller must call free() on the returned pointer
+  // the buffer allocated will actually be one byte greater then reported in
+  // |size|.  And this extra byte is set to zero.  This way the data may
+  // be interpreted as a string, and doesn't harm anything else.
+  //
+  virtual char  *GetFileData(const std::string &filename, size_t *size);
+
+  // |relative_path| is taken to be relative to |root_path|
+  // It may contain relative path elements ("../")
+  //
+  // Extracts a single file and returns a pointer to the file's content.
+  // Returns NULL if |filename| doesn't match any in the archive
+  // or an error occurs.  The caller must call free() on the returned pointer
+  //
+  virtual char  *GetRelativeFileData(const std::string &relative_path,
+                                     const std::string &root_path,
+                                     size_t *size);
+
+  // Extracts the entire archive to disk (relative to current working dir)
+  // returns UNZ_OK on success
+  int   Extract();
+
+  // Extracts a single file to disk (relative to current working dir)
+  // returns UNZ_OK on success
+  int   ExtractOneFile(const std::string &filename,
+                       int opt_extract_without_path,
+                       int opt_overwrite,
+                       const char *password);
+
+  // Extracts |filename| from the archive, saves to a temp file, and sets
+  // the path to the temp file in |temp_filename|
+  // returns |true| on success
+  //
+  bool GetTempFileFromFile(const std::string &filename,
+                           std::string *temp_filename);
+
+  // So we can delete the temp file we made
+  static void DeleteFile(const std::string &filename);
+
+  // Lists content of archive to stdout
+  // returns UNZ_OK on success
+  int   Print();
+
+  // Tests the given file to see if it is a zip file.
+  // (Added by Google)
+  static bool IsZipFile(const std::string& filename);
+
+ protected:
+  void  ChangeFileDate(const char *filename, uLong dosdate, tm_unz tmu_date);
+
+  int   MyMkDir(const char *dirname);
+
+  int   MakeDir(const char *newdir);
+
+  int   ExtractCurrentFile(const int *popt_extract_without_path,
+                           int *popt_overwrite,
+                           const char *password);
+
+  int   DoExtract(int opt_extract_without_path,
+                  int opt_overwrite,
+                  const char *password);
+
+  void  RemoveLastPathComponent(std::string *string);
+
+  void  ConvertRelativeToAbsolutePath(std::string *path,
+                                      const std::string &root_path);
+
+  void GetActualFilename(const std::string &filename,
+                         std::string *actual_filename);
+
+  std::string     zip_filename_;
+  unzFile         zip_file_ref_;
+};
+
+#endif  // O3D_IMPORT_CROSS_ZIP_ARCHIVE_H_
diff --git a/o3d/import/fcollada.scons b/o3d/import/fcollada.scons
new file mode 100644
index 0000000..0849f9f
--- /dev/null
+++ b/o3d/import/fcollada.scons
@@ -0,0 +1,267 @@
+# 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.
+
+
+Import('env')
+
+c_sources = [
+  'LibXML/DOCBparser',
+  'LibXML/HTMLparser',
+  'LibXML/HTMLtree',
+  'LibXML/SAX',
+  'LibXML/SAX2',
+  'LibXML/c14n',
+  'LibXML/catalog',
+  'LibXML/chvalid',
+  'LibXML/debugXML',
+  'LibXML/dict',
+  'LibXML/encoding',
+  'LibXML/entities',
+  'LibXML/error',
+  'LibXML/globals',
+  'LibXML/hash',
+  'LibXML/legacy',
+  'LibXML/list',
+  'LibXML/nanoftp',
+  'LibXML/nanohttp',
+  'LibXML/parser',
+  'LibXML/parserInternals',
+  'LibXML/pattern',
+  'LibXML/relaxng',
+  'LibXML/threads',
+  'LibXML/tree',
+  'LibXML/uri',
+  'LibXML/valid',
+  'LibXML/xinclude',
+  'LibXML/xlink',
+  'LibXML/xmlIO',
+  'LibXML/xmlcatalog',
+  'LibXML/xmlmemory',
+  'LibXML/xmlmodule',
+  'LibXML/xmlreader',
+  'LibXML/xmlregexp',
+  'LibXML/xmlsave',
+  'LibXML/xmlstring',
+  'LibXML/xmlunicode',
+  'LibXML/xmlwriter',
+]
+
+cpp_sources = [
+  'DLLEntry',
+  'FCollada',
+  'FColladaPlugin',
+  'StdAfx',
+
+  'FArchiveXML/FAXAnimationExport',
+  'FArchiveXML/FAXAnimationImport',
+  'FArchiveXML/FAXCameraExport',
+  'FArchiveXML/FAXCameraImport',
+  'FArchiveXML/FAXColladaParser',
+  'FArchiveXML/FAXColladaWriter',
+  'FArchiveXML/FAXControllerExport',
+  'FArchiveXML/FAXControllerImport',
+  'FArchiveXML/FAXEmitterExport',
+  'FArchiveXML/FAXEmitterImport',
+  'FArchiveXML/FAXEntityExport',
+  'FArchiveXML/FAXEntityImport',
+  'FArchiveXML/FAXForceFieldExport',
+  'FArchiveXML/FAXForceFieldImport',
+  'FArchiveXML/FAXGeometryExport',
+  'FArchiveXML/FAXGeometryImport',
+  'FArchiveXML/FAXImportLinking',
+  'FArchiveXML/FAXInstanceExport',
+  'FArchiveXML/FAXInstanceImport',
+  'FArchiveXML/FAXLightExport',
+  'FArchiveXML/FAXLightImport',
+  'FArchiveXML/FAXMaterialExport',
+  'FArchiveXML/FAXMaterialImport',
+  'FArchiveXML/FAXPhysicsExport',
+  'FArchiveXML/FAXPhysicsImport',
+  'FArchiveXML/FAXSceneExport',
+  'FArchiveXML/FAXSceneImport',
+  'FArchiveXML/FArchiveXML',
+  'FArchiveXML/StdAfx',
+
+  'FCDocument/FCDAnimated',
+  'FCDocument/FCDAnimation',
+  'FCDocument/FCDAnimationChannel',
+  'FCDocument/FCDAnimationClip',
+  'FCDocument/FCDAnimationClipTools',
+  'FCDocument/FCDAnimationCurve',
+  'FCDocument/FCDAnimationCurveTools',
+  'FCDocument/FCDAnimationKey',
+  'FCDocument/FCDAnimationMultiCurve',
+  'FCDocument/FCDAsset',
+  'FCDocument/FCDCamera',
+  'FCDocument/FCDController',
+  'FCDocument/FCDControllerInstance',
+  'FCDocument/FCDControllerTools',
+  'FCDocument/FCDEffect',
+  'FCDocument/FCDEffectCode',
+  'FCDocument/FCDEffectParameter',
+  'FCDocument/FCDEffectParameterFactory',
+  'FCDocument/FCDEffectParameterSampler',
+  'FCDocument/FCDEffectParameterSurface',
+  'FCDocument/FCDEffectPass',
+  'FCDocument/FCDEffectPassShader',
+  'FCDocument/FCDEffectPassState',
+  'FCDocument/FCDEffectProfile',
+  'FCDocument/FCDEffectProfileFX',
+  'FCDocument/FCDEffectStandard',
+  'FCDocument/FCDEffectTechnique',
+  'FCDocument/FCDEffectTools',
+  'FCDocument/FCDEmitter',
+  'FCDocument/FCDEmitterInstance',
+  'FCDocument/FCDEmitterObject',
+  'FCDocument/FCDEmitterParticle',
+  'FCDocument/FCDEntity',
+  'FCDocument/FCDEntityInstance',
+  'FCDocument/FCDEntityReference',
+  'FCDocument/FCDExternalReferenceManager',
+  'FCDocument/FCDExtra',
+  'FCDocument/FCDForceDeflector',
+  'FCDocument/FCDForceDrag',
+  'FCDocument/FCDForceField',
+  'FCDocument/FCDForceGravity',
+  'FCDocument/FCDForcePBomb',
+  'FCDocument/FCDForceWind',
+  'FCDocument/FCDGeometry',
+  'FCDocument/FCDGeometryInstance',
+  'FCDocument/FCDGeometryMesh',
+  'FCDocument/FCDGeometryNURBSSurface',
+  'FCDocument/FCDGeometryPolygons',
+  'FCDocument/FCDGeometryPolygonsInput',
+  'FCDocument/FCDGeometryPolygonsTools',
+  'FCDocument/FCDGeometrySource',
+  'FCDocument/FCDGeometrySpline',
+  'FCDocument/FCDImage',
+  'FCDocument/FCDLibrary',
+  'FCDocument/FCDLight',
+  'FCDocument/FCDLightTools',
+  'FCDocument/FCDMaterial',
+  'FCDocument/FCDMaterialInstance',
+  'FCDocument/FCDMorphController',
+  'FCDocument/FCDObject',
+  'FCDocument/FCDObjectWithId',
+  'FCDocument/FCDParameterAnimatable',
+  'FCDocument/FCDParticleModifier',
+  'FCDocument/FCDPhysicsAnalyticalGeometry',
+  'FCDocument/FCDPhysicsForceFieldInstance',
+  'FCDocument/FCDPhysicsMaterial',
+  'FCDocument/FCDPhysicsModel',
+  'FCDocument/FCDPhysicsModelInstance',
+  'FCDocument/FCDPhysicsRigidBody',
+  'FCDocument/FCDPhysicsRigidBodyInstance',
+  'FCDocument/FCDPhysicsRigidBodyParameters',
+  'FCDocument/FCDPhysicsRigidConstraint',
+  'FCDocument/FCDPhysicsRigidConstraintInstance',
+  'FCDocument/FCDPhysicsScene',
+  'FCDocument/FCDPhysicsShape',
+  'FCDocument/FCDPlaceHolder',
+  'FCDocument/FCDSceneNode',
+  'FCDocument/FCDSceneNodeIterator',
+  'FCDocument/FCDSceneNodeTools',
+  'FCDocument/FCDSkinController',
+  'FCDocument/FCDTargetedEntity',
+  'FCDocument/FCDTexture',
+  'FCDocument/FCDTransform',
+  'FCDocument/FCDVersion',
+  'FCDocument/FCDocument',
+  'FCDocument/FCDocumentTools',
+
+  'FMath/FMAllocator',
+  'FMath/FMAngleAxis',
+  'FMath/FMColor',
+  'FMath/FMInterpolation',
+  'FMath/FMLookAt',
+  'FMath/FMMatrix33',
+  'FMath/FMMatrix44',
+  'FMath/FMQuaternion',
+  'FMath/FMRandom',
+  'FMath/FMSkew',
+  'FMath/FMVector3',
+  'FMath/FMVolume',
+  'FMath/StdAfx',
+
+  'FUtils/FUAssert',
+  'FUtils/FUBase64',
+  'FUtils/FUBoundingBox',
+  'FUtils/FUBoundingSphere',
+  'FUtils/FUCrc32',
+  'FUtils/FUCriticalSection',
+  'FUtils/FUDaeEnum',
+  'FUtils/FUDateTime',
+  'FUtils/FUDebug',
+  'FUtils/FUError',
+  'FUtils/FUErrorLog',
+  'FUtils/FUFile',
+  'FUtils/FUFileManager',
+  'FUtils/FULogFile',
+  'FUtils/FUObject',
+  'FUtils/FUObjectType',
+  'FUtils/FUParameter',
+  'FUtils/FUParameterizable',
+  'FUtils/FUPluginManager',
+  'FUtils/FUSemaphore',
+  'FUtils/FUStringBuilder',
+  'FUtils/FUStringConversion',
+  'FUtils/FUSynchronizableObject',
+  'FUtils/FUThread',
+  'FUtils/FUTracker',
+  'FUtils/FUUniqueStringMap',
+  'FUtils/FUUniqueStringMapTest',
+  'FUtils/FUUri',
+  'FUtils/FUXmlDocument',
+  'FUtils/FUXmlParser',
+  'FUtils/FUXmlWriter',
+  'FUtils/StdAfx',
+]
+
+env.Append(CPPPATH=['$COLLADA_DIR/LibXML/include', '$COLLADA_DIR'],
+           # Always set RETAIL so that we don't link in tests.
+           CPPDEFINES=['RETAIL'])
+
+# TESTING is added on our test- targets but messes up fcollada
+env.FilterOut(CPPDEFINES=['TESTING'])
+
+if env.Bit('mac'):
+  # LibXML needs this define on Mac.
+  env.Append(CPPDEFINES = ['OS_MACINTOSH'])
+
+if env.Bit('linux'):
+  # On linux, -O3 seems to cause problems with template instantiation, -O2 is
+  # fine.
+  if not env['DEBUG']:
+    env.FilterOut(CCFLAGS=['-O3'])
+    env.Append(CCFLAGS=['-O2'])
+
+inputs = env.MakeObjects(c_sources, '$COLLADA_DIR', 'c')
+inputs += env.MakeObjects(cpp_sources, '$COLLADA_DIR', 'cpp')
+
+env.ComponentLibrary('FColladaU', inputs)
diff --git a/o3d/import/linux/collada_conditioner_linux.cc b/o3d/import/linux/collada_conditioner_linux.cc
new file mode 100644
index 0000000..640c134
--- /dev/null
+++ b/o3d/import/linux/collada_conditioner_linux.cc
@@ -0,0 +1,120 @@
+/*
+ * 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.
+ */
+
+//
+// This file contains the defintions of the functions in the
+// conditioner namespace, which do the bulk of the work of
+// conditioning a Collada file for use in O3D.
+
+#include "import/cross/precompile.h"
+
+#include <sys/wait.h>
+#include <vector>
+
+#include "base/base_paths.h"
+#include "base/file_path.h"
+#include "base/path_service.h"
+#include "core/cross/error.h"
+#include "core/cross/service_locator.h"
+#include "import/cross/collada.h"
+#include "import/cross/collada_conditioner.h"
+
+namespace o3d {
+
+bool ColladaConditioner::CompileHLSL(const String& shader_source,
+                                     const String& vs_entry,
+                                     const String& ps_entry) {
+  // The HLSL compiler isn't available on Linux.
+  return true;
+}
+
+// Find cgc executable, and run it on the input so that we can get a
+// preprocessed version out.
+bool ColladaConditioner::PreprocessShaderFile(const FilePath& in_filename,
+                                              const FilePath& out_filename) {
+  FilePath executable_path;
+  if (!PathService::Get(base::DIR_EXE, &executable_path)) {
+    O3D_ERROR(service_locator_) << "Couldn't get executable path.";
+    return false;
+  }
+  executable_path = executable_path.Append(FILE_PATH_LITERAL("cgc"));
+
+  std::vector<const char*> args;
+  args.push_back(executable_path.value().c_str());
+  args.push_back("-E");
+  args.push_back(in_filename.value().c_str());
+  args.push_back("-o");
+  args.push_back(out_filename.value().c_str());
+  args.push_back(NULL);
+  char** args_array = const_cast<char**>(&*args.begin());
+
+  pid_t pid = ::fork();
+  if (pid < 0) {
+    return false;
+  }
+  if (pid == 0) {
+    DLOG(INFO) << "Now invoking '"
+               << args_array[0] << " "
+               << args_array[1] << " "
+               << args_array[2] << " "
+               << args_array[3] << " "
+               << args_array[4] << "'";
+    char *environ[] = {NULL};
+    ::execve(args[0], args_array, environ);
+    NOTREACHED() << "Problems invoking "
+                 << args_array[0] << " "
+                 << args_array[1] << " "
+                 << args_array[2] << " "
+                 << args_array[3] << " "
+                 << args_array[4];
+  }
+
+  int status;
+  ::wait(&status);
+  if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
+    return true;
+  } else {
+    if (WIFEXITED(status)) {
+      DLOG(ERROR) << "Cgc terminated with status: " << WEXITSTATUS(status);
+    }
+    if (WIFSIGNALED(status)) {
+      DLOG(ERROR) << "Cgc received a signal: " << WTERMSIG(status);
+      if (WCOREDUMP(status)) {
+        DLOG(ERROR) << "and Cgc dumped a core file.";
+      }
+    }
+    if (WIFSTOPPED(status)) {
+      DLOG(ERROR) << "Cgc is stopped on a signal: " << WSTOPSIG(status);
+    }
+  }
+  return false;
+}
+}  // end namespace o3d
diff --git a/o3d/import/mac/collada_conditioner_mac.mm b/o3d/import/mac/collada_conditioner_mac.mm
new file mode 100644
index 0000000..97f98fa
--- /dev/null
+++ b/o3d/import/mac/collada_conditioner_mac.mm
@@ -0,0 +1,105 @@
+/*
+ * 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.
+ */
+
+//
+// This file contains the defintions of the functions in the
+// conditioner namespace, which do the bulk of the work of
+// conditioning a Collada file for use in O3D.
+
+#include "import/cross/precompile.h"
+
+#include <vector>
+#import <Cocoa/Cocoa.h>
+
+#include "base/base_paths.h"
+#include "base/file_path.h"
+#include "base/path_service.h"
+#include "core/cross/error.h"
+#include "import/cross/collada.h"
+#include "import/cross/collada_conditioner.h"
+#include "utils/cross/file_path_utils.h"
+
+namespace o3d {
+bool ColladaConditioner::CompileHLSL(const String& shader_source,
+                                     const String& vs_entry,
+                                     const String& ps_entry) {
+  // The HLSL compiler isn't available on Mac.
+  return true;
+}
+
+// Find cgc executable, and run it on the input so that we can get a
+// preprocessed version out.
+bool ColladaConditioner::PreprocessShaderFile(const FilePath& in_filename,
+                                              const FilePath& out_filename) {
+  FilePath executable_path;
+  if (!PathService::Get(base::DIR_EXE, &executable_path)) {
+    O3D_ERROR(service_locator_) << "Couldn't get executable path.";
+    return false;
+  }
+  executable_path = executable_path.Append(FILE_PATH_LITERAL("cgc"));
+
+  // Have to convert the file paths to UTF-8
+  std::string executable_path_utf8 = FilePathToUTF8(executable_path);
+  std::string in_filename_utf8 = FilePathToUTF8(in_filename);
+  std::string out_filename_utf8 = FilePathToUTF8(out_filename);
+
+  DLOG(INFO) << "Now invoking '"
+             << executable_path_utf8 << " -E "
+             << in_filename_utf8 << " -o "
+             << out_filename_utf8 << "'";
+
+  // Now we have to convert the UTF-8 file paths to NSStrings.
+  NSString *executable_path_ns =
+      [[[NSString alloc] initWithUTF8String:executable_path_utf8.c_str()]
+        autorelease];
+  NSString *in_filename_ns =
+      [[[NSString alloc] initWithUTF8String:in_filename_utf8.c_str()]
+        autorelease];
+  NSString *out_filename_ns =
+      [[[NSString alloc] initWithUTF8String:out_filename_utf8.c_str()]
+        autorelease];
+
+  NSTask *task = [[[NSTask alloc] init] autorelease];
+  [task setLaunchPath:executable_path_ns];
+  [task setArguments:[NSArray arrayWithObjects:@"-E", in_filename_ns,
+                                @"-o", out_filename_ns, nil]];
+
+  // We send the output to a pipe, even though the tool doesn't really
+  // output anything.  This is so that the invocation of the command
+  // will be synchronous, and we can be sure that the output file has
+  // been written by the time we exit this function.
+  NSPipe *pipe = [NSPipe pipe];
+  [task setStandardOutput:pipe];
+  [task launch];
+  NSData *data = [[pipe fileHandleForReading] readDataToEndOfFile];
+  return true;
+}
+}  // end namespace o3d
diff --git a/o3d/import/test_data/crate.dae b/o3d/import/test_data/crate.dae
new file mode 100644
index 0000000..36565ffd
--- /dev/null
+++ b/o3d/import/test_data/crate.dae
@@ -0,0 +1,239 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+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.
+-->
+
+<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1">
+  <asset>
+    <contributor>
+      <authoring_tool>Maya2008 | ColladaMaya v3.05B</authoring_tool>
+      <comments>ColladaMaya export options: bakeTransforms=0;exportPolygonMeshes=1;bakeLighting=0;isSampling=0;
+curveConstrainSampling=0;removeStaticCurves=1;exportCameraAsLookat=0;
+exportLights=1;exportCameras=1;exportJointsAndSkin=1;
+exportAnimations=1;exportTriangles=0;exportInvisibleNodes=0;
+exportNormals=1;exportTexCoords=1;
+exportVertexColors=1;exportVertexColorsAnimation=0;exportTangents=0;
+exportTexTangents=0;exportConstraints=1;exportPhysics=1;exportXRefs=0;
+dereferenceXRefs=1;cameraXFov=0;cameraYFov=1</comments>
+    </contributor>
+    <created>2008-03-05T22:10:14Z</created>
+    <modified>2008-03-05T22:10:14Z</modified>
+    <unit meter="0.01" name="centimeter"/>
+    <up_axis>Y_UP</up_axis>
+  </asset>
+  <library_physics_scenes>
+    <physics_scene id="MayaNativePhysicsScene">
+      <technique_common>
+        <gravity>0 -980 0</gravity>
+        <time_step>0.083</time_step>
+      </technique_common>
+    </physics_scene>
+  </library_physics_scenes>
+  <library_images>
+    <image id="file1" name="file1">
+      <init_from>rock01.tga</init_from>
+      <extra>
+        <technique profile="MAYA">
+          <dgnode_type>kFile</dgnode_type>
+          <image_sequence>0</image_sequence>
+        </technique>
+      </extra>
+    </image>
+  </library_images>
+  <library_materials>
+    <material id="phong1" name="phong1">
+      <instance_effect url="#phong1-fx"/>
+    </material>
+  </library_materials>
+  <library_effects>
+    <effect id="phong1-fx">
+      <profile_COMMON>
+        <newparam sid="file1-surface">
+          <surface type="2D">
+            <init_from>file1</init_from>
+            <format>A8R8G8B8</format>
+          </surface>
+        </newparam>
+        <newparam sid="file1-sampler">
+          <sampler2D>
+            <source>file1-surface</source>
+            <wrap_s>WRAP</wrap_s>
+            <wrap_t>WRAP</wrap_t>
+            <minfilter>NONE</minfilter>
+            <magfilter>NONE</magfilter>
+            <mipfilter>NONE</mipfilter>
+          </sampler2D>
+        </newparam>
+        <technique sid="common">
+          <phong>
+            <emission>
+              <color>0 0 0 1</color>
+            </emission>
+            <ambient>
+              <color>0 0 0 1</color>
+            </ambient>
+            <diffuse>
+              <texture texture="file1-sampler" texcoord="TEX0">
+                <extra>
+                  <technique profile="MAYA">
+                    <wrapU>1</wrapU>
+                    <wrapV>1</wrapV>
+                    <mirrorU>0</mirrorU>
+                    <mirrorV>0</mirrorV>
+                    <coverageU>1</coverageU>
+                    <coverageV>1</coverageV>
+                    <translateFrameU>0</translateFrameU>
+                    <translateFrameV>0</translateFrameV>
+                    <rotateFrame>0</rotateFrame>
+                    <stagger>0</stagger>
+                    <fast>0</fast>
+                    <repeatU>1</repeatU>
+                    <repeatV>1</repeatV>
+                    <offsetU>0</offsetU>
+                    <offsetV>0</offsetV>
+                    <rotateUV>0</rotateUV>
+                    <noiseU>0</noiseU>
+                    <noiseV>0</noiseV>
+                    <blend_mode>NONE</blend_mode>
+                  </technique>
+                </extra>
+              </texture>
+            </diffuse>
+            <specular>
+              <color>0.5 0.5 0.5 1</color>
+            </specular>
+            <shininess>
+              <float>20</float>
+            </shininess>
+            <reflective>
+              <color>0 0 0 1</color>
+            </reflective>
+            <reflectivity>
+              <float>0.5</float>
+            </reflectivity>
+            <transparent opaque="RGB_ZERO">
+              <color>0 0 0 1</color>
+            </transparent>
+            <transparency>
+              <float>1</float>
+            </transparency>
+          </phong>
+          <extra>
+            <technique profile="FCOLLADA"/>
+          </extra>
+        </technique>
+      </profile_COMMON>
+    </effect>
+  </library_effects>
+  <library_geometries>
+    <geometry id="cubeShape" name="cubeShape">
+      <mesh>
+        <source id="cubeShape-positions" name="position">
+          <float_array id="cubeShape-positions-array" count="24">-0.5 -0.5 0.5 0.5 -0.5 0.5 -0.5 0.5 0.5 0.5 0.5 0.5 -0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 -0.5 -0.5 0.5 -0.5 -0.5</float_array>
+          <technique_common>
+            <accessor source="#cubeShape-positions-array" count="8" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="cubeShape-normals" name="normal">
+          <float_array id="cubeShape-normals-array" count="72">0 0 1 0 0 1 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 0 1 0 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 -1 0 0 -1 0 0 -1 0 0 -1 0 1 0 0 1 0 0 1 0 0 1 0 0 -1 0 0 -1 0 0 -1 0 0 -1 0 0</float_array>
+          <technique_common>
+            <accessor source="#cubeShape-normals-array" count="24" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="cubeShape-map1" name="map1">
+          <float_array id="cubeShape-map1-array" count="48">1 0 1 0 0 0 0 1 0 0 1 1 0 0 1 1 0 1 1 1 1 0 1 1 0 0 0 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 1 0 0 1 0 1</float_array>
+          <technique_common>
+            <accessor source="#cubeShape-map1-array" count="24" stride="2">
+              <param name="S" type="float"/>
+              <param name="T" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="cubeShape-vertices">
+          <input semantic="POSITION" source="#cubeShape-positions"/>
+        </vertices>
+        <polylist material="phong1SG" count="6">
+          <input semantic="VERTEX" source="#cubeShape-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#cubeShape-normals" offset="1"/>
+          <input semantic="TEXCOORD" source="#cubeShape-map1" offset="2" set="0"/>
+          <vcount>4 4 4 4 4 4</vcount>
+          <p>0 0 14 1 1 1 3 2 17 2 3 19 2 4 2 3 5 18 5 6 5 4 7 22 4 8 4 5 9 20 7 10 7 6 11 23 6 12 6 7 13 21 1 14 9 0 15 8 1 16 16 7 17 10 5 18 11 3 19 3 6 20 12 0 21 0 2 22 15 4 23 13</p>
+        </polylist>
+      </mesh>
+      <extra>
+        <technique profile="MAYA">
+          <double_sided>1</double_sided>
+          <dynamic_attributes>
+            <miShadingSamplesOverride short_name="mso" type="bool">0</miShadingSamplesOverride>
+            <miShadingSamples short_name="msh" type="float">0</miShadingSamples>
+            <miMaxDisplaceOverride short_name="mdo" type="bool">0</miMaxDisplaceOverride>
+            <miMaxDisplace short_name="mmd" type="float">0</miMaxDisplace>
+          </dynamic_attributes>
+        </technique>
+      </extra>
+    </geometry>
+  </library_geometries>
+  <library_visual_scenes>
+    <visual_scene id="VisualSceneNode" name="crate">
+      <node id="cube" name="cube" type="NODE">
+        <rotate sid="rotateZ">0 0 1 0</rotate>
+        <rotate sid="rotateY">0 1 0 0</rotate>
+        <rotate sid="rotateX">1 0 0 0</rotate>
+        <instance_geometry url="#cubeShape">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="phong1SG" target="#phong1">
+                <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0"/>
+              </instance_material>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+      <extra>
+        <technique profile="FCOLLADA">
+          <start_time>0.041666</start_time>
+          <end_time>2</end_time>
+        </technique>
+      </extra>
+    </visual_scene>
+  </library_visual_scenes>
+  <scene>
+    <instance_physics_scene url="#MayaNativePhysicsScene"/>
+    <instance_visual_scene url="#VisualSceneNode"/>
+  </scene>
+</COLLADA>
diff --git a/o3d/import/test_data/crate.jpg b/o3d/import/test_data/crate.jpg
new file mode 100644
index 0000000..19d3033
--- /dev/null
+++ b/o3d/import/test_data/crate.jpg
diff --git a/o3d/import/test_data/rock01.tga b/o3d/import/test_data/rock01.tga
new file mode 100644
index 0000000..666741d
--- /dev/null
+++ b/o3d/import/test_data/rock01.tga
diff --git a/o3d/import/test_data/rock02.tga b/o3d/import/test_data/rock02.tga
new file mode 100644
index 0000000..481f657
--- /dev/null
+++ b/o3d/import/test_data/rock02.tga
diff --git a/o3d/import/win/collada_conditioner_win.cc b/o3d/import/win/collada_conditioner_win.cc
new file mode 100644
index 0000000..e9d3ebb
--- /dev/null
+++ b/o3d/import/win/collada_conditioner_win.cc
@@ -0,0 +1,154 @@
+/*
+ * 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.
+ */
+
+
+// This file defines platform-specific implementations of certain
+// methods of ColladaConditioner.
+
+#include "import/cross/precompile.h"
+
+#include <d3dx9effect.h>
+
+#include "base/base_paths.h"
+#include "base/file_path.h"
+#include "base/path_service.h"
+#include "core/cross/error.h"
+#include "core/cross/service_locator.h"
+#include "import/cross/collada.h"
+#include "import/cross/collada_conditioner.h"
+
+namespace o3d {
+
+const int kTimeoutInSeconds = 30;
+
+bool ColladaConditioner::CompileHLSL(const String& shader_source,
+                                     const String& vs_entry,
+                                     const String& ps_entry) {
+  bool retval = false;
+  String shader_source_hlsl = shader_source;
+  shader_source_hlsl +=
+      "technique t {\n"
+      "  pass p {\n"
+      "    VertexShader = compile vs_2_0 " + vs_entry + "();\n"
+      "    PixelShader = compile ps_2_0 " + ps_entry + "();\n"
+      "  }\n"
+      "};\n";
+
+  // Create an effect compiler from the FX file.
+  ID3DXEffectCompiler* compiler = NULL;
+  ID3DXBuffer* parse_errors = NULL;
+  HRESULT hr = ::D3DXCreateEffectCompiler(shader_source_hlsl.c_str(),
+                                          static_cast<UINT>(
+                                              shader_source_hlsl.size()),
+                                          NULL,
+                                          NULL,
+                                          0,
+                                          &compiler,
+                                          &parse_errors);
+
+  if (hr != D3D_OK) {
+    const char* error_str = reinterpret_cast<const char*>(
+        parse_errors->GetBufferPointer());
+    O3D_ERROR(service_locator_) << error_str;
+  } else {
+    ID3DXBuffer* effect_buffer;
+    ID3DXBuffer* error_buffer;
+    hr = compiler->CompileEffect(0, &effect_buffer, &error_buffer);
+    if (hr != S_OK) {
+      const char* compile_errors = reinterpret_cast<const char*>(
+          error_buffer->GetBufferPointer());
+      O3D_ERROR(service_locator_) << compile_errors;
+    } else {
+      retval = true;
+      if (effect_buffer) effect_buffer->Release();
+      if (error_buffer) error_buffer->Release();
+    }
+    if (compiler) compiler->Release();
+    if (parse_errors) parse_errors->Release();
+  }
+  return retval;
+}
+
+// Find cgc executable, and run it on the input so that we can get a
+// preprocessed version out.
+bool ColladaConditioner::PreprocessShaderFile(const FilePath& in_filename,
+                                              const FilePath& out_filename) {
+  FilePath executable_path;
+  if (!PathService::Get(base::DIR_EXE, &executable_path)) {
+    O3D_ERROR(service_locator_) << "Couldn't get executable path.";
+    return false;
+  }
+  executable_path = executable_path.Append(FILE_PATH_LITERAL("cgc.exe"));
+  std::wstring cmd;
+  cmd = L"\"" + executable_path.value() +  L"\" ";
+  cmd += L"-E \"" + in_filename.value() + L"\" ";
+  cmd += L"-o \"" + out_filename.value() + L"\"";
+
+  // Have to dup the string because CreateProcessW might modify the
+  // contents.
+  wchar_t* buf = ::wcsdup(cmd.c_str());
+
+  // Initialize structure to zero with default array initializer.
+  PROCESS_INFORMATION process_info = {0};
+  // Initialize structure to it's size, followed by zeros.
+  STARTUPINFO startup_info = {sizeof(STARTUPINFO)};
+
+  BOOL success = ::CreateProcessW(NULL,
+                                  buf,
+                                  NULL,
+                                  NULL,
+                                  TRUE,
+                                  0,
+                                  NULL,
+                                  NULL,
+                                  &startup_info,
+                                  &process_info);
+
+  if (success) {
+    success = FALSE;
+    int exit_code = ::WaitForSingleObject(process_info.hProcess,
+                                          kTimeoutInSeconds * 1000);
+    if (exit_code == WAIT_OBJECT_0) {
+      success = TRUE;
+    } else if (exit_code == WAIT_TIMEOUT) {
+      O3D_ERROR(service_locator_) << "Timed out waiting for cg compiler!";
+    } else {
+      O3D_ERROR(service_locator_) << "Couldn't start cg compiler (cgc.exe).";
+    }
+  } else {
+    O3D_ERROR(service_locator_) << "Couldn't start cg compiler (cgc.exe).";
+  }
+  ::CloseHandle(process_info.hProcess);
+  ::CloseHandle(process_info.hThread);
+  ::free(buf);
+  return success == TRUE;
+}
+}  // end namespace o3d