Add o3djs.DestinationBuffer to converter....

import/cross/collada.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 18 matching lines @@
  * 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/class_manager.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 "import/cross/destination_buffer.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)
 
@@ skipping 74 matching lines @@
                      Transform* parent,
                      ParamFloat* animation_input,
                      const Options& options) {
   return Collada::Import(pack,
                          UTF8ToFilePath(filename),
                          parent,
                          animation_input,
                          options);
 }
 
+void Collada::Init(ServiceLocator* service_locator) {
+  ClassManager* class_manager=
+      service_locator->GetService<o3d::ClassManager>();
+  class_manager->AddTypedClass<DestinationBuffer>();
+}
+
 // 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),
@@ skipping 224 matching lines @@
         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_);
+        if (ImportTree(instance_root_, parent, animation_input)) {
+          if (ImportTreeInstances(doc, instance_root_)) {
+            status = true;
+          }
+        }
         delete instance_root_;
         instance_root_ = NULL;
-        status = true;
       }
     }
   }
   return status;
 }
 
 namespace {
 
 Curve::Infinity ConvertInfinity(FUDaeInfinity::Infinity infinity) {
   switch (infinity) {
@@ skipping 380 matching lines @@
 }
 
 // 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,
+bool 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);
+    if (!ImportTree(children[i], transform, animation_input)) {
+      return false;
+    }
   }
+  return true;
 }
 
-void Collada::ImportTreeInstances(FCDocument* doc,
+bool 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]);
+    if (!ImportTreeInstances(doc, children[i])) {
+      return false;
+    }
   }
 
   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(o3d): 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);
+        FCDController* controller =
+            static_cast<FCDController*>(controller_instance->GetEntity());
+        if (controller) {
+          if (controller->IsSkin()) {
+            Shape* shape = GetSkinnedShape(doc,
+                                           controller_instance,
+                                           node_instance);
+            if (shape) {
+              transform->AddShape(shape);
+            } else {
+              return false;
+            }
+          }
         }
         break;
       }
       default:
         // do nothing
         break;
     }
   }
+  return true;
 }
 
 // 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;
@@ skipping 440 matching lines @@
         }
       }
     }
 
     // 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())) {
+    if (elements.empty()) {
       return NULL;
     }
+    // check that they all use the same StreamBank and are all Primitives
+    for (unsigned ii = 0; ii < elements.size(); ++ii) {
+      if (!elements[ii]->IsA(Primitive::GetApparentClass())) {
+        O3D_ERROR(service_locator_)
+            << "Element in Shape '" << shape->name() << "' is not a Primitive.";
+        return NULL;
+      }
+      if (down_cast<Primitive*>(elements[ii].Get())->stream_bank() !=
+          down_cast<Primitive*>(elements[0].Get())->stream_bank()) {
+        O3D_ERROR(service_locator_)
+            << "More than one StreamBank in Shape '" << shape->name() << "'.";
+        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);
 
@@ skipping 71 matching lines @@
     // two issues come up
     //
     // 1) If we serialize that VertexBuffer, POSITION and NORMAL are stored
     // twice. Once in the SourceBuffer, again in the VertexBuffer. That's a lot
     // of data to download just to throw it away.
     //
     // 2) If we want to instance the skin we'll need to make a new VertexBuffer
     // so we can store the skinned vertices for the second instance. But we'd
     // like to share the COLOR and TEXCOORDS. To do that they need to be in
     // a separate VertexBuffer.
-    StreamBank* stream_bank = primitive->stream_bank();
-    SourceBuffer* buffer = pack_->Create<SourceBuffer>();
+    StreamBank* old_stream_bank = primitive->stream_bank();
+    StreamBank* new_stream_bank = pack_->Create<StreamBank>();
+    new_stream_bank->set_name(String("skinned_") + old_stream_bank->name());
+    Buffer* old_buffer = NULL;
+    SourceBuffer* source_buffer = pack_->Create<SourceBuffer>();
     VertexBuffer* shared_buffer = pack_->Create<VertexBuffer>();
+    DestinationBuffer* dest_buffer = pack_->Create<DestinationBuffer>();
     const StreamParamVector& source_stream_params =
-        stream_bank->vertex_stream_params();
-    std::vector<Field*> new_fields(source_stream_params.size(), NULL);
+        old_stream_bank->vertex_stream_params();
+    std::vector<Field*> source_fields(source_stream_params.size(), NULL);
+    std::vector<Field*> dest_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 (old_buffer == NULL) {
+        old_buffer = field.buffer();
+      } else if (old_buffer != field.buffer()) {
+        O3D_ERROR(service_locator_)
+            << "More than 1 buffer used by StreamBank '"
+            << old_stream_bank->name().c_str()
+            << "' which the collada importer does not currently support";
+      }
       bool copied = false;
       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: {
             copied = true;
             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()
+                  << old_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);
+            source_fields[ii] = source_buffer->CreateField(
+                FloatField::GetApparentClass(), num_source_components);
+            DCHECK(source_fields[ii]);
+            dest_fields[ii] = dest_buffer->CreateField(
+                FloatField::GetApparentClass(), num_source_components);
+            DCHECK(dest_fields[ii]);
+            if (!new_stream_bank->SetVertexStream(
+                source_stream.semantic(),
+                source_stream.semantic_index(),
+                dest_fields[ii],
+                0)) {
+              O3D_ERROR(service_locator_)
+                << "could not SetVertexStream on StreamBank '"
+                << new_stream_bank->name() << "'";
+              return NULL;
+            }
           }
         }
       }
       if (!copied) {
         // It's a shared field, copy it to the shared buffer.
-        new_fields[ii] = shared_buffer->CreateField(field.GetClass(),
-                                                    field.num_components());
+        source_fields[ii] = shared_buffer->CreateField(field.GetClass(),
+                                                       field.num_components());
+        new_stream_bank->SetVertexStream(source_stream.semantic(),
+                                         source_stream.semantic_index(),
+                                         source_fields[ii],
+                                         0);
       }
     }
 
