vrpn  07.33
Virtual Reality Peripheral Network
vrpn_ForceDevice.C
Go to the documentation of this file.
1 // Include vrpn_Shared.h _first_ to avoid conflicts with sys/time.h
2 // and unistd.h
3 #include <math.h> // for sqrt
4 #include <stdio.h> // for fprintf, stderr, NULL, etc
5 
6 #include "vrpn_Connection.h" // for vrpn_Connection, etc
7 #include "vrpn_Shared.h" // for vrpn_buffer, vrpn_unbuffer, etc
8 
9 #if defined(linux) || defined(__sparc) || defined(hpux) || defined(__GNUC__)
10 #include <string.h> // for memcpy
11 #endif
12 
13 #include <quat.h> // for q_matrix_type, etc
14 
15 #include "vrpn_ForceDevice.h"
16 
17 /* cheezy hack to make sure this enum is defined in the case we didn't
18  include trimesh.h */
19 #ifndef TRIMESH_H
20 // the different types of trimeshes we have available for haptic display
22 #endif
23 
24 #define CHECK(a) \
25  if (a == -1) return -1
26 
27 #if 0
28 // c = a x b
29 static void vector_cross (const vrpn_float64 a [3], const vrpn_float64 b [3],
30  vrpn_float64 c [3]) {
31 
32  c[0] = a[1] * b[2] - a[2] * b[1];
33  c[1] = a[2] * b[0] - a[0] * b[2];
34  c[2] = a[0] * b[1] - a[1] * b[0];
35 
36 }
37 
38 // vprime = v * T
39 static void rotate_vector (const vrpn_float64 v [3], const vrpn_float64 T [9],
40  vrpn_float64 vprime [3]) {
41  vprime[0] = v[0] * T[0] + v[1] * T[3] + v[2] * T[6];
42  vprime[1] = v[0] * T[1] + v[1] * T[4] + v[2] * T[7];
43  vprime[2] = v[0] * T[2] + v[1] * T[5] + v[2] * T[8];
44 }
45 
46 static vrpn_float64 vector_dot (const vrpn_float64 a [3],
47  const vrpn_float64 b [3]) {
48  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
49 }
50 #endif
51 
53  : vrpn_BaseClass(name, c)
54 {
56 
57  // set the current time to zero
58  timestamp.tv_sec = 0;
59  timestamp.tv_usec = 0;
60 
61  // set the force to zero
62  // d_force[0] = d_force[1] = d_force[2] = 0.0;
63  SurfaceKspring = 0.8f;
64  SurfaceFdynamic = 0.3f;
65  SurfaceFstatic = 0.7f;
66  SurfaceKdamping = 0.001f;
67 
68  numRecCycles = 1;
69  errorCode = FD_OK;
70 
71  SurfaceKadhesionNormal = 0.0001f;
72  SurfaceKadhesionLateral = 0.0002f;
73  SurfaceBuzzFreq = 0.0003f;
74  SurfaceBuzzAmp = 0.0004f;
76  SurfaceTextureAmplitude = 0.0005f;
77 
78  // ajout ONDIM
79  customEffectId = -1;
80  customEffectParams = NULL;
82  // fin ajout ONDIM
83 }
84 
85 // ajout ONDIM
86 void vrpn_ForceDevice::setCustomEffect(vrpn_int32 effectId,
87  vrpn_float32 *params,
88  vrpn_uint32 nbParams)
89 {
90  customEffectId = effectId;
91  if (customEffectParams != NULL) {
92  delete[] customEffectParams;
93  }
94  customEffectParams = new vrpn_float32[nbParams];
95  memcpy(customEffectParams, params, sizeof(vrpn_float32) * nbParams);
96  nbCustomEffectParams = nbParams;
97 }
98 // fin ajout ondim
99 
101 {
103  d_connection->register_message_type("vrpn_ForceDevice Force");
105  d_connection->register_message_type("vrpn_ForceDevice Force_Field");
107  d_connection->register_message_type("vrpn_ForceDevice Plane");
109  d_connection->register_message_type("vrpn_ForceDevice Plane2");
111  d_connection->register_message_type("vrpn_ForceDevice addObject");
113  "vrpn_ForceDevice addObjectExScene");
115  d_connection->register_message_type("vrpn_ForceDevice moveToParent");
117  "vrpn_ForceDevice setObjectPosition");
119  "vrpn_ForceDevice setObjectOrientation");
121  d_connection->register_message_type("vrpn_ForceDevice setObjectScale");
123  d_connection->register_message_type("vrpn_ForceDevice removeObject");
125  d_connection->register_message_type("vrpn_ForceDevice setVertex");
127  d_connection->register_message_type("vrpn_ForceDevice setNormal");
129  d_connection->register_message_type("vrpn_ForceDevice setTriangle");
131  d_connection->register_message_type("vrpn_ForceDevice removeTriangle");
133  "vrpn_ForceDevice updateTrimeshChanges");
135  "vrpn_ForceDevice transformTrimesh");
137  d_connection->register_message_type("vrpn_ForceDevice setTrimeshType");
139  d_connection->register_message_type("vrpn_ForceDevice clearTrimesh");
140 
142  d_connection->register_message_type("vrpn_ForceDevice setHapticOrigin");
144  d_connection->register_message_type("vrpn_ForceDevice setHapticScale");
146  d_connection->register_message_type("vrpn_ForceDevice setSceneOrigin");
147 
149  d_connection->register_message_type("vrpn_ForceDevice getNewObjectID");
151  "vrpn_ForceDevice setObjectIsTouchable");
153  d_connection->register_message_type("vrpn_ForceDevice SCP");
155  d_connection->register_message_type("vrpn_ForceDevice Force_Error");
156 
158  "vrpn_ForceDevice constraint_enable");
160  d_connection->register_message_type("vrpn_ForceDevice constraint_mode");
162  "vrpn_ForceDevice constraint_point");
164  "vrpn_ForceDevice constraint_linept");
166  "vrpn_ForceDevice constraint_linedir");
168  d_connection->register_message_type("vrpn_ForceDevice constraint_plpt");
170  "vrpn_ForceDevice constraint_plnorm");
172  "vrpn_ForceDevice constraint_KSpring");
173 
174  // ajout ONDIM
176  d_connection->register_message_type("vrpn_ForceDevice Custom Effect");
177  // fin ajout ONDIM
178 
179  return 0;
180 }
181 
182 // virtual
184 {
185  if (customEffectParams != NULL) {
186  delete[] customEffectParams;
187  }
188 }
189 
191 {
192  printf("plane: %f, %f, %f, %f\n", plane[0], plane[1], plane[2], plane[3]);
193 }
194 
196 {
197  // Nothing sets d_force any more!
198  printf("Timestamp:%ld:%ld\n", timestamp.tv_sec,
199  static_cast<long>(timestamp.tv_usec));
200  // printf("Force :%lf, %lf, %lf\n", d_force[0],d_force[1],d_force[2]);
201 }
202 
203 // static
204 char *vrpn_ForceDevice::encode_force(vrpn_int32 &length,
205  const vrpn_float64 *force)
206 {
207  // Message includes: vrpn_float64 force[3]
208  // Byte order of each needs to be reversed to match network standard
209 
210  int i;
211  char *buf;
212  char *mptr;
213  vrpn_int32 mlen;
214 
215  length = 3 * sizeof(vrpn_float64);
216  mlen = length;
217 
218  buf = new char[length];
219  mptr = buf;
220 
221  // Move the force there
222  for (i = 0; i < 3; i++) {
223  vrpn_buffer(&mptr, &mlen, force[i]);
224  }
225 
226  return buf;
227 }
228 
229 // static
230 vrpn_int32 vrpn_ForceDevice::decode_force(const char *buffer,
231  const vrpn_int32 len,
232  vrpn_float64 *force)
233 {
234  int i;
235  const char *mptr = buffer;
236 
237  if (len != (3 * sizeof(vrpn_float64))) {
238  fprintf(stderr, "vrpn_ForceDevice: force message payload error\n");
239  fprintf(stderr, " (got %d, expected %lud)\n", len,
240  static_cast<unsigned long>(3 * sizeof(vrpn_float64)));
241  return -1;
242  }
243 
244  for (i = 0; i < 3; i++)
245  CHECK(vrpn_unbuffer(&mptr, &(force[i])));
246 
247  return 0;
248 }
249 
250 // ajout ONDIM
252  vrpn_uint32 effectId,
253  const vrpn_float32 *params,
254  vrpn_uint32 nbParams)
255 {
256  char *buf;
257  char *mptr;
258  vrpn_int32 mlen;
259 
260  len = sizeof(vrpn_uint32) * 2 + nbParams * sizeof(vrpn_float32);
261  mlen = len;
262 
263  buf = new char[len];
264  mptr = buf;
265 
266  vrpn_buffer(&mptr, &mlen, effectId);
267  vrpn_buffer(&mptr, &mlen, nbParams);
268 
269  for (unsigned int i = 0; i < nbParams; i++) {
270  vrpn_buffer(&mptr, &mlen, params[i]);
271  }
272 
273  return buf;
274 }
275 
276 // static
277 vrpn_int32 vrpn_ForceDevice::decode_custom_effect(const char *buffer,
278  const vrpn_int32 len,
279  vrpn_uint32 *effectId,
280  vrpn_float32 **params,
281  vrpn_uint32 *nbParams)
282 {
283  const char *mptr = buffer;
284 
285  // OutputDebugString("decoding custom effect\n");
286 
287  if (static_cast<size_t>(len) < (sizeof(vrpn_uint32) * 2)) {
288  fprintf(stderr,
289  "vrpn_ForceDevice: custom effect message payload error\n");
290  fprintf(stderr, " (got %d, expected at least %lud)\n", len,
291  static_cast<unsigned long>(2 * sizeof(vrpn_uint32)));
292  return -1;
293  }
294 
295  CHECK(vrpn_unbuffer(&mptr, effectId));
296  CHECK(vrpn_unbuffer(&mptr, nbParams));
297 
298  if ((vrpn_uint32)(len) <
299  (2 * sizeof(vrpn_uint32) + (*nbParams) * sizeof(vrpn_float32))) {
300  fprintf(stderr,
301  "vrpn_ForceDevice: custom effect message payload error\n");
302  fprintf(stderr, " (got %d, expected at least %lud)\n", len,
303  static_cast<unsigned long>(2 * sizeof(vrpn_uint32) +
304  (*nbParams) * sizeof(vrpn_float32)));
305  return -2;
306  }
307 
308  if (*params != NULL) delete[] * params;
309  *params = new vrpn_float32[(*nbParams)];
310 
311  for (vrpn_uint32 i = 0; i < (*nbParams); i++) {
312  CHECK(vrpn_unbuffer(&mptr, &((*params)[i])));
313  }
314 
315  return 0;
316 }
317 // fin ajout ONDIM
318 
319 // static
320 char *vrpn_ForceDevice::encode_scp(vrpn_int32 &length, const vrpn_float64 *pos,
321  const vrpn_float64 *quat)
322 {
323  int i;
324  char *buf;
325  char *mptr;
326  vrpn_int32 mlen;
327 
328  length = 7 * sizeof(vrpn_float64);
329  mlen = length;
330 
331  buf = new char[length];
332  mptr = buf;
333 
334  for (i = 0; i < 3; i++) {
335  vrpn_buffer(&mptr, &mlen, pos[i]);
336  }
337  for (i = 0; i < 4; i++) {
338  vrpn_buffer(&mptr, &mlen, quat[i]);
339  }
340 
341  return buf;
342 }
343 
344 // static
345 vrpn_int32 vrpn_ForceDevice::decode_scp(const char *buffer,
346  const vrpn_int32 len, vrpn_float64 *pos,
347  vrpn_float64 *quat)
348 {
349  int i;
350  const char *mptr = buffer;
351  int desiredLen = 7 * sizeof(vrpn_float64);
352 
353  if (len != desiredLen) {
354  fprintf(stderr, "vrpn_ForceDevice: scp message payload error\n");
355  fprintf(stderr, " (got %d, expected %d)\n", len,
356  desiredLen);
357  return -1;
358  }
359 
360  for (i = 0; i < 3; i++)
361  CHECK(vrpn_unbuffer(&mptr, &(pos[i])));
362  for (i = 0; i < 4; i++)
363  CHECK(vrpn_unbuffer(&mptr, &(quat[i])));
364 
365  return 0;
366 }
367 
368 // static
370  vrpn_int32 &len, const vrpn_float32 *plane, const vrpn_float32 kspring,
371  const vrpn_float32 kdamp, const vrpn_float32 fdyn, const vrpn_float32 fstat,
372  const vrpn_int32 plane_index, const vrpn_int32 n_rec_cycles)
373 {
374  // Message includes: vrpn_float32 plane[4],
375 
376  int i;
377  char *buf;
378  char *mptr;
379  vrpn_int32 mlen;
380 
381  len = 8 * sizeof(vrpn_float32) + 2 * sizeof(vrpn_int32);
382  mlen = len;
383 
384  buf = new char[len];
385  mptr = buf;
386 
387  for (i = 0; i < 4; i++) {
388  vrpn_buffer(&mptr, &mlen, plane[i]);
389  }
390 
391  vrpn_buffer(&mptr, &mlen, kspring);
392  vrpn_buffer(&mptr, &mlen, kdamp);
393  vrpn_buffer(&mptr, &mlen, fdyn);
394  vrpn_buffer(&mptr, &mlen, fstat);
395  vrpn_buffer(&mptr, &mlen, plane_index);
396  vrpn_buffer(&mptr, &mlen, n_rec_cycles);
397 
398  return buf;
399 }
400 
401 // static
403  const char *buffer, const vrpn_int32 len, vrpn_float32 *plane,
404  vrpn_float32 *kspring, vrpn_float32 *kdamp, vrpn_float32 *fdyn,
405  vrpn_float32 *fstat, vrpn_int32 *plane_index, vrpn_int32 *n_rec_cycles)
406 {
407  int i;
408  const char *mptr = buffer;
409 
410  if (len != 8 * sizeof(vrpn_float32) + 2 * sizeof(vrpn_int32)) {
411  fprintf(stderr, "vrpn_ForceDevice: plane message payload error\n");
412  fprintf(stderr, " (got %d, expected %lud)\n", len,
413  static_cast<unsigned long>(8 * sizeof(vrpn_float32) +
414  2 * sizeof(vrpn_int32)));
415  return -1;
416  }
417 
418  for (i = 0; i < 4; i++)
419  CHECK(vrpn_unbuffer(&mptr, &(plane[i])));
420  CHECK(vrpn_unbuffer(&mptr, kspring));
421  CHECK(vrpn_unbuffer(&mptr, kdamp));
422  CHECK(vrpn_unbuffer(&mptr, fdyn));
423  CHECK(vrpn_unbuffer(&mptr, fstat));
424  CHECK(vrpn_unbuffer(&mptr, plane_index));
425  CHECK(vrpn_unbuffer(&mptr, n_rec_cycles));
426 
427  return 0;
428 }
429 
430 // static
432  vrpn_int32 &len, const vrpn_float32 k_adhesion_normal,
433  const vrpn_float32 k_adhesion_lateral, const vrpn_float32 tex_amp,
434  const vrpn_float32 tex_wl, const vrpn_float32 buzz_amp,
435  const vrpn_float32 buzz_freq)
436 {
437 
438  char *buf;
439  char *mptr;
440  vrpn_int32 mlen;
441 
442  len = 6 * sizeof(vrpn_float32);
443  mlen = len;
444 
445  buf = new char[len];
446  mptr = buf;
447 
448  vrpn_buffer(&mptr, &mlen, k_adhesion_normal);
449  vrpn_buffer(&mptr, &mlen, k_adhesion_lateral);
450  vrpn_buffer(&mptr, &mlen, tex_amp);
451  vrpn_buffer(&mptr, &mlen, tex_wl);
452  vrpn_buffer(&mptr, &mlen, buzz_amp);
453  vrpn_buffer(&mptr, &mlen, buzz_freq);
454 
455  return buf;
456 }
457 
458 // static
460  const char *buffer, const vrpn_int32 len, vrpn_float32 *k_adhesion_normal,
461  vrpn_float32 *k_adhesion_lateral, vrpn_float32 *tex_amp,
462  vrpn_float32 *tex_wl, vrpn_float32 *buzz_amp, vrpn_float32 *buzz_freq)
463 {
464 
465  const char *mptr = buffer;
466 
467  if (len != 6 * sizeof(vrpn_float32)) {
468  fprintf(stderr, "vrpn_ForceDevice: surface effects message payload ");
469  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
470  static_cast<unsigned long>(6 * sizeof(vrpn_float32)));
471  return -1;
472  }
473 
474  CHECK(vrpn_unbuffer(&mptr, k_adhesion_normal));
475  CHECK(vrpn_unbuffer(&mptr, k_adhesion_lateral));
476  CHECK(vrpn_unbuffer(&mptr, tex_amp));
477  CHECK(vrpn_unbuffer(&mptr, tex_wl));
478  CHECK(vrpn_unbuffer(&mptr, buzz_amp));
479  CHECK(vrpn_unbuffer(&mptr, buzz_freq));
480 
481  return 0;
482 }
483 
484 // static
485 char *vrpn_ForceDevice::encode_vertex(vrpn_int32 &len, const vrpn_int32 objNum,
486  const vrpn_int32 vertNum,
487  const vrpn_float32 x,
488  const vrpn_float32 y,
489  const vrpn_float32 z)
490 {
491 
492  char *buf;
493  char *mptr;
494  vrpn_int32 mlen;
495 
496  len = sizeof(objNum) + sizeof(vertNum) + 3 * sizeof(vrpn_float32);
497  mlen = len;
498 
499  buf = new char[len];
500  mptr = buf;
501 
502  vrpn_buffer(&mptr, &mlen, objNum);
503  vrpn_buffer(&mptr, &mlen, vertNum);
504  vrpn_buffer(&mptr, &mlen, x);
505  vrpn_buffer(&mptr, &mlen, y);
506  vrpn_buffer(&mptr, &mlen, z);
507 
508  return buf;
509 }
510 
511 // static
512 vrpn_int32 vrpn_ForceDevice::decode_vertex(const char *buffer,
513  const vrpn_int32 len,
514  vrpn_int32 *objNum,
515  vrpn_int32 *vertNum, vrpn_float32 *x,
516  vrpn_float32 *y, vrpn_float32 *z)
517 {
518  const char *mptr = buffer;
519 
520  if (len != (sizeof(objNum) + sizeof(vertNum) + 3 * sizeof(vrpn_float32))) {
521  fprintf(stderr, "vrpn_ForceDevice: vertex message payload error\n");
522  fprintf(stderr, " (got %d, expected %lud)\n", len,
523  static_cast<unsigned long>(sizeof(objNum) + sizeof(vertNum) +
524  3 * sizeof(vrpn_float32)));
525  return -1;
526  }
527 
528  CHECK(vrpn_unbuffer(&mptr, objNum));
529  CHECK(vrpn_unbuffer(&mptr, vertNum));
530  CHECK(vrpn_unbuffer(&mptr, x));
531  CHECK(vrpn_unbuffer(&mptr, y));
532  CHECK(vrpn_unbuffer(&mptr, z));
533 
534  return 0;
535 }
536 
537 // static
538 char *vrpn_ForceDevice::encode_normal(vrpn_int32 &len, const vrpn_int32 objNum,
539  const vrpn_int32 normNum,
540  const vrpn_float32 x,
541  const vrpn_float32 y,
542  const vrpn_float32 z)
543 {
544 
545  char *buf;
546  char *mptr;
547  vrpn_int32 mlen;
548 
549  len = sizeof(vrpn_int32) + sizeof(vrpn_int32) + 3 * sizeof(vrpn_float32);
550  mlen = len;
551 
552  buf = new char[len];
553  mptr = buf;
554  vrpn_buffer(&mptr, &mlen, objNum);
555  vrpn_buffer(&mptr, &mlen, normNum);
556  vrpn_buffer(&mptr, &mlen, x);
557  vrpn_buffer(&mptr, &mlen, y);
558  vrpn_buffer(&mptr, &mlen, z);
559 
560  return buf;
561 }
562 
563 // static
564 vrpn_int32 vrpn_ForceDevice::decode_normal(const char *buffer,
565  const vrpn_int32 len,
566  vrpn_int32 *objNum,
567  vrpn_int32 *vertNum, vrpn_float32 *x,
568  vrpn_float32 *y, vrpn_float32 *z)
569 {
570 
571  const char *mptr = buffer;
572 
573  if (len !=
574  (sizeof(vrpn_int32) + sizeof(vrpn_int32) + 3 * sizeof(vrpn_float32))) {
575  fprintf(stderr, "vrpn_ForceDevice: normal message payload error\n");
576  fprintf(stderr, " (got %d, expected %lud)\n", len,
577  static_cast<unsigned long>(sizeof(vrpn_int32) +
578  sizeof(vrpn_int32) +
579  3 * sizeof(vrpn_float32)));
580  return -1;
581  }
582 
583  CHECK(vrpn_unbuffer(&mptr, objNum));
584  CHECK(vrpn_unbuffer(&mptr, vertNum));
585  CHECK(vrpn_unbuffer(&mptr, x));
586  CHECK(vrpn_unbuffer(&mptr, y));
587  CHECK(vrpn_unbuffer(&mptr, z));
588 
589  return 0;
590 }
591 
592 // static
594  vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_int32 triNum,
595  const vrpn_int32 vert0, const vrpn_int32 vert1, const vrpn_int32 vert2,
596  const vrpn_int32 norm0, const vrpn_int32 norm1, const vrpn_int32 norm2)
597 {
598  char *buf;
599  char *mptr;
600  vrpn_int32 mlen;
601 
602  len = sizeof(vrpn_int32) + 7 * sizeof(vrpn_int32);
603  mlen = len;
604 
605  buf = new char[len];
606  mptr = buf;
607 
608  vrpn_buffer(&mptr, &mlen, objNum);
609  vrpn_buffer(&mptr, &mlen, triNum);
610  vrpn_buffer(&mptr, &mlen, vert0);
611  vrpn_buffer(&mptr, &mlen, vert1);
612  vrpn_buffer(&mptr, &mlen, vert2);
613  vrpn_buffer(&mptr, &mlen, norm0);
614  vrpn_buffer(&mptr, &mlen, norm1);
615  vrpn_buffer(&mptr, &mlen, norm2);
616 
617  return buf;
618 }
619 
620 // static
622  const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum,
623  vrpn_int32 *triNum, vrpn_int32 *vert0, vrpn_int32 *vert1, vrpn_int32 *vert2,
624  vrpn_int32 *norm0, vrpn_int32 *norm1, vrpn_int32 *norm2)
625 {
626  const char *mptr = buffer;
627 
628  if (len != (sizeof(vrpn_int32) + 7 * sizeof(vrpn_int32))) {
629  fprintf(stderr, "vrpn_ForceDevice: triangle message payload error\n");
630  fprintf(stderr, " (got %d, expected %lud)\n", len,
631  static_cast<unsigned long>(sizeof(vrpn_int32) +
632  7 * sizeof(vrpn_int32)));
633  return -1;
634  }
635 
636  CHECK(vrpn_unbuffer(&mptr, objNum));
637  CHECK(vrpn_unbuffer(&mptr, triNum));
638  CHECK(vrpn_unbuffer(&mptr, vert0));
639  CHECK(vrpn_unbuffer(&mptr, vert1));
640  CHECK(vrpn_unbuffer(&mptr, vert2));
641  CHECK(vrpn_unbuffer(&mptr, norm0));
642  CHECK(vrpn_unbuffer(&mptr, norm1));
643  CHECK(vrpn_unbuffer(&mptr, norm2));
644 
645  return 0;
646 }
647 
648 // static
650  const vrpn_int32 objNum,
651  const vrpn_int32 triNum)
652 {
653 
654  char *buf;
655  char *mptr;
656  vrpn_int32 mlen;
657 
658  len = sizeof(vrpn_int32) + sizeof(vrpn_int32);
659  mlen = len;
660 
661  buf = new char[len];
662  mptr = buf;
663 
664  vrpn_buffer(&mptr, &mlen, objNum);
665  vrpn_buffer(&mptr, &mlen, triNum);
666 
667  return buf;
668 }
669 
670 // static
671 vrpn_int32 vrpn_ForceDevice::decode_removeTriangle(const char *buffer,
672  const vrpn_int32 len,
673  vrpn_int32 *objNum,
674  vrpn_int32 *triNum)
675 {
676  const char *mptr = buffer;
677 
678  if (len != (sizeof(vrpn_int32) + sizeof(vrpn_int32))) {
679  fprintf(stderr, "vrpn_ForceDevice: remove triangle message payload");
680  fprintf(stderr, " error\n (got %d, expected %lud)\n", len,
681  static_cast<unsigned long>(sizeof(vrpn_int32) +
682  sizeof(vrpn_int32)));
683  return -1;
684  }
685 
686  CHECK(vrpn_unbuffer(&mptr, objNum));
687  CHECK(vrpn_unbuffer(&mptr, triNum));
688 
689  return 0;
690 }
691 
692 // static
693 // this is where we send down our surface parameters
695  vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_float32 kspring,
696  const vrpn_float32 kdamp, const vrpn_float32 fstat, const vrpn_float32 fdyn)
697 {
698 
699  char *buf;
700  char *mptr;
701  vrpn_int32 mlen;
702 
703  len = sizeof(vrpn_int32) + 4 * sizeof(vrpn_float32);
704  mlen = len;
705 
706  buf = new char[len];
707  mptr = buf;
708 
709  vrpn_buffer(&mptr, &mlen, objNum);
710  vrpn_buffer(&mptr, &mlen, kspring);
711  vrpn_buffer(&mptr, &mlen, kdamp);
712  vrpn_buffer(&mptr, &mlen, fstat);
713  vrpn_buffer(&mptr, &mlen, fdyn);
714 
715  return buf;
716 }
717 
718 // static
720  const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum,
721  vrpn_float32 *kspring, vrpn_float32 *kdamp, vrpn_float32 *fstat,
722  vrpn_float32 *fdyn)
723 {
724 
725  const char *mptr = buffer;
726 
727  if (len != (sizeof(vrpn_int32) + 4 * sizeof(vrpn_float32))) {
728  fprintf(stderr, "vrpn_ForceDevice: update trimesh message payload");
729  fprintf(stderr, " error\n (got %d, expected %lud)\n", len,
730  static_cast<unsigned long>(sizeof(vrpn_int32) +
731  4 * sizeof(vrpn_float32)));
732  return -1;
733  }
734 
735  CHECK(vrpn_unbuffer(&mptr, objNum));
736  CHECK(vrpn_unbuffer(&mptr, kspring));
737  CHECK(vrpn_unbuffer(&mptr, kdamp));
738  CHECK(vrpn_unbuffer(&mptr, fstat));
739  CHECK(vrpn_unbuffer(&mptr, fdyn));
740 
741  return 0;
742 }
743 
744 // static
746  const vrpn_int32 objNum,
747  const vrpn_int32 type)
748 {
749 
750  char *buf;
751  char *mptr;
752  vrpn_int32 mlen;
753 
754  len = sizeof(vrpn_int32) + sizeof(vrpn_int32);
755  mlen = len;
756 
757  buf = new char[len];
758  mptr = buf;
759 
760  vrpn_buffer(&mptr, &mlen, objNum);
761  vrpn_buffer(&mptr, &mlen, type);
762 
763  return buf;
764 }
765 
766 // static
767 vrpn_int32 vrpn_ForceDevice::decode_setTrimeshType(const char *buffer,
768  const vrpn_int32 len,
769  vrpn_int32 *objNum,
770  vrpn_int32 *type)
771 {
772 
773  const char *mptr = buffer;
774 
775  if (len != (sizeof(vrpn_int32) + sizeof(vrpn_int32))) {
776  fprintf(stderr, "vrpn_ForceDevice: trimesh type message payload");
777  fprintf(stderr, " error\n (got %d, expected %lud)\n", len,
778  static_cast<unsigned long>(sizeof(vrpn_int32) +
779  sizeof(vrpn_int32)));
780  return -1;
781  }
782 
783  CHECK(vrpn_unbuffer(&mptr, objNum));
784  CHECK(vrpn_unbuffer(&mptr, type));
785 
786  return 0;
787 }
788 
789 // static
791  vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_float32 homMatrix[16])
792 {
793  int i;
794  char *buf;
795  char *mptr;
796  vrpn_int32 mlen;
797 
798  len = sizeof(vrpn_int32) + 16 * sizeof(vrpn_float32);
799  mlen = len;
800 
801  buf = new char[len];
802  mptr = buf;
803 
804  vrpn_buffer(&mptr, &mlen, objNum);
805  for (i = 0; i < 16; i++)
806  vrpn_buffer(&mptr, &mlen, homMatrix[i]);
807 
808  return buf;
809 }
810 
811 // static
812 vrpn_int32 vrpn_ForceDevice::decode_trimeshTransform(const char *buffer,
813  const vrpn_int32 len,
814  vrpn_int32 *objNum,
815  vrpn_float32 homMatrix[16])
816 {
817  int i;
818  const char *mptr = buffer;
819 
820  if (len != (sizeof(vrpn_int32) + 16 * sizeof(vrpn_float32))) {
821  fprintf(stderr, "vrpn_ForceDevice: trimesh transform message payload ");
822  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
823  static_cast<unsigned long>(sizeof(vrpn_int32) +
824  16 * sizeof(vrpn_float32)));
825  return -1;
826  }
827 
828  CHECK(vrpn_unbuffer(&mptr, objNum));
829  for (i = 0; i < 16; i++)
830  CHECK(vrpn_unbuffer(&mptr, &(homMatrix[i])));
831 
832  return 0;
833 }
834 
836  const vrpn_int32 objNum,
837  const vrpn_int32 ParentNum)
838 {
839  char *buf;
840  char *mptr;
841  vrpn_int32 mlen;
842 
843  len = 2 * sizeof(vrpn_int32);
844  mlen = len;
845 
846  buf = new char[len];
847  mptr = buf;
848 
849  vrpn_buffer(&mptr, &mlen, objNum);
850  vrpn_buffer(&mptr, &mlen, ParentNum);
851 
852  return buf;
853 }
854 
855 vrpn_int32 vrpn_ForceDevice::decode_addObject(const char *buffer,
856  vrpn_int32 len,
857  vrpn_int32 *objNum,
858  vrpn_int32 *ParentNum)
859 {
860  const char *mptr = buffer;
861 
862  if (len != 2 * sizeof(vrpn_int32)) {
863  fprintf(stderr, "vrpn_ForceDevice: add object message payload ");
864  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
865  static_cast<unsigned long>(2 * sizeof(vrpn_int32)));
866  return -1;
867  }
868 
869  CHECK(vrpn_unbuffer(&mptr, objNum));
870  CHECK(vrpn_unbuffer(&mptr, ParentNum));
871 
872  return 0;
873 }
874 
876  const vrpn_int32 objNum)
877 {
878  char *buf;
879  char *mptr;
880  vrpn_int32 mlen;
881 
882  len = sizeof(objNum);
883  mlen = len;
884 
885  buf = new char[len];
886  mptr = buf;
887 
888  vrpn_buffer(&mptr, &mlen, objNum);
889 
890  return buf;
891 }
892 
893 vrpn_int32 vrpn_ForceDevice::decode_addObjectExScene(const char *buffer,
894  vrpn_int32 len,
895  vrpn_int32 *objNum)
896 {
897  const char *mptr = buffer;
898 
899  if (len != sizeof(vrpn_int32)) {
900  fprintf(stderr, "vrpn_ForceDevice: add object message payload ");
901  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
902  static_cast<unsigned long>(sizeof(vrpn_int32)));
903  return -1;
904  }
905 
906  CHECK(vrpn_unbuffer(&mptr, objNum));
907 
908  return 0;
909 }
910 
912  const vrpn_int32 objNum,
913  const vrpn_float32 Pos[3])
914 {
915  char *buf;
916  char *mptr;
917  vrpn_int32 mlen;
918 
919  len = sizeof(vrpn_int32) + 3 * sizeof(vrpn_float32);
920  mlen = len;
921 
922  buf = new char[len];
923  mptr = buf;
924 
925  vrpn_buffer(&mptr, &mlen, objNum);
926  vrpn_buffer(&mptr, &mlen, Pos[0]);
927  vrpn_buffer(&mptr, &mlen, Pos[1]);
928  vrpn_buffer(&mptr, &mlen, Pos[2]);
929 
930  return buf;
931 }
932 
933 vrpn_int32 vrpn_ForceDevice::decode_objectPosition(const char *buffer,
934  vrpn_int32 len,
935  vrpn_int32 *objNum,
936  vrpn_float32 Pos[3])
937 {
938  const char *mptr = buffer;
939 
940  if (len != (sizeof(vrpn_int32) + 3 * sizeof(vrpn_float32))) {
941  fprintf(stderr, "vrpn_ForceDevice: object position message payload ");
942  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
943  static_cast<unsigned long>(sizeof(vrpn_int32) +
944  3 * sizeof(vrpn_float32)));
945  return -1;
946  }
947 
948  CHECK(vrpn_unbuffer(&mptr, objNum));
949  CHECK(vrpn_unbuffer(&mptr, &Pos[0]));
950  CHECK(vrpn_unbuffer(&mptr, &Pos[1]));
951  CHECK(vrpn_unbuffer(&mptr, &Pos[2]));
952 
953  return 0;
954 }
955 
957  const vrpn_int32 objNum,
958  const vrpn_float32 axis[3],
959  const vrpn_float32 angle)
960 {
961  char *buf;
962  char *mptr;
963  vrpn_int32 mlen;
964 
965  len = sizeof(vrpn_int32) + 4 * sizeof(vrpn_float32);
966  mlen = len;
967 
968  buf = new char[len];
969  mptr = buf;
970 
971  vrpn_buffer(&mptr, &mlen, objNum);
972  vrpn_buffer(&mptr, &mlen, axis[0]);
973  vrpn_buffer(&mptr, &mlen, axis[1]);
974  vrpn_buffer(&mptr, &mlen, axis[2]);
975  vrpn_buffer(&mptr, &mlen, angle);
976 
977  return buf;
978 }
979 
980 vrpn_int32 vrpn_ForceDevice::decode_objectOrientation(const char *buffer,
981  vrpn_int32 len,
982  vrpn_int32 *objNum,
983  vrpn_float32 axis[3],
984  vrpn_float32 *angle)
985 {
986  const char *mptr = buffer;
987 
988  if (len != (sizeof(vrpn_int32) + 4 * sizeof(vrpn_float32))) {
989  fprintf(stderr,
990  "vrpn_ForceDevice: object orientation message payload ");
991  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
992  static_cast<unsigned long>(sizeof(vrpn_int32) +
993  4 * sizeof(vrpn_float32)));
994  return -1;
995  }
996 
997  CHECK(vrpn_unbuffer(&mptr, objNum));
998  CHECK(vrpn_unbuffer(&mptr, &axis[0]));
999  CHECK(vrpn_unbuffer(&mptr, &axis[1]));
1000  CHECK(vrpn_unbuffer(&mptr, &axis[2]));
1001  CHECK(vrpn_unbuffer(&mptr, angle));
1002 
1003  return 0;
1004 }
1005 
1007  const vrpn_int32 objNum,
1008  const vrpn_float32 Scale[3])
1009 {
1010  char *buf;
1011  char *mptr;
1012  vrpn_int32 mlen;
1013 
1014  len = sizeof(vrpn_int32) + 3 * sizeof(vrpn_float32);
1015  mlen = len;
1016 
1017  buf = new char[len];
1018  mptr = buf;
1019 
1020  vrpn_buffer(&mptr, &mlen, objNum);
1021  vrpn_buffer(&mptr, &mlen, Scale[0]);
1022  vrpn_buffer(&mptr, &mlen, Scale[1]);
1023  vrpn_buffer(&mptr, &mlen, Scale[2]);
1024 
1025  return buf;
1026 }
1027 
1028 vrpn_int32 vrpn_ForceDevice::decode_objectScale(const char *buffer,
1029  vrpn_int32 len,
1030  vrpn_int32 *objNum,
1031  vrpn_float32 Scale[3])
1032 {
1033  const char *mptr = buffer;
1034 
1035  if (len != (sizeof(vrpn_int32) + 3 * sizeof(vrpn_float32))) {
1036  fprintf(stderr, "vrpn_ForceDevice: object scale message payload ");
1037  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
1038  static_cast<unsigned long>(sizeof(vrpn_int32) +
1039  3 * sizeof(vrpn_float32)));
1040  return -1;
1041  }
1042 
1043  CHECK(vrpn_unbuffer(&mptr, objNum));
1044  CHECK(vrpn_unbuffer(&mptr, &Scale[0]));
1045  CHECK(vrpn_unbuffer(&mptr, &Scale[1]));
1046  CHECK(vrpn_unbuffer(&mptr, &Scale[2]));
1047 
1048  return 0;
1049 }
1050 
1052  const vrpn_int32 objNum)
1053 {
1054  char *buf;
1055  char *mptr;
1056  vrpn_int32 mlen;
1057 
1058  len = sizeof(vrpn_int32);
1059  mlen = len;
1060 
1061  buf = new char[len];
1062  mptr = buf;
1063 
1064  vrpn_buffer(&mptr, &mlen, objNum);
1065 
1066  return buf;
1067 }
1068 
1069 vrpn_int32 vrpn_ForceDevice::decode_removeObject(const char *buffer,
1070  vrpn_int32 len,
1071  vrpn_int32 *objNum)
1072 {
1073  const char *mptr = buffer;
1074 
1075  if (len != sizeof(vrpn_int32)) {
1076  fprintf(stderr, "vrpn_ForceDevice: remove object message payload ");
1077  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
1078  static_cast<unsigned long>(sizeof(vrpn_int32)));
1079  return -1;
1080  }
1081 
1082  CHECK(vrpn_unbuffer(&mptr, objNum));
1083 
1084  return 0;
1085 }
1086 
1088  const vrpn_int32 objNum)
1089 {
1090  char *buf;
1091  char *mptr;
1092  vrpn_int32 mlen;
1093 
1094  len = sizeof(vrpn_int32);
1095  mlen = len;
1096 
1097  buf = new char[len];
1098  mptr = buf;
1099 
1100  vrpn_buffer(&mptr, &mlen, objNum);
1101 
1102  return buf;
1103 }
1104 
1105 vrpn_int32 vrpn_ForceDevice::decode_clearTrimesh(const char *buffer,
1106  vrpn_int32 len,
1107  vrpn_int32 *objNum)
1108 {
1109  const char *mptr = buffer;
1110 
1111  if (len != sizeof(vrpn_int32)) {
1112  fprintf(stderr, "vrpn_ForceDevice: clear TriMesh message payload ");
1113  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
1114  static_cast<unsigned long>(sizeof(vrpn_int32)));
1115  return -1;
1116  }
1117 
1118  CHECK(vrpn_unbuffer(&mptr, objNum));
1119 
1120  return 0;
1121 }
1122 
1124  const vrpn_int32 objNum,
1125  const vrpn_int32 parentNum)
1126 {
1127  char *buf;
1128  char *mptr;
1129  vrpn_int32 mlen;
1130 
1131  len = sizeof(vrpn_int32) + sizeof(vrpn_int32);
1132  mlen = len;
1133 
1134  buf = new char[len];
1135  mptr = buf;
1136 
1137  vrpn_buffer(&mptr, &mlen, objNum);
1138  vrpn_buffer(&mptr, &mlen, parentNum);
1139 
1140  return buf;
1141 }
1142 
1143 vrpn_int32 vrpn_ForceDevice::decode_moveToParent(const char *buffer,
1144  vrpn_int32 len,
1145  vrpn_int32 *objNum,
1146  vrpn_int32 *parentNum)
1147 {
1148  const char *mptr = buffer;
1149 
1150  if (len != (sizeof(vrpn_int32) + sizeof(vrpn_int32))) {
1151  fprintf(stderr,
1152  "vrpn_ForceDevice: move object to parent message payload ");
1153  fprintf(stderr, "error\n (got %d, expected %lud)\n", len,
1154  static_cast<unsigned long>(sizeof(vrpn_int32) +
1155  sizeof(vrpn_int32)));
1156  return -1;
1157  }
1158 
1159  CHECK(vrpn_unbuffer(&mptr, objNum));
1160  CHECK(vrpn_unbuffer(&mptr, parentNum));
1161 
1162  return 0;
1163 }
1164 
1166  const vrpn_float32 Pos[3],
1167  const vrpn_float32 axis[3],
1168  const vrpn_float32 angle)
1169 {
1170  int i;
1171  char *buf;
1172  char *mptr;
1173  vrpn_int32 mlen;
1174 
1175  len = 7 * sizeof(vrpn_float32);
1176  mlen = len;
1177 
1178  buf = new char[len];
1179  mptr = buf;
1180 
1181  for (i = 0; i < 3; i++)
1182  vrpn_buffer(&mptr, &mlen, Pos[i]);
1183 
1184  for (i = 0; i < 3; i++)
1185  vrpn_buffer(&mptr, &mlen, axis[i]);
1186 
1187  vrpn_buffer(&mptr, &mlen, angle);
1188 
1189  return buf;
1190 }
1191 
1192 vrpn_int32 vrpn_ForceDevice::decode_setHapticOrigin(const char *buffer,
1193  vrpn_int32 len,
1194  vrpn_float32 Pos[3],
1195  vrpn_float32 axis[3],
1196  vrpn_float32 *angle)
1197 {
1198  int i;
1199  const char *mptr = buffer;
1200 
1201  if (len != 7 * sizeof(vrpn_int32)) {
1202  fprintf(stderr,
1203  "vrpn_ForceDevice: sethapticorigin message payload error\n");
1204  fprintf(stderr, " (got %d, expected %lud)\n", len,
1205  static_cast<unsigned long>(7 * sizeof(vrpn_int32)));
1206  return -1;
1207  }
1208 
1209  for (i = 0; i < 3; i++)
1210  CHECK(vrpn_unbuffer(&mptr, &Pos[i]));
1211 
1212  for (i = 0; i < 3; i++)
1213  CHECK(vrpn_unbuffer(&mptr, &axis[i]));
1214 
1215  CHECK(vrpn_unbuffer(&mptr, angle));
1216  return 0;
1217 }
1218 
1220  const vrpn_float32 scale)
1221 {
1222  char *buf;
1223  char *mptr;
1224  vrpn_int32 mlen;
1225 
1226  len = sizeof(vrpn_float32);
1227  mlen = len;
1228 
1229  buf = new char[len];
1230  mptr = buf;
1231 
1232  vrpn_buffer(&mptr, &mlen, scale);
1233 
1234  return buf;
1235 }
1236 
1237 vrpn_int32 vrpn_ForceDevice::decode_setHapticScale(const char *buffer,
1238  vrpn_int32 len,
1239  vrpn_float32 *scale)
1240 {
1241  const char *mptr = buffer;
1242 
1243  if (len != sizeof(vrpn_float32)) {
1244  fprintf(stderr,
1245  "vrpn_ForceDevice: sethapticscale message payload error\n");
1246  fprintf(stderr, " (got %d, expected %lud)\n", len,
1247  static_cast<unsigned long>(7 * sizeof(vrpn_float32)));
1248  return -1;
1249  }
1250 
1251  CHECK(vrpn_unbuffer(&mptr, scale));
1252 
1253  return 0;
1254 }
1255 
1257  const vrpn_float32 Pos[3],
1258  const vrpn_float32 axis[3],
1259  const vrpn_float32 angle)
1260 {
1261  int i;
1262  char *buf;
1263  char *mptr;
1264  vrpn_int32 mlen;
1265 
1266  len = 7 * sizeof(vrpn_float32);
1267  mlen = len;
1268 
1269  buf = new char[len];
1270  mptr = buf;
1271 
1272  for (i = 0; i < 3; i++)
1273  vrpn_buffer(&mptr, &mlen, Pos[i]);
1274 
1275  for (i = 0; i < 3; i++)
1276  vrpn_buffer(&mptr, &mlen, axis[i]);
1277 
1278  vrpn_buffer(&mptr, &mlen, angle);
1279 
1280  return buf;
1281 }
1282 
1283 vrpn_int32 vrpn_ForceDevice::decode_setSceneOrigin(const char *buffer,
1284  vrpn_int32 len,
1285  vrpn_float32 Pos[3],
1286  vrpn_float32 axis[3],
1287  vrpn_float32 *angle)
1288 {
1289  int i;
1290  const char *mptr = buffer;
1291 
1292  if (len != 7 * sizeof(vrpn_int32)) {
1293  fprintf(stderr,
1294  "vrpn_ForceDevice: setsceneorigin message payload error\n");
1295  fprintf(stderr, " (got %d, expected %lud)\n", len,
1296  static_cast<unsigned long>(7 * sizeof(vrpn_int32)));
1297  return -1;
1298  }
1299 
1300  for (i = 0; i < 3; i++)
1301  CHECK(vrpn_unbuffer(&mptr, &Pos[i]));
1302 
1303  for (i = 0; i < 3; i++)
1304  CHECK(vrpn_unbuffer(&mptr, &axis[i]));
1305 
1306  CHECK(vrpn_unbuffer(&mptr, angle));
1307 
1308  return 0;
1309 }
1310 
1312  const vrpn_int32 objNum,
1313  const vrpn_bool IsTouchable)
1314 {
1315  char *buf;
1316  char *mptr;
1317  vrpn_int32 mlen;
1318 
1319  len = sizeof(vrpn_int32) + sizeof(vrpn_bool);
1320  mlen = len;
1321 
1322  buf = new char[len];
1323  mptr = buf;
1324 
1325  vrpn_buffer(&mptr, &mlen, objNum);
1326  vrpn_buffer(&mptr, &mlen, IsTouchable);
1327 
1328  return buf;
1329 }
1330 
1332  vrpn_int32 len,
1333  vrpn_int32 *objNum,
1334  vrpn_bool *IsTouchable)
1335 {
1336  const char *mptr = buffer;
1337 
1338  if (len != (sizeof(vrpn_int32) + sizeof(vrpn_bool))) {
1339  fprintf(stderr, "vrpn_ForceDevice: set object is touchable message "
1340  "payload error\n");
1341  fprintf(
1342  stderr, " (got %d, expected %lud)\n", len,
1343  static_cast<unsigned long>(sizeof(vrpn_int32) + sizeof(vrpn_bool)));
1344  return -1;
1345  }
1346 
1347  CHECK(vrpn_unbuffer(&mptr, objNum));
1348  CHECK(vrpn_unbuffer(&mptr, IsTouchable));
1349 
1350  return 0;
1351 }
1352 
1353 // static
1355  const vrpn_float32 origin[3],
1356  const vrpn_float32 force[3],
1357  const vrpn_float32 jacobian[3][3],
1358  const vrpn_float32 radius)
1359 {
1360  int i, j;
1361  char *buf;
1362  char *mptr;
1363  vrpn_int32 mlen;
1364 
1365  len = 16 * sizeof(vrpn_float32);
1366  mlen = len;
1367 
1368  buf = new char[len];
1369  mptr = buf;
1370 
1371  for (i = 0; i < 3; i++)
1372  vrpn_buffer(&mptr, &mlen, origin[i]);
1373 
1374  for (i = 0; i < 3; i++)
1375  vrpn_buffer(&mptr, &mlen, force[i]);
1376 
1377  for (i = 0; i < 3; i++)
1378  for (j = 0; j < 3; j++)
1379  vrpn_buffer(&mptr, &mlen, jacobian[i][j]);
1380 
1381  vrpn_buffer(&mptr, &mlen, radius);
1382 
1383  return buf;
1384 }
1385 
1386 // static
1388  const char *buffer, const vrpn_int32 len, vrpn_float32 origin[3],
1389  vrpn_float32 force[3], vrpn_float32 jacobian[3][3], vrpn_float32 *radius)
1390 {
1391  int i, j;
1392  const char *mptr = buffer;
1393 
1394  if (len != 16 * sizeof(vrpn_float32)) {
1395  fprintf(stderr,
1396  "vrpn_ForceDevice: force field message payload error\n");
1397  fprintf(stderr, " (got %d, expected %lud)\n", len,
1398  static_cast<unsigned long>(16 * sizeof(vrpn_float32)));
1399  return -1;
1400  }
1401 
1402  for (i = 0; i < 3; i++)
1403  CHECK(vrpn_unbuffer(&mptr, &(origin[i])));
1404 
1405  for (i = 0; i < 3; i++)
1406  CHECK(vrpn_unbuffer(&mptr, &(force[i])));
1407 
1408  for (i = 0; i < 3; i++)
1409  for (j = 0; j < 3; j++)
1410  CHECK(vrpn_unbuffer(&mptr, &(jacobian[i][j])));
1411 
1412  CHECK(vrpn_unbuffer(&mptr, radius));
1413 
1414  return 0;
1415 }
1416 
1417 char *vrpn_ForceDevice::encode_error(vrpn_int32 &len,
1418  const vrpn_int32 error_code)
1419 {
1420 
1421  char *buf;
1422  char *mptr;
1423  vrpn_int32 mlen;
1424 
1425  len = sizeof(vrpn_int32);
1426  mlen = len;
1427 
1428  buf = new char[len];
1429  mptr = buf;
1430 
1431  vrpn_buffer(&mptr, &mlen, error_code);
1432 
1433  return buf;
1434 }
1435 
1436 vrpn_int32 vrpn_ForceDevice::decode_error(const char *buffer,
1437  const vrpn_int32 len,
1438  vrpn_int32 *error_code)
1439 {
1440 
1441  const char *mptr = buffer;
1442 
1443  if (len != sizeof(vrpn_int32)) {
1444  fprintf(stderr, "vrpn_ForceDevice: error message payload error\n");
1445  fprintf(stderr, " (got %d, expected %lud)\n", len,
1446  static_cast<unsigned long>(sizeof(vrpn_int32)));
1447  return -1;
1448  }
1449 
1450  CHECK(vrpn_unbuffer(&mptr, error_code));
1451 
1452  return 0;
1453 }
1454 
1455 void vrpn_ForceDevice::set_plane(vrpn_float32 *p)
1456 {
1457  for (int i = 0; i < 4; i++) {
1458  plane[i] = p[i];
1459  }
1460 }
1461 
1462 void vrpn_ForceDevice::set_plane(vrpn_float32 a, vrpn_float32 b, vrpn_float32 c,
1463  vrpn_float32 d)
1464 {
1465  plane[0] = a;
1466  plane[1] = b;
1467  plane[2] = c;
1468  plane[3] = d;
1469 }
1470 
1471 void vrpn_ForceDevice::set_plane(vrpn_float32 *normal, vrpn_float32 d)
1472 {
1473  for (int i = 0; i < 3; i++) {
1474  plane[i] = normal[i];
1475  }
1476 
1477  plane[3] = d;
1478 }
1479 
1480 void vrpn_ForceDevice::sendError(int error_code)
1481 {
1482  char *msgbuf;
1483  vrpn_int32 len;
1484  struct timeval current_time;
1485 
1486  vrpn_gettimeofday(&current_time, NULL);
1487  timestamp.tv_sec = current_time.tv_sec;
1488  timestamp.tv_usec = current_time.tv_usec;
1489 
1490  if (d_connection) {
1491  msgbuf = encode_error(len, error_code);
1493  d_sender_id, msgbuf,
1495  fprintf(stderr, "Phantom: cannot write message: tossing\n");
1496  }
1497  delete[] msgbuf;
1498  }
1499 }
1500 
1501 // constraint message encode/decode methods
1502 
1503 // static
1505  vrpn_int32 enable)
1506 {
1507  char *buf;
1508  char *mptr;
1509  vrpn_int32 mlen;
1510 
1511  len = sizeof(vrpn_int32);
1512  mlen = len;
1513 
1514  buf = new char[len];
1515  mptr = buf;
1516 
1517  vrpn_buffer(&mptr, &mlen, enable);
1518 
1519  return buf;
1520 }
1521 
1522 // static
1523 vrpn_int32 vrpn_ForceDevice::decode_enableConstraint(const char *buffer,
1524  const vrpn_int32 len,
1525  vrpn_int32 *enable)
1526 {
1527  const char *mptr = buffer;
1528 
1529  if (len != sizeof(vrpn_int32)) {
1530  fprintf(stderr, "vrpn_ForceDevice: "
1531  "enable constraint message payload error\n"
1532  " (got %d, expected %lud)\n",
1533  len, static_cast<unsigned long>(sizeof(vrpn_int32)));
1534  return -1;
1535  }
1536 
1537  CHECK(vrpn_unbuffer(&mptr, enable));
1538 
1539  return 0;
1540 }
1541 
1542 // static
1544  ConstraintGeometry mode)
1545 {
1546  char *buf;
1547  char *mptr;
1548  vrpn_int32 modeint;
1549  vrpn_int32 mlen;
1550 
1551  len = sizeof(vrpn_int32);
1552  mlen = len;
1553 
1554  buf = new char[len];
1555  mptr = buf;
1556 
1557  switch (mode) {
1558  case NO_CONSTRAINT:
1559  modeint = 0;
1560  break;
1561  case POINT_CONSTRAINT:
1562  modeint = 1;
1563  break;
1564  case LINE_CONSTRAINT:
1565  modeint = 2;
1566  break;
1567  case PLANE_CONSTRAINT:
1568  modeint = 3;
1569  break;
1570  default:
1571  fprintf(stderr, "vrpn_ForceDevice: "
1572  "Unknown or illegal constraint mode.\n");
1573  modeint = 0;
1574  break;
1575  }
1576 
1577  vrpn_buffer(&mptr, &mlen, modeint);
1578 
1579  return buf;
1580 }
1581 
1582 // static
1583 vrpn_int32 vrpn_ForceDevice::decode_setConstraintMode(const char *buffer,
1584  const vrpn_int32 len,
1585  ConstraintGeometry *mode)
1586 {
1587  const char *mptr = buffer;
1588  vrpn_int32 modeint;
1589 
1590  if (len != sizeof(vrpn_int32)) {
1591  fprintf(stderr, "vrpn_ForceDevice: "
1592  "constraint mode payload error\n"
1593  " (got %d, expected %lud)\n",
1594  len, static_cast<unsigned long>(sizeof(vrpn_int32)));
1595  return -1;
1596  }
1597 
1598  CHECK(vrpn_unbuffer(&mptr, &modeint));
1599 
1600  switch (modeint) {
1601  case 0:
1602  *mode = NO_CONSTRAINT;
1603  break;
1604  case 1:
1605  *mode = POINT_CONSTRAINT;
1606  break;
1607  case 2:
1608  *mode = LINE_CONSTRAINT;
1609  break;
1610  case 3:
1611  *mode = PLANE_CONSTRAINT;
1612  break;
1613  default:
1614  fprintf(stderr, "vrpn_ForceDevice: "
1615  "Unknown or illegal constraint mode.\n");
1616  *mode = NO_CONSTRAINT;
1617  return -1;
1618  }
1619 
1620  return 0;
1621 }
1622 
1623 // static
1625  vrpn_float32 x,
1626  vrpn_float32 y,
1627  vrpn_float32 z)
1628 {
1629  return encodePoint(len, x, y, z);
1630 }
1631 
1632 // static
1633 vrpn_int32 vrpn_ForceDevice::decode_setConstraintPoint(const char *buffer,
1634  const vrpn_int32 len,
1635  vrpn_float32 *x,
1636  vrpn_float32 *y,
1637  vrpn_float32 *z)
1638 {
1639  return decodePoint(buffer, len, x, y, z);
1640 }
1641 
1642 // static
1644  vrpn_float32 x,
1645  vrpn_float32 y,
1646  vrpn_float32 z)
1647 {
1648  return encodePoint(len, x, y, z);
1649 }
1650 
1651 // static
1653  const vrpn_int32 len,
1654  vrpn_float32 *x,
1655  vrpn_float32 *y,
1656  vrpn_float32 *z)
1657 {
1658  return decodePoint(buffer, len, x, y, z);
1659 }
1660 
1661 // static
1663  vrpn_float32 x,
1664  vrpn_float32 y,
1665  vrpn_float32 z)
1666 {
1667  return encodePoint(len, x, y, z);
1668 }
1669 
1670 // static
1672  const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y,
1673  vrpn_float32 *z)
1674 {
1675  return decodePoint(buffer, len, x, y, z);
1676 }
1677 
1678 // static
1680  vrpn_float32 x,
1681  vrpn_float32 y,
1682  vrpn_float32 z)
1683 {
1684  return encodePoint(len, x, y, z);
1685 }
1686 
1687 // static
1689  const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y,
1690  vrpn_float32 *z)
1691 {
1692  return decodePoint(buffer, len, x, y, z);
1693 }
1694 
1695 // static
1697  vrpn_float32 x,
1698  vrpn_float32 y,
1699  vrpn_float32 z)
1700 {
1701  return encodePoint(len, x, y, z);
1702 }
1703 
1704 // static
1706  const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y,
1707  vrpn_float32 *z)
1708 {
1709  return decodePoint(buffer, len, x, y, z);
1710 }
1711 
1712 // static
1714  vrpn_float32 k)
1715 {
1716  char *buf;
1717  char *mptr;
1718  vrpn_int32 mlen;
1719 
1720  len = sizeof(vrpn_float32);
1721  mlen = len;
1722 
1723  buf = new char[len];
1724  mptr = buf;
1725 
1726  vrpn_buffer(&mptr, &mlen, k);
1727 
1728  return buf;
1729 }
1730 
1731 // static
1733  const vrpn_int32 len,
1734  vrpn_float32 *k)
1735 {
1736  const char *mptr = buffer;
1737 
1738  if (len != sizeof(vrpn_float32)) {
1739  fprintf(stderr, "vrpn_ForceDevice: "
1740  "set constraint spring message payload error\n"
1741  " (got %d, expected %lud)\n",
1742  len, static_cast<unsigned long>(sizeof(vrpn_float32)));
1743  return -1;
1744  }
1745 
1746  CHECK(vrpn_unbuffer(&mptr, k));
1747 
1748  return 0;
1749 }
1750 
1751 //
1752 // utility functions
1753 //
1754 
1755 // static
1756 char *vrpn_ForceDevice::encodePoint(vrpn_int32 &len, vrpn_float32 x,
1757  vrpn_float32 y, vrpn_float32 z)
1758 {
1759  char *buf;
1760  char *mptr;
1761  vrpn_int32 mlen;
1762 
1763  len = 3 * sizeof(vrpn_float32);
1764  mlen = len;
1765 
1766  buf = new char[len];
1767  mptr = buf;
1768 
1769  vrpn_buffer(&mptr, &mlen, x);
1770  vrpn_buffer(&mptr, &mlen, y);
1771  vrpn_buffer(&mptr, &mlen, z);
1772 
1773  return buf;
1774 }
1775 
1776 // static
1777 vrpn_int32 vrpn_ForceDevice::decodePoint(const char *buffer,
1778  const vrpn_int32 len, vrpn_float32 *x,
1779  vrpn_float32 *y, vrpn_float32 *z)
1780 {
1781  const char *mptr = buffer;
1782 
1783  if (len != 3 * sizeof(vrpn_float32)) {
1784  fprintf(stderr, "vrpn_ForceDevice: "
1785  "decode point message payload error\n"
1786  " (got size %d, expected %lud)\n",
1787  len, static_cast<unsigned long>(3 * sizeof(vrpn_float32)));
1788  return -1;
1789  }
1790 
1791  CHECK(vrpn_unbuffer(&mptr, x));
1792  CHECK(vrpn_unbuffer(&mptr, y));
1793  CHECK(vrpn_unbuffer(&mptr, z));
1794 
1795  return 0;
1796 }
1797 
1798 /* ******************** vrpn_ForceDevice_Remote ********************** */
1799 
1801  vrpn_Connection *cn)
1802  : vrpn_ForceDevice(name, cn)
1803  , d_conEnabled(0)
1804  , d_conMode(POINT_CONSTRAINT)
1805 {
1806  which_plane = 0;
1807 
1808  // Make sure that we have a valid connection
1809  if (d_connection == NULL) {
1810  fprintf(stderr, "vrpn_ForceDevice_Remote: No connection\n");
1811  return;
1812  }
1813 
1814  // Register a handler for the change callback from this device.
1817  fprintf(stderr, "vrpn_ForceDevice_Remote:can't register handler\n");
1818  d_connection = NULL;
1819  }
1820 
1821  // Register a handler for the scp change callback from this device.
1823  this, d_sender_id)) {
1824  fprintf(stderr, "vrpn_ForceDevice_Remote:can't register handler\n");
1825  d_connection = NULL;
1826  }
1827 
1828  // Register a handler for the error change callback from this device.
1831  fprintf(stderr, "vrpn_ForceDevice_Remote:can't register handler\n");
1832  d_connection = NULL;
1833  }
1834 
1835  // Find out what time it is and put this into the timestamp
1836  vrpn_gettimeofday(&timestamp, NULL);
1837 }
1838 
1839 // virtual
1841 
1843 { // Encode the plane if there is a connection
1844  char *msgbuf;
1845  vrpn_int32 len;
1846  struct timeval current_time;
1847 
1848  vrpn_gettimeofday(&current_time, NULL);
1849  timestamp.tv_sec = current_time.tv_sec;
1850  timestamp.tv_usec = current_time.tv_usec;
1851 
1852  if (d_connection) {
1855  numRecCycles);
1857  d_sender_id, msgbuf,
1859  fprintf(stderr, "Phantom: cannot write message: tossing\n");
1860  }
1861  delete[] msgbuf;
1862 
1863  msgbuf = encode_surface_effects(
1866  SurfaceBuzzFreq);
1868  d_sender_id, msgbuf,
1870  fprintf(stderr, "Phantom: cannot write message: tossing\n");
1871  }
1872  delete[] msgbuf;
1873  }
1874 }
1875 
1877 { // Encode the plane if there is a connection
1878  char *msgbuf;
1879  vrpn_int32 len;
1880  struct timeval current_time;
1881 
1882  vrpn_gettimeofday(&current_time, NULL);
1883  timestamp.tv_sec = current_time.tv_sec;
1884  timestamp.tv_usec = current_time.tv_usec;
1885 
1886  if (d_connection) {
1889  numRecCycles);
1891  d_sender_id, msgbuf,
1893  fprintf(stderr, "Phantom: cannot write message: tossing\n");
1894  }
1895  delete[] msgbuf;
1896  }
1897 }
1898 
1900 { // Encode the plane if there is a connection
1901  char *msgbuf;
1902  vrpn_int32 len;
1903  struct timeval current_time;
1904 
1905  vrpn_gettimeofday(&current_time, NULL);
1906  timestamp.tv_sec = current_time.tv_sec;
1907  timestamp.tv_usec = current_time.tv_usec;
1908 
1909  set_plane(0, 0, 0, 0);
1910 
1911  if (d_connection) {
1914  numRecCycles);
1916  d_sender_id, msgbuf,
1918  fprintf(stderr, "Phantom: cannot write message: tossing\n");
1919  }
1920  delete[] msgbuf;
1921  }
1922 }
1923 
1924 void vrpn_ForceDevice_Remote::setVertex(vrpn_int32 vertNum, vrpn_float32 x,
1925  vrpn_float32 y, vrpn_float32 z)
1926 {
1927  setObjectVertex(0, vertNum, x, y, z);
1928 }
1929 
1930 void vrpn_ForceDevice_Remote::setNormal(vrpn_int32 normNum, vrpn_float32 x,
1931  vrpn_float32 y, vrpn_float32 z)
1932 {
1933  setObjectNormal(0, normNum, x, y, z);
1934 }
1935 
1936 void vrpn_ForceDevice_Remote::setTriangle(vrpn_int32 triNum, vrpn_int32 vert0,
1937  vrpn_int32 vert1, vrpn_int32 vert2,
1938  vrpn_int32 norm0, vrpn_int32 norm1,
1939  vrpn_int32 norm2)
1940 {
1941  setObjectTriangle(0, triNum, vert0, vert1, vert2, norm0, norm1, norm2);
1942 }
1943 
1945 {
1946  removeObjectTriangle(0, triNum);
1947 }
1948 
1950 {
1952 }
1953 
1954 // set the trimesh's homogen transform matrix (in row major order)
1955 void vrpn_ForceDevice_Remote::setTrimeshTransform(vrpn_float32 homMatrix[16])
1956 {
1957  setObjectTrimeshTransform(0, homMatrix);
1958 }
1959 
1960 // clear the triMesh if connection
1962 
1965 // Add an object to the haptic scene as root (parent -1 = default) or as child
1966 // (ParentNum =the number of the parent)
1967 void vrpn_ForceDevice_Remote::addObject(vrpn_int32 objNum,
1968  vrpn_int32 ParentNum /*=-1*/)
1969 {
1970  char *msgbuf;
1971  vrpn_int32 len;
1972  struct timeval current_time;
1973 
1974  if (objNum > m_NextAvailableObjectID) m_NextAvailableObjectID = objNum + 1;
1975 
1976  vrpn_gettimeofday(&current_time, NULL);
1977  timestamp.tv_sec = current_time.tv_sec;
1978  timestamp.tv_usec = current_time.tv_usec;
1979 
1980  if (d_connection) {
1981  msgbuf = encode_addObject(len, objNum, ParentNum);
1983  d_sender_id, msgbuf,
1985  fprintf(stderr, "Phantom: cannot write message: tossing\n");
1986  }
1987  delete[] msgbuf;
1988  }
1989 }
1990 
1991 // Add an object next to the haptic scene as root
1993 {
1994  char *msgbuf;
1995  vrpn_int32 len;
1996  struct timeval current_time;
1997 
1998  if (objNum > m_NextAvailableObjectID) m_NextAvailableObjectID = objNum + 1;
1999 
2000  vrpn_gettimeofday(&current_time, NULL);
2001  timestamp.tv_sec = current_time.tv_sec;
2002  timestamp.tv_usec = current_time.tv_usec;
2003 
2004  if (d_connection) {
2005  msgbuf = encode_addObjectExScene(len, objNum);
2008  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2009  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2010  }
2011  delete[] msgbuf;
2012  }
2013 }
2014 
2015 // vertNum normNum and triNum start at 0
2017  vrpn_int32 vertNum,
2018  vrpn_float32 x, vrpn_float32 y,
2019  vrpn_float32 z)
2020 {
2021  char *msgbuf;
2022  vrpn_int32 len;
2023  struct timeval current_time;
2024 
2025  vrpn_gettimeofday(&current_time, NULL);
2026  timestamp.tv_sec = current_time.tv_sec;
2027  timestamp.tv_usec = current_time.tv_usec;
2028 
2029  if (d_connection) {
2030  msgbuf = encode_vertex(len, objNum, vertNum, x, y, z);
2032  d_sender_id, msgbuf,
2034  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2035  }
2036  delete[] msgbuf;
2037  }
2038 }
2039 
2040 // NOTE: ghost doesn't take normals,
2041 // and normals still aren't implemented for Hcollide
2043  vrpn_int32 normNum,
2044  vrpn_float32 x, vrpn_float32 y,
2045  vrpn_float32 z)
2046 {
2047  char *msgbuf;
2048  vrpn_int32 len;
2049  struct timeval current_time;
2050 
2051  vrpn_gettimeofday(&current_time, NULL);
2052  timestamp.tv_sec = current_time.tv_sec;
2053  timestamp.tv_usec = current_time.tv_usec;
2054 
2055  if (d_connection) {
2056  msgbuf = encode_normal(len, objNum, normNum, x, y, z);
2058  d_sender_id, msgbuf,
2060  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2061  }
2062  delete[] msgbuf;
2063  }
2064 }
2065 
2067  vrpn_int32 objNum, vrpn_int32 triNum, vrpn_int32 vert0, vrpn_int32 vert1,
2068  vrpn_int32 vert2, vrpn_int32 norm0 /*=-1*/, vrpn_int32 norm1 /*=-1*/,
2069  vrpn_int32 norm2 /*=-1*/)
2070 {
2071  char *msgbuf;
2072  vrpn_int32 len;
2073  struct timeval current_time;
2074 
2075  vrpn_gettimeofday(&current_time, NULL);
2076  timestamp.tv_sec = current_time.tv_sec;
2077  timestamp.tv_usec = current_time.tv_usec;
2078 
2079  if (d_connection) {
2080  msgbuf = encode_triangle(len, objNum, triNum, vert0, vert1, vert2,
2081  norm0, norm1, norm2);
2083  d_sender_id, msgbuf,
2085  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2086  }
2087  delete[] msgbuf;
2088  }
2089 }
2090 
2092  vrpn_int32 triNum)
2093 {
2094  char *msgbuf;
2095  vrpn_int32 len;
2096  struct timeval current_time;
2097 
2098  vrpn_gettimeofday(&current_time, NULL);
2099  timestamp.tv_sec = current_time.tv_sec;
2100  timestamp.tv_usec = current_time.tv_usec;
2101 
2102  if (d_connection) {
2103  msgbuf = encode_removeTriangle(len, objNum, triNum);
2106  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2107  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2108  }
2109  delete[] msgbuf;
2110  }
2111 }
2112 
2113 // should be called to incorporate the above changes into the
2114 // displayed trimesh
2116 {
2117  char *msgbuf;
2118  vrpn_int32 len;
2119  struct timeval current_time;
2120 
2121  vrpn_gettimeofday(&current_time, NULL);
2122  timestamp.tv_sec = current_time.tv_sec;
2123  timestamp.tv_usec = current_time.tv_usec;
2124 
2125  if (d_connection) {
2126  msgbuf = encode_updateTrimeshChanges(len, objNum, SurfaceKspring,
2128  SurfaceFdynamic);
2131  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2132  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2133  }
2134  delete[] msgbuf;
2135  }
2136 }
2137 
2138 // set the trimesh's homogen transform matrix (in row major order)
2140  vrpn_int32 objNum, vrpn_float32 homMatrix[16])
2141 {
2142  char *msgbuf;
2143  vrpn_int32 len;
2144  struct timeval current_time;
2145 
2146  vrpn_gettimeofday(&current_time, NULL);
2147  timestamp.tv_sec = current_time.tv_sec;
2148  timestamp.tv_usec = current_time.tv_usec;
2149 
2150  if (d_connection) {
2151  msgbuf = encode_trimeshTransform(len, objNum, homMatrix);
2154  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2155  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2156  }
2157  delete[] msgbuf;
2158  }
2159 }
2160 
2161 // set position of an object
2163  vrpn_float32 Pos[3])
2164 {
2165  char *msgbuf;
2166  vrpn_int32 len;
2167  struct timeval current_time;
2168 
2169  vrpn_gettimeofday(&current_time, NULL);
2170  timestamp.tv_sec = current_time.tv_sec;
2171  timestamp.tv_usec = current_time.tv_usec;
2172 
2173  if (d_connection) {
2174  msgbuf = encode_objectPosition(len, objNum, Pos);
2177  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2178  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2179  }
2180  delete[] msgbuf;
2181  }
2182 }
2183 
2184 // set orientation of an object
2186  vrpn_float32 axis[3],
2187  vrpn_float32 angle)
2188 {
2189  char *msgbuf;
2190  vrpn_int32 len;
2191  struct timeval current_time;
2192 
2193  vrpn_gettimeofday(&current_time, NULL);
2194  timestamp.tv_sec = current_time.tv_sec;
2195  timestamp.tv_usec = current_time.tv_usec;
2196 
2197  if (d_connection) {
2198  msgbuf = encode_objectOrientation(len, objNum, axis, angle);
2201  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2202  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2203  }
2204  delete[] msgbuf;
2205  }
2206 }
2207 
2208 // set Scale of an object
2210  vrpn_float32 Scale[3])
2211 {
2212  char *msgbuf;
2213  vrpn_int32 len;
2214  struct timeval current_time;
2215 
2216  vrpn_gettimeofday(&current_time, NULL);
2217  timestamp.tv_sec = current_time.tv_sec;
2218  timestamp.tv_usec = current_time.tv_usec;
2219 
2220  if (d_connection) {
2221  msgbuf = encode_objectScale(len, objNum, Scale);
2224  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2225  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2226  }
2227  delete[] msgbuf;
2228  }
2229 }
2230 
2231 // remove an object from the scene
2233 {
2234  char *msgbuf;
2235  vrpn_int32 len;
2236  struct timeval current_time;
2237 
2238  vrpn_gettimeofday(&current_time, NULL);
2239  timestamp.tv_sec = current_time.tv_sec;
2240  timestamp.tv_usec = current_time.tv_usec;
2241 
2242  if (d_connection) {
2243  msgbuf = encode_removeObject(len, objNum);
2245  d_sender_id, msgbuf,
2247  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2248  }
2249  delete[] msgbuf;
2250  }
2251 }
2252 
2254 {
2255  char *msgbuf = NULL;
2256  vrpn_int32 len = 0;
2257  struct timeval current_time;
2258 
2259  vrpn_gettimeofday(&current_time, NULL);
2260  timestamp.tv_sec = current_time.tv_sec;
2261  timestamp.tv_usec = current_time.tv_usec;
2262 
2263  if (d_connection) {
2264  msgbuf = encode_clearTrimesh(len, objNum);
2266  d_sender_id, msgbuf,
2268  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2269  }
2270  delete[] msgbuf;
2271  }
2272 }
2273 
2276 // Change The parent of an object
2278  vrpn_int32 ParentNum)
2279 {
2280  char *msgbuf;
2281  vrpn_int32 len;
2282  struct timeval current_time;
2283 
2284  vrpn_gettimeofday(&current_time, NULL);
2285  timestamp.tv_sec = current_time.tv_sec;
2286  timestamp.tv_usec = current_time.tv_usec;
2287 
2288  if (d_connection) {
2289  msgbuf = encode_moveToParent(len, objNum, ParentNum);
2291  d_sender_id, msgbuf,
2293  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2294  }
2295  delete[] msgbuf;
2296  }
2297 }
2298 
2299 // Set the Origin of the haptic scene
2301  vrpn_float32 axis[3],
2302  vrpn_float32 angle)
2303 {
2304  char *msgbuf;
2305  vrpn_int32 len;
2306  struct timeval current_time;
2307 
2308  vrpn_gettimeofday(&current_time, NULL);
2309  timestamp.tv_sec = current_time.tv_sec;
2310  timestamp.tv_usec = current_time.tv_usec;
2311 
2312  if (d_connection) {
2313  msgbuf = encode_setHapticOrigin(len, Pos, axis, angle);
2316  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2317  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2318  }
2319  delete[] msgbuf;
2320  }
2321 }
2322 
2323 // Set the scale of the haptic scene
2325 {
2326  char *msgbuf;
2327  vrpn_int32 len;
2328  struct timeval current_time;
2329 
2330  vrpn_gettimeofday(&current_time, NULL);
2331  timestamp.tv_sec = current_time.tv_sec;
2332  timestamp.tv_usec = current_time.tv_usec;
2333 
2334  if (d_connection) {
2335  msgbuf = encode_setHapticScale(len, Scale);
2338  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2339  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2340  }
2341  delete[] msgbuf;
2342  }
2343 }
2344 
2346  vrpn_float32 axis[3],
2347  vrpn_float32 angle)
2348 {
2349  char *msgbuf;
2350  vrpn_int32 len;
2351  struct timeval current_time;
2352 
2353  vrpn_gettimeofday(&current_time, NULL);
2354  timestamp.tv_sec = current_time.tv_sec;
2355  timestamp.tv_usec = current_time.tv_usec;
2356 
2357  if (d_connection) {
2358  msgbuf = encode_setSceneOrigin(len, Pos, axis, angle);
2361  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2362  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2363  }
2364  delete[] msgbuf;
2365  }
2366 }
2367 
2368 // get new ID, use only if wish to use vrpn ids and do not want to manage them
2369 // yourself: ids need to be unique
2371 {
2372  return m_NextAvailableObjectID++;
2373 }
2374 
2375 // make an object touchable or not
2377  vrpn_int32 objNum, vrpn_bool IsTouchable /*=true*/)
2378 {
2379  char *msgbuf;
2380  vrpn_int32 len;
2381  struct timeval current_time;
2382 
2383  vrpn_gettimeofday(&current_time, NULL);
2384  timestamp.tv_sec = current_time.tv_sec;
2385  timestamp.tv_usec = current_time.tv_usec;
2386 
2387  if (d_connection) {
2388  msgbuf = encode_setObjectIsTouchable(len, objNum, IsTouchable);
2391  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2392  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2393  }
2394  delete[] msgbuf;
2395  }
2396 }
2397 
2398 // the next time we send a trimesh we will use the following type
2400 {
2401  char *msgbuf;
2402  vrpn_int32 len;
2403  struct timeval current_time;
2404 
2405  vrpn_gettimeofday(&current_time, NULL);
2406  timestamp.tv_sec = current_time.tv_sec;
2407  timestamp.tv_usec = current_time.tv_usec;
2408 
2409  if (d_connection) {
2410  msgbuf = encode_setTrimeshType(len, -1, HCOLLIDE);
2413  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2414  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2415  }
2416  delete[] msgbuf;
2417  }
2418 }
2419 
2421 {
2422  char *msgbuf;
2423  vrpn_int32 len;
2424  struct timeval current_time;
2425 
2426  vrpn_gettimeofday(&current_time, NULL);
2427  timestamp.tv_sec = current_time.tv_sec;
2428  timestamp.tv_usec = current_time.tv_usec;
2429 
2430  if (d_connection) {
2431  msgbuf = encode_setTrimeshType(len, -1, GHOST);
2434  msgbuf, vrpn_CONNECTION_RELIABLE)) {
2435  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2436  }
2437  delete[] msgbuf;
2438  }
2439 }
2440 
2441 // ajout ONDIM
2443 {
2444  char *msgbuf;
2445  vrpn_int32 len;
2446  struct timeval current_time;
2447 
2448  vrpn_gettimeofday(&current_time, NULL);
2449  timestamp.tv_sec = current_time.tv_sec;
2450  timestamp.tv_usec = current_time.tv_usec;
2451 
2452  if (d_connection) {
2456  d_sender_id, msgbuf,
2458  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2459  }
2460  delete[] msgbuf;
2461  }
2462 }
2463 
2465 {
2466  char *msgbuf;
2467  vrpn_int32 len;
2468  struct timeval current_time;
2469 
2470  vrpn_gettimeofday(&current_time, NULL);
2471  timestamp.tv_sec = current_time.tv_sec;
2472  timestamp.tv_usec = current_time.tv_usec;
2473 
2474  setCustomEffect(-1, NULL, 0);
2475 
2476  if (d_connection) {
2480  d_sender_id, msgbuf,
2482  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2483  }
2484  delete[] msgbuf;
2485  }
2486 }
2487 // fin ajout ONDIM
2488 
2489 //
2490 // constraint methods
2491 //
2492 
2493 #ifndef FD_SPRINGS_AS_FIELDS
2494 
2495 #if 0
2496 void vrpn_ForceDevice_Remote::enableConstraint (vrpn_int32 enable) {
2497 }
2498 
2499 void vrpn_ForceDevice_Remote::setConstraintMode (ConstraintGeometry mode) {
2500 }
2501 
2503 }
2504 
2506 }
2507 
2509 }
2510 
2512 }
2513 
2515 }
2516 
2517 void vrpn_ForceDevice_Remote::setConstraintKSpring (vrpn_float32 k) {
2518 }
2519 #endif // 0
2520 
2521 #else
2522 
2524 {
2525  if (enable == d_conEnabled) return;
2526  d_conEnabled = enable;
2527 
2528  switch (d_conEnabled) {
2529  case 0:
2530  stopForceField();
2531  break;
2532  case 1:
2534  sendForceField();
2535  break;
2536  default:
2537  fprintf(stderr, "vrpn_ForceDevice_Remote::enableConstraint: "
2538  "Illegal value of enable (%d).\n",
2539  enable);
2540  break;
2541  }
2542 }
2543 
2544 void vrpn_ForceDevice_Remote::setConstraintMode(ConstraintGeometry mode)
2545 {
2546  d_conMode = mode;
2548  if (d_conEnabled) {
2549  sendForceField();
2550  }
2551 }
2552 
2554 {
2555  d_conPoint[0] = point[0];
2556  d_conPoint[1] = point[1];
2557  d_conPoint[2] = point[2];
2559  if (d_conEnabled) {
2560  sendForceField();
2561  }
2562 }
2563 
2565 {
2566  d_conLinePoint[0] = point[0];
2567  d_conLinePoint[1] = point[1];
2568  d_conLinePoint[2] = point[2];
2570  if (d_conEnabled) {
2571  sendForceField();
2572  }
2573 }
2574 
2576  vrpn_float32 direction[3])
2577 {
2578  d_conLineDirection[0] = direction[0];
2579  d_conLineDirection[1] = direction[1];
2580  d_conLineDirection[2] = direction[2];
2582  if (d_conEnabled) {
2583  sendForceField();
2584  }
2585 }
2586 
2588 {
2589  d_conPlanePoint[0] = point[0];
2590  d_conPlanePoint[1] = point[1];
2591  d_conPlanePoint[2] = point[2];
2593  if (d_conEnabled) {
2594  sendForceField();
2595  }
2596 }
2597 
2599 {
2600  d_conPlaneNormal[0] = normal[0];
2601  d_conPlaneNormal[1] = normal[1];
2602  d_conPlaneNormal[2] = normal[2];
2604  if (d_conEnabled) {
2605  sendForceField();
2606  }
2607 }
2608 
2610 {
2611  d_conKSpring = k;
2613  if (d_conEnabled) {
2614  sendForceField();
2615  }
2616 }
2617 
2618 #endif // FD_SPRINGS_AS_FIELDS
2619 
2621 {
2623 }
2624 
2625 void vrpn_ForceDevice_Remote::sendForceField(vrpn_float32 origin[3],
2626  vrpn_float32 force[3],
2627  vrpn_float32 jacobian[3][3],
2628  vrpn_float32 radius)
2629 {
2630  char *msgbuf;
2631  vrpn_int32 len;
2632  struct timeval current_time;
2633 
2634  vrpn_gettimeofday(&current_time, NULL);
2635  timestamp.tv_sec = current_time.tv_sec;
2636  timestamp.tv_usec = current_time.tv_usec;
2637 
2638  if (d_connection) {
2639  msgbuf = encode_forcefield(len, origin, force, jacobian, radius);
2641  d_sender_id, msgbuf,
2643  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2644  }
2645  delete[] msgbuf;
2646  }
2647 }
2648 
2649 // same as sendForceField but sets force to 0 and sends RELIABLY
2651 {
2652  vrpn_float32 origin[3] = {0, 0, 0};
2653  vrpn_float32 force[3] = {0, 0, 0};
2654  vrpn_float32 jacobian[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
2655  vrpn_float32 radius = 0;
2656 
2657  char *msgbuf;
2658  vrpn_int32 len;
2659  struct timeval current_time;
2660 
2661  vrpn_gettimeofday(&current_time, NULL);
2662  timestamp.tv_sec = current_time.tv_sec;
2663  timestamp.tv_usec = current_time.tv_usec;
2664 
2665  if (d_connection) {
2666  msgbuf = encode_forcefield(len, origin, force, jacobian, radius);
2668  d_sender_id, msgbuf,
2670  fprintf(stderr, "Phantom: cannot write message: tossing\n");
2671  }
2672  delete[] msgbuf;
2673  }
2674 }
2675 
2677 {
2678  if (d_connection) {
2680  }
2681  client_mainloop();
2682 }
2683 
2686 {
2688  vrpn_FORCECB tp;
2689 
2690  tp.msg_time = p.msg_time;
2692  me->d_change_list.call_handlers(tp);
2693 
2694  return 0;
2695 }
2696 
2699 {
2701  vrpn_FORCESCPCB tp;
2702 
2703  tp.msg_time = p.msg_time;
2704  decode_scp(p.buffer, p.payload_len, tp.pos, tp.quat);
2706 
2707  return 0;
2708 }
2709 
2712 {
2714  vrpn_FORCEERRORCB tp;
2715 
2716  if (p.payload_len != sizeof(vrpn_int32)) {
2717  fprintf(stderr, "vrpn_ForceDevice: error message payload"
2718  " error\n(got %d, expected %lud)\n",
2719  p.payload_len, static_cast<unsigned long>(sizeof(vrpn_int32)));
2720  return -1;
2721  }
2722  tp.msg_time = p.msg_time;
2725  return 0;
2726 }
2727 
2728 void vrpn_ForceDevice_Remote::send(const char *msgbuf, vrpn_int32 len,
2729  vrpn_int32 type)
2730 {
2731  struct timeval now;
2732 
2733  vrpn_gettimeofday(&now, NULL);
2734  timestamp.tv_sec = now.tv_sec;
2735  timestamp.tv_usec = now.tv_usec;
2736 
2737  if (d_connection) {
2738  if (d_connection->pack_message(len, now, type, d_sender_id, msgbuf,
2740  fprintf(stderr,
2741  "vrpn_ForceDevice_Remote::send: Can't pack message.\n");
2742  }
2743  }
2744 
2745  // HP compiler won't let you delete a const argument.
2746  delete[](char *)msgbuf;
2747 }
2748 
2749 #ifdef FD_SPRINGS_AS_FIELDS
2750 
2752 {
2753 
2754  vrpn_float32 c[9]; // scratch matrix
2755  int i, j;
2756 
2757  // quatlib wants 64-bit reals; the forcefield code wants 32-bit
2758  // reals. We do most of our math in 64 bits, then copy into 32
2759  // for output to force field.
2760 
2761  const float largeRadius = 100.0f; // infinity
2762 
2763  switch (d_conMode) {
2764 
2765  case NO_CONSTRAINT:
2766  break;
2767 
2768  case POINT_CONSTRAINT:
2770  setFF_Force(0.0f, 0.0f, 0.0f);
2771  setFF_Jacobian(-d_conKSpring, 0.0f, 0.0f, 0.0f, -d_conKSpring, 0.0f,
2772  0.0f, 0.0f, -d_conKSpring);
2773  setFF_Radius(largeRadius);
2774  break;
2775 
2776  case LINE_CONSTRAINT: {
2778  setFF_Force(0.0f, 0.0f, 0.0f);
2779 
2780  // Paul Grayson (pdg@mit.edu) points out that rotating the Jacobian
2781  // won't work and we should use something simpler here.
2782  // Unfortunately, it's because of the apparent difficulty of this
2783  // case that we'd tried rotating a Jacobian in the first place.
2784  // Time to hit the books again looking for something that'll work.
2785 
2786  //------------------------------------------------------------------
2787  // We want to generate a force that is in the opposite direction
2788  // of the offset between where the pen is and where the line is
2789  // defined to be. Because we are going to multiply the jacobian by
2790  // this offset vector, we want it to hold values that produce a
2791  // force that is in the direction of -OFFSET, but we want the
2792  // force to be scaled by the amount by which OFFSET is perpendicular
2793  // to the line direction (it should be zero along the line). So,
2794  // along the line direction it should always evaluate to (0,0,0)
2795  // independent of OFFSET, and perpendicular to this it should
2796  // always be OFFSET in length in direction -OFFSET,
2797  // which is just -OFFSET, which makes the matrix act like
2798  // -1 scaled by the spring constant. This means that we want a
2799  // matrix with Eigenvalues (-1, -1, 0) whose 0 Eigenvector lies
2800  // along the line direction. We get this by compositing a matrix
2801  // that rotates this vector to lie along Z, then applying the diagonal
2802  // (-1, -1, 0) matrix, then a matrix that rotates Z back to the
2803  // line direction. Remember to scale all of this by the spring
2804  // constant;
2805  // we do this during the diagonal matrix construction.
2806 
2807  // Normalize the direction to avoid having its length scale the force
2808  q_vec_type norm_line_dir;
2809  vrpn_float64 norm_len =
2810  sqrt((d_conLineDirection[0] * d_conLineDirection[0]) +
2813  if (norm_len == 0) {
2814  norm_len = 1;
2815  }
2816  for (i = 0; i < 3; i++) {
2817  norm_line_dir[i] = d_conLineDirection[i] / norm_len;
2818  }
2819 
2820  // Construct the rotation from the normalized direction to +Z
2821  // and the rotation back.
2822  q_vec_type z_dir = {0, 0, 1};
2823  q_type q_forward;
2824  q_matrix_type forward;
2825  q_type q_reverse;
2826  q_matrix_type reverse;
2827  q_from_two_vecs(q_forward, norm_line_dir, z_dir);
2828  q_to_row_matrix(forward, q_forward);
2829  q_invert(q_reverse, q_forward);
2830  q_to_row_matrix(reverse, q_reverse);
2831 
2832  // Construct the (-d_conKSpring, -d_conKSpring, 0) matrix and catenate
2833  // the
2834  // matrices to form the final jacobian.
2835  q_matrix_type diagonal, temp, jacobian;
2836  for (i = 0; i < 4; i++) {
2837  for (j = 0; j < 4; j++) {
2838  if ((i == j) && (i < 2)) {
2839  diagonal[i][j] = -d_conKSpring;
2840  }
2841  else {
2842  diagonal[i][j] = 0.0;
2843  }
2844  }
2845  }
2846  q_matrix_mult(temp, diagonal, forward);
2847  q_matrix_mult(jacobian, reverse, temp);
2848 
2849  // Grab the upper-left 3x3 portion of the jacobian and put it into
2850  // the coefficients.
2851  for (i = 0; i < 3; i++) {
2852  for (j = 0; j < 3; j++) {
2853  c[i + j * 3] = (vrpn_float32)jacobian[i][j];
2854  }
2855  }
2856 
2857  setFF_Jacobian(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8]);
2858 
2859  setFF_Radius(largeRadius);
2860  }; break;
2861 
2862  case PLANE_CONSTRAINT: {
2864  setFF_Force(0.0f, 0.0f, 0.0f);
2865 
2866  // Normalize the direction to avoid having its length scale the force
2867  vrpn_float64 norm_plane_dir[3];
2868  vrpn_float64 norm_len =
2869  sqrt((d_conPlaneNormal[0] * d_conPlaneNormal[0]) +
2872  if (norm_len == 0) {
2873  norm_len = 1;
2874  }
2875  for (i = 0; i < 3; i++) {
2876  norm_plane_dir[i] = d_conPlaneNormal[i] / norm_len;
2877  }
2878 
2879  // Paul Grayson (pdg@mit.edu) points out that rotating the Jacobian
2880  // won't work and we should use something simpler here. The below
2881  // is his code.
2882 
2883  for (i = 0; i < 3; i++)
2884  for (j = 0; j < 3; j++)
2885  c[i + j * 3] = (vrpn_float32)(
2886  -d_conKSpring * norm_plane_dir[i] * norm_plane_dir[j]);
2887 
2888  setFF_Jacobian(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8]);
2889 
2890  setFF_Radius(largeRadius);
2891  }; break;
2892  }
2893 }
2894 
2895 #endif // FD_SPRINGS_AS_FIELDS
vrpn_ForceDevice::setNormal_message_id
vrpn_int32 setNormal_message_id
Definition: vrpn_ForceDevice.h:174
vrpn_ForceDevice::encode_scp
static char * encode_scp(vrpn_int32 &length, const vrpn_float64 *pos, const vrpn_float64 *quat)
Definition: vrpn_ForceDevice.C:320
vrpn_ForceDevice::decode_setConstraintLinePoint
static vrpn_int32 decode_setConstraintLinePoint(const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y, vrpn_float32 *z)
Definition: vrpn_ForceDevice.C:1652
vrpn_ForceDevice::encode_enableConstraint
static char * encode_enableConstraint(vrpn_int32 &len, vrpn_int32 enable)
Definition: vrpn_ForceDevice.C:1504
vrpn_BaseClassUnique::register_autodeleted_handler
int register_autodeleted_handler(vrpn_int32 type, vrpn_MESSAGEHANDLER handler, void *userdata, vrpn_int32 sender=vrpn_ANY_SENDER)
Registers a handler with the connection, and remembers to delete at destruction.
Definition: vrpn_BaseClass.C:503
vrpn_Connection::pack_message
virtual int pack_message(vrpn_uint32 len, struct timeval time, vrpn_int32 type, vrpn_int32 sender, const char *buffer, vrpn_uint32 class_of_service)
Pack a message that will be sent the next time mainloop() is called. Turn off the RELIABLE flag if yo...
Definition: vrpn_Connection.C:4632
vrpn_ForceDevice::encode_removeTriangle
static char * encode_removeTriangle(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_int32 triNum)
Definition: vrpn_ForceDevice.C:649
vrpn_FORCEERRORCB::error_code
vrpn_int32 error_code
Definition: vrpn_ForceDevice.h:511
vrpn_ForceDevice::decode_removeObject
static vrpn_int32 decode_removeObject(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum)
Definition: vrpn_ForceDevice.C:1069
vrpn_BaseClassUnique::client_mainloop
void client_mainloop(void)
Handles functions that all clients should provide in their mainloop() (warning of no server,...
Definition: vrpn_BaseClass.C:637
vrpn_ForceDevice_Remote::setVertex
void setVertex(vrpn_int32 vertNum, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
functions for a single object
Definition: vrpn_ForceDevice.C:1924
TrimeshType
TrimeshType
Definition: vrpn_ForceDevice.C:21
vrpn_ForceDevice::clearTrimesh_message_id
vrpn_int32 clearTrimesh_message_id
Definition: vrpn_ForceDevice.h:180
vrpn_ForceDevice_Remote::sendSurface
void sendSurface(void)
Definition: vrpn_ForceDevice.C:1842
vrpn_ForceDevice::SurfaceFstatic
vrpn_float32 SurfaceFstatic
Definition: vrpn_ForceDevice.h:468
vrpn_ForceDevice::setConstraintMode_message_id
vrpn_int32 setConstraintMode_message_id
Definition: vrpn_ForceDevice.h:150
vrpn_ForceDevice::encode_setConstraintMode
static char * encode_setConstraintMode(vrpn_int32 &len, ConstraintGeometry mode)
Definition: vrpn_ForceDevice.C:1543
vrpn_ForceDevice::encode_removeObject
static char * encode_removeObject(vrpn_int32 &len, const vrpn_int32 objNum)
Definition: vrpn_ForceDevice.C:1051
vrpn_ForceDevice::setObjectPosition_message_id
vrpn_int32 setObjectPosition_message_id
Definition: vrpn_ForceDevice.h:169
vrpn_ForceDevice_Remote::setTriangle
void setTriangle(vrpn_int32 triNum, vrpn_int32 vert0, vrpn_int32 vert1, vrpn_int32 vert2, vrpn_int32 norm0=-1, vrpn_int32 norm1=-1, vrpn_int32 norm2=-1)
Definition: vrpn_ForceDevice.C:1936
vrpn_ForceDevice::ff_jacobian
vrpn_float32 ff_jacobian[3][3]
Definition: vrpn_ForceDevice.h:463
vrpn_ForceDevice_Remote::setConstraintPoint
void setConstraintPoint(vrpn_float32 point[3])
Definition: vrpn_ForceDevice.C:2553
vrpn_ForceDevice::~vrpn_ForceDevice
virtual ~vrpn_ForceDevice(void)
Definition: vrpn_ForceDevice.C:183
vrpn_ForceDevice::encode_setConstraintPlanePoint
static char * encode_setConstraintPlanePoint(vrpn_int32 &len, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:1679
vrpn_ForceDevice_Remote::setConstraintKSpring
void setConstraintKSpring(vrpn_float32 k)
Definition: vrpn_ForceDevice.C:2609
vrpn_ForceDevice_Remote::d_conMode
ConstraintGeometry d_conMode
Definition: vrpn_ForceDevice.h:703
vrpn_ForceDevice_Remote::setTrimeshTransform
void setTrimeshTransform(vrpn_float32 homMatrix[16])
Definition: vrpn_ForceDevice.C:1955
vrpn_ForceDevice_Remote::removeObjectTriangle
void removeObjectTriangle(vrpn_int32 objNum, vrpn_int32 triNum)
Definition: vrpn_ForceDevice.C:2091
vrpn_ForceDevice::SurfaceFdynamic
vrpn_float32 SurfaceFdynamic
Definition: vrpn_ForceDevice.h:469
vrpn_ForceDevice::setConstraintPoint_message_id
vrpn_int32 setConstraintPoint_message_id
Definition: vrpn_ForceDevice.h:151
vrpn_ForceDevice::print_plane
void print_plane(void)
Definition: vrpn_ForceDevice.C:190
vrpn_ForceDevice_Remote::d_scp_change_list
vrpn_Callback_List< vrpn_FORCESCPCB > d_scp_change_list
Definition: vrpn_ForceDevice.h:692
vrpn_ForceDevice_Remote::updateObjectTrimeshChanges
void updateObjectTrimeshChanges(vrpn_int32 objNum)
Definition: vrpn_ForceDevice.C:2115
vrpn_ForceDevice::transformTrimesh_message_id
vrpn_int32 transformTrimesh_message_id
Definition: vrpn_ForceDevice.h:178
vrpn_ForceDevice::SurfaceTextureAmplitude
vrpn_float32 SurfaceTextureAmplitude
Definition: vrpn_ForceDevice.h:478
vrpn_ForceDevice::encode_setSceneOrigin
static char * encode_setSceneOrigin(vrpn_int32 &len, const vrpn_float32 Pos[3], const vrpn_float32 axis[3], const vrpn_float32 angle)
Definition: vrpn_ForceDevice.C:1256
vrpn_ForceDevice::decode_setConstraintPlaneNormal
static vrpn_int32 decode_setConstraintPlaneNormal(const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y, vrpn_float32 *z)
Definition: vrpn_ForceDevice.C:1705
vrpn_ForceDevice::setFF_Radius
void setFF_Radius(vrpn_float32 r)
Definition: vrpn_ForceDevice.h:117
vrpn_ForceDevice_Remote::d_conEnabled
vrpn_int32 d_conEnabled
Definition: vrpn_ForceDevice.h:702
vrpn_ForceDevice::ConstraintGeometry
ConstraintGeometry
Definition: vrpn_ForceDevice.h:131
vrpn_FORCECB::msg_time
struct timeval msg_time
Definition: vrpn_ForceDevice.h:503
vrpn_BaseClassUnique::userdata
void * userdata
Definition: vrpn_BaseClass.h:287
vrpn_ForceDevice::encode_plane
static char * encode_plane(vrpn_int32 &length, const vrpn_float32 *plane, const vrpn_float32 kspring, const vrpn_float32 kdamp, const vrpn_float32 fdyn, const vrpn_float32 fstat, const vrpn_int32 plane_index, const vrpn_int32 n_rec_cycles)
Definition: vrpn_ForceDevice.C:369
vrpn_ForceDevice::encode_forcefield
static char * encode_forcefield(vrpn_int32 &len, const vrpn_float32 origin[3], const vrpn_float32 force[3], const vrpn_float32 jacobian[3][3], const vrpn_float32 radius)
Definition: vrpn_ForceDevice.C:1354
vrpn_ForceDevice::timestamp
struct timeval timestamp
Definition: vrpn_ForceDevice.h:449
vrpn_ForceDevice_Remote
Definition: vrpn_ForceDevice.h:516
vrpn_ForceDevice::encode_setConstraintPlaneNormal
static char * encode_setConstraintPlaneNormal(vrpn_int32 &len, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:1696
vrpn_ForceDevice::decode_setConstraintPoint
static vrpn_int32 decode_setConstraintPoint(const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y, vrpn_float32 *z)
Definition: vrpn_ForceDevice.C:1633
vrpn_ForceDevice_Remote::clearTrimesh
void clearTrimesh(void)
Definition: vrpn_ForceDevice.C:1961
vrpn_ForceDevice::encode_setHapticScale
static char * encode_setHapticScale(vrpn_int32 &len, const vrpn_float32 Scale)
Definition: vrpn_ForceDevice.C:1219
vrpn_ForceDevice::setConstraintLinePoint_message_id
vrpn_int32 setConstraintLinePoint_message_id
Definition: vrpn_ForceDevice.h:152
vrpn_ForceDevice_Remote::setHapticOrigin
void setHapticOrigin(vrpn_float32 Pos[3], vrpn_float32 axis[3], vrpn_float32 angle)
Definition: vrpn_ForceDevice.C:2300
vrpn_ForceDevice::decode_setObjectIsTouchable
static vrpn_int32 decode_setObjectIsTouchable(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum, vrpn_bool *isTouchable)
Definition: vrpn_ForceDevice.C:1331
vrpn_ForceDevice::set_plane
void set_plane(vrpn_float32 *p)
Definition: vrpn_ForceDevice.C:1455
vrpn_ForceDevice::encode_setConstraintPoint
static char * encode_setConstraintPoint(vrpn_int32 &len, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:1624
vrpn_ForceDevice::decode_removeTriangle
static vrpn_int32 decode_removeTriangle(const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum, vrpn_int32 *triNum)
Definition: vrpn_ForceDevice.C:671
vrpn_ForceDevice::sendError
void sendError(int error_code)
Definition: vrpn_ForceDevice.C:1480
vrpn_ForceDevice_Remote::setConstraintLineDirection
void setConstraintLineDirection(vrpn_float32 direction[3])
Definition: vrpn_ForceDevice.C:2575
vrpn_ForceDevice::addObjectExScene_message_id
vrpn_int32 addObjectExScene_message_id
Definition: vrpn_ForceDevice.h:167
vrpn_ForceDevice::encode_objectPosition
static char * encode_objectPosition(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_float32 Pos[3])
Definition: vrpn_ForceDevice.C:911
vrpn_ForceDevice::encode_moveToParent
static char * encode_moveToParent(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_int32 parentNum)
Definition: vrpn_ForceDevice.C:1123
vrpn_ForceDevice::SurfaceKadhesionLateral
vrpn_float32 SurfaceKadhesionLateral
Definition: vrpn_ForceDevice.h:473
vrpn_ForceDevice::setHapticScale_message_id
vrpn_int32 setHapticScale_message_id
Definition: vrpn_ForceDevice.h:184
vrpn_HANDLERPARAM::payload_len
vrpn_int32 payload_len
Definition: vrpn_Connection.h:48
vrpn_ForceDevice::decode_normal
static vrpn_int32 decode_normal(const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum, vrpn_int32 *vertNum, vrpn_float32 *x, vrpn_float32 *y, vrpn_float32 *z)
Definition: vrpn_ForceDevice.C:564
vrpn_ForceDevice::decode_addObjectExScene
static vrpn_int32 decode_addObjectExScene(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum)
Definition: vrpn_ForceDevice.C:893
vrpn_ForceDevice::decode_scp
static vrpn_int32 decode_scp(const char *buffer, const vrpn_int32 len, vrpn_float64 *pos, vrpn_float64 *quat)
Definition: vrpn_ForceDevice.C:345
vrpn_FORCESCPCB
Definition: vrpn_ForceDevice.h:494
vrpn_ForceDevice_Remote::d_conPlaneNormal
vrpn_float64 d_conPlaneNormal[3]
Definition: vrpn_ForceDevice.h:708
vrpn_ForceDevice_Remote::constraintToForceField
void constraintToForceField(void)
Definition: vrpn_ForceDevice.C:2751
vrpn_ForceDevice::errorCode
vrpn_int32 errorCode
Definition: vrpn_ForceDevice.h:471
vrpn_ForceDevice_Remote::setNormal
void setNormal(vrpn_int32 normNum, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:1930
vrpn_ForceDevice::decode_setHapticScale
static vrpn_int32 decode_setHapticScale(const char *buffer, vrpn_int32 len, vrpn_float32 *Scale)
Definition: vrpn_ForceDevice.C:1237
vrpn_ForceDevice.h
vrpn_ForceDevice_Remote::send
void send(const char *msgbuf, vrpn_int32 len, vrpn_int32 type)
Definition: vrpn_ForceDevice.C:2728
vrpn_ForceDevice_Remote::setObjectIsTouchable
void setObjectIsTouchable(vrpn_int32 objNum, vrpn_bool IsTouchable=true)
Definition: vrpn_ForceDevice.C:2376
vrpn_ForceDevice_Remote::updateTrimeshChanges
void updateTrimeshChanges()
Definition: vrpn_ForceDevice.C:1949
vrpn_ForceDevice::decode_enableConstraint
static vrpn_int32 decode_enableConstraint(const char *buffer, const vrpn_int32 len, vrpn_int32 *enable)
Definition: vrpn_ForceDevice.C:1523
vrpn_CONNECTION_LOW_LATENCY
const vrpn_uint32 vrpn_CONNECTION_LOW_LATENCY
Definition: vrpn_Connection.h:122
vrpn_unbuffer
VRPN_API int vrpn_unbuffer(const char **buffer, timeval *t)
Utility routine for taking a struct timeval from a buffer that was sent as a message.
Definition: vrpn_Shared.C:312
vrpn_ForceDevice::encode_addObjectExScene
static char * encode_addObjectExScene(vrpn_int32 &len, const vrpn_int32 objNum)
Definition: vrpn_ForceDevice.C:875
vrpn_ForceDevice::SurfaceBuzzAmp
vrpn_float32 SurfaceBuzzAmp
Definition: vrpn_ForceDevice.h:476
vrpn_ForceDevice_Remote::addObjectExScene
void addObjectExScene(vrpn_int32 objNum)
Definition: vrpn_ForceDevice.C:1992
vrpn_ForceDevice::setVertex_message_id
vrpn_int32 setVertex_message_id
Definition: vrpn_ForceDevice.h:173
vrpn_BaseClassUnique::d_connection
vrpn_Connection * d_connection
Connection that this object talks to.
Definition: vrpn_BaseClass.h:224
vrpn_ForceDevice::decode_setTrimeshType
static vrpn_int32 decode_setTrimeshType(const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum, vrpn_int32 *type)
Definition: vrpn_ForceDevice.C:767
vrpn_HANDLERPARAM::buffer
const char * buffer
Definition: vrpn_Connection.h:49
vrpn_Connection::register_message_type
virtual vrpn_int32 register_message_type(const char *name)
Definition: vrpn_Connection.C:5074
vrpn_ForceDevice::numRecCycles
vrpn_int32 numRecCycles
Definition: vrpn_ForceDevice.h:470
vrpn_ForceDevice_Remote::removeObject
void removeObject(vrpn_int32 objNum)
Definition: vrpn_ForceDevice.C:2232
vrpn_ForceDevice_Remote::stopForceField
void stopForceField(void)
Definition: vrpn_ForceDevice.C:2650
vrpn_ForceDevice_Remote::~vrpn_ForceDevice_Remote
virtual ~vrpn_ForceDevice_Remote(void)
Definition: vrpn_ForceDevice.C:1840
CHECK
#define CHECK(a)
Definition: vrpn_ForceDevice.C:24
vrpn_ForceDevice::encode_setConstraintLinePoint
static char * encode_setConstraintLinePoint(vrpn_int32 &len, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:1643
vrpn_FORCEERRORCB::msg_time
struct timeval msg_time
Definition: vrpn_ForceDevice.h:510
vrpn_ForceDevice::encode_objectScale
static char * encode_objectScale(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_float32 Scale[3])
Definition: vrpn_ForceDevice.C:1006
vrpn_ForceDevice::decodePoint
static vrpn_int32 decodePoint(const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y, vrpn_float32 *z)
Definition: vrpn_ForceDevice.C:1777
vrpn_ForceDevice_Remote::handle_force_change_message
static int VRPN_CALLBACK handle_force_change_message(void *userdata, vrpn_HANDLERPARAM p)
Definition: vrpn_ForceDevice.C:2684
vrpn_ForceDevice::setFF_Force
void setFF_Force(vrpn_float32 fx, vrpn_float32 fy, vrpn_float32 fz)
Definition: vrpn_ForceDevice.h:89
vrpn_FORCECB::force
vrpn_float64 force[3]
Definition: vrpn_ForceDevice.h:504
vrpn_ForceDevice::setTrimeshType_message_id
vrpn_int32 setTrimeshType_message_id
Definition: vrpn_ForceDevice.h:179
vrpn_CONNECTION_RELIABLE
const vrpn_uint32 vrpn_CONNECTION_RELIABLE
Classes of service for messages, specify multiple by ORing them together Priority of satisfying these...
Definition: vrpn_Connection.h:120
vrpn_ForceDevice_Remote::setObjectNormal
void setObjectNormal(vrpn_int32 objNum, vrpn_int32 normNum, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:2042
vrpn_HANDLERPARAM
This structure is what is passed to a vrpn_Connection message callback.
Definition: vrpn_Connection.h:44
vrpn_Shared.h
vrpn_ForceDevice::setConstraintKSpring_message_id
vrpn_int32 setConstraintKSpring_message_id
Definition: vrpn_ForceDevice.h:156
vrpn_ForceDevice_Remote::setObjectOrientation
void setObjectOrientation(vrpn_int32 objNum, vrpn_float32 axis[3], vrpn_float32 angle)
Definition: vrpn_ForceDevice.C:2185
vrpn_ForceDevice_Remote::setConstraintPlaneNormal
void setConstraintPlaneNormal(vrpn_float32 normal[3])
Definition: vrpn_ForceDevice.C:2598
vrpn_FORCESCPCB::pos
vrpn_float64 pos[3]
Definition: vrpn_ForceDevice.h:496
vrpn_ForceDevice::setConstraintLineDirection_message_id
vrpn_int32 setConstraintLineDirection_message_id
Definition: vrpn_ForceDevice.h:153
vrpn_ForceDevice::LINE_CONSTRAINT
@ LINE_CONSTRAINT
Definition: vrpn_ForceDevice.h:134
vrpn_ForceDevice_Remote::mainloop
virtual void mainloop()
Called once through each main loop iteration to handle updates. Remote object mainloop() should call ...
Definition: vrpn_ForceDevice.C:2676
vrpn_ForceDevice_Remote::d_conLinePoint
vrpn_float32 d_conLinePoint[3]
Definition: vrpn_ForceDevice.h:705
vrpn_ForceDevice::decode_triangle
static vrpn_int32 decode_triangle(const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum, vrpn_int32 *triNum, vrpn_int32 *vert0, vrpn_int32 *vert1, vrpn_int32 *vert2, vrpn_int32 *norm0, vrpn_int32 *norm1, vrpn_int32 *norm2)
Definition: vrpn_ForceDevice.C:621
vrpn_FORCESCPCB::msg_time
struct timeval msg_time
Definition: vrpn_ForceDevice.h:495
vrpn_ForceDevice::setHapticOrigin_message_id
vrpn_int32 setHapticOrigin_message_id
Definition: vrpn_ForceDevice.h:183
vrpn_ForceDevice::setFF_Jacobian
void setFF_Jacobian(vrpn_float32 dfxdx, vrpn_float32 dfxdy, vrpn_float32 dfxdz, vrpn_float32 dfydx, vrpn_float32 dfydy, vrpn_float32 dfydz, vrpn_float32 dfzdx, vrpn_float32 dfzdy, vrpn_float32 dfzdz)
Definition: vrpn_ForceDevice.h:101
vrpn_ForceDevice_Remote::setConstraintMode
void setConstraintMode(ConstraintGeometry mode)
Definition: vrpn_ForceDevice.C:2544
vrpn_BaseClassUnique::d_sender_id
vrpn_int32 d_sender_id
Sender ID registered with the connection.
Definition: vrpn_BaseClass.h:228
vrpn_ForceDevice::encode_vertex
static char * encode_vertex(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_int32 vertNum, const vrpn_float32 x, const vrpn_float32 y, const vrpn_float32 z)
Definition: vrpn_ForceDevice.C:485
vrpn_ForceDevice_Remote::d_change_list
vrpn_Callback_List< vrpn_FORCECB > d_change_list
Definition: vrpn_ForceDevice.h:685
vrpn_ForceDevice::decode_plane
static vrpn_int32 decode_plane(const char *buffer, const vrpn_int32 len, vrpn_float32 *plane, vrpn_float32 *kspring, vrpn_float32 *kdamp, vrpn_float32 *fdyn, vrpn_float32 *fstat, vrpn_int32 *plane_index, vrpn_int32 *n_rec_cycles)
Definition: vrpn_ForceDevice.C:402
vrpn_ForceDevice::POINT_CONSTRAINT
@ POINT_CONSTRAINT
Definition: vrpn_ForceDevice.h:133
vrpn_ForceDevice_Remote::clearObjectTrimesh
void clearObjectTrimesh(vrpn_int32 objNum)
Definition: vrpn_ForceDevice.C:2253
vrpn_ForceDevice::encodePoint
static char * encodePoint(vrpn_int32 &len, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:1756
vrpn_ForceDevice::setConstraintPlaneNormal_message_id
vrpn_int32 setConstraintPlaneNormal_message_id
Definition: vrpn_ForceDevice.h:155
vrpn_ForceDevice::forcefield_message_id
vrpn_int32 forcefield_message_id
Definition: vrpn_ForceDevice.h:144
vrpn_ForceDevice::decode_setConstraintMode
static vrpn_int32 decode_setConstraintMode(const char *buffer, const vrpn_int32 len, ConstraintGeometry *mode)
Definition: vrpn_ForceDevice.C:1583
vrpn_ForceDevice::addObject_message_id
vrpn_int32 addObject_message_id
Definition: vrpn_ForceDevice.h:166
vrpn_ForceDevice::error_message_id
vrpn_int32 error_message_id
Definition: vrpn_ForceDevice.h:162
vrpn_ForceDevice::encode_clearTrimesh
static char * encode_clearTrimesh(vrpn_int32 &len, const vrpn_int32 objNum)
Definition: vrpn_ForceDevice.C:1087
vrpn_ForceDevice_Remote::handle_scp_change_message
static int VRPN_CALLBACK handle_scp_change_message(void *userdata, vrpn_HANDLERPARAM p)
Definition: vrpn_ForceDevice.C:2697
vrpn_ForceDevice_Remote::d_conKSpring
vrpn_float32 d_conKSpring
Definition: vrpn_ForceDevice.h:709
vrpn_ForceDevice
Definition: vrpn_ForceDevice.h:39
vrpn_ForceDevice_Remote::setHapticScale
void setHapticScale(vrpn_float32 Scale)
Definition: vrpn_ForceDevice.C:2324
vrpn_ForceDevice_Remote::startSurface
void startSurface(void)
Definition: vrpn_ForceDevice.C:1876
vrpn_ForceDevice::encode_setHapticOrigin
static char * encode_setHapticOrigin(vrpn_int32 &len, const vrpn_float32 Pos[3], const vrpn_float32 axis[3], const vrpn_float32 angle)
Definition: vrpn_ForceDevice.C:1165
vrpn_ForceDevice_Remote::stopSurface
void stopSurface(void)
Definition: vrpn_ForceDevice.C:1899
vrpn_Connection::mainloop
virtual int mainloop(const struct timeval *timeout=NULL)=0
Call each time through program main loop to handle receiving any incoming messages and sending any pa...
vrpn_ForceDevice::PLANE_CONSTRAINT
@ PLANE_CONSTRAINT
Definition: vrpn_ForceDevice.h:135
vrpn_ForceDevice_Remote::setObjectScale
void setObjectScale(vrpn_int32 objNum, vrpn_float32 Scale[3])
Definition: vrpn_ForceDevice.C:2209
vrpn_ForceDevice::print_report
void print_report(void)
Definition: vrpn_ForceDevice.C:195
vrpn_ForceDevice_Remote::startEffect
void startEffect(void)
Definition: vrpn_ForceDevice.C:2442
vrpn_HANDLERPARAM::msg_time
struct timeval msg_time
Definition: vrpn_Connection.h:47
vrpn_ForceDevice::plane
vrpn_float32 plane[4]
Definition: vrpn_ForceDevice.h:459
vrpn_ForceDevice_Remote::stopEffect
void stopEffect(void)
Definition: vrpn_ForceDevice.C:2464
vrpn_ForceDevice::decode_forcefield
static vrpn_int32 decode_forcefield(const char *buffer, const vrpn_int32 len, vrpn_float32 origin[3], vrpn_float32 force[3], vrpn_float32 jacobian[3][3], vrpn_float32 *radius)
Definition: vrpn_ForceDevice.C:1387
vrpn_ForceDevice::enableConstraint_message_id
vrpn_int32 enableConstraint_message_id
Definition: vrpn_ForceDevice.h:149
vrpn_Connection
Generic connection class not specific to the transport mechanism.
Definition: vrpn_Connection.h:510
vrpn_ForceDevice_Remote::setObjectVertex
void setObjectVertex(vrpn_int32 objNum, vrpn_int32 vertNum, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:2016
vrpn_Connection.h
vrpn_ForceDevice::removeTriangle_message_id
vrpn_int32 removeTriangle_message_id
Definition: vrpn_ForceDevice.h:176
vrpn_ForceDevice_Remote::d_error_change_list
vrpn_Callback_List< vrpn_FORCEERRORCB > d_error_change_list
Definition: vrpn_ForceDevice.h:696
vrpn_FORCECB
Definition: vrpn_ForceDevice.h:502
vrpn_ForceDevice_Remote::removeTriangle
void removeTriangle(vrpn_int32 triNum)
Definition: vrpn_ForceDevice.C:1944
vrpn_ForceDevice::NO_CONSTRAINT
@ NO_CONSTRAINT
Definition: vrpn_ForceDevice.h:132
vrpn_ForceDevice::customEffectParams
vrpn_float32 * customEffectParams
Definition: vrpn_ForceDevice.h:482
vrpn_ForceDevice::SurfaceTextureWavelength
vrpn_float32 SurfaceTextureWavelength
Definition: vrpn_ForceDevice.h:477
vrpn_ForceDevice::decode_updateTrimeshChanges
static vrpn_int32 decode_updateTrimeshChanges(const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum, vrpn_float32 *kspring, vrpn_float32 *kdamp, vrpn_float32 *fdyn, vrpn_float32 *fstat)
Definition: vrpn_ForceDevice.C:719
vrpn_ForceDevice::SurfaceKadhesionNormal
vrpn_float32 SurfaceKadhesionNormal
Definition: vrpn_ForceDevice.h:474
vrpn_gettimeofday
#define vrpn_gettimeofday
Definition: vrpn_Shared.h:89
vrpn_ForceDevice::encode_updateTrimeshChanges
static char * encode_updateTrimeshChanges(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_float32 kspring, const vrpn_float32 kdamp, const vrpn_float32 fdyn, const vrpn_float32 fstat)
Definition: vrpn_ForceDevice.C:694
vrpn_FORCESCPCB::quat
vrpn_float64 quat[4]
Definition: vrpn_ForceDevice.h:497
vrpn_ForceDevice::decode_error
static vrpn_int32 decode_error(const char *buffer, const vrpn_int32 len, vrpn_int32 *error_code)
Definition: vrpn_ForceDevice.C:1436
vrpn_ForceDevice::encode_setObjectIsTouchable
static char * encode_setObjectIsTouchable(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_bool isTouchable)
Definition: vrpn_ForceDevice.C:1311
vrpn_ForceDevice::decode_trimeshTransform
static vrpn_int32 decode_trimeshTransform(const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum, vrpn_float32 homMatrix[16])
Definition: vrpn_ForceDevice.C:812
vrpn_ForceDevice::register_types
virtual int register_types(void)
Register the types of messages this device sends/receives. Return 0 on success, -1 on fail.
Definition: vrpn_ForceDevice.C:100
vrpn_ForceDevice::updateTrimeshChanges_message_id
vrpn_int32 updateTrimeshChanges_message_id
Definition: vrpn_ForceDevice.h:177
vrpn_ForceDevice::encode_normal
static char * encode_normal(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_int32 vertNum, const vrpn_float32 x, const vrpn_float32 y, const vrpn_float32 z)
Definition: vrpn_ForceDevice.C:538
vrpn_ForceDevice_Remote::moveToParent
void moveToParent(vrpn_int32 objNum, vrpn_int32 ParentNum)
Functions to organize the scene.
Definition: vrpn_ForceDevice.C:2277
vrpn_ForceDevice::encode_triangle
static char * encode_triangle(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_int32 triNum, const vrpn_int32 vert0, const vrpn_int32 vert1, const vrpn_int32 vert2, const vrpn_int32 norm0, const vrpn_int32 norm1, const vrpn_int32 norm2)
Definition: vrpn_ForceDevice.C:593
vrpn_ForceDevice_Remote::d_conPoint
vrpn_float32 d_conPoint[3]
Definition: vrpn_ForceDevice.h:704
vrpn_ForceDevice::encode_custom_effect
static char * encode_custom_effect(vrpn_int32 &len, vrpn_uint32 effectId, const vrpn_float32 *params, vrpn_uint32 nbParams)
Definition: vrpn_ForceDevice.C:251
vrpn_ForceDevice::decode_setHapticOrigin
static vrpn_int32 decode_setHapticOrigin(const char *buffer, vrpn_int32 len, vrpn_float32 Pos[3], vrpn_float32 axis[3], vrpn_float32 *angle)
Definition: vrpn_ForceDevice.C:1192
vrpn_ForceDevice::ff_force
vrpn_float32 ff_force[3]
Definition: vrpn_ForceDevice.h:462
vrpn_ForceDevice_Remote::setObjectTrimeshTransform
void setObjectTrimeshTransform(vrpn_int32 objNum, vrpn_float32 homMatrix[16])
Definition: vrpn_ForceDevice.C:2139
vrpn_ForceDevice_Remote::sendForceField
void sendForceField(void)
Definition: vrpn_ForceDevice.C:2620
vrpn_ForceDevice::custom_effect_message_id
vrpn_int32 custom_effect_message_id
Definition: vrpn_ForceDevice.h:190
vrpn_ForceDevice_Remote::setObjectPosition
void setObjectPosition(vrpn_int32 objNum, vrpn_float32 Pos[3])
Definition: vrpn_ForceDevice.C:2162
vrpn_ForceDevice::ff_origin
vrpn_float32 ff_origin[3]
Definition: vrpn_ForceDevice.h:461
vrpn_ForceDevice::encode_force
static char * encode_force(vrpn_int32 &length, const vrpn_float64 *force)
Definition: vrpn_ForceDevice.C:204
vrpn_ForceDevice::setObjectOrientation_message_id
vrpn_int32 setObjectOrientation_message_id
Definition: vrpn_ForceDevice.h:170
vrpn_ForceDevice::decode_custom_effect
static vrpn_int32 decode_custom_effect(const char *buffer, const vrpn_int32 len, vrpn_uint32 *effectId, vrpn_float32 **params, vrpn_uint32 *nbParams)
Definition: vrpn_ForceDevice.C:277
vrpn_ForceDevice::decode_moveToParent
static vrpn_int32 decode_moveToParent(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum, vrpn_int32 *parentNum)
Definition: vrpn_ForceDevice.C:1143
vrpn_ForceDevice::decode_objectPosition
static vrpn_int32 decode_objectPosition(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum, vrpn_float32 Pos[3])
Definition: vrpn_ForceDevice.C:933
vrpn_ForceDevice::encode_trimeshTransform
static char * encode_trimeshTransform(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_float32 homMatrix[16])
Definition: vrpn_ForceDevice.C:790
vrpn_ForceDevice::encode_error
static char * encode_error(vrpn_int32 &len, const vrpn_int32 error_code)
Definition: vrpn_ForceDevice.C:1417
vrpn_ForceDevice::encode_setConstraintKSpring
static char * encode_setConstraintKSpring(vrpn_int32 &len, vrpn_float32 k)
Definition: vrpn_ForceDevice.C:1713
vrpn_ForceDevice::setObjectScale_message_id
vrpn_int32 setObjectScale_message_id
Definition: vrpn_ForceDevice.h:171
vrpn_ForceDevice::decode_setConstraintLineDirection
static vrpn_int32 decode_setConstraintLineDirection(const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y, vrpn_float32 *z)
Definition: vrpn_ForceDevice.C:1671
vrpn_ForceDevice::vrpn_ForceDevice
vrpn_ForceDevice(const char *name, vrpn_Connection *c)
Definition: vrpn_ForceDevice.C:52
vrpn_ForceDevice::setCustomEffect
void setCustomEffect(vrpn_int32 effectId, vrpn_float32 *params=NULL, vrpn_uint32 nbParams=0)
Definition: vrpn_ForceDevice.C:86
vrpn_ForceDevice_Remote::setConstraintPlanePoint
void setConstraintPlanePoint(vrpn_float32 point[3])
Definition: vrpn_ForceDevice.C:2587
vrpn_ForceDevice::setTriangle_message_id
vrpn_int32 setTriangle_message_id
Definition: vrpn_ForceDevice.h:175
vrpn_ForceDevice::setSceneOrigin_message_id
vrpn_int32 setSceneOrigin_message_id
Definition: vrpn_ForceDevice.h:185
vrpn_ForceDevice::plane_message_id
vrpn_int32 plane_message_id
Definition: vrpn_ForceDevice.h:142
vrpn_ForceDevice::decode_setConstraintPlanePoint
static vrpn_int32 decode_setConstraintPlanePoint(const char *buffer, const vrpn_int32 len, vrpn_float32 *x, vrpn_float32 *y, vrpn_float32 *z)
Definition: vrpn_ForceDevice.C:1688
vrpn_ForceDevice_Remote::enableConstraint
void enableConstraint(vrpn_int32 enable)
Definition: vrpn_ForceDevice.C:2523
vrpn_ForceDevice::setConstraintPlanePoint_message_id
vrpn_int32 setConstraintPlanePoint_message_id
Definition: vrpn_ForceDevice.h:154
vrpn_ForceDevice::SurfaceKdamping
vrpn_float32 SurfaceKdamping
Definition: vrpn_ForceDevice.h:467
vrpn_BaseClass::init
virtual int init(void)
Initialize things that the constructor can't. Returns 0 on success, -1 on failure.
Definition: vrpn_BaseClass.C:363
GHOST
@ GHOST
Definition: vrpn_ForceDevice.C:21
vrpn_ForceDevice::decode_setConstraintKSpring
static vrpn_int32 decode_setConstraintKSpring(const char *buffer, const vrpn_int32 len, vrpn_float32 *k)
Definition: vrpn_ForceDevice.C:1732
vrpn_ForceDevice::encode_addObject
static char * encode_addObject(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_int32 ParentNum)
Definition: vrpn_ForceDevice.C:835
vrpn_buffer
VRPN_API int vrpn_buffer(char **insertPt, vrpn_int32 *buflen, const timeval t)
Utility routine for placing a timeval struct into a buffer that is to be sent as a message.
Definition: vrpn_Shared.C:241
FD_OK
#define FD_OK
Definition: vrpn_ForceDevice.h:25
vrpn_ForceDevice::encode_setTrimeshType
static char * encode_setTrimeshType(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_int32 type)
Definition: vrpn_ForceDevice.C:745
vrpn_ForceDevice::decode_clearTrimesh
static vrpn_int32 decode_clearTrimesh(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum)
Definition: vrpn_ForceDevice.C:1105
vrpn_ForceDevice::setObjectIsTouchable_message_id
vrpn_int32 setObjectIsTouchable_message_id
Definition: vrpn_ForceDevice.h:187
vrpn_ForceDevice::setFF_Origin
void setFF_Origin(vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.h:77
vrpn_ForceDevice_Remote::d_conLineDirection
vrpn_float64 d_conLineDirection[3]
Definition: vrpn_ForceDevice.h:706
vrpn_ForceDevice::nbCustomEffectParams
vrpn_uint32 nbCustomEffectParams
Definition: vrpn_ForceDevice.h:483
vrpn_ForceDevice_Remote::useHcollide
void useHcollide()
Definition: vrpn_ForceDevice.C:2399
vrpn_ForceDevice::decode_setSceneOrigin
static vrpn_int32 decode_setSceneOrigin(const char *buffer, vrpn_int32 len, vrpn_float32 Pos[3], vrpn_float32 axis[3], vrpn_float32 *angle)
Definition: vrpn_ForceDevice.C:1283
vrpn_ForceDevice::decode_addObject
static vrpn_int32 decode_addObject(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum, vrpn_int32 *ParentNum)
Definition: vrpn_ForceDevice.C:855
vrpn_ForceDevice::getNewObjectID_message_id
vrpn_int32 getNewObjectID_message_id
Definition: vrpn_ForceDevice.h:186
vrpn_ForceDevice::moveToParent_message_id
vrpn_int32 moveToParent_message_id
Definition: vrpn_ForceDevice.h:168
vrpn_ForceDevice::SurfaceKspring
vrpn_float32 SurfaceKspring
Definition: vrpn_ForceDevice.h:466
vrpn_Callback_List::call_handlers
void call_handlers(const CALLBACK_STRUCT &info)
This will pass the referenced parameter as a const to all the callbacks.
Definition: vrpn_BaseClass.h:451
vrpn_ForceDevice::SurfaceBuzzFreq
vrpn_float32 SurfaceBuzzFreq
Definition: vrpn_ForceDevice.h:475
vrpn_ForceDevice::which_plane
vrpn_int32 which_plane
Definition: vrpn_ForceDevice.h:451
vrpn_ForceDevice::encode_objectOrientation
static char * encode_objectOrientation(vrpn_int32 &len, const vrpn_int32 objNum, const vrpn_float32 axis[3], const vrpn_float32 angle)
Definition: vrpn_ForceDevice.C:956
vrpn_ForceDevice_Remote::useGhost
void useGhost()
Definition: vrpn_ForceDevice.C:2420
vrpn_ForceDevice::encode_surface_effects
static char * encode_surface_effects(vrpn_int32 &len, const vrpn_float32 k_adhesion_norm, const vrpn_float32 k_adhesion_lat, const vrpn_float32 tex_amp, const vrpn_float32 tex_wl, const vrpn_float32 buzz_amp, const vrpn_float32 buzz_freq)
Definition: vrpn_ForceDevice.C:431
vrpn_ForceDevice_Remote::setConstraintLinePoint
void setConstraintLinePoint(vrpn_float32 point[3])
Definition: vrpn_ForceDevice.C:2564
vrpn_ForceDevice_Remote::m_NextAvailableObjectID
vrpn_int32 m_NextAvailableObjectID
Definition: vrpn_ForceDevice.h:712
vrpn_ForceDevice::ff_radius
vrpn_float32 ff_radius
Definition: vrpn_ForceDevice.h:464
vrpn_ForceDevice::decode_objectScale
static vrpn_int32 decode_objectScale(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum, vrpn_float32 Scale[3])
Definition: vrpn_ForceDevice.C:1028
vrpn_ForceDevice::removeObject_message_id
vrpn_int32 removeObject_message_id
Definition: vrpn_ForceDevice.h:172
vrpn_ForceDevice_Remote::setObjectTriangle
void setObjectTriangle(vrpn_int32 objNum, vrpn_int32 triNum, vrpn_int32 vert0, vrpn_int32 vert1, vrpn_int32 vert2, vrpn_int32 norm0=-1, vrpn_int32 norm1=-1, vrpn_int32 norm2=-1)
Definition: vrpn_ForceDevice.C:2066
vrpn_ForceDevice::decode_force
static vrpn_int32 decode_force(const char *buffer, const vrpn_int32 len, vrpn_float64 *force)
Definition: vrpn_ForceDevice.C:230
vrpn_BaseClassUnique::type
vrpn_int32 type
Definition: vrpn_BaseClass.h:286
vrpn_ForceDevice::plane_effects_message_id
vrpn_int32 plane_effects_message_id
Definition: vrpn_ForceDevice.h:143
vrpn_ForceDevice_Remote::getNewObjectID
vrpn_int32 getNewObjectID()
Definition: vrpn_ForceDevice.C:2370
vrpn_ForceDevice::force_message_id
vrpn_int32 force_message_id
Definition: vrpn_ForceDevice.h:141
vrpn_ForceDevice::decode_vertex
static vrpn_int32 decode_vertex(const char *buffer, const vrpn_int32 len, vrpn_int32 *objNum, vrpn_int32 *vertNum, vrpn_float32 *x, vrpn_float32 *y, vrpn_float32 *z)
Definition: vrpn_ForceDevice.C:512
vrpn_ForceDevice::scp_message_id
vrpn_int32 scp_message_id
Definition: vrpn_ForceDevice.h:145
vrpn_ForceDevice_Remote::setSceneOrigin
void setSceneOrigin(vrpn_float32 Pos[3], vrpn_float32 axis[3], vrpn_float32 angle)
Definition: vrpn_ForceDevice.C:2345
vrpn_BaseClass
Class from which all user-level (and other) classes that communicate with vrpn_Connections should der...
Definition: vrpn_BaseClass.h:313
vrpn_ForceDevice_Remote::vrpn_ForceDevice_Remote
vrpn_ForceDevice_Remote(const char *name, vrpn_Connection *cn=NULL)
Definition: vrpn_ForceDevice.C:1800
vrpn_FORCEERRORCB
Definition: vrpn_ForceDevice.h:509
vrpn_ForceDevice_Remote::d_conPlanePoint
vrpn_float32 d_conPlanePoint[3]
Definition: vrpn_ForceDevice.h:707
HCOLLIDE
@ HCOLLIDE
Definition: vrpn_ForceDevice.C:21
vrpn_ForceDevice::decode_surface_effects
static vrpn_int32 decode_surface_effects(const char *buffer, const vrpn_int32 len, vrpn_float32 *k_adhesion_norm, vrpn_float32 *k_adhesion_lat, vrpn_float32 *tex_amp, vrpn_float32 *tex_wl, vrpn_float32 *buzz_amp, vrpn_float32 *buzz_freq)
Definition: vrpn_ForceDevice.C:459
vrpn_ForceDevice::customEffectId
vrpn_int32 customEffectId
Definition: vrpn_ForceDevice.h:481
vrpn_ForceDevice::decode_objectOrientation
static vrpn_int32 decode_objectOrientation(const char *buffer, vrpn_int32 len, vrpn_int32 *objNum, vrpn_float32 axis[3], vrpn_float32 *angle)
Definition: vrpn_ForceDevice.C:980
vrpn_ForceDevice::encode_setConstraintLineDirection
static char * encode_setConstraintLineDirection(vrpn_int32 &len, vrpn_float32 x, vrpn_float32 y, vrpn_float32 z)
Definition: vrpn_ForceDevice.C:1662
vrpn_ForceDevice_Remote::addObject
void addObject(vrpn_int32 objNum, vrpn_int32 ParentNum=-1)
functions for multiple objects in the haptic scene
Definition: vrpn_ForceDevice.C:1967
vrpn_ForceDevice_Remote::handle_error_change_message
static int VRPN_CALLBACK handle_error_change_message(void *userdata, vrpn_HANDLERPARAM p)
Definition: vrpn_ForceDevice.C:2710