S3D_CACHE Class Reference

Cache for storing the 3D shapes. More...

#include <3d_cache.h>

Inheritance diagram for S3D_CACHE:

Public Member Functions
	S3D_CACHE ()
virtual	~S3D_CACHE ()
KICAD_T	Type () noexcept override
bool	Set3DConfigDir (const wxString &aConfigDir)
	Sets the configuration directory to be used by the model manager for storing 3D model manager configuration data and the model cache. More...
bool	SetProject (PROJECT *aProject)
	Set the current project's working directory; this affects the model search path. More...
void	SetProgramBase (PGM_BASE *aBase)
	Set the filename resolver's pointer to the application's PGM_BASE instance. More...
SCENEGRAPH *	Load (const wxString &aModelFile)
	Attempt to load the scene data for a model. More...
FILENAME_RESOLVER *	GetResolver () noexcept
std::list< wxString > const *	GetFileFilters () const
	Return the list of file filters retrieved from the plugins. More...
void	FlushCache (bool closePlugins=true)
	Free all data in the cache and by default closes all plugins. More...
void	ClosePlugins ()
	Unload plugins to free memory. More...
S3DMODEL *	GetModel (const wxString &aModelFileName)
	Attempt to load the scene data for a model and to translate it into an S3D_MODEL structure for display by a renderer. More...
void	CleanCacheDir (int aNumDaysOld)
	Delete up old cache files in cache directory. More...

Private Member Functions
SCENEGRAPH *	checkCache (const wxString &aFileName, S3D_CACHE_ENTRY **aCachePtr=nullptr)
	Find or create cache entry for file name. More...
bool	getSHA1 (const wxString &aFileName, unsigned char *aSHA1Sum)
	Calculate the SHA1 hash of the given file. More...
bool	loadCacheData (S3D_CACHE_ENTRY *aCacheItem)
bool	saveCacheData (S3D_CACHE_ENTRY *aCacheItem)
SCENEGRAPH *	load (const wxString &aModelFile, S3D_CACHE_ENTRY **aCachePtr=nullptr)

Private Attributes
std::list< S3D_CACHE_ENTRY * >	m_CacheList
	cache entries More...
std::map< wxString, S3D_CACHE_ENTRY *, rsort_wxString >	m_CacheMap
	mapping of file names to cache names and data More...
FILENAME_RESOLVER *	m_FNResolver
S3D_PLUGIN_MANAGER *	m_Plugins
PROJECT *	m_project
wxString	m_CacheDir
wxString	m_ConfigDir

Detailed Description

Cache for storing the 3D shapes.

This cache is able to be stored as a project element (since it inherits from PROJECT::_ELEM).

Definition at line 52 of file 3d_cache.h.

Constructor & Destructor Documentation

S3D_CACHE()

S3D_CACHE::S3D_CACHE

(

)

Definition at line 186 of file 3d_cache.cpp.

{
    m_FNResolver = new FILENAME_RESOLVER;
    m_project = nullptr;
    m_Plugins = new S3D_PLUGIN_MANAGER;
}

References m_FNResolver, m_Plugins, and m_project.

~S3D_CACHE()

S3D_CACHE::~S3D_CACHE ( )

virtual

Definition at line 194 of file 3d_cache.cpp.

{
    COMMON_SETTINGS* commonSettings = Pgm().GetCommonSettings();

    FlushCache();

    // We'll delete ".3dc" cache files older than this many days
    int clearCacheInterval = commonSettings->m_System.clear_3d_cache_interval;

    // An interval of zero means the user doesn't want to ever clear the cache

    if( clearCacheInterval > 0 )
        CleanCacheDir( clearCacheInterval );

    delete m_FNResolver;
    delete m_Plugins;
}

References CleanCacheDir(), COMMON_SETTINGS::SYSTEM::clear_3d_cache_interval, FlushCache(), m_FNResolver, m_Plugins, COMMON_SETTINGS::m_System, and Pgm().

Member Function Documentation

checkCache()

SCENEGRAPH * S3D_CACHE::checkCache ( const wxString &  aFileName, S3D_CACHE_ENTRY **  aCachePtr = nullptr  )

private

Find or create cache entry for file name.

Searches the cache list for the given filename and retrieves the cache data; a cache entry is created if one does not already exist.

Parameters

aFileName	is the file name (full or partial path).
aCachePtr	is an optional return address for cache entry pointer.

Returns

SCENEGRAPH object associated with file name or NULL on error.

Definition at line 289 of file 3d_cache.cpp.

{
    if( aCachePtr )
        *aCachePtr = nullptr;

    unsigned char sha1sum[20];

    if( !getSHA1( aFileName, sha1sum ) || m_CacheDir.empty() )
    {
        // just in case we can't get a hash digest (for example, on access issues)
        // or we do not have a configured cache file directory, we create an
        // entry to prevent further attempts at loading the file
        S3D_CACHE_ENTRY* ep = new S3D_CACHE_ENTRY;
        m_CacheList.push_back( ep );
        wxFileName fname( aFileName );
        ep->modTime = fname.GetModificationTime();

        if( m_CacheMap.insert( std::pair< wxString, S3D_CACHE_ENTRY* >
            ( aFileName, ep ) ).second == false )
        {
            wxLogTrace( MASK_3D_CACHE, "%s:%s:%d\n * [BUG] duplicate entry in map file; key = '%s'",
                        __FILE__, __FUNCTION__, __LINE__, aFileName );

            m_CacheList.pop_back();
            delete ep;
        }
        else
        {
            if( aCachePtr )
                *aCachePtr = ep;
        }

        return nullptr;
    }

    S3D_CACHE_ENTRY* ep = new S3D_CACHE_ENTRY;
    m_CacheList.push_back( ep );
    wxFileName fname( aFileName );
    ep->modTime = fname.GetModificationTime();

    if( m_CacheMap.insert( std::pair< wxString, S3D_CACHE_ENTRY* >
                               ( aFileName, ep ) ).second == false )
    {
        wxLogTrace( MASK_3D_CACHE, "%s:%s:%d\n * [BUG] duplicate entry in map file; key = '%s'",
                    __FILE__, __FUNCTION__, __LINE__, aFileName );

        m_CacheList.pop_back();
        delete ep;
        return nullptr;
    }

    if( aCachePtr )
        *aCachePtr = ep;

    ep->SetSHA1( sha1sum );

    wxString bname = ep->GetCacheBaseName();
    wxString cachename = m_CacheDir + bname + wxT( ".3dc" );

    if( wxFileName::FileExists( cachename ) && loadCacheData( ep ) )
        return ep->sceneData;

    ep->sceneData = m_Plugins->Load3DModel( aFileName, ep->pluginInfo );

    if( nullptr != ep->sceneData )
        saveCacheData( ep );

    return ep->sceneData;
}

References S3D_CACHE_ENTRY::GetCacheBaseName(), getSHA1(), S3D_PLUGIN_MANAGER::Load3DModel(), loadCacheData(), m_CacheDir, m_CacheList, m_CacheMap, m_Plugins, MASK_3D_CACHE, S3D_CACHE_ENTRY::modTime, S3D_CACHE_ENTRY::pluginInfo, saveCacheData(), S3D_CACHE_ENTRY::sceneData, and S3D_CACHE_ENTRY::SetSHA1().

Referenced by load().

CleanCacheDir()

void S3D_CACHE::CleanCacheDir

(

int

aNumDaysOld

)

Delete up old cache files in cache directory.

Deletes ".3dc" files in the cache directory that are older than aNumDaysOld.

Parameters

aNumDaysOld

is age threshold to delete ".3dc" cache files.

Definition at line 672 of file 3d_cache.cpp.

{
    wxDir         dir;
    wxString      fileSpec = wxT( "*.3dc" );
    wxArrayString fileList; // Holds list of ".3dc" files found in cache directory
    size_t        numFilesFound = 0;

    wxFileName thisFile;
    wxDateTime lastAccess, thresholdDate;
    wxDateSpan durationInDays;

    // Calc the threshold date above which we delete cache files
    durationInDays.SetDays( aNumDaysOld );
    thresholdDate = wxDateTime::Now() - durationInDays;

    // If the cache directory can be found and opened, then we'll try and clean it up
    if( dir.Open( m_CacheDir ) )
    {
        thisFile.SetPath( m_CacheDir ); // Set the base path to the cache folder

        // Get a list of all the ".3dc" files in the cache directory
        numFilesFound = dir.GetAllFiles( m_CacheDir, &fileList, fileSpec );

        for( unsigned int i = 0; i < numFilesFound; i++ )
        {
            // Completes path to specific file so we can get its "last access" date
            thisFile.SetFullName( fileList[i] );

            // Only get "last access" time to compare against. Don't need the other 2 timestamps.
            if( thisFile.GetTimes( &lastAccess, nullptr, nullptr ) )
            {
                if( lastAccess.IsEarlierThan( thresholdDate ) )
                {
                    // This file is older than the threshold so delete it
                    wxRemoveFile( thisFile.GetFullPath() );
                }
            }
        }
    }
}

References m_CacheDir.

Referenced by ~S3D_CACHE().

ClosePlugins()

void S3D_CACHE::ClosePlugins

(

)

Unload plugins to free memory.

Definition at line 639 of file 3d_cache.cpp.

{
    if( m_Plugins )
        m_Plugins->ClosePlugins();
}

References S3D_PLUGIN_MANAGER::ClosePlugins(), and m_Plugins.

Referenced by FlushCache().

FlushCache()

void S3D_CACHE::FlushCache

(

bool

closePlugins = true

)

Free all data in the cache and by default closes all plugins.

Definition at line 620 of file 3d_cache.cpp.

{
    std::list< S3D_CACHE_ENTRY* >::iterator sCL = m_CacheList.begin();
    std::list< S3D_CACHE_ENTRY* >::iterator eCL = m_CacheList.end();

    while( sCL != eCL )
    {
        delete *sCL;
        ++sCL;
    }

    m_CacheList.clear();
    m_CacheMap.clear();

    if( closePlugins )
        ClosePlugins();
}

References ClosePlugins(), m_CacheList, and m_CacheMap.

Referenced by ~S3D_CACHE().

GetFileFilters()

std::list< wxString > const * S3D_CACHE::GetFileFilters

(

)

const

Return the list of file filters retrieved from the plugins.

This will contain at least the default "All Files (*.*)|*.*"

Returns

a pointer to the filter list.

Definition at line 614 of file 3d_cache.cpp.

{
    return m_Plugins->GetFileFilters();
}

References S3D_PLUGIN_MANAGER::GetFileFilters(), and m_Plugins.

Referenced by DLG_SELECT_3DMODEL::DLG_SELECT_3DMODEL().

GetModel()

S3DMODEL * S3D_CACHE::GetModel

(

const wxString &

aModelFileName

)

Attempt to load the scene data for a model and to translate it into an S3D_MODEL structure for display by a renderer.

Parameters

aModelFileName

is the full path to the model to be loaded.

Returns

is a pointer to the render data or NULL if not available.

Definition at line 646 of file 3d_cache.cpp.

{
    S3D_CACHE_ENTRY* cp = nullptr;
    SCENEGRAPH* sp = load( aModelFileName, &cp );

    if( !sp )
        return nullptr;

    if( !cp )
    {
        wxLogTrace( MASK_3D_CACHE,
                    "%s:%s:%d\n  * [BUG] model loaded with no associated S3D_CACHE_ENTRY",
                    __FILE__, __FUNCTION__, __LINE__ );

        return nullptr;
    }

    if( cp->renderData )
        return cp->renderData;

    S3DMODEL* mp = S3D::GetModel( sp );
    cp->renderData = mp;

    return mp;
}

References S3D::GetModel(), load(), MASK_3D_CACHE, and S3D_CACHE_ENTRY::renderData.

Referenced by RENDER_3D_LEGACY::load3dModels(), RENDER_3D_RAYTRACE::loadModels(), and C3D_MODEL_VIEWER::Set3DModel().

GetResolver()

FILENAME_RESOLVER * S3D_CACHE::GetResolver ( )

noexcept

Definition at line 608 of file 3d_cache.cpp.

{
    return m_FNResolver;
}

References m_FNResolver.

Referenced by DLG_SELECT_3DMODEL::DLG_SELECT_3DMODEL(), and EXPORTER_PCB_VRML::ExportVrmlFootprint().

getSHA1()

bool S3D_CACHE::getSHA1 ( const wxString &  aFileName, unsigned char *  aSHA1Sum  )

private

Calculate the SHA1 hash of the given file.

Parameters

aFileName	file name (full path).
aSHA1Sum	a 20 byte character array to hold the SHA1 hash.

Returns

true on success, otherwise false.

Definition at line 360 of file 3d_cache.cpp.

{
    if( aFileName.empty() )
    {
        wxLogTrace( MASK_3D_CACHE, "%s:%s:%d\n * [BUG] empty filename",
                    __FILE__, __FUNCTION__, __LINE__ );

        return false;
    }

    if( nullptr == aSHA1Sum )
    {
        wxLogTrace( MASK_3D_CACHE, "%s\n * [BUG] NULL pointer passed for aMD5Sum",
                    __FILE__, __FUNCTION__, __LINE__ );

        return false;
    }

#ifdef _WIN32
    FILE* fp = _wfopen( aFileName.wc_str(), L"rb" );
#else
    FILE* fp = fopen( aFileName.ToUTF8(), "rb" );
#endif

    if( nullptr == fp )
        return false;

    boost::uuids::detail::sha1 dblock;
    unsigned char block[4096];
    size_t bsize = 0;

    while( ( bsize = fread( &block, 1, 4096, fp ) ) > 0 )
        dblock.process_bytes( block, bsize );

    fclose( fp );
    unsigned int digest[5];
    dblock.get_digest( digest );

    // ensure MSB order
    for( int i = 0; i < 5; ++i )
    {
        int idx = i << 2;
        unsigned int tmp = digest[i];
        aSHA1Sum[idx+3] = tmp & 0xff;
        tmp >>= 8;
        aSHA1Sum[idx+2] = tmp & 0xff;
        tmp >>= 8;
        aSHA1Sum[idx+1] = tmp & 0xff;
        tmp >>= 8;
        aSHA1Sum[idx] = tmp & 0xff;
    }

    return true;
}

References MASK_3D_CACHE.

Referenced by checkCache(), and load().

Load()

SCENEGRAPH * S3D_CACHE::Load

(

const wxString &

aModelFile

)

Attempt to load the scene data for a model.

It will consult the internal cache list and load from cache if possible before invoking the load() function of the available plugins. The model may fail to load if, for example, the plugin does not support rendering of the 3D model.

Parameters

aModelFile

is the partial or full path to the model to be loaded.

Returns

true if the model was successfully loaded, otherwise false.

Definition at line 283 of file 3d_cache.cpp.

{
    return load( aModelFile );
}

References load().

Referenced by EXPORTER_PCB_VRML::ExportVrmlFootprint().

load()

SCENEGRAPH * S3D_CACHE::load ( const wxString &  aModelFile, S3D_CACHE_ENTRY **  aCachePtr = nullptr  )

private

Definition at line 213 of file 3d_cache.cpp.

{
    if( aCachePtr )
        *aCachePtr = nullptr;

    wxString full3Dpath = m_FNResolver->ResolvePath( aModelFile );

    if( full3Dpath.empty() )
    {
        // the model cannot be found; we cannot proceed
        wxLogTrace( MASK_3D_CACHE, "%s:%s:%d\n * [3D model] could not find model '%s'\n",
                    __FILE__, __FUNCTION__, __LINE__, aModelFile );
        return nullptr;
    }

    // check cache if file is already loaded
    std::lock_guard<std::mutex> lock( mutex3D_cache );

    std::map< wxString, S3D_CACHE_ENTRY*, rsort_wxString >::iterator mi;
    mi = m_CacheMap.find( full3Dpath );

    if( mi != m_CacheMap.end() )
    {
        wxFileName fname( full3Dpath );

        if( fname.FileExists() )    // Only check if file exists. If not, it will
        {                           // use the same model in cache.
            bool reload = false;
            wxDateTime fmdate = fname.GetModificationTime();

            if( fmdate != mi->second->modTime )
            {
                unsigned char hashSum[20];
                getSHA1( full3Dpath, hashSum );
                mi->second->modTime = fmdate;

                if( !isSHA1Same( hashSum, mi->second->sha1sum ) )
                {
                    mi->second->SetSHA1( hashSum );
                    reload = true;
                }
            }

            if( reload )
            {
                if( nullptr != mi->second->sceneData )
                {
                    S3D::DestroyNode( mi->second->sceneData );
                    mi->second->sceneData = nullptr;
                }

                if( nullptr != mi->second->renderData )
                    S3D::Destroy3DModel( &mi->second->renderData );

                mi->second->sceneData = m_Plugins->Load3DModel( full3Dpath,
                                                                mi->second->pluginInfo );
            }
        }

        if( nullptr != aCachePtr )
            *aCachePtr = mi->second;

        return mi->second->sceneData;
    }

    // a cache item does not exist; search the Filename->Cachename map
    return checkCache( full3Dpath, aCachePtr );
}

References checkCache(), S3D::Destroy3DModel(), S3D::DestroyNode(), getSHA1(), isSHA1Same(), S3D_PLUGIN_MANAGER::Load3DModel(), m_CacheMap, m_FNResolver, m_Plugins, MASK_3D_CACHE, mutex3D_cache, reload, FILENAME_RESOLVER::ResolvePath(), and S3D_CACHE_ENTRY::sceneData.

Referenced by GetModel(), and Load().

loadCacheData()

bool S3D_CACHE::loadCacheData ( S3D_CACHE_ENTRY *  aCacheItem )

private

Definition at line 416 of file 3d_cache.cpp.

{
    wxString bname = aCacheItem->GetCacheBaseName();

    if( bname.empty() )
    {
        wxLogTrace( MASK_3D_CACHE,
                    " * [3D model] cannot load cached model; no file hash available" );

        return false;
    }

    if( m_CacheDir.empty() )
    {
        wxLogTrace( MASK_3D_CACHE,
                    " * [3D model] cannot load cached model; config directory unknown" );

        return false;
    }

    wxString fname = m_CacheDir + bname + wxT( ".3dc" );

    if( !wxFileName::FileExists( fname ) )
    {
        wxString errmsg = "cannot open file";
        wxLogTrace( MASK_3D_CACHE, " * [3D model] %s '%s'", errmsg.GetData(), fname.GetData() );
        return false;
    }

    if( nullptr != aCacheItem->sceneData )
        S3D::DestroyNode( (SGNODE*) aCacheItem->sceneData );

    aCacheItem->sceneData = (SCENEGRAPH*)S3D::ReadCache( fname.ToUTF8(), m_Plugins, checkTag );

    if( nullptr == aCacheItem->sceneData )
        return false;

    return true;
}

References checkTag(), S3D::DestroyNode(), S3D_CACHE_ENTRY::GetCacheBaseName(), m_CacheDir, m_Plugins, MASK_3D_CACHE, S3D::ReadCache(), and S3D_CACHE_ENTRY::sceneData.

Referenced by checkCache().

saveCacheData()

bool S3D_CACHE::saveCacheData ( S3D_CACHE_ENTRY *  aCacheItem )

private

Definition at line 457 of file 3d_cache.cpp.

