mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-04-23 04:30:09 -05:00
Code Issues Packages Projects Releases Wiki Activity

Move rendering function calls from Chunk and ChunkNode to ChunkedLodGlobe

Browse Source
This commit is contained in:
Erik Broberg
2016-06-21 21:09:19 -04:00
parent 658e2d51a8
commit 911cf7a77d
6 changed files with 41 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/globebrowsing/chunk/chunk.cpp
-6
View File
@@ -172,10 +172,4 @@ namespace openspace {
}
void Chunk::render(const RenderData& data) const {
_owner->getPatchRenderer().renderChunk(*this, data);
}
} // namespace openspace
modules/globebrowsing/chunk/chunk.h
-2
View File
@@ -60,8 +60,6 @@ namespace openspace {
/// Updates chunk internally and returns a desired level
Status update(const RenderData& data);
void render(const RenderData& data) const;
std::vector<glm::dvec4> getBoundingPolyhedronCorners() const;
modules/globebrowsing/chunk/chunkedlodglobe.cpp
+40 -53
View File
@@ -85,7 +85,7 @@ namespace openspace {
_chunkEvaluatorByProjectedArea = std::make_unique<EvaluateChunkLevelByProjectedArea>();
_chunkEvaluatorByDistance = std::make_unique<EvaluateChunkLevelByDistance>();
_patchRenderer = std::make_unique<ChunkRenderer>(geometry, tileProviderManager);
_renderer = std::make_unique<ChunkRenderer>(geometry, tileProviderManager);
}
ChunkedLodGlobe::~ChunkedLodGlobe() {
@@ -109,11 +109,6 @@ namespace openspace {
return _tileProviderManager;
}
ChunkRenderer& ChunkedLodGlobe::getPatchRenderer() const{
return *_patchRenderer;
}
bool ChunkedLodGlobe::testIfCullable(const Chunk& chunk, const RenderData& renderData) const {
if (debugOptions.doHorizonCulling && _chunkCullers[0]->isCullable(chunk, renderData)) {
return true;
@@ -147,17 +142,49 @@ namespace openspace {
void ChunkedLodGlobe::render(const RenderData& data){
minDistToCamera = INFINITY;
ChunkNode::renderedChunks = 0;
_leftRoot->updateChunkTree(data);
_rightRoot->updateChunkTree(data);
_leftRoot->renderReversedBreadthFirst(data);
_rightRoot->renderReversedBreadthFirst(data);
// Calculate the MVP matrix
dmat4 modelTransform = translate(dmat4(1), data.position.dvec3());
dmat4 viewTransform = dmat4(data.camera.combinedViewMatrix());
dmat4 vp = dmat4(data.camera.projectionMatrix()) * viewTransform;
dmat4 mvp = vp * modelTransform;
if (debugOptions.showChunkBounds || debugOptions.showChunkAABB) {
debugRenderChunks(data);
}
// Render function
std::function<void(const ChunkNode&)> renderJob = [this, &data, &mvp](const ChunkNode& chunkNode) {
const Chunk& chunk = chunkNode.getChunk();
if (chunkNode.isLeaf() && chunk.isVisible()) {
_renderer->renderChunk(chunkNode.getChunk(), data);
const std::vector<glm::dvec4> modelSpaceCorners = chunk.getBoundingPolyhedronCorners();
std::vector<glm::vec4> clippingSpaceCorners(8);
AABB3 screenSpaceBounds;
for (size_t i = 0; i < 8; i++) {
const vec4& clippingSpaceCorner = mvp * modelSpaceCorners[i];
clippingSpaceCorners[i] = clippingSpaceCorner;
vec3 screenSpaceCorner = (1.0f / clippingSpaceCorner.w) * clippingSpaceCorner.xyz();
screenSpaceBounds.expand(screenSpaceCorner);
}
unsigned int colorBits = 1 + chunk.index().level % 6;
vec4 color = vec4(colorBits & 1, colorBits & 2, colorBits & 4, 0.3);
if (debugOptions.showChunkBounds) {
DebugRenderer::ref()->renderNiceBox(clippingSpaceCorners, color);
}
if (debugOptions.showChunkAABB) {
auto& screenSpacePoints = DebugRenderer::ref()->verticesFor(screenSpaceBounds);
DebugRenderer::ref()->renderNiceBox(screenSpacePoints, color);
}
}
};
_leftRoot->reverseBreadthFirst(renderJob);
_rightRoot->reverseBreadthFirst(renderJob);
@@ -176,49 +203,9 @@ namespace openspace {
//LDEBUG(ChunkNode::renderedChunks << " / " << ChunkNode::chunkNodeCount << " chunks rendered");
}
void ChunkedLodGlobe::debugRenderChunks(const RenderData& data) const {
// Calculate the MVP matrix
dmat4 modelTransform = translate(dmat4(1), data.position.dvec3());
dmat4 viewTransform = dmat4(data.camera.combinedViewMatrix());
dmat4 vp = dmat4(data.camera.projectionMatrix()) * viewTransform;
dmat4 mvp = vp * modelTransform;
std::function<void(const ChunkNode&)> chunkDebugRenderer = [this, &data, &mvp](const ChunkNode& chunkNode) {
const Chunk& chunk = chunkNode.getChunk();
if (chunkNode.isLeaf() && chunk.isVisible()) {
const std::vector<glm::dvec4> modelSpaceCorners = chunk.getBoundingPolyhedronCorners();
std::vector<glm::vec4> clippingSpaceCorners(8);
AABB3 screenSpaceBounds;
for (size_t i = 0; i < 8; i++) {
const vec4& clippingSpaceCorner = mvp * modelSpaceCorners[i];
clippingSpaceCorners[i] = clippingSpaceCorner;
vec3 screenSpaceCorner = (1.0f / clippingSpaceCorner.w) * clippingSpaceCorner.xyz();
screenSpaceBounds.expand(screenSpaceCorner);
}
unsigned int colorBits = 1 + chunk.index().level % 6;
vec4 color = vec4(colorBits & 1, colorBits & 2, colorBits & 4, 0.3);
if (debugOptions.showChunkBounds) {
DebugRenderer::ref()->renderNiceBox(clippingSpaceCorners, color);
}
if (debugOptions.showChunkAABB) {
auto& screenSpacePoints = DebugRenderer::ref()->verticesFor(screenSpaceBounds);
DebugRenderer::ref()->renderNiceBox(screenSpacePoints, color);
}
}
};
_leftRoot->reverseBreadthFirst(chunkDebugRenderer);
_rightRoot->reverseBreadthFirst(chunkDebugRenderer);
}
void ChunkedLodGlobe::update(const UpdateData& data) {
_patchRenderer->update();
_renderer->update();
}
void ChunkedLodGlobe::setStateMatrix(const glm::dmat3& stateMatrix)
modules/globebrowsing/chunk/chunkedlodglobe.h
+1 -4
View File
@@ -65,8 +65,6 @@ namespace openspace {
std::shared_ptr<TileProviderManager> tileProviderManager);
virtual ~ChunkedLodGlobe();
ChunkRenderer& getPatchRenderer() const;
bool initialize() override;
bool deinitialize() override;
bool isReady() const override;
@@ -122,7 +120,6 @@ namespace openspace {
void debugRenderChunks(const RenderData& data) const;
// Covers all negative longitudes
std::unique_ptr<ChunkNode> _leftRoot;
@@ -130,7 +127,7 @@ namespace openspace {
std::unique_ptr<ChunkNode> _rightRoot;
// the patch used for actual rendering
std::unique_ptr<ChunkRenderer> _patchRenderer;
std::unique_ptr<ChunkRenderer> _renderer;
static const GeodeticPatch LEFT_HEMISPHERE;
static const GeodeticPatch RIGHT_HEMISPHERE;
modules/globebrowsing/chunk/chunknode.cpp
-46
View File
@@ -41,7 +41,6 @@ namespace {
namespace openspace {
int ChunkNode::chunkNodeCount = 0;
int ChunkNode::renderedChunks = 0;
ChunkNode::ChunkNode(const Chunk& chunk, ChunkNode* parent)
: _chunk(chunk)
@@ -137,51 +136,6 @@ void ChunkNode::reverseBreadthFirst(const std::function<void(const ChunkNode&)>&
}
}
void ChunkNode::renderReversedBreadthFirst(const RenderData& data) {
std::stack<ChunkNode*> S;
std::queue<ChunkNode*> Q;
Q.push(this);
while (Q.size() > 0) {
ChunkNode* node = Q.front();
Q.pop();
if (node->isLeaf()) {
if (node->_chunk.isVisible()) {
S.push(node);
}
}
else {
for (int i = 0; i < 4; ++i) {
Q.push(node->_children[i].get());
}
}
}
while (S.size() > 0) {
S.top()->renderThisChunk(data);
S.pop();
}
}
void ChunkNode::renderThisChunk(const RenderData& data) {
_chunk.render(data);
ChunkNode::renderedChunks++;
}
void ChunkNode::renderDepthFirst(const RenderData& data) {
if (isLeaf()) {
if (_chunk.isVisible()) {
renderThisChunk(data);
}
}
else {
for (int i = 0; i < 4; ++i) {
_children[i]->renderDepthFirst(data);
}
}
}
void ChunkNode::split(int depth) {
if (depth > 0 && isLeaf()) {
for (size_t i = 0; i < 4; i++) {
modules/globebrowsing/chunk/chunknode.h
-4
View File
@@ -68,13 +68,9 @@ public:
const ChunkNode& getChild(Quad quad) const;
const Chunk& getChunk() const;
void renderDepthFirst(const RenderData& data);
void renderReversedBreadthFirst(const RenderData& data);
void renderThisChunk(const RenderData& data);
bool updateChunkTree(const RenderData& data);
static int chunkNodeCount;
static int renderedChunks;
private: