Add o3djs.DestinationBuffer to converter....

serializer/cross/serializer.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 29 matching lines @@
 #include "core/cross/buffer.h"
 #include "core/cross/curve.h"
 #include "core/cross/iclass_manager.h"
 #include "core/cross/pack.h"
 #include "core/cross/param_array.h"
 #include "core/cross/primitive.h"
 #include "core/cross/shape.h"
 #include "core/cross/skin.h"
 #include "core/cross/texture.h"
 #include "core/cross/transform.h"
+#include "import/cross/destination_buffer.h"
 #include "import/cross/iarchive_generator.h"
 #include "import/cross/memory_buffer.h"
 #include "import/cross/memory_stream.h"
 #include "serializer/cross/version.h"
 #include "utils/cross/structured_writer.h"
 
 using std::string;
 
 namespace o3d {
 
@@ skipping 278 matching lines @@
 
   StructuredWriter* writer_;
 };
 
 class CustomVisitor : public VisitorBase<CustomVisitor> {
  public:
   explicit CustomVisitor(StructuredWriter* writer,
                          BinaryArchiveManager* binary_archive_manager)
       : writer_(writer),
         binary_archive_manager_(binary_archive_manager) {
+    Enable<DestinationBuffer>(&CustomVisitor::Visit);
     Enable<Buffer>(&CustomVisitor::Visit);
     Enable<Curve>(&CustomVisitor::Visit);
     Enable<Primitive>(&CustomVisitor::Visit);
     Enable<Skin>(&CustomVisitor::Visit);
     Enable<SkinEval>(&CustomVisitor::Visit);
     Enable<StreamBank>(&CustomVisitor::Visit);
     Enable<Texture2D>(&CustomVisitor::Visit);
     Enable<TextureCUBE>(&CustomVisitor::Visit);
   }
 
  private:
+  void Visit(DestinationBuffer* buffer) {
+    Visit(static_cast<NamedObject*>(buffer));

[apatrick, 2009/07/07 00:58:25]

Comment why its not the base class.

+    writer_->WritePropertyName("numElements");
+    Serialize(writer_, buffer->num_elements());
+    writer_->WritePropertyName("fields");
+    writer_->OpenArray();
+    const FieldRefArray& fields = buffer->fields();
+    for (size_t ii = 0; ii < fields.size(); ++ii) {
+      Field* field = fields[ii].Get();
+      writer_->BeginCompacting();
+      writer_->OpenObject();
+      writer_->WritePropertyName("id");
+      Serialize(writer_, field->id());
+      writer_->WritePropertyName("type");
+      Serialize(writer_, field->GetClassName());
+      writer_->WritePropertyName("numComponents");
+      Serialize(writer_, field->num_components());
+      writer_->CloseObject();
+      writer_->EndCompacting();
+    }
+    writer_->CloseArray();
+  }
+
   void Visit(Buffer* buffer) {
     Visit(static_cast<NamedObject*>(buffer));
 
     writer_->WritePropertyName("fields");
     writer_->OpenArray();
     const FieldRefArray& fields = buffer->fields();
     for (size_t ii = 0; ii < fields.size(); ++ii) {
       Field* field = fields[ii].Get();
       Serialize(writer_, field->id());
     }
@@ skipping 209 matching lines @@
 
   StructuredWriter* writer_;
 };
 
 class BinaryVisitor : public VisitorBase<BinaryVisitor> {
  public:
   explicit BinaryVisitor(BinaryArchiveManager* binary_archive_manager)
       : binary_archive_manager_(binary_archive_manager) {
     Enable<Curve>(&BinaryVisitor::Visit);
     Enable<IndexBuffer>(&BinaryVisitor::Visit);
+    Enable<DestinationBuffer>(&BinaryVisitor::Visit);
     Enable<VertexBufferBase>(&BinaryVisitor::Visit);
     Enable<Skin>(&BinaryVisitor::Visit);
   }
 
  private:
   void Visit(ObjectBase* object) {
   }
 
   // TODO: Replace this when we have code to serialize to the
   // final binary format. This is just placeholder.
   void Visit(Curve* curve) {
     Visit(static_cast<NamedObject*>(curve));
 
     MemoryBuffer<uint8> serialized_data;
     SerializeCurve(*curve, &serialized_data);
 
     binary_archive_manager_->WriteObjectBinary(
         curve,
         "curve-keys.bin",
         serialized_data,
         serialized_data.GetLength());
   }
 
+  void Visit(DestinationBuffer* buffer) {
+    // Destination buffers should NOT have their contents serialized.
+    Visit(static_cast<Buffer*>(buffer));
+  }
+
   void Visit(IndexBuffer* buffer) {
     Visit(static_cast<Buffer*>(buffer));
 
     MemoryBuffer<uint8> serialized_data;
     SerializeBuffer(*buffer, &serialized_data);
 
     binary_archive_manager_->WriteObjectBinary(
         buffer,
         "index-buffers.bin",
         serialized_data,
@@ skipping 157 matching lines @@
 
 void Serializer::SerializeSection(ObjectBase* object, Section section) {
   DCHECK(section >= 0 && section < NUM_SECTIONS);
   sections_[section].visitor_->Accept(object);
 }
 
 void Serializer::SerializeParam(Param* param) {
   param_visitor_->Accept(param);
 }
 }  // namespace o3d