source: geovis/trunk/Picker.cpp @ 5972

/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 * Copyright (C) 2015  HUBzero Foundation, LLC
 *
 * Author: Leif Delgass <ldelgass@purdue.edu>
 */
#include <vector>
#include <cstdio>
#include <cassert>

#include <osgEarth/Registry>
#include <osgEarth/ShaderGenerator>
#include <osgEarth/ObjectIndex>
#include <osgEarthFeatures/Feature>
#include <osgEarthFeatures/FeatureIndex>
#include <osgEarthFeatures/FeatureSourceIndexNode>
#include <osgEarthAnnotation/AnnotationNode>
#include <osgEarthAnnotation/LabelNode>
#include <osgEarthSymbology/Color>
#include <osgEarthSymbology/Style>
#include <osgEarthSymbology/TextSymbol>

#include "Picker.h"
#include "Placard.h"
#include "Renderer.h"
#include "RendererCmd.h"
#include "Trace.h"

using namespace GeoVis;

static const char *highlightVert =
    "#version 130\n"
    "uniform uint objectid_to_highlight; \n"
    "uint oe_index_objectid;      // Stage global containing object id \n"
    "flat out int selected; \n"
    "void checkForHighlight(inout vec4 vertex) \n"
    "{ \n"
    "    selected = (objectid_to_highlight > 1u && objectid_to_highlight == oe_index_objectid) ? 1 : 0; \n"
    "} \n";

static const char *highlightFrag =
    "#version 130\n"
    "flat in int selected; \n"
    "void highlightFragment(inout vec4 color) \n"
    "{ \n"
    "    if ( selected == 1 ) \n"
    "        color.rgb = mix(color.rgb, clamp(vec3(0.5,0.5,2.0)*(1.0-color.rgb), 0.0, 1.0), 0.5); \n"
    "} \n";

static osg::Uniform *s_highlightUniform = NULL;

static void installHighlighter(osg::StateSet *stateSet, int attrLocation)
{
    TRACE("GLSL Version: %s", GLSL_VERSION_STR);
    // This shader program will highlight the selected object.
    osgEarth::VirtualProgram *vp = osgEarth::VirtualProgram::getOrCreate(stateSet);
    vp->setFunction("checkForHighlight",  highlightVert, osgEarth::ShaderComp::LOCATION_VERTEX_CLIP);
    vp->setFunction("highlightFragment",  highlightFrag, osgEarth::ShaderComp::LOCATION_FRAGMENT_COLORING);

    // Since we're accessing object IDs, we need to load the indexing shader as well:
    osgEarth::Registry::objectIndex()->loadShaders(vp);

    // A uniform that will tell the shader which object to highlight:
    if (s_highlightUniform == NULL) {
        s_highlightUniform = new osg::Uniform("objectid_to_highlight", 0u);
    }
    stateSet->addUniform(s_highlightUniform);
}

void GeoVis::setHighlightByObjectID(osgEarth::ObjectID id)
{
    if (s_highlightUniform != NULL) {
        s_highlightUniform->set(id);
    }
}

void GeoVis::clearHighlight()
{
    if (s_highlightUniform != NULL) {
        s_highlightUniform->set(0U);
    }
}

HoverCallback::HoverCallback(Renderer *renderer) :
    _renderer(renderer)
{
    installHighlighter(renderer->getMapNode()->getOrCreateStateSet(),
                       osgEarth::Registry::objectIndex()->getObjectIDAttribLocation());
}

