mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-05-01 08:19:51 -05:00
Code Issues Packages Projects Releases Wiki Activity

Create PatchCoverage to be returned from PatchCoverageProvide

Browse Source
This commit is contained in:
Kalle Bladin
2016-05-02 19:29:58 -04:00
parent b0d00dbd66
commit 5f0997454c
8 changed files with 150 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/globebrowsing/geodetics/geodetic2.h
+5 -3
View File
@@ -91,10 +91,12 @@ using HashKey = unsigned long;
struct GeodeticTileIndex {
const int x, y, level;
int x, y, level;
GeodeticTileIndex() = delete;
GeodeticTileIndex()
: x(0), y(0), level(0) {
}
GeodeticTileIndex(int x, int y, int level)
: x(x), y(y), level(level) {
modules/globebrowsing/globes/clipmapglobe.cpp
+8 -3
View File
@@ -49,10 +49,15 @@ namespace openspace {
: _clipMapPyramid(Geodetic2(M_PI / 2, M_PI / 2))
, _ellipsoid(ellipsoid)
{
_tileProvider = shared_ptr<TileProvider>(new TileProvider("map_service_configs/TERRAIN.wms", 100));
// init Renderer
auto outerPatchRenderer = new ClipMapPatchRenderer(shared_ptr<OuterClipMapGrid>(new OuterClipMapGrid(256)));
auto outerPatchRenderer = new ClipMapPatchRenderer(
shared_ptr<OuterClipMapGrid>(new OuterClipMapGrid(256)),
_tileProvider);
_outerPatchRenderer.reset(outerPatchRenderer);
auto innerPatchRenderer = new ClipMapPatchRenderer(shared_ptr<InnerClipMapGrid>(new InnerClipMapGrid(256)));
auto innerPatchRenderer = new ClipMapPatchRenderer(
shared_ptr<InnerClipMapGrid>(new InnerClipMapGrid(256)),
_tileProvider);
_innerPatchRenderer.reset(innerPatchRenderer);
}
@@ -80,7 +85,7 @@ namespace openspace {
void ClipMapGlobe::render(const RenderData& data)
{
// TODO : Choose the max depth and the min depth depending on the camera
int maxDepth = 5;
int maxDepth = 10;
int minDepth = 0;
// render patches
for (size_t i = minDepth; i < maxDepth; i++)
modules/globebrowsing/globes/clipmapglobe.h
+21 -20
View File
@@ -37,35 +37,36 @@
#include <modules/globebrowsing/globes/clipmappyramid.h>
namespace ghoul {
namespace opengl {
class ProgramObject;
}
namespace opengl {
class ProgramObject;
}
}
namespace openspace {
class ClipMapGlobe : public Renderable {
public:
ClipMapGlobe(const Ellipsoid& ellipsoid);
~ClipMapGlobe();
class ClipMapGlobe : public Renderable {
public:
ClipMapGlobe(const Ellipsoid& ellipsoid);
~ClipMapGlobe();
bool initialize() override;
bool deinitialize() override;
bool isReady() const override;
bool initialize() override;
bool deinitialize() override;
bool isReady() const override;
void render(const RenderData& data) override;
void update(const UpdateData& data) override;
void render(const RenderData& data) override;
void update(const UpdateData& data) override;
const Ellipsoid& ellipsoid() const;
const Ellipsoid& ellipsoid() const;
private:
std::unique_ptr<ClipMapPatchRenderer> _outerPatchRenderer;
std::unique_ptr<ClipMapPatchRenderer> _innerPatchRenderer;
ClipMapPyramid _clipMapPyramid;
private:
shared_ptr<TileProvider> _tileProvider;
std::unique_ptr<ClipMapPatchRenderer> _outerPatchRenderer;
std::unique_ptr<ClipMapPatchRenderer> _innerPatchRenderer;
ClipMapPyramid _clipMapPyramid;
const Ellipsoid& _ellipsoid;
};
const Ellipsoid& _ellipsoid;
};
} // namespace openspace
modules/globebrowsing/globes/renderableglobe.cpp
+1 -1
View File
@@ -55,7 +55,7 @@ namespace openspace {
dictionary.getValue(keyRadii, radii);
_ellipsoid = Ellipsoid(radii);
addSwitchValue(std::shared_ptr<ClipMapGlobe>(new ClipMapGlobe(_ellipsoid)), 1e8);
//addSwitchValue(std::shared_ptr<ClipMapGlobe>(new ClipMapGlobe(_ellipsoid)), 1e8);
addSwitchValue(std::shared_ptr<ChunkLodGlobe>(new ChunkLodGlobe(_ellipsoid)), 1e9);
addSwitchValue(std::shared_ptr<GlobeMesh>(new GlobeMesh()), 1e10);
}
modules/globebrowsing/other/patchcoverageprovider.cpp
+67 -1
View File
@@ -35,14 +35,30 @@ namespace {
namespace openspace {
PatchCoverageProvider::PatchCoverageProvider(
std::shared_ptr<TileProvider> tileProvider,
Geodetic2 sizeLevel0,
Geodetic2 offsetLevel0,
int depth)
: _sizeLevel0(sizeLevel0)
: _tileProvider(tileProvider)
, _sizeLevel0(sizeLevel0)
, _offsetLevel0(offsetLevel0)
, _depth(depth)
{
// Set e texture to test
std::string fileName = "textures/earth_bluemarble.jpg";
//std::string fileName = "../../../build/tiles/tile5_8_12.png";
//std::string fileName = "tile5_8_12.png";
_tempTexture = std::move(ghoul::io::TextureReader::ref().loadTexture(absPath(fileName)));
if (_tempTexture) {
LDEBUG("Loaded texture from '" << "textures/earth_bluemarble.jpg" << "'");
_tempTexture->uploadTexture();
// Textures of planets looks much smoother with AnisotropicMipMap rather than linear
// TODO: AnisotropicMipMap crashes on ATI cards ---abock
//_testTexture->setFilter(ghoul::opengl::Texture::FilterMode::AnisotropicMipMap);
_tempTexture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
}
}
PatchCoverageProvider::~PatchCoverageProvider(){
@@ -108,4 +124,54 @@ namespace openspace {
return invTileScale * globalTranslation * patchScale;
}
PatchCoverage PatchCoverageProvider::getCoverage(GeodeticPatch patch)
{
static const int numTilesInCoverageX = 2;
static const int numTilesInCoverageY = 2;
PatchCoverage patchCoverageToReturn;
for (int y = 0; y < numTilesInCoverageY; y++)
{
for (int x = 0; x < numTilesInCoverageX; x++)
{
int linearIdx = x + y * numTilesInCoverageX;
GeodeticTileIndex tileIndex = getTileIndex(patch);
// Offset tileIndex
tileIndex.x += x;
tileIndex.y += y;
int numLevelsToLoop = tileIndex.level;
// Start at the highest level and go down if the texture don't exist
for (int j = numLevelsToLoop; j >= 0; j--)
{
// Try if the texture exists
std::shared_ptr<Texture> tile = _tileProvider->getTile(tileIndex);
if (tile == nullptr)
{ // If it doesn't exist, go down a level
tileIndex.x /= 2;
tileIndex.y /= 2;
tileIndex.level -= 1;
}
else
{ // A texture was found, put it in the data structure to return
patchCoverageToReturn.textureTransformPairs[linearIdx].first =
tile;
patchCoverageToReturn.textureTransformPairs[linearIdx].second =
getUvTransformationPatchToTile(patch, tileIndex);
}
}
// If the texture still doesn't exist put a temporary texture
if (patchCoverageToReturn.textureTransformPairs[linearIdx].first == nullptr)
{
patchCoverageToReturn.textureTransformPairs[linearIdx].first =
_tempTexture;
patchCoverageToReturn.textureTransformPairs[linearIdx].second =
glm::mat3(1);
}
}
}
return patchCoverageToReturn;
}
} // namespace openspace
modules/globebrowsing/other/patchcoverageprovider.h
+20 -1
View File
@@ -28,17 +28,29 @@
#include <ghoul/logging/logmanager.h>
#include <modules/globebrowsing/geodetics/geodetic2.h>
#include <modules/globebrowsing/other/tileprovider.h>
#include <ghoul/opengl/texture.h>
//////////////////////////////////////////////////////////////////////////////////////////
// PATCH TILE CONVERTER //
// PATCH COVERAGE PROVIDER //
//////////////////////////////////////////////////////////////////////////////////////////
namespace openspace {
using namespace ghoul::opengl;
struct PatchCoverage
{
using TextureTransformPair = std::pair<std::shared_ptr<Texture>, glm::mat3>;
TextureTransformPair textureTransformPairs[4];
};
class PatchCoverageProvider
{
public:
PatchCoverageProvider(
std::shared_ptr<TileProvider> tileProvider,
Geodetic2 sizeLevel0,
Geodetic2 offsetLevel0,
int depth);
@@ -67,10 +79,17 @@ namespace openspace {
GeodeticPatch patch,
GeodeticPatch tile);
PatchCoverage getCoverage(GeodeticPatch patch);
private:
std::shared_ptr<TileProvider> _tileProvider;
Geodetic2 _sizeLevel0;
Geodetic2 _offsetLevel0;
int _depth;
std::shared_ptr<Texture> _tempTexture;
};
modules/globebrowsing/rendering/patchrenderer.cpp
+24 -48
View File
@@ -172,11 +172,14 @@ namespace openspace {
//////////////////////////////////////////////////////////////////////////////////////
// CLIPMAP PATCH RENDERER //
//////////////////////////////////////////////////////////////////////////////////////
ClipMapPatchRenderer::ClipMapPatchRenderer(shared_ptr<ClipMapGrid> grid)
ClipMapPatchRenderer::ClipMapPatchRenderer(
shared_ptr<ClipMapGrid> grid,
shared_ptr<TileProvider> tileProvider)
: PatchRenderer()
, _grid(grid)
, _tileProvider("map_service_configs/TERRAIN.wms", 5000)
, _patchCoverageProvider(Geodetic2(M_PI * 2, M_PI * 2), Geodetic2(-M_PI -M_PI/2, -M_PI), 10)
, _tileProvider(tileProvider)
, _patchCoverageProvider(_tileProvider,
Geodetic2(M_PI * 2, M_PI * 2), Geodetic2(-M_PI -M_PI/2, -M_PI), 10)
{
_programObject = OsEng.renderEngine().buildRenderProgram(
"LatLonSphereMappingProgram",
@@ -189,7 +192,7 @@ namespace openspace {
}
void ClipMapPatchRenderer::update() {
_tileProvider.prerender();
_tileProvider->prerender();
}
@@ -229,70 +232,43 @@ namespace openspace {
ivec2 contraction = ivec2(intSnapCoord.y % 2, intSnapCoord.x % 2);
//LDEBUG("patch.center = [ " << patch.center.lat << " , " << patch.center.lon << " ]");
//LDEBUG("intSnapCoord = [ " << intSnapCoord.x << " , " << intSnapCoord.y << " ]");
//LDEBUG("contraction = [ " << contraction.x << " , " << contraction.y << " ]");
// Get the textures that should be used for rendering
GeodeticTileIndex tileIndex00 = _patchCoverageProvider.getTileIndex(newPatch);
GeodeticTileIndex tileIndex10 = { tileIndex00.x + 1, tileIndex00.y, tileIndex00.level };
GeodeticTileIndex tileIndex01 = { tileIndex00.x, tileIndex00.y + 1, tileIndex00.level };
GeodeticTileIndex tileIndex11 = { tileIndex00.x + 1, tileIndex00.y + 1, tileIndex00.level };
std::shared_ptr<ghoul::opengl::Texture> tile00 = _tileProvider.getTile(tileIndex00);
std::shared_ptr<ghoul::opengl::Texture> tile10 = _tileProvider.getTile(tileIndex10);
std::shared_ptr<ghoul::opengl::Texture> tile01 = _tileProvider.getTile(tileIndex01);
std::shared_ptr<ghoul::opengl::Texture> tile11 = _tileProvider.getTile(tileIndex11);
if (tile00 == nullptr) {
tile00 = _tileSet.getTile(tileIndex00);
}
if (tile10 == nullptr) {
tile10 = _tileSet.getTile(tileIndex01);
}
if (tile01 == nullptr) {
tile01 = _tileSet.getTile(tileIndex10);
}
if (tile11 == nullptr) {
tile11 = _tileSet.getTile(tileIndex11);
}
glm::mat3 uvTransform00 = _patchCoverageProvider.getUvTransformationPatchToTile(newPatch, tileIndex00);
glm::mat3 uvTransform10 = _patchCoverageProvider.getUvTransformationPatchToTile(newPatch, tileIndex10);
glm::mat3 uvTransform01 = _patchCoverageProvider.getUvTransformationPatchToTile(newPatch, tileIndex01);
glm::mat3 uvTransform11 = _patchCoverageProvider.getUvTransformationPatchToTile(newPatch, tileIndex11);
//std::shared_ptr<ghoul::opengl::Texture> tile00 = _tileSet.getTile(tileIndex);
PatchCoverage patchCoverage = _patchCoverageProvider.getCoverage(newPatch);
// Bind and use the texture
ghoul::opengl::TextureUnit texUnit00;
texUnit00.activate();
tile00->bind();
patchCoverage.textureTransformPairs[0].first->bind(); // tile00
_programObject->setUniform("textureSampler00", texUnit00);
ghoul::opengl::TextureUnit texUnit10;
texUnit10.activate();
tile10->bind();
patchCoverage.textureTransformPairs[1].first->bind(); // tile10
_programObject->setUniform("textureSampler10", texUnit10);
ghoul::opengl::TextureUnit texUnit01;
texUnit01.activate();
tile01->bind();
patchCoverage.textureTransformPairs[2].first->bind(); // tile01
_programObject->setUniform("textureSampler01", texUnit01);
ghoul::opengl::TextureUnit texUnit11;
texUnit11.activate();
tile11->bind();
patchCoverage.textureTransformPairs[3].first->bind(); // tile11
_programObject->setUniform("textureSampler11", texUnit11);
_programObject->setUniform("uvTransformPatchToTile00", mat3(uvTransform00));
_programObject->setUniform("uvTransformPatchToTile10", mat3(uvTransform10));
_programObject->setUniform("uvTransformPatchToTile01", mat3(uvTransform01));
_programObject->setUniform("uvTransformPatchToTile11", mat3(uvTransform11));
_programObject->setUniform(
"uvTransformPatchToTile00",
patchCoverage.textureTransformPairs[0].second);
_programObject->setUniform(
"uvTransformPatchToTile10",
patchCoverage.textureTransformPairs[1].second);
_programObject->setUniform(
"uvTransformPatchToTile01",
patchCoverage.textureTransformPairs[2].second);
_programObject->setUniform(
"uvTransformPatchToTile11",
patchCoverage.textureTransformPairs[3].second);
_programObject->setUniform(
"modelViewProjectionTransform",
modules/globebrowsing/rendering/patchrenderer.h
+4 -2
View File
@@ -102,7 +102,9 @@ namespace openspace {
class ClipMapPatchRenderer : public PatchRenderer {
public:
ClipMapPatchRenderer(shared_ptr<ClipMapGrid> grid);
ClipMapPatchRenderer(
shared_ptr<ClipMapGrid> grid,
shared_ptr<TileProvider> tileProvider);
void update();
@@ -113,7 +115,7 @@ namespace openspace {
private:
TileProvider _tileProvider;
std::shared_ptr<TileProvider> _tileProvider;
PatchCoverageProvider _patchCoverageProvider;
shared_ptr<ClipMapGrid> _grid;
};