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

Merge branch 'feature/globebrowsing' of github.com:OpenSpace/OpenSpace-Development into feature/globebrowsing

Browse Source
This commit is contained in:
Kalle
2016-07-08 13:20:19 -04:00
parent 8ec942d87a 35347b2d8d
commit 6c10e89ec0
10 changed files with 99 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
modules/globebrowsing/chunk/chunkrenderer.cpp
View File

@@ -218,9 +218,9 @@ namespace openspace {
// Get the texture that should be used for rendering
TileAndTransform tileAndTransform = TileSelector::getHighestResolutionTile(tileProvider, chunkIndex);
if (tileAndTransform.tile.status == Tile::Status::Unavailable) {
// don't render if no tile was available
programObject->deactivate();
return nullptr;
tileAndTransform.tile = tileProvider->getDefaultTile();
tileAndTransform.uvTransform.uvOffset = { 0, 0 };
tileAndTransform.uvTransform.uvScale = { 1, 1 };
}
activateTileAndSetTileUniforms(

1
modules/globebrowsing/shaders/globalchunkedlodpatch_fs.glsl
View File

@@ -158,6 +158,7 @@ Fragment getFragment() {
frag.depth = fs_position.w;
return frag;
}

43
modules/globebrowsing/tile/temporaltileprovider.cpp
View File

@@ -64,6 +64,7 @@ namespace openspace {
// read file
std::string xml( (std::istreambuf_iterator<char>(in)), (std::istreambuf_iterator<char>()));
_gdalXmlTemplate = consumeTemporalMetaData(xml);
_defaultTile = getTileProvider()->getDefaultTile();
}
std::string TemporalTileProvider::consumeTemporalMetaData(const std::string& xml) {
@@ -109,48 +110,42 @@ namespace openspace {
}
TileDepthTransform TemporalTileProvider::depthTransform() {
if (_currentTileProvider == nullptr) {
LDEBUG("Warning: had to call update from depthTransform()");
update();
}
ensureUpdated();
return _currentTileProvider->depthTransform();
}
Tile::Status TemporalTileProvider::getTileStatus(const ChunkIndex& chunkIndex) {
if (_currentTileProvider == nullptr) {
LDEBUG("Warning: had to call update from getTileStatus()");
update();
}
ensureUpdated();
return _currentTileProvider->getTileStatus(chunkIndex);
}
Tile TemporalTileProvider::getTile(const ChunkIndex& chunkIndex) {
if (_currentTileProvider == nullptr) {
LDEBUG("Warning: had to call update from getTile()");
update();
}
ensureUpdated();
return _currentTileProvider->getTile(chunkIndex);
}
Tile TemporalTileProvider::getDefaultTile() {
return _defaultTile;
}
int TemporalTileProvider::maxLevel() {
ensureUpdated();
return _currentTileProvider->maxLevel();
}
void TemporalTileProvider::ensureUpdated() {
if (_currentTileProvider == nullptr) {
LDEBUG("Warning: update was done lazily");
update();
}
}
void TemporalTileProvider::update() {
_currentTileProvider = getTileProvider();
_currentTileProvider->update();
}
int TemporalTileProvider::maxLevel() {
if (_currentTileProvider == nullptr) {
LDEBUG("Warning: had to call update from getAsyncTileReader()");
update();
}
return _currentTileProvider->maxLevel();
}
std::shared_ptr<TileProvider> TemporalTileProvider::getTileProvider(Time t) {
Time tCopy(t);

5
modules/globebrowsing/tile/temporaltileprovider.h
View File

@@ -121,6 +121,7 @@ namespace openspace {
// These methods implements TileProvider
virtual Tile getTile(const ChunkIndex& chunkIndex);
virtual Tile getDefaultTile();
virtual Tile::Status getTileStatus(const ChunkIndex& chunkIndex);
virtual TileDepthTransform depthTransform();
virtual void update();
@@ -148,6 +149,8 @@ namespace openspace {
std::string consumeTemporalMetaData(const std::string &xml);
std::string getXMLValue(CPLXMLNode*, const std::string& key, const std::string& defaultVal);
void ensureUpdated();
//////////////////////////////////////////////////////////////////////////////////
// Members variables //
//////////////////////////////////////////////////////////////////////////////////
@@ -158,6 +161,8 @@ namespace openspace {
std::unordered_map<TimeKey, std::shared_ptr<TileProvider> > _tileProviderMap;
TileProviderInitData _tileProviderInitData;
Tile _defaultTile;
std::shared_ptr<TileProvider> _currentTileProvider;
TimeFormat * _timeFormat;

31
modules/globebrowsing/tile/tiledataset.cpp
View File

@@ -118,10 +118,11 @@ namespace openspace {
const glm::ivec2 TileDataset::tilePixelSizeDifference = glm::ivec2(4);
const PixelRegion TileDataset::padding = PixelRegion(tilePixelStartOffset, tilePixelSizeDifference);
bool TileDataset::GdalHasBeenInitialized = false;
TileDataset::TileDataset(const std::string& gdalDatasetDesc, const Configuration& config)
: _config(config)
, hasBeenInitialized(false)
@@ -201,7 +202,7 @@ namespace openspace {
IODescription io = getIODescription(chunkIndex);
CPLErr worstError = CPLErr::CE_None;
// Build the Tile IO Result from the data we queried
// Build the Tile IO Result from the data we queride
std::shared_ptr<TileIOResult> result = std::make_shared<TileIOResult>();
result->imageData = readImageData(io, worstError);
result->error = worstError;
@@ -209,7 +210,7 @@ namespace openspace {
result->dimensions = glm::uvec3(io.write.region.numPixels, 1);
result->nBytesImageData = io.write.totalNumBytes;
if (_doPreprocessing) {
if (_config.doPreProcessing) {
result->preprocessData = preprocess(result, io.write.region);
result->error = std::max(result->error, postProcessErrorCheck(result, io));
}
@@ -217,6 +218,28 @@ namespace openspace {
return result;
}
std::shared_ptr<TileIOResult> TileDataset::defaultTileData() {
ensureInitialized();
PixelRegion pixelRegion = { PixelCoordinate(0, 0), PixelRange(16, 16) };
std::shared_ptr<TileIOResult> result = std::make_shared<TileIOResult>();
result->chunkIndex = { 0, 0, 0 };
result->dimensions = glm::uvec3(pixelRegion.numPixels, 1);
result->nBytesImageData = result->dimensions.x * result->dimensions.y * _dataLayout.bytesPerPixel;
result->imageData = new char[result->nBytesImageData];
for (size_t i = 0; i < result->nBytesImageData; ++i) {
result->imageData[i] = 0;
}
result->error = CPLErr::CE_None;
if (_config.doPreProcessing) {
result->preprocessData = preprocess(result, pixelRegion);
//result->error = std::max(result->error, postProcessErrorCheck(result, io));
}
return result;
}
int TileDataset::maxChunkLevel() {
ensureInitialized();
if (_cached._maxLevel < 0) {

11
modules/globebrowsing/tile/tiledataset.h
View File

@@ -106,9 +106,10 @@ namespace openspace {
// Public interface //
//////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<TileIOResult> readTileData(ChunkIndex chunkIndex);
std::shared_ptr<TileIOResult> defaultTileData();
int maxChunkLevel();
TileDepthTransform getDepthTransform() ;
const TileDataLayout& getDataLayout() ;
TileDepthTransform getDepthTransform();
const TileDataLayout& getDataLayout();
const static glm::ivec2 tilePixelStartOffset;
@@ -116,12 +117,11 @@ namespace openspace {
const static PixelRegion padding; // same as the two above
private:
//////////////////////////////////////////////////////////////////////////////////
// Initialization //
//////////////////////////////////////////////////////////////////////////////////\
//////////////////////////////////////////////////////////////////////////////////
void initialize();
void ensureInitialized();
@@ -132,6 +132,7 @@ namespace openspace {
//////////////////////////////////////////////////////////////////////////////////
// GDAL helper methods //
//////////////////////////////////////////////////////////////////////////////////
void gdalEnsureInitialized();
GDALDataset* gdalDataset(const std::string& gdalDatasetDesc);
bool gdalHasOverviews() const;
@@ -181,8 +182,6 @@ namespace openspace {
TileDepthTransform _depthTransform;
TileDataLayout _dataLayout;
bool _doPreprocessing;
static bool GdalHasBeenInitialized;
bool hasBeenInitialized;
};

21
modules/globebrowsing/tile/tileprovider.cpp
View File

@@ -65,6 +65,11 @@ namespace openspace {
return _tile;
}
Tile SingleImagePrivoder::getDefaultTile() {
return _tile;
}
Tile::Status SingleImagePrivoder::getTileStatus(const ChunkIndex& index) {
return _tile.status;
}
@@ -140,10 +145,20 @@ namespace openspace {
return tile;
}
Tile CachingTileProvider::getDefaultTile() {
if (_defaultTile.texture == nullptr) {
_defaultTile = createTile(_asyncTextureDataProvider->getTextureDataProvider()->defaultTileData());
}
return _defaultTile;
}
void CachingTileProvider::initTexturesFromLoadedData() {
while (_asyncTextureDataProvider->hasLoadedTextureData()) {
std::shared_ptr<TileIOResult> tileIOResult = _asyncTextureDataProvider->nextTileIOResult();
initializeAndAddToCache(tileIOResult);
ChunkHashKey key = tileIOResult->chunkIndex.hashKey();
Tile tile = createTile(tileIOResult);
_tileCache->put(key, tile);
}
}
@@ -184,7 +199,7 @@ namespace openspace {
}
void CachingTileProvider::initializeAndAddToCache(std::shared_ptr<TileIOResult> tileIOResult) {
Tile CachingTileProvider::createTile(std::shared_ptr<TileIOResult> tileIOResult) {
ChunkHashKey key = tileIOResult->chunkIndex.hashKey();
TileDataLayout dataLayout = _asyncTextureDataProvider->getTextureDataProvider()->getDataLayout();
Texture* texturePtr = new Texture(
@@ -209,7 +224,7 @@ namespace openspace {
tileIOResult->error == CE_None ? Tile::Status::OK : Tile::Status::IOError
};
_tileCache->put(key, tile);
return tile;
}

7
modules/globebrowsing/tile/tileprovider.h
View File

@@ -68,6 +68,7 @@ namespace openspace {
virtual ~TileProvider() { }
virtual Tile getTile(const ChunkIndex& chunkIndex) = 0;
virtual Tile getDefaultTile() = 0;
virtual Tile::Status getTileStatus(const ChunkIndex& index) = 0;
virtual TileDepthTransform depthTransform() = 0;
virtual void update() = 0;
@@ -84,6 +85,7 @@ namespace openspace {
virtual ~SingleImagePrivoder() { }
virtual Tile getTile(const ChunkIndex& chunkIndex);
virtual Tile getDefaultTile();
virtual Tile::Status getTileStatus(const ChunkIndex& index);
virtual TileDepthTransform depthTransform();
virtual void update();
@@ -110,6 +112,7 @@ namespace openspace {
virtual ~CachingTileProvider();
virtual Tile getTile(const ChunkIndex& chunkIndex);
virtual Tile getDefaultTile();
virtual Tile::Status getTileStatus(const ChunkIndex& index);
virtual TileDepthTransform depthTransform();
virtual void update();
@@ -130,7 +133,8 @@ namespace openspace {
/**
Creates an OpenGL texture and pushes the data to the GPU.
*/
void initializeAndAddToCache(std::shared_ptr<TileIOResult> uninitedTexture);
Tile createTile(std::shared_ptr<TileIOResult> res);
void clearRequestQueue();
@@ -143,6 +147,7 @@ namespace openspace {
//////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<TileCache> _tileCache;
Tile _defaultTile;
int _framesSinceLastRequestFlush;
int _framesUntilRequestFlush;

14
modules/globebrowsing/tile/tileproviderfactory.cpp
View File

@@ -62,7 +62,19 @@ namespace openspace {
LERROR("Unknown type: " << type);
return nullptr;
}
return concreteFactoryIterator->second(desc, initData);
std::shared_ptr<TileProvider> tileProvider;
try {
tileProvider = concreteFactoryIterator->second(desc, initData);
}
catch (const std::exception& e) {
LERROR(e.what());
}
catch (...) {
LERROR("Could not open dataset:\n" << desc << "\n");
}
return tileProvider;
}
void TileProviderFactory::initialize() {

3
modules/globebrowsing/tile/tileselector.cpp
View File

@@ -66,7 +66,8 @@ namespace openspace {
}
else return { tile, uvTransform };
}
return {Tile::TileUnavailable, uvTransform};
return{ Tile::TileUnavailable, uvTransform };
}
void TileSelector::ascendToParent(ChunkIndex& chunkIndex, TileUvTransform& uv) {