void HoverCallback::onHit(osgEarth::ObjectID id)
{
    // First see whether it's a feature:
    osgEarth::Features::FeatureIndex *index = osgEarth::Registry::objectIndex()->get<osgEarth::Features::FeatureIndex>(id);
    osgEarth::Features::Feature *feature = index ? index->getFeature(id) : 0L;
    INFO("Hover hit");
    if (feature) {
        INFO("Hit feature ID: %lu (of %d), oid: %lu", feature->getFID(), index->size(), id);
        const osgEarth::Features::AttributeTable &attrs = feature->getAttrs();
        for (osgEarth::Features::AttributeTable::const_iterator itr = attrs.begin(); itr != attrs.end(); ++itr) {
            INFO(" attr: %s", itr->first.c_str());
            switch (itr->second.first) {
            case osgEarth::Features::ATTRTYPE_STRING:
                INFO(" value: %s", itr->second.getString().c_str());
                break;
            case osgEarth::Features::ATTRTYPE_INT:
                INFO(" value: %d", itr->second.getInt());
                break;
            case osgEarth::Features::ATTRTYPE_DOUBLE:
                INFO(" value: %g", itr->second.getDouble());
                break;
            case osgEarth::Features::ATTRTYPE_BOOL:
                INFO(" value: %s", itr->second.getBool() ? "true" : "false");
                break;
            default:
                INFO(" value: unknown type");
            }
        }
        //INFO("Feature name: %s", feature->getString("name").c_str());
    } else {
        osgEarth::Annotation::AnnotationNode* anno =
            osgEarth::Registry::objectIndex()->get<osgEarth::Annotation::AnnotationNode>(id);

        std::set<osgEarth::Annotation::AnnotationNode*> toUnHover;
        std::set<osgEarth::Annotation::AnnotationNode*>& hovered = _renderer->getHovered();
        for (std::set<osgEarth::Annotation::AnnotationNode*>::iterator itr = hovered.begin();
             itr != hovered.end(); ++itr) {
            toUnHover.insert(*itr);
        }
        if (anno != NULL && anno->getDecoration().empty()) {
            INFO("Hit AnnotationNode: %p", anno);
#if 0
            if (hovered.find(anno) == hovered.end()) {
                hovered.insert(anno);
                anno->setDecoration("hover");
                _renderer->eventuallyRender();
            }
            toUnHover.erase(anno);
#endif
        }
#if 0
        for (std::set<osgEarth::Annotation::AnnotationNode *>::iterator itr = toUnHover.begin();
             itr != toUnHover.end(); ++itr) {
            hovered.erase(*itr);
            (*itr)->clearDecoration();
            _renderer->eventuallyRender();
        }
#endif
    }
    setHighlightByObjectID(id);
}

void HoverCallback::onMiss()
{
    INFO("Hover miss");
    std::set<osgEarth::Annotation::AnnotationNode*> toUnHover;
    std::set<osgEarth::Annotation::AnnotationNode*>& hovered = _renderer->getHovered();
    for (std::set<osgEarth::Annotation::AnnotationNode*>::iterator itr = hovered.begin();
         itr != hovered.end(); ++itr) {
        toUnHover.insert(*itr);
    }
    for (std::set<osgEarth::Annotation::AnnotationNode *>::iterator itr = toUnHover.begin();
         itr != toUnHover.end(); ++itr) {
        hovered.erase(*itr);
        (*itr)->clearDecoration();
        _renderer->eventuallyRender();
    }
    clearHighlight();
}

bool HoverCallback::accept(const osgGA::GUIEventAdapter& ea, const osgGA::GUIActionAdapter& aa)
{
    // Pick whenever mouse moves
    return ea.getEventType() == ea.MOVE;
}

SelectCallback::SelectCallback(Renderer *renderer) :
    _renderer(renderer)
{
    installHighlighter(renderer->getMapNode()->getOrCreateStateSet(),
                       osgEarth::Registry::objectIndex()->getObjectIDAttribLocation());
    installHighlighter(renderer->getPlaceNodes()->getOrCreateStateSet(),
                       osgEarth::Registry::objectIndex()->getObjectIDAttribLocation());
}