{
    if( nullptr == aCacheItem )
    {
        wxLogTrace( MASK_3D_CACHE, "%s:%s:%d\n * NULL passed for aCacheItem",
                    __FILE__, __FUNCTION__, __LINE__ );

        return false;
    }

    if( nullptr == aCacheItem->sceneData )
    {
        wxLogTrace( MASK_3D_CACHE, "%s:%s:%d\n * aCacheItem has no valid scene data",
                    __FILE__, __FUNCTION__, __LINE__ );

        return false;
    }

    wxString bname = aCacheItem->GetCacheBaseName();

    if( bname.empty() )
    {
        wxLogTrace( MASK_3D_CACHE,
                    " * [3D model] cannot load cached model; no file hash available" );

        return false;
    }

    if( m_CacheDir.empty() )
    {
        wxLogTrace( MASK_3D_CACHE,
                    " * [3D model] cannot load cached model; config directory unknown" );

        return false;
    }

    wxString fname = m_CacheDir + bname + wxT( ".3dc" );

    if( wxFileName::Exists( fname ) )
    {
        if( !wxFileName::FileExists( fname ) )
        {
            wxLogTrace( MASK_3D_CACHE, " * [3D model] path exists but is not a regular file '%s'",
                        fname );

            return false;
        }
    }

    return S3D::WriteCache( fname.ToUTF8(), true, (SGNODE*)aCacheItem->sceneData,
                            aCacheItem->pluginInfo.c_str() );
}

References S3D_CACHE_ENTRY::GetCacheBaseName(), m_CacheDir, MASK_3D_CACHE, S3D_CACHE_ENTRY::pluginInfo, S3D_CACHE_ENTRY::sceneData, and S3D::WriteCache().

Referenced by checkCache().

Set3DConfigDir()

bool S3D_CACHE::Set3DConfigDir

(

const wxString &

aConfigDir

)

Sets the configuration directory to be used by the model manager for storing 3D model manager configuration data and the model cache.

The config directory may only be set once in the lifetime of the object.

Parameters

aConfigDir

is the configuration directory to use for 3D model manager data

Returns

true on success

Definition at line 511 of file 3d_cache.cpp.

{
    if( !m_ConfigDir.empty() )
        return false;

    wxFileName cfgdir( ExpandEnvVarSubstitutions( aConfigDir, m_project ), "" );

    cfgdir.Normalize();

    if( !cfgdir.DirExists() )
    {
        cfgdir.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );

        if( !cfgdir.DirExists() )
        {
            wxLogTrace( MASK_3D_CACHE,
                        "%s:%s:%d\n * failed to create 3D configuration directory '%s'",
                        __FILE__, __FUNCTION__, __LINE__, cfgdir.GetPath() );

            return false;
        }
    }

    m_ConfigDir = cfgdir.GetPath();

    // inform the file resolver of the config directory
    if( !m_FNResolver->Set3DConfigDir( m_ConfigDir ) )
    {
        wxLogTrace( MASK_3D_CACHE,
                    "%s:%s:%d\n * could not set 3D Config Directory on filename resolver\n"
                    " * config directory: '%s'",
                    __FILE__, __FUNCTION__, __LINE__, m_ConfigDir );
    }

    // 3D cache data must go to a user's cache directory;
    // unfortunately wxWidgets doesn't seem to provide
    // functions to retrieve such a directory.
    //
    // 1. OSX: ~/Library/Caches/kicad/3d/
    // 2. Linux: ${XDG_CACHE_HOME}/kicad/3d ~/.cache/kicad/3d/
    // 3. MSWin: AppData\Local\kicad\3d
    wxFileName cacheDir;
    cacheDir.AssignDir( PATHS::GetUserCachePath() );
    cacheDir.AppendDir( "3d" );

    if( !cacheDir.DirExists() )
    {
        cacheDir.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );

        if( !cacheDir.DirExists() )
        {
            wxLogTrace( MASK_3D_CACHE, "%s:%s:%d\n * failed to create 3D cache directory '%s'",
                        __FILE__, __FUNCTION__, __LINE__, cacheDir.GetPath() );

            return false;
        }
    }

    m_CacheDir = cacheDir.GetPathWithSep();
    return true;
}

