historical/toontown-classic.git/panda/include/bamCache.I

260 lines
7 KiB
Text
Raw Normal View History

2024-01-16 11:20:27 -06:00
/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file bamCache.I
* @author drose
* @date 2006-06-09
*/
/**
* Changes the state of the active flag. "active" means that the cache should
* be consulted automatically on loads, "not active" means that objects should
* be loaded directly without consulting the cache.
*
* This represents the global flag. Also see the individual cache_models,
* cache_textures, cache_compressed_textures flags.
*/
INLINE void BamCache::
set_active(bool active) {
ReMutexHolder holder(_lock);
_active = active;
}
/**
* Returns true if the BamCache is currently active, false if it is not.
* "active" means that the cache should be consulted automatically on loads,
* "not active" means that objects should be loaded directly without
* consulting the cache.
*
* This represents the global flag. Also see the individual cache_models,
* cache_textures, cache_compressed_textures flags.
*/
INLINE bool BamCache::
get_active() const {
ReMutexHolder holder(_lock);
return _active;
}
/**
* Indicates whether model files (e.g. egg files and bam files) will be
* stored in the cache, as bam files.
*/
INLINE void BamCache::
set_cache_models(bool flag) {
ReMutexHolder holder(_lock);
_cache_models = flag;
}
/**
* Returns whether model files (e.g. egg files and bam files) will be stored
* in the cache, as bam files.
*
* This also returns false if get_active() is false.
*/
INLINE bool BamCache::
get_cache_models() const {
ReMutexHolder holder(_lock);
return _cache_models && _active;
}
/**
* Indicates whether texture files will be stored in the cache, as
* uncompressed txo files.
*/
INLINE void BamCache::
set_cache_textures(bool flag) {
ReMutexHolder holder(_lock);
_cache_textures = flag;
}
/**
* Returns whether texture files (e.g. egg files and bam files) will be
* stored in the cache, as txo files.
*
* This also returns false if get_active() is false.
*/
INLINE bool BamCache::
get_cache_textures() const {
ReMutexHolder holder(_lock);
return _cache_textures && _active;
}
/**
* Indicates whether compressed texture files will be stored in the cache, as
* compressed txo files. The compressed data may either be generated in-CPU,
* via the squish library, or it may be extracted from the GSG after the
* texture has been loaded.
*
* This may be set in conjunction with set_cache_textures(), or independently
* of it. If set_cache_textures() is true and this is false, all textures
* will be cached in their uncompressed form. If set_cache_textures() is
* false and this is true, only compressed textures will be cached, and they
* will be cached in their compressed form. If both are true, all textures
* will be cached, in their uncompressed or compressed form appropriately.
*/
INLINE void BamCache::
set_cache_compressed_textures(bool flag) {
ReMutexHolder holder(_lock);
_cache_compressed_textures = flag;
}
/**
* Returns whether compressed texture files will be stored in the cache, as
* compressed txo files. See set_cache_compressed_textures().
*
* This also returns false if get_active() is false.
*/
INLINE bool BamCache::
get_cache_compressed_textures() const {
ReMutexHolder holder(_lock);
return _cache_compressed_textures && _active;
}
/**
* Indicates whether compiled shader programs will be stored in the cache, as
* binary .sho files. This may not be supported by all shader languages or
* graphics renderers.
*/
INLINE void BamCache::
set_cache_compiled_shaders(bool flag) {
ReMutexHolder holder(_lock);
_cache_compiled_shaders = flag;
}
/**
* Returns whether compiled shader programs will be stored in the cache, as
* binary .txo files. See set_cache_compiled_shaders().
*
* This also returns false if get_active() is false.
*/
INLINE bool BamCache::
get_cache_compiled_shaders() const {
ReMutexHolder holder(_lock);
return _cache_compiled_shaders && _active;
}
/**
* Returns the current root pathname of the cache. See set_root().
*/
INLINE Filename BamCache::
get_root() const {
ReMutexHolder holder(_lock);
return _root;
}
/**
* Specifies the time in seconds between automatic flushes of the cache index.
*/
INLINE void BamCache::
set_flush_time(int flush_time) {
ReMutexHolder holder(_lock);
_flush_time = flush_time;
}
/**
* Returns the time in seconds between automatic flushes of the cache index.
*/
INLINE int BamCache::
get_flush_time() const {
ReMutexHolder holder(_lock);
return _flush_time;
}
/**
* Specifies the maximum size, in kilobytes, which the cache is allowed to
* grow to. If a newly cached file would exceed this size, an older file is
* removed from the cache.
*
* Note that in the case of multiple different processes simultaneously
* operating on the same cache directory, the actual cache size may slightly
* exceed this value from time to time due to latency in checking between the
* processes.
*/
INLINE void BamCache::
set_cache_max_kbytes(int max_kbytes) {
ReMutexHolder holder(_lock);
_max_kbytes = max_kbytes;
check_cache_size();
}
/**
* Returns the maximum size, in kilobytes, which the cache is allowed to grow
* to. See set_cache_max_kbytes().
*/
INLINE int BamCache::
get_cache_max_kbytes() const {
ReMutexHolder holder(_lock);
return _max_kbytes;
}
/**
* Can be used to put the cache in read-only mode, or take it out of read-only
* mode. Note that if you put it into read-write mode, and it discovers that
* it does not have write access, it will put itself right back into read-only
* mode.
*/
INLINE void BamCache::
set_read_only(bool ro) {
ReMutexHolder holder(_lock);
_read_only = ro;
}
/**
* Returns true if the cache is in read-only mode. Normally, the cache starts
* in read-write mode. It can put itself into read-only mode automatically if
* it discovers that it does not have write access to the cache.
*/
INLINE bool BamCache::
get_read_only() const {
ReMutexHolder holder(_lock);
return _read_only;
}
/**
* Returns a pointer to the global BamCache object, which is used
* automatically by the ModelPool and TexturePool.
*/
INLINE BamCache *BamCache::
get_global_ptr() {
if (_global_ptr == nullptr) {
make_global();
}
return _global_ptr;
}
/**
* If there is a global BamCache object, calls consider_flush_index() on it.
*/
INLINE void BamCache::
consider_flush_global_index() {
if (_global_ptr != nullptr) {
_global_ptr->consider_flush_index();
}
}
/**
* If there is a global BamCache object, calls flush_index() on it.
*/
INLINE void BamCache::
flush_global_index() {
if (_global_ptr != nullptr) {
_global_ptr->flush_index();
}
}
/**
* Indicates that the index has been modified and will need to be written to
* disk eventually.
*/
INLINE void BamCache::
mark_index_stale() {
if (_index_stale_since == 0) {
_index_stale_since = time(nullptr);
}
}