]> git.mxchange.org Git - flightgear.git/blob - src/GUI/sgVec3Slider.cxx
Set the initial log-level back to info
[flightgear.git] / src / GUI / sgVec3Slider.cxx
1 /**
2  *      sgVec3Slider.cxx
3  *
4  *      Simple PUI wrapper around sgVec3 class
5  *
6  *      Created by: Norman Vine [NHV]
7  *         nhv@yahoo.com, nhv@cape.com
8  *
9  *      Revision History
10  *      ---------------- 
11  *  Started 12:53 01/28/2001
12  *
13  */
14
15 #include "sgVec3Slider.hxx"
16 #include <Main/fg_props.hxx>
17 #include <simgear/sg_inlines.h>
18
19 static void
20 setPilotXOffset (float value)
21 {
22         PilotOffsetSet(0, value);
23 }
24
25 static float
26 getPilotXOffset ()
27 {
28         return( PilotOffsetGetSetting(0) );
29 }
30
31
32 static void
33 setPilotYOffset (float value)
34 {
35         PilotOffsetSet(1, value);
36 }
37
38 static float
39 getPilotYOffset ()
40 {
41         return( PilotOffsetGetSetting(1) );
42 }
43
44
45 static void
46 setPilotZOffset (float value)
47 {
48         PilotOffsetSet(2, value);
49 }
50
51 static float
52 getPilotZOffset ()
53 {
54         return( PilotOffsetGetSetting(2) );
55 }
56
57
58 class FloatSlider : public puSlider
59 {
60
61 protected:
62         float maxValue;
63         float minValue;
64         float origValue;
65         float Adjust;
66         float MyValue;
67         float TmpValue;
68         float SaveValue;
69         char buf[8];
70         char _title[32];
71         char _text[16];
72 public:
73         FloatSlider ( int x, int y, int sz, float f, const char *title,
74                                   float max = 100.0f, float min = 0.0f);
75
76         ~FloatSlider () {;}
77
78         static void adj( puObject *);
79                 
80         void updateText() {
81                 sprintf( _text, "%05.2f", MyValue );
82         }
83
84         float get() { return( MyValue ); }
85
86         // calc actual "setting" by multiplying the pui fraction by highest value setable
87         void  set() { MyValue = maxValue * TmpValue; }
88
89         float *getTmp() { return( &TmpValue ); }
90
91         // adjust the TmpValue back to 0 to 1 range of pui widget
92         void   setTmp() { TmpValue += 0.0f; }
93
94         void incTmp() { TmpValue += 0.0001f; setTmp(); }
95         void decTmp() { TmpValue -= 0.0001f; setTmp(); }
96
97         // adjust actual "setting" value back to fraction for pui widget
98         void init( float f ) {
99                 if (f > maxValue) f = maxValue;
100                 if (f < minValue) f = minValue;
101                 Adjust   = 1.0f / maxValue;
102                 setValue(f * Adjust);
103                 adj( this );
104         }
105
106         void reinit() { init( origValue ); }
107         void cancel() { MyValue = TmpValue; }
108         void reset () { init( origValue ); }
109
110 };
111
112 void FloatSlider::adj( puObject *hs )
113 {
114         FloatSlider *slider = (FloatSlider *)hs;
115         slider->getValue ( slider->getTmp() );
116         slider->setTmp();
117         slider->set();
118         slider->updateText();
119 }
120
121 FloatSlider::FloatSlider ( int x, int y, int sz, float f, const char *title,
122                                                    float max, float min ) :  puSlider( x, y, sz, FALSE )
123 {
124         maxValue = max;
125         minValue = min;
126         origValue = f;
127         init(f);
128         setDelta    ( 0.01 );
129         setCBMode   ( PUSLIDER_DELTA ) ;
130         strcpy      ( _title, title);
131         setLabel    ( _title );
132         setLabelPlace ( PUPLACE_LEFT );
133         setLegend(_text);
134         // setLegendPlace( PUPLACE_RIGHT );
135 }
136
137
138 class FloatDial : public puDial
139 {
140
141 protected:
142         float maxValue;
143         float minValue;
144         float origValue;
145         float Adjust;
146         float MyValue;
147         float TmpValue;
148         float SaveValue;
149         char buf[8];
150         char _title[32];
151         char _text[16];
152 public:
153         FloatDial ( int x, int y, int sz, float f, const char *title,
154                                   float max = 180.0f, float min = -180.0f );
155
156         ~FloatDial () {;}
157                 
158         static void adj( puObject *);
159
160         void updateText() {
161                 sprintf( _text, "%05.2f", MyValue );
162         }
163
164         float get() { return( MyValue ); }
165
166         // calc actual "setting" by multiplying the pui fraction by highest value setable
167         // in this case we're also turning a 0 to 1 range into a -.05 to +.05 before converting
168         void  set() { MyValue = ((2.0*maxValue) * (TmpValue - 0.5f)) - maxValue; }
169
170         float *getTmp() { return( &TmpValue ); }
171
172         // adjust the TmpValue back to 0 to 1 range of pui widget
173         void   setTmp() { TmpValue += 0.5f; }
174         
175         void incTmp() { TmpValue += 0.0001f; setTmp(); }
176         void decTmp() { TmpValue -= 0.0001f; setTmp(); }
177
178         // adjust actual "setting" value back to fraction for pui widget
179         // double the range from -max <-> max
180         void init( float f ) {
181                 if (f > maxValue) f = maxValue;
182                 if (f < minValue) f = minValue;
183                 Adjust   = 0.5f / maxValue;
184                 setValue((f * Adjust) + 0.5f);
185                 adj( this );
186         }
187
188         void reinit() { init( origValue ); }
189         void cancel() { MyValue = TmpValue; }
190         void reset () { init( origValue ); }
191
192 };
193
194 void FloatDial::adj( puObject *hs )
195 {
196         FloatDial *dial = (FloatDial *)hs;
197         dial->getValue ( dial->getTmp() );
198         dial->setTmp();
199         dial->set();
200         dial->updateText();
201 }
202
203 FloatDial::FloatDial ( int x, int y, int sz, float f, const char *title,
204                                                    float max, float min ) :  puDial( x, y, sz )
205 {
206         maxValue = max;
207         minValue = min;
208         origValue = f;
209         init(f);
210         setDelta    ( 0.01 );
211         setCBMode   ( PUSLIDER_DELTA ) ;
212         strcpy      ( _title, title);
213         setLabel    ( _title );
214         setLabelPlace ( PUPLACE_LEFT  );
215         setLegend(_text);
216         // setLegendPlace( PUPLACE_RIGHT );
217 }
218
219
220 /***********************************************/
221
222 class sgVec3Slider : public puDialogBox
223 {
224         static void handle_arrow(puObject *p_obj);
225         static void heading_adj(puObject *p_obj);
226         static void pitch_adj(puObject *p_obj);
227         static void radius_adj(puObject *p_obj);
228         static void goAway(puObject *p_obj);
229         static void reset(puObject *p_obj);
230         static void cancel(puObject *p_obj);
231
232 protected:
233         char Label[64];
234         FloatDial *HS0;
235         FloatDial *HS1;
236         FloatSlider *HS2;
237         puText *TitleText;
238         puOneShot *OkButton;
239         puOneShot *ResetButton;
240         puOneShot *CancelButton;
241         puArrowButton *right_arrow;
242         puArrowButton *left_arrow;
243         sgVec3 Vec, SaveVec;
244         
245 public:
246
247         sgVec3Slider ( int x, int y, sgVec3 vec,
248                                    const char *title = "Vector Adjuster",
249                                    const char *Xtitle = "Heading",
250                                    const char *Ytitle = "Pitch",
251                                    const char *Ztitle = "Radius   " );
252
253         ~sgVec3Slider () {;}
254
255
256         // calc the property Vec with the actual point on sphere
257         void setVec()
258         {
259                 Vec3FromHeadingPitchRadius( Vec,
260                                                 HS0->get(),
261                                                 HS1->get(),
262                                                 HS2->get());
263         }
264
265         // return the offset vector according to current widget values
266         sgVec3 *getVec()
267         { 
268                 setVec();
269                 return &Vec;
270         };
271
272         // save the Vector before pushing dialog (for cancel button)
273         sgVec3 *getStashVec() { return &SaveVec; }
274         void stashVec() { 
275                 SaveVec[2] = HS0->get();
276                 SaveVec[1] = HS1->get();
277                 SaveVec[0] = HS2->get();
278         }
279
280         // functions to return pointers to protected pui widget instances
281         FloatDial *getHS0() { return HS0; }
282         FloatDial *getHS1() { return HS1; }
283         FloatSlider *getHS2() { return HS2; }
284
285         static void adjust(puObject *p_obj);
286 };
287
288 // class constructor
289 sgVec3Slider::sgVec3Slider ( int x, int y, sgVec3 cart, const char *title,
290                              const char *Xtitle,
291                              const char *Ytitle,
292                              const char *Ztitle ): puDialogBox ( x, y )
293 {
294         puFont LegendFont, LabelFont;
295         puGetDefaultFonts ( &LegendFont, &LabelFont );
296         int fudge = 20;
297
298         HeadingPitchRadiusFromVec3( Vec, cart);
299         sgVec3 vec;
300         sgSetVec3(vec, Vec[0], Vec[1], Vec[2]);
301
302         int labelW = LabelFont.getStringWidth(Xtitle);
303         labelW = SG_MAX2( labelW, LabelFont.getStringWidth(Ytitle));
304         labelW = SG_MAX2( labelW, LabelFont.getStringWidth(Ztitle));
305                 
306
307         sgCopyVec3(SaveVec, vec);
308         sgCopyVec3(Vec, vec);
309         strcpy( Label, title );
310
311         int nSliders = 3;
312         int slider_x = 70+fudge;
313         int slider_y = 75;
314         int slider_width = 270;
315         int dialer_x = 70+fudge;
316         int dialer_y = 115;
317         int dialer_size = 100;
318
319         int horiz_slider_height = LabelFont.getStringHeight()
320             + LabelFont.getStringDescender()
321             + PUSTR_TGAP + PUSTR_BGAP + 5;
322
323         int DialogWidth = slider_width + 20 + fudge + labelW;
324         int DialogHeight = dialer_size + 115 + nSliders * horiz_slider_height;
325         
326         // HACKS
327         setUserData( this );
328         horiz_slider_height += 10;
329
330         new puFrame ( 0, 0, DialogWidth, DialogHeight );
331
332         setLabelPlace( PUPLACE_DEFAULT /*PUPLACE_CENTERED*/ );
333         setLabel( Label );
334
335         /* heading */
336         HS0 = new FloatDial (  dialer_x, dialer_y, dialer_size, vec[0], Xtitle, 180.0f, -180.0f );
337         dialer_x = dialer_x + 170;
338         HS0->setUserData (this);
339         HS0->setCallback ( heading_adj ) ;
340
341         /* pitch */
342         HS1 = new FloatDial (  dialer_x, dialer_y, dialer_size, vec[1], Ytitle, 89.99f, -89.99f );
343         HS1->setUserData (this);
344         HS1->setCallback ( pitch_adj ) ;
345
346         /* radius */
347         HS2 = new FloatSlider (  slider_x+20, slider_y, slider_width-40, vec[2], Ztitle, 100.0f, 0.0f );
348         HS2->setUserData (this);
349         HS2->setCallback ( radius_adj );
350
351         right_arrow = new puArrowButton ( slider_x + slider_width - 20, slider_y + 1, slider_x + slider_width, slider_y+21, PUARROW_RIGHT ) ;
352         right_arrow->setUserData ( HS2 ) ;
353         right_arrow->setCallback ( handle_arrow ) ;
354
355         left_arrow = new puArrowButton ( slider_x, slider_y + 1, slider_x+20, slider_y+21, PUARROW_LEFT ) ;
356         left_arrow->setUserData ( HS2 ) ;
357         left_arrow->setCallback ( handle_arrow ) ;
358
359         TitleText = new puText( 130, DialogHeight - 40);
360         TitleText->setLabel("Pilot Offset");
361
362         OkButton = new puOneShot ( 70+fudge, 20, 120+fudge, 50 );
363         OkButton-> setUserData( this );
364         OkButton-> setLegend ( gui_msg_OK );
365         OkButton-> makeReturnDefault ( TRUE );
366         OkButton-> setCallback ( goAway );
367
368         CancelButton = new puOneShot ( 130+fudge, 20, 210+fudge, 50 );
369         CancelButton-> setUserData( this );
370         CancelButton-> setLegend ( gui_msg_CANCEL );
371         CancelButton-> setCallback ( cancel );
372
373 // renabling this button requires binding in the sim/view[?]/config/?-offset-m values
374 //      ResetButton = new puOneShot ( 220+fudge, 20, 280+fudge, 50 );
375 //      ResetButton-> setUserData( this );
376 //      ResetButton-> setLegend ( gui_msg_RESET );
377 //      ResetButton-> setCallback ( reset );
378
379         FG_FINALIZE_PUI_DIALOG( this );
380 }
381
382 void sgVec3Slider::handle_arrow(puObject *arrow)
383 {
384   FloatSlider *slider = (FloatSlider *) arrow->getUserData();
385   if (((puArrowButton *)arrow)->getArrowType() == PUARROW_RIGHT)
386     slider->incTmp();
387   else
388     slider->decTmp();
389   slider->set();
390   slider->init( slider->get() );
391   sgVec3Slider *me = (sgVec3Slider *)slider->getUserData();
392   me->setVec();
393 };
394
395 void sgVec3Slider::heading_adj(puObject *p_obj)
396 {
397   sgVec3Slider *me = (sgVec3Slider *)p_obj->getUserData();
398   me->HS0->adj((puObject *)me ->HS0 );
399   me->setVec();
400 };
401
402 void sgVec3Slider::pitch_adj(puObject *p_obj)
403 {
404   sgVec3Slider *me = (sgVec3Slider *)p_obj->getUserData();
405   me->HS1->adj((puObject *)me ->HS1 );
406   me->setVec();
407 };
408
409 void sgVec3Slider::radius_adj(puObject *p_obj)
410 {
411   sgVec3Slider *me = (sgVec3Slider *)p_obj->getUserData();
412   me ->HS2-> adj((puObject *)me ->HS2 );
413   me->setVec();
414 };
415
416 void sgVec3Slider::goAway(puObject *p_obj)
417 {
418         sgVec3Slider *me = (sgVec3Slider *)p_obj->getUserData();
419         FG_POP_PUI_DIALOG( me );
420 };
421
422 void sgVec3Slider::reset(puObject *p_obj)
423 {
424         sgVec3Slider *me = (sgVec3Slider *)p_obj->getUserData();
425         me->HS0->reinit();
426         me->HS1->reinit();
427         me->HS2->reinit();
428 };
429
430 void sgVec3Slider::cancel(puObject *p_obj)
431 {
432         sgVec3 vec;
433         sgVec3Slider *me = (sgVec3Slider *)p_obj->getUserData();
434         sgVec3 *pvec = me -> getStashVec();
435         sgCopyVec3( vec, *pvec );
436         me->HS0->init(vec[2]);
437         me->HS1->init(vec[1]);
438         me->HS2->init(vec[0]);
439         me->setVec();
440         FG_POP_PUI_DIALOG( me );
441 };
442
443 void sgVec3Slider::adjust(puObject *p_obj)
444 {
445         sgVec3Slider *me = (sgVec3Slider *)p_obj->getUserData();
446         heading_adj( me );
447         pitch_adj( me );
448         radius_adj( me );
449
450         sgVec3 cart;
451         sgSetVec3(cart,
452                fgGetFloat("/sim/current-view/x-offset-m"),
453                fgGetFloat("/sim/current-view/y-offset-m"),
454                fgGetFloat("/sim/current-view/z-offset-m")
455         );
456
457         HeadingPitchRadiusFromVec3( me->Vec, cart);
458
459         me -> getHS0() -> init(me->Vec[0]);
460         me -> getHS1() -> init(me->Vec[1]);
461         me -> getHS2() -> init(me->Vec[2]);
462
463         me -> getHS0() -> adj((puObject *)me -> getHS0());
464         me -> getHS1() -> adj((puObject *)me -> getHS1());
465         me -> getHS2() -> adj((puObject *)me -> getHS2());
466         me -> setVec();
467 };
468
469 void sgVec3SliderAdjust( puObject *p_obj )
470 {
471         sgVec3Slider *me = (sgVec3Slider *)p_obj -> getUserData();
472         me -> adjust( me );
473         FG_PUSH_PUI_DIALOG( me );
474 }
475
476 // These are globals for now
477 static puObject *PO_vec = 0;
478
479 void PilotOffsetInit() {
480         sgVec3 cart;
481         sgSetVec3(cart,
482                fgGetFloat("/sim/current-view/x-offset-m"),
483                fgGetFloat("/sim/current-view/y-offset-m"),
484                fgGetFloat("/sim/current-view/z-offset-m")
485         );
486         PilotOffsetInit(cart);
487 }
488
489 void PilotOffsetInit( sgVec3 cart )
490 {
491         // Only one of these things for now
492         if( PO_vec == 0 ) {
493                 sgVec3Slider *PO = new sgVec3Slider ( 200, 200, cart, "Pilot Offset" );
494                 PO_vec = PO;
495                 // Bindings for Pilot Offset
496                 fgTie("/sim/current-view/x-offset-m", getPilotXOffset, setPilotXOffset);
497                 fgTie("/sim/current-view/y-offset-m", getPilotYOffset, setPilotYOffset);
498                 fgTie("/sim/current-view/z-offset-m", getPilotZOffset, setPilotZOffset);
499         }
500 }
501
502 void PilotOffsetAdjust( puObject * )
503 {
504         if( PO_vec == 0 ) {
505                 PilotOffsetInit();
506         }
507         sgVec3Slider *me = (sgVec3Slider *)PO_vec -> getUserData();
508         me -> adjust( me );
509         me -> stashVec();
510         FG_PUSH_PUI_DIALOG( me );
511 }
512
513 // external to get pilot offset vector for viewer
514 sgVec3 *PilotOffsetGet()
515 {
516         if( PO_vec == 0 ) {
517                 PilotOffsetInit();
518         }
519         sgVec3Slider *me = (sgVec3Slider *)PO_vec -> getUserData();
520         return( me -> getVec() );
521 }
522
523 // external function used to tie to FG properties
524 float PilotOffsetGetSetting(int opt)
525 {
526         float setting = 0.0;
527         if( PO_vec == 0 ) {
528             PilotOffsetInit();
529         }
530         sgVec3Slider *me = (sgVec3Slider *)PO_vec -> getUserData();
531         sgVec3 vec;
532         sgCopyVec3(vec, (float *) me->getVec());
533         if( opt == 0 ) setting = vec[0];
534         if( opt == 1 ) setting = vec[1];
535         if( opt == 2 ) setting = vec[2];
536         return( setting );
537 }
538
539 // external function used to tie to FG properties
540 void PilotOffsetSet(int opt, float setting)
541 {
542         if( PO_vec == 0 ) {
543                 PilotOffsetInit();
544         }
545         sgVec3Slider *me = (sgVec3Slider *)PO_vec -> getUserData();
546
547         sgVec3 HPR;
548         sgVec3 vec;
549         sgCopyVec3(vec, (float *) me->getVec());
550         if( opt == 0 ) vec[0] = setting;
551         if( opt == 1 ) vec[1] = setting;
552         if( opt == 2 ) vec[2] = setting;
553         HeadingPitchRadiusFromVec3 ( HPR, vec );
554         me -> getHS0() -> init( HPR[0] );
555         me -> getHS1() -> init( HPR[1] );
556         me -> getHS2() -> init( HPR[2] );
557         me -> stashVec();
558 }
559
560
561 // Calculate vector of point on sphere:
562 // input Heading == longitude of point on sphere
563 // input Pitch   == latitude of point on sphere
564 // input Radius  == radius of sphere
565
566 #define MIN_VIEW_OFFSET 0.001
567 void Vec3FromHeadingPitchRadius ( sgVec3 vec3, float heading, float pitch,
568 float radius )
569 {
570   double ch, sh, cp, sp;
571
572   if ( heading == SG_ZERO )
573   {
574     ch = SGD_ONE ;
575     sh = SGD_ZERO ;
576   }
577   else
578   {
579     sh = sin( (double)( heading * SG_DEGREES_TO_RADIANS )) ;
580     ch = cos( (double)( heading * SG_DEGREES_TO_RADIANS )) ;
581   }
582
583   if ( pitch == SG_ZERO )
584   {
585     cp = SGD_ONE ;
586     sp = SGD_ZERO ;
587   }
588   else
589   {
590     sp = sin( (double)( pitch * SG_DEGREES_TO_RADIANS )) ;
591     cp = cos( (double)( pitch * SG_DEGREES_TO_RADIANS )) ;
592   }
593
594   if ( radius < MIN_VIEW_OFFSET )
595           radius = MIN_VIEW_OFFSET ;
596
597   vec3[2] = (SGfloat)( ch * cp ) * radius ; // X
598   vec3[1] = (SGfloat)( sh * cp ) * radius ; // Y
599   vec3[0] = (SGfloat)(  sp ) * radius ; // Z
600 }
601
602 // Convert to speherical coordinates for the dials
603
604 void HeadingPitchRadiusFromVec3 ( sgVec3 hpr, sgVec3 vec3 )
605 {
606   double x = vec3[0];
607   double y = vec3[1];
608   double z = vec3[2];
609   double Zx;
610   double Pr;
611
612   if (z == 0.0f) {
613     hpr[0] = 0;
614     hpr[1] = 0;
615     hpr[2] = 0;
616   } else {
617     if (fabs(y) < 0.001f)
618       y = 0.001f;
619
620     Zx = sqrt(y*y + z*z);
621
622     hpr[2] = sqrt(x*x + y*y + z*z);
623
624     Pr = Zx / hpr[2];
625     if (Pr > 1.0f)
626       hpr[1] = 0.0f;
627     else 
628       hpr[1] = acos(Pr) * SGD_RADIANS_TO_DEGREES;
629     if (x < 0.0f) 
630       hpr[1] *= -SGD_ONE;
631
632     if (z < 0.0f) {
633       hpr[0] = (SGD_PI - asin(y/Zx)) * SGD_RADIANS_TO_DEGREES;
634     } else {
635       hpr[0] = asin(y/Zx) * SGD_RADIANS_TO_DEGREES;
636       if (hpr[0] > 180) {
637         hpr[0] = 180 - hpr[0];
638       }
639     }
640   }
641 }