Merge pull request #1064 from erwincoumans/master

also report VR events for HMD and generic tracked devices.

examples/CommonInterfaces/CommonExampleInterface.h

@@ -49,6 +49,8 @@ public:
 
 	virtual void	vrControllerMoveCallback(int controllerId, float pos[4], float orientation[4], float analogAxis) {}
 	virtual void	vrControllerButtonCallback(int controllerId, int button, int state, float pos[4], float orientation[4]){}
+	virtual void	vrHMDMoveCallback(int controllerId, float pos[4], float orientation[4]){}
+	virtual void	vrGenericTrackerMoveCallback(int controllerId, float pos[4], float orientation[4]){}
 
 	virtual void	processCommandLineArgs(int argc, char* argv[]){};
 };

examples/SharedMemory/PhysicsClientC_API.cpp

@@ -2537,11 +2537,20 @@ b3SharedMemoryCommandHandle	b3RequestVREventsCommandInit(b3PhysicsClientHandle p
 	b3Assert(command);
 
 	command->m_type = CMD_REQUEST_VR_EVENTS_DATA;
-	command->m_updateFlags = 0;
+	command->m_updateFlags = VR_DEVICE_CONTROLLER;
-
 	return (b3SharedMemoryCommandHandle)command;
 }
 
+void b3VREventsSetDeviceTypeFilter(b3SharedMemoryCommandHandle commandHandle, int deviceTypeFilter)
+{
+	struct SharedMemoryCommand* command = (struct SharedMemoryCommand*) commandHandle;
+    b3Assert(command);
+	if (command->m_type == CMD_REQUEST_VR_EVENTS_DATA)
+	{
+		command->m_updateFlags = deviceTypeFilter;
+	}
+}
+
 void b3GetVREventsData(b3PhysicsClientHandle physClient, struct b3VREventsData* vrEventsData)
 {
 	PhysicsClient* cl = (PhysicsClient* ) physClient;

examples/SharedMemory/PhysicsClientC_API.h

@@ -352,6 +352,8 @@ int b3LoadBunnySetCollisionMargin(b3SharedMemoryCommandHandle commandHandle, dou
 
 
 b3SharedMemoryCommandHandle	b3RequestVREventsCommandInit(b3PhysicsClientHandle physClient);
+void b3VREventsSetDeviceTypeFilter(b3SharedMemoryCommandHandle commandHandle, int deviceTypeFilter);
+
 void b3GetVREventsData(b3PhysicsClientHandle physClient, struct b3VREventsData* vrEventsData);
 
 b3SharedMemoryCommandHandle	b3SetVRCameraStateCommandInit(b3PhysicsClientHandle physClient);

examples/SharedMemory/PhysicsServerCommandProcessor.cpp

@@ -605,6 +605,7 @@ struct b3VRControllerEvents
 	{
 		for (int i=0;i<MAX_VR_CONTROLLERS;i++)
 		{
+			m_vrEvents[i].m_deviceType = 0;
 			m_vrEvents[i].m_numButtonEvents = 0;
 			m_vrEvents[i].m_numMoveEvents = 0;
 			for (int b=0;b<MAX_VR_BUTTONS;b++)
@@ -628,6 +629,7 @@ struct b3VRControllerEvents
 			if (vrEvents[i].m_numMoveEvents+vrEvents[i].m_numButtonEvents)
 			{
 				m_vrEvents[controlledId].m_controllerId = vrEvents[i].m_controllerId;
+				m_vrEvents[controlledId].m_deviceType = vrEvents[i].m_deviceType;
 
 				m_vrEvents[controlledId].m_pos[0] = vrEvents[i].m_pos[0];
 				m_vrEvents[controlledId].m_pos[1] = vrEvents[i].m_pos[1];
@@ -1209,7 +1211,9 @@ struct PhysicsServerCommandProcessorInternalData
 	bool m_allowRealTimeSimulation;
 	bool m_hasGround;
 
-	b3VRControllerEvents m_vrEvents1;
+	b3VRControllerEvents m_vrControllerEvents;
+
+
 	btAlignedObjectArray<b3KeyboardEvent> m_keyboardEvents;
 	
 	btMultiBodyFixedConstraint* m_gripperRigidbodyFixed;
@@ -1324,7 +1328,7 @@ struct PhysicsServerCommandProcessorInternalData
 		m_pickedConstraint(0),
 		m_pickingMultiBodyPoint2Point(0)
 	{
-		m_vrEvents1.init();
+		m_vrControllerEvents.init();
 
 		initHandles();
 #if 0
@@ -2362,12 +2366,14 @@ bool PhysicsServerCommandProcessor::processCommand(const struct SharedMemoryComm
 				case CMD_REQUEST_VR_EVENTS_DATA:
 				{
 					BT_PROFILE("CMD_REQUEST_VR_EVENTS_DATA");
-
 					serverStatusOut.m_sendVREvents.m_numVRControllerEvents = 0;
+
 					for (int i=0;i<MAX_VR_CONTROLLERS;i++)
 					{
-						b3VRControllerEvent& event = m_data->m_vrEvents1.m_vrEvents[i];
+						b3VRControllerEvent& event = m_data->m_vrControllerEvents.m_vrEvents[i];
 
+						if (clientCmd.m_updateFlags&event.m_deviceType)
+						{
 							if (event.m_numButtonEvents + event.m_numMoveEvents)
 							{
 								serverStatusOut.m_sendVREvents.m_controllerEvents[serverStatusOut.m_sendVREvents.m_numVRControllerEvents++] = event;
@@ -2379,6 +2385,7 @@ bool PhysicsServerCommandProcessor::processCommand(const struct SharedMemoryComm
 								}
 							}
 						}
+					}
 					serverStatusOut.m_type = CMD_REQUEST_VR_EVENTS_DATA_COMPLETED;
 					hasStatus = true;
 					break;
@@ -5668,15 +5675,15 @@ void PhysicsServerCommandProcessor::enableRealTimeSimulation(bool enableRealTime
 	m_data->m_allowRealTimeSimulation = enableRealTimeSim;
 }
 
-void PhysicsServerCommandProcessor::stepSimulationRealTime(double dtInSec,	const struct b3VRControllerEvent* vrEvents, int numVREvents,const struct b3KeyboardEvent* keyEvents, int numKeyEvents)
+void PhysicsServerCommandProcessor::stepSimulationRealTime(double dtInSec,	const struct b3VRControllerEvent* vrControllerEvents, int numVRControllerEvents,const struct b3KeyboardEvent* keyEvents, int numKeyEvents)
 {
-	m_data->m_vrEvents1.addNewVREvents(vrEvents,numVREvents);
+	m_data->m_vrControllerEvents.addNewVREvents(vrControllerEvents,numVRControllerEvents);
 	for (int i=0;i<m_data->m_stateLoggers.size();i++)
 	{
 		if (m_data->m_stateLoggers[i]->m_loggingType==STATE_LOGGING_VR_CONTROLLERS)
 		{
 			VRControllerStateLogger* vrLogger = (VRControllerStateLogger*) m_data->m_stateLoggers[i];
-			vrLogger->m_vrEvents.addNewVREvents(vrEvents,numVREvents);
+			vrLogger->m_vrEvents.addNewVREvents(vrControllerEvents,numVRControllerEvents);
 		}
 	}
 

examples/SharedMemory/PhysicsServerExample.cpp

@@ -1046,6 +1046,8 @@ public:
 
 	virtual void	vrControllerButtonCallback(int controllerId, int button, int state, float pos[4], float orientation[4]);
 	virtual void	vrControllerMoveCallback(int controllerId, float pos[4], float orientation[4], float analogAxis);
+	virtual void	vrHMDMoveCallback(int controllerId, float pos[4], float orientation[4]);
+	virtual void	vrGenericTrackerMoveCallback(int controllerId, float pos[4], float orientation[4]);
 
 
 	virtual bool	mouseMoveCallback(float x,float y)
@@ -2229,6 +2231,7 @@ void	PhysicsServerExample::vrControllerButtonCallback(int controllerId, int butt
 
 	m_args[0].m_csGUI->lock();
 	m_args[0].m_vrControllerEvents[controllerId].m_controllerId = controllerId;
+	m_args[0].m_vrControllerEvents[controllerId].m_deviceType = VR_DEVICE_CONTROLLER;
 	m_args[0].m_vrControllerEvents[controllerId].m_pos[0] = trTotal.getOrigin()[0];
 	m_args[0].m_vrControllerEvents[controllerId].m_pos[1] = trTotal.getOrigin()[1];
 	m_args[0].m_vrControllerEvents[controllerId].m_pos[2] = trTotal.getOrigin()[2];
@@ -2252,7 +2255,7 @@ void	PhysicsServerExample::vrControllerButtonCallback(int controllerId, int butt
 void	PhysicsServerExample::vrControllerMoveCallback(int controllerId, float pos[4], float orn[4], float analogAxis)
 {
 
-	if (controllerId <= 0 || controllerId >= MAX_VR_CONTROLLERS)
+	if (controllerId < 0 || controllerId >= MAX_VR_CONTROLLERS)
 	{
 		printf("Controller Id exceeds max: %d > %d", controllerId, MAX_VR_CONTROLLERS);
 		return;
@@ -2299,6 +2302,7 @@ void	PhysicsServerExample::vrControllerMoveCallback(int controllerId, float pos[
 
 	m_args[0].m_csGUI->lock();
 	m_args[0].m_vrControllerEvents[controllerId].m_controllerId = controllerId;
+	m_args[0].m_vrControllerEvents[controllerId].m_deviceType = VR_DEVICE_CONTROLLER;
 	m_args[0].m_vrControllerEvents[controllerId].m_pos[0] = trTotal.getOrigin()[0];
 	m_args[0].m_vrControllerEvents[controllerId].m_pos[1] = trTotal.getOrigin()[1];
 	m_args[0].m_vrControllerEvents[controllerId].m_pos[2] = trTotal.getOrigin()[2];
@@ -2311,4 +2315,87 @@ void	PhysicsServerExample::vrControllerMoveCallback(int controllerId, float pos[
 	m_args[0].m_csGUI->unlock();
 
 }
+
+void	PhysicsServerExample::vrHMDMoveCallback(int controllerId, float pos[4], float orn[4])
+{
+		if (controllerId < 0 || controllerId >= MAX_VR_CONTROLLERS)
+	{
+		printf("Controller Id exceeds max: %d > %d", controllerId, MAX_VR_CONTROLLERS);
+		return;
+	}
+
+	//we may need to add some trLocal transform, to align the camera to our preferences
+	btTransform trLocal;
+	trLocal.setIdentity();
+//	trLocal.setRotation(btQuaternion(btVector3(0, 0, 1), SIMD_HALF_PI)*btQuaternion(btVector3(0, 1, 0), SIMD_HALF_PI));
+
+	btTransform trOrg;
+	trOrg.setIdentity();
+	trOrg.setOrigin(btVector3(pos[0], pos[1], pos[2]));
+	trOrg.setRotation(btQuaternion(orn[0], orn[1], orn[2], orn[3]));
+
+	btTransform tr2a;
+	tr2a.setIdentity();
+	btTransform tr2;
+	tr2.setIdentity();
+	tr2.setOrigin(gVRTeleportPos1);
+	tr2a.setRotation(gVRTeleportOrn);
+	btTransform trTotal = tr2*tr2a*trOrg*trLocal;
+
+
+
+	m_args[0].m_csGUI->lock();
+	m_args[0].m_vrControllerEvents[controllerId].m_controllerId = controllerId;
+	m_args[0].m_vrControllerEvents[controllerId].m_deviceType = VR_DEVICE_HMD;
+	m_args[0].m_vrControllerEvents[controllerId].m_pos[0] = trTotal.getOrigin()[0];
+	m_args[0].m_vrControllerEvents[controllerId].m_pos[1] = trTotal.getOrigin()[1];
+	m_args[0].m_vrControllerEvents[controllerId].m_pos[2] = trTotal.getOrigin()[2];
+	m_args[0].m_vrControllerEvents[controllerId].m_orn[0] = trTotal.getRotation()[0];
+	m_args[0].m_vrControllerEvents[controllerId].m_orn[1] = trTotal.getRotation()[1];
+	m_args[0].m_vrControllerEvents[controllerId].m_orn[2] = trTotal.getRotation()[2];
+	m_args[0].m_vrControllerEvents[controllerId].m_orn[3] = trTotal.getRotation()[3];
+	m_args[0].m_vrControllerEvents[controllerId].m_numMoveEvents++;
+	m_args[0].m_csGUI->unlock();
+}
+void	PhysicsServerExample::vrGenericTrackerMoveCallback(int controllerId, float pos[4], float orn[4])
+{
+	if (controllerId < 0 || controllerId >= MAX_VR_CONTROLLERS)
+	{
+		printf("Controller Id exceeds max: %d > %d", controllerId, MAX_VR_CONTROLLERS);
+		return;
+	}
+
+		//we may need to add some trLocal transform, to align the camera to our preferences
+	btTransform trLocal;
+	trLocal.setIdentity();
+	trLocal.setRotation(btQuaternion(btVector3(0, 0, 1), SIMD_HALF_PI)*btQuaternion(btVector3(0, 1, 0), SIMD_HALF_PI));
+
+
+	btTransform trOrg;
+	trOrg.setIdentity();
+	trOrg.setOrigin(btVector3(pos[0], pos[1], pos[2]));
+	trOrg.setRotation(btQuaternion(orn[0], orn[1], orn[2], orn[3]));
+
+	btTransform tr2a;
+	tr2a.setIdentity();
+	btTransform tr2;
+	tr2.setIdentity();
+	tr2.setOrigin(gVRTeleportPos1);
+	tr2a.setRotation(gVRTeleportOrn);
+	btTransform trTotal = tr2*tr2a*trOrg*trLocal;
+
+	m_args[0].m_csGUI->lock();
+	m_args[0].m_vrControllerEvents[controllerId].m_controllerId = controllerId;
+	m_args[0].m_vrControllerEvents[controllerId].m_deviceType = VR_DEVICE_GENERIC_TRACKER;
+	m_args[0].m_vrControllerEvents[controllerId].m_pos[0] = trTotal.getOrigin()[0];
+	m_args[0].m_vrControllerEvents[controllerId].m_pos[1] = trTotal.getOrigin()[1];
+	m_args[0].m_vrControllerEvents[controllerId].m_pos[2] = trTotal.getOrigin()[2];
+	m_args[0].m_vrControllerEvents[controllerId].m_orn[0] = trTotal.getRotation()[0];
+	m_args[0].m_vrControllerEvents[controllerId].m_orn[1] = trTotal.getRotation()[1];
+	m_args[0].m_vrControllerEvents[controllerId].m_orn[2] = trTotal.getRotation()[2];
+	m_args[0].m_vrControllerEvents[controllerId].m_orn[3] = trTotal.getRotation()[3];
+	m_args[0].m_vrControllerEvents[controllerId].m_numMoveEvents++;
+	m_args[0].m_csGUI->unlock();
+}
+
 B3_STANDALONE_EXAMPLE(PhysicsServerCreateFunc)

examples/SharedMemory/SharedMemoryCommands.h

@@ -605,6 +605,7 @@ struct UserDebugDrawResultArgs
 	double m_parameterValue;
 };
 
+
 struct SendVREvents
 {
 	int m_numVRControllerEvents;

examples/SharedMemory/SharedMemoryPublic.h

@@ -252,7 +252,9 @@ struct b3CameraImageData
 enum b3VREventType
 {
 	VR_CONTROLLER_MOVE_EVENT=1,
-	VR_CONTROLLER_BUTTON_EVENT
+	VR_CONTROLLER_BUTTON_EVENT=2,
+	VR_HMD_MOVE_EVENT=4,
+	VR_GENERIC_TRACKER_MOVE_EVENT=8,
 };
 
 #define MAX_VR_BUTTONS 64
@@ -271,9 +273,19 @@ enum b3VRButtonInfo
 	eButtonReleased = 4,
 };
 
+
+
+enum eVRDeviceTypeEnums
+{
+	VR_DEVICE_CONTROLLER=1,
+	VR_DEVICE_HMD=2,
+	VR_DEVICE_GENERIC_TRACKER=4,
+};
+
 struct b3VRControllerEvent
 {
 	int m_controllerId;//valid for VR_CONTROLLER_MOVE_EVENT and VR_CONTROLLER_BUTTON_EVENT
+	int m_deviceType;
 	int m_numMoveEvents;
 	int m_numButtonEvents;
 	
@@ -289,6 +301,11 @@ struct b3VREventsData
 {
 	int m_numControllerEvents;
 	struct b3VRControllerEvent* m_controllerEvents;
+	int m_numHmdEvents;
+	struct b3VRMoveEvent* m_hmdEvents;
+
+	int  m_numGenericTrackerEvents;
+	struct b3VRMoveEvent* m_genericTrackerEvents;
 };
 
 

examples/StandaloneMain/hellovr_opengl_main.cpp

@@ -709,8 +709,50 @@ bool CMainApplication::HandleInput()
 		vr::VRControllerState_t state;
 		if( m_pHMD->GetControllerState( unDevice, &state ,sizeof(vr::VRControllerState_t)) )
 		{
+			b3Transform tr;
+			getControllerTransform(unDevice, tr);
+			float pos[3] = { tr.getOrigin()[0], tr.getOrigin()[1], tr.getOrigin()[2] };
+			b3Quaternion born = tr.getRotation();
+			float orn[4] = { born[0], born[1], born[2], born[3] };
+
 			//we need to have the 'move' events, so no early out here
 			//if (sPrevStates[unDevice].unPacketNum != state.unPacketNum)
+			if( m_pHMD->GetTrackedDeviceClass( unDevice) == vr::TrackedDeviceClass_HMD )
+			{
+				Matrix4 rotYtoZ = rotYtoZ.identity();
+				//some Bullet apps (especially robotics related) require Z as up-axis)
+				if (m_app->getUpAxis()==2)
+				{
+					rotYtoZ.rotateX(-90);
+				}
+				Matrix4 viewMatCenter = m_mat4HMDPose * rotYtoZ;
+				const float* mat = viewMatCenter.invertAffine().get();
+				pos[0] = mat[12];
+				pos[1] = mat[13];
+				pos[2] = mat[14];
+
+				b3Matrix3x3 bmat;
+				for (int i=0;i<3;i++)
+				{
+					for (int j=0;j<3;j++)
+					{
+						bmat[i][j] = mat[i+4*j];
+					}
+				}
+				b3Quaternion orn2;
+				bmat.getRotation(orn2);
+				orn[0] = orn2[0];
+				orn[1] = orn2[1];
+				orn[2] = orn2[2];
+				orn[3] = orn2[3];
+				sExample->vrHMDMoveCallback(unDevice, pos,orn);
+			}
+
+			if( m_pHMD->GetTrackedDeviceClass( unDevice) == vr::TrackedDeviceClass_GenericTracker )
+			{
+				sExample->vrGenericTrackerMoveCallback(unDevice, pos,orn);
+			}
+
 			if( m_pHMD->GetTrackedDeviceClass( unDevice) == vr::TrackedDeviceClass_Controller )
 			{
 				sPrevStates[unDevice].unPacketNum = state.unPacketNum;
@@ -723,11 +765,6 @@ bool CMainApplication::HandleInput()
 					if (isTrigger)
 					{
 
-						b3Transform tr;
-						getControllerTransform(unDevice, tr);
-						float pos[3] = { tr.getOrigin()[0], tr.getOrigin()[1], tr.getOrigin()[2] };
-						b3Quaternion born = tr.getRotation();
-						float orn[4] = { born[0], born[1], born[2], born[3] };
 
 						//pressed now, not pressed before -> raise a button down event
 						if ((sPrevStates[unDevice].ulButtonPressed&trigger)==0)
@@ -765,11 +802,6 @@ bool CMainApplication::HandleInput()
 						{
 							
 
-							b3Transform tr;
-							getControllerTransform(unDevice, tr);
-							float pos[3] = { tr.getOrigin()[0], tr.getOrigin()[1], tr.getOrigin()[2] };
-							b3Quaternion born = tr.getRotation();
-							float orn[4] = { born[0], born[1], born[2], born[3] };
 	//							printf("Device RELEASED: %d, button %d\n", unDevice,button);
 					
 							//not pressed now, but pressed before -> raise a button up event

examples/pybullet/examples/vrtracker.py

@@ -0,0 +1,82 @@
+# See pybullet quickstart guide here:
+# https://docs.google.com/document/d/10sXEhzFRSnvFcl3XxNGhnD4N2SedqwdAvK3dsihxVUA/edit#
+# Create a Tiltbrush-like app, drawing lines using any controller
+# Line width can be changed
+
+import pybullet as p
+
+CONTROLLER_ID = 0
+POSITION=1
+ORIENTATION=2
+BUTTONS=6
+
+#assume that the VR physics server is already started before
+c = p.connect(p.SHARED_MEMORY)
+print(c)
+if (c<0):
+		p.connect(p.GUI)
+
+p.setInternalSimFlags(0)#don't load default robot assets etc
+p.resetSimulation()
+p.loadURDF("plane.urdf")
+
+prevPosition=[None]*p.VR_MAX_CONTROLLERS
+colors=[0.,0.5,0.5]*p.VR_MAX_CONTROLLERS
+widths = [3]*p.VR_MAX_CONTROLLERS
+a=[0,0,0]
+#use a few default colors
+colors[0] = [0,0,0]
+colors[1] = [0.5,0,0]
+colors[2] = [0,0.5,0]
+colors[3] = [0,0,0.5]
+colors[4] = [0.5,0.5,0.]
+colors[5] = [.5,.5,.5]
+
+while True:
+	events = p.getVREvents(p.VR_DEVICE_HMD+p.VR_DEVICE_GENERIC_TRACKER)
+	for e in (events):
+		pos = e[POSITION]
+		mat = p.getMatrixFromQuaternion(e[ORIENTATION])
+		dir0 = [mat[0],mat[3],mat[6]]
+		dir1 = [mat[1],mat[4],mat[7]]
+		dir2 = [mat[2],mat[5],mat[8]]
+		lineLen = 0.1
+		dir = [-mat[2],-mat[5],-mat[8]]
+
+		to = [pos[0]+lineLen*dir[0],pos[1]+lineLen*dir[1],pos[2]+lineLen*dir[2]]
+		toX = [pos[0]+lineLen*dir0[0],pos[1]+lineLen*dir0[1],pos[2]+lineLen*dir0[2]]
+		toY = [pos[0]+lineLen*dir1[0],pos[1]+lineLen*dir1[1],pos[2]+lineLen*dir1[2]]
+		toZ = [pos[0]+lineLen*dir2[0],pos[1]+lineLen*dir2[1],pos[2]+lineLen*dir2[2]]
+		p.addUserDebugLine(pos,toX,[1,0,0],1)
+		p.addUserDebugLine(pos,toY,[0,1,0],1)
+		p.addUserDebugLine(pos,toZ,[0,0,1],1)
+	
+		p.addUserDebugLine(pos,to,[0.5,0.5,0.],1,3)
+		
+	events = p.getVREvents()
+
+	for e in (events):
+		if (e[BUTTONS][33]&p.VR_BUTTON_WAS_TRIGGERED):
+			prevPosition[e[CONTROLLER_ID]] = e[POSITION]
+		if (e[BUTTONS][32]&p.VR_BUTTON_WAS_TRIGGERED):
+			widths[e[CONTROLLER_ID]]=widths[e[0]]+1
+			if (widths[e[CONTROLLER_ID]]>20):
+				widths[e[CONTROLLER_ID]] = 1
+		if (e[BUTTONS][1]&p.VR_BUTTON_WAS_TRIGGERED):
+			p.resetSimulation()
+			#p.setGravity(0,0,-10)
+			p.removeAllUserDebugItems()
+			p.loadURDF("plane.urdf")
+		if (e[BUTTONS][33]==p.VR_BUTTON_IS_DOWN):
+			pt = prevPosition[e[CONTROLLER_ID]]
+			
+			#print(prevPosition[e[0]])
+			#print(e[1])
+			diff = [pt[0]-e[POSITION][0],pt[1]-e[POSITION][1],pt[2]-e[POSITION][2]]
+			lenSqr =	diff[0]*diff[0]+diff[1]*diff[1]+diff[2]*diff[2]
+			ptDistThreshold = 0.01
+			if (lenSqr>(ptDistThreshold*ptDistThreshold)):
+				p.addUserDebugLine(e[POSITION],prevPosition[e[CONTROLLER_ID]],colors[e[CONTROLLER_ID]],widths[e[CONTROLLER_ID]])
+				#p.loadURDF("cube_small.urdf",e[1])
+				colors[e[CONTROLLER_ID]] = [1-colors[e[CONTROLLER_ID]][0],1-colors[e[CONTROLLER_ID]][1],1-colors[e[CONTROLLER_ID]][2]]
+				prevPosition[e[CONTROLLER_ID]] = e[POSITION]

examples/pybullet/pybullet.c

@@ -3166,10 +3166,11 @@ static PyObject* pybullet_getVREvents(PyObject* self, PyObject* args, PyObject*
 	b3SharedMemoryCommandHandle commandHandle;
 	b3SharedMemoryStatusHandle statusHandle;
 	int statusType;
+	int deviceTypeFilter = VR_DEVICE_CONTROLLER;
 	int physicsClientId = 0;
 	b3PhysicsClientHandle sm = 0;
-	static char* kwlist[] = {"physicsClientId", NULL};
+	static char* kwlist[] = {"deviceTypeFilter", "physicsClientId", NULL};
-	if (!PyArg_ParseTupleAndKeywords(args, keywds, "|i", kwlist, &physicsClientId))
+	if (!PyArg_ParseTupleAndKeywords(args, keywds, "|ii", kwlist, &deviceTypeFilter, &physicsClientId))
 	{
 		return NULL;
 	}
@@ -3182,6 +3183,9 @@ static PyObject* pybullet_getVREvents(PyObject* self, PyObject* args, PyObject*
 	}
 
 	commandHandle = b3RequestVREventsCommandInit(sm);
+
+	b3VREventsSetDeviceTypeFilter(commandHandle, deviceTypeFilter);
+
 	statusHandle = b3SubmitClientCommandAndWaitStatus(sm, commandHandle);
 	statusType = b3GetStatusType(statusHandle);
 	if (statusType == CMD_REQUEST_VR_EVENTS_DATA_COMPLETED)
@@ -3194,7 +3198,7 @@ static PyObject* pybullet_getVREvents(PyObject* self, PyObject* args, PyObject*
 		vrEventsObj = PyTuple_New(vrEvents.m_numControllerEvents);
 		for (i = 0; i < vrEvents.m_numControllerEvents; i++)
 		{
-			PyObject* vrEventObj = PyTuple_New(7);
+			PyObject* vrEventObj = PyTuple_New(8);
 
 			PyTuple_SetItem(vrEventObj, 0, PyInt_FromLong(vrEvents.m_controllerEvents[i].m_controllerId));
 			{
@@ -3226,6 +3230,7 @@ static PyObject* pybullet_getVREvents(PyObject* self, PyObject* args, PyObject*
 				}
 				PyTuple_SetItem(vrEventObj, 6, buttonsObj);
 			}
+			PyTuple_SetItem(vrEventObj, 7, PyInt_FromLong(vrEvents.m_controllerEvents[i].m_deviceType));
 			PyTuple_SetItem(vrEventsObj, i, vrEventObj);
 		}
 		return vrEventsObj;
@@ -5592,6 +5597,10 @@ initpybullet(void)
 	PyModule_AddIntConstant(m, "VR_MAX_CONTROLLERS", MAX_VR_CONTROLLERS);
 	PyModule_AddIntConstant(m, "VR_MAX_BUTTONS", MAX_VR_BUTTONS);
 
+	PyModule_AddIntConstant(m, "VR_DEVICE_CONTROLLER", VR_DEVICE_CONTROLLER);
+	PyModule_AddIntConstant(m, "VR_DEVICE_HMD", VR_DEVICE_HMD);
+	PyModule_AddIntConstant(m, "VR_DEVICE_GENERIC_TRACKER", VR_DEVICE_GENERIC_TRACKER);
+
 	PyModule_AddIntConstant(m, "KEY_IS_DOWN", eButtonIsDown);
 	PyModule_AddIntConstant(m, "KEY_WAS_TRIGGERED", eButtonTriggered);
 	PyModule_AddIntConstant(m, "KEY_WAS_RELEASED", eButtonReleased);