TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-02 09:52:27 -04:00
Code Issues Packages Projects Releases Wiki Activity

new pgraph bam

Browse Source
This commit is contained in:
David Rose 2002-03-05 02:48:20 +00:00
parent 65395b9721
commit d6ed3f9092
26 changed files with 137 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
pandatool/src/bam/eggToBam.cxx
View File

@ -18,13 +18,14 @@
#include "eggToBam.h"
#include <config_util.h>
#include <bamFile.h>
#include <nodePath.h>
#include <load_egg_file.h>
#include <config_egg2sg.h>
#include <config_gobj.h>
#include <config_chan.h>
#include "config_util.h"
#include "bamFile.h"
#include "nodePath.h"
#include "load_egg_file.h"
#include "qpload_egg_file.h"
#include "config_egg2sg.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,6 +145,40 @@ run() {
_data.set_coordinate_system(CS_zup_right);
}
if (_pgraph_style) {
// New style scene graph.
PT(PandaNode) root = qpload_egg_data(_data);
if (root == (PandaNode *)NULL) {
nout << "Unable to build scene graph from egg file.\n";
exit(1);
}
if (_ls) {
root->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);
}
} else {
// Old style scene graph.
PT_NamedNode root = load_egg_data(_data);
if (root == (NamedNode *)NULL) {
nout << "Unable to build scene graph from egg file.\n";
@ -167,6 +209,7 @@ run() {
exit(1);
}
}
}
int main(int argc, char *argv[]) {

5
pandatool/src/bam/eggToBam.h
View File

@ -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;

7
pandatool/src/egg-palettize/eggFile.cxx
View File

@ -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) {
nassertr((int)p_list.size() >= _num_textures + 1, 0);
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = TypedWritable::complete_pointers(p_list, manager);
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());

2
pandatool/src/egg-palettize/eggFile.h
View File

@ -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:

2
pandatool/src/egg-palettize/imageFile.cxx
View File

@ -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());

7
pandatool/src/egg-palettize/paletteGroup.cxx
View File

@ -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) {
nassertr((int)p_list.size() >= _num_placements + _num_pages, 0);
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = TypedWritable::complete_pointers(p_list, manager);
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);

2
pandatool/src/egg-palettize/paletteGroup.h
View File

@ -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();

10
pandatool/src/egg-palettize/paletteGroups.cxx
View File

@ -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) {
nassertr(_num_groups == (int)p_list.size(), 0);
complete_pointers(TypedWritable **p_list, BamReader *manager) {
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);
}

2
pandatool/src/egg-palettize/paletteGroups.h
View File

@ -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:

5
pandatool/src/egg-palettize/paletteImage.cxx
View File

@ -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) {
nassertr((int)p_list.size() >= _num_placements + 1, 0);
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = ImageFile::complete_pointers(p_list, manager);
int i;
_placements.reserve(_num_placements);

2
pandatool/src/egg-palettize/paletteImage.h
View File

@ -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:

7
pandatool/src/egg-palettize/palettePage.cxx
View File

@ -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) {
nassertr((int)p_list.size() >= 1 + _num_images, 0);
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = TypedWritable::complete_pointers(p_list, manager);
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

2
pandatool/src/egg-palettize/palettePage.h
View File

@ -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:

9
pandatool/src/egg-palettize/palettizer.cxx
View File

@ -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) {
nassertr((int)p_list.size() >= 4 + _num_egg_files + _num_groups + _num_textures, 0);
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = TypedWritable::complete_pointers(p_list, manager);
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());

2
pandatool/src/egg-palettize/palettizer.h
View File

@ -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:

8
pandatool/src/egg-palettize/sourceTextureImage.cxx
View File

@ -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) {
nassertr(p_list.size() >= 1, 0);
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int pi = ImageFile::complete_pointers(p_list, manager);
DCAST_INTO_R(_texture, p_list[0], 0);
return 1;
DCAST_INTO_R(_texture, p_list[pi++], pi);
return pi;
}
////////////////////////////////////////////////////////////////////

2
pandatool/src/egg-palettize/sourceTextureImage.h
View File

@ -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:

5
pandatool/src/egg-palettize/textureImage.cxx
View File

@ -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) {
nassertr((int)p_list.size() >= _num_placement * 2 + _num_sources + _num_dests, 0);
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = ImageFile::complete_pointers(p_list, manager);
int i;
for (i = 0; i < _num_placement; i++) {

2
pandatool/src/egg-palettize/textureImage.h
View File

@ -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:

12
pandatool/src/egg-palettize/texturePlacement.cxx
View File

@ -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) {
nassertr((int)p_list.size() >= 3 + _num_references, 0);
if (Palettizer::_read_pi_version >= 2) {
nassertr((int)p_list.size() >= 4 + _num_references, 0);
}
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = TypedWritable::complete_pointers(p_list, manager);
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

2
pandatool/src/egg-palettize/texturePlacement.h
View File

@ -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:

2
pandatool/src/egg-palettize/texturePosition.cxx
View File

@ -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();

7
pandatool/src/egg-palettize/textureProperties.cxx
View File

@ -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) {
nassertr(p_list.size() >= 2, 0);
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = TypedWritable::complete_pointers(p_list, manager);
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();

2
pandatool/src/egg-palettize/textureProperties.h
View File

@ -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:

7
pandatool/src/egg-palettize/textureReference.cxx
View File

@ -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) {
nassertr((int)p_list.size() >= 3, 0);
int index = 0;
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int index = TypedWritable::complete_pointers(p_list, manager);
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);

2
pandatool/src/egg-palettize/textureReference.h
View File

@ -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: