259 lines
7 KiB
Text
259 lines
7 KiB
Text
/**
|
|
* 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);
|
|
}
|
|
}
|