-    if (!buffer->AllocateElements(num_vertices) ||
-        !shared_buffer->AllocateElements(num_vertices)) {
+    if (!source_buffer->AllocateElements(num_vertices) ||
+        !shared_buffer->AllocateElements(num_vertices) ||
+        !dest_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();
       bool copied = false;
       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: {
             copied = true;
             unsigned num_source_components = field.num_components();
-            Field* new_field = new_fields[ii];
+            Field* source_field = source_fields[ii];
 
             std::vector<float> data(num_vertices * num_source_components);
             field.GetAsFloats(0, &data[0], num_source_components,
                               num_vertices);
             // TODO(o3d): 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: {
@@ skipping 20 matching lines @@
                                                   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);
+            source_field->SetFromFloats(&data[0], num_source_components, 0,
+                                        num_vertices);
             // Bind streams
             skin_eval->SetVertexStream(source_stream.semantic(),
                                        source_stream.semantic_index(),
-                                       new_field,
+                                       source_field,
                                        0);
-            stream_bank->BindStream(skin_eval,
-                                    source_stream.semantic(),
-                                    source_stream.semantic_index());
+            new_stream_bank->BindStream(skin_eval,
+                                        source_stream.semantic(),
+                                        source_stream.semantic_index());
             break;
           }
         }
       }
       if (!copied) {
-        Field* new_field = new_fields[ii];
-        new_field->Copy(field);
-        field.buffer()->RemoveField(&source_stream.field());
-        stream_bank->SetVertexStream(source_stream.semantic(),
-                                     source_stream.semantic_index(),
-                                     new_field,
-                                     0);
+        Field* source_field = source_fields[ii];
+        source_field->Copy(field);
       }
     }
+
+    // Set all primitives to use new stream bank.
+    for (unsigned ii = 0; ii < elements.size(); ++ii) {
+      down_cast<Primitive*>(elements[ii].Get())->set_stream_bank(
+          new_stream_bank);
+    }
+    pack_->RemoveObject(old_stream_bank);
+    if (old_buffer) {
+      source_buffer->set_name(String("source_") + old_buffer->name());
+      dest_buffer->set_name(String("skinned_") + old_buffer->name());
+      shared_buffer->set_name(String("shared_") + old_buffer->name());
+      pack_->RemoveObject(old_buffer);
+    }
   }
   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;
@@ skipping 1207 matching lines @@
       SetParamFromFCEffectParam(param_object,
                                 kMaterialParamNameShininess,
                                 effect_standard->GetShininessParam());
       SetParamFromFCEffectParam(param_object,
                                 kMaterialParamNameSpecularFactor,
                                 effect_standard->GetSpecularFactorParam());
     }
   }
 }
 }  // namespace o3d