some minor debug aids and robustness additions

panda/src/glstuff/glGraphicsBuffer_src.cxx

@@ -1156,8 +1156,11 @@ select_tex_view(int view) {
     CLP(TextureContext) *gtc = DCAST(CLP(TextureContext), tc);
     glgsg->update_texture(tc, true);
 
-    GLCAT.spam() << "Binding texture " << *tex
-      << " view " << view << " to color attachment.\n";
+    if (GLCAT.is_spam()) {
+      GLCAT.spam()
+        << "Binding texture " << *tex
+        << " view " << view << " to color attachment.\n";
+    }
 
   #ifndef OPENGLES
     GLclampf priority = 1.0f;

panda/src/glstuff/glGraphicsStateGuardian_src.cxx

@@ -3543,12 +3543,6 @@ update_texture(TextureContext *tc, bool force) {
 
   CLP(TextureContext) *gtc = DCAST(CLP(TextureContext), tc);
 
-  if (GLCAT.is_debug() && gtc->get_texture()->get_name() != string("buf")) {
-    GLCAT.debug()
-      << "Considering update " << gtc->get_texture()->get_name()
-      << ": " << gtc->was_image_modified() << ", modified = " << gtc->get_texture()->get_image_modified() << "\n";
-  }
-
   if (gtc->was_image_modified()) {
     // If the texture image was modified, reload the texture.  This
     // means we also re-specify the properties for good measure.
@@ -9040,7 +9034,7 @@ upload_texture(CLP(TextureContext) *gtc, bool force) {
 //               in the case of cube mapping, in which case
 //               texture_target will be target for the overall
 //               texture, e.g. GL_TEXTURE_CUBE_MAP, and page_target
-//               will the target for this particular page,
+//               will be the target for this particular page,
 //               e.g. GL_TEXTURE_CUBE_MAP_POSITIVE_X.
 ////////////////////////////////////////////////////////////////////
 bool CLP(GraphicsStateGuardian)::
@@ -9082,6 +9076,8 @@ upload_texture_image(CLP(TextureContext) *gtc,
       GLCAT.debug()
         << "loading uncompressed texture " << tex->get_name() << "\n";
     }
+    GLCAT.debug()
+      << "page_target " << hex << page_target << dec << "\n";
   }
 
   int num_ram_mipmap_levels = 0;
@@ -9104,6 +9100,7 @@ upload_texture_image(CLP(TextureContext) *gtc,
         uses_mipmaps = false;
       }
     }
+
   } else {
     num_ram_mipmap_levels = 1;
     if (uses_mipmaps) {

panda/src/gobj/texture.I

@@ -31,9 +31,9 @@ INLINE PT(Texture) Texture::
 make_copy() const {
   PT(Texture) tex = make_copy_impl();
   CDWriter cdata_tex(tex->_cycler, true);
-  ++(cdata_tex->_properties_modified);
-  ++(cdata_tex->_image_modified);
-  ++(cdata_tex->_simple_image_modified);
+  cdata_tex->inc_properties_modified();
+  cdata_tex->inc_image_modified();
+  cdata_tex->inc_simple_image_modified();
   return tex;
 }
 
@@ -288,8 +288,8 @@ INLINE bool Texture::
 load(const PNMImage &pnmimage, const LoaderOptions &options) {
   CDWriter cdata(_cycler, true);
   do_clear(cdata);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   if (do_load_one(cdata, pnmimage, get_name(), 0, 0, options)) {
     bool generate_mipmaps = ((options.get_texture_flags() & LoaderOptions::TF_generate_mipmaps) != 0);
     consider_auto_process_ram_image(generate_mipmaps || uses_mipmaps(), true);
@@ -307,8 +307,8 @@ load(const PNMImage &pnmimage, const LoaderOptions &options) {
 INLINE bool Texture::
 load(const PNMImage &pnmimage, int z, int n, const LoaderOptions &options) {
   CDWriter cdata(_cycler, true);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   if (do_load_one(cdata, pnmimage, get_name(), z, n, options)) {
     return true;
   }
@@ -324,8 +324,8 @@ INLINE bool Texture::
 load(const PfmFile &pfm, const LoaderOptions &options) {
   CDWriter cdata(_cycler, true);
   do_clear(cdata);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   if (do_load_one(cdata, pfm, get_name(), 0, 0, options)) {
     bool generate_mipmaps = ((options.get_texture_flags() & LoaderOptions::TF_generate_mipmaps) != 0);
     consider_auto_process_ram_image(generate_mipmaps || uses_mipmaps(), true);
@@ -343,8 +343,8 @@ load(const PfmFile &pfm, const LoaderOptions &options) {
 INLINE bool Texture::
 load(const PfmFile &pfm, int z, int n, const LoaderOptions &options) {
   CDWriter cdata(_cycler, true);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   if (do_load_one(cdata, pfm, get_name(), z, n, options)) {
     return true;
   }
@@ -1412,7 +1412,7 @@ get_ram_image_compression() const {
 INLINE PTA_uchar Texture::
 modify_ram_image() {
   CDWriter cdata(_cycler, true);
-  ++(cdata->_image_modified);
+  cdata->inc_image_modified();
   return do_modify_ram_image(cdata);
 }
 
@@ -1453,7 +1453,7 @@ get_uncompressed_ram_image() {
 INLINE PTA_uchar Texture::
 make_ram_image() {
   CDWriter cdata(_cycler, true);
-  ++(cdata->_image_modified);
+  cdata->inc_image_modified();
   return do_make_ram_image(cdata);
 }
 
@@ -1537,7 +1537,7 @@ compress_ram_image(Texture::CompressionMode compression,
                    GraphicsStateGuardianBase *gsg) {
   CDWriter cdata(_cycler, false);
   if (do_compress_ram_image(cdata, compression, quality_level, gsg)) {
-    ++(cdata->_image_modified);
+    cdata->inc_image_modified();
     return true;
   }
   return false;
@@ -1558,7 +1558,7 @@ INLINE bool Texture::
 uncompress_ram_image() {
   CDWriter cdata(_cycler, false);
   if (do_uncompress_ram_image(cdata)) {
-    ++(cdata->_image_modified);
+    cdata->inc_image_modified();
     return true;
   }
   return false;
@@ -1723,7 +1723,7 @@ get_expected_ram_mipmap_page_size(int n) const {
 INLINE PTA_uchar Texture::
 modify_ram_mipmap_image(int n) {
   CDWriter cdata(_cycler, false);
-  ++(cdata->_image_modified);
+  cdata->inc_image_modified();
   return do_modify_ram_mipmap_image(cdata, n);
 }
 
@@ -1739,7 +1739,7 @@ modify_ram_mipmap_image(int n) {
 INLINE PTA_uchar Texture::
 make_ram_mipmap_image(int n) {
   CDWriter cdata(_cycler, false);
-  ++(cdata->_image_modified);
+  cdata->inc_image_modified();
   return do_make_ram_mipmap_image(cdata, n);
 }
 
@@ -1769,7 +1769,7 @@ set_ram_mipmap_image(int n, CPTA_uchar image, size_t page_size) {
 INLINE void Texture::
 clear_ram_mipmap_images() {
   CDWriter cdata(_cycler, false);
-  ++(cdata->_image_modified);
+  cdata->inc_image_modified();
   do_clear_ram_mipmap_images(cdata);
 }
 
@@ -1790,7 +1790,7 @@ clear_ram_mipmap_images() {
 INLINE void Texture::
 generate_ram_mipmap_images() {
   CDWriter cdata(_cycler, unlocked_ensure_ram_image(false));
-  ++(cdata->_image_modified);
+  cdata->inc_image_modified();
   do_generate_ram_mipmap_images(cdata);
 }
 
@@ -2627,6 +2627,36 @@ is_dds_filename(const Filename &fullpath) {
   return (downcase(extension) == "dds");
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: Texture::CData::inc_properties_modified
+//       Access: Public
+//  Description: 
+////////////////////////////////////////////////////////////////////
+INLINE void Texture::CData::
+inc_properties_modified() {
+  ++_properties_modified;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: Texture::CData::inc_image_modified
+//       Access: Public
+//  Description: 
+////////////////////////////////////////////////////////////////////
+INLINE void Texture::CData::
+inc_image_modified() {
+  ++_image_modified;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: Texture::CData::inc_simple_image_modified
+//       Access: Public
+//  Description: 
+////////////////////////////////////////////////////////////////////
+INLINE void Texture::CData::
+inc_simple_image_modified() {
+  ++_simple_image_modified;
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: Texture::RamImage::Constructor
 //       Access: Public

panda/src/gobj/texture.cxx

@@ -238,8 +238,8 @@ generate_normalization_cube_map(int size) {
   PTA_uchar image = do_make_ram_image(cdata);
   cdata->_keep_ram_image = true;
 
-  ++(cdata->_image_modified);
-  ++(cdata->_properties_modified);
+  cdata->inc_image_modified();
+  cdata->inc_properties_modified();
 
   PN_stdfloat half_size = (PN_stdfloat)size * 0.5f;
   PN_stdfloat center = half_size - 0.5f;
@@ -345,8 +345,8 @@ generate_alpha_scale_map() {
   cdata->_magfilter = FT_nearest;
   cdata->_compression = CM_off;
 
-  ++(cdata->_image_modified);
-  ++(cdata->_properties_modified);
+  cdata->inc_image_modified();
+  cdata->inc_properties_modified();
 
   PTA_uchar image = do_make_ram_image(cdata);
   cdata->_keep_ram_image = true;
@@ -366,8 +366,8 @@ bool Texture::
 read(const Filename &fullpath, const LoaderOptions &options) {
   CDWriter cdata(_cycler, true);
   do_clear(cdata);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   return do_read(cdata, fullpath, Filename(), 0, 0, 0, 0, false, false,
                  options, NULL);
 }
@@ -389,8 +389,8 @@ read(const Filename &fullpath, const Filename &alpha_fullpath,
      const LoaderOptions &options) {
   CDWriter cdata(_cycler, true);
   do_clear(cdata);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   return do_read(cdata, fullpath, alpha_fullpath, primary_file_num_channels,
                  alpha_file_channel, 0, 0, false, false,
                  options, NULL);
@@ -411,8 +411,8 @@ read(const Filename &fullpath, int z, int n,
      bool read_pages, bool read_mipmaps,
      const LoaderOptions &options) {
   CDWriter cdata(_cycler, true);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   return do_read(cdata, fullpath, Filename(), 0, 0, z, n, read_pages, read_mipmaps,
                  options, NULL);
 }
@@ -493,8 +493,8 @@ read(const Filename &fullpath, const Filename &alpha_fullpath,
      BamCacheRecord *record,
      const LoaderOptions &options) {
   CDWriter cdata(_cycler, true);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   return do_read(cdata, fullpath, alpha_fullpath, primary_file_num_channels,
                  alpha_file_channel, z, n, read_pages, read_mipmaps,
                  options, record);
@@ -652,8 +652,8 @@ get_aux_data(const string &key) const {
 bool Texture::
 read_txo(istream &in, const string &filename) {
   CDWriter cdata(_cycler, true);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   return do_read_txo(cdata, in, filename);
 }
 
@@ -760,8 +760,8 @@ write_txo(ostream &out, const string &filename) const {
 bool Texture::
 read_dds(istream &in, const string &filename, bool header_only) {
   CDWriter cdata(_cycler, true);
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
   return do_read_dds(cdata, in, filename, header_only);
 }
 
@@ -1122,7 +1122,7 @@ set_ram_mipmap_pointer(int n, void *image, size_t page_size) {
   cdata->_ram_images[n]._page_size = page_size;
   //_ram_images[n]._image.clear(); wtf is going on?!
   cdata->_ram_images[n]._pointer_image = image;
-  ++(cdata->_image_modified);
+  cdata->inc_image_modified();
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -1189,7 +1189,7 @@ new_simple_ram_image(int x_size, int y_size) {
   cdata->_simple_ram_image._image = PTA_uchar::empty_array(expected_page_size);
   cdata->_simple_ram_image._page_size = expected_page_size;
   cdata->_simple_image_date_generated = (PN_int32)time(NULL);
-  ++(cdata->_simple_image_modified);
+  cdata->inc_simple_image_modified();
 
   return cdata->_simple_ram_image._image;
 }
@@ -4127,8 +4127,8 @@ unlocked_ensure_ram_image(bool allow_compression) {
     cdataw->_format = cdata_tex->_format;
     cdataw->_component_type = cdata_tex->_component_type;
     
-    ++(cdataw->_properties_modified);
-    ++(cdataw->_image_modified);
+    cdataw->inc_properties_modified();
+    cdataw->inc_image_modified();
   }
   
   cdataw->_keep_ram_image = cdata_tex->_keep_ram_image;
@@ -4343,7 +4343,7 @@ do_set_ram_image(CData *cdata, CPTA_uchar image, Texture::CompressionMode compre
     cdata->_ram_images[0]._page_size = page_size;
     cdata->_ram_images[0]._pointer_image = NULL;
     cdata->_ram_image_compression = compression;
-    ++(cdata->_image_modified);
+    cdata->inc_image_modified();
   }
 }
 
@@ -4404,7 +4404,7 @@ do_set_ram_mipmap_image(CData *cdata, int n, CPTA_uchar image, size_t page_size)
     cdata->_ram_images[n]._image = image.cast_non_const();
     cdata->_ram_images[n]._pointer_image = NULL;
     cdata->_ram_images[n]._page_size = page_size;
-    ++(cdata->_image_modified);
+    cdata->inc_image_modified();
   }
 }
 
@@ -4839,7 +4839,7 @@ do_rescale_texture(CData *cdata) {
     new_image.quick_filter_from(orig_image);
 
     do_clear_ram_image(cdata);
-    ++(cdata->_image_modified);
+    cdata->inc_image_modified();
     cdata->_x_size = new_x_size;
     cdata->_y_size = new_y_size;
     if (!do_load_one(cdata, new_image, get_name(), 0, 0, LoaderOptions())) {
@@ -4871,7 +4871,7 @@ do_rescale_texture(CData *cdata) {
 
       do_clear_ram_image(cdata);
       cdata->_loaded_from_image = false;
-      ++(cdata->_image_modified);
+      cdata->inc_image_modified();
       if (!do_load_one(cdata, new_image, get_name(), 0, 0, LoaderOptions())) {
         return false;
       }
@@ -4933,9 +4933,9 @@ do_clear(CData *cdata) {
   CDReader cdata_tex(tex._cycler);
   do_assign(cdata, &tex, cdata_tex);
 
-  ++(cdata->_properties_modified);
-  ++(cdata->_image_modified);
-  ++(cdata->_simple_image_modified);
+  cdata->inc_properties_modified();
+  cdata->inc_image_modified();
+  cdata->inc_simple_image_modified();
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -5008,7 +5008,7 @@ do_set_format(CData *cdata, Texture::Format format) {
     return;
   }
   cdata->_format = format;
-  ++(cdata->_properties_modified);
+  cdata->inc_properties_modified();
 
   switch (cdata->_format) {
   case F_color_index:
@@ -5091,7 +5091,7 @@ void Texture::
 do_set_x_size(CData *cdata, int x_size) {
   if (cdata->_x_size != x_size) {
     cdata->_x_size = x_size;
-    ++(cdata->_image_modified);
+    cdata->inc_image_modified();
     do_clear_ram_image(cdata);
     do_set_pad_size(cdata, 0, 0, 0);
   }
@@ -5107,7 +5107,7 @@ do_set_y_size(CData *cdata, int y_size) {
   if (cdata->_y_size != y_size) {
     nassertv(cdata->_texture_type != Texture::TT_1d_texture || y_size == 1);
     cdata->_y_size = y_size;
-    ++(cdata->_image_modified);
+    cdata->inc_image_modified();
     do_clear_ram_image(cdata);
     do_set_pad_size(cdata, 0, 0, 0);
   }
@@ -5127,7 +5127,7 @@ do_set_z_size(CData *cdata, int z_size) {
              (cdata->_texture_type == Texture::TT_cube_map && z_size == 6) ||
              (cdata->_texture_type == Texture::TT_2d_texture_array) || (z_size == 1));
     cdata->_z_size = z_size;
-    ++(cdata->_image_modified);
+    cdata->inc_image_modified();
     do_clear_ram_image(cdata);
     do_set_pad_size(cdata, 0, 0, 0);
   }
@@ -5143,8 +5143,10 @@ do_set_num_views(CData *cdata, int num_views) {
   nassertv(num_views >= 1);
   if (cdata->_num_views != num_views) {
     cdata->_num_views = num_views;
-    ++(cdata->_image_modified);
-    do_clear_ram_image(cdata);
+    if (do_has_ram_image(cdata)) {
+      cdata->inc_image_modified();
+      do_clear_ram_image(cdata);
+    }
     do_set_pad_size(cdata, 0, 0, 0);
   }
 }
@@ -5157,7 +5159,7 @@ do_set_num_views(CData *cdata, int num_views) {
 void Texture::
 do_set_wrap_u(CData *cdata, Texture::WrapMode wrap) {
   if (cdata->_wrap_u != wrap) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_wrap_u = wrap;
   }
 }
@@ -5170,7 +5172,7 @@ do_set_wrap_u(CData *cdata, Texture::WrapMode wrap) {
 void Texture::
 do_set_wrap_v(CData *cdata, Texture::WrapMode wrap) {
   if (cdata->_wrap_v != wrap) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_wrap_v = wrap;
   }
 }
@@ -5183,7 +5185,7 @@ do_set_wrap_v(CData *cdata, Texture::WrapMode wrap) {
 void Texture::
 do_set_wrap_w(CData *cdata, Texture::WrapMode wrap) {
   if (cdata->_wrap_w != wrap) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_wrap_w = wrap;
   }
 }
@@ -5196,7 +5198,7 @@ do_set_wrap_w(CData *cdata, Texture::WrapMode wrap) {
 void Texture::
 do_set_minfilter(CData *cdata, Texture::FilterType filter) {
   if (cdata->_minfilter != filter) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_minfilter = filter;
   }
 }
@@ -5209,7 +5211,7 @@ do_set_minfilter(CData *cdata, Texture::FilterType filter) {
 void Texture::
 do_set_magfilter(CData *cdata, Texture::FilterType filter) {
   if (cdata->_magfilter != filter) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_magfilter = filter;
   }
 }
@@ -5222,7 +5224,7 @@ do_set_magfilter(CData *cdata, Texture::FilterType filter) {
 void Texture::
 do_set_anisotropic_degree(CData *cdata, int anisotropic_degree) {
   if (cdata->_anisotropic_degree != anisotropic_degree) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_anisotropic_degree = anisotropic_degree;
   }
 }
@@ -5235,7 +5237,7 @@ do_set_anisotropic_degree(CData *cdata, int anisotropic_degree) {
 void Texture::
 do_set_border_color(CData *cdata, const LColor &color) {
   if (cdata->_border_color != color) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_border_color = color;
   }
 }
@@ -5248,7 +5250,7 @@ do_set_border_color(CData *cdata, const LColor &color) {
 void Texture::
 do_set_compression(CData *cdata, Texture::CompressionMode compression) {
   if (cdata->_compression != compression) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_compression = compression;
 
     if (do_has_ram_image(cdata)) {
@@ -5273,7 +5275,7 @@ do_set_compression(CData *cdata, Texture::CompressionMode compression) {
 void Texture::
 do_set_quality_level(CData *cdata, Texture::QualityLevel quality_level) {
   if (cdata->_quality_level != quality_level) {
-    ++(cdata->_properties_modified);
+    cdata->inc_properties_modified();
     cdata->_quality_level = quality_level;
   }
 }
@@ -5325,12 +5327,14 @@ do_get_ram_image(CData *cdata) {
   if (!do_has_ram_image(cdata) && do_can_reload(cdata)) {
     do_reload_ram_image(cdata, true);
 
-    // Normally, we don't update the cdata->_modified semaphores in a do_blah
-    // method, but we'll make an exception in this case, because it's
-    // easiest to modify these here, and only when we know it's
-    // needed.
-    ++(cdata->_image_modified);
-    ++(cdata->_properties_modified);
+    if (do_has_ram_image(cdata)) {
+      // Normally, we don't update the cdata->_modified semaphores in a do_blah
+      // method, but we'll make an exception in this case, because it's
+      // easiest to modify these here, and only when we know it's
+      // needed.
+      cdata->inc_image_modified();
+      cdata->inc_properties_modified();
+    }
   }
 
   if (cdata->_ram_images.empty()) {
@@ -5539,7 +5543,7 @@ do_set_simple_ram_image(CData *cdata, CPTA_uchar image, int x_size, int y_size)
   cdata->_simple_ram_image._image = image.cast_non_const();
   cdata->_simple_ram_image._page_size = image.size();
   cdata->_simple_image_date_generated = (PN_int32)time(NULL);
-  ++(cdata->_simple_image_modified);
+  cdata->inc_simple_image_modified();
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -5644,7 +5648,7 @@ do_clear_simple_ram_image(CData *cdata) {
   // We allow this exception: we update the _simple_image_modified
   // here, since no one really cares much about that anyway, and it's
   // convenient to do it here.
-  ++(cdata->_simple_image_modified);
+  cdata->inc_simple_image_modified();
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -5804,7 +5808,7 @@ do_reload(CData *cdata) {
     do_reload_ram_image(cdata, true);
     if (do_has_ram_image(cdata)) {
       // An explicit call to reload() should increment image_modified.
-      ++(cdata->_image_modified);
+      cdata->inc_image_modified();
       return true;
     }
     return false;
@@ -7769,7 +7773,7 @@ do_fillin_body(CData *cdata, DatagramIterator &scan, BamReader *manager) {
   cdata->_format = (Format)scan.get_uint8();
   cdata->_num_components = scan.get_uint8();
 
-  ++(cdata->_properties_modified);
+  cdata->inc_properties_modified();
 
   cdata->_auto_texture_scale = ATS_unspecified;
   if (manager->get_file_minor_ver() >= 28) {
@@ -7797,7 +7801,7 @@ do_fillin_body(CData *cdata, DatagramIterator &scan, BamReader *manager) {
 
     cdata->_simple_ram_image._image = image;
     cdata->_simple_ram_image._page_size = u_size;
-    ++(cdata->_simple_image_modified);
+    cdata->inc_simple_image_modified();
   }
 }
 
@@ -7856,7 +7860,7 @@ do_fillin_rawdata(CData *cdata, DatagramIterator &scan, BamReader *manager) {
     cdata->_ram_images[n]._image = image;
   }
   cdata->_loaded_from_image = true;
-  ++(cdata->_image_modified);
+  cdata->inc_image_modified();
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/gobj/texture.h

@@ -776,6 +776,9 @@ protected:
     }
 
     void do_assign(const CData *copy);
+    INLINE void inc_properties_modified();
+    INLINE void inc_image_modified();
+    INLINE void inc_simple_image_modified();
 
     Filename _filename;
     Filename _alpha_filename;

panda/src/gobj/textureContext.I

@@ -98,6 +98,42 @@ was_simple_image_modified() const {
   return _simple_image_modified != _texture->get_simple_image_modified();
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: TextureContext::get_properties_modified
+//       Access: Published
+//  Description: Returns a sequence number which is guaranteed to
+//               change at least every time the texture properties
+//               (unrelated to the image) are modified.
+////////////////////////////////////////////////////////////////////
+INLINE UpdateSeq TextureContext::
+get_properties_modified() const {
+  return _properties_modified;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: TextureContext::get_image_modified
+//       Access: Published
+//  Description: Returns a sequence number which is guaranteed to
+//               change at least every time the texture image data
+//               (including mipmap levels) are modified.
+////////////////////////////////////////////////////////////////////
+INLINE UpdateSeq TextureContext::
+get_image_modified() const {
+  return _image_modified;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: TextureContext::get_simple_image_modified
+//       Access: Published
+//  Description: Returns a sequence number which is guaranteed to
+//               change at least every time the texture's "simple"
+//               image data is modified.
+////////////////////////////////////////////////////////////////////
+INLINE UpdateSeq TextureContext::
+get_simple_image_modified() const {
+  return _simple_image_modified;
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: TextureContext::update_data_size_bytes
 //       Access: Public

panda/src/gobj/textureContext.h

@@ -48,6 +48,10 @@ PUBLISHED:
   INLINE bool was_image_modified() const;
   INLINE bool was_simple_image_modified() const;
 
+  INLINE UpdateSeq get_properties_modified() const;
+  INLINE UpdateSeq get_image_modified() const;
+  INLINE UpdateSeq get_simple_image_modified() const;
+
 public:
   INLINE void update_data_size_bytes(size_t new_data_size_bytes);
   INLINE void mark_loaded();

panda/src/putil/updateSeq.I

@@ -264,6 +264,17 @@ operator ++ (int) {
   return temp;
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: UpdateSeq::get_seq
+//       Access: Published
+//  Description: Returns the internal integer value associated with
+//               the UpdateSeq.  Useful for debugging only.
+////////////////////////////////////////////////////////////////////
+INLINE AtomicAdjust::Integer UpdateSeq::
+get_seq() const {
+  return _seq;
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: UpdateSeq::output
 //       Access: Published

panda/src/putil/updateSeq.h

@@ -67,6 +67,8 @@ PUBLISHED:
   INLINE UpdateSeq operator ++ ();
   INLINE UpdateSeq operator ++ (int);
 
+  INLINE AtomicAdjust::Integer get_seq() const;
+
   INLINE void output(ostream &out) const;
 
 private: