C++ SDK Reference  12.5
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
diguyChainSettings.h
Go to the documentation of this file.
1 
2 /*
3  * Copyright (C) 1992-2013 Boston Dynamics
4  * ALL RIGHTS RESERVED.
5  *
6  * These coded instructions, statements, and computer programs
7  * contain unpublished proprietary information of Boston Dynamics
8  * and are protected by Copyright Laws of the United States.
9  * They may not be used, duplicated, or disclosed in any form, in
10  * whole or in part, without the prior written consent from Boston
11  * Dynamics.
12  *
13  * RESTRICTED RIGHTS LEGEND
14  * Use, duplication, or disclosure by the government is subject
15  * to restrictions as set forth in FAR 52.227.19(c)(2) or
16  * subparagraph (c)(1)(ii) of the Rights in Technical Data and
17  * Computer Software clause at DFARS 252.227-7013 and/or in
18  * similar or successor clauses in the FAR, or the DOD or NASA
19  * FAR Supplement, or to subparagraphs (c)(1) and (c)(2) of the
20  * Commercial Computer Software--Restricted Rights at 48 CFR
21  * 52.227-19, as applicable. Unpublished-rights reserved under
22  * the Copyright Laws of the United States.
23  * Contractor/Manufacturer is:
24  * Boston Dynamics/78 Fourth Avenue/Waltham MA 02451.
25  */
26 
27 
28 /*********************************************************************
29  **
30  *t diguyChainSettings
31  **
32  */
33 
34 #ifndef __diguyChainSettings_H
35 #define __diguyChainSettings_H
36 
37 
38 #ifdef SWIG
39 %module diguyChainSettings
40 #else
41 #define CPLUSPLUS_ONLY
42 #endif
43 
44 #ifdef CPLUSPLUS_ONLY
45 class bdiScenarioChainSettings;
46 #endif
47 
48 
49 #include <declspec_diguy.h>
50 
51 /****************************************************************************/
52 class BDI_DECLSPEC_diguy diguyChainSettings
53 {
54 
55 public:
56 
57 /*****************************************************************************/
63  /*l
64  *b Returns:
65  **
66  ** name of this object; this value will never be NULL
67  **
68  *b Callable From:
69  **
70  *- - C++
71  *- - Script
72  */
73  const char* get_name();
74 
75  /*l
76  *b Description:
77  **
78  ** This function sets the name of this object.
79  **
80  *b Returns:
81  **
82  ** 0 on success, -1 on failure
83  **
84  *b Callable From:
85  **
86  *- - C++
87  *- - Script
88  */
89  int set_name(const char* name);
90 
91 
92 /*****************************************************************************/
98  /*l
99  *b Description:
100  **
101  ** This function sets how many masses will in a chain using these
102  ** settings.
103  **
104  ** The default is 80 masses.
105  **
106  *b Arguments:
107  **
108  *a num_masses - number of masses
109  **
110  *b Callable From:
111  **
112  *- - C++
113  *- - Script
114  */
115  void set_num_masses(int num_masses);
116 
117  /*l
118  *b Returns:
119  **
120  ** number of masses; see set_num_masses()
121  **
122  *b Callable From:
123  **
124  *- - C++
125  *- - Script
126  */
127  int get_num_masses();
128 
129  /*l
130  *b Description:
131  **
132  ** This function sets which chain mass will be connected to the
133  ** chain's associated character when a chain using these settings is
134  ** created or reset.
135  **
136  ** Pass -1 for no mass to be connected.
137  **
138  ** The default is chain mass 0.
139  **
140  *b Arguments:
141  **
142  *a chain_mass_index - index of chain mass
143  **
144  *b Callable From:
145  **
146  *- - C++
147  *- - Script
148  */
149  void set_index_of_chain_mass_connected_to_character(int chain_mass_index);
150 
151  /*l
152  *b Returns:
153  **
154  ** which mass to connect on reset; see
155  ** set_index_of_chain_mass_connected_to_character()
156  **
157  *b Callable From:
158  **
159  *- - C++
160  *- - Script
161  */
162  int get_index_of_chain_mass_connected_to_character();
163 
164  /*l
165  *b Description:
166  **
167  ** This function sets the dt of the chain simulation using these
168  ** settings.
169  **
170  ** Higher dt values will provide faster simulations at the risk of
171  ** instabilities. Conversely, lower dt values result in more
172  ** simulation computational overhead, but the simulation will be more
173  ** stable.
174  **
175  ** The default is 0.002 seconds.
176  **
177  *b Arguments:
178  **
179  *a simulation_dt - dt of each simulation time step, in seconds
180  **
181  *b Callable From:
182  **
183  *- - C++
184  *- - Script
185  */
186  void set_simulation_dt(float simulation_dt);
187 
188  /*l
189  *b Returns:
190  **
191  ** dt of chain simulation; see set_simulation_dt()
192  **
193  *b Callable From:
194  **
195  *- - C++
196  *- - Script
197  */
198  float get_simulation_dt();
199 
200  /*l
201  *b Description:
202  **
203  ** This function sets the mass of each chain mass of the chain
204  ** simulation using these settings.
205  **
206  ** Heavier mass will result in chain masses that have more momentum
207  ** when moving.
208  **
209  ** The default is 0.5 kg.
210  **
211  *b Arguments:
212  **
213  *a mass - mass of each chain mass, in kg
214  **
215  *b Callable From:
216  **
217  *- - C++
218  *- - Script
219  */
220  void set_mass(float mass);
221 
222  /*l
223  *b Returns:
224  **
225  ** mass of each chain mass; see set_mass()
226  **
227  *b Callable From:
228  **
229  *- - C++
230  *- - Script
231  */
232  float get_mass();
233 
234  /*l
235  *b Description:
236  **
237  ** This function sets the nominal length of the springs connecting
238  ** adjacent chain masses of the chain simulation using these
239  ** settings.
240  **
241  ** Adjacent chain masses will try to keep this distance between them.
242  ** A longer spring length will result in a longer chain.
243  **
244  ** The default is 0.2 meters
245  **
246  *b Arguments:
247  **
248  *a spring_length - nominal length between adjacent chain masses,
249  *a in meters
250  **
251  *b Callable From:
252  **
253  *- - C++
254  *- - Script
255  */
256  void set_spring_length(float spring_length);
257 
258  /*l
259  *b Returns:
260  **
261  ** nominal length between adjacent chain masses;
262  ** see set_spring_length()
263  **
264  *b Callable From:
265  **
266  *- - C++
267  *- - Script
268  */
269  float get_spring_length();
270 
271  /*l
272  *b Description:
273  **
274  ** This function sets the spring constant of the springs connecting
275  ** adjacent chain masses of the chain simulation using these
276  ** settings.
277  **
278  ** A higher spring constant will result in a more rigid chain, as
279  ** adjacent masses will try to maintain their nominal spring length
280  ** between them, as set by set_spring_length().
281  **
282  ** A hose would have a high spring constant, while a "slinky" would
283  ** have a low spring constant.
284  **
285  ** This spring constant only applies between adjacent masses.
286  **
287  ** The default is 10000.
288  **
289  *b Arguments:
290  **
291  *a spring_k - spring constant of springs between adjacent masses
292  **
293  *b Callable From:
294  **
295  *- - C++
296  *- - Script
297  */
298  void set_spring_k(float spring_k);
299 
300  /*l
301  *b Returns:
302  **
303  ** spring constant of springs between adjacent masses; see
304  ** set_spring_k()
305  **
306  *b Callable From:
307  **
308  *- - C++
309  *- - Script
310  */
311  float get_spring_k();
312 
313  /*l
314  *b Description:
315  **
316  ** This function sets the damping constant of the springs connecting
317  ** adjacent chain masses of the chain simulation using these
318  ** settings.
319  **
320  ** A higher damping constant will result in a chain that doesn't
321  ** oscillate as much; movement between masses will quickly die down.
322  **
323  ** A hose would have a high damping constant, while a "slinky" would
324  ** have a low damping constant.
325  **
326  ** The default is 15.
327  **
328  *b Arguments:
329  **
330  *a damping constant of springs between adjacent masses
331  **
332  *b Callable From:
333  **
334  *- - C++
335  *- - Script
336  */
337  void set_spring_b(float spring_b);
338 
339  /*l
340  *b Returns:
341  **
342  ** damping constant of springs between adjacent masses; see
343  ** set_spring_b()
344  **
345  *b Callable From:
346  **
347  *- - C++
348  *- - Script
349  */
350  float get_spring_b();
351 
352  /*l
353  *b Description:
354  **
355  ** This function sets the nominal length of the springs connecting
356  ** '2nd neighbor' chain masses of the chain simulation using these
357  ** settings.
358  **
359  ** 2nd neighbor chain masses are two masses apart instead of one.
360  ** (Adjacent masses are one mass apart.)
361  **
362  ** A longer 2nd neighbor spring length will result in a chain that is
363  ** stiffer and doesn't droop. A lower value will result in a chain
364  ** that can droop a lot from mass to mass.
365  **
366  ** A garden hose would have a high 2nd neighbor spring length, while
367  ** a metal chain made of linked chain links would have a low 2nd
368  ** neighbor spring length.
369  **
370  ** The default is 0.8 meters
371  **
372  *b Arguments:
373  **
374  *a spring_length - nominal length between adjacent chain masses,
375  *a in meters
376  **
377  *b Callable From:
378  **
379  *- - C++
380  *- - Script
381  */
382  void set_neighbor2_spring_length(float neighbor2_spring_length);
383 
384  /*l
385  *b Returns:
386  **
387  ** nominal distance between each mass and its '2nd neighbor'; see
388  ** set_neighbor2_spring_length()
389  **
390  *b Callable From:
391  **
392  *- - C++
393  *- - Script
394  */
395  float get_neighbor2_spring_length();
396 
397  /*l
398  *b Description:
399  **
400  ** This function sets the spring constant of springs connecting 2nd
401  ** neighbor chain masses of the chain simulation using these
402  ** settings.
403  **
404  ** See set_spring_k() for a discussion of what this value means.
405  **
406  ** The default is 600.
407  **
408  *b Arguments:
409  **
410  *a neighbor2_spring_k - spring constant of springs between
411  ** 2nd neighbor masses
412  **
413  *b Callable From:
414  **
415  *- - C++
416  *- - Script
417  */
418  void set_neighbor2_spring_k(float neighbor2_spring_k);
419 
420  /*l
421  *b Returns:
422  **
423  ** spring constant of springs between 2nd neighbor masses; see
424  ** set_neighbor2_spring_k()
425  **
426  *b Callable From:
427  **
428  *- - C++
429  *- - Script
430  */
431  float get_neighbor2_spring_k();
432 
433  /*l
434  *b Description:
435  **
436  ** This function sets the damping constant of springs connecting 2nd
437  ** neighbor chain masses of the chain simulation using these
438  ** settings.
439  **
440  ** See set_spring_b() for a discussion of what this value means.
441  **
442  ** The default is 5.
443  **
444  *b Arguments:
445  **
446  *a neighbor2_spring_b - damping constant of springs between
447  ** 2nd neighbor masses
448  **
449  *b Callable From:
450  **
451  *- - C++
452  *- - Script
453  */
454  void set_neighbor2_spring_b(float neighbor2_spring_b);
455 
456  /*l
457  *b Returns:
458  **
459  ** damping constant of springs between 2nd neighbor masses; see
460  ** set_neighbor2_spring_b()
461  **
462  *b Callable From:
463  **
464  *- - C++
465  *- - Script
466  */
467  float get_neighbor2_spring_b();
468 
469  /*l
470  *b Description:
471  **
472  ** This function sets the spring constant of the ground model.
473  **
474  ** A higher spring constant will result in a harder ground that
475  ** bounces chain masses higher when they come in contact with the
476  ** ground. Also, chain masses will not sink as far into the ground
477  ** when they come to rest.
478  **
479  ** A tile floor would have a high spring constant, while a mattress
480  ** would have a low spring constant.
481  **
482  ** The default is 5000.
483  **
484  *b Arguments:
485  **
486  *a ground_k - spring constant of ground model
487  **
488  *b Callable From:
489  **
490  *- - C++
491  *- - Script
492  */
493  void set_ground_k(float ground_k);
494 
495  /*l
496  *b Returns:
497  **
498  ** spring constant of ground model; see set_ground_k()
499  **
500  *b Callable From:
501  **
502  *- - C++
503  *- - Script
504  */
505  float get_ground_k();
506 
507  /*l
508  *b Description:
509  **
510  ** This function sets the damping constant of the ground model.
511  **
512  ** A higher damping constant will result in a ground that absorbs
513  ** impacts and doesn't bounce masses as much when they hit the
514  ** ground.
515  **
516  ** A tile floor would have a low damping constant, while an exercise
517  ** mat would have a high damping constant.
518  **
519  ** The default is 100.
520  **
521  *b Arguments:
522  **
523  *a ground_b - vertical damping constant of ground model
524  **
525  *b Callable From:
526  **
527  *- - C++
528  *- - Script
529  */
530  void set_ground_b(float ground_b);
531 
532  /*l
533  *b Returns:
534  **
535  ** vertical damping constant of ground model; see set_ground_b()
536  **
537  *b Callable From:
538  **
539  *- - C++
540  *- - Script
541  */
542  float get_ground_b();
543 
544  /*l
545  *b Description:
546  **
547  ** This function sets how much the ground model slows down masses
548  ** that are sliding on it.
549  **
550  ** A higher lateral damping constant will quickly slow down masses
551  ** sliding along the ground.
552  **
553  ** Dirt or grass ground would have a high lateral damping constant.
554  ** Ice would have a very low damping constant.
555  **
556  ** The default is 0.5.
557  **
558  *b Arguments:
559  **
560  *a ground_lateral_b - lateral damping constant of ground model
561  **
562  *b Callable From:
563  **
564  *- - C++
565  *- - Script
566  */
567  void set_ground_lateral_b(float ground_lateral_b);
568 
569  /*l
570  *b Returns:
571  **
572  ** lateral damping constant of ground model; see
573  ** set_ground_lateral_b()
574  **
575  *b Callable From:
576  **
577  *- - C++
578  *- - Script
579  */
580  float get_ground_lateral_b();
581 
582  /*l
583  *b Description:
584  **
585  ** This function sets how slow a mass in contact with the ground must
586  ** go in order for the mass to stop moving and "stick" to the ground.
587  ** This is a simple form of "stiction".
588  **
589  ** A mass will unstick if the force being applied to it exceeds the
590  ** stiction release force as set by
591  ** set_ground_stiction_release_force().
592  **
593  ** The default is 0.05 m/s.
594  **
595  *b Arguments:
596  **
597  *a ground_stiction_engage_vel - velocity at stiction will engage
598  **
599  *b Callable From:
600  **
601  *- - C++
602  *- - Script
603  */
604  void set_ground_stiction_engage_vel(float ground_stiction_engage_vel);
605 
606  /*l
607  *b Returns:
608  **
609  ** velocity at stiction will engage; see
610  ** set_ground_stiction_engage_vel()
611  **
612  *b Callable From:
613  **
614  *- - C++
615  *- - Script
616  */
617  float get_ground_stiction_engage_vel();
618 
619  /*l
620  *b Description:
621  **
622  ** This function sets how much force is required to cause a mass that
623  ** has stuck to the ground because of stiction to be released.
624  **
625  ** The default is 10 newtons.
626  **
627  *b Arguments:
628  **
629  *a ground_stiction_release_force - force at which masses will
630  *a release from stiction
631  **
632  *b Callable From:
633  **
634  *- - C++
635  *- - Script
636  */
637  void set_ground_stiction_release_force(float ground_stiction_release_force);
638 
639  /*l
640  *b Returns:
641  **
642  ** force at which masses will release from stiction; see
643  ** set_ground_stiction_release_force()
644  **
645  *b Callable From:
646  **
647  *- - C++
648  *- - Script
649  */
650  float get_ground_stiction_release_force();
651 
652  /*l
653  *b Description:
654  **
655  ** This function sets the height of the ground model. Chain masses
656  ** below this height will be repelled upward based on their mass and
657  ** the ground spring and damping constants.
658  **
659  ** Currently the ground is a level plane.
660  **
661  ** The default is 0 meters.
662  **
663  *b Arguments:
664  **
665  *a ground_height - height of the ground model, in meters
666  **
667  *b Callable From:
668  **
669  *- - C++
670  *- - Script
671  */
672  void set_ground_height(float ground_height);
673 
674  /*l
675  *b Returns:
676  **
677  ** height of the ground model; see set_ground_height()
678  **
679  *b Callable From:
680  **
681  *- - C++
682  *- - Script
683  */
684  float get_ground_height();
685 
686  /*l
687  *b Description:
688  **
689  ** This function sets the damping constant caused by air resistance.
690  **
691  ** A higher air damping constant will result in chains that don't
692  ** swing as much. A low air damping constant will result in chains
693  ** that swing freely for a long time.
694  **
695  ** Water would have a very high "air" damping constant. A clock
696  ** pendulum would have a very low air damping constant.
697  **
698  ** The default is 0.1.
699  **
700  *b Arguments:
701  **
702  *a air_b - damping constant of air, or air resistance
703  **
704  *b Callable From:
705  **
706  *- - C++
707  *- - Script
708  */
709  void set_air_b(float air_b);
710 
711  /*l
712  *b Returns:
713  **
714  ** damping constant of air; see set_air_b()
715  **
716  *b Callable From:
717  **
718  *- - C++
719  *- - Script
720  */
721  float get_air_b();
722 
723  /*l
724  *b Description:
725  **
726  ** This function sets how strongly link masses will be accelerated in
727  ** the gravity direction, typically downward.
728  **
729  ** The default is (0, 0, -9.8), in meters per second squared.
730  **
731  *b Arguments:
732  **
733  *a x, y, z - accelerations due to gravity
734  **
735  *b Callable From:
736  **
737  *- - C++
738  *- - Script
739  */
740  void set_gravity(float x, float y, float z);
741 
742  /*l
743  *b Returns:
744  **
745  ** x, y, and z components of gravity; see set_gravity()
746  **
747  *b Callable From:
748  **
749  *- - C++
750  *- - Script
751  */
752  void get_gravity(float* x, float* y, float* z);
753 
754 
755 /*****************************************************************************/
761  /*l
762  *b Description:
763  **
764  ** This function sets the radius of the chain visual.
765  **
766  ** The default is 0.05 meters.
767  **
768  *b Arguments:
769  **
770  *a radius - radius of chain visual, in meters
771  **
772  *b Callable From:
773  **
774  *- - C++
775  *- - Script
776  */
777  void set_radius(float radius);
778 
779  /*l
780  *b Returns:
781  **
782  ** radius of chain visual; see set_radius()
783  **
784  *b Callable From:
785  **
786  *- - C++
787  *- - Script
788  */
789  float get_radius();
790 
791  /*l
792  *b Description:
793  **
794  ** This function sets the ambient color of the chain visual. Passed
795  ** values should be between 0 and 1.
796  **
797  ** The default values are (0.4, 0.4, 0.4, 1).
798  **
799  *b Arguments:
800  **
801  *a r - red component
802  *a g - blue component
803  *a b - green component
804  *a a - alpha component
805  **
806  *b Callable From:
807  **
808  *- - C++
809  *- - Script
810  */
811  void set_ambient_color(float r, float g, float b, float a);
812 
813  /*l
814  *b Description:
815  **
816  ** This function gets the ambient color of the chain visual. Values
817  ** are returned via the passed pointers.
818  **
819  *b Arguments:
820  **
821  *a r - red component
822  *a g - blue component
823  *a b - green component
824  *a a - alpha component
825  **
826  *b Callable From:
827  **
828  *- - C++
829  *- - Script
830  */
831  void get_ambient_color(float* r, float* g, float* b, float* a);
832 
833  /*l
834  *b Description:
835  **
836  ** This function sets the diffuse color of the chain visual. Passed
837  ** values should be between 0 and 1.
838  **
839  ** The default values are (1, 1, 1, 1).
840  **
841  *b Arguments:
842  **
843  *a r - red component
844  *a g - blue component
845  *a b - green component
846  *a a - alpha component
847  **
848  *b Callable From:
849  **
850  *- - C++
851  *- - Script
852  */
853  void set_diffuse_color(float r, float g, float b, float a);
854 
855  /*l
856  *b Description:
857  **
858  ** This function gets the diffuse color of the chain visual. Values
859  ** are returned via the passed pointers.
860  **
861  *b Arguments:
862  **
863  *a r - red component
864  *a g - blue component
865  *a b - green component
866  *a a - alpha component
867  **
868  *b Callable From:
869  **
870  *- - C++
871  *- - Script
872  */
873  void get_diffuse_color(float* r, float* g, float* b, float* a);
874 
875  /*l
876  *b Description:
877  **
878  ** This function sets the specular color of the chain visual. Passed
879  ** values should be between 0 and 1.
880  **
881  ** The default values are (1, 1, 1, 1).
882  **
883  *b Arguments:
884  **
885  *a r - red component
886  *a g - blue component
887  *a b - green component
888  *a a - alpha component
889  **
890  *b Callable From:
891  **
892  *- - C++
893  *- - Script
894  */
895  void set_specular_color(float r, float g, float b, float a);
896 
897  /*l
898  *b Description:
899  **
900  ** This function gets the specular color of the chain visual. Values
901  ** are returned via the passed pointers.
902  **
903  *b Arguments:
904  **
905  *a r - red component
906  *a g - blue component
907  *a b - green component
908  *a a - alpha component
909  **
910  *b Callable From:
911  **
912  *- - C++
913  *- - Script
914  */
915  void get_specular_color(float* r, float* g, float* b, float* a);
916 
917  /*l
918  *b Description:
919  **
920  ** This function sets the shininess of the chain visual.
921  **
922  ** The default is 20.
923  **
924  *b Arguments:
925  **
926  *a shininess - the shininess of the chain visual
927  **
928  *b Callable From:
929  **
930  *- - C++
931  *- - Script
932  */
933  void set_shininess(float shininess);
934 
935  /*l
936  *b Returns:
937  **
938  ** the shininess of the chain visual; see set_shininess()
939  **
940  *b Callable From:
941  **
942  *- - C++
943  *- - Script
944  */
945  float get_shininess();
946 
947  /*l
948  *b Description:
949  **
950  ** This function sets the filename of the texture that will be used
951  ** for the chain visual.
952  **
953  ** Common textures are:
954  **
955  *- - "chain_link.rgba"
956  *- - "firefighter_hose2.rgb"
957  **
958  ** The default is "" (no texture).
959  **
960  *b Arguments:
961  **
962  *a texture_filename - filename of texture of chain visual
963  **
964  *b Callable From:
965  **
966  *- - C++
967  *- - Script
968  */
969  void set_texture_filename(const char* texture_filename);
970 
971  /*l
972  *b Returns:
973  **
974  ** filename of texture of chain visual; see set_texture_filename()
975  **
976  *b Callable From:
977  **
978  *- - C++
979  *- - Script
980  */
981  const char* get_texture_filename();
982 
983  /*l
984  *b Description:
985  **
986  ** This function sets how many times the texture will be repeated
987  ** along the length of the chain.
988  **
989  ** The default is 1 rep.
990  **
991  *b Arguments:
992  **
993  *a num_texture_repetitions - how many times texture will be
994  *a repeated on chain visual
995  **
996  *b Callable From:
997  **
998  *- - C++
999  *- - Script
1000  */
1001  void set_num_texture_repetitions(int num_texture_repetitions);
1002 
1003  /*l
1004  *b Returns:
1005  **
1006  ** how many times texture will be repeated on chain visual; see
1007  ** set_num_texture_repetitions()
1008  **
1009  *b Callable From:
1010  **
1011  *- - C++
1012  *- - Script
1013  */
1014  int get_num_texture_repetitions();
1015 
1016  /*l
1017  *b Description:
1018  **
1019  ** This function sets what the "cross section" of the chain visual
1020  ** will be.
1021  **
1022  ** See the documentation for diguyChainCrossSection for information
1023  ** on what the different cross sections mean.
1024  **
1025  ** The default is DIGUY_CHAIN_CROSS_SECTION_SQUARE.
1026  **
1027  *b Arguments:
1028  **
1029  *a cs - cross section of the chain visual
1030  **
1031  *b Callable From:
1032  **
1033  *- - C++
1034  *- - Script
1035  */
1036  void set_cross_section(diguyChainCrossSection cs);
1037 
1038  /*l
1039  *b Returns:
1040  **
1041  ** cross section type of chain visual; see set_cross_section()
1042  **
1043  *b Callable From:
1044  **
1045  *- - C++
1046  *- - Script
1047  */
1048  diguyChainCrossSection get_cross_section();
1049 
1050  /*l
1051  *b Description:
1052  **
1053  ** Set the shape that will be attached to the beginning end of the
1054  ** chain. Options are:
1055  **
1056  *- - "chain_cap_firehose_nozzle"
1057  *- - "chain_cap_fuel_hose_nozzle"
1058  *- - "chain_cap_taser_probe"
1059  *- - "chain_cap_chain_hook"
1060  **
1061  ** The default is "" (no begin cap).
1062  **
1063  *b Arguments:
1064  **
1065  *a appearance_begin_cap - name of begin cap
1066  **
1067  *b Callable From:
1068  **
1069  *- - C++
1070  *- - Script
1071  */
1072  void set_appearance_begin_cap(const char* appearance_begin_cap);
1073 
1074  /*l
1075  *b Returns:
1076  **
1077  ** name of cap appearance at beginning of chain; see
1078  ** set_appearance_begin_cap()
1079  **
1080  *b Callable From:
1081  **
1082  *- - C++
1083  *- - Script
1084  */
1085  const char* get_appearance_begin_cap();
1086 
1087  /*l
1088  *b Description:
1089  **
1090  ** Sets the shape that will be attached to the end of the chain. See
1091  ** set_appearance_begin_cap().
1092  **
1093  ** The default is "" (no end cap).
1094  **
1095  *b Arguments:
1096  **
1097  *a appearance_end_cap - name of end cap
1098  **
1099  *b Callable From:
1100  **
1101  *- - C++
1102  *- - Script
1103  */
1104  void set_appearance_end_cap(const char* appearance_end_cap);
1105 
1106  /*l
1107  *b Returns:
1108  **
1109  ** name of cap appearance at end of chain; see
1110  ** set_appearance_end_cap()
1111  **
1112  *b Callable From:
1113  **
1114  *- - C++
1115  *- - Script
1116  */
1117  const char* get_appearance_end_cap();
1118 
1119 
1120 /*****************************************************************************/
1126  /*l
1127  *b Description:
1128  **
1129  ** For chains with the DIGUY_CHAIN_CROSS_SECTION_COIL cross section,
1130  ** sets the number of coil windings of the chain.
1131  **
1132  ** The default is 4 coils.
1133  **
1134  *b Arguments:
1135  **
1136  *a num_coils - number of coil windings
1137  **
1138  *b Callable From:
1139  **
1140  *- - C++
1141  *- - Script
1142  */
1143  void set_num_coils(int num_coils);
1144 
1145  /*l
1146  *b Returns:
1147  **
1148  ** number of coils for chain visual of type
1149  ** DIGUY_CHAIN_CROSS_SECTION_COIL; see set_num_coils()
1150  **
1151  *b Callable From:
1152  **
1153  *- - C++
1154  *- - Script
1155  */
1156  int get_num_coils();
1157 
1158  /*l
1159  *b Description:
1160  **
1161  ** Sets how thick the coil will be.
1162  **
1163  ** The default is 0.02 meters.
1164  **
1165  *b Arguments:
1166  **
1167  *a coil_thickness - thickness of coil
1168  **
1169  *b Callable From:
1170  **
1171  *- - C++
1172  *- - Script
1173  */
1174  void set_coil_thickness(float coil_thickness);
1175 
1176  /*l
1177  *b Returns:
1178  **
1179  ** thickness of coils for chain visual of type
1180  ** DIGUY_CHAIN_CROSS_SECTION_COIL; see set_coil_thickness()
1181  **
1182  *b Callable From:
1183  **
1184  *- - C++
1185  *- - Script
1186  */
1187  float get_coil_thickness();
1188 
1189  /*l
1190  *b Description:
1191  **
1192  ** Sets at which mass in the coil the thickness of the coil will
1193  ** reach its full radius.
1194  **
1195  ** The default is 6.
1196  **
1197  *b Arguments:
1198  **
1199  *a coil_taper_begin_mass_count - chain mass at which to begin taper
1200  **
1201  *b Callable From:
1202  **
1203  *- - C++
1204  *- - Script
1205  */
1206  void set_coil_taper_begin_mass_count(int coil_taper_begin_mass_count);
1207 
1208  /*l
1209  *b Returns:
1210  **
1211  ** mass at which the coil will reach its full radius at the beginning
1212  ** of chain; see set_coil_taper_begin_mass_count()
1213  **
1214  *b Callable From:
1215  **
1216  *- - C++
1217  *- - Script
1218  */
1219  int get_coil_taper_begin_mass_count();
1220 
1221  /*l
1222  *b Description:
1223  **
1224  ** Similar to set_coil_taper_begin_mass_count(), but for the end of
1225  ** the chain.
1226  **
1227  ** The default is 0.
1228  **
1229  *b Arguments:
1230  **
1231  *a coil_taper_end_mass_count - chain mass at which to end taper
1232  **
1233  *b Callable From:
1234  **
1235  *- - C++
1236  *- - Script
1237  */
1238  void set_coil_taper_end_mass_count(int coil_taper_end_mass_count);
1239 
1240  /*l
1241  *b Returns:
1242  **
1243  ** mass at which the coil will reach its full radius at end of chain;
1244  ** see set_coil_taper_end_mass_count()
1245  **
1246  *b Callable From:
1247  **
1248  *- - C++
1249  *- - Script
1250  */
1251  int get_coil_taper_end_mass_count();
1252 
1257 #ifdef CPLUSPLUS_ONLY
1258 
1259  bdiScenarioChainSettings* get_scripted_object() {return m_scripted_object;}
1260 
1261 private:
1262 
1263  /*l
1264  ** A private constructor.
1265  */
1266  diguyChainSettings(bdiScenarioChainSettings* scripted_object);
1267 
1268  /*l
1269  ** A private destructor.
1270  */
1271  ~diguyChainSettings();
1272 
1273  /*l
1274  ** A pointer to internal data.
1275  */
1276  bdiScenarioChainSettings* m_scripted_object;
1277 
1278  friend class bdiScenarioChainSettings;
1279 
1280 #endif
1281 
1282 };
1283 
1284 
1285 #endif /* __diguyChainSettings_H */
1286 
1287 
1288 /*
1289  * Copyright (C) 1992-2013 Boston Dynamics
1290  * ALL RIGHTS RESERVED.
1291  *
1292  * These coded instructions, statements, and computer programs
1293  * contain unpublished proprietary information of Boston Dynamics
1294  * and are protected by Copyright Laws of the United States.
1295  * They may not be used, duplicated, or disclosed in any form, in
1296  * whole or in part, without the prior written consent from Boston
1297  * Dynamics.
1298  *
1299  * RESTRICTED RIGHTS LEGEND
1300  * Use, duplication, or disclosure by the government is subject
1301  * to restrictions as set forth in FAR 52.227.19(c)(2) or
1302  * subparagraph (c)(1)(ii) of the Rights in Technical Data and
1303  * Computer Software clause at DFARS 252.227-7013 and/or in
1304  * similar or successor clauses in the FAR, or the DOD or NASA
1305  * FAR Supplement, or to subparagraphs (c)(1) and (c)(2) of the
1306  * Commercial Computer Software--Restricted Rights at 48 CFR
1307  * 52.227-19, as applicable. Unpublished-rights reserved under
1308  * the Copyright Laws of the United States.
1309  * Contractor/Manufacturer is:
1310  * Boston Dynamics/78 Fourth Avenue/Waltham MA 02451.
1311  */
1312