bool MicrobeBarGraphObject::processEvent(InteractionEvent * ie)
{
if(ie->asTrackedButtonEvent() && ie->asTrackedButtonEvent()->getButton() == 0 && (ie->getInteraction() == BUTTON_DOWN || ie->getInteraction() == BUTTON_DOUBLE_CLICK))
{
TrackedButtonInteractionEvent * tie = (TrackedButtonInteractionEvent*)ie;
GraphLayoutObject * layout = dynamic_cast<GraphLayoutObject*>(_parent);
if(!layout)
{
return false;
}
std::string selectedGroup;
std::vector<std::string> selectedKeys;
osg::Vec3 start, end(0,1000,0);
start = start * tie->getTransform() * getWorldToObjectMatrix();
end = end * tie->getTransform() * getWorldToObjectMatrix();
osg::Vec3 planePoint;
osg::Vec3 planeNormal(0,-1,0);
osg::Vec3 intersect;
float w;
bool clickUsed = false;
bool selectValid = false;
if(linePlaneIntersectionRef(start,end,planePoint,planeNormal,intersect,w))
{
if(_graph->processClick(intersect,selectedKeys,selectValid))
{
clickUsed = true;
}
}
if(selectValid && _microbeCount)
{
if(selectedKeys.size())
{
for(int i = 0; i < _microbeCount; ++i)
{
if(!strcmp(selectedKeys[0].c_str(),_microbeList[i].species))
{
selectedGroup = _microbeList[i].phylum;
break;
}
}
}
layout->selectMicrobes(selectedGroup,selectedKeys);
}
if(clickUsed)
{
return true;
}
}
return TiledWallSceneObject::processEvent(ie);
}
bool OsgEarth::processEvent(InteractionEvent * event)
{
MouseInteractionEvent * mie = event->asMouseEvent();
if(mie)
{
return mouseButtonEvent(mie->getInteraction(),mie->getButton(),mie->getX(),mie->getY(),mie->getTransform());
}
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if(tie)
{
return buttonEvent(tie->getInteraction(),tie->getButton(),tie->getHand(),tie->getTransform());
}
return false;
}
bool MicrobePointLineObject::processEvent(cvr::InteractionEvent * ie)
{
if(ie->asTrackedButtonEvent() && ie->asTrackedButtonEvent()->getButton() == 0 && (ie->getInteraction() == BUTTON_DOWN || ie->getInteraction() == BUTTON_DOUBLE_CLICK))
{
TrackedButtonInteractionEvent * tie = (TrackedButtonInteractionEvent*)ie;
GraphLayoutObject * layout = dynamic_cast<GraphLayoutObject*>(_parent);
if(!layout)
{
return false;
}
std::string selectedGroup;
std::vector<std::string> selectedKeys;
osg::Vec3 start, end(0,1000,0);
start = start * tie->getTransform() * getWorldToObjectMatrix();
end = end * tie->getTransform() * getWorldToObjectMatrix();
osg::Vec3 planePoint;
osg::Vec3 planeNormal(0,-1,0);
osg::Vec3 intersect;
float w;
bool clickUsed = false;
if(linePlaneIntersectionRef(start,end,planePoint,planeNormal,intersect,w))
{
if(_graph->processClick(intersect,selectedGroup,selectedKeys))
{
clickUsed = true;
}
}
layout->selectPatients(selectedGroup,selectedKeys);
if(clickUsed)
{
return true;
}
}
return FPTiledWallSceneObject::processEvent(ie);
}
bool GraphKeyObject::eventCallback(InteractionEvent * ie)
{
TrackedButtonInteractionEvent * tie = ie->asTrackedButtonEvent();
if(tie)
{
if(tie->getButton() == 0 && (tie->getInteraction() == BUTTON_DOWN || tie->getInteraction() == BUTTON_DOUBLE_CLICK))
{
osg::Vec3 point1, point2(0,1000.0,0);
point1 = point1 * tie->getTransform() * getWorldToObjectMatrix();
point2 = point2 * tie->getTransform() * getWorldToObjectMatrix();
osg::Vec3 planePoint, planeNormal(0,-1,0), intersect;
float w;
if(linePlaneIntersectionRef(point1,point2,planePoint,planeNormal,intersect,w))
{
for(int i = 0; i < _rangeList.size(); ++i)
{
if(intersect.x() >= _rangeList[i].first && intersect.x() <= _rangeList[i].second)
{
std::string group = _labels[i];
std::vector<std::string> emptyList;
GraphLayoutObject * layout = dynamic_cast<GraphLayoutObject*>(_parent);
if(layout)
{
layout->selectPatients(group,emptyList);
}
return true;
}
}
}
}
}
return false;
}
bool WaterMaze::processEvent(InteractionEvent * event)
{
KeyboardInteractionEvent * kie = event->asKeyboardEvent();
if (kie)
{
if (kie->getInteraction() == KEY_UP)
{
switch(kie->getKey())
{
case 'n':
//next paradigm
changeParadigm(1);
break;
case 'b':
changeParadigm(-1);
break;
case 'f':
//next trial
changeTrial(1);
break;
case 'a':
//override trial limit add trial
addTrial();
break;
case 's':
// start/abort trail and reset position
startStop();
break;
case 'l':
//load geometry
load();
break;
case 'i':
/* info */
cout << endl << endl;
//running state of application
cout << "Current Running State: " << _state << endl;
//Paradigm ID
cout << "Current Paradigm: " << _paradigms[_currentParadigm]->getID() << endl;
//trials ran
cout << "Trial: " << _paradigms[_currentParadigm]->getTrialNumber() << endl;
//android controller data
if(ComController::instance()->isMaster())
cout << "# of Connected Devices: " << _controller->getNumControllers() << endl;
//volume
cout << "Master Volume: " << _masterVolume << endl;
break;
case 'h':
//help menu
std::cout << "Welcome to WaterMaze!\n" <<
"l - load geometry\n" <<
"n - proceed to next paradigm\n" <<
"s - start/stop trial\n" <<
"f - proceed to next trial\n" <<
"a - override trial limit/add trial\n" <<
"i - info\n" <<
"h - help menu" << std::endl;
break;
case osgGA::GUIEventAdapter::KeySymbol::KEY_Up:
//raise master volume
cout << "Raising Volume" << endl;
_masterVolume = min(1.0, _masterVolume + 0.1);
for(int i = 0; i < _paradigms.size(); ++i)
{
_paradigms[i]->setVolume(_masterVolume);
}
break;
case osgGA::GUIEventAdapter::KeySymbol::KEY_Down:
//lower master volume
cout << "Lowering Volume" << endl;
_masterVolume = max(0.0, _masterVolume - 0.1);
for(int i = 0; i < _paradigms.size(); ++i)
{
_paradigms[i]->setVolume(_masterVolume);
}
break;
}
}
}
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if (tie)
{
if(tie->getHand() == 0 && tie->getButton() == 0)
{
if (tie->getInteraction() == BUTTON_DOWN && !_runningTrial)
{
return true;
}
else if (tie->getInteraction() == BUTTON_DRAG && !_runningTrial)
{
return true;
}
else if (tie->getInteraction() == BUTTON_UP)
{
return false;
}
return false;
}
}
return false;
}
bool BubbleMenu::processEvent(InteractionEvent * event)
{
if(!_myMenu || !event->asTrackedButtonEvent())
{
return false;
}
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if(!_menuActive && !_showFavMenu)
{
if(_trigger == DOUBLECLICK)
{
if(event->getInteraction() == BUTTON_DOUBLE_CLICK)
{
if(tie->getButton() == _secondaryButton)
{
SceneManager::instance()->getMenuRoot()->addChild(_menuRoot);
if (!_showFavMenu)
{
SceneManager::instance()->getMenuRoot()->addChild(_favMenuRoot);
}
osg::Vec3 menuPoint = osg::Vec3(0, _distance, 0);
osg::Vec3 menuStartPos = osg::Vec3(0, _distance, _height);
menuPoint = menuStartPos;
if(event->asMouseEvent())
{
osg::Vec3 menuOffset = osg::Vec3(
_widthMap[_myMenu] / 2.0,0,0);
osg::Matrix m;
m.makeTranslate(menuPoint);
m.makeTranslate(menuStartPos);
_menuRoot->setMatrix(m);
}
else
{
osg::Vec3 viewerPoint =
TrackingManager::instance()->getHeadMat(0).getTrans();
osg::Vec3 viewerDir = viewerPoint - menuPoint;
viewerDir.z() = 0.0;
osg::Vec3 menuOffset = osg::Vec3(
_widthMap[_myMenu] * _scale / 2.0,0,0);
_menuRoot->setMatrix(osg::Matrix::translate(menuPoint));
}
_menuActive = true;
SceneManager::instance()->closeOpenObjectMenu();
return true;
}
}
}
else if(_trigger == UPCLICK)
{
return false;
}
}
else if (!_menuActive && _showFavMenu)
{
if(_trigger == DOUBLECLICK)
{
if(event->getInteraction() == BUTTON_DOUBLE_CLICK)
{
if(tie->getButton() == _secondaryButton)
{
SceneManager::instance()->getMenuRoot()->addChild(_menuRoot);
if (!_showFavMenu)
{
SceneManager::instance()->getMenuRoot()->addChild(_favMenuRoot);
}
osg::Vec3 menuPoint = osg::Vec3(0, _distance, 0);
osg::Vec3 menuStartPos = osg::Vec3(0, _distance, _height);
menuPoint = menuStartPos;
if(event->asMouseEvent())
{
osg::Vec3 menuOffset = osg::Vec3(
_widthMap[_myMenu] / 2.0,0,0);
osg::Matrix m;
m.makeTranslate(menuPoint);
m.makeTranslate(menuStartPos);
_menuRoot->setMatrix(m);
}
else
{
osg::Vec3 viewerPoint =
TrackingManager::instance()->getHeadMat(0).getTrans();
osg::Vec3 viewerDir = viewerPoint - menuPoint;
viewerDir.z() = 0.0;
osg::Vec3 menuOffset = osg::Vec3(
_widthMap[_myMenu] * _scale / 2.0,0,0);
_menuRoot->setMatrix(osg::Matrix::translate(menuPoint));
}
_menuActive = true;
SceneManager::instance()->closeOpenObjectMenu();
return true;
}
}
}
if(tie->getButton() == _primaryButton
&& (tie->getInteraction() == BUTTON_UP))
{
_timeLastButtonUp = PluginHelper::getProgramDuration();
_clickActive = false;
}
if(0)//_clickActive)
{
if(tie->getHand() == _activeHand)
{
if(tie->getButton() == _primaryButton)
{
_activeItem->processEvent(event);
if(tie->getInteraction() == BUTTON_UP)
{
_clickActive = false;
}
return true;
}
}
return false;
}
else if(tie->getHand() == _activeHand)
{
if (tie->getButton() == _primaryButton
&& (tie->getInteraction() == BUTTON_DOWN))
{
_timeLastButtonUp = PluginHelper::getProgramDuration();
_prevEvent = new InteractionEvent();
_prevEvent->setInteraction(event->getInteraction());
_prevActiveItem = _activeItem;
_clickActive = true;
return true;
}
if(tie->getButton() == _primaryButton
&& tie->getInteraction() == BUTTON_DOUBLE_CLICK)
{
// do click
//std::cout << "Double click" << std::endl;
_prevEvent = NULL;
MenuItem * item = _activeItem->getMenuItem();
if (_favMenu->getItemPosition(item) < 0)
{
_favMenu->addItem(item);
}
else
{
_favMenu->removeItem(item);
osg::MatrixTransform * mat = _favMaskMap[_favGeometryMap[item]];
osg::Matrix m = _favMenuRoot->getMatrix();
_lerpMap[mat] = new Lerp(mat->getMatrix().getTrans(),
- m.getTrans() - osg::Vec3(0, -m.getTrans()[1], 0)
+ osg::Vec3(0, 0, _height)
+ _rootPositionMap[_favGeometryMap[item]],
_speed, 0, true, true);
}
return true;
}
return false;
}
if(tie->getButton() == _secondaryButton
&& tie->getInteraction() == BUTTON_DOWN)
{
if(_activeItem)
{
selectItem(NULL);
}
SceneManager::instance()->getMenuRoot()->removeChild(_menuRoot);
if (!_showFavMenu)
{
SceneManager::instance()->getMenuRoot()->removeChild(_favMenuRoot);
}
_menuActive = false;
return true;
}
}
else
{
if(tie->getButton() == _primaryButton
&& (tie->getInteraction() == BUTTON_UP))
{
_timeLastButtonUp = PluginHelper::getProgramDuration();
_clickActive = false;
}
if(0)//_clickActive)
{
if(tie->getHand() == _activeHand)
{
if(tie->getButton() == _primaryButton)
{
_activeItem->processEvent(event);
if(tie->getInteraction() == BUTTON_UP)
{
_clickActive = false;
}
return true;
}
}
return false;
}
else if(tie->getHand() == _activeHand)
{
if (tie->getButton() == _primaryButton
&& (tie->getInteraction() == BUTTON_DOWN))
{
_timeLastButtonUp = PluginHelper::getProgramDuration();
_prevEvent = new InteractionEvent();
_prevEvent->setInteraction(event->getInteraction());
_prevActiveItem = _activeItem;
_clickActive = true;
if (_soundEnabled)
{
// click->play();
}
return true;
}
if(tie->getButton() == _primaryButton
&& tie->getInteraction() == BUTTON_DOUBLE_CLICK)
{
// do click
//std::cout << "Double click" << std::endl;
_prevEvent = NULL;
MenuItem * item = _activeItem->getMenuItem();
if (_favMenu->getItemPosition(item) < 0)
{
_favMenu->addItem(item);
}
else
{
_favMenu->removeItem(item);
osg::MatrixTransform * mat = _favMaskMap[_favGeometryMap[item]];
/*
_lerpMap[mat] = new Lerp(mat->getMatrix().getTrans(),
-_favMenuRoot->getMatrix().getTrans() +
_rootPositionMap[_favGeometryMap[item]] + osg::Vec3(0,0,_radius),
_speed, 0, true, true);
*/
if (mat)
{
osg::Matrix m = _favMenuRoot->getMatrix();
_lerpMap[mat] = new Lerp(mat->getMatrix().getTrans(),
- m.getTrans() - osg::Vec3(0, -m.getTrans()[1], 0)
+ osg::Vec3(0, 0, _height)
+ _rootPositionMap[_favGeometryMap[item]],
_speed, 0, true, true);
}
}
/*
if(_activeItem)
{
BubbleMenuSubMenuGeometry * smg =
dynamic_cast<BubbleMenuSubMenuGeometry *>(_activeItem);
if(smg && !smg->isMenuHead())
{
if(smg->isMenuOpen())
{
closeMenu((SubMenu*)smg->getMenuItem());
}
else
{
openMenu(smg);
}
}
_activeItem->processEvent(event);
_clickActive = true;
return true;
}*/
return true;
}
return false;
}
if(tie->getButton() == _secondaryButton
&& tie->getInteraction() == BUTTON_DOWN)
{
if(_activeItem)
{
selectItem(NULL);
}
SceneManager::instance()->getMenuRoot()->removeChild(_menuRoot);
if (!_showFavMenu)
{
SceneManager::instance()->getMenuRoot()->removeChild(_favMenuRoot);
}
_menuActive = false;
return true;
}
}
return false;
}
bool Sketch::processEvent(InteractionEvent * event)
{
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if(!tie)
{
return false;
}
if(tie->getHand() == 0 && tie->getButton() == 0)
{
if(_csCB->getValue())
{
if(_colorSelector->buttonEvent(tie->getInteraction(),
tie->getTransform()))
{
_color = _colorSelector->getColor();
if(_activeObject)
{
_activeObject->setColor(_color);
}
return true;
}
}
osg::Vec3 point(0,Sketch::instance()->getPointerDistance(),0);
point = point * TrackingManager::instance()->getHandMat(0);
osg::Vec3 distance;
if (!_freezeCB->getValue())
{
point = point * PluginHelper::getWorldToObjectTransform();
}
else
{
}
if (_snapToGridCB->getValue())
{
for (int i = 0; i < 3; ++i)
{
int diff = (int)floor(point[i]) % _gridSize;
point[i] -= diff;
}
distance = point - _lastPoint;
distance[0] = (int)distance[0];
distance[1] = (int)distance[1];
distance[2] = (int)distance[2];
}
else
{
distance = point - _lastPoint;
}
_lastPoint = point;
if (_mode == MOVE)
{
if (tie->getInteraction() == BUTTON_DOWN)
{
bool inSphere = false;
for (int i = 0; i < _shapeList.size(); ++i)
{
if (_shapeList[i]->containsPoint(_lastPoint))
{
_movingList.push_back(_shapeList[i]->getPat());
_movingLayout = false;
inSphere = true;
}
}
for (int i = 0; i < _layoutList.size(); ++i)
{
if (_layoutList[i]->shape->containsPoint(_lastPoint))
{
if (!inSphere)
{
_movingLayout = true;
_movingList.push_back(_layoutList[i]->getPat());
for (int j = 0; j < _layoutList[i]->children.size(); ++j)
{
_movingList.push_back(_layoutList[i]->children[j]);
}
}
}
}
return !_movingList.empty();
}
else if (tie->getInteraction() == BUTTON_DRAG)
{
for (int i = 0; i < _movingList.size(); ++i)
{
// remove child shapes that are dragged out of layouts
if (!_movingLayout)
{
for (int j = 0; j < _layoutList.size(); ++j)
{
_layoutList[j]->removeChild(_movingList[i]);
if (_layoutList[j]->shape->containsPoint(_lastPoint))
{
_layoutList[j]->shape->highlight();
_layoutList[j]->addChild(_movingList[i]);
}
}
}
_movingList[i]->setPosition(
_movingList[i]->getPosition() + distance);
_movingList[i]->dirtyBound();
}
return !_movingList.empty();
}
else if (tie->getInteraction() == BUTTON_UP)
{
_movingList.clear();
return false;
}
return true;
}
else if (_mode == DRAW && !_activeObject)
{
return false;
}
else if (_mode == DRAW && _activeObject)
{
bool ret = _activeObject->buttonEvent(tie->getInteraction(),
tie->getTransform());
if (tie->getInteraction() == BUTTON_DOWN)
{
if (_drawMode == SHAPE)
{
SketchShape * shape = dynamic_cast<SketchShape*>(_activeObject);
if (shape)
{
_sketchRoot->addChild(_pat);
_shapeList.push_back((SketchShape*)_activeObject);
shape->setSize(_sizeRV->getValue() * _sizeScale);
}
// add shape as child of layout if point in layout
for (int i = 0; i < _layoutList.size(); ++i)
{
if (_layoutList[i]->shape->containsPoint(point))
{
point = _layoutList[i]->addChild(_pat);
_lastPoint = point;
break;
}
}
_pat->setPosition(_lastPoint);
if (_modelCB->getValue())
{
_pat->addChild(getNextModel());
}
return true;
}
else if (_drawMode == LAYOUT)
{
SketchShape * shape = dynamic_cast<SketchShape*>(_activeObject);
if (shape)
{
Layout * lo;
switch (_st)
{
case 4:
lo = new Layout(_lot,
_layoutSizeRV->getValue() * _sizeScale * 1.5,
_layoutSizeRV->getValue() * _sizeScale * 0.5);
break;
case 5:
lo = new Layout(_lot,
_layoutSizeRV->getValue() * _sizeScale * 0.5,
_layoutSizeRV->getValue() * 1.5 * _sizeScale * 4);
break;
case 6:
lo = new Layout(_lot,
_layoutSizeRV->getValue() * _sizeScale * 0.5,
_layoutSizeRV->getValue() * 1.5 * _sizeScale * 4);
break;
}
lo->setPat(_layoutPat);
lo->setCenter(_lastPoint);
lo->setShape(shape);
_layoutList.push_back(lo);
_sketchRoot->addChild(_layoutPat);
_layoutPat->setPosition(_lastPoint);
}
return true;
}
if(_activeObject->isDone())
{
finishGeometry();
createGeometry();
}
}
else if (tie->getInteraction() == BUTTON_DRAG)
{
if(_drawMode == SHAPE)
{
bool inLayout = false;
for (int i = 0; i < _layoutList.size(); ++i)
{
if (_layoutList[i]->shape->containsPoint(point))
{
inLayout = true;
// point = _layoutList[i]->addChild(_pat);
break;
}
else
{
_layoutList[i]->removeChild(_pat);
}
}
if (!inLayout)
{
_pat->setPosition(_pat->getPosition() + distance);
_modelpat->setPosition(_modelpat->getPosition() + distance);
}
}
if (_drawMode == LAYOUT)
{
_layoutPat->setPosition(_layoutPat->getPosition() + distance);
_layoutList[_layoutList.size() - 1]->setCenter(
_layoutPat->getPosition() + distance);
}
}
else if (tie->getInteraction() == BUTTON_UP)
{
finishGeometry();
createGeometry();
}
return ret;
}
else if (_mode == SELECT || _mode == OPTIONS)
{
if (tie->getInteraction() == BUTTON_DOWN)
{
bool inNone = true;
bool alreadyIn = false;
bool inSphere = false;
for (int i = 0; i < _shapeList.size(); ++i)
{
if (_shapeList[i]->containsPoint(_lastPoint))
{
vector<osg::PositionAttitudeTransform*>::iterator it;
for (it = _movingList.begin(); it != _movingList.end(); ++it)
{
if (*it == _shapeList[i]->getPat())
{
_movingList.erase(it);
alreadyIn = true;
break;
}
}
if (!alreadyIn)
{
inSphere = true;
_movingList.push_back(_shapeList[i]->getPat());
}
inNone = false;
}
}
for (int i = 0; i < _layoutList.size(); ++i)
{
if (_layoutList[i]->shape->containsPoint(_lastPoint))
{
if (!inSphere)
{
inNone = false;
_movingList.push_back(_layoutList[i]->getPat());
}
}
}
if (inNone)
{
_movingList.clear();
return false;
}
}
else if (tie->getInteraction() == BUTTON_DRAG)
{
return false;
}
else if (tie->getInteraction() == BUTTON_UP)
{
return false;
}
}
return true;
}
return false;
}
bool SceneObject::processEvent(InteractionEvent * ie)
{
TrackedButtonInteractionEvent * tie = ie->asTrackedButtonEvent();
if(tie)
{
if(_eventActive && _activeHand != tie->getHand())
{
return false;
}
if(_movable && tie->getButton() == _moveButton)
{
if(tie->getInteraction() == BUTTON_DOWN)
{
_lastHandInv = osg::Matrix::inverse(tie->getTransform());
_lastHandMat = tie->getTransform();
_lastobj2world = getObjectToWorldMatrix();
_eventActive = true;
_moving = true;
_activeHand = tie->getHand();
return true;
}
else if(_moving
&& (tie->getInteraction() == BUTTON_DRAG
|| tie->getInteraction() == BUTTON_UP))
{
processMove(tie->getTransform());
if(tie->getInteraction() == BUTTON_UP)
{
_eventActive = false;
_moving = false;
_activeHand = -2;
}
return true;
}
}
if(_contextMenu && tie->getButton() == _menuButton)
{
if(tie->getInteraction() == BUTTON_DOWN)
{
if(!_myMenu->isVisible())
{
_myMenu->setVisible(true);
osg::Vec3 start(0,0,0), end(0,1000,0);
start = start * tie->getTransform();
end = end * tie->getTransform();
osg::Vec3 p1, p2;
bool n1, n2;
float dist = 0;
if(intersects(start,end,p1,n1,p2,n2))
{
float d1 = (p1 - start).length();
if(n1)
{
d1 = -d1;
}
float d2 = (p2 - start).length();
if(n2)
{
d2 = -d2;
}
if(n1)
{
dist = d2;
}
else if(n2)
{
dist = d1;
}
else
{
if(d1 < d2)
{
dist = d1;
}
else
{
dist = d2;
}
}
}
dist = std::min(dist,
SceneManager::instance()->_menuMaxDistance);
dist = std::max(dist,
SceneManager::instance()->_menuMinDistance);
osg::Vec3 menuPoint(0,dist,0);
menuPoint = menuPoint * tie->getTransform();
osg::Vec3 viewerPoint =
TrackingManager::instance()->getHeadMat(0).getTrans();
osg::Vec3 viewerDir = viewerPoint - menuPoint;
viewerDir.z() = 0.0;
osg::Matrix menuRot;
// point towards viewer if not on tiled wall
if(!ie->asPointerEvent())
{
menuRot.makeRotate(osg::Vec3(0,-1,0),viewerDir);
}
osg::Matrix m;
m.makeTranslate(menuPoint);
_myMenu->setTransform(menuRot * m);
_myMenu->setScale(SceneManager::instance()->_menuScale);
SceneManager::instance()->setMenuOpenObject(this);
}
else
{
SceneManager::instance()->closeOpenObjectMenu();
}
return true;
}
}
//TODO: replace button down/up active check with mask of buttons to
// handle multiple buttons down
//bool retValue;
//retValue = eventCallback(tie->getIntera, tie->hand, tie->button, transform);
/*if(retValue && tie->type == BUTTON_DOWN)
{
_activeButton = tie->button;
_eventActive = true;
_activeHand = tie->hand;
}
else if(tie->type == BUTTON_UP && tie->button == _activeButton)
{
_eventActive = false;
_activeHand = -2;
}*/
//return retValue;
}
bool ret = eventCallback(ie);
if(ret)
{
return true;
}
else
{
if(_parent)
{
return _parent->processEvent(ie);
}
else
{
return false;
}
}
}
bool Sketch::processEvent(InteractionEvent * event)
{
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if(!tie)
{
return false;
}
if(tie->getHand() == 0 && tie->getButton() == 0)
{
if(_csCB->getValue())
{
if(_colorSelector->buttonEvent(tie->getInteraction(), tie->getTransform()))
{
_color = _colorSelector->getColor();
if(_activeObject)
{
_activeObject->setColor(_color);
}
return true;
}
}
if(_activeObject)
{
bool ret = _activeObject->buttonEvent(tie->getInteraction(), tie->getTransform());
if(_activeObject->isDone())
{
finishGeometry();
createGeometry();
}
return ret;
}
}
/*if(hand == 0 && button == 0 && type == BUTTON_DOWN && _mode >= 0)
{
//std::cerr << "Start drawing." << std::endl;
if(_mode == RIBBON)
{
_verts = new Vec3Array(0);
_colors = new Vec4Array(1);
_normals = new Vec3Array(0);
_primitive = new DrawArrays(PrimitiveSet::TRIANGLE_STRIP, 0, 0);
_currentGeometry = new osg::Geometry();
(*_colors)[0] = _color;
_currentGeometry->setVertexArray(_verts);
_currentGeometry->setColorArray(_colors);
_currentGeometry->setNormalArray(_normals);
_currentGeometry->setNormalBinding(Geometry::BIND_PER_VERTEX);
_currentGeometry->setColorBinding(Geometry::BIND_OVERALL);
_currentGeometry->setUseDisplayList(false);
//_currentGeometry->setUseVertexBufferObjects(true);
_currentGeometry->addPrimitiveSet(_primitive);
_sketchGeode->addDrawable(_currentGeometry);
MyComputeBounds * mcb = new MyComputeBounds();
_currentBound = &mcb->_bound;
_currentGeometry->setComputeBoundingBoxCallback(mcb);
osg::Vec3 point(-50.0 * _sizeRV->getValue(), _pointerDistance, 0);
point = point * mat * PluginHelper::getWorldToObjectTransform();
_verts->push_back(point);
_normals->push_back(osg::Vec3(0,0,1));
_currentBound->expandBy(point);
point = osg::Vec3(50.0 * _sizeRV->getValue(), _pointerDistance, 0);
point = point * mat * PluginHelper::getWorldToObjectTransform();
_verts->push_back(point);
_normals->push_back(osg::Vec3(0,0,1));
_currentBound->expandBy(point);
_lastTransform = mat * PluginHelper::getWorldToObjectTransform();
_count = 2;
_primitive->setCount(_count);
_currentGeometry->dirtyBound();
_drawing = true;
}
else if(_mode == LINE)
{
if(_lt == LINE_NONE)
{
//std::cerr << "LINE_NONE" << std::endl;
return false;
}
if(!_drawing)
{
//std::cerr << "Starting Line." << std::endl;
_verts = new Vec3Array(0);
_colors = new Vec4Array(1);
_primitive = new DrawArrays(PrimitiveSet::LINE_STRIP, 0, 0);
_currentGeometry = new osg::Geometry();
(*_colors)[0] = _color;
_currentGeometry->setVertexArray(_verts);
_currentGeometry->setColorArray(_colors);
_currentGeometry->setColorBinding(Geometry::BIND_OVERALL);
_currentGeometry->setUseDisplayList(false);
//_currentGeometry->setUseVertexBufferObjects(true);
_currentGeometry->addPrimitiveSet(_primitive);
_sketchGeode->addDrawable(_currentGeometry);
MyComputeBounds * mcb = new MyComputeBounds();
_currentBound = &mcb->_bound;
_currentGeometry->setComputeBoundingBoxCallback(mcb);
osg::Vec3 point;
if(_lineSnap->getValue())
{
point = _brushRoot->getMatrix().getTrans();
}
else
{
point = osg::Vec3(0, _pointerDistance, 0);
point = point * mat;
}
point = point * PluginHelper::getWorldToObjectTransform();
_verts->push_back(point);
_currentBound->expandBy(point);
_count = 1;
if(_lt == SEGMENT || _lt == MULTI_SEGMENT)
{
_verts->push_back(point);
_count = 2;
_updateLastPoint = true;
}
_primitive->setCount(_count);
_currentGeometry->dirtyBound();
osg::StateSet * stateset = _currentGeometry->getOrCreateStateSet();
stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
osg::LineWidth * lw = new osg::LineWidth();
lw->setWidth(_sizeRV->getValue());
stateset->setAttributeAndModes(lw,osg::StateAttribute::ON);
//TODO: tube shader?
_drawing = true;
}
else if(_lt == MULTI_SEGMENT)
{
osg::Vec3 point;
if(_lineSnap->getValue())
{
point = _brushRoot->getMatrix().getTrans();
}
else
{
point = osg::Vec3(0, _pointerDistance, 0);
point = point * mat;
}
point = point * PluginHelper::getWorldToObjectTransform();
_verts->push_back(point);
_currentBound->expandBy(point);
_count++;
_primitive->setCount(_count);
_currentGeometry->dirtyBound();
_updateLastPoint = true;
}
}
return true;
}
else if(hand == 0 && button == 0 && type == BUTTON_UP && _drawing)
{
//std::cerr << "Stop drawing." << std::endl;
if(_mode == RIBBON || (_mode == LINE && (_lt == SEGMENT || _lt == FREEHAND)))
{
//std::cerr << "Finish geometry" << std::endl;
finishGeometry();
}
if(_mode == LINE && (_lt == SEGMENT || _lt == MULTI_SEGMENT))
{
_updateLastPoint = false;
}
return true;
}
else if(hand == 0 && button == 0 && type == BUTTON_DRAG && _drawing)
{
if(_mode == RIBBON)
{
osg::Vec3 lastpoint1(-50.0 * _sizeRV->getValue(), _pointerDistance, 0), lastpoint2(50.0 * _sizeRV->getValue(), _pointerDistance, 0), newpoint1(-50.0 * _sizeRV->getValue(), _pointerDistance, 0), newpoint2(50.0 * _sizeRV->getValue(), _pointerDistance, 0);
lastpoint1 = lastpoint1 * _lastTransform;
lastpoint2 = lastpoint2 * _lastTransform;
newpoint1 = newpoint1 * mat * PluginHelper::getWorldToObjectTransform();
newpoint2 = newpoint2 * mat * PluginHelper::getWorldToObjectTransform();
if((newpoint1 - lastpoint1).length2() > 10.0 || (newpoint2 - lastpoint2).length2() > 10.0)
{
_verts->push_back(newpoint1);
_verts->push_back(newpoint2);
osg::Vec3 v1, v2, normal1, normal2, normala;
v1 = newpoint1 - (*_verts)[_count-2];
v1.normalize();
v2 = (*_verts)[_count-1] - (*_verts)[_count-2];
v2.normalize();
normal1 = v1 ^ v2;
normal1.normalize();
v1 = (*_verts)[_count-1] - newpoint2;
v1.normalize();
v2 = newpoint1 - newpoint2;
v2.normalize();
normal2 = v1 ^ v2;
normal2.normalize();
//normal1 = osg::Vec3(normal1.x(),-normal1.z(),normal1.y());
//normal2 = osg::Vec3(normal2.x(),-normal2.z(),normal2.y());
normala = (normal1 + normal2) / 2.0;
normala.normalize();
//_normals->push_back(osg::Vec3(0,0,1));
//_normals->push_back(osg::Vec3(0,0,1));
_normals->push_back(normala);
_normals->push_back(normal2);
if(_count == 2)
{
(*_normals)[0] = normal1;
(*_normals)[1] = normala;
}
else
{
(*_normals)[_count-2] = ((*_normals)[_count-2] + normal1) / 2.0;
(*_normals)[_count-2].normalize();
(*_normals)[_count-1] = ((*_normals)[_count-1] + normala) / 2.0;
(*_normals)[_count-1].normalize();
}
_count += 2;
_lastTransform = mat * PluginHelper::getWorldToObjectTransform();
_primitive->setCount(_count);
_currentBound->expandBy(newpoint1);
_currentBound->expandBy(newpoint2);
_currentGeometry->dirtyBound();
//std::cerr << "Count: " << _count << std::endl;
}
}
if(_mode == LINE)
{
//std::cerr << "Line update" << std::endl;
osg::Vec3 point;
if(_lineSnap->getValue())
{
point = _brushRoot->getMatrix().getTrans();
}
else
{
point = osg::Vec3(0, _pointerDistance, 0);
point = point * mat;
}
point = point * PluginHelper::getWorldToObjectTransform();
if(_lt == FREEHAND)
{
_verts->push_back(point);
_count++;
_primitive->setCount(_count);
}
else if(_updateLastPoint)
{
//std::cerr << "Changing last point" << std::endl;
//std::cerr << "Point x: " << point.x() << " y: " << point.y() << " z: " << point.z() << std::endl;
(*_verts)[_count-1] = point;
}
_currentBound->expandBy(point);
_currentGeometry->dirtyBound();
//std::cerr << "Count: " << _count << std::endl;
}
return true;
}*/
return false;
}
bool FPTiledWallSceneObject::processEvent(InteractionEvent * ie)
{
if(!_tiledWallMovement)
{
return SceneObject::processEvent(ie);
}
TrackedButtonInteractionEvent * tie = ie->asTrackedButtonEvent();
if(tie)
{
if(_eventActive && _activeHand != tie->getHand())
{
return false;
}
if(_movable && tie->getButton() == _moveButton)
{
//sort of a hack, need to find a better way to disable navigation for this object type
if(getNavigationOn())
{
setNavigationOn(false);
}
if(tie->getInteraction() == BUTTON_DOWN || (_moving
&& (tie->getInteraction() == BUTTON_DRAG
|| tie->getInteraction() == BUTTON_UP)))
{
if(tie->getInteraction() == BUTTON_DOWN)
{
osg::Vec3 lineP1,lineP2(0,1000.0,0),planePoint,planeNormal(0,-1,0);
float w;
lineP1 = lineP1 * tie->getTransform() * getWorldToObjectMatrix();
lineP2 = lineP2 * tie->getTransform() * getWorldToObjectMatrix();
linePlaneIntersectionRef(lineP1,lineP2,planePoint,planeNormal,_movePoint,w);
_eventActive = true;
_moving = true;
_activeHand = tie->getHand();
return true;
}
if(!_moving)
{
return false;
}
// top level
if(!_parent)
{
osg::Vec3 wallPoint;
if(SceneManager::instance()->getPointOnTiledWall(tie->getTransform(),wallPoint))
{
osg::Vec3 soPoint = _movePoint * getObjectToWorldMatrix();
osg::Matrix m;
m.makeTranslate(wallPoint - soPoint);
setTransform(getTransform() * m);
}
}
else
{
osg::Vec3 lineP1,lineP2(0,1000.0,0),planePoint,planeNormal(0,-1,0),intersect;
float w;
lineP1 = lineP1 * tie->getTransform() * _parent->getWorldToObjectMatrix();
lineP2 = lineP2 * tie->getTransform() * _parent->getWorldToObjectMatrix();
if(linePlaneIntersectionRef(lineP1,lineP2,planePoint,planeNormal,intersect,w))
{
osg::Vec3 soPoint = _movePoint * getTransform();
osg::Matrix m;
m.makeTranslate(intersect - soPoint);
setTransform(getTransform() * m);
}
}
if(tie->getInteraction() == BUTTON_UP)
{
_eventActive = false;
_moving = false;
_activeHand = -2;
}
return true;
}
}
}
return SceneObject::processEvent(ie);
}
void TrackingManager::generateButtonEvents()
{
int numEvents;
TrackedButtonInteractionEvent * events = NULL;
if(ComController::instance()->isMaster())
{
std::vector<TrackedButtonInteractionEvent*> eventList;
for(int j = 0; j < _numHands; j++)
{
unsigned int bit = 1;
unsigned int newMask = getHandButtonMask(j);
//std::cerr << "ButtonMask: " << newMask << std::endl;
for(int i = 0; i < _genHandDefaultButtonEvents[j].size(); i++)
{
if(!_genHandDefaultButtonEvents[j][i])
{
bit = bit << 1;
continue;
}
//std::cerr << "last mask " << _lastButtonMask << " new mask " << newMask << " bit: " << bit << " " << (newMask & bit) << " " << (_lastButtonMask & bit) << std::endl;
if(((_lastHandButtonMask[j] & bit) != (newMask & bit))
|| ((_lastHandButtonMask[j] & bit) && (newMask & bit)))
{
//std::cerr << "last mask " << _lastButtonMask << " new mask " << newMask << std::endl;
TrackedButtonInteractionEvent * buttonEvent =
new TrackedButtonInteractionEvent();
if((_lastHandButtonMask[j] & bit) && (newMask & bit))
{
buttonEvent->setInteraction(BUTTON_DRAG);
}
else if(_lastHandButtonMask[j] & bit)
{
buttonEvent->setInteraction(BUTTON_UP);
}
else
{
buttonEvent->setInteraction(BUTTON_DOWN);
}
buttonEvent->setButton(i);
// set current pointer info
buttonEvent->setTransform(_handMatList[j]);
buttonEvent->setHand(j);
eventList.push_back(buttonEvent);
}
bit = bit << 1;
}
_lastHandButtonMask[j] = newMask;
}
numEvents = eventList.size();
ComController::instance()->sendSlaves(&numEvents,sizeof(int));
if(numEvents)
{
events = new TrackedButtonInteractionEvent[numEvents];
for(int i = 0; i < numEvents; i++)
{
events[i] = *eventList[i];
delete eventList[i];
}
ComController::instance()->sendSlaves(events,
numEvents * sizeof(TrackedButtonInteractionEvent));
}
}
else
{
ComController::instance()->readMaster(&numEvents,sizeof(int));
if(numEvents)
{
events = new TrackedButtonInteractionEvent[numEvents];
ComController::instance()->readMaster(events,
numEvents * sizeof(TrackedButtonInteractionEvent));
}
}
TrackedButtonInteractionEvent * ie;
for(int i = 0; i < numEvents; i++)
{
ie = new TrackedButtonInteractionEvent();
*ie = events[i];
InteractionManager::instance()->addEvent(ie);
}
if(events)
{
delete[] events;
}
}
bool WaterMaze::processEvent(InteractionEvent * event)
{
KeyboardInteractionEvent * kie = event->asKeyboardEvent();
if (kie)
{
if (kie->getInteraction() == KEY_UP && kie->getKey() == 'n')
{
// next trial
if (_runningTrial)
{
return true;
}
if (_currentTrial == _trials.size() - 1)
{
std::cout << "No more trials." << std::endl;
return true;
}
_currentTrial++;
std::cout << "Loading next trial." << std::endl;
std::cout << _trials[_currentTrial].width << " x " <<
_trials[_currentTrial].height << ", " << _trials[_currentTrial].timeSec
<< " seconds." << std::endl;
clear();
load(_trials[_currentTrial].width, _trials[_currentTrial].height);
return true;
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == 'r')
{
// repeat last trial
if (_runningTrial)
{
return true;
}
std::cout << "Repeating last trial." << std::endl;
std::cout << _trials[_currentTrial].width << " x " <<
_trials[_currentTrial].height << ", " << _trials[_currentTrial].timeSec
<< " seconds." << std::endl;
return true;
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == 'b')
{
// back to previous trial
if (_runningTrial)
{
return true;
}
if (_currentTrial - 1 < 0)
{
std::cout << "No previous trials." << std::endl;
return true;
}
_currentTrial--;
std::cout << "Back to previous trial." << std::endl;
std::cout << _trials[_currentTrial].width << " x " <<
_trials[_currentTrial].height << ", " << _trials[_currentTrial].timeSec
<< " seconds." << std::endl;
clear();
load(_trials[_currentTrial].width, _trials[_currentTrial].height);
return true;
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == 'p')
{
// pause/play
if (_runningTrial)
{
std::cout << "Paused." << std::endl;
_runningTrial = false;
}
else
{
std::cout << "Play." << std::endl;
_runningTrial = true;
if (_resetTime)
{
_startTime = PluginHelper::getProgramDuration();
_resetTime = false;
_lastTimeLeft = _trials[_currentTrial].timeSec;
// Setup write to data file
time_t timet;
time(&timet);
char buf[100];
sprintf(buf, "/Logs/%dx%d-%dsec-%ld.txt", _trials[_currentTrial].width,
_trials[_currentTrial].height, _trials[_currentTrial].timeSec, timet);
_dataFile = _dataDir + buf;
std::cout << "Recording trial to" << _dataFile << std::endl;
_fileTimer = PluginHelper::getProgramDuration();
}
}
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == 's')
{
// start/stop
if (_runningTrial)
{
std::cout << "Stopping trial." << std::endl;
_runningTrial = false;
_resetTime = true;
}
else
{
std::cout << "Starting trial." << std::endl;
_runningTrial = true;
}
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == 'l')
{
std::cout << "Loading geometry." << std::endl;
load(_trials[_currentTrial].width, _trials[_currentTrial].height);
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == 'h')
{
std::cout << "Welcome to WaterMaze!\n" <<
"l - load geometry\n" <<
"n - next trial\n" <<
"r - repeat trial\n" <<
"b - back to previous trial\n" <<
"p - play/pause\n" <<
"h - help\n" <<
"1-9 - reset position" << std::endl;
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == '1')
{
if (_runningTrial)
{
return true;
}
osg::Matrixd mat;
mat = _tilePositions[0]->getMatrix();
PluginHelper::setObjectMatrix(mat);
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == '2')
{
if (_runningTrial)
{
return true;
}
osg::Matrixd mat;
mat = _tilePositions[1]->getMatrix();
PluginHelper::setObjectMatrix(mat);
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == '3')
{
if (_runningTrial)
{
return true;
}
osg::Matrixd mat;
mat = _tilePositions[2]->getMatrix();
PluginHelper::setObjectMatrix(mat);
}
else if (kie->getInteraction() == KEY_UP && kie->getKey() == '4')
{
if (_runningTrial)
{
return true;
}
osg::Matrixd mat;
mat = _tilePositions[3]->getMatrix();
PluginHelper::setObjectMatrix(mat);
}
}
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if (tie)
{
return false;
if(tie->getHand() == 0 && tie->getButton() == 0)
{
if (tie->getInteraction() == BUTTON_DOWN)
{
return true;
}
else if (tie->getInteraction() == BUTTON_DRAG)
{
return true;
}
else if (tie->getInteraction() == BUTTON_UP)
{
return true;
}
return true;
}
}
return true;
}
void BoardMenuListGeometry::processEvent(InteractionEvent * event)
{
if(event->getInteraction() == BUTTON_UP)
{
_geodeSelected->removeDrawables(0,_geodeSelected->getNumDrawables());
_geodeSelected->addDrawable(_valuesSelected[_listItem->getFocus()]);
_clicked = false;
_listItem->setDirty(true);
}
if(event->asMouseEvent())
{
MouseInteractionEvent * mie = event->asMouseEvent();
if(event->getInteraction() == BUTTON_DOWN
|| event->getInteraction() == BUTTON_DOUBLE_CLICK)
{
int y = mie->getY();
_lastMouseY = y;
_clicked = true;
_listItem->setDirty(true);
return;
}
if(event->getInteraction() == BUTTON_DRAG
|| event->getInteraction() == BUTTON_UP)
{
int y = mie->getY();
float pixelRange = 400;
bool valueUpdated = false;
int valueMax = _listItem->getListSize();
int index = _listItem->getIndex();
if(y != _lastMouseY)
{
int change = (int)((y - _lastMouseY)
* _listItem->getSensitivity() / pixelRange);
if(change)
{
index -= change;
if(index > valueMax)
index = valueMax;
else if(index < 0)
index = 0;
_listItem->setIndex(index);
valueUpdated = true;
}
}
if(valueUpdated)
{
if(_listItem->getCallback())
{
_listItem->getCallback()->menuCallback(_item);
}
_lastMouseY = y;
}
return;
}
}
else if(event->asTrackedButtonEvent())
{
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if(event->getInteraction() == BUTTON_DOWN
|| event->getInteraction() == BUTTON_DOUBLE_CLICK)
{
_point = tie->getTransform().getTrans();
_lastDistance = 0.0;
_clicked = true;
_listItem->setDirty(true);
return;
}
if(event->getInteraction() == BUTTON_DRAG
|| event->getInteraction() == BUTTON_UP)
{
MenuList * _listItem = (MenuList*)_item;
osg::Vec3 vec = tie->getTransform().getTrans();
;
vec = vec - _point;
float newDistance = vec.z();
float range = 400;
bool valueUpdated = false;
int valueMax = _listItem->getListSize();
int index = _listItem->getIndex();
if(newDistance != _lastDistance)
{
int change = (int)((newDistance - _lastDistance)
* _listItem->getSensitivity() / range);
if(change)
{
index -= change;
if(index > valueMax)
index = valueMax;
else if(index < 0)
index = 0;
_listItem->setIndex(index);
valueUpdated = true;
}
}
if(valueUpdated)
{
if(_listItem->getCallback())
{
_listItem->getCallback()->menuCallback(_item);
}
_lastDistance = newDistance;
}
return;
}
}
}
bool BoardPopupMenu::processEvent(InteractionEvent * event)
{
if(!_menuActive || !_myMenu || !event->asTrackedButtonEvent())
{
return false;
}
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if(_clickActive)
{
if(tie->getHand() == _activeHand)
{
if(tie->getInteraction() == BUTTON_DRAG
|| tie->getInteraction() == BUTTON_UP)
{
if(tie->getButton() == _primaryButton)
{
BoardMenuSubMenuGeometry * smg =
dynamic_cast<BoardMenuSubMenuGeometry *>(_activeItem);
if(smg && smg->isMenuHead())
{
updateMovement(tie);
}
_activeItem->processEvent(event);
if(tie->getInteraction() == BUTTON_UP)
{
_clickActive = false;
}
return true;
}
}
}
return false;
}
else if(tie->getHand() == _activeHand && tie->getButton() == _primaryButton)
{
if(tie->getInteraction() == BUTTON_DOWN
|| tie->getInteraction() == BUTTON_DOUBLE_CLICK)
{
if(_activeItem)
{
BoardMenuSubMenuGeometry * smg =
dynamic_cast<BoardMenuSubMenuGeometry *>(_activeItem);
if(smg && smg->isMenuHead())
{
osg::Vec3 ray;
ray = _currentPoint[tie->getHand()]
- tie->getTransform().getTrans();
if(!tie->asPointerEvent())
{
_moveDistance = ray.length();
}
else
{
_moveDistance = ray.y();
}
_menuPoint = _currentPoint[tie->getHand()]
* osg::Matrix::inverse(_menuRoot->getMatrix());
updateMovement(tie);
}
else if(smg && !smg->isMenuHead())
{
if(smg->isMenuOpen())
{
closeMenu((SubMenu*)smg->getMenuItem());
}
else
{
openMenu(smg);
}
}
_clickActive = true;
_activeItem->processEvent(event);
return true;
}
return false;
}
}
return false;
}
void TrackerMouse::update(
std::map<int,std::list<InteractionEvent*> > & eventMap)
{
if(!_handListInit)
{
if(_debug)
{
std::cerr << "TrackerMouse: hand list init:" << std::endl;
}
int mySystem = -1;
for(int i = 0; i < TrackingManager::instance()->getNumTrackingSystems(); i++)
{
if(TrackingManager::instance()->getTrackingSystem(i) == this)
{
mySystem = i;
break;
}
}
if(mySystem < 0)
{
std::cerr << "TrackerMouse: Error: Unable to find own system in list" << std::endl;
}
else
{
if(_debug)
{
std::cerr << "Mouse system: " << mySystem << std::endl;
for(int i = 0; i < TrackingManager::instance()->getNumHands(); i++)
{
std::cerr << "Hand: " << i << " buttonFilter: " << TrackingManager::instance()->getButtonFilter(i,mySystem) << std::endl;
}
}
int bhand, bbutton;
for(int i = 0; i < CVR_NUM_MOUSE_BUTTONS; i++)
{
TrackingManager::instance()->getHandButtonFromSystemButton(mySystem,i,bhand,bbutton);
_handButtonList.push_back(std::pair<int,int>(bhand,bbutton));
}
for(int i = 0; i < _handButtonList.size(); i++)
{
if(_handButtonList[i].first < 0)
{
_handValidList.push_back(false);
continue;
}
int hsystem, hindex;
TrackingManager::instance()->getHandAddress(_handButtonList[i].first,hsystem,hindex);
if(hsystem < 0 || hindex < 0)
{
_handValidList.push_back(false);
continue;
}
if(hsystem >= 0 && hsystem < TrackingManager::instance()->getNumTrackingSystems() && TrackingManager::instance()->getTrackingSystem(hsystem) && hindex >= 0 && hindex < TrackingManager::instance()->getNumBodies(hsystem))
{
_handValidList.push_back(true);
}
else
{
_handValidList.push_back(false);
}
}
if(_debug)
{
for(int i = 0; i < _handButtonList.size(); i++)
{
std::cerr << "Button: " << i << " hand: " << _handButtonList[i].first << " handButton: " << _handButtonList[i].second << " valid: " << _handValidList[i] << std::endl;
}
}
}
_handListInit = true;
}
osg::Matrix m = InteractionManager::instance()->getMouseMat();
osg::Vec3 pos = m.getTrans();
osg::Quat rot = m.getRotate();
_mouseBody.x = pos.x();
_mouseBody.y = pos.y();
_mouseBody.z = pos.z();
_mouseBody.qx = rot.x();
_mouseBody.qy = rot.y();
_mouseBody.qz = rot.z();
_mouseBody.qw = rot.w();
_mouseButtonMask = InteractionManager::instance()->getMouseButtonMask();
int mouseWheel = InteractionManager::instance()->getMouseWheel();
if(mouseWheel > 0)
{
_mouseValuator = 1.0;
}
else if(mouseWheel < 0)
{
_mouseValuator = -1.0;
}
else
{
_mouseValuator = 0.0;
}
if(!_handButtonList.size())
{
return;
}
std::queue<InteractionEvent *,std::list<InteractionEvent *> > tempQueue;
//std::cerr << "Mouse queue size: " << InteractionManager::instance()->_mouseQueue.size() << std::endl;
while(InteractionManager::instance()->_mouseQueue.size())
{
MouseInteractionEvent * mie = dynamic_cast<MouseInteractionEvent*>(InteractionManager::instance()->_mouseQueue.front());
if(!mie)
{
tempQueue.push(InteractionManager::instance()->_mouseQueue.front());
InteractionManager::instance()->_mouseQueue.pop();
continue;
}
InteractionManager::instance()->_mouseQueue.pop();
if(mie->getButton() < 0 || mie->getButton() >= _handButtonList.size() || !_handValidList[mie->getButton()])
{
tempQueue.push(mie);
continue;
}
InteractionEvent * event;
if(TrackingManager::instance()->getHandTrackerType(_handButtonList[mie->getButton()].first) == TrackerBase::MOUSE)
{
mie->setHand(_handButtonList[mie->getButton()].first);
mie->setButton(_handButtonList[mie->getButton()].second);
event = mie;
}
else
{
TrackedButtonInteractionEvent * tie = new TrackedButtonInteractionEvent;
tie->setInteraction(mie->getInteraction());
tie->setHand(_handButtonList[mie->getButton()].first);
tie->setButton(_handButtonList[mie->getButton()].second);
int hsystem, hindex;
TrackingManager::instance()->getHandAddress(_handButtonList[mie->getButton()].first,hsystem,hindex);
if(TrackingManager::instance()->getTrackingSystem(hsystem))
{
TrackerBase::TrackedBody * body = TrackingManager::instance()->getTrackingSystem(hsystem)->getBody(hindex);
tie->setTransform(TrackingManager::instance()->getHandTransformFromTrackedBody(_handButtonList[mie->getButton()].first,body));
}
delete mie;
event = tie;
}
eventMap[event->getEventType()].push_back(event);
}
// put unusable events back in the mouse interaction queue so they will be cleaned up later
while(tempQueue.size())
{
InteractionManager::instance()->_mouseQueue.push(tempQueue.front());
tempQueue.pop();
}
}
void BubbleMenuRangeValueCompactGeometry::processEvent(InteractionEvent * event)
{
if(event->asMouseEvent())
{
MouseInteractionEvent * mie = event->asMouseEvent();
if(event->getInteraction() == BUTTON_DOWN
|| event->getInteraction() == BUTTON_DOUBLE_CLICK)
{
int x, y;
x = mie->getX();
y = mie->getY();
_lastMouseX = x;
_lastMouseY = y;
return;
}
if(event->getInteraction() == BUTTON_DRAG
|| event->getInteraction() == BUTTON_UP)
{
int x, y;
x = mie->getX();
y = mie->getY();
MenuRangeValueCompact * mrv = (MenuRangeValueCompact*)_item;
float min, max, current;
if(mrv->getIsLog())
{
min = log(mrv->getMin()) / log(mrv->getLogBase());
max = log(mrv->getMax()) / log(mrv->getLogBase());
current = log(mrv->getValue()) / log(mrv->getLogBase());
}
else
{
min = mrv->getMin();
max = mrv->getMax();
current = mrv->getValue();
}
float pixelRange = 800;
bool valueUpdated = false;
if(x > _lastMouseX)
{
if(mrv->getValue() != mrv->getMax())
{
float change = (x - _lastMouseX) * (max - min) / pixelRange;
float newValue;
if(mrv->getIsLog())
{
newValue = pow(mrv->getLogBase(),current + change);
newValue = std::max(newValue,mrv->getMin());
}
else
{
newValue = std::max(mrv->getValue() + change,
mrv->getMin());
}
mrv->setValue(newValue);
valueUpdated = true;
}
}
else if(x < _lastMouseX)
{
if(mrv->getValue() != mrv->getMin())
{
float change = (x - _lastMouseX) * (max - min) / pixelRange;
float newValue;
if(mrv->getIsLog())
{
newValue = pow(mrv->getLogBase(),current + change);
newValue = std::min(newValue,mrv->getMax());
}
else
{
newValue = std::min(mrv->getValue() + change,
mrv->getMax());
}
mrv->setValue(newValue);
valueUpdated = true;
}
}
if(valueUpdated)
{
if(mrv->getCallback())
{
mrv->getCallback()->menuCallback(_item);
}
}
_lastMouseY = y;
_lastMouseX = x;
return;
}
}
else if(event->asTrackedButtonEvent())
{
TrackedButtonInteractionEvent * tie = event->asTrackedButtonEvent();
if(event->getInteraction() == BUTTON_DOWN
|| event->getInteraction() == BUTTON_DOUBLE_CLICK)
{
_point = tie->getTransform().getTrans();
osg::Vec3 forward = osg::Vec3(0,1.0,0) * tie->getTransform();
forward = forward - _point;
_normal = forward ^ osg::Vec3(0,0,1.0);
_normal.normalize();
_lastDistance = 0.0;
return;
}
if(event->getInteraction() == BUTTON_DRAG
|| event->getInteraction() == BUTTON_UP)
{
MenuRangeValueCompact * mrv = (MenuRangeValueCompact*)_item;
float min, max, current;
if(mrv->getIsLog())
{
min = log(mrv->getMin()) / log(mrv->getLogBase());
max = log(mrv->getMax()) / log(mrv->getLogBase());
current = log(mrv->getValue()) / log(mrv->getLogBase());
}
else
{
min = mrv->getMin();
max = mrv->getMax();
current = mrv->getValue();
}
osg::Vec3 vec = tie->getTransform().getTrans();
vec = vec - _point;
float newDistance = vec * _normal;
float range = 1000;
bool valueUpdated = false;
if(newDistance < _lastDistance)
{
if(mrv->getValue() != mrv->getMin())
{
float change = (newDistance - _lastDistance) * (max - min)
/ range;
float newValue;
if(mrv->getIsLog())
{
newValue = pow(mrv->getLogBase(),current + change);
newValue = std::max(newValue,mrv->getMin());
}
else
{
newValue = std::max(mrv->getValue() + change,
mrv->getMin());
}
mrv->setValue(newValue);
valueUpdated = true;
}
}
else if(newDistance > _lastDistance)
{
if(mrv->getValue() != mrv->getMax())
{
float change = (newDistance - _lastDistance) * (max - min)
/ range;
float newValue;
if(mrv->getIsLog())
{
newValue = pow(mrv->getLogBase(),current + change);
newValue = std::min(newValue,mrv->getMax());
}
else
{
newValue = std::min(mrv->getValue() + change,
mrv->getMax());
}
mrv->setValue(newValue);
valueUpdated = true;
}
}
if(valueUpdated)
{
if(mrv->getCallback())
{
mrv->getCallback()->menuCallback(_item);
}
}
_lastDistance = newDistance;
return;
}
}
}
void TrackingManager::generateThreadButtonEvents()
{
TrackedButtonInteractionEvent * buttonEvent;
for(int j = 0; j < _numHands; j++)
{
unsigned int bit = 1;
unsigned int newMask = _threadHandButtonMasks[j];
//std::cerr << "ButtonMask: " << newMask << std::endl;
for(int i = 0; i < _genHandDefaultButtonEvents[j].size(); i++)
{
if(!_genHandDefaultButtonEvents[j][i])
{
bit = bit << 1;
continue;
}
//std::cerr << "last mask " << _lastButtonMask << " new mask " << newMask << " bit: " << bit << " " << (newMask & bit) << " " << (_lastButtonMask & bit) << std::endl;
if((_threadLastHandButtonMask[j] & bit) != (newMask & bit))
{
buttonEvent = new TrackedButtonInteractionEvent();
//std::cerr << "last mask " << _lastButtonMask << " new mask " << newMask << std::endl;
if(_threadLastHandButtonMask[j] & bit)
{
buttonEvent->setInteraction(BUTTON_UP);
}
else
{
buttonEvent->setInteraction(BUTTON_DOWN);
}
buttonEvent->setButton(i);
// set current pointer info
if(getIsHandThreaded(j))
{
buttonEvent->setTransform(_threadHandMatList[j]);
}
else
{
buttonEvent->setTransform(_handMatList[j]);
}
buttonEvent->setHand(j);
//_threadEvents.push((InteractionEvent*)buttonEvent);
genComTrackEvents->processEvent(buttonEvent);
}
else if((_threadLastHandButtonMask[j] & bit) && (newMask & bit))
{
buttonEvent = new TrackedButtonInteractionEvent();
buttonEvent->setInteraction(BUTTON_DRAG);
buttonEvent->setButton(i);
// set current pointer info
if(getIsHandThreaded(j))
{
buttonEvent->setTransform(_threadHandMatList[j]);
}
else
{
buttonEvent->setTransform(_handMatList[j]);
}
buttonEvent->setHand(j);
//_threadEvents.push((InteractionEvent*)buttonEvent);
genComTrackEvents->processEvent(buttonEvent);
}
bit = bit << 1;
}
_threadLastHandButtonMask[j] = newMask;
}
}
