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

some minor debug aids and robustness additions

Browse Source
This commit is contained in:
David Rose 2013-12-06 20:53:40 +00:00
parent a4563fb342
commit 741203a693
9 changed files with 172 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
panda/src/glstuff/glGraphicsBuffer_src.cxx
View File

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

11
panda/src/glstuff/glGraphicsStateGuardian_src.cxx
View File

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

68
panda/src/gobj/texture.I
View File

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

112
panda/src/gobj/texture.cxx
View File

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

3
panda/src/gobj/texture.h
View File

@ -776,6 +776,9 @@ protected:
} }
void do_assign(const CData *copy); 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 _filename;
Filename _alpha_filename; Filename _alpha_filename;

36
panda/src/gobj/textureContext.I
View File

@ -98,6 +98,42 @@ was_simple_image_modified() const {
return _simple_image_modified != _texture->get_simple_image_modified(); 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 // Function: TextureContext::update_data_size_bytes
// Access: Public // Access: Public

4
panda/src/gobj/textureContext.h
View File

@ -48,6 +48,10 @@ PUBLISHED:
INLINE bool was_image_modified() const; INLINE bool was_image_modified() const;
INLINE bool was_simple_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: public:
INLINE void update_data_size_bytes(size_t new_data_size_bytes); INLINE void update_data_size_bytes(size_t new_data_size_bytes);
INLINE void mark_loaded(); INLINE void mark_loaded();

11
panda/src/putil/updateSeq.I
View File

@ -264,6 +264,17 @@ operator ++ (int) {
return temp; 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 // Function: UpdateSeq::output
// Access: Published // Access: Published

2
panda/src/putil/updateSeq.h
View File

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