new pgraph bam

pandatool/src/bam/eggToBam.cxx

@@ -18,13 +18,14 @@
 
 #include "eggToBam.h"
 
-#include <config_util.h>
+#include "config_util.h"
-#include <bamFile.h>
+#include "bamFile.h"
-#include <nodePath.h>
+#include "nodePath.h"
-#include <load_egg_file.h>
+#include "load_egg_file.h"
-#include <config_egg2sg.h>
+#include "qpload_egg_file.h"
-#include <config_gobj.h>
+#include "config_egg2sg.h"
-#include <config_chan.h>
+#include "config_gobj.h"
+#include "config_chan.h"
 
 ////////////////////////////////////////////////////////////////////
 //     Function: EggToBam::Constructor
@@ -43,6 +44,13 @@ EggToBam() :
   // provide it as an option to the user.
   remove_option("f");
 
+  add_option
+    ("p", "", 0,
+     "Writes a pgraph-style bam file, with the new scene graph code, "
+     "suitable for loading in pview (but won't work in demo).  This is "
+     "a temporary hack.",
+     &EggToBam::dispatch_none, &_pgraph_style);
+
   add_option
     ("tp", "path", 0,
      "Add the indicated colon-delimited paths to the texture-path.  This "
@@ -137,34 +145,69 @@ run() {
     _data.set_coordinate_system(CS_zup_right);
   }
 
-  PT_NamedNode root = load_egg_data(_data);
+  if (_pgraph_style) {
-  if (root == (NamedNode *)NULL) {
+    // New style scene graph.
-    nout << "Unable to build scene graph from egg file.\n";
-    exit(1);
-  }
 
-  if (_ls) {
+    PT(PandaNode) root = qpload_egg_data(_data);
-    // If we wanted to list the contents, we need a NodePath.
+    if (root == (PandaNode *)NULL) {
-    NodePath np(root);
+      nout << "Unable to build scene graph from egg file.\n";
-    np.ls();
+      exit(1);
-  }
+    }
 
-  // This should be guaranteed because we pass false to the
+    if (_ls) {
-  // constructor, above.
+      root->ls();
-  nassertv(has_output_filename());
+    }
+    
+    // This should be guaranteed because we pass false to the
+    // constructor, above.
+    nassertv(has_output_filename());
+    
+    Filename filename = get_output_filename();
+    filename.make_dir();
+    nout << "Writing " << filename << "\n";
+    BamFile bam_file;
+    if (!bam_file.open_write(filename)) {
+      nout << "Error in writing.\n";
+      exit(1);
+    }
+    
+    if (!bam_file.write_object(root)) {
+      nout << "Error in writing.\n";
+      exit(1);
+    }
 
-  Filename filename = get_output_filename();
+  } else {
-  filename.make_dir();
+    // Old style scene graph.
-  nout << "Writing " << filename << "\n";
-  BamFile bam_file;
-  if (!bam_file.open_write(filename)) {
-    nout << "Error in writing.\n";
-    exit(1);
-  }
 
-  if (!bam_file.write_object(root)) {
+    PT_NamedNode root = load_egg_data(_data);
-    nout << "Error in writing.\n";
+    if (root == (NamedNode *)NULL) {
-    exit(1);
+      nout << "Unable to build scene graph from egg file.\n";
+      exit(1);
+    }
+
+    if (_ls) {
+      // If we wanted to list the contents, we need a NodePath.
+      NodePath np(root);
+      np.ls();
+    }
+    
+    // This should be guaranteed because we pass false to the
+    // constructor, above.
+    nassertv(has_output_filename());
+    
+    Filename filename = get_output_filename();
+    filename.make_dir();
+    nout << "Writing " << filename << "\n";
+    BamFile bam_file;
+    if (!bam_file.open_write(filename)) {
+      nout << "Error in writing.\n";
+      exit(1);
+    }
+    
+    if (!bam_file.write_object(root)) {
+      nout << "Error in writing.\n";
+      exit(1);
+    }
   }
 }
 

pandatool/src/bam/eggToBam.h

@@ -19,9 +19,9 @@
 #ifndef EGGTOBAM_H
 #define EGGTOBAM_H
 
-#include <pandatoolbase.h>
+#include "pandatoolbase.h"
 
-#include <eggToSomething.h>
+#include "eggToSomething.h"
 
 ////////////////////////////////////////////////////////////////////
 //       Class : EggToBam
@@ -33,6 +33,7 @@ public:
 
   void run();
 
+  bool _pgraph_style;
   bool _keep_paths;
   bool _has_egg_flatten;
   int _egg_flatten;

pandatool/src/egg-palettize/eggFile.cxx

@@ -536,6 +536,7 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void EggFile::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   datagram.add_string(get_name());
 
   // We don't write out _data; that needs to be reread each session.
@@ -570,9 +571,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int EggFile::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr((int)p_list.size() >= _num_textures + 1, 0);
+  int index = TypedWritable::complete_pointers(p_list, manager);
-  int index = 0;
 
   int i;
   _textures.reserve(_num_textures);
@@ -619,6 +619,7 @@ make_EggFile(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void EggFile::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
   set_name(scan.get_string());
   _current_directory = FilenameUnifier::get_bam_filename(scan.get_string());
   _source_filename = FilenameUnifier::get_bam_filename(scan.get_string());

pandatool/src/egg-palettize/eggFile.h

@@ -100,7 +100,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/imageFile.cxx

@@ -410,6 +410,7 @@ output_filename(ostream &out) const {
 ////////////////////////////////////////////////////////////////////
 void ImageFile::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   _properties.write_datagram(writer, datagram);
   datagram.add_string(FilenameUnifier::make_bam_filename(_filename));
   datagram.add_string(FilenameUnifier::make_bam_filename(_alpha_filename));
@@ -427,6 +428,7 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 ////////////////////////////////////////////////////////////////////
 void ImageFile::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
   _properties.fillin(scan, manager);
   _filename = FilenameUnifier::get_bam_filename(scan.get_string());
   _alpha_filename = FilenameUnifier::get_bam_filename(scan.get_string());

pandatool/src/egg-palettize/paletteGroup.cxx

@@ -600,6 +600,7 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void PaletteGroup::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   datagram.add_string(get_name());
   datagram.add_string(_dirname);
   _dependent.write_datagram(writer, datagram);
@@ -631,9 +632,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int PaletteGroup::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr((int)p_list.size() >= _num_placements + _num_pages, 0);
+  int index = TypedWritable::complete_pointers(p_list, manager);
-  int index = 0;
 
   int i;
   for (i = 0; i < _num_placements; i++) {
@@ -711,6 +711,7 @@ make_PaletteGroup(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void PaletteGroup::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
   set_name(scan.get_string());
   _dirname = scan.get_string();
   _dependent.fillin(scan, manager);

pandatool/src/egg-palettize/paletteGroup.h

@@ -108,7 +108,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
   virtual void finalize();
 

pandatool/src/egg-palettize/paletteGroups.cxx

@@ -279,6 +279,7 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void PaletteGroups::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   datagram.add_uint32(_groups.size());
 
   Groups::const_iterator gi;
@@ -297,14 +298,14 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int PaletteGroups::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr(_num_groups == (int)p_list.size(), 0);
+  int pi = TypedWritable::complete_pointers(p_list, manager);
   for (int i = 0; i < _num_groups; i++) {
     PaletteGroup *group;
-    DCAST_INTO_R(group, p_list[i], i);
+    DCAST_INTO_R(group, p_list[pi++], i);
     _groups.insert(group);
   }
-  return 0;
+  return pi;
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -335,6 +336,7 @@ make_PaletteGroups(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void PaletteGroups::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
   _num_groups = scan.get_int32();
   manager->read_pointers(scan, this, _num_groups);
 }

pandatool/src/egg-palettize/paletteGroups.h

@@ -77,7 +77,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/paletteImage.cxx

@@ -791,9 +791,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int PaletteImage::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr((int)p_list.size() >= _num_placements + 1, 0);
+  int index = ImageFile::complete_pointers(p_list, manager);
-  int index = 0;
 
   int i;
   _placements.reserve(_num_placements);

pandatool/src/egg-palettize/paletteImage.h

@@ -106,7 +106,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/palettePage.cxx

@@ -270,6 +270,7 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void PalettePage::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   datagram.add_string(get_name());
 
   writer->write_pointer(datagram, _group);
@@ -294,9 +295,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int PalettePage::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr((int)p_list.size() >= 1 + _num_images, 0);
+  int index = TypedWritable::complete_pointers(p_list, manager);
-  int index = 0;
 
   if (p_list[index] != (TypedWritable *)NULL) {
     DCAST_INTO_R(_group, p_list[index], index);
@@ -343,6 +343,7 @@ make_PalettePage(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void PalettePage::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
   set_name(scan.get_string());
 
   manager->read_pointer(scan, this);  // _group

pandatool/src/egg-palettize/palettePage.h

@@ -73,7 +73,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/palettizer.cxx

@@ -862,6 +862,8 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void Palettizer::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
+
   datagram.add_int32(_pi_version);
   datagram.add_string(_map_dirname);
   datagram.add_string(FilenameUnifier::make_bam_filename(_shadow_dirname));
@@ -916,9 +918,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int Palettizer::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr((int)p_list.size() >= 4 + _num_egg_files + _num_groups + _num_textures, 0);
+  int index = TypedWritable::complete_pointers(p_list, manager);
-  int index = 0;
 
   if (p_list[index] != (TypedWritable *)NULL) {
     DCAST_INTO_R(_color_type, p_list[index], index);
@@ -993,6 +994,8 @@ make_Palettizer(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void Palettizer::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
+
   _read_pi_version = scan.get_int32();
   _map_dirname = scan.get_string();
   _shadow_dirname = FilenameUnifier::get_bam_filename(scan.get_string());

pandatool/src/egg-palettize/palettizer.h

@@ -136,7 +136,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/sourceTextureImage.cxx

@@ -201,11 +201,11 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int SourceTextureImage::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr(p_list.size() >= 1, 0);
+  int pi = ImageFile::complete_pointers(p_list, manager);
 
-  DCAST_INTO_R(_texture, p_list[0], 0);
+  DCAST_INTO_R(_texture, p_list[pi++], pi);
-  return 1;
+  return pi;
 }
 
 ////////////////////////////////////////////////////////////////////

pandatool/src/egg-palettize/sourceTextureImage.h

@@ -56,7 +56,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/textureImage.cxx

@@ -1172,9 +1172,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int TextureImage::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr((int)p_list.size() >= _num_placement * 2 + _num_sources + _num_dests, 0);
+  int index = ImageFile::complete_pointers(p_list, manager);
-  int index = 0;
 
   int i;
   for (i = 0; i < _num_placement; i++) {

pandatool/src/egg-palettize/textureImage.h

@@ -136,7 +136,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/texturePlacement.cxx

@@ -931,6 +931,7 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void TexturePlacement::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   writer->write_pointer(datagram, _texture);
   writer->write_pointer(datagram, _group);
   writer->write_pointer(datagram, _image);
@@ -962,13 +963,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int TexturePlacement::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr((int)p_list.size() >= 3 + _num_references, 0);
+  int index = TypedWritable::complete_pointers(p_list, manager);
-  if (Palettizer::_read_pi_version >= 2) {
-    nassertr((int)p_list.size() >= 4 + _num_references, 0);
-  }
-
-  int index = 0;
 
   if (p_list[index] != (TypedWritable *)NULL) {
     DCAST_INTO_R(_texture, p_list[index], index);
@@ -1031,6 +1027,8 @@ make_TexturePlacement(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void TexturePlacement::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
+
   manager->read_pointer(scan, this);  // _texture
   manager->read_pointer(scan, this);  // _group
   manager->read_pointer(scan, this);  // _image

pandatool/src/egg-palettize/texturePlacement.h

@@ -119,7 +119,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/texturePosition.cxx

@@ -101,6 +101,7 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void TexturePosition::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   datagram.add_int32(_margin);
   datagram.add_int32(_x);
   datagram.add_int32(_y);
@@ -142,6 +143,7 @@ make_TexturePosition(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void TexturePosition::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
   _margin = scan.get_int32();
   _x = scan.get_int32();
   _y = scan.get_int32();

pandatool/src/egg-palettize/textureProperties.cxx

@@ -605,6 +605,7 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void TextureProperties::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   datagram.add_bool(_got_num_channels);
   datagram.add_int32(_num_channels);
   datagram.add_int32((int)_format);
@@ -625,9 +626,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int TextureProperties::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr(p_list.size() >= 2, 0);
+  int index = TypedWritable::complete_pointers(p_list, manager);
-  int index = 0;
 
   if (p_list[index] != (TypedWritable *)NULL) {
     DCAST_INTO_R(_color_type, p_list[index], index);
@@ -670,6 +670,7 @@ make_TextureProperties(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void TextureProperties::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
   _got_num_channels = scan.get_bool();
   _num_channels = scan.get_int32();
   _format = (EggTexture::Format)scan.get_int32();

pandatool/src/egg-palettize/textureProperties.h

@@ -77,7 +77,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected:

pandatool/src/egg-palettize/textureReference.cxx

@@ -688,6 +688,7 @@ register_with_read_factory() {
 ////////////////////////////////////////////////////////////////////
 void TextureReference::
 write_datagram(BamWriter *writer, Datagram &datagram) {
+  TypedWritable::write_datagram(writer, datagram);
   writer->write_pointer(datagram, _egg_file);
 
   // We don't write _egg_tex or _egg_data; that's specific to the
@@ -720,9 +721,8 @@ write_datagram(BamWriter *writer, Datagram &datagram) {
 //               number of pointers processed from the list.
 ////////////////////////////////////////////////////////////////////
 int TextureReference::
-complete_pointers(vector_typedWritable &p_list, BamReader *manager) {
+complete_pointers(TypedWritable **p_list, BamReader *manager) {
-  nassertr((int)p_list.size() >= 3, 0);
+  int index = TypedWritable::complete_pointers(p_list, manager);
-  int index = 0;
 
   if (p_list[index] != (TypedWritable *)NULL) {
     DCAST_INTO_R(_egg_file, p_list[index], index);
@@ -770,6 +770,7 @@ make_TextureReference(const FactoryParams &params) {
 ////////////////////////////////////////////////////////////////////
 void TextureReference::
 fillin(DatagramIterator &scan, BamReader *manager) {
+  TypedWritable::fillin(scan, manager);
   manager->read_pointer(scan, this);  // _egg_file
 
   _tex_mat.read_datagram(scan);

pandatool/src/egg-palettize/textureReference.h

@@ -105,7 +105,7 @@ private:
 public:
   static void register_with_read_factory();
   virtual void write_datagram(BamWriter *writer, Datagram &datagram);
-  virtual int complete_pointers(vector_typedWritable &p_list,
+  virtual int complete_pointers(TypedWritable **p_list,
                                 BamReader *manager);
 
 protected: