comparison native/PhantomOmni/HapticManager.cpp @ 3:9e67171477bc

PHANTOM Omni Heptic device release

+#include "HapticManager.h"
+
+#define NO_ERROR_SIMUL
+
+
+void checkExceptions(void);
+void stopExecution(char* msg);
+
+bool movedNode = false;
+
+
+void HLCALLBACK HapticManager::hlButton1CB(HLenum event, HLuint object,
+                                         HLenum thread, HLcache *cache, 
+										 void *userdata)
+{
+	HapticManager *pThis = static_cast<HapticManager*>(userdata);
+	if(object == pThis->wall1Id||object == pThis->wall2Id) // no event is associated to the wall 
+		return;
+	if(event != HL_EVENT_1BUTTONDOWN)
+		return;
+
+	/* check if it was a double click or not */
+	
+	clock_t time = clock();
+	if(pThis->clickStart == 0) // first click
+		pThis->clickStart = time; 
+	else if(time < (pThis->clickStart + CLICK_INTERVAL))
+		pThis->doubleClick = true;
+	
+}
+
+void HLCALLBACK HapticManager::hlButton2CB(HLenum event, HLuint object,
+                                         HLenum thread, HLcache *cache, 
+										 void *userdata){
+	HapticManager *pThis = static_cast<HapticManager*>(userdata);
+	if(event == HL_EVENT_2BUTTONDOWN){
+		pThis->stickyMode = !pThis->stickyMode;
+		pThis->executeCommand('g', pThis->stickyMode ? 1 : 0,0,0,0,0);
+		/* we change mode to stickyMode, thus dragging becomes not active */
+		if(pThis->stickyMode && pThis->springStatus == DRAGGING){
+				pThis->springStatus = STOP_DRAGGING;
+				pThis->secondClick = false;
+		}
+#ifdef VIBRATION
+		// vibrate 
+		if(pThis->vibrationStatus == NO_VIBRATION){
+			pThis->vibrationStatus = START_VIBRATION;
+		}
+#endif
+	}
+}
+
+void HLCALLBACK HapticManager::hlTouchCB(HLenum event, HLuint object, HLenum thread,
+										 HLcache *cache, void *userdata)
+{
+	HapticManager *pThis = static_cast<HapticManager*>(userdata);
+	if(object == pThis->wall1Id||object == pThis->wall2Id) // no event is associated to the wall 
+		return;
+	if(pThis->lastMovedElement == object){
+		pThis->stillTouchingLastMovedElement = true;
+	}
+	
+	try{
+		// check if the touched object is an edge
+		if(pThis->collectionsManager->isEdge(object)){
+			CollectionsManager::EdgeData & ed = pThis->collectionsManager->getEdgeDataFromID(object);
+			pThis->lastTouchedEdgeID = object;
+			pThis->lastTouchedEdgeIsUntouched = false;
+			pThis->lastTouchedEdgeStipplePattern = ed.stipplePattern;
+			// check if the proxy is still touching the edge's node, in that case only play the sound
+			HLboolean isTouching = HL_FALSE;
+			if(pThis->lastTouchedNodeID != HL_OBJECT_ANY){
+				hlGetShapeBooleanv(pThis->lastTouchedNodeID,HL_PROXY_IS_TOUCHING,&isTouching);
+			}
+			/* play the sound and speech associated to the edge */
+			if((isTouching == HL_TRUE||pThis->stillTouchingLastMovedElement) && (object != pThis->attractToHapticId)){
+				if(!pThis->stickyMode)
+					pThis->executeCommand('p',ed.diagramId,0,0,0,0); // just plays the sound
+			}else{
+				pThis->executeCommand('s',ed.diagramId,0,0,0,0);
+				pThis->lastHighlightElementID = object;
+				pThis->executeCommand('t',ed.diagramId,0,0,0,0); // speaks the edge's name
+			}
+		}else{ // it's a node 
+			pThis->lastTouchedNodeID = object;
+			CollectionsManager::NodeData & nd = pThis->collectionsManager->getNodeDataFromID(object);
+			pThis->lastTouchedNodePosition[0] = nd.x;
+			pThis->lastTouchedNodePosition[1] = nd.y;
+			pThis->lastTouchedNodePosition[2] = 0;
+			pThis->frictionDisabled = true;
+			pThis->executeCommand('s',nd.diagramId,0,0,0,0);
+			pThis->lastHighlightElementID = object;
+			pThis->executeCommand('t',nd.diagramId,0,0,0,0);
+		}	
+	}catch(int){
+		stopExecution("Touch Call Back: Could not retrieve element from ID");
+	}
+}
+
+void HLCALLBACK HapticManager::hlUntouchCB(HLenum event, HLuint object, HLenum thread,
+										   HLcache *cache, void *userdata)
+{
+	HapticManager *pThis = static_cast<HapticManager*>(userdata);
+	if(object == pThis->wall1Id||object == pThis->wall2Id) // no event is associated to the wall 
+		return;
+	
+	if(object == pThis->lastMovedElement){
+		pThis->lastMovedElement = HL_OBJECT_ANY;
+		pThis->stillTouchingLastMovedElement = false;
+	}
+	if(pThis->lastHighlightElementID == object){
+		pThis->lastHighlightElementID = HL_OBJECT_ANY;
+		pThis->executeCommand('u',0,0,0,0,0);
+	}
+	if(pThis->lastTouchedEdgeID == object){
+		pThis->lastTouchedEdgeIsUntouched = true;
+	}
+}
+
+
+void HLCALLBACK HapticManager::hlMotionCB(HLenum event, HLuint object, HLenum thread,
+										   HLcache *cache, void *userdata)
+{
+	HapticManager *pThis = static_cast<HapticManager*>(userdata);
+	
+	/* plays the sound to acknowledge the user they're dragging an element around */
+	static int onceinawhile = 0;
+	if(pThis->springStatus == DRAGGING){
+		onceinawhile = (onceinawhile+1)%5;
+		if(!onceinawhile)
+			pThis->executeCommand('g',3,0,0,0,0);
+	}
+	
+	/* the following code is to play element speech when taking a path through an edge starting from a connected node */
+	
+	/* friction is disabled when we land on a node. If proxy ain't on a node, then just return  */
+	/* else it would play every time we move along the edge even if not detouching from a node  */
+	if(!pThis->frictionDisabled){
+		return;
+	}
+
+	/* calculate the distance between the node, the stylus was on, and the current proxy position after moving out from it*/
+	HLdouble proxyPosition[3];
+	hlGetDoublev(HL_DEVICE_POSITION,proxyPosition);
+	proxyPosition[0] -= pThis->lastTouchedNodePosition[0];
+	proxyPosition[1] -= pThis->lastTouchedNodePosition[1];
+	proxyPosition[2] -= pThis->lastTouchedNodePosition[2];
+	if(pThis->lastTouchedEdgeID != HL_OBJECT_ANY){
+		if(norm(proxyPosition) > EDGE_SPEECH_DISTANCE_WHEN_LEAVING_NODE){
+			pThis->frictionDisabled = false;
+			HLboolean isTouching;
+			hlGetShapeBooleanv(pThis->lastTouchedEdgeID,HL_PROXY_IS_TOUCHING,&isTouching);
+			if(isTouching == HL_TRUE){
+				try{
+					CollectionsManager::EdgeData & ed = pThis->collectionsManager->getEdgeDataFromID(pThis->lastTouchedEdgeID);
+					pThis->executeCommand('t',ed.diagramId,0,0,0,0);
+					pThis->lastTouchedEdgeID = ed.hapticId;
+					pThis->lastHighlightElementID = ed.hapticId;
+					pThis->executeCommand('s',ed.diagramId,0,0,0,0);
+				}catch(int){
+					stopExecution("Button 1 callback: Could not retrieve edge from ID");
+				}
+			}
+		}
+	}
+}
+
+#ifdef VIBRATION
+void HLCALLBACK HapticManager::vibrationCB(HDdouble force[3], HLcache *cache, void *userdata){
+	static const hduVector3Dd direction( 0, 1, 0 );
+    HDdouble instRate;
+    static HDdouble timer = 0;
+
+	HapticManager *pThis = static_cast<HapticManager*>(userdata);
+
+    /* Use the reciprocal of the instantaneous rate as a timer. */
+    hdGetDoublev(HD_INSTANTANEOUS_UPDATE_RATE, &instRate);
+    timer += 1.0 / instRate;
+
+    /* Apply a sinusoidal force in the direction of motion. */
+    hduVecScale(force, direction, VIBRATION_AMPLITUDE * sin(timer * VIBRATION_FREQUENCY));
+    hdSetDoublev(HD_CURRENT_FORCE, force);
+}
+
+void HLCALLBACK HapticManager::beforeVibrationCB(HLcache *cache, void *userdata){}
+
+void HLCALLBACK HapticManager::afterVibrationCB(HLcache *cache, void *userdata){}
+#endif
+
+void HapticManager::init(void) throw(HapticException){
+	HDErrorInfo error;
+
+    ghHD = hdInitDevice(HD_DEFAULT_DEVICE);
+    if (HD_DEVICE_ERROR(error = hdGetError())){
+        throw HapticException();
+    }
+    
+    ghHLRC = hlCreateContext(ghHD);
+    hlMakeCurrent(ghHLRC);
+
+    // Enable optimization of the viewing parameters when rendering geometry for OpenHaptics.
+    hlEnable(HL_HAPTIC_CAMERA_VIEW);
+
+    hlTouchableFace(HL_FRONT);
+	wall1Id = hlGenShapes(1);
+	wall2Id = hlGenShapes(1);
+	attractToHapticId = HL_OBJECT_ANY;
+	lastTouchedNodeID = HL_OBJECT_ANY;
+	lastTouchedEdgeID = HL_OBJECT_ANY;
+	draggedElementID = HL_OBJECT_ANY;
+	lastHighlightElementID = HL_OBJECT_ANY;
+
+	// initialize effects
+	frictionFX = hlGenEffects(1);
+	vibrationFX = hlGenEffects(1);
+	attractionFX = hlGenEffects(1);
+	springFX = hlGenEffects(1);
+	displayList1 = 0;
+	displayList2 = 0;
+	hlEventd(HL_EVENT_MOTION_LINEAR_TOLERANCE,5);
+	hlEventd(HL_EVENT_MOTION_ANGULAR_TOLERANCE,5);
+
+	// add callbacks 
+	hlAddEventCallback(HL_EVENT_2BUTTONDOWN,HL_OBJECT_ANY,HL_CLIENT_THREAD,hlButton2CB,this);
+	hlAddEventCallback(HL_EVENT_2BUTTONUP,HL_OBJECT_ANY,HL_CLIENT_THREAD,hlButton2CB,this);
+	hlAddEventCallback(HL_EVENT_1BUTTONUP,HL_OBJECT_ANY,HL_CLIENT_THREAD,hlButton1CB,this);
+	hlAddEventCallback(HL_EVENT_1BUTTONDOWN,HL_OBJECT_ANY,HL_CLIENT_THREAD,hlButton1CB,this);
+	hlAddEventCallback(HL_EVENT_TOUCH, HL_OBJECT_ANY, HL_CLIENT_THREAD, hlTouchCB, this);
+	hlAddEventCallback(HL_EVENT_UNTOUCH, HL_OBJECT_ANY, HL_CLIENT_THREAD, hlUntouchCB, this);
+	hlAddEventCallback(HL_EVENT_MOTION, HL_OBJECT_ANY, HL_CLIENT_THREAD, hlMotionCB, this);
+
+#ifdef VIBRATION
+	hlBeginFrame();
+	hlCallback(HL_EFFECT_START,(HLcallbackProc) beforeVibrationCB, this);
+	hlCallback(HL_EFFECT_STOP,(HLcallbackProc) afterVibrationCB, this);
+    hlCallback(HL_EFFECT_COMPUTE_FORCE, (HLcallbackProc) vibrationCB, this);
+	hlEndFrame();
+#endif
+}
+
+HapticManager::ClickStatus HapticManager::getButton1Status(){
+	if(clickStart == 0){
+		return NO_CLICK;
+	}else if(doubleClick){
+		/* double click: set everything back to default value and return DOUBLE_CLICK */
+		clickStart = 0;
+		doubleClick = false;
+		return TWO_CLICK;
+	}else if(clock() >= clickStart + CLICK_INTERVAL || secondClick) {
+		/* one click and enough time elapsed, so that it cannot be a double click */
+		clickStart = 0;
+		return ONE_CLICK;
+	}
+	return NO_CLICK;
+}
+
+void HapticManager::doButton1Click(bool doubleClick){
+	/* DOUBLE CLICK*/
+	if(doubleClick){
+		if(lastTouchedNodeID != HL_OBJECT_ANY){
+			HLboolean isTouching = HL_FALSE;
+			hlGetShapeBooleanv(lastTouchedNodeID,HL_PROXY_IS_TOUCHING,&isTouching); // priority to nodes
+			if(isTouching == HL_TRUE||lastTouchedNodeID == lastMovedElement){
+				try{
+					CollectionsManager::NodeData & nd = collectionsManager->getNodeDataFromID(lastTouchedNodeID);
+					executeCommand('i',nd.diagramId, 0,0,0,0);
+				}catch(int){
+					stopExecution("Button 1 callback: Could not retrieve node from ID");
+				}
+			}else{
+				if(lastTouchedEdgeID != HL_OBJECT_ANY){
+					hlGetShapeBooleanv(lastTouchedEdgeID,HL_PROXY_IS_TOUCHING,&isTouching);
+					if(isTouching == HL_TRUE||lastTouchedNodeID == lastMovedElement){
+						try{
+							CollectionsManager::EdgeData & ed = collectionsManager->getEdgeDataFromID(lastTouchedEdgeID);
+							executeCommand('i',ed.diagramId, 0,0,0,0);
+						}catch(int){
+							stopExecution("Button 1 callback: Could not retrieve edge from ID");
+						}
+					}
+				}
+			}
+		}
+		// this was a double click, thus clean up the data about the dragging
+		if(springStatus == DRAGGING){
+			springStatus = STOP_DRAGGING;
+			secondClick = false;
+		}
+		return;			
+	}
+	
+	/* - SINLGE CLICK - */
+	if(!secondClick){ //  button 1 pressed for the first time 
+		HLboolean isTouching;
+		/* if the stylus is touching a node then pick it up */
+		/* give priority to nodes */
+		if(lastTouchedNodeID != HL_OBJECT_ANY){
+			hlGetShapeBooleanv(lastTouchedNodeID,HL_PROXY_IS_TOUCHING,&isTouching);
+			if(isTouching == HL_TRUE || (stillTouchingLastMovedElement&&lastMovedElement == lastTouchedNodeID)){
+				draggedElementID = lastTouchedNodeID;
+				try{
+					CollectionsManager::NodeData & nd = collectionsManager->getNodeDataFromID(lastTouchedNodeID);
+					executeCommand('c',nd.diagramId,0,0,0,0); // pick up command
+				}catch(int){
+					stopExecution("Button 1 callback: Could not retrieve node from ID");
+				}
+				return;
+			}
+		}
+		/* no node is currently touched, check the edges now */
+		if(collectionsManager->isEdge(lastTouchedEdgeID)){
+			hlGetShapeBooleanv(lastTouchedEdgeID,HL_PROXY_IS_TOUCHING,&isTouching);
+			if(isTouching == HL_TRUE||(stillTouchingLastMovedElement&&lastMovedElement == lastTouchedEdgeID)){
+				draggedElementID = lastTouchedEdgeID;
+				try{
+					CollectionsManager::EdgeData & ed = collectionsManager->getEdgeDataFromID(lastTouchedEdgeID);
+					executeCommand('c',ed.diagramId,0,0,0,0); // pick up command
+				}catch(int){
+					stopExecution("Button 1 callback: Could not retrieve edge from ID");
+				}
+			}
+		}
+	}else{ // button 1 pressed for the second time 
+		if(springStatus != DRAGGING)
+			return;
+		springStatus = STOP_DRAGGING;
+		HLdouble leanPoint[3];
+		hlGetDoublev(HL_PROXY_POSITION,leanPoint);
+		leanPoint[2] = 1;
+		hduVector3Dd winCoordPoint;				
+		toScreen(hduVector3Dd(leanPoint),winCoordPoint);
+		
+		try{
+			if(collectionsManager->isNode(draggedElementID)){
+				CollectionsManager::NodeData & nd = collectionsManager->getNodeDataFromID(draggedElementID);
+				movedNode = true;
+				executeCommand('m',nd.diagramId,winCoordPoint[0],collectionsManager->getScreenHeight() - winCoordPoint[1],0,0);
+			}else if(collectionsManager->isEdge(draggedElementID)){ // double check necessary for the user might have changed the tab or closed the window before releasing the spring 		
+				springStart[2] = 1;
+				hduVector3Dd startWinCoordPoint;
+				toScreen(hduVector3Dd(springStart),startWinCoordPoint);//it's an edge, we also need the point where the motion has started
+				CollectionsManager::EdgeData & ed = collectionsManager->getEdgeDataFromID(draggedElementID);
+				executeCommand('m', ed.diagramId, 
+					winCoordPoint[0],
+					collectionsManager->getScreenHeight() - winCoordPoint[1],
+					startWinCoordPoint[0],
+					collectionsManager->getScreenHeight() - startWinCoordPoint[1]
+				);
+			}
+		}catch(int){
+			stopExecution("Button 1 callback: Could not retrieve element from ID");
+		}
+		/* with second click we place the element and it becomes the last moved element */
+		lastMovedElement = draggedElementID;
+		secondClick = false;
+	}
+}
+
+void HapticManager::setAttractTo(jint hapticId){
+	if(attractionStatus == NO_ATTRACTION) // starts only if there is no previous attraction being overwritten
+		attractionStatus = START_ATTRACTION;	
+	attractToHapticId = hapticId;
+	alreadyTouchingAttractingElement = false;
+}
+
+void HapticManager::pickUp(jint hapticId){
+	springStatus = START_DRAGGING;
+	secondClick = true;
+	hlGetDoublev(HL_PROXY_POSITION,springStart);
+}
+
+bool HapticManager::wasAlreadyTouchingAttractingElement(){
+	return alreadyTouchingAttractingElement;
+}
+
+void HapticManager::draw(void){
+	// Start haptic frame.  (Must do this before rendering any haptic shapes.)
+    hlBeginFrame();   
+
+	if(!doneOnce){
+		hlStartEffect(HL_EFFECT_FRICTION, frictionFX);
+		doneOnce = true;
+	}
+
+	if(wall){
+		// Plane shape.
+		hlPushAttrib(HL_MATERIAL_BIT|HL_TOUCH_BIT);
+		hlBeginShape(HL_SHAPE_FEEDBACK_BUFFER, wall1Id);
+		hlMaterialf(HL_FRONT_AND_BACK, HL_STIFFNESS, 1);
+		hlMaterialf(HL_FRONT, HL_POPTHROUGH, 0 );
+		hlMaterialf(HL_FRONT, HL_STATIC_FRICTION, 0);
+		hlMaterialf(HL_FRONT, HL_DYNAMIC_FRICTION, 0);
+		hlTouchModel(HL_CONTACT);
+		hlTouchableFace(HL_FRONT);
+		drawPlane(-0.005);
+		hlEndShape();
+#define SECOND_PLANE
+#ifdef SECOND_PLANE
+		hlBeginShape(HL_SHAPE_FEEDBACK_BUFFER, wall2Id);
+		hlMaterialf(HL_BACK, HL_STIFFNESS, 1);
+		hlTouchableFace(HL_BACK);
+		hlMaterialf(HL_FRONT, HL_POPTHROUGH, 0 );
+		hlMaterialf(HL_FRONT, HL_STATIC_FRICTION, 0);
+		hlMaterialf(HL_FRONT, HL_DYNAMIC_FRICTION, 0);
+		drawPlane(0.005);
+		hlEndShape();
+#endif
+		hlPopAttrib();
+	}
+
+    // Start a new haptic shape.  Use the feedback buffer to capture OpenGL 
+    // geometry for haptic rendering.
+
+	// draw nodes
+	int size = collectionsManager->getNodesNum();
+	
+	for(int i=0; i< size;i++){
+		CollectionsManager::NodeData & nd = collectionsManager->getNodeData(i);
+
+		hlPushAttrib(HL_HINT_BIT);
+		hlHinti(HL_SHAPE_FEEDBACK_BUFFER_VERTICES, 3);
+		hlBeginShape(HL_SHAPE_FEEDBACK_BUFFER, nd.hapticId);
+		 hlTouchModel(HL_CONSTRAINT);
+		 hlTouchModelf(HL_SNAP_DISTANCE ,  4.0f );
+		 hlMaterialf(HL_FRONT_AND_BACK, HL_STIFFNESS, 1.0);
+		 hlMaterialf(HL_FRONT_AND_BACK, HL_DAMPING, 0);
+
+		 hlMaterialf(HL_FRONT_AND_BACK, HL_STATIC_FRICTION, 0);
+		 hlMaterialf(HL_FRONT_AND_BACK, HL_DYNAMIC_FRICTION, 0);
+
+		 //draw the point
+		 glBegin(GL_POINTS);
+		  glVertex3d(nd.x,nd.y,0);
+		 glEnd();
+		 
+		// End the shape.
+		hlEndShape();
+		hlPopAttrib();
+
+		// saves the coorinates for a later use so that for the effect we don't need to cycle again
+		if(attractionStatus == START_ATTRACTION || attractionStatus == DOING_ATTRACTION){
+			if(nd.hapticId == attractToHapticId){
+				attractToCoord[0] = nd.x;
+				attractToCoord[1] = nd.y;
+				attractToCoord[2] = 0;
+			}
+		}
+	}
+
+	/* draw lines. When a node is moved, edges are not drawn for the very first haptic frame after the shift.   *
+	 *  This is to address the behaviour of the device which, after a n ode is moved cannot see the styilus     *
+	 *  touching the edge. As a consequence of that in hlMotionCB() when moving away from a node along an edge  *
+	 *  no edge name will be spoken and furthermore the pick up botton won't work as the device thinks it's not *  
+	 *  touching anything. Not drawing the edge on the first frame, seems to address this issue.                */
+	if(!movedNode) {
+		size = collectionsManager->getEdgesNum();
+		for(int i = 0; i<size; i++){
+			CollectionsManager::EdgeData & ed = collectionsManager->getEdgeData(i);
+			hlPushAttrib(HL_HINT_BIT|HL_MATERIAL_BIT);
+			hlHinti(HL_SHAPE_FEEDBACK_BUFFER_VERTICES, ed.getSize());
+
+			hlBeginShape(HL_SHAPE_FEEDBACK_BUFFER, ed.hapticId);
+			hlTouchModel(HL_CONSTRAINT);
+			hlTouchModelf(HL_SNAP_DISTANCE, ( (stickyMode && springStatus != DRAGGING && springStatus != START_DRAGGING)  ? 20.0f : 3.5f ));
+			hlMaterialf(HL_FRONT_AND_BACK, HL_STIFFNESS, 1);
+			
+			if(ed.stipplePattern == 0xFFFF){
+				hlMaterialf(HL_FRONT_AND_BACK, HL_STATIC_FRICTION, 0.5f);
+			}
+
+			glLineWidth(1.0);
+			
+			glBegin(GL_LINES);
+			 for(unsigned int j = 0; j < ed.getSize(); j++){
+				for(unsigned int k = j; k < ed.getSize(); k++){
+					if(ed.adjMatrix[j][k]){
+						if(  k >= ed.nodeStart && 
+							   (!stickyMode || (springStatus != RELEASED && springStatus != STOP_DRAGGING))
+							   && attractionStatus != DOING_ATTRACTION && attractionStatus != START_ATTRACTION){ // not a line connecting two edges and stickyMode not enabled
+							/* it's drawing a line from a point to a node, thus it draws it a little shorter*/
+							double hypotenuse = sqrt( (ed.x[j] - ed.x[k])*(ed.x[j] - ed.x[k]) + (ed.y[j] - ed.y[k])*(ed.y[j] - ed.y[k]));		
+							if(hypotenuse == 0)
+								continue;
+							double mySin = (ed.y[j] - ed.y[k])/hypotenuse;
+							double myCos = (ed.x[j] - ed.x[k])/hypotenuse; 
+							glVertex3d(ed.x[k]+(EDGE_SHORTEND_VAL * myCos) , ed.y[k]+(EDGE_SHORTEND_VAL*mySin),0);
+							if(j >= ed.nodeStart) //its a direct edge connecting two nodes 
+								glVertex3d(ed.x[j]+(EDGE_SHORTEND_VAL * -myCos),ed.y[j]+(EDGE_SHORTEND_VAL*-mySin),0);
+							else
+								glVertex3d(ed.x[j],ed.y[j],0);
+						}else{
+							glVertex3d(ed.x[j],ed.y[j],0);
+							glVertex3d(ed.x[k],ed.y[k],0);
+						}
+					}
+				}
+			}
+			glEnd();
+			hlEndShape();
+			hlPopAttrib();
+
+			// saves the coorinates for a later use so that for the effect we don't need to cycle again
+			if(attractionStatus == START_ATTRACTION || attractionStatus == DOING_ATTRACTION){
+				if(ed.hapticId == attractToHapticId){
+					attractToCoord[0] = ed.attractPoint[0];
+					attractToCoord[1] = ed.attractPoint[1];
+					attractToCoord[2] = 0;
+				}
+			}
+		}
+	}else {
+		movedNode = false;
+	}
+	/* ---  FORCES --- */
+	/* friction */
+	if(lastTouchedEdgeID != HL_OBJECT_ANY){
+		/* check if the edge is still there, it might not as the tab could be changed */
+		if(collectionsManager->isEdge(lastTouchedEdgeID)){
+			//hlGetShapeBooleanv(lastTouchedEdgeID,HL_PROXY_IS_TOUCHING,&isTouching); FIXME to remove
+			if(frictionDisabled||lastTouchedEdgeIsUntouched/*(isTouching == HL_FALSE)*/){
+					hlEffectd(HL_EFFECT_PROPERTY_MAGNITUDE, 0);
+					hlEffectd(HL_EFFECT_PROPERTY_GAIN, 0);
+				}else{
+					if(lastTouchedEdgeStipplePattern == 0xAAAA){ // dotted
+						hlEffectd(HL_EFFECT_PROPERTY_MAGNITUDE, 0.4f);
+						hlEffectd(HL_EFFECT_PROPERTY_GAIN, 1);
+					}else if(lastTouchedEdgeStipplePattern == 0xF0F0){ // dashed
+						hlEffectd(HL_EFFECT_PROPERTY_MAGNITUDE, 0.6);
+						hlEffectd(HL_EFFECT_PROPERTY_GAIN, 0.6);
+					}
+			}
+		}else{
+			lastTouchedEdgeID = HL_OBJECT_ANY;
+			hlEffectd(HL_EFFECT_PROPERTY_MAGNITUDE, 0);
+			hlEffectd(HL_EFFECT_PROPERTY_GAIN, 0);
+		}
+		hlUpdateEffect(frictionFX); 
+	}
+
+	// spring 
+	if(springStatus == START_DRAGGING){
+		hlPushAttrib(HL_EFFECT_BIT);
+		hlEffectd(HL_EFFECT_PROPERTY_GAIN, 0.3);
+		hlEffectd(HL_EFFECT_PROPERTY_MAGNITUDE, 0.5);
+		
+		hduMatrix worldToView;
+		hduMatrix graphicToTouch;
+		hduMatrix touchToWorkspace;
+		hduMatrix WorldToDevice;
+		glMatrixMode(GL_MODELVIEW);
+		glGetDoublev(GL_MODELVIEW_MATRIX,worldToView);
+		hlGetDoublev(HL_VIEWTOUCH_MATRIX, graphicToTouch );
+		hlGetDoublev(HL_TOUCHWORKSPACE_MATRIX, touchToWorkspace );
+		WorldToDevice = worldToView * graphicToTouch * touchToWorkspace;
+
+		hduVector3Dd dst;
+		WorldToDevice.multVecMatrix(hduVector3Dd(springStart[0],springStart[1],0),dst);
+		
+		hlEffectdv(HL_EFFECT_PROPERTY_POSITION, dst);
+		hlStartEffect(HL_EFFECT_SPRING, springFX);
+		hlPopAttrib();
+		springStatus = DRAGGING;
+	}else if(springStatus == STOP_DRAGGING){
+		hlStopEffect(springFX);
+		springStatus = RELEASED;
+	}
+	
+	// attraction 
+	HLboolean isTouching = HL_FALSE;
+	if(attractionStatus == DOING_ATTRACTION || attractionStatus == START_ATTRACTION){
+		/* we need to be sure we're currently touching the element */
+		if(attractToHapticId != HL_OBJECT_ANY){
+			hlGetShapeBooleanv(attractToHapticId,HL_PROXY_IS_TOUCHING,&isTouching);
+		}
+		
+		// when touching the element we're getting attracted to, then shut the force down
+		if(isTouching == HL_TRUE){ 
+			if(attractionStatus == DOING_ATTRACTION){ // we finally reached the attracting node
+				attractionStatus = STOP_ATTRACTION;
+			}else{
+				attractionStatus = NO_ATTRACTION; // we were already touching the node we wanted to get attracted to 
+				alreadyTouchingAttractingElement = true;
+			}
+		}
+	}
+
+	if(attractionStatus == STOP_ATTRACTION){
+		attractionStatus = NO_ATTRACTION;
+	    hlStopEffect(attractionFX);
+	} else if(attractionStatus == START_ATTRACTION || attractionStatus == DOING_ATTRACTION){
+		HLdouble devicePosition[3];
+		HDdouble direction[3];
+		hlGetDoublev(HL_DEVICE_POSITION,devicePosition);
+		direction[0] = attractToCoord[0] - devicePosition[0];
+		direction[1] = attractToCoord[1] - devicePosition[1];
+		direction[2] = attractToCoord[2] - devicePosition[2];
+		HDdouble directionNorm = norm(direction);
+		if(directionNorm != 0 ){
+			direction[0] /= directionNorm;
+			direction[1] /= directionNorm;
+			direction[2] /= directionNorm;
+		}
+		hlPushAttrib(HL_EFFECT_BIT);
+		hlEffectdv(HL_EFFECT_PROPERTY_DIRECTION, direction);
+		hlEffectd(HL_EFFECT_PROPERTY_GAIN, 0.5f);
+		hlEffectd(HL_EFFECT_PROPERTY_MAGNITUDE, 0.5f);
+		if(attractionStatus == START_ATTRACTION){
+			hlStartEffect(HL_EFFECT_CONSTANT, attractionFX);
+			attractionStatus = DOING_ATTRACTION;
+		}else{
+			hlUpdateEffect(attractionFX);
+		}
+		hlPopAttrib();
+	}
+#ifdef VIBRATION
+	if(vibrationStatus == START_VIBRATION){
+		hlStartEffect(HL_EFFECT_CALLBACK, vibrationFX);
+		vibrationEnd = clock() + VIBRATION_DURATION;
+		vibrationStatus = DOING_VIBRATION;
+	}else if(vibrationStatus == DOING_VIBRATION){
+		if(clock() >= vibrationEnd){
+			hlStopEffect(vibrationFX);
+			vibrationStatus = NO_VIBRATION;
+		}
+	}
+#endif
+    // End the haptic frame.
+    hlEndFrame();
+}
+
+void HapticManager::drawPlane(float zoffset){
+	GLuint displayList = (zoffset < 0) ? displayList1 : displayList2;
+
+	if (displayList){
+		glCallList(displayList);
+	}
+	else{
+		if(zoffset < 0){
+			displayList1 = glGenLists(1);
+			glNewList(displayList1, GL_COMPILE_AND_EXECUTE);
+		}else{
+			displayList2 = glGenLists(1);
+			glNewList(displayList2, GL_COMPILE_AND_EXECUTE);
+		}	
+		glNewList(displayList, GL_COMPILE_AND_EXECUTE);
+		glPushAttrib(GL_ENABLE_BIT);
+		glPolygonOffset(1,1);
+		glEnable(GL_POLYGON_OFFSET_FILL);
+		
+		glBegin(GL_QUADS);
+		glVertex3f(-5, -5, zoffset);
+		glVertex3f(5, -5, zoffset);
+		glVertex3f(5, 5, zoffset);
+		glVertex3f(-5, 5, zoffset);
+		glEnd();
+		glDisable(GL_POLYGON_OFFSET_FILL);
+		glPopAttrib();
+		glEndList();
+	}
+	
+}
+
+HHD HapticManager::ghHD = HD_INVALID_HANDLE;
+HHLRC HapticManager::ghHLRC = 0;
+const double HapticManager::EDGE_SHORTEND_VAL = 0.06;
+const unsigned int HapticManager::CLICK_INTERVAL = CLOCKS_PER_SEC/5;
+const double HapticManager::EDGE_SPEECH_DISTANCE_WHEN_LEAVING_NODE = 0.03;
+#ifdef VIBRATION
+const HDdouble HapticManager::VIBRATION_AMPLITUDE = 0.88;//0.88;
+const HDint HapticManager::VIBRATION_FREQUENCY = 170;//160;
+const unsigned int HapticManager::VIBRATION_DURATION = CLOCKS_PER_SEC/10; // = 100 ms
+#endif