773 lines
27 KiB
Plaintext
773 lines
27 KiB
Plaintext
|
/* -*-c++-*- */
|
||
|
|
/* osgEarth - Geospatial SDK for OpenSceneGraph
|
||
|
|
* Copyright 2020 Pelican Mapping
|
||
|
|
* http://osgearth.org
|
||
|
|
*
|
||
|
|
* osgEarth is free software; you can redistribute it and/or modify
|
||
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
||
|
|
* the Free Software Foundation; either version 2 of the License, or
|
||
|
|
* (at your option) any later version.
|
||
|
|
*
|
||
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||
|
|
* IN THE SOFTWARE.
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU Lesser General Public License
|
||
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
||
|
|
*/
|
||
|
|
#ifndef OSGEARTH_SCREEN_SPACE_LAYOUT_CALLOUT_H
|
||
|
|
#define OSGEARTH_SCREEN_SPACE_LAYOUT_CALLOUT_H 1
|
||
|
|
|
||
|
|
#include <osgEarth/ScreenSpaceLayoutImpl>
|
||
|
|
|
||
|
|
// https://github.com/JCash/voronoi
|
||
|
|
#define JC_VORONOI_IMPLEMENTATION
|
||
|
|
#define JCV_REAL_TYPE double
|
||
|
|
#define JCV_ATAN2 atan2
|
||
|
|
#define JCV_FLT_MAX 1.7976931348623157E+308
|
||
|
|
#include "jc_voronoi.h"
|
||
|
|
|
||
|
|
// whether to use the rotated axis-aligned bounding box method for
|
||
|
|
// calculating a Voronoi site centroid (as opposed to a simple centroid)
|
||
|
|
#define USE_ROTATED_AABB_CENTROID_METHOD 1
|
||
|
|
|
||
|
|
|
||
|
|
namespace osgEarth { namespace Internal
|
||
|
|
{
|
||
|
|
using namespace osgEarth;
|
||
|
|
|
||
|
|
struct jcv_point_comparator {
|
||
|
|
bool operator()(const jcv_point& a, const jcv_point& b) const {
|
||
|
|
if (a.x < b.x) return true;
|
||
|
|
else if (a.x > b.x) return false;
|
||
|
|
else return a.y < b.y;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Custom RenderLeaf sorting algorithm for deconflicting drawables
|
||
|
|
* as callouts.
|
||
|
|
*/
|
||
|
|
struct CalloutImplementation : public osgUtil::RenderBin::SortCallback
|
||
|
|
{
|
||
|
|
struct BBox
|
||
|
|
{
|
||
|
|
BBox() : LL(DBL_MAX,DBL_MAX), UR(-DBL_MAX,-DBL_MAX) { }
|
||
|
|
void expandToInclude(double x, double y) {
|
||
|
|
LL.x() = osg::minimum(LL.x(), x);
|
||
|
|
UR.x() = osg::maximum(UR.x(), x);
|
||
|
|
LL.y() = osg::minimum(LL.y(), y);
|
||
|
|
UR.y() = osg::maximum(UR.y(), y);
|
||
|
|
}
|
||
|
|
osg::Vec2d LL, UR;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct Element
|
||
|
|
{
|
||
|
|
osg::Drawable* _drawable;
|
||
|
|
osgEarth::Text* _text;
|
||
|
|
osgUtil::RenderLeaf* _leaf;
|
||
|
|
osg::ref_ptr<osg::RefMatrix> _matrix;
|
||
|
|
unsigned _frame;
|
||
|
|
osg::Vec3d _anchor;
|
||
|
|
osg::Vec3d _offsetVector;
|
||
|
|
double _offsetLength;
|
||
|
|
unsigned _leaderLineIndex;
|
||
|
|
bool _declutter;
|
||
|
|
int _numFramesSinceMove;
|
||
|
|
|
||
|
|
Element();
|
||
|
|
bool operator < (const Element&) const; // comparator
|
||
|
|
void move(float dir);
|
||
|
|
};
|
||
|
|
|
||
|
|
using Elements = std::map<osg::Drawable*, Element>;
|
||
|
|
|
||
|
|
struct CameraLocal
|
||
|
|
{
|
||
|
|
CameraLocal();
|
||
|
|
const osg::Camera* _camera; // camera associated with the data structure
|
||
|
|
unsigned _frame;
|
||
|
|
osg::Matrix _scalebias; // scale bias matrix for the viewport
|
||
|
|
Elements _elements;
|
||
|
|
osg::Matrix _vpm;
|
||
|
|
bool _vpmChanged;
|
||
|
|
osg::ref_ptr<LineDrawable> _leaders;
|
||
|
|
bool _leadersDirty;
|
||
|
|
osg::Vec4f _leaderColor;
|
||
|
|
std::vector<jcv_point> _points;
|
||
|
|
// TODO: use unordered_map?
|
||
|
|
std::map<jcv_point, Element*, jcv_point_comparator> _lookup;
|
||
|
|
osg::ref_ptr<LineDrawable> _voronoi;
|
||
|
|
|
||
|
|
void initDebug();
|
||
|
|
};
|
||
|
|
|
||
|
|
ScreenSpaceLayoutContext* _context;
|
||
|
|
DeclutterSortFunctor* _customSortFunctor;
|
||
|
|
PerObjectFastMap<const osg::Camera*, CameraLocal> _cameraLocal;
|
||
|
|
bool _resetWhenViewChanges;
|
||
|
|
|
||
|
|
//! Constructor
|
||
|
|
CalloutImplementation(ScreenSpaceLayoutContext* context, DeclutterSortFunctor* f);
|
||
|
|
|
||
|
|
//! Override from SortCallback
|
||
|
|
void sortImplementation(osgUtil::RenderBin*) override;
|
||
|
|
|
||
|
|
void push(osgUtil::RenderLeaf* leaf, CameraLocal& local);
|
||
|
|
|
||
|
|
void sort(CameraLocal& local);
|
||
|
|
};
|
||
|
|
|
||
|
|
CalloutImplementation::Element::Element() :
|
||
|
|
_drawable(NULL),
|
||
|
|
_text(NULL),
|
||
|
|
_frame(0u),
|
||
|
|
_leaderLineIndex(INT_MAX),
|
||
|
|
_offsetVector(0,1,0),
|
||
|
|
_leaf(NULL),
|
||
|
|
_offsetLength(0.0),
|
||
|
|
_declutter(false),
|
||
|
|
_numFramesSinceMove(0)
|
||
|
|
{
|
||
|
|
//nop
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CalloutImplementation::Element::operator<(const Element& rhs) const
|
||
|
|
{
|
||
|
|
return ((intptr_t)_drawable < (intptr_t)rhs._drawable);
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
CalloutImplementation::Element::move(float dir)
|
||
|
|
{
|
||
|
|
// rotate little more than 1/4 turn:
|
||
|
|
const double rotation = osg::PI / 16; //1.7; //osg::PI / 32; //1.6;
|
||
|
|
const osg::Quat q(dir*rotation, osg::Vec3d(0, 0, 1));
|
||
|
|
_offsetVector = q * _offsetVector;
|
||
|
|
}
|
||
|
|
|
||
|
|
CalloutImplementation::CameraLocal::CameraLocal() :
|
||
|
|
_camera(0),
|
||
|
|
_frame(0),
|
||
|
|
_vpmChanged(true),
|
||
|
|
_leadersDirty(false),
|
||
|
|
_leaderColor(1,1,1,1)
|
||
|
|
{
|
||
|
|
_leaders = new LineDrawable(GL_LINES);
|
||
|
|
_leaders->setCullingActive(false);
|
||
|
|
_leaders->setDataVariance(osg::Object::DYNAMIC);
|
||
|
|
_leaders->setColor(_leaderColor);
|
||
|
|
_leaders->setLineSmooth(true);
|
||
|
|
GLUtils::setLighting(_leaders->getOrCreateStateSet(), osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED);
|
||
|
|
}
|
||
|
|
|
||
|
|
void CalloutImplementation::CameraLocal::initDebug()
|
||
|
|
{
|
||
|
|
_voronoi = new LineDrawable(GL_LINES);
|
||
|
|
_voronoi->setCullingActive(false);
|
||
|
|
_voronoi->setDataVariance(osg::Object::DYNAMIC);
|
||
|
|
_voronoi->setColor(osg::Vec4f(1,0,0,1));
|
||
|
|
_voronoi->setLineWidth(1.0f);
|
||
|
|
GLUtils::setLighting(_voronoi->getOrCreateStateSet(), osg::StateAttribute::OFF | osg::StateAttribute::PROTECTED);
|
||
|
|
}
|
||
|
|
|
||
|
|
CalloutImplementation::CalloutImplementation(ScreenSpaceLayoutContext* context, DeclutterSortFunctor* f) :
|
||
|
|
_context(context),
|
||
|
|
_customSortFunctor(f),
|
||
|
|
_resetWhenViewChanges(false)
|
||
|
|
{
|
||
|
|
//nop
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
inline float signOf(float x) {
|
||
|
|
return x<0.0f? -1.0f: x>0.0f? 1.0f : 0.0f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CalloutImplementation::push(osgUtil::RenderLeaf* leaf, CameraLocal& local)
|
||
|
|
{
|
||
|
|
static Element prototype;
|
||
|
|
const osg::Vec3d zero(0,0,0);
|
||
|
|
|
||
|
|
osg::Drawable* drawable = leaf->_drawable.get();
|
||
|
|
|
||
|
|
std::pair<Elements::iterator,bool> result = local._elements.insert(std::make_pair(drawable,prototype));
|
||
|
|
Element& element = result.first->second;
|
||
|
|
|
||
|
|
bool isNew =
|
||
|
|
(result.second == true) ||
|
||
|
|
(local._frame - element._frame > 1);
|
||
|
|
|
||
|
|
element._frame = local._frame;
|
||
|
|
element._leaf = leaf;
|
||
|
|
|
||
|
|
osg::Vec3d offset;
|
||
|
|
const ScreenSpaceLayoutData* layoutData = dynamic_cast<const ScreenSpaceLayoutData*>(drawable->getUserData());
|
||
|
|
if (layoutData)
|
||
|
|
{
|
||
|
|
offset = osg::Vec3d(layoutData->getPixelOffset().x(), layoutData->getPixelOffset().y(), 0.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (element._drawable == NULL)
|
||
|
|
{
|
||
|
|
element._drawable = drawable;
|
||
|
|
element._text = dynamic_cast<osgEarth::Text*>(drawable);
|
||
|
|
element._drawable->setDataVariance(osg::Object::DYNAMIC);
|
||
|
|
element._declutter = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (layoutData)
|
||
|
|
{
|
||
|
|
// FLT_MAX priority => don't declutter this element.
|
||
|
|
// Fixed position => don't move the element
|
||
|
|
if (layoutData->getPriority() == FLT_MAX ||
|
||
|
|
layoutData->getFixed())
|
||
|
|
{
|
||
|
|
element._declutter = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
element._declutter = (element._drawable != NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
element._anchor =
|
||
|
|
zero *
|
||
|
|
(*leaf->_modelview) *
|
||
|
|
(*leaf->_projection) *
|
||
|
|
local._scalebias;
|
||
|
|
|
||
|
|
const osg::Viewport* vp = local._camera->getViewport();
|
||
|
|
|
||
|
|
if (isNew)
|
||
|
|
{
|
||
|
|
element._offsetVector = element._anchor - osg::Vec3d(0.5*vp->width(), 0.5*vp->height(), 0.0);
|
||
|
|
element._offsetVector.normalize();
|
||
|
|
}
|
||
|
|
else if (_resetWhenViewChanges && local._vpmChanged)
|
||
|
|
{
|
||
|
|
element._offsetVector = element._anchor - osg::Vec3d(0.5*vp->width(), 0.5*vp->height(), 0.0);
|
||
|
|
element._offsetVector.normalize();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (element._leaderLineIndex == INT_MAX)
|
||
|
|
{
|
||
|
|
element._leaderLineIndex = local._leaders->getNumVerts();
|
||
|
|
local._leaders->pushVertex(osg::Vec3f());
|
||
|
|
local._leaders->pushVertex(osg::Vec3f());
|
||
|
|
local._leadersDirty = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// each one needs a unique mvm
|
||
|
|
leaf->_modelview = new osg::RefMatrix();
|
||
|
|
|
||
|
|
if (element._declutter && ScreenSpaceLayout::globallyEnabled)
|
||
|
|
{
|
||
|
|
double leaderLen = osg::minimum((double)_context->_options.leaderLineMaxLength().get(), element._offsetLength);
|
||
|
|
osg::Vec3d pos = element._anchor + element._offsetVector*leaderLen;
|
||
|
|
|
||
|
|
// alignment of text relative to the leader line
|
||
|
|
const float margin = 5.0f;
|
||
|
|
osg::Vec3d alignment;
|
||
|
|
const osg::BoundingBox& bb = element._drawable->getBoundingBox();
|
||
|
|
alignment.x() = element._offsetVector.x() * 0.5*(bb.xMax()-bb.xMin()) + margin*signOf(element._offsetVector.x());
|
||
|
|
alignment.y() = element._offsetVector.y() * 0.5*(bb.yMax()-bb.yMin()) + margin*signOf(element._offsetVector.y());
|
||
|
|
|
||
|
|
leaf->_modelview->makeTranslate(pos + alignment);
|
||
|
|
|
||
|
|
// and update the leader line endpoints
|
||
|
|
if (element._anchor != local._leaders->getVertex(element._leaderLineIndex))
|
||
|
|
{
|
||
|
|
local._leaders->setVertex(element._leaderLineIndex, element._anchor);
|
||
|
|
}
|
||
|
|
if (pos != local._leaders->getVertex(element._leaderLineIndex + 1))
|
||
|
|
{
|
||
|
|
local._leaders->setVertex(element._leaderLineIndex + 1, pos);
|
||
|
|
}
|
||
|
|
|
||
|
|
// and update the colors of the leader line
|
||
|
|
if (element._text)
|
||
|
|
{
|
||
|
|
osg::Vec4f color =
|
||
|
|
_context->_options.leaderLineColor().isSet() ? _context->_options.leaderLineColor().get() :
|
||
|
|
element._text->getDrawMode() & osgText::Text::BOUNDINGBOX ? element._text->getBoundingBoxColor() :
|
||
|
|
local._leaderColor;
|
||
|
|
|
||
|
|
local._leaders->setColor(element._leaderLineIndex, color);
|
||
|
|
local._leaders->setColor(element._leaderLineIndex + 1, color);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
leaf->_modelview->makeTranslate(element._anchor + offset);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CalloutImplementation::sort(CameraLocal& local)
|
||
|
|
{
|
||
|
|
if (local._elements.empty())
|
||
|
|
return;
|
||
|
|
|
||
|
|
const osg::Viewport* vp = local._camera->getViewport();
|
||
|
|
|
||
|
|
local._points.clear();
|
||
|
|
local._lookup.clear();
|
||
|
|
|
||
|
|
jcv_rect bounds;
|
||
|
|
const double K = 0;
|
||
|
|
bounds.min.x = vp->x() + K, bounds.min.y = vp->y() + K;
|
||
|
|
bounds.max.x = vp->x() + vp->width() - K * 2, bounds.max.y = vp->y() + vp->height() - K * 2;
|
||
|
|
|
||
|
|
for (Elements::reverse_iterator i = local._elements.rbegin();
|
||
|
|
i != local._elements.rend();
|
||
|
|
++i)
|
||
|
|
{
|
||
|
|
Element& element = i->second;
|
||
|
|
|
||
|
|
if (element._leaf != NULL && element._declutter)
|
||
|
|
{
|
||
|
|
// Hm, not sure what this is doing
|
||
|
|
//if (element._frame == element._frame)
|
||
|
|
if (element._frame == local._frame)
|
||
|
|
{
|
||
|
|
// i.e., visible
|
||
|
|
element._leaf->_depth = 1.0f;
|
||
|
|
|
||
|
|
if (element._anchor.x() >= bounds.min.x &&
|
||
|
|
element._anchor.x() <= bounds.max.x &&
|
||
|
|
element._anchor.y() >= bounds.min.y &&
|
||
|
|
element._anchor.y() <= bounds.max.y)
|
||
|
|
{
|
||
|
|
jcv_point back{ element._anchor.x(), element._anchor.y() };
|
||
|
|
local._points.emplace_back(back);
|
||
|
|
local._lookup[back] = &element;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (local._points.empty())
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Use a Voronoi diagram to find the best location for each callout.
|
||
|
|
// Use the "visual center" of the point's site as the label location.
|
||
|
|
jcv_diagram diagram;
|
||
|
|
::memset(&diagram, 0, sizeof(jcv_diagram));
|
||
|
|
jcv_diagram_generate(local._points.size(), &local._points[0], &bounds, &diagram);
|
||
|
|
|
||
|
|
if (local._voronoi.valid())
|
||
|
|
{
|
||
|
|
local._voronoi->clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef USE_ROTATED_AABB_CENTROID_METHOD
|
||
|
|
osg::Quat q;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
const jcv_site* sites = jcv_diagram_get_sites(&diagram);
|
||
|
|
for(int i=0; i<diagram.numsites; ++i)
|
||
|
|
{
|
||
|
|
const jcv_site* site = &sites[i];
|
||
|
|
|
||
|
|
Element* element = local._lookup[site->p];
|
||
|
|
if (element)
|
||
|
|
{
|
||
|
|
#ifdef USE_ROTATED_AABB_CENTROID_METHOD
|
||
|
|
// This centroid-finding method calculates an axis-aligned bounding box formed by
|
||
|
|
// first rotating the site so that its longest edge is axis-aligned. This seems to
|
||
|
|
// provide a better centroid in some cases, esp for trianglar sites.
|
||
|
|
|
||
|
|
// first find the longest edge in the site:
|
||
|
|
const jcv_graphedge* edge = NULL;
|
||
|
|
const jcv_graphedge* longestEdge = NULL;
|
||
|
|
|
||
|
|
jcv_real maxLen2 = 0;
|
||
|
|
for(edge = site->edges; edge; edge = edge->next)
|
||
|
|
{
|
||
|
|
jcv_real dx = edge->pos[1].x - edge->pos[0].x;
|
||
|
|
jcv_real dy = edge->pos[1].y - edge->pos[0].y;
|
||
|
|
jcv_real len2 = dx*dx + dy*dy;
|
||
|
|
if (len2 > maxLen2)
|
||
|
|
{
|
||
|
|
maxLen2 = len2;
|
||
|
|
longestEdge = edge;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// now compute a rotation that transforms the longest edge so that
|
||
|
|
// it is parallel with x=0
|
||
|
|
osg::Vec3d v(longestEdge->pos[1].x-longestEdge->pos[0].x, longestEdge->pos[1].y-longestEdge->pos[0].y, 0);
|
||
|
|
q.makeRotate(v, osg::Vec3d(0,1,0));
|
||
|
|
|
||
|
|
// now calculate an axis-aligned bounding box for the rotated site:
|
||
|
|
BBox bb;
|
||
|
|
const jcv_graphedge* lastEdge = NULL;
|
||
|
|
osg::Vec3d p0, p1;
|
||
|
|
for(edge = site->edges; edge; edge = edge->next)
|
||
|
|
{
|
||
|
|
p0.set(edge->pos[0].x, edge->pos[0].y, 0);
|
||
|
|
p1.set(edge->pos[1].x, edge->pos[1].y, 0);
|
||
|
|
|
||
|
|
if (local._voronoi.valid())
|
||
|
|
{
|
||
|
|
local._voronoi->pushVertex(p0);
|
||
|
|
local._voronoi->pushVertex(p1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// rotate the point into the aabb frame and incorporate it
|
||
|
|
// into the bounding box.
|
||
|
|
p0 = q*p0;
|
||
|
|
bb.expandToInclude(p0.x(), p0.y());
|
||
|
|
}
|
||
|
|
|
||
|
|
// finally take the centroid and transform it back into the original frame:
|
||
|
|
osg::Vec3d centroid(
|
||
|
|
bb.LL.x() + 0.5*(bb.UR.x()-bb.LL.x()),
|
||
|
|
bb.LL.y() + 0.5*(bb.UR.y()-bb.LL.y()),
|
||
|
|
0);
|
||
|
|
|
||
|
|
centroid = q.inverse()*centroid;
|
||
|
|
|
||
|
|
#else
|
||
|
|
// This centroid-finding method is the typical bounding-box centroid.
|
||
|
|
BBox bb;
|
||
|
|
|
||
|
|
const jcv_graphedge* edge = site->edges;
|
||
|
|
while(edge)
|
||
|
|
{
|
||
|
|
bb.expandToInclude(edge->pos[0].x, edge->pos[0].y);
|
||
|
|
|
||
|
|
if (local._voronoi.valid())
|
||
|
|
{
|
||
|
|
local._voronoi->pushVertex(osg::Vec3(edge->pos[0].x, edge->pos[0].y, 0));
|
||
|
|
local._voronoi->pushVertex(osg::Vec3(edge->pos[1].x, edge->pos[1].y, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
edge = edge->next;
|
||
|
|
}
|
||
|
|
|
||
|
|
osg::Vec3d centroid(
|
||
|
|
bb.LL.x() + 0.5*(bb.UR.x()-bb.LL.x()),
|
||
|
|
bb.LL.y() + 0.5*(bb.UR.y()-bb.LL.y()),
|
||
|
|
0);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
osg::Vec3d prevOffset = element->_offsetVector;
|
||
|
|
osg::Vec3d newOffset = centroid - element->_anchor;
|
||
|
|
double newOffsetLength = newOffset.length();
|
||
|
|
newOffset.normalize();
|
||
|
|
|
||
|
|
// Try to avoid moving the offsetVector too drastically per frame.
|
||
|
|
// If the label still needs to move after 60 frames go ahead and move it.
|
||
|
|
// This helps for fast moving entities or if you are moving the camera quickly.
|
||
|
|
double dot = newOffset * prevOffset;
|
||
|
|
if (osg::absolute(dot) < 0.9 && element->_numFramesSinceMove < 60)
|
||
|
|
{
|
||
|
|
element->_numFramesSinceMove++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
element->_offsetVector = newOffset;
|
||
|
|
element->_numFramesSinceMove = 0;
|
||
|
|
element->_offsetLength = newOffsetLength;
|
||
|
|
element->_offsetVector.normalize();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
jcv_diagram_free(&diagram);
|
||
|
|
|
||
|
|
if (local._voronoi.valid())
|
||
|
|
{
|
||
|
|
local._voronoi->finish();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// runs in CULL thread after culling completes
|
||
|
|
void CalloutImplementation::sortImplementation(osgUtil::RenderBin* bin)
|
||
|
|
{
|
||
|
|
const ScreenSpaceLayoutOptions& options = _context->_options;
|
||
|
|
|
||
|
|
bin->copyLeavesFromStateGraphListToRenderLeafList();
|
||
|
|
|
||
|
|
osgUtil::RenderBin::RenderLeafList& leaves = bin->getRenderLeafList();
|
||
|
|
|
||
|
|
// first, sort the leaves:
|
||
|
|
if (_customSortFunctor && ScreenSpaceLayout::globallyEnabled)
|
||
|
|
{
|
||
|
|
// if there's a custom sorting function installed
|
||
|
|
std::sort(leaves.begin(), leaves.end(), SortContainer(*_customSortFunctor));
|
||
|
|
}
|
||
|
|
else if (options.sortByDistance() == true)
|
||
|
|
{
|
||
|
|
// default behavior:
|
||
|
|
std::sort(leaves.begin(), leaves.end(), SortFrontToBackPreservingGeodeTraversalOrder());
|
||
|
|
}
|
||
|
|
|
||
|
|
// nothing to sort? bail out
|
||
|
|
if (leaves.empty())
|
||
|
|
return;
|
||
|
|
|
||
|
|
// access the per-camera persistent data:
|
||
|
|
osg::Camera* cam = bin->getStage()->getCamera();
|
||
|
|
|
||
|
|
// bail out if this camera is a master camera with no GC
|
||
|
|
// (e.g., in a multi-screen layout)
|
||
|
|
if (cam == NULL || (cam->getGraphicsContext() == NULL && !cam->isRenderToTextureCamera()))
|
||
|
|
return;
|
||
|
|
|
||
|
|
CameraLocal& local = _cameraLocal.get(cam);
|
||
|
|
local._camera = cam;
|
||
|
|
|
||
|
|
static osg::Vec4f invisible(1,0,0,0);
|
||
|
|
local._leaders->setColor(invisible);
|
||
|
|
local._leaders->setLineWidth(_context->_options.leaderLineWidth().get());
|
||
|
|
|
||
|
|
if (_context->_debug && !local._voronoi.valid() && ScreenSpaceLayout::globallyEnabled)
|
||
|
|
local.initDebug();
|
||
|
|
|
||
|
|
osg::GraphicsContext* gc = cam->getGraphicsContext();
|
||
|
|
local._frame = gc && gc->getState() && gc->getState()->getFrameStamp() ?
|
||
|
|
gc->getState()->getFrameStamp()->getFrameNumber() : 0u;
|
||
|
|
|
||
|
|
const osg::Viewport* vp = cam->getViewport();
|
||
|
|
local._scalebias =
|
||
|
|
osg::Matrix::translate(1, 1, 1) *
|
||
|
|
osg::Matrix::scale(0.5*vp->width(), 0.5*vp->height(), 0.5) *
|
||
|
|
osg::Matrix::translate(vp->x(), vp->y(), 0.0);
|
||
|
|
|
||
|
|
for(osgUtil::RenderBin::RenderLeafList::iterator i = leaves.begin();
|
||
|
|
i != leaves.end();
|
||
|
|
++i)
|
||
|
|
{
|
||
|
|
push(*i, local);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ScreenSpaceLayout::globallyEnabled)
|
||
|
|
{
|
||
|
|
sort(local);
|
||
|
|
}
|
||
|
|
|
||
|
|
// clear out the RenderLeaf pointers (since they change each frame)
|
||
|
|
for (Elements::iterator i = local._elements.begin();
|
||
|
|
i != local._elements.end();
|
||
|
|
++i)
|
||
|
|
{
|
||
|
|
Element& element = i->second;
|
||
|
|
element._leaf = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Custom draw routine for our declutter render bin.
|
||
|
|
*/
|
||
|
|
struct CalloutDraw : public osgUtil::RenderBin::DrawCallback
|
||
|
|
{
|
||
|
|
ScreenSpaceLayoutContext* _context;
|
||
|
|
PerThread< osg::ref_ptr<osg::RefMatrix> > _ortho2D;
|
||
|
|
osg::ref_ptr<osg::Uniform> _fade;
|
||
|
|
CalloutImplementation* _sortCallback;
|
||
|
|
|
||
|
|
struct RunningState
|
||
|
|
{
|
||
|
|
RunningState() : lastFade(-1.0f), lastPCP(NULL) { }
|
||
|
|
float lastFade;
|
||
|
|
const osg::Program::PerContextProgram* lastPCP;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs the decluttering draw callback.
|
||
|
|
* @param context A shared context among all decluttering objects.
|
||
|
|
*/
|
||
|
|
CalloutDraw(ScreenSpaceLayoutContext* context)
|
||
|
|
: _context(context)
|
||
|
|
, _sortCallback(NULL)
|
||
|
|
{
|
||
|
|
// create the fade uniform.
|
||
|
|
_fade = new osg::Uniform(osg::Uniform::FLOAT, FADE_UNIFORM_NAME);
|
||
|
|
_fade->set(1.0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Draws a bin. Most of this code is copied from osgUtil::RenderBin::drawImplementation.
|
||
|
|
* The modifications are (a) skipping code to render child bins, (b) setting a bin-global
|
||
|
|
* projection matrix in orthographic space, and (c) calling our custom "renderLeaf()" method
|
||
|
|
* instead of RenderLeaf::render()
|
||
|
|
*/
|
||
|
|
void drawImplementation(osgUtil::RenderBin* bin, osg::RenderInfo& renderInfo, osgUtil::RenderLeaf*& previous)
|
||
|
|
{
|
||
|
|
osg::State& state = *renderInfo.getState();
|
||
|
|
|
||
|
|
unsigned int numToPop = (previous ? osgUtil::StateGraph::numToPop(previous->_parent) : 0);
|
||
|
|
if (numToPop > 1) --numToPop;
|
||
|
|
unsigned int insertStateSetPosition = state.getStateSetStackSize() - numToPop;
|
||
|
|
|
||
|
|
if (bin->getStateSet())
|
||
|
|
{
|
||
|
|
state.insertStateSet(insertStateSetPosition, bin->getStateSet());
|
||
|
|
}
|
||
|
|
|
||
|
|
// apply a window-space projection matrix.
|
||
|
|
const osg::Viewport* vp = renderInfo.getCurrentCamera()->getViewport();
|
||
|
|
if (vp)
|
||
|
|
{
|
||
|
|
osg::ref_ptr<osg::RefMatrix>& m = _ortho2D.get();
|
||
|
|
if (!m.valid())
|
||
|
|
m = new osg::RefMatrix();
|
||
|
|
|
||
|
|
//m->makeOrtho2D( vp->x(), vp->x()+vp->width()-1, vp->y(), vp->y()+vp->height()-1 );
|
||
|
|
m->makeOrtho(vp->x(), vp->x() + vp->width() - 1, vp->y(), vp->y() + vp->height() - 1, -1000, 1000);
|
||
|
|
state.applyProjectionMatrix(m.get());
|
||
|
|
}
|
||
|
|
|
||
|
|
// initialize the fading uniform
|
||
|
|
RunningState rs;
|
||
|
|
|
||
|
|
// render the list
|
||
|
|
osgUtil::RenderBin::RenderLeafList& leaves = bin->getRenderLeafList();
|
||
|
|
|
||
|
|
for (osgUtil::RenderBin::RenderLeafList::reverse_iterator rlitr = leaves.rbegin();
|
||
|
|
rlitr != leaves.rend();
|
||
|
|
++rlitr)
|
||
|
|
{
|
||
|
|
osgUtil::RenderLeaf* rl = *rlitr;
|
||
|
|
//if (rl->_depth > 0.0f)
|
||
|
|
{
|
||
|
|
renderLeaf(rl, renderInfo, previous, rs);
|
||
|
|
previous = rl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bin->getStateSet())
|
||
|
|
{
|
||
|
|
state.removeStateSet(insertStateSetPosition);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ScreenSpaceLayout::globallyEnabled)
|
||
|
|
{
|
||
|
|
// the leader lines
|
||
|
|
CalloutImplementation::CameraLocal& local = _sortCallback->_cameraLocal.get(renderInfo.getCurrentCamera());
|
||
|
|
|
||
|
|
if (local._leadersDirty)
|
||
|
|
{
|
||
|
|
local._leaders->dirty();
|
||
|
|
local._leadersDirty = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
renderInfo.getState()->applyModelViewMatrix(osg::Matrix::identity());
|
||
|
|
|
||
|
|
if (local._leaders->getUseGPU())
|
||
|
|
{
|
||
|
|
renderInfo.getState()->pushStateSet(local._leaders->getGPUStateSet());
|
||
|
|
}
|
||
|
|
|
||
|
|
renderInfo.getState()->pushStateSet(local._leaders->getStateSet());
|
||
|
|
|
||
|
|
renderInfo.getState()->apply();
|
||
|
|
|
||
|
|
glDepthFunc(GL_ALWAYS);
|
||
|
|
glDepthMask(GL_FALSE);
|
||
|
|
glEnable(GL_BLEND);
|
||
|
|
|
||
|
|
if (renderInfo.getState()->getUseModelViewAndProjectionUniforms())
|
||
|
|
renderInfo.getState()->applyModelViewAndProjectionUniformsIfRequired();
|
||
|
|
|
||
|
|
local._leaders->draw(renderInfo);
|
||
|
|
|
||
|
|
renderInfo.getState()->popStateSet();
|
||
|
|
if (local._leaders->getUseGPU())
|
||
|
|
{
|
||
|
|
renderInfo.getState()->popStateSet();
|
||
|
|
}
|
||
|
|
|
||
|
|
// the debug diagram
|
||
|
|
if (local._voronoi.valid())
|
||
|
|
{
|
||
|
|
local._voronoi->draw(renderInfo);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Renders a single leaf. We already applied the projection matrix, so here we only
|
||
|
|
* need to apply a modelview matrix that specifies the ortho offset of the drawable.
|
||
|
|
*
|
||
|
|
* Most of this code is copied from RenderLeaf::draw() -- but I removed all the code
|
||
|
|
* dealing with nested bins, since decluttering does not support them.
|
||
|
|
*/
|
||
|
|
void renderLeaf(osgUtil::RenderLeaf* leaf, osg::RenderInfo& renderInfo, osgUtil::RenderLeaf*& previous, RunningState& rs)
|
||
|
|
{
|
||
|
|
osg::State& state = *renderInfo.getState();
|
||
|
|
|
||
|
|
// don't draw this leaf if the abort rendering flag has been set.
|
||
|
|
if (state.getAbortRendering())
|
||
|
|
{
|
||
|
|
//cout << "early abort"<<endl;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
state.applyModelViewMatrix(leaf->_modelview.get());
|
||
|
|
|
||
|
|
if (previous)
|
||
|
|
{
|
||
|
|
// apply state if required.
|
||
|
|
osgUtil::StateGraph* prev_rg = previous->_parent;
|
||
|
|
osgUtil::StateGraph* prev_rg_parent = prev_rg->_parent;
|
||
|
|
osgUtil::StateGraph* rg = leaf->_parent;
|
||
|
|
if (prev_rg_parent != rg->_parent)
|
||
|
|
{
|
||
|
|
osgUtil::StateGraph::moveStateGraph(state, prev_rg_parent, rg->_parent);
|
||
|
|
|
||
|
|
// send state changes and matrix changes to OpenGL.
|
||
|
|
state.apply(rg->getStateSet());
|
||
|
|
|
||
|
|
}
|
||
|
|
else if (rg != prev_rg)
|
||
|
|
{
|
||
|
|
// send state changes and matrix changes to OpenGL.
|
||
|
|
state.apply(rg->getStateSet());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// apply state if required.
|
||
|
|
osgUtil::StateGraph::moveStateGraph(state, NULL, leaf->_parent->_parent);
|
||
|
|
|
||
|
|
state.apply(leaf->_parent->getStateSet());
|
||
|
|
}
|
||
|
|
|
||
|
|
// if we are using osg::Program which requires OSG's generated uniforms to track
|
||
|
|
// modelview and projection matrices then apply them now.
|
||
|
|
if (state.getUseModelViewAndProjectionUniforms())
|
||
|
|
state.applyModelViewAndProjectionUniformsIfRequired();
|
||
|
|
|
||
|
|
// apply the fading uniform
|
||
|
|
const osg::Program::PerContextProgram* pcp = state.getLastAppliedProgramObject();
|
||
|
|
if (pcp)
|
||
|
|
{
|
||
|
|
if (pcp != rs.lastPCP)
|
||
|
|
{
|
||
|
|
pcp->apply(*_fade.get());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
rs.lastPCP = pcp;
|
||
|
|
|
||
|
|
// draw the drawable
|
||
|
|
leaf->_drawable->draw(renderInfo);
|
||
|
|
|
||
|
|
if (leaf->_dynamic)
|
||
|
|
{
|
||
|
|
state.decrementDynamicObjectCount();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
} }
|
||
|
|
|
||
|
|
#endif // OSGEARTH_SCREEN_SPACE_LAYOUT_CALLOUT_H
|