void SelectCallback::onHit(osgEarth::ObjectID id)
{
    // First see whether it's a feature:
    osgEarth::Features::FeatureIndex *index = osgEarth::Registry::objectIndex()->get<osgEarth::Features::FeatureIndex>(id);
    osgEarth::Features::Feature *feature = index ? index->getFeature(id) : 0L;
    INFO("Select hit oid: %lu at %g,%g", id, _pickPoint.x(), _pickPoint.y());
    if (feature) {
        osgEarth::Features::FeatureSourceIndex *fsi = dynamic_cast<osgEarth::Features::FeatureSourceIndex *>(index);
        std::string layerName;
        if (fsi) {
            osgEarth::Features::FeatureSource *source = fsi->getFeatureSource();
            if (source) {
                layerName = source->getFeatureSourceOptions().name().get();
            }
        }
        INFO("Hit feature ID: %lu (of %d) layer: %s", feature->getFID(), index->size(), layerName.c_str());

        clearSelection();

        const osgEarth::Features::AttributeTable &attrs = feature->getAttrs();
        Placard placard = _renderer->getPlacardConfig(layerName);
        if (placard.getNumEntries() == 0) {
            placard.addAllAttributes(attrs);
        }
        PlacardNode *label = 
            new PlacardNode(_renderer->getMapNode(), _pickPoint, placard, attrs);
        label->getOrCreateStateSet()->setRenderBinDetails(INT_MAX, "RenderBin");
        _renderer->getAnnotations()->addChild(label);

        char mesg[256];
        snprintf(mesg, sizeof(mesg), "nv>select feature %u %lu %d {%s}\n", id, feature->getFID(), index->size(), layerName.c_str());
        size_t length = strlen(mesg);
        queueResponse(mesg, length, Response::VOLATILE, Response::DATA);
    } else {
        clearSelection();
        osgEarth::Annotation::AnnotationNode* anno =
            osgEarth::Registry::objectIndex()->get<osgEarth::Annotation::AnnotationNode>(id);
        if (anno != NULL) {
            INFO("Hit AnnotationNode: %p, \"%s\"", anno, anno->getName().c_str());
            char mesg[256];
            snprintf(mesg, sizeof(mesg), "nv>select annotation %u {%s}\n", id, anno->getName().c_str());
            size_t length = strlen(mesg);
            queueResponse(mesg, length, Response::VOLATILE, Response::DATA);
        }
    }
    setHighlightByObjectID(id);
    _renderer->eventuallyRender();
}

void SelectCallback::onMiss()
{
    INFO("Select miss");
    clearSelection();
    clearHighlight();

    static const char *mesg = "nv>select clear\n";
    static const size_t length = strlen(mesg);
    queueResponse(mesg, length, Response::STATIC, Response::DATA);

    _renderer->eventuallyRender();
}

void SelectCallback::clearSelection()
{
    osg::Group *nodes = _renderer->getAnnotations();
    std::vector<osg::Node *> toRemove;
    for (unsigned int i = 0; i < nodes->getNumChildren(); i++) {
        osg::Node *node = nodes->getChild(i);
        if (dynamic_cast<osgEarth::Annotation::OrthoNode *>(node) != NULL) {
            toRemove.push_back(node);
        }
    }
    for (std::vector<osg::Node *>::iterator itr = toRemove.begin();
         itr != toRemove.end(); ++itr) {
        nodes->removeChild(*itr);
    }
}

bool SelectCallback::accept(const osgGA::GUIEventAdapter& ea, const osgGA::GUIActionAdapter& aa)
{
    _renderer->mapMouseCoords(ea.getX(), ea.getY(), _pickPoint, false);
    // Pick on click
    return ea.getEventType() == ea.RELEASE;
}

void DeleteCallback::onHit(osgEarth::ObjectID id)
{
    // First see whether it's a feature:
    osgEarth::Features::FeatureIndex *index = osgEarth::Registry::objectIndex()->get<osgEarth::Features::FeatureIndex>(id);
    osgEarth::Features::Feature *feature = index ? index->getFeature(id) : 0L;

    if (feature) {
        TRACE("Hit feature ID: %lu, oid: %lu name: %s", feature->getFID(), id);
        TRACE("Feature name: %s", feature->getString("name").c_str());
    } else {
        TRACE("Picker hit!");
        osgEarth::Annotation::AnnotationNode* anno =
            osgEarth::Registry::objectIndex()->get<osgEarth::Annotation::AnnotationNode>(id);
        std::set<osgEarth::Annotation::AnnotationNode*>& hovered = _renderer->getHovered();
        anno->clearDecoration();
        _renderer->getPlaceNodes()->removeChild(anno);
        if (hovered.find(anno) != hovered.end()) {
            hovered.erase(anno);
        }
    }
}