Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision

Target

Select target project
  • danc/MicroCART
  • snawerdt/MicroCART_17-18
  • bbartels/MicroCART_17-18
  • jonahu/MicroCART
4 results
Select Git revision
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 2263 deletions
src/vrpn/client_src/forcedevice_test_client.dsp deleted 100644 → 0
View file @ 4375e2bb
# Microsoft Developer Studio Project File - Name="forcedevice_test_client" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=forcedevice_test_client - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "forcedevice_test_client.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "forcedevice_test_client.mak" CFG="forcedevice_test_client - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "forcedevice_test_client - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "forcedevice_test_client - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "forcedevice_test_client - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MD /W3 /GX /O2 /I ".." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /libpath:"../pc_win32/Release" /libpath:"../pc_win32/DLL/Release"
!ELSEIF "$(CFG)" == "forcedevice_test_client - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I ".." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"../pc_win32/Debug" /libpath:"../pc_win32/DLL/Debug"
!ENDIF
# Begin Target
# Name "forcedevice_test_client - Win32 Release"
# Name "forcedevice_test_client - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\forcedevice_test_client.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project
src/vrpn/client_src/forcedevice_test_client.vcproj deleted 100644 → 0
View file @ 4375e2bb
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="forcedevice_test_client"
ProjectGUID="{91042ED0-E0EC-40E1-9AEB-FD5296EA11A7}"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Debug/forcedevice_test_client.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;$(SYSTEMDRIVE)\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Include&quot;;&quot;$(SYSTEMDRIVE)\Program Files\Microsoft Platform SDK\Include&quot;;..;..\..\quat"
PreprocessorDefinitions="_CRT_SECURE_NO_DEPRECATE"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
PrecompiledHeaderFile=".\Debug/forcedevice_test_client.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
BrowseInformation="1"
WarningLevel="3"
SuppressStartupBanner="true"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile=".\Debug/forcedevice_test_client.exe"
LinkIncremental="2"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(SYSTEMDRIVE)\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Lib"
GenerateDebugInformation="true"
ProgramDatabaseFile=".\Debug/forcedevice_test_client.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
SuppressStartupBanner="true"
OutputFile=".\Debug/forcedevice_test_client.bsc"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Release/forcedevice_test_client.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="&quot;$(SYSTEMDRIVE)\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Include&quot;;&quot;$(SYSTEMDRIVE)\Program Files\Microsoft Platform SDK\Include&quot;;..;..\..\quat"
PreprocessorDefinitions="_CRT_SECURE_NO_DEPRECATE"
StringPooling="true"
RuntimeLibrary="2"
EnableFunctionLevelLinking="true"
PrecompiledHeaderFile=".\Release/forcedevice_test_client.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="true"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
OutputFile=".\Release/forcedevice_test_client.exe"
LinkIncremental="1"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(SYSTEMDRIVE)\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Lib"
ProgramDatabaseFile=".\Release/forcedevice_test_client.pdb"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
SuppressStartupBanner="true"
OutputFile=".\Release/forcedevice_test_client.bsc"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
>
<File
RelativePath="forcedevice_test_client.cpp"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl"
>
</Filter>
<Filter
Name="Resource Files"
Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
src/vrpn/client_src/forwarderClient.C deleted 100644 → 0
View file @ 4375e2bb
#include <vrpn_Connection.h>
#include <vrpn_ForwarderController.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// This program connects to a vrpn (Tracker) server and can be used
// to tell it to open ports for other clients to listen to and to
// start forwarding Tracker messages to them.
// Tom Hudson, October 1998
vrpn_Connection * connection;
vrpn_Forwarder_Controller * controller;
void Usage (char * s) {
fprintf(stderr, "Usage: %s location\n", s);
exit(0);
}
int main (int argc, char ** argv) {
char ib [1000];
char sb [75], tb [75];
char * qp;
char * source_location;
int port;
int len;
if (argc != 2) Usage(argv[0]);
source_location = argv[1];
connection = vrpn_get_connection_by_name (source_location);
controller = new vrpn_Forwarder_Controller (connection);
printf("Commands:\n"
" quit\n"
" open <port>\n"
" forward <port> \"<service name>\" \"<message type>\"\n");
do {
if (fgets(ib, 1000, stdin) == NULL) {
perror("Could not read line");
return -1;
}
fprintf(stderr, "Got: >%s<\n", ib);
if (!strncmp(ib, "open", 4)) {
port = atoi(ib + 5);
controller->start_remote_forwarding(port);
fprintf(stderr, "Opening %d.\n", port);
}
if (!strncmp(ib, "forward", 7)) {
port = atoi(ib + 8);
qp = strchr(ib, '\"'); // start of service name
qp++;
len = static_cast<int>(strcspn(qp, "\"")); fprintf(stderr, "Prefix len %d.\n", len);
strncpy(sb, qp, len);
sb[len] = '\0';
qp = strchr(qp, '\"'); // end of service name
qp++;
qp = strchr(qp, '\"'); // start of message type name
qp++;
len = static_cast<int>(strcspn(qp, "\"")); fprintf(stderr, "Prefix len %d.\n", len);
strncpy(tb, qp, len);
tb[len] = '\0';
qp = strchr(qp, '\"'); // end of message type name
controller->forward_message_type(port, sb, tb);
fprintf(stderr, "Forwarding %s of %s on %d.\n", tb, sb, port);
}
connection->mainloop();
} while (strncmp(ib, "quit", 4));
}
src/vrpn/client_src/haptic/Makefile deleted 100644 → 0
View file @ 4375e2bb
CC = gcc
CXX = g++
CFLAGS = -O
CCFLAGS = -O
VRPNDIR = $(HOME)/vrpn
VRPNINC = -I$(VRPNDIR)/include
VRPNLIB = -L$(VRPNDIR)/lib -lvrpn -lquat -lpthread
INCS = $(VRPNINC)
LIBS = $(VRPNLIB) -lm
OBJS = testvrpn.o phantom-field.o phantom-plane.o phantom-wave.o \
glwin.o glvrpn.o smdvrpn.o
BINS = testvrpn phantom-field phantom-plane phantom-wave glvrpn smdvrpn
all: $(BINS) $(OBJS)
.c.o :
$(CC) $(CCFLAGS) $(INCS) -c $*.c
.C.o :
$(CXX) $(CCFLAGS) $(INCS) -c $*.C
glwin.o : glwin.c glwin.h
$(CC) $(CCFLAGS) -DUSEOPENGL $(INCS) -c $*.c
testvrpn : testvrpn.o
$(CXX) $(CCFLAGS) $(INCS) testvrpn.o $(LIBS) -o $@
phantom-field : phantom-field.o
$(CXX) $(CCFLAGS) $(INCS) phantom-field.o $(LIBS) -o $@
phantom-plane : phantom-plane.o
$(CXX) $(CCFLAGS) $(INCS) phantom-plane.o $(LIBS) -o $@
phantom-wave : phantom-wave.o
$(CXX) $(CCFLAGS) $(INCS) phantom-wave.o $(LIBS) -o $@
glvrpn : glvrpn.o glwin.o
$(CXX) $(CCFLAGS) $(INCS) glvrpn.o glwin.o $(LIBS) -lGL -lGLU -lX11 -o $@
smdvrpn: smdvrpn.o glwin.o
$(CXX) $(CCFLAGS) $(INCS) smdvrpn.o glwin.o $(LIBS) -lGL -lGLU -lX11 -o $@
clean :
rm -f $(OBJS) $(BINS)
src/vrpn/client_src/haptic/README deleted 100644 → 0
View file @ 4375e2bb
This directory contains test and example files for using a Phantom
force-feedback device with VRPN. They were written by John Stone
at the NIH Resource for Macromolecular Modeling and Bioinformatics at the
Beckman Institute at UIUC.
These programs are made to compile and run on an SGI. The VRPN portions of
these programs should be portable across platforms, but the openGL portions
(if any) have not been ported to Windows.
This README is made by Russ Taylor, so hopefully it is accurate.
testvrpn.C:
This opens the Phantom as a tracker, button, and forcedevice.
It prints out all tracker messages, button messages, amd force messages
(should there be force messages?)
glwin.[hc]:
Helper functions to create openGL windows quickly and easily on Unix.
glvrpn.C:
This opens and openGL window and displays the tracker as it moves
around (along with a line from the origin to the tracker). It is a good
example of how to use a VRPN tracker with openGL.
phantom-field.C:
Sends a forcefield to the Phantom when the button is held down.
phantom-plane.C:
Sends a plane to the Phantom that the user can feel, quits when the
button is pressed.
phantom-wave.c:
Sends a spatially-varying force field to the Phantom while the button
is held down.
smdvrpn.C:
Simple molecular dynamics simulation using VRPN, graphics, and haptics.
src/vrpn/client_src/haptic/drag-sphere.C deleted 100644 → 0
View file @ 4375e2bb
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <vrpn_ForceDevice.h>
#include <vrpn_Tracker.h>
#include <vrpn_Button.h>
#define PHANTOM_SERVER "Tracker0@localhost"
/*****************************************************************************
*
Callback handler
*
*****************************************************************************/
void handle_force_change(void *userdata, const vrpn_FORCECB f)
{
static vrpn_FORCECB lr; // last report
static int first_report_done = 0;
if ((!first_report_done) ||
((f.force[0] != lr.force[0]) || (f.force[1] != lr.force[1])
|| (f.force[2] != lr.force[2]))) {
//printf("force is (%f,%f,%f)\n", f.force[0], f.force[1], f.force[2]);
}
first_report_done = 1;
lr = f;
}
void handle_tracker_change(void *userdata, const vrpn_TRACKERCB t)
{
static vrpn_TRACKERCB lr; // last report
static float dist_interval_sq = 0.004;
float *pos = (float *)userdata;
if ((lr.pos[0] - t.pos[0])*(lr.pos[0] - t.pos[0]) +
(lr.pos[1] - t.pos[1])*(lr.pos[1] - t.pos[1]) +
(lr.pos[2] - t.pos[2])*(lr.pos[2] - t.pos[2]) + dist_interval_sq){
//printf("Sensor %d is now at (%g,%g,%g)\n", t.sensor,
// t.pos[0], t.pos[1], t.pos[2]);
lr = t;
}
pos[0] = t.pos[0];
pos[1] = t.pos[1];
pos[2] = t.pos[2];
}
void handle_button_change(void *userdata, const vrpn_BUTTONCB b)
{
static int buttonstate = 1;
if (b.state != buttonstate) {
printf("button #%ld is in state %ld\n", b.button, b.state);
buttonstate = b.state;
}
*(int *)userdata = buttonstate;
}
int main(int argc, char *argv[])
{
int done = 0;
float pos[3];
int forceInEffect = 0;
int forceEnabled = 0;
vrpn_ForceDevice_Remote *forceDevice;
vrpn_Tracker_Remote *tracker;
vrpn_Button_Remote *button;
/* initialize the force device */
forceDevice = new vrpn_ForceDevice_Remote(PHANTOM_SERVER);
forceDevice->register_change_handler(NULL, handle_force_change);
/* initialize the tracker */
tracker = new vrpn_Tracker_Remote(PHANTOM_SERVER);
tracker->register_change_handler((void *)pos, handle_tracker_change);
/* initialize the button */
button = new vrpn_Button_Remote(PHANTOM_SERVER);
button->register_change_handler((void *)&forceEnabled, handle_button_change);
// main loop
while (! done )
{
// Let the forceDevice send its messages to remote force device
forceDevice->mainloop();
// Let tracker receive position information from remote tracker
tracker->mainloop();
// Let button receive button status from remote button
button->mainloop();
if (forceEnabled) {
forceDevice->setFF_Origin(0.1,0.1,0.0);
// units = dynes
forceDevice->setFF_Force(-10.0*pos[0],-10.0*pos[1],-10.0*pos[2]);
// set derivatives of force field:
// units = dynes/meter
forceDevice->setFF_Jacobian(-10,0, 0, 0,
-10, 0, 0, 0,
-10);
forceDevice->setFF_Radius(0.2); // 20cm radius of validity
forceDevice->sendForceField();
forceInEffect = 1;
}
else if (forceInEffect){
forceDevice->stopForceField();
forceInEffect = 0;
}
}
} /* main */
src/vrpn/client_src/haptic/glvrpn.C deleted 100644 → 0
View file @ 4375e2bb
#include <stdio.h>
#include "vrpn_Tracker.h"
#include "vrpn_Button.h"
#include "vrpn_ForceDevice.h"
#include "quat.h"
#include "glwin.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>
typedef struct {
float x; // position
float y;
float z;
double qx, qy, qz, qw; // quaternion orientation
} posquat;
typedef struct {
int b[100];
} buttons;
void handle_tracker(void *userdata, const vrpn_TRACKERCB t) {
posquat *pq = (posquat *) userdata;
pq->x = t.pos[0];
pq->y = t.pos[1];
pq->z = t.pos[2];
pq->qx=t.quat[Q_X];
pq->qy=t.quat[Q_Y];
pq->qz=t.quat[Q_Z];
pq->qw=t.quat[Q_W];
}
void handle_button(void *userdata, const vrpn_BUTTONCB b) {
buttons *bt = (buttons *) userdata;
if (b.button < 100)
bt->b[b.button] = b.state;
printf("\nButton %3d is in state: %d \n",
b.button, b.state);
fflush(stdout);
}
void handle_force(void *userdata, const vrpn_FORCECB f) {
#if 0
static vrpn_FORCECB lr; // last report
static int first_report_done = 0;
if ((!first_report_done) || ((f.force[0] != lr.force[0]) ||
(f.force[1] != lr.force[1]) || (f.force[2] != lr.force[2])))
printf("\nForce is (%11f, %11f, %11f) \n",
f.force[0], f.force[1], f.force[2]);
first_report_done = 1;
lr = f;
#endif
}
void init_graphics(void *myglwin) {
glwin_handle_events(myglwin); // let window to open and handle events once
glwin_handle_events(myglwin); // let window to open and handle events once
// setup OpenGL state...
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, 1.0, 0.01, 10.0);
gluLookAt( 0.0, 0.1, -5.0, // eye pos
0.0, 0.0, 0.0, // look at this point
0.0, 1.0, 0.0); // up direction
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
//
// Setup cute lighting parms..
//
glEnable(GL_LIGHTING);
glEnable(GL_LEQUAL);
GLfloat lpos[] = { 0.0, 0.0, -100.0, 1.0};
GLfloat lamb[] = { 0.05, 0.05, 0.05, 1.0};
GLfloat ldif[] = { 0.5, 0.5, 0.5, 1.0};
GLfloat lspc[] = { 0.5, 0.5, 0.5, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, lpos);
glLightfv(GL_LIGHT0, GL_AMBIENT, lamb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, ldif);
glLightfv(GL_LIGHT0, GL_SPECULAR, lspc);
glLightf(GL_LIGHT0, GL_SHININESS, 400.0);
glEnable(GL_LIGHT0);
GLfloat mdif[] = {0.9, 0.0, 0.2, 1.0};
GLfloat mspc[] = {0.2, 0.2, 0.2, 1.0};
glMaterialfv(GL_FRONT, GL_SPECULAR, mspc);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mdif);
glEnable(GL_COLOR_MATERIAL);
}
void draw_axes() {
//
// Draw Coordinate Axes
//
glDisable(GL_LIGHTING);
glBegin(GL_LINES);
float i;
glColor3f(0.0, 1.0, 0.0);
for (i=-10; i<10; i += 0.50) {
glVertex3f( -10.0, 0.0, i);
glVertex3f( 10.0, 0.0, i);
glVertex3f( i, 0.0, -10.0);
glVertex3f( i, 0.0, 10.0);
}
glEnd();
}
void draw_tracker(posquat *pq, GLUquadricObj *qobj1, GLUquadricObj *qobj2)
{
float x, y, z;
// Convert from haptic coordinates to our scene coordinates
x=-10.0*(pq->x);
y=10.0*(pq->y);
z=-10.0*(pq->z);
double q[4] = {-(pq->qx), (pq->qy), -(pq->qz), pq->qw};
// convert the orientation from quaternion to OpenGL matrix
double rotation[16];
q_to_ogl_matrix(rotation,q);
// Draw the tracker itself
//
// First draw line to object
glColor3f(1.0, 1.0, 1.0);
glBegin(GL_LINES);
glVertex3f(0.0, 0.0, 0.0 );
glVertex3f(x, y, z);
glEnd();
glEnable(GL_LIGHTING);
glColor3f(1.0, 0.0, 0.2);
glPushMatrix();
glTranslatef(x, y, z);
glMultMatrixd(rotation);
glTranslatef(-1.5, 0.0, 0.0);
gluSphere(qobj1, 0.2, 32, 32);
glTranslatef(3.0,0.0,0.0);
gluSphere(qobj2, 0.2, 32, 32);
glPopMatrix();
}
int main(int argc, char **argv) {
char * server;
posquat *tposquat = new posquat;
buttons bpos;
vrpn_Tracker_Remote *tkr;
vrpn_Button_Remote *btn;
vrpn_ForceDevice_Remote *fdv;
if (argc < 2) {
printf("%s: Invalid parms\n", argv[0]);
printf("usage: \n");
printf(" %s Tracker0@host\n", argv[0]);
return -1;
}
server = argv[1];
printf("Opening: %s ...\n", server);
tkr = new vrpn_Tracker_Remote(server);
tkr->register_change_handler(tposquat, handle_tracker);
btn = new vrpn_Button_Remote(server);
btn->register_change_handler(&bpos, handle_button);
fdv = new vrpn_ForceDevice_Remote(server);
fdv->register_force_change_handler(NULL, handle_force);
void * myglwin = glwin_create(700, 700);
if (myglwin == NULL) {
printf("Failed to open OpenGL window!!\n");
return -1;
}
init_graphics(myglwin);
GLUquadricObj *qobj1 = gluNewQuadric();
GLUquadricObj *qobj2 = gluNewQuadric();
/*
* main interactive loop
*/
while (1) {
// Let the tracker do its thing
tkr->mainloop();
btn->mainloop();
fdv->mainloop();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
draw_axes();
draw_tracker(tposquat, qobj1, qobj2);
glwin_swap_buffers(myglwin);
}
} /* main */
src/vrpn/client_src/haptic/glwin.c deleted 100644 → 0
View file @ 4375e2bb
/*
* glwin.c -- simple code for opening an OpenGL display window, and doing
* BitBlt operations or whatever...
*
*/
#include <stdio.h>
#include <stdlib.h>
#ifdef USEOPENGL
#if !defined(WIN32) && !defined(_MSC_VER)
#include <X11/Xlib.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>
#include "glwin.h"
typedef struct {
int scrnum;
Display *dpy;
Window root;
Window win;
GLXContext ctx;
int width;
int height;
} oglhandle;
void * glwin_create(int width, int height) {
oglhandle * handle;
XSetWindowAttributes attr;
unsigned long mask;
XVisualInfo *visinfo;
int attrib[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1, GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER, None };
handle = (oglhandle *) malloc(sizeof(oglhandle));
if (handle == NULL) {
printf("failed to allocate handle\n");
return NULL;
}
handle->width = width;
handle->height = height;
handle->dpy = XOpenDisplay(getenv("DISPLAY"));
if (handle->dpy == NULL) {
printf("failed to open Display!!\n");
free(handle);
return NULL;
}
handle->scrnum = DefaultScreen( handle->dpy );
handle->root = RootWindow( handle->dpy, handle->scrnum );
visinfo = glXChooseVisual( handle->dpy, handle->scrnum, attrib );
if (visinfo == NULL) {
printf("Error: couldn't get an RGB, Double-buffered visual\n");
free(handle);
return NULL;
}
/* window attributes */
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = XCreateColormap(handle->dpy, handle->root,
visinfo->visual, AllocNone);
attr.event_mask = StructureNotifyMask | ExposureMask;
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
handle->win = XCreateWindow(handle->dpy, handle->root, 0, 0, width, height,
0, visinfo->depth, InputOutput,
visinfo->visual, mask, &attr );
handle->ctx = glXCreateContext( handle->dpy, visinfo, NULL, True );
glXMakeCurrent( handle->dpy, handle->win, handle->ctx );
XStoreName(handle->dpy, handle->win,
"OpenGL Window");
XMapWindow(handle->dpy, handle->win);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glwin_swap_buffers(handle);
glClear(GL_COLOR_BUFFER_BIT);
glwin_swap_buffers(handle);
glwin_handle_events(handle);
glwin_handle_events(handle);
XFlush(handle->dpy);
return handle;
}
void glwin_destroy(void * voidhandle) {
oglhandle * handle = (oglhandle *) voidhandle;
if (handle == NULL)
return;
XUnmapWindow(handle->dpy, handle->win);
glXMakeCurrent(handle->dpy, None, NULL);
XDestroyWindow(handle->dpy, handle->win);
XCloseDisplay(handle->dpy);
}
void glwin_swap_buffers(void * voidhandle) {
oglhandle * handle = (oglhandle *) voidhandle;
if (handle != NULL)
glXSwapBuffers(handle->dpy, handle->win);
}
int glwin_handle_events(void * voidhandle) {
oglhandle * handle = (oglhandle *) voidhandle;
XEvent event;
if (handle == NULL)
return 0;
XNextEvent(handle->dpy, &event);
switch(event.type) {
case ConfigureNotify:
handle->width = event.xconfigure.width;
handle->height = event.xconfigure.height;
glShadeModel(GL_FLAT);
glViewport(0, 0, handle->width, handle->height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* this is upside-down for what most code thinks, but it is */
/* right side up for the ray tracer.. */
gluOrtho2D(0.0, handle->width, 0.0, handle->height);
glMatrixMode(GL_MODELVIEW);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelZoom(1.0, 1.0); /* for upside-down images that ray uses */
return 1;
}
return 0;
}
void glwin_draw_image(void * voidhandle, int xsize, int ysize,
unsigned char * img) {
glRasterPos2i(0, 0);
glDrawPixels(xsize, ysize, GL_RGB, GL_UNSIGNED_BYTE, img);
glwin_swap_buffers(voidhandle);
}
#else
/*
* WIN32 Version
*/
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "glwin.h"
typedef struct {
HWND hWnd;
HDC hDC;
HGLRC hRC;
long scrwidth;
long scrheight;
int width;
int height;
} oglhandle;
static char szAppName[] = "OpenGL";
static char szAppTitle[]="OpenGL Window";
/* XXX GET RID OF THIS!!!!! */
static oglhandle * globhandle; /* XXX GET RID OF THIS!!!!! */
/* XXX GET RID OF THIS!!!!! */
/*
* declaration of myWindowProc()
*/
LONG WINAPI myWindowProc( HWND, UINT, WPARAM, LPARAM );
static int OpenWin32Connection(oglhandle * handle) {
WNDCLASS wc;
HINSTANCE hInstance = GetModuleHandle(NULL);
/* Clear (important!) and then fill in the window class structure. */
memset(&wc, 0, sizeof(WNDCLASS));
wc.style = CS_OWNDC;
wc.lpfnWndProc = (WNDPROC) myWindowProc;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = LoadCursor(hInstance, IDC_ARROW);
wc.hbrBackground = NULL; /* Default color */
wc.lpszMenuName = NULL;
wc.lpszClassName = szAppName;
if(!RegisterClass(&wc)) {
printf("Cannot register window class.\n");
return -1;
}
handle->scrwidth = GetSystemMetrics(SM_CXSCREEN);
handle->scrheight = GetSystemMetrics(SM_CYSCREEN);
return 0;
}
static HGLRC SetupOpenGL(HWND hWnd) {
int nMyPixelFormatID;
HDC hDC;
HGLRC hRC;
static PIXELFORMATDESCRIPTOR pfd = {
sizeof (PIXELFORMATDESCRIPTOR), /* struct size */
1, /* Version number */
PFD_DRAW_TO_WINDOW /* Flags, draw to a window, */
| PFD_SUPPORT_OPENGL, /* use OpenGL */
PFD_TYPE_RGBA, /* RGBA pixel values */
24, /* 24-bit color */
0, 0, 0, /* RGB bits & shift sizes. */
0, 0, 0, /* Don't care about them */
0, 0, /* No alpha buffer info */
0, 0, 0, 0, 0, /* No accumulation buffer */
32, /* 32-bit depth buffer */
0, /* No stencil buffer */
0, /* No auxiliary buffers */
PFD_MAIN_PLANE, /* Layer type */
0, /* Reserved (must be 0) */
0, /* No layer mask */
0, /* No visible mask */
0 /* No damage mask */
};
hDC = GetDC(hWnd);
nMyPixelFormatID = ChoosePixelFormat(hDC, &pfd);
/*
* catch errors here.
* If nMyPixelFormat is zero, then there's
* something wrong... most likely the window's
* style bits are incorrect (in CreateWindow() )
* or OpenGL isn't installed on this machine
*
*/
if (nMyPixelFormatID == 0) {
printf("Error selecting OpenGL Pixel Format!!\n");
return NULL;
}
SetPixelFormat( hDC, nMyPixelFormatID, &pfd );
hRC = wglCreateContext(hDC);
ReleaseDC(hWnd, hDC);
return hRC;
}
static int myCreateWindow(oglhandle * handle,
int xpos, int ypos, int xs, int ys) {
/* Create a main window for this application instance. */
handle->hWnd =
CreateWindow(
szAppName, /* app name */
szAppTitle, /* Text for window title bar */
WS_OVERLAPPEDWINDOW /* Window style */
| WS_CLIPCHILDREN
| WS_CLIPSIBLINGS, /* NEED THESE for OpenGL calls to work! */
xpos, ypos,
xs, ys,
NULL, /* no parent window */
NULL, /* Use the window class menu. */
GetModuleHandle(NULL), /* This instance owns this window */
handle /* We don't use any extra data */
);
if (!handle->hWnd) {
printf("Couldn't Open Window!!\n");
return -1;
}
handle->hDC = GetDC(handle->hWnd);
wglMakeCurrent(handle->hDC, handle->hRC);
/* Make the window visible & update its client area */
ShowWindow( handle->hWnd, SW_SHOW); /* Show the window */
UpdateWindow( handle->hWnd ); /* Sends WM_PAINT message */
return 0;
}
LONG WINAPI myWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
PAINTSTRUCT ps; /* Paint structure. */
switch(msg) {
case WM_CREATE:
globhandle->hRC = SetupOpenGL(hwnd);
return 0;
case WM_SIZE:
// hDC = GetDC(hwnd);
wglMakeCurrent(globhandle->hDC, globhandle->hRC);
glShadeModel(GL_FLAT);
glViewport(0, 0, (GLsizei) LOWORD(lParam), (GLsizei) HIWORD (lParam));
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* this is upside-down for what most code thinks, but it is */
/* right side up for the ray tracer.. */
gluOrtho2D(0.0, (GLsizei) LOWORD(lParam), 0.0, (GLsizei) HIWORD (lParam));
glMatrixMode(GL_MODELVIEW);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelZoom(1.0, 1.0); /* for upside-down images that ray uses */
return 0;
case WM_CLOSE:
PostQuitMessage(0);
return 0;
case WM_PAINT:
BeginPaint(hwnd, &ps);
EndPaint(hwnd, &ps);
return 0;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
}
void * glwin_create(int width, int height) {
oglhandle * handle;
int rc;
handle = (oglhandle *) malloc(sizeof(oglhandle));
if (handle == NULL)
return NULL;
globhandle = handle;
rc = OpenWin32Connection(handle);
if (rc != 0) {
printf("OpenWin32Connection() returned an error!\n");
free(handle);
return NULL;
}
handle->width = width;
handle->height = height;
rc = myCreateWindow(handle, 0, 0, width, height);
if (rc != 0) {
printf("CreateWindow() returned an error!\n");
free(handle);
return NULL;
}
return handle;
}
void glwin_destroy(void * voidhandle) {
oglhandle * handle = (oglhandle *) voidhandle;
wglDeleteContext(handle->hRC);
PostQuitMessage( 0 );
/* glwin_handle_events(handle); */
}
void glwin_swap_buffers(void * voidhandle) {
oglhandle * handle = (oglhandle *) voidhandle;
glFlush();
}
int glwin_handle_events(void * voidhandle) {
oglhandle * handle = (oglhandle *) voidhandle;
MSG msg;
if (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
return 1;
}
return 0;
}
void glwin_draw_image(void * voidhandle, int xsize, int ysize, unsigned char * img) {
oglhandle * handle = (oglhandle *) voidhandle;
glRasterPos2i(0, 0);
glDrawPixels(xsize, ysize, GL_RGB, GL_UNSIGNED_BYTE, img);
glwin_swap_buffers(voidhandle);
return;
}
#endif
#else
void * glwin_create(int width, int height) {
return NULL;
}
void glwin_destroy(void * voidhandle) {
return;
}
void glwin_swap_buffers(void * voidhandle) {
return;
}
int glwin_handle_events(void * voidhandle) {
return 0;
}
void glwin_draw_image(void * voidhandle, int xsize, int ysize, unsigned char * img) {
return;
}
#endif
src/vrpn/client_src/haptic/glwin.h deleted 100644 → 0
View file @ 4375e2bb
#ifdef __cplusplus
extern "C" {
#endif
void * glwin_create(int width, int height);
void glwin_destroy(void * voidhandle);
void glwin_swap_buffers(void * voidhandle);
int glwin_handle_events(void * voidhandle);
void glwin_draw_image(void * voidhandle, int xsize, int ysize, unsigned char * img);
#ifdef __cplusplus
}
#endif
src/vrpn/client_src/haptic/phantom-field.C deleted 100644 → 0
View file @ 4375e2bb
#include <stdlib.h>
#include <stdio.h>
#include <vrpn_ForceDevice.h>
#include <vrpn_Tracker.h>
#include <vrpn_Button.h>
/*****************************************************************************
*
Callback handler
*
*****************************************************************************/
void handle_force_change(void *userdata, const vrpn_FORCECB f)
{
static vrpn_FORCECB lr; // last report
static int first_report_done = 0;
if ((!first_report_done) ||
((f.force[0] != lr.force[0]) || (f.force[1] != lr.force[1])
|| (f.force[2] != lr.force[2]))) {
//printf("force is (%f,%f,%f)\n", f.force[0], f.force[1], f.force[2]);
}
first_report_done = 1;
lr = f;
}
void handle_tracker_change(void *userdata, const vrpn_TRACKERCB t)
{
static vrpn_TRACKERCB lr; // last report
static float dist_interval_sq = 0.004;
float *pos = (float *)userdata;
if ((lr.pos[0] - t.pos[0])*(lr.pos[0] - t.pos[0]) +
(lr.pos[1] - t.pos[1])*(lr.pos[1] - t.pos[1]) +
(lr.pos[2] - t.pos[2])*(lr.pos[2] - t.pos[2]) + dist_interval_sq){
//printf("Sensor %d is now at (%g,%g,%g)\n", t.sensor,
// t.pos[0], t.pos[1], t.pos[2]);
lr = t;
}
pos[0] = t.pos[0];
pos[1] = t.pos[1];
pos[2] = t.pos[2];
}
void handle_button_change(void *userdata, const vrpn_BUTTONCB b)
{
static int buttonstate = 1;
if (b.state != buttonstate) {
printf("button #%ld is in state %ld\n", b.button, b.state);
buttonstate = b.state;
}
*(int *)userdata = buttonstate;
}
int main(int argc, char **argv) {
int done = 0;
float pos[3];
int forceInEffect = 0;
int forceEnabled = 0;
vrpn_ForceDevice_Remote *forceDevice;
vrpn_Tracker_Remote *tracker;
vrpn_Button_Remote *button;
if (argc < 2) {
printf("Usage: %s Phantom@machine\n", argv[0]);
exit(1);
}
char * servername = argv[1];
/* initialize the force device */
forceDevice = new vrpn_ForceDevice_Remote(servername);
forceDevice->register_force_change_handler(NULL, handle_force_change);
/* initialize the tracker */
tracker = new vrpn_Tracker_Remote(servername);
tracker->register_change_handler((void *)pos, handle_tracker_change);
/* initialize the button */
button = new vrpn_Button_Remote(servername);
button->register_change_handler((void *)&forceEnabled, handle_button_change);
// main loop
while (! done ) {
// Let the forceDevice send its messages to remote force device
forceDevice->mainloop();
// Let tracker receive position information from remote tracker
tracker->mainloop();
// Let button receive button status from remote button
button->mainloop();
if (forceEnabled) {
forceDevice->setFF_Origin(pos[0],pos[1],pos[2]);
// units = dynes
forceDevice->setFF_Force(0.02*cos(pos[0]*200.0*M_PI),
0.02*cos(pos[1]*200.0*M_PI),
0.02*cos(pos[2]*200.0*M_PI));
// set derivatives of force field:
// units = dynes/meter
forceDevice->setFF_Jacobian(-4.0*M_PI*sin(pos[0]*200.0*M_PI), 0, 0, 0,
-4.0*M_PI*sin(pos[1]*200.0*M_PI), 0, 0, 0,
-4.0*M_PI*sin(pos[2]*200.0*M_PI));
forceDevice->setFF_Radius(0.15); // radius of validity
forceDevice->sendForceField();
forceInEffect = 1;
}
else if (forceInEffect){
forceDevice->stopForceField();
forceInEffect = 0;
}
}
} /* main */
src/vrpn/client_src/haptic/phantom-plane.C deleted 100644 → 0
View file @ 4375e2bb
#include <stdlib.h>
#include <stdio.h>
#include <vrpn_ForceDevice.h>
#include <vrpn_Tracker.h>
#include <vrpn_Button.h>
#define PHANTOM_SERVER "Phantom@budapest"
/******************************************************************************
* Callback handler
*****************************************************************************/
void handle_force_change(void *userdata, vrpn_FORCECB f)
{
static vrpn_FORCECB lr; // last report
static int first_report_done = 0;
if ((!first_report_done) ||
((f.force[0] != lr.force[0]) || (f.force[1] != lr.force[1])
|| (f.force[2] != lr.force[2])))
printf("force is (%f,%f,%f)\n", f.force[0], f.force[1], f.force[2]);
first_report_done = 1;
lr = f;
}
void handle_tracker_change(void *userdata, const vrpn_TRACKERCB t)
{
static vrpn_TRACKERCB lr; // last report
static float dist_interval_sq = 0.004;
if ((lr.pos[0] - t.pos[0])*(lr.pos[0] - t.pos[0]) +
(lr.pos[1] - t.pos[1])*(lr.pos[1] - t.pos[1]) +
(lr.pos[2] - t.pos[2])*(lr.pos[2] - t.pos[2]) > dist_interval_sq){
printf("Sensor %d is now at (%g,%g,%g)\n", t.sensor,
t.pos[0], t.pos[1], t.pos[2]);
lr = t;
}
}
void handle_button_change(void *userdata, vrpn_BUTTONCB b)
{
static int count=0;
static int buttonstate = 1;
int done = 0;
if (b.state != buttonstate) {
printf("button #%ld is in state %ld\n", b.button, b.state);
buttonstate = b.state;
count++;
}
if (count > 4)
done = 1;
*(int *)userdata = done;
}
int main(int argc, char *argv[]) {
int done = 0;
vrpn_ForceDevice_Remote *forceDevice;
vrpn_Tracker_Remote *tracker;
vrpn_Button_Remote *button;
/* initialize the force device */
forceDevice = new vrpn_ForceDevice_Remote(PHANTOM_SERVER);
forceDevice->register_force_change_handler(NULL, handle_force_change);
/* initialize the tracker */
tracker = new vrpn_Tracker_Remote(PHANTOM_SERVER);
tracker->register_change_handler(NULL, handle_tracker_change);
/* initialize the button */
button = new vrpn_Button_Remote(PHANTOM_SERVER);
button->register_change_handler(&done, handle_button_change);
// Set plane and surface parameters
forceDevice->set_plane(0.0, 1.0, 0.0, 1.0);
forceDevice->setSurfaceKspring(0.1); // spring constant - units of
// dynes/cm
forceDevice->setSurfaceKdamping(0.002); // damping constant -
// units of dynes*sec/cm
forceDevice->setSurfaceFstatic(0.01); // set static friction
forceDevice->setSurfaceFdynamic(0.005); // set dynamic friction
forceDevice->setRecoveryTime(10); // recovery occurs over 10
// force update cycles
// enable force device and send first surface
forceDevice->startSurface();
// main loop
while (! done ){
// Let the forceDevice send its planes to remote force device
forceDevice->mainloop();
// Let tracker receive position information from remote tracker
tracker->mainloop();
// Let button receive button status from remote button
button->mainloop();
// we may call forceDevice->set_plane(...) followed by
// forceDevice->sendSurface() here to change the plane
// for example: using position information from a tracker we can
// compute a plane to approximate a complex surface at that
// position and send that approximation 15-30 times per
// second to simulate the complex surface
}
// shut off force device
forceDevice->stopSurface();
} /* main */
src/vrpn/client_src/haptic/phantom-wave.C deleted 100644 → 0
View file @ 4375e2bb
#include <stdlib.h>
#include <stdio.h>
#include <vrpn_ForceDevice.h>
#include <vrpn_Tracker.h>
#include <vrpn_Button.h>
#define PHANTOM_SERVER "Tracker0@localhost"
/*****************************************************************************
*
Callback handler
*
*****************************************************************************/
void handle_force_change(void *userdata, const vrpn_FORCECB f)
{
static vrpn_FORCECB lr; // last report
static int first_report_done = 0;
if ((!first_report_done) ||
((f.force[0] != lr.force[0]) || (f.force[1] != lr.force[1])
|| (f.force[2] != lr.force[2]))) {
//printf("force is (%f,%f,%f)\n", f.force[0], f.force[1], f.force[2]);
}
first_report_done = 1;
lr = f;
}
void handle_tracker_change(void *userdata, const vrpn_TRACKERCB t)
{
static vrpn_TRACKERCB lr; // last report
static float dist_interval_sq = 0.04;
float *pos = (float *)userdata;
if ((lr.pos[0] - t.pos[0])*(lr.pos[0] - t.pos[0]) +
(lr.pos[1] - t.pos[1])*(lr.pos[1] - t.pos[1]) +
(lr.pos[2] - t.pos[2])*(lr.pos[2] - t.pos[2]) + dist_interval_sq){
//printf("Sensor %d is now at (%g,%g,%g)\n", t.sensor,
// t.pos[0], t.pos[1], t.pos[2]);
lr = t;
}
pos[0] = t.pos[0];
pos[1] = t.pos[1];
pos[2] = t.pos[2];
}
void handle_button_change(void *userdata, const vrpn_BUTTONCB b)
{
static int buttonstate = 1;
if (b.state != buttonstate) {
printf("button #%ld is in state %ld\n", b.button, b.state);
buttonstate = b.state;
}
*(int *)userdata = buttonstate;
}
int main(int argc, char *argv[]) {
int done = 0;
float pos[3];
int forceInEffect = 0;
int forceEnabled = 0;
vrpn_ForceDevice_Remote *forceDevice;
vrpn_Tracker_Remote *tracker;
vrpn_Button_Remote *button;
float t;
/* initialize the force device */
forceDevice = new vrpn_ForceDevice_Remote(PHANTOM_SERVER);
forceDevice->register_force_change_handler(NULL, handle_force_change);
/* initialize the tracker */
tracker = new vrpn_Tracker_Remote(PHANTOM_SERVER);
tracker->register_change_handler((void *)pos, handle_tracker_change);
/* initialize the button */
button = new vrpn_Button_Remote(PHANTOM_SERVER);
button->register_change_handler((void *)&forceEnabled, handle_button_change);
t=0.0;
// main loop
while (!done) {
t+=0.001f;
// Let the forceDevice send its messages to remote force device
forceDevice->mainloop();
// Let tracker receive position information from remote tracker
tracker->mainloop();
// Let button receive button status from remote button
button->mainloop();
forceEnabled = 1;
if (forceEnabled) {
float py = (0.05 * sin(t + pos[0]*40.0*M_PI) + 0.05);
if (pos[1] > py) {
forceDevice->stopForceField();
forceInEffect = 0;
} else {
float fy;
forceDevice->setFF_Origin(pos[0],pos[1],pos[2]);
fy = (py - pos[1]) * 14.0;
// units = dynes
forceDevice->setFF_Force(0.20 * cos(t + pos[0]*200.0*M_PI),
fy,
0.0 * cos( pos[2]*200.0*M_PI));
// set derivatives of force field:
// units = dynes/meter
forceDevice->setFF_Jacobian(
-20.0*sin(t + pos[0]*200.0*M_PI), 0, 0,
0, -14.0, 0,
0, 0, -0.0*M_PI*sin(pos[2]*200.0*M_PI)
);
forceDevice->setFF_Radius(0.02); // 2cm radius of validity
forceDevice->sendForceField();
forceInEffect = 1;
}
}
else if (forceInEffect){
forceDevice->stopForceField();
forceInEffect = 0;
}
}
} /* main */
src/vrpn/client_src/haptic/smdvrpn.C deleted 100644 → 0
View file @ 4375e2bb
#include <stdio.h>
#include "vrpn_Tracker.h"
#include "vrpn_Button.h"
#include "vrpn_ForceDevice.h"
#include "quat.h"
#include "glwin.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glx.h>
typedef struct {
float x; // position
float y;
float z;
} pos;
typedef struct {
float fx;
float fy;
float fz;
} force;
typedef struct {
float x;
float y;
float z;
float vx;
float vy;
float vz;
float ax;
float ay;
float az;
float mass;
float charge;
} state;
void handle_tracker(void *userdata, const vrpn_TRACKERCB t) {
pos *p = (pos *) userdata;
p->x = -t.pos[0];
p->y = t.pos[1];
p->z = -t.pos[2];
}
void handle_force(void *userdata, const vrpn_FORCECB fcb) {
force *f = (force *) userdata;
f->fx = -fcb.force[0];
f->fy = fcb.force[1];
f->fz = -fcb.force[2];
}
void handle_button(void *userdata, const vrpn_BUTTONCB b) {
switch (b.button) {
case 0:
*(int *)userdata = b.state;
if (b.state == 1) printf("Force field enabled\n");
else printf("Force field disabled\n");
break;
default:
printf("Unknown button %3d was pressed\n",b.button);
}
fflush(stdout);
}
void init_graphics(void *myglwin)
{
// allw the window to open and do its stuff once
glwin_handle_events(myglwin);
// setup OpenGL state...
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, 1.0, 0.01, 10.0);
gluLookAt( 0.0, 0.1, -5.0, // eye pos
0.0, 0.0, 0.0, // look at this point
0.0, 1.0, 0.0); // up direction
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
//
// Setup cute lighting parms..
//
glEnable(GL_LIGHTING);
GLfloat lpos[] = { 0.0, 0.0, -100.0, 1.0};
GLfloat lamb[] = { 0.05, 0.05, 0.05, 1.0};
GLfloat ldif[] = { 0.5, 0.5, 0.5, 1.0};
GLfloat lspc[] = { 0.5, 0.5, 0.5, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, lpos);
glLightfv(GL_LIGHT0, GL_AMBIENT, lamb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, ldif);
glLightfv(GL_LIGHT0, GL_SPECULAR, lspc);
glLightf(GL_LIGHT0, GL_SHININESS, 400.0);
glEnable(GL_LIGHT0);
GLfloat mdif[] = {0.9, 0.0, 0.2, 1.0};
GLfloat mspc[] = {0.2, 0.2, 0.2, 1.0};
glMaterialfv(GL_FRONT, GL_DIFFUSE, mdif);
glMaterialfv(GL_FRONT, GL_SPECULAR, mspc);
glEnable(GL_COLOR_MATERIAL);
}
void draw_axes() {
//
// Draw Coordinate Axes
//
glDisable(GL_LIGHTING);
glBegin(GL_LINES);
float i;
glColor3f(0.0, 1.0, 0.0);
for (i=-10; i<10; i += 0.50) {
glVertex3f( -10.0, 0.0, i);
glVertex3f( 10.0, 0.0, i);
glVertex3f( i, 0.0, -10.0);
glVertex3f( i, 0.0, 10.0);
}
for (i=-10; i<10; i += 0.50) {
glVertex3f( -10.0, 1.0, i);
glVertex3f( 10.0, 1.0, i);
glVertex3f( i, 1.0, -10.0);
glVertex3f( i, 1.0, 10.0);
}
glEnd();
}
void draw_tracker_and_atom(force *p, GLUquadricObj *qobj,
state *atom, GLUquadricObj *qatom)
{
float x, y, z;
float atomx, atomy, atomz;
// Convert from atom coordinates to scene coordinates
atomx = atom->x;
atomy = atom->y;
atomz = atom->z;
// Convert from haptic coordinates to our scene coordinates
x=-(p->fx) + atomx;
y=-(p->fy) + atomy;
z=-(p->fz) + atomz;
// First draw line from tracker to atom
glColor3f(1.0, 1.0, 1.0);
glBegin(GL_LINES);
glVertex3f(x, y, z);
glVertex3f(atomx, atomy, atomz);
glEnd();
glEnable(GL_LIGHTING);
glColor3f(1.0, 0.0, 0.2);
glPushMatrix();
glTranslatef(x, y, z);
gluSphere(qobj, 0.2, 32, 32);
glPopMatrix();
glColor3f(0.0, 1.0, 0.2);
glPushMatrix();
glTranslatef(atomx, atomy, atomz);
gluSphere(qobj, 0.2, 32, 32);
glPopMatrix();
}
void apply_bc(state *atom)
{
const float floor_k = 20.0;
const float maxdim = 1.0;
const float nearclip = 3.99;
const float farclip = 5.0;
if (atom->y < 0) atom->ay -= floor_k*atom->y/atom->mass;
if (atom->y > maxdim) atom->ay -= floor_k*(atom->y-maxdim)/atom->mass;
if (atom->x > maxdim) atom->ax -= floor_k*(atom->x-maxdim)/atom->mass;
if (atom->x < -maxdim) atom->ax -= floor_k*(atom->x+maxdim)/atom->mass;
if (atom->z > farclip) atom->az -= floor_k*(atom->z-farclip)/atom->mass;
if (atom->z < -nearclip) atom->az -= floor_k*(atom->z+nearclip)/atom->mass;
}
void run_dynamics(state *atom, force *f)
{
const int N=1;
const float dt = 0.0004;
for (int i=0; i < N; i++) {
atom->x += dt*atom->vx + .5*dt*dt*atom->ax;
atom->y += dt*atom->vy + .5*dt*dt*atom->ay;
atom->z += dt*atom->vz + .5*dt*dt*atom->az;
atom->vx += 0.5*dt*(atom->ax);
atom->vy += 0.5*dt*(atom->ay);
atom->vz += 0.5*dt*(atom->az);
atom->ax = -f->fx/atom->mass;
atom->ay = -f->fy/atom->mass;
atom->az = -f->fz/atom->mass;
apply_bc(atom);
atom->vx += 0.5*dt*(atom->ax);
atom->vy += 0.5*dt*(atom->ay);
atom->vz += 0.5*dt*(atom->az);
}
}
int main(int argc, char **argv) {
if (argc < 2) {
printf("%s: Invalid parms\n", argv[0]);
printf("usage: \n");
printf(" %s Tracker0@host\n", argv[0]);
return -1;
}
char *server = argv[1];
pos *phan_position = new pos;
pos *phan_offset = new pos;
force *phan_force = new force;
state *atom_state = new state;
int ff_enabled, ff_active;
double kspr = 500.0; // Units???
vrpn_Tracker_Remote *tkr;
vrpn_Button_Remote *btn;
vrpn_ForceDevice_Remote *fdv;
printf("Opening: %s ...\n", server);
tkr = new vrpn_Tracker_Remote(server);
tkr->register_change_handler(phan_position, handle_tracker);
btn = new vrpn_Button_Remote(server);
btn->register_change_handler(&ff_enabled, handle_button);
fdv = new vrpn_ForceDevice_Remote(server);
fdv->register_force_change_handler(phan_force, handle_force);
void * myglwin = glwin_create(700, 700);
if (myglwin == NULL) {
printf("Failed to open OpenGL window!!\n");
return -1;
}
atom_state->x = 0.0; atom_state->y = 0.0; atom_state->z = 0.0;
atom_state->vx = 0.0; atom_state->vy = 0.0; atom_state->vz = 0.0;
atom_state->ax = 0.0; atom_state->ay = 0.0; atom_state->az = 0.0;
atom_state->mass = .001;
ff_active = 0;
init_graphics(myglwin);
GLUquadricObj *qobj = gluNewQuadric();
GLUquadricObj *qatom = gluNewQuadric();
/*
* main interactive loop
*/
while (1) {
// Let the tracker do its thing
tkr->mainloop();
btn->mainloop();
fdv->mainloop();
run_dynamics(atom_state, phan_force);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (ff_enabled ) {
if (!ff_active) {
// Set up force field so initially the force is zero
phan_offset->x = phan_position->x - .2*atom_state->x;
phan_offset->y = phan_position->y - .2*atom_state->y;
phan_offset->z = phan_position->z - .2*atom_state->z;
}
// Now turn the force field on
// scene -> haptic: rotate 180 about the y axis
fdv->setConstraintMode(vrpn_ForceDevice::POINT_CONSTRAINT);
float cpos[3];
cpos[0] = -(.2*atom_state->x + phan_offset->x);
cpos[1] = (.2*atom_state->y + phan_offset->y);
cpos[2] = -(.2*atom_state->z + phan_offset->z);
fdv->setConstraintPoint(cpos);
fdv->setConstraintKSpring(kspr);
fdv->enableConstraint(1); // enable force field
ff_active = 1;
}
else if (ff_active) {
fdv->enableConstraint(0); // disable force field
ff_active = 0;
}
draw_axes();
draw_tracker_and_atom(phan_force, qobj, atom_state, qatom);
glwin_swap_buffers(myglwin);
}
} /* main */
src/vrpn/client_src/haptic/testvrpn.C deleted 100644 → 0
View file @ 4375e2bb
#include <stdio.h>
#include "vrpn_Tracker.h"
#include "vrpn_Button.h"
#include "vrpn_ForceDevice.h"
void handle_tracker(void *userdata, const vrpn_TRACKERCB t) {
printf("Sensor %3d is now at (%11f, %11f, %11f, %11f, %11f, %11f, %11f) \r",
t.sensor, t.pos[0], t.pos[1], t.pos[2],
t.quat[0], t.quat[1], t.quat[2], t.quat[3]);
fflush(stdout);
}
void handle_button(void *userdata, const vrpn_BUTTONCB b) {
printf("\nButton %3d is in state: %d \n",
b.button, b.state);
fflush(stdout);
}
void handle_force(void *userdata, const vrpn_FORCECB f) {
static vrpn_FORCECB lr; // last report
static int first_report_done = 0;
if ((!first_report_done) || ((f.force[0] != lr.force[0]) ||
(f.force[1] != lr.force[1]) || (f.force[2] != lr.force[2])))
printf("\nForce is (%11f, %11f, %11f) \n",
f.force[0], f.force[1], f.force[2]);
first_report_done = 1;
lr = f;
}
int main(int argc, char **argv) {
char * server;
vrpn_Tracker_Remote *tkr;
vrpn_Button_Remote *btn;
vrpn_ForceDevice_Remote *fdv;
if (argc < 2) {
printf("%s: Invalid parms\n", argv[0]);
printf("usage: \n");
printf(" %s Tracker0@host\n", argv[0]);
return -1;
}
server = argv[1];
printf("Opening: %s ...\n", server);
tkr = new vrpn_Tracker_Remote(server);
tkr->register_change_handler(NULL, handle_tracker);
btn = new vrpn_Button_Remote(server);
btn->register_change_handler(NULL, handle_button);
fdv = new vrpn_ForceDevice_Remote(server);
fdv->register_force_change_handler(NULL, handle_force);
tkr->reset_origin();
/*
* main interactive loop
*/
while (1) {
// Let the tracker do its thing
tkr->mainloop();
btn->mainloop();
fdv->mainloop();
}
} /* main */
src/vrpn/client_src/logfilesenders deleted 100755 → 0
View file @ 4375e2bb
File deleted
src/vrpn/client_src/logfilesenders.C deleted 100644 → 0
View file @ 4375e2bb
#include <fcntl.h> // for open, O_RDONLY
#ifndef _WIN32
#include <netinet/in.h> // for ntohl
#include <unistd.h> // for close, read
#endif
#include <stdio.h> // for printf, fprintf, stderr
#include <stdlib.h> // for exit
#include <vrpn_Connection.h> // for vrpn_HANDLERPARAM, etc
#include "vrpn_Shared.h" // for timeval
const int buflen = 8000;
void Usage (const char * name) {
fprintf(stderr, "Usage: %s <filename>\n", name);
}
int main (int argc, char ** argv) {
char buffer [buflen];
vrpn_HANDLERPARAM header;
int file;
int retval;
if (argc != 2) {
Usage(argv[0]);
exit(0);
}
file = open(argv[1], O_RDONLY);
if (file == -1) {
fprintf(stderr, "Couldn't open \"%s\".\n", argv[1]);
exit(0);
}
while (1) {
int len;
struct timeval time;
long sender;
long type;
int len2;
retval = read(file, &header, sizeof(header));
if (retval < 0) { printf("ERROR\n"); close(file); exit(0); }
if (!retval) { printf("EOF\n"); close(file); exit(0); }
len = ntohl(header.payload_len);
time.tv_sec = ntohl(header.msg_time.tv_sec);
time.tv_usec = ntohl(header.msg_time.tv_usec);
sender = ntohl(header.sender);
type = ntohl(header.type);
//printf("Message type %d, sender %d, payload length %d\n",
//type, sender, len);
retval = read(file, buffer, len);
if (retval < 0) { printf("ERROR\n"); close(file); exit(0); }
if (!retval) { printf("EOF\n"); close(file); exit(0); }
//printf(" <%d bytes>\n", retval);
switch (type) {
case vrpn_CONNECTION_SENDER_DESCRIPTION:
len2 = ntohl(* ((int *) buffer));
buffer[len2 + sizeof(int)] = 0;
printf(" The name of sender #%ld is \"%s\".\n", sender, buffer + sizeof(int));
break;
case vrpn_CONNECTION_TYPE_DESCRIPTION:
len2 = ntohl(* ((int *) buffer));
buffer[len2 + sizeof(int)] = 0;
//printf(" The name of type #%d is \"%s\".\n", sender, buffer + sizeof(int));
break;
case vrpn_CONNECTION_UDP_DESCRIPTION:
buffer[len] = 0;
//printf(" UDP host is \"%s\", port %d.\n", buffer, sender);
break;
case vrpn_CONNECTION_LOG_DESCRIPTION:
buffer[len] = 0;
//printf(" Log to file \"%s\".\n", buffer);
break;
}
}
}
src/vrpn/client_src/logfiletypes deleted 100755 → 0
View file @ 4375e2bb
File deleted
src/vrpn/client_src/logfiletypes.C deleted 100644 → 0
View file @ 4375e2bb
#include <fcntl.h> // for open, O_RDONLY
#ifndef _WIN32
#include <netinet/in.h> // for ntohl
#include <unistd.h> // for close, read
#endif
#include <stdio.h> // for printf, fprintf, stderr
#include <stdlib.h> // for exit
#include <vrpn_Connection.h> // for vrpn_HANDLERPARAM, etc
#include "vrpn_Shared.h" // for timeval
const int buflen = 8000;
void Usage (const char * name) {
fprintf(stderr, "Usage: %s <filename>\n", name);
}
int main (int argc, char ** argv) {
char buffer [buflen];
vrpn_HANDLERPARAM header;
int file;
int retval;
if (argc != 2) {
Usage(argv[0]);
exit(0);
}
file = open(argv[1], O_RDONLY);
if (file == -1) {
fprintf(stderr, "Couldn't open \"%s\".\n", argv[1]);
exit(0);
}
while (1) {
int len;
struct timeval time;
long sender;
long type;
int len2;
retval = read(file, &header, sizeof(header));
if (retval < 0) { printf("ERROR\n"); close(file); exit(0); }
if (!retval) { printf("EOF\n"); close(file); exit(0); }
len = ntohl(header.payload_len);
time.tv_sec = ntohl(header.msg_time.tv_sec);
time.tv_usec = ntohl(header.msg_time.tv_usec);
sender = ntohl(header.sender);
type = ntohl(header.type);
//printf("Message type %d, sender %d, payload length %d\n",
//type, sender, len);
retval = read(file, buffer, len);
if (retval < 0) { printf("ERROR\n"); close(file); exit(0); }
if (!retval) { printf("EOF\n"); close(file); exit(0); }
//printf(" <%d bytes>\n", retval);
switch (type) {
case vrpn_CONNECTION_SENDER_DESCRIPTION:
len2 = ntohl(* ((int *) buffer));
buffer[len2 + sizeof(int)] = 0;
//printf(" The name of sender #%d is \"%s\".\n", sender, buffer + sizeof(int));
break;
case vrpn_CONNECTION_TYPE_DESCRIPTION:
len2 = ntohl(* ((int *) buffer));
buffer[len2 + sizeof(int)] = 0;
printf(" The name of type #%ld is \"%s\".\n", sender, buffer + sizeof(int));
break;
case vrpn_CONNECTION_UDP_DESCRIPTION:
buffer[len] = 0;
//printf(" UDP host is \"%s\", port %d.\n", buffer, sender);
break;
case vrpn_CONNECTION_LOG_DESCRIPTION:
buffer[len] = 0;
//printf(" Log to file \"%s\".\n", buffer);
break;
}
}
}
src/vrpn/client_src/midi_client.C deleted 100644 → 0
View file @ 4375e2bb
#include <unistd.h>
#include <stdio.h>
#include "vrpn_Sound.h"
char *SERVER = "Sound0@ioph100";
int main()
{
vrpn_Sound_Remote *remote;
remote = new vrpn_Sound_Remote(SERVER);
printf("Opened sound server %s\n",SERVER);
printf("Playing at level 0.24:\n");
remote->play_midi_sound(0.24);
remote->mainloop();
sleep (10);
printf("Playing at level 0.45:\n");
remote->play_midi_sound(0.45);
remote->mainloop();
sleep (10);
printf("Playing at level 0.74:\n");
remote->play_midi_sound(0.74);
remote->mainloop();
sleep (10);
printf("Playing at level 1.00:\n");
remote->play_midi_sound(1.00);
remote->mainloop();
sleep (10);
printf("...Done\n");
remote->play_stop(1);
remote->mainloop();
return 0;
}
src/vrpn/client_src/pc_linux64/add_vrpn_cookie deleted 100755 → 0
View file @ 4375e2bb
File deleted