mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-05-07 20:09:58 -05: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:
Erik Broberg
2016-04-15 18:05:21 -04:00
parent fafe4819e2 6758f79d91
commit 269e6d61ed
7 changed files with 74 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/globebrowsing/rendering/patchrenderer.cpp
+21 -4
View File
@@ -31,9 +31,11 @@
#include <openspace/engine/openspaceengine.h>
#include <openspace/rendering/renderengine.h>
// ghoul includes
#include <ghoul/misc/assert.h>
#include <ghoul/opengl/texture.h>
#include <ghoul/opengl/textureunit.h>
#define _USE_MATH_DEFINES
#include <math.h>
@@ -101,13 +103,16 @@ namespace openspace {
mat4 modelViewProjectionTransform = data.camera.projectionMatrix()
* viewTransform * modelTransform;
// Get the textures that should be used for rendering
glm::ivec3 tileIndex = tileSet.getTileIndex(patch);
LatLonPatch tilePatch = tileSet.getTilePositionAndScale(tileIndex);
TextureTile tile00 = tileSet.getTile(tileIndex);
std::shared_ptr<ghoul::opengl::Texture> tile00 = tileSet.getTile(tileIndex);
// Upload the tile to the GPU (a lot of caching things should be done)
// Bind and use the texture
ghoul::opengl::TextureUnit texUnit;
texUnit.activate();
tile00->bind();
_programObject->setUniform("textureSampler", texUnit);
LatLon swCorner = patch.southWestCorner();
_programObject->setUniform("modelViewProjectionTransform", modelViewProjectionTransform);
@@ -176,6 +181,18 @@ namespace openspace {
//LDEBUG("intSnapCoord = [ " << intSnapCoord.x << " , " << intSnapCoord.y << " ]");
//LDEBUG("contraction = [ " << contraction.x << " , " << contraction.y << " ]");
// Get the textures that should be used for rendering
glm::ivec3 tileIndex = tileSet.getTileIndex(patch);
LatLonPatch tilePatch = tileSet.getTilePositionAndScale(tileIndex);
std::shared_ptr<ghoul::opengl::Texture> tile00 = tileSet.getTile(tileIndex);
// Bind and use the texture
ghoul::opengl::TextureUnit texUnit;
texUnit.activate();
tile00->bind();
_programObject->setUniform("textureSampler", texUnit);
_programObject->setUniform("modelViewProjectionTransform", data.camera.projectionMatrix() * viewTransform * modelTransform);
_programObject->setUniform("minLatLon", vec2(swCorner.toLonLatVec2()));
_programObject->setUniform("lonLatScalingFactor", 2.0f * vec2(halfSize.toLonLatVec2()));
modules/globebrowsing/rendering/renderableglobe.cpp
+2 -2
View File
@@ -71,8 +71,8 @@ namespace openspace {
// Mainly for debugging purposes @AA
addProperty(_rotation);
//addSwitchValue(std::shared_ptr<ClipMapGlobe>(new ClipMapGlobe(dictionary)), 1e9);
addSwitchValue(std::shared_ptr<ChunkLodGlobe>(new ChunkLodGlobe(dictionary)), 1e9);
addSwitchValue(std::shared_ptr<ClipMapGlobe>(new ClipMapGlobe(dictionary)), 1e9);
//addSwitchValue(std::shared_ptr<ChunkLodGlobe>(new ChunkLodGlobe(dictionary)), 1e9);
addSwitchValue(std::shared_ptr<GlobeMesh>(new GlobeMesh(dictionary)), 1e10);
}
modules/globebrowsing/rendering/renderableglobe.h
+3 -3
View File
@@ -22,8 +22,8 @@
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
****************************************************************************************/
#ifndef __PLANET_H__
#define __PLANET_H__
#ifndef __RENDERABLEGLOBE_H__
#define __RENDERABLEGLOBE_H__
#include <ghoul/logging/logmanager.h>
@@ -66,4 +66,4 @@ private:
} // namespace openspace
#endif // __PLANET_H__
#endif // __RENDERABLEGLOBE_H__
modules/globebrowsing/rendering/texturetile.h
+2 -2
View File
@@ -26,8 +26,10 @@
#define __TEXTURETILE_H__
#include <ghoul/logging/logmanager.h>
#include <ghoul/opengl/ghoul_gl.h>
#include <glm/glm.hpp>
#include <memory>
namespace openspace {
@@ -38,8 +40,6 @@ namespace openspace {
~TextureTile();
private:
glm::ivec2 positionIndex;
int level;
};
} // namespace openspace
modules/globebrowsing/rendering/texturetileset.cpp
+33 -12
View File
@@ -23,12 +23,32 @@
****************************************************************************************/
#include <modules/globebrowsing/rendering/texturetileset.h>
#include <ghoul/opengl/texturemanager.h>
#include <ghoul/io/texture/texturereader.h>
#include <ghoul/filesystem/filesystem.h>
#include <ghoul/logging/logmanager.h>
#include <glm/glm.hpp>
namespace {
const std::string _loggerCat = "TextureTileSet";
}
namespace openspace {
TextureTileSet::TextureTileSet()
{
{
_testTexture = std::move(ghoul::io::TextureReader::ref().loadTexture(absPath("textures/earth_bluemarble.jpg")));
if (_testTexture) {
LDEBUG("Loaded texture from '" << "textures/earth_bluemarble.jpg" << "'");
_testTexture->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);
_testTexture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
}
}
TextureTileSet::~TextureTileSet()
@@ -38,31 +58,32 @@ namespace openspace {
glm::ivec3 TextureTileSet::getTileIndex(LatLonPatch patch)
{
int level = log2(static_cast<int>(glm::max(
sizeLevel0.lat / patch.halfSize().lat * 2,
sizeLevel0.lon / patch.halfSize().lon * 2)));
Vec2 TileSize = sizeLevel0.toLonLatVec2() / pow(2, level);
glm::ivec2 tileIndex = -(patch.northWestCorner().toLonLatVec2() + offsetLevel0.toLonLatVec2()) / TileSize;
_sizeLevel0.lat / patch.halfSize().lat * 2,
_sizeLevel0.lon / patch.halfSize().lon * 2)));
Vec2 TileSize = _sizeLevel0.toLonLatVec2() / pow(2, level);
glm::ivec2 tileIndex = -(patch.northWestCorner().toLonLatVec2() + _offsetLevel0.toLonLatVec2()) / TileSize;
return glm::ivec3(tileIndex, level);
}
TextureTile TextureTileSet::getTile(LatLonPatch patch)
std::shared_ptr<Texture> TextureTileSet::getTile(LatLonPatch patch)
{
return getTile(getTileIndex(patch));
}
TextureTile TextureTileSet::getTile(glm::ivec3 tileIndex)
std::shared_ptr<Texture> TextureTileSet::getTile(glm::ivec3 tileIndex)
{
return TextureTile();
return _testTexture;
}
LatLonPatch TextureTileSet::getTilePositionAndScale(glm::ivec3 tileIndex)
{
LatLon tileSize = LatLon(
sizeLevel0.lat / pow(2, tileIndex.z),
sizeLevel0.lon / pow(2, tileIndex.z));
_sizeLevel0.lat / pow(2, tileIndex.z),
_sizeLevel0.lon / pow(2, tileIndex.z));
LatLon northWest = LatLon(
offsetLevel0.lat + tileIndex.y * tileSize.lat,
offsetLevel0.lon + tileIndex.x * tileSize.lon);
_offsetLevel0.lat + tileIndex.y * tileSize.lat,
_offsetLevel0.lon + tileIndex.x * tileSize.lon);
return LatLonPatch(
LatLon(northWest.lat + tileSize.lat / 2, northWest.lon + tileSize.lon / 2),
modules/globebrowsing/rendering/texturetileset.h
+10 -5
View File
@@ -26,12 +26,15 @@
#define __TEXTURETILESET_H__
#include <ghoul/logging/logmanager.h>
#include <ghoul/opengl/texture.h>
#include <modules/globebrowsing/datastructures/latlon.h>
#include <modules/globebrowsing/rendering/texturetile.h>
namespace openspace {
using namespace ghoul::opengl;
class TextureTileSet
{
public:
@@ -41,14 +44,16 @@ namespace openspace {
/// Returns the index of the tile at an appropriate level.
/// Appropriate meaning that the tile should be at as high level as possible
/// Without the tile being smaller than the patch in lat-lon space.
/// The tile needs to be at least as big as the patch.
/// The tile is at least as big as the patch.
glm::ivec3 getTileIndex(LatLonPatch patch);
TextureTile getTile(LatLonPatch patch);
TextureTile getTile(glm::ivec3 tileIndex);
std::shared_ptr<Texture> getTile(LatLonPatch patch);
std::shared_ptr<Texture> getTile(glm::ivec3 tileIndex);
LatLonPatch getTilePositionAndScale(glm::ivec3 tileIndex);
private:
LatLon sizeLevel0;
LatLon offsetLevel0;
LatLon _sizeLevel0;
LatLon _offsetLevel0;
std::shared_ptr<Texture> _testTexture;
};
} // namespace openspace
modules/globebrowsing/shaders/simple_fs.glsl
+3 -1
View File
@@ -35,6 +35,8 @@ uniform float time;
uniform sampler2D texture1;
uniform sampler2D nightTex;
uniform sampler2D textureSampler;
in vec4 vs_position;
in vec2 vs_uv;
@@ -45,7 +47,7 @@ in vec2 vs_uv;
Fragment getFragment() {
Fragment frag;
frag.color = vec4(fract(vs_uv * 1), 0.4,1);
frag.color = texture2D(textureSampler, vs_uv);// vec4(fract(vs_uv * 1), 0.4,1);
frag.depth = pscDepth(vs_position);
return frag;