References ExpandEnvVarSubstitutions(), PATHS::GetUserCachePath(), m_CacheDir, m_ConfigDir, m_FNResolver, m_project, MASK_3D_CACHE, and FILENAME_RESOLVER::Set3DConfigDir().

SetProgramBase()

void S3D_CACHE::SetProgramBase

(

PGM_BASE *

aBase

)

Set the filename resolver's pointer to the application's PGM_BASE instance.

The pointer is used to extract the local environment variables.

Definition at line 602 of file 3d_cache.cpp.

{
    m_FNResolver->SetProgramBase( aBase );
}

References m_FNResolver, and FILENAME_RESOLVER::SetProgramBase().

SetProject()

bool S3D_CACHE::SetProject

(

PROJECT *

aProject

)

Set the current project's working directory; this affects the model search path.

Definition at line 574 of file 3d_cache.cpp.

{
    m_project = aProject;

    bool hasChanged = false;

    if( m_FNResolver->SetProject( aProject, &hasChanged ) && hasChanged )
    {
        m_CacheMap.clear();

        std::list< S3D_CACHE_ENTRY* >::iterator sL = m_CacheList.begin();
        std::list< S3D_CACHE_ENTRY* >::iterator eL = m_CacheList.end();

        while( sL != eL )
        {
            delete *sL;
            ++sL;
        }

        m_CacheList.clear();

        return true;
    }

    return false;
}

References m_CacheList, m_CacheMap, m_FNResolver, m_project, and FILENAME_RESOLVER::SetProject().

Type()

KICAD_T S3D_CACHE::Type ( )

inlineoverridevirtualnoexcept

Implements PROJECT::_ELEM.

Definition at line 58 of file 3d_cache.h.

    {
        return S3D_CACHE_T;
    }

References S3D_CACHE_T.

Member Data Documentation

m_CacheDir

wxString S3D_CACHE::m_CacheDir

private

Definition at line 180 of file 3d_cache.h.

Referenced by checkCache(), CleanCacheDir(), loadCacheData(), saveCacheData(), and Set3DConfigDir().

m_CacheList

std::list< S3D_CACHE_ENTRY* > S3D_CACHE::m_CacheList

private

cache entries

Definition at line 170 of file 3d_cache.h.

Referenced by checkCache(), FlushCache(), and SetProject().

m_CacheMap

std::map< wxString, S3D_CACHE_ENTRY*, rsort_wxString > S3D_CACHE::m_CacheMap

private

mapping of file names to cache names and data

Definition at line 173 of file 3d_cache.h.

Referenced by checkCache(), FlushCache(), load(), and SetProject().

m_ConfigDir

wxString S3D_CACHE::m_ConfigDir

private

Definition at line 181 of file 3d_cache.h.

Referenced by Set3DConfigDir().

m_FNResolver

FILENAME_RESOLVER* S3D_CACHE::m_FNResolver

private

Definition at line 175 of file 3d_cache.h.

Referenced by GetResolver(), load(), S3D_CACHE(), Set3DConfigDir(), SetProgramBase(), SetProject(), and ~S3D_CACHE().

m_Plugins

S3D_PLUGIN_MANAGER* S3D_CACHE::m_Plugins

private

Definition at line 177 of file 3d_cache.h.

Referenced by checkCache(), ClosePlugins(), GetFileFilters(), load(), loadCacheData(), S3D_CACHE(), and ~S3D_CACHE().

m_project

PROJECT* S3D_CACHE::m_project

private

Definition at line 179 of file 3d_cache.h.

Referenced by S3D_CACHE(), Set3DConfigDir(), and SetProject().

---

The documentation for this class was generated from the following files:

• 3d_cache.h
• 3d_cache.cpp