RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix reload-texture bug

This commit is contained in:
David Rose 2006-10-16 23:12:17 +00:00
parent 3b03d4f2f9
commit 9cd582faca
6 changed files with 116 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6489,12 +6489,21 @@ apply_texture(TextureContext *tc) {
}
GLP(BindTexture)(target, gtc->_index);
if (gtc->was_modified()) {
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.
specify_texture(gtc->get_texture());
upload_texture(gtc);
gtc->mark_loaded();
} else if (gtc->was_properties_modified()) {
// If only the properties have been modified, we don't necessarily
// need to reload the texture.
specify_texture(gtc->get_texture());
gtc->mark_loaded();
}
report_my_gl_errors();
}
@ -6728,6 +6737,9 @@ upload_texture_image(CLP(TextureContext) *gtc,
} else if (is_compressed_format(internal_format)) {
GLCAT.debug()
<< "compressing texture " << tex->get_name() << "\n";
} else {
GLCAT.debug()
<< "loading uncompressed texture " << tex->get_name() << "\n";
}
}

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

@ -169,7 +169,8 @@ read(const Filename &fullpath, const Filename &alpha_fullpath,
INLINE bool Texture::
read(const Filename &fullpath, int z, int n,
bool read_pages, bool read_mipmaps) {
++_modified;
++_properties_modified;
++_image_modified;
return do_read(fullpath, Filename(), 0, 0, z, n, read_pages, read_mipmaps,
NULL);
}
@ -248,7 +249,8 @@ read(const Filename &fullpath, const Filename &alpha_fullpath,
int primary_file_num_channels, int alpha_file_channel,
int z, int n, bool read_pages, bool read_mipmaps,
BamCacheRecord *record) {
++_modified;
++_properties_modified;
++_image_modified;
return do_read(fullpath, alpha_fullpath, primary_file_num_channels,
alpha_file_channel, z, n, read_pages, read_mipmaps,
record);
@ -343,7 +345,8 @@ load(const PNMImage &pnmimage) {
////////////////////////////////////////////////////////////////////
INLINE bool Texture::
load(const PNMImage &pnmimage, int z, int n) {
++_modified;
++_properties_modified;
++_image_modified;
return do_load_one(pnmimage, get_name(), z, n);
}
@ -785,7 +788,7 @@ get_ram_image_compression() const {
INLINE PTA_uchar Texture::
modify_ram_image() {
do_modify_ram_image();
++_modified;
++_image_modified;
return _ram_images[0]._image;
}
@ -800,7 +803,7 @@ modify_ram_image() {
////////////////////////////////////////////////////////////////////
INLINE PTA_uchar Texture::
make_ram_image() {
++_modified;
++_image_modified;
do_make_ram_image();
return _ram_images[0]._image;
}
@ -931,20 +934,32 @@ get_expected_ram_mipmap_page_size(int n) const {
INLINE PTA_uchar Texture::
modify_ram_mipmap_image(int n) {
do_modify_ram_mipmap_image(n);
++_modified;
++_image_modified;
return _ram_images[n]._image;
}
////////////////////////////////////////////////////////////////////
// Function: Texture::get_modified
// Function: Texture::get_properties_modified
// Access: Published
// Description: Returns a sequence number which is guaranteed to
// change at least every time the texture data or
// properties are modified.
// change at least every time the texture properties
// (unrelated to the image) are modified.
////////////////////////////////////////////////////////////////////
INLINE UpdateSeq Texture::
get_modified() const {
return _modified;
get_properties_modified() const {
return _properties_modified;
}
////////////////////////////////////////////////////////////////////
// Function: Texture::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 Texture::
get_image_modified() const {
return _image_modified;
}
////////////////////////////////////////////////////////////////////
@ -1068,7 +1083,7 @@ INLINE void Texture::
set_x_size(int x_size) {
if (_x_size != x_size) {
_x_size = x_size;
++_modified;
++_image_modified;
clear_ram_image();
}
}
@ -1085,7 +1100,7 @@ set_y_size(int y_size) {
if (_y_size != y_size) {
nassertv(_texture_type != Texture::TT_1d_texture || y_size == 1);
_y_size = y_size;
++_modified;
++_image_modified;
clear_ram_image();
}
}
@ -1104,7 +1119,7 @@ set_z_size(int z_size) {
(_texture_type == Texture::TT_cube_map && z_size == 6) ||
(z_size == 1));
_z_size = z_size;
++_modified;
++_image_modified;
clear_ram_image();
}
}

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

@ -168,7 +168,8 @@ operator = (const Texture &copy) {
_match_framebuffer_format = copy._match_framebuffer_format;
_ram_image_compression = copy._ram_image_compression;
_ram_images = copy._ram_images;
++_modified;
++_properties_modified;
++_image_modified;
}
////////////////////////////////////////////////////////////////////
@ -619,7 +620,7 @@ bool Texture::
reload() {
if (_loaded_from_image && has_filename()) {
reload_ram_image();
++_modified;
++_image_modified;
return has_ram_image();
}
@ -686,7 +687,7 @@ load_related(const InternalName *suffix) const {
void Texture::
set_wrap_u(Texture::WrapMode wrap) {
if (_wrap_u != wrap) {
++_modified;
++_properties_modified;
_wrap_u = wrap;
}
}
@ -699,7 +700,7 @@ set_wrap_u(Texture::WrapMode wrap) {
void Texture::
set_wrap_v(Texture::WrapMode wrap) {
if (_wrap_v != wrap) {
++_modified;
++_properties_modified;
_wrap_v = wrap;
}
}
@ -712,7 +713,7 @@ set_wrap_v(Texture::WrapMode wrap) {
void Texture::
set_wrap_w(Texture::WrapMode wrap) {
if (_wrap_w != wrap) {
++_modified;
++_properties_modified;
_wrap_w = wrap;
}
}
@ -725,7 +726,7 @@ set_wrap_w(Texture::WrapMode wrap) {
void Texture::
set_minfilter(Texture::FilterType filter) {
if (_minfilter != filter) {
++_modified;
++_properties_modified;
_minfilter = filter;
}
}
@ -738,7 +739,7 @@ set_minfilter(Texture::FilterType filter) {
void Texture::
set_magfilter(Texture::FilterType filter) {
if (_magfilter != filter) {
++_modified;
++_properties_modified;
_magfilter = filter;
}
}
@ -755,7 +756,7 @@ set_magfilter(Texture::FilterType filter) {
void Texture::
set_anisotropic_degree(int anisotropic_degree) {
if (_anisotropic_degree != anisotropic_degree) {
++_modified;
++_properties_modified;
_anisotropic_degree = anisotropic_degree;
}
}
@ -771,7 +772,7 @@ set_anisotropic_degree(int anisotropic_degree) {
void Texture::
set_border_color(const Colorf &color) {
if (_border_color != color) {
++_modified;
++_properties_modified;
_border_color = color;
}
}
@ -798,7 +799,7 @@ set_border_color(const Colorf &color) {
void Texture::
set_compression(Texture::CompressionMode compression) {
if (_compression != compression) {
++_modified;
++_properties_modified;
_compression = compression;
}
}
@ -993,7 +994,7 @@ set_ram_image(PTA_uchar image, Texture::CompressionMode compression,
_ram_images[0]._image = image;
_ram_images[0]._page_size = page_size;
_ram_image_compression = compression;
++_modified;
++_image_modified;
}
}
@ -1091,7 +1092,7 @@ make_ram_mipmap_image(int n) {
_ram_images[n]._image = PTA_uchar::empty_array(get_expected_ram_mipmap_image_size(n));
_ram_images[n]._page_size = get_expected_ram_mipmap_page_size(n);
++_modified;
++_image_modified;
return _ram_images[n]._image;
}
@ -1122,7 +1123,7 @@ set_ram_mipmap_image(int n, PTA_uchar image, size_t page_size) {
_ram_images[n]._page_size != page_size) {
_ram_images[n]._image = image;
_ram_images[n]._page_size = page_size;
++_modified;
++_image_modified;
}
}
@ -2320,7 +2321,7 @@ reload_ram_image() {
// Function: Texture::do_modify_ram_image
// Access: Protected
// Description: This is called internally to uniquify the ram image
// pointer without updating _modified.
// pointer without updating _image_modified.
////////////////////////////////////////////////////////////////////
void Texture::
do_modify_ram_image() {
@ -2336,7 +2337,7 @@ do_modify_ram_image() {
// Function: Texture::do_make_ram_image
// Access: Protected
// Description: This is called internally to make a new ram image
// without updating _modified.
// without updating _image_modified.
////////////////////////////////////////////////////////////////////
void Texture::
do_make_ram_image() {
@ -2351,7 +2352,7 @@ do_make_ram_image() {
// Function: Texture::do_modify_ram_mipmap_image
// Access: Protected
// Description: This is called internally to uniquify the nth mipmap
// image pointer without updating _modified.
// image pointer without updating _image_modified.
////////////////////////////////////////////////////////////////////
void Texture::
do_modify_ram_mipmap_image(int n) {
@ -3352,16 +3353,23 @@ make_from_bam(const FactoryParams &params) {
void Texture::
fillin(DatagramIterator &scan, BamReader *manager, bool has_rawdata) {
// We have already read in the filenames; don't read them again.
_wrap_u = (WrapMode)scan.get_uint8();
_wrap_v = (WrapMode)scan.get_uint8();
_wrap_w = (WrapMode)scan.get_uint8();
_minfilter = (FilterType)scan.get_uint8();
_magfilter = (FilterType)scan.get_uint8();
_anisotropic_degree = scan.get_int16();
_border_color.read_datagram(scan);
_compression = CM_default;
// We use the setters here, instead of directly assigning these
// values, so that we will correctly update _properties_modified
// only if any of these changes.
set_wrap_u((WrapMode)scan.get_uint8());
set_wrap_v((WrapMode)scan.get_uint8());
set_wrap_w((WrapMode)scan.get_uint8());
set_minfilter((FilterType)scan.get_uint8());
set_magfilter((FilterType)scan.get_uint8());
set_anisotropic_degree(scan.get_int16());
Colorf border_color;
border_color.read_datagram(scan);
set_border_color(border_color);
if (manager->get_file_minor_ver() >= 1) {
_compression = (CompressionMode)scan.get_uint8();
set_compression((CompressionMode)scan.get_uint8());
}
Format format = (Format)scan.get_uint8();
@ -3413,8 +3421,9 @@ fillin(DatagramIterator &scan, BamReader *manager, bool has_rawdata) {
_ram_images[n]._image = image;
}
_loaded_from_image = true;
++_image_modified;
++_properties_modified;
}
++_modified;
}
////////////////////////////////////////////////////////////////////

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

@ -302,7 +302,8 @@ PUBLISHED:
void clear_ram_mipmap_images();
void generate_ram_mipmap_images();
INLINE UpdateSeq get_modified() const;
INLINE UpdateSeq get_properties_modified() const;
INLINE UpdateSeq get_image_modified() const;
void prepare(PreparedGraphicsObjects *prepared_objects);
bool release(PreparedGraphicsObjects *prepared_objects);
@ -520,7 +521,8 @@ protected:
typedef pvector<RamImage> RamImages;
RamImages _ram_images;
UpdateSeq _modified;
UpdateSeq _properties_modified;
UpdateSeq _image_modified;
private:
// The auxiliary data is not recorded to a bam file.

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

@ -40,15 +40,40 @@ get_texture() const {
return _texture;
}
////////////////////////////////////////////////////////////////////
// Function: TextureContext::was_modified
// Access: Public
// Description: Returns true if the texture has been modified since the
// last time mark_loaded() was called.
// Description: Returns true if the texture properties or image have
// been modified since the last time mark_loaded() was
// called.
////////////////////////////////////////////////////////////////////
INLINE bool TextureContext::
was_modified() const {
return get_modified() != _texture->get_modified();
return was_properties_modified() || was_image_modified();
}
////////////////////////////////////////////////////////////////////
// Function: TextureContext::was_properties_modified
// Access: Public
// Description: Returns true if the texture properties (unrelated to
// the image) have been modified since the last time
// mark_loaded() was called.
////////////////////////////////////////////////////////////////////
INLINE bool TextureContext::
was_properties_modified() const {
return _properties_modified != _texture->get_properties_modified();
}
////////////////////////////////////////////////////////////////////
// Function: TextureContext::was_image_modified
// Access: Public
// Description: Returns true if the texture image has been modified
// since the last time mark_loaded() was called.
////////////////////////////////////////////////////////////////////
INLINE bool TextureContext::
was_image_modified() const {
return _image_modified != _texture->get_image_modified();
}
////////////////////////////////////////////////////////////////////
@ -61,7 +86,9 @@ was_modified() const {
INLINE void TextureContext::
mark_loaded() {
// _data_size_bytes = _data->get_texture_size_bytes();
update_modified(_texture->get_modified());
_properties_modified = _texture->get_properties_modified();
_image_modified = _texture->get_image_modified();
update_modified(max(_properties_modified, _image_modified));
// Assume the texture is now resident.
set_resident(true);

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

@ -45,6 +45,8 @@ public:
INLINE Texture *get_texture() const;
INLINE bool was_modified() const;
INLINE bool was_properties_modified() const;
INLINE bool was_image_modified() const;
INLINE void mark_loaded();
private:
@ -52,6 +54,8 @@ private:
// both own their TextureContexts! That would create a circular
// reference count.
Texture *_texture;
UpdateSeq _properties_modified;
UpdateSeq _image_modified;
public:
static TypeHandle get_class_type() {