TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-01 17:35:34 -04:00
Code Issues Packages Projects Releases Wiki Activity

refine path_replace usage

Browse Source
This commit is contained in:
David Rose 2003-02-13 18:47:28 +00:00
parent ff2576f3c4
commit 6bfce4f544
16 changed files with 234 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
pandatool/src/converter/somethingToEggConverter.I
View File

@ -480,8 +480,8 @@ get_egg_data() {
// Function: SomethingToEggConverter::convert_texture_path
// Access: Public
// Description: Converts the indicated texture filename to a relative
// or absolute or whatever filename, according to _tpc
// and _tpc_directory. See convert_path().
// or absolute or whatever filename, according to
// _path_replace.
////////////////////////////////////////////////////////////////////
INLINE Filename SomethingToEggConverter::
convert_texture_path(const Filename &orig_filename) {
@ -492,8 +492,8 @@ convert_texture_path(const Filename &orig_filename) {
// Function: SomethingToEggConverter::convert_model_path
// Access: Public
// Description: Converts the indicated model filename to a relative
// or absolute or whatever filename, according to _mpc
// and _mpc_directory. See convert_path().
// or absolute or whatever filename, according to
// _path_replace.
////////////////////////////////////////////////////////////////////
INLINE Filename SomethingToEggConverter::
convert_model_path(const Filename &orig_filename) {

15
pandatool/src/converter/somethingToEggConverter.cxx
View File

@ -108,21 +108,16 @@ set_egg_data(EggData *egg_data, bool owns_egg_data) {
////////////////////////////////////////////////////////////////////
bool SomethingToEggConverter::
handle_external_reference(EggGroupNode *egg_parent,
const Filename &orig_filename,
const DSearchPath &searchpath) {
const Filename &ref_filename) {
if (_merge_externals) {
SomethingToEggConverter *ext = make_copy();
EggData egg_data;
egg_data.set_coordinate_system(get_egg_data().get_coordinate_system());
ext->set_egg_data(&egg_data, false);
// If we're reading references directly, we don't need to convert
// the pathname to something appropriate for storing, but we do
// need to hunt for it.
Filename as_found = _path_replace->match_path(orig_filename, searchpath);
if (!ext->convert_file(as_found)) {
if (!ext->convert_file(ref_filename)) {
delete ext;
nout << "Unable to read external reference: " << orig_filename << "\n";
nout << "Unable to read external reference: " << ref_filename << "\n";
if (!_allow_errors) {
_error = true;
}
@ -135,8 +130,8 @@ handle_external_reference(EggGroupNode *egg_parent,
} else {
// If we're installing external references instead of reading
// them, we should massage the filename as specified.
Filename filename = _path_replace->convert_path(orig_filename, searchpath);
// them, we should make it into an egg filename.
Filename filename = ref_filename;
filename.set_extension("egg");
EggExternalReference *egg_ref = new EggExternalReference("", filename);

3
pandatool/src/converter/somethingToEggConverter.h
View File

@ -105,8 +105,7 @@ public:
virtual bool convert_file(const Filename &filename)=0;
bool handle_external_reference(EggGroupNode *egg_parent,
const Filename &orig_filename,
const DSearchPath &searchpath = DSearchPath());
const Filename &ref_filename);
INLINE Filename convert_texture_path(const Filename &orig_filename);
INLINE Filename convert_model_path(const Filename &orig_filename);

51
pandatool/src/flt/fltExternalReference.cxx
View File

@ -35,27 +35,18 @@ FltExternalReference(FltHeader *header) : FltBead(header) {
}
////////////////////////////////////////////////////////////////////
// Function: FltExternalReference::convert_paths
// Function: FltExternalReference::apply_converted_filenames
// Access: Public, Virtual
// Description: Converts all of the paths referenced by this record
// and below according to the indicated path replace
// parameters. If the resulting paths are absolute
// (beginning with a slash), they are converted to
// os-specific form before writing them out; otherwise,
// if they are relative, they are left in panda-specific
// form (under the assumption that a slash-delimited set
// of directory names is universally understood).
// Description: Walks the hierarchy at this record and below and
// copies the _converted_filename record into the
// _orig_filename record, so the flt file will be
// written out with the converted filename instead of
// what was originally read in.
////////////////////////////////////////////////////////////////////
void FltExternalReference::
convert_paths(PathReplace *path_replace) {
Filename new_filename = path_replace->convert_path(get_ref_filename());
if (new_filename.is_local()) {
_filename = new_filename;
} else {
_filename = new_filename.to_os_specific();
}
FltRecord::convert_paths(path_replace);
apply_converted_filenames() {
_orig_filename = _converted_filename.to_os_generic();
FltBead::apply_converted_filenames();
}
////////////////////////////////////////////////////////////////////
@ -68,20 +59,31 @@ convert_paths(PathReplace *path_replace) {
////////////////////////////////////////////////////////////////////
void FltExternalReference::
output(ostream &out) const {
out << "External " << _filename;
out << "External " << get_ref_filename();
if (!_bead_id.empty()) {
out << " (" << _bead_id << ")";
}
}
////////////////////////////////////////////////////////////////////
// Function: FltTexture::get_ref_filename
// Function: FltExternalReference::get_ref_filename
// Access: Public
// Description: Returns the name of the referenced file.
////////////////////////////////////////////////////////////////////
Filename FltExternalReference::
get_ref_filename() const {
return Filename::from_os_specific(_filename);
return _converted_filename;
}
////////////////////////////////////////////////////////////////////
// Function: FltExternalReference::set_ref_filename
// Access: Public
// Description: Changes the name of the referenced file.
////////////////////////////////////////////////////////////////////
void FltExternalReference::
set_ref_filename(const Filename &filename) {
_converted_filename = filename;
_orig_filename = _converted_filename.to_os_generic();
}
////////////////////////////////////////////////////////////////////
@ -108,16 +110,17 @@ extract_record(FltRecordReader &reader) {
iterator.skip_bytes(2);
iterator.skip_bytes(2); // Undocumented additional padding.
_filename = name;
_orig_filename = name;
if (!name.empty() && name[name.length() - 1] == '>') {
// Extract out the bead name.
size_t open = name.rfind('<');
if (open != string::npos) {
_filename = name.substr(0, open);
_orig_filename = name.substr(0, open);
_bead_id = name.substr(open + 1, name.length() - open - 2);
}
}
_converted_filename = _header->convert_path(_orig_filename);
check_remaining_size(iterator);
return true;
@ -140,7 +143,7 @@ build_record(FltRecordWriter &writer) const {
writer.set_opcode(FO_external_ref);
Datagram &datagram = writer.update_datagram();
string name = _filename;
string name = _orig_filename;
if (!_bead_id.empty()) {
name += "<" + _bead_id + ">";
}

6
pandatool/src/flt/fltExternalReference.h
View File

@ -34,7 +34,7 @@ class FltExternalReference : public FltBead {
public:
FltExternalReference(FltHeader *header);
virtual void convert_paths(PathReplace *path_replace);
virtual void apply_converted_filenames();
virtual void output(ostream &out) const;
enum Flags {
@ -46,11 +46,13 @@ public:
F_light_palette_override = 0x04000000
};
Filename _filename;
string _orig_filename;
Filename _converted_filename;
string _bead_id;
int _flags;
Filename get_ref_filename() const;
void set_ref_filename(const Filename &filename);
protected:
virtual bool extract_record(FltRecordReader &reader);

121
pandatool/src/flt/fltHeader.cxx
View File

@ -22,7 +22,7 @@
#include "fltUnsupportedRecord.h"
#include "config_flt.h"
#include <nearly_zero.h>
#include "nearly_zero.h"
#include <assert.h>
#include <math.h>
@ -32,10 +32,27 @@ TypeHandle FltHeader::_type_handle;
////////////////////////////////////////////////////////////////////
// Function: FltHeader::Constructor
// Access: Public
// Description:
// Description: The FltHeader constructor accepts a PathReplace
// pointer; it uses this object to automatically convert
// all external filename and texture references. (This
// is necessary because the FltHeader has to look in the
// same directory as the texture to find the .attr file,
// so it must pre-convert at least the texture
// references.)
//
// Most of the other file converters do not have this
// requirement, so they do not need to pre-convert any
// pathname references.
////////////////////////////////////////////////////////////////////
FltHeader::
FltHeader() : FltBeadID(this) {
FltHeader(PathReplace *path_replace) : FltBeadID(this) {
if (path_replace == (PathReplace *)NULL) {
_path_replace = new PathReplace;
_path_replace->_path_store = PS_absolute;
} else {
_path_replace = path_replace;
}
_format_revision_level = 1570;
_edit_revision_level = 1570;
_next_group_id = 1;
@ -91,7 +108,104 @@ FltHeader() : FltBeadID(this) {
_got_eyepoint_trackplane_palette = false;
_auto_attr_update = AU_if_missing;
}
////////////////////////////////////////////////////////////////////
// Function: FltHeader::apply_converted_filenames
// Access: Public, Virtual
// Description: Walks the hierarchy at this record and below and
// copies the _converted_filename record into the
// _orig_filename record, so the flt file will be
// written out with the converted filename instead of
// what was originally read in.
////////////////////////////////////////////////////////////////////
void FltHeader::
apply_converted_filenames() {
Textures::const_iterator ti;
for (ti = _textures.begin(); ti != _textures.end(); ++ti) {
FltTexture *texture = (*ti).second;
texture->apply_converted_filenames();
}
FltBeadID::apply_converted_filenames();
}
////////////////////////////////////////////////////////////////////
// Function: FltHeader::set_path_replace
// Access: Public
// Description: Replaces the PathReplace object (which specifies how
// to mangle paths from the source to the destination
// file) with a new one.
////////////////////////////////////////////////////////////////////
void FltHeader::
set_path_replace(PathReplace *path_replace) {
_path_replace = path_replace;
}
////////////////////////////////////////////////////////////////////
// Function: FltHeader::get_path_replace
// Access: Public
// Description: Returns a pointer to the PathReplace object
// associated with this converter. If the converter is
// non-const, this returns a non-const pointer, which
// can be adjusted.
////////////////////////////////////////////////////////////////////
PathReplace *FltHeader::
get_path_replace() {
return _path_replace;
}
////////////////////////////////////////////////////////////////////
// Function: FltHeader::get_path_replace
// Access: Public
// Description: Returns a pointer to the PathReplace object
// associated with this converter. If the converter is
// non-const, this returns a non-const pointer, which
// can be adjusted.
////////////////////////////////////////////////////////////////////
const PathReplace *FltHeader::
get_path_replace() const {
return _path_replace;
}
////////////////////////////////////////////////////////////////////
// Function: FltHeader::convert_path
// Access: Public
// Description: Uses the PathReplace object to convert the named
// filename as read from the flt record to its actual
// name.
////////////////////////////////////////////////////////////////////
Filename FltHeader::
convert_path(const Filename &orig_filename, const DSearchPath &additional_path) {
DSearchPath file_path;
if (!_flt_filename.empty()) {
file_path.append_directory(_flt_filename.get_dirname());
}
file_path.append_path(additional_path);
return _path_replace->convert_path(orig_filename, file_path);
}
////////////////////////////////////////////////////////////////////
// Function: FltHeader::set_flt_filename
// Access: Public
// Description: Sets the filename--especially the directory part--in
// which the flt file is considered to reside. This is
// also implicitly set by read_flt().
////////////////////////////////////////////////////////////////////
void FltHeader::
set_flt_filename(const Filename &flt_filename) {
_flt_filename = flt_filename;
}
////////////////////////////////////////////////////////////////////
// Function: FltHeader::get_flt_filename
// Access: Public
// Description: Returns the directory in which the flt file is
// considered to reside.
////////////////////////////////////////////////////////////////////
const Filename &FltHeader::
get_flt_filename() const {
return _flt_filename;
}
////////////////////////////////////////////////////////////////////
@ -104,6 +218,7 @@ FltHeader() : FltBeadID(this) {
FltError FltHeader::
read_flt(Filename filename) {
filename.set_binary();
_flt_filename = filename;
ifstream in;
if (!filename.open_read(in)) {

18
pandatool/src/flt/fltHeader.h
View File

@ -30,6 +30,8 @@
#include "fltTrackplane.h"
#include "fltInstanceDefinition.h"
#include "pathReplace.h"
#include "pointerTo.h"
#include "filename.h"
#include "dSearchPath.h"
#include "distanceUnit.h"
@ -49,7 +51,18 @@
////////////////////////////////////////////////////////////////////
class FltHeader : public FltBeadID {
public:
FltHeader();
FltHeader(PathReplace *path_replace);
virtual void apply_converted_filenames();
void set_path_replace(PathReplace *path_replace);
PathReplace *get_path_replace();
const PathReplace *get_path_replace() const;
Filename convert_path(const Filename &orig_filename,
const DSearchPath &additional_path = DSearchPath());
void set_flt_filename(const Filename &flt_filename);
const Filename &get_flt_filename() const;
FltError read_flt(Filename filename);
FltError read_flt(istream &in);
@ -284,6 +297,9 @@ private:
FltEyepoint _eyepoints[10];
FltTrackplane _trackplanes[10];
// This pointer is used to resolve references in the flt file.
PT(PathReplace) _path_replace;
Filename _flt_filename;
protected:
virtual bool extract_record(FltRecordReader &reader);

21
pandatool/src/flt/fltRecord.cxx
View File

@ -331,25 +331,22 @@ check_remaining_size(const DatagramIterator &di, const string &name) const {
}
////////////////////////////////////////////////////////////////////
// Function: FltRecord::convert_paths
// Function: FltRecord::apply_converted_filenames
// Access: Public, Virtual
// Description: Converts all of the paths referenced by this record
// and below according to the indicated path replace
// parameters. If the resulting paths are absolute
// (beginning with a slash), they are converted to
// os-specific form before writing them out; otherwise,
// if they are relative, they are left in panda-specific
// form (under the assumption that a slash-delimited set
// of directory names is universally understood).
// Description: Walks the hierarchy at this record and below and
// copies the _converted_filename record into the
// _orig_filename record, so the flt file will be
// written out with the converted filename instead of
// what was originally read in.
////////////////////////////////////////////////////////////////////
void FltRecord::
convert_paths(PathReplace *path_replace) {
apply_converted_filenames() {
Records::const_iterator ci;
for (ci = _subfaces.begin(); ci != _subfaces.end(); ++ci) {
(*ci)->convert_paths(path_replace);
(*ci)->apply_converted_filenames();
}
for (ci = _children.begin(); ci != _children.end(); ++ci) {
(*ci)->convert_paths(path_replace);
(*ci)->apply_converted_filenames();
}
}

3
pandatool/src/flt/fltRecord.h
View File

@ -32,7 +32,6 @@ class FltHeader;
class FltRecordReader;
class FltRecordWriter;
class DatagramIterator;
class PathReplace;
////////////////////////////////////////////////////////////////////
// Class : FltRecord
@ -75,7 +74,7 @@ public:
void check_remaining_size(const DatagramIterator &di,
const string &name = string()) const;
virtual void convert_paths(PathReplace *path_replace);
virtual void apply_converted_filenames();
virtual void output(ostream &out) const;
virtual void write(ostream &out, int indent_level = 0) const;

48
pandatool/src/flt/fltTexture.cxx
View File

@ -21,6 +21,7 @@
#include "fltRecordWriter.h"
#include "fltHeader.h"
#include "pathReplace.h"
#include "config_util.h"
TypeHandle FltTexture::_type_handle;
@ -89,27 +90,18 @@ FltTexture(FltHeader *header) : FltRecord(header) {
}
////////////////////////////////////////////////////////////////////
// Function: FltTexture::convert_paths
// Function: FltTexture::apply_converted_filenames
// Access: Public, Virtual
// Description: Converts all of the paths referenced by this record
// and below according to the indicated path replace
// parameters. If the resulting paths are absolute
// (beginning with a slash), they are converted to
// os-specific form before writing them out; otherwise,
// if they are relative, they are left in panda-specific
// form (under the assumption that a slash-delimited set
// of directory names is universally understood).
// Description: Walks the hierarchy at this record and below and
// copies the _converted_filename record into the
// _orig_filename record, so the flt file will be
// written out with the converted filename instead of
// what was originally read in.
////////////////////////////////////////////////////////////////////
void FltTexture::
convert_paths(PathReplace *path_replace) {
Filename new_filename = path_replace->convert_path(get_texture_filename());
if (new_filename.is_local()) {
_filename = new_filename;
} else {
_filename = new_filename.to_os_specific();
}
FltRecord::convert_paths(path_replace);
apply_converted_filenames() {
_orig_filename = _converted_filename.to_os_generic();
FltRecord::apply_converted_filenames();
}
////////////////////////////////////////////////////////////////////
@ -119,7 +111,18 @@ convert_paths(PathReplace *path_replace) {
////////////////////////////////////////////////////////////////////
Filename FltTexture::
get_texture_filename() const {
return Filename::from_os_specific(_filename);
return _converted_filename;
}
////////////////////////////////////////////////////////////////////
// Function: FltTexture::set_texture_filename
// Access: Public
// Description: Changes the name of the texture image file.
////////////////////////////////////////////////////////////////////
void FltTexture::
set_texture_filename(const Filename &filename) {
_converted_filename = filename;
_orig_filename = _converted_filename.to_os_generic();
}
////////////////////////////////////////////////////////////////////
@ -239,10 +242,11 @@ extract_record(FltRecordReader &reader) {
DatagramIterator &iterator = reader.get_iterator();
if (_header->get_flt_version() < 1420) {
_filename = iterator.get_fixed_string(80);
_orig_filename = iterator.get_fixed_string(80);
} else {
_filename = iterator.get_fixed_string(200);
_orig_filename = iterator.get_fixed_string(200);
}
_converted_filename = _header->convert_path(_orig_filename, get_texture_path());
_pattern_index = iterator.get_be_int32();
_x_location = iterator.get_be_int32();
_y_location = iterator.get_be_int32();
@ -272,7 +276,7 @@ build_record(FltRecordWriter &writer) const {
writer.set_opcode(FO_texture);
Datagram &datagram = writer.update_datagram();
datagram.add_fixed_string(_filename, 200);
datagram.add_fixed_string(_orig_filename, 200);
datagram.add_be_int32(_pattern_index);
datagram.add_be_int32(_x_location);
datagram.add_be_int32(_y_location);

12
pandatool/src/flt/fltTexture.h
View File

@ -19,12 +19,12 @@
#ifndef FLTTEXTURE_H
#define FLTTEXTURE_H
#include <pandatoolbase.h>
#include "pandatoolbase.h"
#include "fltRecord.h"
#include <filename.h>
#include <luse.h>
#include "filename.h"
#include "luse.h"
////////////////////////////////////////////////////////////////////
// Class : FltTexture
@ -34,14 +34,16 @@ class FltTexture : public FltRecord {
public:
FltTexture(FltHeader *header);
virtual void convert_paths(PathReplace *path_replace);
virtual void apply_converted_filenames();
string _filename;
string _orig_filename;
Filename _converted_filename;
int _pattern_index;
int _x_location;
int _y_location;
Filename get_texture_filename() const;
void set_texture_filename(const Filename &filename);
Filename get_attr_filename() const;
FltError read_attr_data();
FltError write_attr_data() const;

7
pandatool/src/fltegg/fltToEggConverter.cxx
View File

@ -120,7 +120,7 @@ get_extension() const {
////////////////////////////////////////////////////////////////////
bool FltToEggConverter::
convert_file(const Filename &filename) {
PT(FltHeader) header = new FltHeader;
PT(FltHeader) header = new FltHeader(_path_replace);
nout << "Reading " << filename << "\n";
FltError result = header->read_flt(filename);
@ -619,7 +619,8 @@ parse_comment(const FltBead *flt_bead, EggNode *egg_node) {
////////////////////////////////////////////////////////////////////
bool FltToEggConverter::
parse_comment(const FltTexture *flt_texture, EggNode *egg_node) {
return parse_comment(flt_texture->_comment, flt_texture->_filename, egg_node);
return parse_comment(flt_texture->get_comment(),
flt_texture->get_texture_filename(), egg_node);
}
////////////////////////////////////////////////////////////////////
@ -744,7 +745,7 @@ make_egg_texture(const FltTexture *flt_texture) {
// Create a new one.
string tref_name = format_string(flt_texture->_pattern_index);
Filename filename = convert_texture_path(flt_texture->get_texture_filename());
Filename filename = flt_texture->get_texture_filename();
PT_EggTexture egg_texture = new EggTexture(tref_name, filename);

16
pandatool/src/fltprogs/fltCopy.cxx
View File

@ -110,7 +110,7 @@ copy_file(const Filename &source, const Filename &dest,
bool FltCopy::
copy_flt_file(const Filename &source, const Filename &dest,
CVSSourceDirectory *dir) {
PT(FltHeader) header = new FltHeader;
PT(FltHeader) header = new FltHeader(_path_replace);
// We don't want to automatically generate .attr files--we'd rather
// write them out explicitly.
@ -132,8 +132,7 @@ copy_flt_file(const Filename &source, const Filename &dest,
Refs::const_iterator ri;
for (ri = refs.begin(); ri != refs.end(); ++ri) {
FltExternalReference *ref = (*ri);
Filename ref_filename =
_path_replace->convert_path(ref->get_ref_filename());
Filename ref_filename = ref->get_ref_filename();
if (!ref_filename.exists()) {
nout << "*** Warning: external reference " << ref_filename
@ -150,8 +149,8 @@ copy_flt_file(const Filename &source, const Filename &dest,
// Update the reference to point to the new flt filename, relative
// to the base flt file.
ref->_filename = dir->get_rel_to(ref_dir) + "/" +
ref_filename.get_basename();
ref->set_ref_filename(dir->get_rel_to(ref_dir) + "/" +
ref_filename.get_basename());
}
}
@ -163,8 +162,7 @@ copy_flt_file(const Filename &source, const Filename &dest,
Textures::const_iterator ti;
for (ti = textures.begin(); ti != textures.end(); ++ti) {
FltTexture *tex = (*ti);
Filename texture_filename =
_path_replace->convert_path(tex->get_texture_filename());
Filename texture_filename = tex->get_texture_filename();
if (!texture_filename.exists()) {
nout << "*** Warning: texture " << texture_filename
@ -182,8 +180,8 @@ copy_flt_file(const Filename &source, const Filename &dest,
// Update the texture reference to point to the new texture
// filename, relative to the flt file.
tex->_filename = dir->get_rel_to(texture_dir) + "/" +
texture_filename.get_basename();
tex->set_texture_filename(dir->get_rel_to(texture_dir) + "/" +
texture_filename.get_basename());
header->add_texture(tex);
}
}

2
pandatool/src/fltprogs/fltInfo.cxx
View File

@ -49,7 +49,7 @@ FltInfo() {
////////////////////////////////////////////////////////////////////
void FltInfo::
run() {
PT(FltHeader) header = new FltHeader;
PT(FltHeader) header = new FltHeader(_path_replace);
nout << "Reading " << _input_filename << "\n";
FltError result = header->read_flt(_input_filename);

2
pandatool/src/fltprogs/fltToEgg.cxx
View File

@ -68,7 +68,7 @@ FltToEgg() :
////////////////////////////////////////////////////////////////////
void FltToEgg::
run() {
PT(FltHeader) header = new FltHeader;
PT(FltHeader) header = new FltHeader(_path_replace);
nout << "Reading " << _input_filename << "\n";
FltError result = header->read_flt(_input_filename);

4
pandatool/src/fltprogs/fltTrans.cxx
View File

@ -79,7 +79,7 @@ run() {
}
}
PT(FltHeader) header = new FltHeader;
PT(FltHeader) header = new FltHeader(_path_replace);
nout << "Reading " << _input_filename << "\n";
FltError result = header->read_flt(_input_filename);
@ -97,7 +97,7 @@ run() {
header->set_flt_version(new_version);
}
header->convert_paths(_path_replace);
header->apply_converted_filenames();
result = header->write_flt(get_output());
if (result != FE_ok) {