robustify pathnames some more

panda/src/egg2pg/config_egg2pg.cxx

@@ -52,15 +52,6 @@ bool egg_flatten_siblings = config_egg2pg.GetBool("egg-flatten-siblings", false)
 
 bool egg_show_collision_solids = config_egg2pg.GetBool("egg-show-collision-solids", false);
 
-// When this is true, keep texture pathnames exactly the same as they
-// appeared in the egg file, in particular leaving them as relative
-// paths, rather than letting them reflect the full path at which they
-// were found.  This is particularly useful when generating bam files.
-// However, if the same texture is named by two different relative
-// paths, these will still be collapsed into one texture (using one of
-// the relative paths, chosen arbitrarily).
-bool egg_keep_texture_pathnames = config_egg2pg.GetBool("egg-keep-texture-pathnames", false);
-
 // When this is true, a <NurbsCurve> entry appearing in an egg file
 // will load a ClassicNurbsCurve object instead of the default, a
 // NurbsCurve object.  This only makes a difference when the NURBS++

panda/src/egg2pg/config_egg2pg.h

@@ -52,7 +52,6 @@ extern EXPCL_PANDAEGG bool egg_ignore_decals;
 extern EXPCL_PANDAEGG bool egg_flatten;
 extern EXPCL_PANDAEGG bool egg_flatten_siblings;
 extern EXPCL_PANDAEGG bool egg_show_collision_solids;
-extern EXPCL_PANDAEGG bool egg_keep_texture_pathnames;
 extern EXPCL_PANDAEGG bool egg_load_classic_nurbs_curves;
 extern EXPCL_PANDAEGG bool egg_accept_errors;
 extern EXPCL_PANDAEGG EggRenderMode::AlphaMode egg_alpha_mode;

panda/src/egg2pg/eggLoader.cxx

@@ -487,15 +487,6 @@ load_texture(TextureDef &def, const EggTexture *egg_tex) {
     return false;
   }
 
-  if (egg_keep_texture_pathnames) {
-    tex->set_filename(egg_tex->get_filename());
-    if (egg_tex->has_alpha_file()) {
-      tex->set_alpha_filename(egg_tex->get_alpha_file());
-    } else {
-      tex->clear_alpha_filename();
-    }
-  }
-
   apply_texture_attributes(tex, egg_tex);
   CPT(RenderAttrib) apply = get_texture_apply_attributes(egg_tex);
 

panda/src/gobj/imageBuffer.I

