mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-03-18 11:30:32 -05:00
Code Issues Packages Projects Releases Wiki Activity

rename TileProvider -> CachingTileProvider

Browse Source
This commit is contained in:
Erik Broberg
2016-06-02 12:31:57 -04:00
parent 87e1a623dd
commit 0b62168317
7 changed files with 38 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
modules/globebrowsing/globes/renderableglobe.cpp
View File

@@ -127,8 +127,8 @@ namespace openspace {
std::shared_ptr<AsyncTileDataProvider> tileReader = std::shared_ptr<AsyncTileDataProvider>(
new AsyncTileDataProvider(tileDataset, threadPool));
std::shared_ptr<TileProvider> colorTextureProvider = std::shared_ptr<TileProvider>(
new TileProvider(tileReader, cacheSize, frameUntilFlushRequestQueue));
std::shared_ptr<CachingTileProvider> colorTextureProvider = std::shared_ptr<CachingTileProvider>(
new CachingTileProvider(tileReader, cacheSize, frameUntilFlushRequestQueue));
_tileProviderManager->addColorTexture(name, colorTextureProvider, true);
@@ -159,8 +159,8 @@ namespace openspace {
std::shared_ptr<AsyncTileDataProvider> tileReader = std::shared_ptr<AsyncTileDataProvider>(
new AsyncTileDataProvider(tileDataset, threadPool));
std::shared_ptr<TileProvider> heightMapProvider = std::shared_ptr<TileProvider>(
new TileProvider(tileReader, cacheSize, frameUntilFlushRequestQueue));
std::shared_ptr<CachingTileProvider> heightMapProvider = std::shared_ptr<CachingTileProvider>(
new CachingTileProvider(tileReader, cacheSize, frameUntilFlushRequestQueue));
_tileProviderManager->addHeightMap(name, heightMapProvider, true);

12
modules/globebrowsing/other/TileProviderManager.cpp
View File

@@ -44,7 +44,7 @@ namespace openspace {
void TileProviderManager::addHeightMap(
std::string name,
std::shared_ptr<TileProvider> tileProvider,
std::shared_ptr<CachingTileProvider> tileProvider,
bool isActive)
{
_heightMapProviders.push_back({ name , tileProvider, isActive});
@@ -52,7 +52,7 @@ namespace openspace {
void TileProviderManager::addColorTexture(
std::string name,
std::shared_ptr<TileProvider> tileProvider,
std::shared_ptr<CachingTileProvider> tileProvider,
bool isActive)
{
_colorTextureProviders.push_back({ name , tileProvider, isActive });
@@ -70,10 +70,10 @@ namespace openspace {
return _colorTextureProviders;
}
const std::vector<std::shared_ptr<TileProvider> >
const std::vector<std::shared_ptr<CachingTileProvider> >
TileProviderManager::getActiveHeightMapProviders()
{
std::vector<std::shared_ptr<TileProvider> > tileProviders;
std::vector<std::shared_ptr<CachingTileProvider> > tileProviders;
for (auto it = _heightMapProviders.begin(); it != _heightMapProviders.end(); it++)
{
if (it->isActive) {
@@ -83,10 +83,10 @@ namespace openspace {
return tileProviders;
}
const std::vector<std::shared_ptr<TileProvider> >
const std::vector<std::shared_ptr<CachingTileProvider> >
TileProviderManager::getActiveColorTextureProviders()
{
std::vector<std::shared_ptr<TileProvider> > tileProviders;
std::vector<std::shared_ptr<CachingTileProvider> > tileProviders;
for (auto it = _colorTextureProviders.begin(); it != _colorTextureProviders.end(); it++)
{
if (it->isActive) {

14
modules/globebrowsing/other/TileProviderManager.h
View File

@@ -39,7 +39,7 @@ namespace openspace {
public:
struct TileProviderWithName {
std::string name;
std::shared_ptr<TileProvider> tileProvider;
std::shared_ptr<CachingTileProvider> tileProvider;
bool isActive;
};
@@ -50,18 +50,18 @@ namespace openspace {
void addHeightMap(
std::string name,
std::shared_ptr<TileProvider> tileProvider,
std::shared_ptr<CachingTileProvider> tileProvider,
bool isActive);
void addColorTexture(
std::string name,
std::shared_ptr<TileProvider> tileProvider,
std::shared_ptr<CachingTileProvider> tileProvider,
bool isActive);
/*
std::shared_ptr<TileProvider> getHeightMap(std::string name);
std::shared_ptr<TileProvider> getColorTexture(std::string name);
std::shared_ptr<CachingTileProvider> getHeightMap(std::string name);
std::shared_ptr<CachingTileProvider> getColorTexture(std::string name);
*/
const std::vector<std::shared_ptr<TileProvider> > getActiveHeightMapProviders();
const std::vector<std::shared_ptr<TileProvider> > getActiveColorTextureProviders();
const std::vector<std::shared_ptr<CachingTileProvider> > getActiveHeightMapProviders();
const std::vector<std::shared_ptr<CachingTileProvider> > getActiveColorTextureProviders();
std::vector<TileProviderWithName>& heightMapProviders();
std::vector<TileProviderWithName>& colorTextureProviders();

8
modules/globebrowsing/other/temporaltileprovider.cpp
View File

@@ -63,7 +63,7 @@ namespace openspace {
}
std::shared_ptr<TileProvider> TemporalTileProvider::getTileProvider(Time t) {
std::shared_ptr<CachingTileProvider> TemporalTileProvider::getTileProvider(Time t) {
TimeKey timekey = getTimeKey(t);
auto it = _tileProviderMap.find(timekey);
if (it != _tileProviderMap.end()) {
@@ -76,7 +76,7 @@ namespace openspace {
}
}
std::shared_ptr<TileProvider> TemporalTileProvider::initTileProvider(TimeKey timekey) {
std::shared_ptr<CachingTileProvider> TemporalTileProvider::initTileProvider(TimeKey timekey) {
std::string gdalDatasetXml = getGdalDatasetXML(timekey);
std::shared_ptr<TileDataset> tileDataset = std::shared_ptr<TileDataset>(
@@ -88,8 +88,8 @@ namespace openspace {
std::shared_ptr<AsyncTileDataProvider> tileReader = std::shared_ptr<AsyncTileDataProvider>(
new AsyncTileDataProvider(tileDataset, threadPool));
std::shared_ptr<TileProvider> tileProvider= std::shared_ptr<TileProvider>(
new TileProvider(tileReader,
std::shared_ptr<CachingTileProvider> tileProvider= std::shared_ptr<CachingTileProvider>(
new CachingTileProvider(tileReader,
_tileProviderInitData.cacheSize,
_tileProviderInitData.framesUntilRequestQueueFlush));

6
modules/globebrowsing/other/temporaltileprovider.h
View File

@@ -58,7 +58,7 @@ namespace openspace {
public:
TemporalTileProvider(const std::string& datasetFile, const TileProviderInitData& tileProviderInitData);
std::shared_ptr<TileProvider> getTileProvider(Time t = Time::ref());
std::shared_ptr<CachingTileProvider> getTileProvider(Time t = Time::ref());
private:
@@ -71,7 +71,7 @@ namespace openspace {
TimeKey getTimeKey(const Time& t);
std::shared_ptr<TileProvider> initTileProvider(TimeKey timekey);
std::shared_ptr<CachingTileProvider> initTileProvider(TimeKey timekey);
//////////////////////////////////////////////////////////////////////////////////
@@ -82,7 +82,7 @@ namespace openspace {
std::string _dataSourceXmlTemplate;
std::unordered_map<TimeKey, std::shared_ptr<TileProvider> > _tileProviderMap;
std::unordered_map<TimeKey, std::shared_ptr<CachingTileProvider> > _tileProviderMap;
TileProviderInitData _tileProviderInitData;

22
modules/globebrowsing/other/tileprovider.cpp
View File

@@ -46,7 +46,7 @@ namespace {
namespace openspace {
TileProvider::TileProvider(std::shared_ptr<AsyncTileDataProvider> tileReader, int tileCacheSize,
CachingTileProvider::CachingTileProvider(std::shared_ptr<AsyncTileDataProvider> tileReader, int tileCacheSize,
int framesUntilFlushRequestQueue)
: _asyncTextureDataProvider(tileReader)
, _tileCache(tileCacheSize)
@@ -56,32 +56,32 @@ namespace openspace {
}
TileProvider::~TileProvider(){
CachingTileProvider::~CachingTileProvider(){
clearRequestQueue();
}
void TileProvider::prerender() {
void CachingTileProvider::prerender() {
initTexturesFromLoadedData();
if (_framesSinceLastRequestFlush++ > _framesUntilRequestFlush) {
clearRequestQueue();
}
}
void TileProvider::initTexturesFromLoadedData() {
void CachingTileProvider::initTexturesFromLoadedData() {
while (_asyncTextureDataProvider->hasLoadedTextureData()) {
std::shared_ptr<TileIOResult> tileIOResult = _asyncTextureDataProvider->nextTileIOResult();
initializeAndAddToCache(tileIOResult);
}
}
void TileProvider::clearRequestQueue() {
void CachingTileProvider::clearRequestQueue() {
_asyncTextureDataProvider->clearRequestQueue();
_framesSinceLastRequestFlush = 0;
}
Tile TileProvider::getHighestResolutionTile(ChunkIndex chunkIndex, int parents, TileUvTransform uvTransform) {
Tile CachingTileProvider::getHighestResolutionTile(ChunkIndex chunkIndex, int parents, TileUvTransform uvTransform) {
for (int i = 0; i < parents && chunkIndex.level > 1; i++) {
transformFromParent(chunkIndex, uvTransform);
chunkIndex = chunkIndex.parent();
@@ -96,7 +96,7 @@ namespace openspace {
return getOrEnqueueHighestResolutionTile(chunkIndex, uvTransform);
}
Tile TileProvider::getOrEnqueueHighestResolutionTile(const ChunkIndex& chunkIndex,
Tile CachingTileProvider::getOrEnqueueHighestResolutionTile(const ChunkIndex& chunkIndex,
TileUvTransform& uvTransform)
{
@@ -124,7 +124,7 @@ namespace openspace {
void TileProvider::transformFromParent(const ChunkIndex& chunkIndex, TileUvTransform& uv) const {
void CachingTileProvider::transformFromParent(const ChunkIndex& chunkIndex, TileUvTransform& uv) const {
uv.uvOffset *= 0.5;
uv.uvScale *= 0.5;
@@ -139,7 +139,7 @@ namespace openspace {
}
std::shared_ptr<Texture> TileProvider::getOrStartFetchingTile(ChunkIndex chunkIndex) {
std::shared_ptr<Texture> CachingTileProvider::getOrStartFetchingTile(ChunkIndex chunkIndex) {
HashKey hashkey = chunkIndex.hashKey();
if (_tileCache.exist(hashkey)) {
return _tileCache.get(hashkey).texture;
@@ -150,12 +150,12 @@ namespace openspace {
}
}
TileDepthTransform TileProvider::depthTransform() {
TileDepthTransform CachingTileProvider::depthTransform() {
return _asyncTextureDataProvider->getTextureDataProvider()->getDepthTransform();
}
void TileProvider::initializeAndAddToCache(std::shared_ptr<TileIOResult> tileIOResult) {
void CachingTileProvider::initializeAndAddToCache(std::shared_ptr<TileIOResult> tileIOResult) {
std::shared_ptr<RawTileData> tileData = tileIOResult->rawTileData;
HashKey key = tileData->chunkIndex.hashKey();

6
modules/globebrowsing/other/tileprovider.h
View File

@@ -71,13 +71,13 @@ namespace openspace {
Provides tiles through GDAL datasets which can be defined with xml files
for example for wms.
*/
class TileProvider {
class CachingTileProvider {
public:
TileProvider(std::shared_ptr<AsyncTileDataProvider> tileReader, int tileCacheSize,
CachingTileProvider(std::shared_ptr<AsyncTileDataProvider> tileReader, int tileCacheSize,
int framesUntilFlushRequestQueue);
~TileProvider();
~CachingTileProvider();
Tile getHighestResolutionTile(ChunkIndex chunkIndex, int parents = 0,