@@ -31,10 +31,9 @@ has_filename() const {
 ////////////////////////////////////////////////////////////////////
 //     Function: ImageBuffer::get_filename
 //       Access: Published
-//  Description: Returns the filename that has been set.  Use
+//  Description: Returns the filename that has been set.  This is the
-//               this in conjunction with get_name() to get the names
+//               name of the file as it was requested.  Also see
-//               of the file(s) that were loaded into the buffer.  See
+//               get_fullpath().
-//               set_filename().
 ////////////////////////////////////////////////////////////////////
 INLINE const Filename &ImageBuffer::
 get_filename() const {
@@ -55,16 +54,63 @@ has_alpha_filename() const {
 ////////////////////////////////////////////////////////////////////
 //     Function: ImageBuffer::get_alpha_filename
 //       Access: Published
-//  Description: Returns the alpha_filename that has been set.  Use
+//  Description: Returns the alpha_filename that has been set.  If
-//               this in conjunction with get_name() to get the names
+//               this is set, it represents the name of the alpha
-//               of the file(s) that were loaded into the buffer.  See
+//               component, which is stored in a separate file.  See
-//               set_alpha_filename().
+//               also get_filename(), and get_alpha_fullpath().
 ////////////////////////////////////////////////////////////////////
 INLINE const Filename &ImageBuffer::
 get_alpha_filename() const {
   return _alpha_filename;
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: ImageBuffer::has_fullpath
+//       Access: Published
+//  Description: Returns true if the fullpath has been set and
+//               is available.  See set_fullpath().
+////////////////////////////////////////////////////////////////////
+INLINE bool ImageBuffer::
+has_fullpath() const {
+  return !_fullpath.empty();
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: ImageBuffer::get_fullpath
+//       Access: Published
+//  Description: Returns the fullpath that has been set.  This is the
+//               full path to the file as it was found along the
+//               texture search path.
+////////////////////////////////////////////////////////////////////
+INLINE const Filename &ImageBuffer::
+get_fullpath() const {
+  return _fullpath;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: ImageBuffer::has_alpha_fullpath
+//       Access: Published
+//  Description: Returns true if the alpha_fullpath has been set and
+//               is available.  See set_alpha_fullpath().
+////////////////////////////////////////////////////////////////////
+INLINE bool ImageBuffer::
+has_alpha_fullpath() const {
+  return !_alpha_fullpath.empty();
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: ImageBuffer::get_alpha_fullpath
+//       Access: Published
+//  Description: 
+//               Returns the alpha_fullpath that has been set.  This
+//               is the full path to the alpha part of the image file
+//               as it was found along the texture search path.
+////////////////////////////////////////////////////////////////////
+INLINE const Filename &ImageBuffer::
+get_alpha_fullpath() const {
+  return _alpha_fullpath;
+}
+
 
 ////////////////////////////////////////////////////////////////////
 //     Function: ImageBuffer::set_filename
@@ -127,3 +173,52 @@ INLINE void ImageBuffer::
 clear_alpha_filename() {
   _alpha_filename = Filename();
 }
+
+////////////////////////////////////////////////////////////////////
+//     Function: ImageBuffer::set_fullpath
+//       Access: Public
+//  Description: Sets the full pathname to the file that contains the
+//               image's contents, as found along the search path.
+//               Normally, this is set automatically when the image is
+//               loaded, for instance via Texture::read().
+////////////////////////////////////////////////////////////////////
+INLINE void ImageBuffer::
+set_fullpath(const Filename &fullpath) {
+  _fullpath = fullpath;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: ImageBuffer::clear_fullpath
+//       Access: Public
+//  Description: Removes the alpha fullpath, if it was previously set.
+//               See set_fullpath().
+////////////////////////////////////////////////////////////////////
+INLINE void ImageBuffer::
+clear_fullpath() {
+  _fullpath = Filename();
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: ImageBuffer::set_alpha_fullpath
+//       Access: Public
+//  Description: Sets the full pathname to the file that contains the
+//               image's alpha channel contents, as found along the
+//               search path.  Normally, this is set automatically
+//               when the image is loaded, for instance via
+//               Texture::read().
+////////////////////////////////////////////////////////////////////
+INLINE void ImageBuffer::
+set_alpha_fullpath(const Filename &alpha_fullpath) {
+  _alpha_fullpath = alpha_fullpath;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: ImageBuffer::clear_alpha_fullpath
+//       Access: Public
+//  Description: Removes the alpha fullpath, if it was previously set.
+//               See set_alpha_fullpath().
+////////////////////////////////////////////////////////////////////
+INLINE void ImageBuffer::
+clear_alpha_fullpath() {
+  _alpha_fullpath = Filename();
+}

panda/src/gobj/imageBuffer.cxx

@@ -48,17 +48,23 @@ write_datagram(BamWriter *, Datagram &me)
 
   switch (bam_texture_mode) {
   case BTM_unchanged:
+    break;
+
   case BTM_fullpath:
+    filename = get_fullpath();
+    alpha_filename = get_alpha_fullpath();
     break;
 
   case BTM_relative:
-    filename.find_on_searchpath(get_texture_path());
+    filename = get_fullpath();
+    alpha_filename = get_alpha_fullpath();
+    filename.find_on_searchpath(get_texture_path()) ||
       filename.find_on_searchpath(get_model_path());
     if (gobj_cat.is_debug()) {
       gobj_cat.debug()
         << "Texture file " << get_filename() << " found as " << filename << "\n";
     }
-    alpha_filename.find_on_searchpath(get_texture_path());
+    alpha_filename.find_on_searchpath(get_texture_path()) ||
       alpha_filename.find_on_searchpath(get_model_path());
     if (gobj_cat.is_debug()) {
       gobj_cat.debug()

panda/src/gobj/imageBuffer.h

@@ -57,15 +57,27 @@ PUBLISHED:
   INLINE bool has_alpha_filename() const;
   INLINE const Filename &get_alpha_filename() const;
 
+  INLINE bool has_fullpath() const;
+  INLINE const Filename &get_fullpath() const;
+  INLINE bool has_alpha_fullpath() const;
+  INLINE const Filename &get_alpha_fullpath() const;
+
 public:
   INLINE void set_filename(const Filename &filename);
   INLINE void clear_filename();
   INLINE void set_alpha_filename(const Filename &alpha_filename);
   INLINE void clear_alpha_filename();
 
+  INLINE void set_fullpath(const Filename &fullpath);
+  INLINE void clear_fullpath();
+  INLINE void set_alpha_fullpath(const Filename &alpha_fullpath);
+  INLINE void clear_alpha_fullpath();
+
 private:
   Filename _filename;
   Filename _alpha_filename;
+  Filename _fullpath;
+  Filename _alpha_fullpath;
 
 public:
   //Abstract class, so no factory methods for Reading and Writing

panda/src/gobj/texture.cxx

@@ -166,22 +166,30 @@ Texture::
 //  Description: Reads the texture from the indicated filename.
 ////////////////////////////////////////////////////////////////////
 bool Texture::
-read(const Filename &name) {
+read(const Filename &fullpath) {
-  PNMImage pnmimage;
+  PNMImage image;
 
-  if (!pnmimage.read(name)) {
+  if (!image.read(fullpath)) {
     gobj_cat.error()
-      << "Texture::read() - couldn't read: " << name << endl;
+      << "Texture::read() - couldn't read: " << fullpath << endl;
     return false;
   }
 
-  // Check to see if we need to scale it.
+  if (!has_name()) {
-  consider_rescale(pnmimage, name);
+    set_name(fullpath.get_basename_wo_extension());
-
+  }
-  set_name(name.get_basename_wo_extension());
+  if (!has_filename()) {
-  set_filename(name);
+    set_filename(fullpath);
     clear_alpha_filename();
-  return load(pnmimage);
+  }
+
+  set_fullpath(fullpath);
+  clear_alpha_fullpath();
+
+  // Check to see if we need to scale it.
+  consider_rescale(image, get_name());
+
+  return load(image);
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -191,51 +199,60 @@ read(const Filename &name) {
 //               to get a 4-component image
 ////////////////////////////////////////////////////////////////////
 bool Texture::
-read(const Filename &name, const Filename &gray) {
+read(const Filename &fullpath, const Filename &alpha_fullpath) {
-  PNMImage pnmimage;
+  PNMImage image;
-  if (!pnmimage.read(name)) {
+  if (!image.read(fullpath)) {
     gobj_cat.error()
-      << "Texture::read() - couldn't read: " << name << endl;
+      << "Texture::read() - couldn't read: " << fullpath << endl;
     return false;
   }
 
-  PNMImage grayimage;
+  PNMImage alpha_image;
-  if (!grayimage.read(gray)) {
+  if (!alpha_image.read(alpha_fullpath)) {
     gobj_cat.error()
-      << "Texture::read() - couldn't read: " << gray << endl;
+      << "Texture::read() - couldn't read: " << alpha_fullpath << endl;
     return false;
   }
 
-  consider_rescale(pnmimage, name);
+  if (!has_name()) {
+    set_name(fullpath.get_basename_wo_extension());
+  }
+  if (!has_filename()) {
+    set_filename(fullpath);
+    set_alpha_filename(alpha_fullpath);
+  }
+
+  set_fullpath(fullpath);
+  set_alpha_fullpath(alpha_fullpath);
+
+  consider_rescale(image, get_name());
 
   // The grayscale (alpha channel) image must be the same size as the
   // main image.
-  if (pnmimage.get_x_size() != grayimage.get_x_size() ||
+  if (image.get_x_size() != alpha_image.get_x_size() ||
-      pnmimage.get_y_size() != grayimage.get_y_size()) {
+      image.get_y_size() != alpha_image.get_y_size()) {
     gobj_cat.info()
-      << "Automatically rescaling " << gray << " from "
+      << "Automatically rescaling " << alpha_fullpath.get_basename()
-      << grayimage.get_x_size() << " by " << grayimage.get_y_size() << " to "
+      << " from " << alpha_image.get_x_size() << " by " 
-      << pnmimage.get_x_size() << " by " << pnmimage.get_y_size() << "\n";
+      << alpha_image.get_y_size() << " to " << image.get_x_size()
+      << " by " << image.get_y_size() << "\n";
 
-    PNMImage scaled(pnmimage.get_x_size(), pnmimage.get_y_size(),
+    PNMImage scaled(image.get_x_size(), image.get_y_size(),
-                    grayimage.get_num_channels(),
+                    alpha_image.get_num_channels(),
-                    grayimage.get_maxval(), grayimage.get_type());
+                    alpha_image.get_maxval(), alpha_image.get_type());
-    scaled.quick_filter_from(grayimage);
+    scaled.quick_filter_from(alpha_image);
-    grayimage = scaled;
+    alpha_image = scaled;
   }
 
   // Make the original image a 4-component image
-  pnmimage.add_alpha();
+  image.add_alpha();
-  for (int x = 0; x < pnmimage.get_x_size(); x++) {
+  for (int x = 0; x < image.get_x_size(); x++) {
-    for (int y = 0; y < pnmimage.get_y_size(); y++) {
+    for (int y = 0; y < image.get_y_size(); y++) {
-      pnmimage.set_alpha(x, y, grayimage.get_gray(x, y));
+      image.set_alpha(x, y, alpha_image.get_gray(x, y));
     }
   }
 
-  set_name(name.get_basename_wo_extension());
+  return load(image);
-  set_filename(name);
-  set_alpha_filename(gray);
-  return load(pnmimage);
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -519,19 +536,14 @@ PixelBuffer *Texture::
 get_ram_image() {
   if (!has_ram_image() && has_filename()) {
     // Now we have to reload the texture image.
-    string name = get_name();
     gobj_cat.info()
-      << "Reloading texture " << name << "\n";
+      << "Reloading texture " << get_name() << "\n";
     
-    if (has_alpha_filename()) {
+    if (has_alpha_fullpath()) {
-      read(get_filename(), get_alpha_filename());
+      read(get_fullpath(), get_alpha_fullpath());
     } else {
-      read(get_filename());
+      read(get_fullpath());
     }
-
-    // Just in case the read operation changed our name, we should
-    // change it back.
-    set_name(name);
   }
 
   if (has_ram_image()) {
@@ -688,9 +700,6 @@ make_Texture(const FactoryParams &params) {
 
   } else {
     me->set_name(name);
-    if (gobj_cat.is_debug()) {
-      gobj_cat->debug() << "Created texture " << me->get_name() << endl;
-    }
     me->fillin(scan, manager);
   }
   return me;

panda/src/gobj/texture.h

@@ -79,9 +79,9 @@ PUBLISHED:
           bool bAllocateRAM);
   ~Texture();
 
-  bool read(const Filename &name);
+  bool read(const Filename &fullpath);
-  bool read(const Filename &name, const Filename &gray);
+  bool read(const Filename &fullpath, const Filename &alpha_fullpath);
-  bool write(const Filename &name = "") const;
+  bool write(const Filename &fullpath = "") const;
 
   void set_wrapu(WrapMode wrap);
   void set_wrapv(WrapMode wrap);

panda/src/gobj/texturePool.I

@@ -66,8 +66,8 @@ load_texture(const string &filename) {
 //               file cannot be found, returns NULL.
 ////////////////////////////////////////////////////////////////////
 INLINE Texture *TexturePool::
-load_texture(const string &filename, const string &grayfilename) {
+load_texture(const string &filename, const string &alpha_filename) {
-  return get_ptr()->ns_load_texture(filename, grayfilename);
+  return get_ptr()->ns_load_texture(filename, alpha_filename);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/gobj/texturePool.cxx

@@ -74,11 +74,11 @@ ns_load_texture(const Filename &orig_filename) {
 
   if (use_vfs) {
     VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
-    vfs->resolve_filename(filename, get_texture_path());
+    vfs->resolve_filename(filename, get_texture_path()) ||
       vfs->resolve_filename(filename, get_model_path());
 
   } else {
-    filename.resolve_filename(get_texture_path());
+    filename.resolve_filename(get_texture_path()) ||
       filename.resolve_filename(get_model_path());
   }
 
@@ -94,13 +94,13 @@ ns_load_texture(const Filename &orig_filename) {
   PT(Texture) tex = new Texture;
   if (!tex->read(filename)) {
     // This texture was not found.
-    gobj_cat.error() << "Unable to read texture " << filename << "\n";
+    gobj_cat.error()
+      << "Unable to read texture " << filename << "\n";
     return NULL;
   }
 
-  if (bam_texture_mode == BTM_unchanged) {
+  // Set the original filename, before we searched along the path.
   tex->set_filename(orig_filename);
-  }
 
   _textures[filename] = tex;
   return tex;
@@ -113,9 +113,9 @@ ns_load_texture(const Filename &orig_filename) {
 ////////////////////////////////////////////////////////////////////
 Texture *TexturePool::
 ns_load_texture(const Filename &orig_filename, 
-                const Filename &orig_grayfilename) {
+                const Filename &orig_alpha_filename) {
   Filename filename(orig_filename);
-  Filename grayfilename(orig_grayfilename);
+  Filename alpha_filename(orig_alpha_filename);
 
   if (!fake_texture_image.empty()) {
     return ns_load_texture(fake_texture_image);
@@ -123,18 +123,18 @@ ns_load_texture(const Filename &orig_filename,
 
   if (use_vfs) {
     VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
-    vfs->resolve_filename(filename, get_texture_path());
+    vfs->resolve_filename(filename, get_texture_path()) ||
       vfs->resolve_filename(filename, get_model_path());
 
-    vfs->resolve_filename(grayfilename, get_texture_path());
+    vfs->resolve_filename(alpha_filename, get_texture_path()) ||
-    vfs->resolve_filename(grayfilename, get_model_path());
+      vfs->resolve_filename(alpha_filename, get_model_path());
 
   } else {
-    filename.resolve_filename(get_texture_path());
+    filename.resolve_filename(get_texture_path()) ||
       filename.resolve_filename(get_model_path());
 
-    grayfilename.resolve_filename(get_texture_path());
+    alpha_filename.resolve_filename(get_texture_path()) ||
-    grayfilename.resolve_filename(get_model_path());
+      alpha_filename.resolve_filename(get_model_path());
   }
 
   Textures::const_iterator ti;
@@ -145,19 +145,18 @@ ns_load_texture(const Filename &orig_filename,
   }
 
   gobj_cat.info()
-    << "Loading texture " << filename << " and grayscale texture "
+    << "Loading texture " << filename << " and alpha component "
-    << grayfilename << endl;
+    << alpha_filename << endl;
   PT(Texture) tex = new Texture;
-  if (!tex->read(filename, grayfilename)) {
+  if (!tex->read(filename, alpha_filename)) {
     // This texture was not found.
     gobj_cat.error() << "Unable to read texture " << filename << "\n";
     return NULL;
   }
 
-  if (bam_texture_mode == BTM_unchanged) {
+  // Set the original filenames, before we searched along the path.
   tex->set_filename(orig_filename);
-    tex->set_alpha_filename(orig_grayfilename);
+  tex->set_alpha_filename(orig_alpha_filename);
-  }
 
   _textures[filename] = tex;
   return tex;

panda/src/gobj/texturePool.h

@@ -44,7 +44,7 @@ PUBLISHED:
   INLINE static bool verify_texture(const string &filename);
   INLINE static Texture *load_texture(const string &filename);
   INLINE static Texture *load_texture(const string &filename,
-                                      const string &grayfilename);
+                                      const string &alpha_filename);
   INLINE static void add_texture(Texture *texture);
   INLINE static void release_texture(Texture *texture);
   INLINE static void release_all_textures();
@@ -59,7 +59,7 @@ private:
   bool ns_has_texture(const Filename &orig_filename);
   Texture *ns_load_texture(const Filename &orig_filename);
   Texture *ns_load_texture(const Filename &orig_filename, 
-                           const Filename &orig_grayfilename);
+                           const Filename &orig_alpha_filename);
   void ns_add_texture(Texture *texture);
   void ns_release_texture(Texture *texture);
   void ns_release_all_textures();