source: osgVisual/trunk/src/object/visual_object.cpp @ 210

Last change on this file since 210 was 210, checked in by Torben Dannhauer, 13 years ago
File size: 21.8 KB
Line 
1/* -*-c++-*- osgVisual - Copyright (C) 2009-2010 Torben Dannhauer
2 *
3 * This library is based on OpenSceneGraph, open source and may be redistributed and/or modified under
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * osgVisual requires for some proprietary modules a license from the correspondig manufacturer.
9 * You have to aquire licenses for all used proprietary modules.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * OpenSceneGraph Public License for more details.
15*/
16
17#include <visual_object.h>
18
19using namespace osgVisual;
20
21visual_object::visual_object( osg::CoordinateSystemNode* sceneRoot_, std::string nodeName_)
22{
23        // Add this node to Scenegraph
24        sceneRoot_->addChild( this );
25
26        // Set Nodename for further identification
27        this->setName( nodeName_ );
28
29        // Set callback.
30        /** \todo: welcher update ist der richtige? voraussichtlich event.) */
31        //this->setUpdateCallback( new visual_objectPositionCallback() );
32        this->setEventCallback( new visual_objectPositionCallback() );
33
34        // Init Position and Attitude
35        lat = 0;
36        lon = 0;
37        alt = 0;
38
39        azimuthAngle_psi = 0;
40        pitchAngle_theta = 0;
41        bankAngle_phi = 0;
42
43        geometry_offset_rotation.makeRotate( 0.0, 1.0, 1.0, 1.0 );
44
45        // Init Scale factor
46        scaleX = 1.0;
47        scaleY = 1.0;
48        scaleZ = 1.0;
49
50        // Init cameraOffset
51        cameraTranslationOffset.makeTranslate( osg::Vec3d(0.0, 0.0, 0.0) );     // Trans: (y, x, -z_down)
52        cameraRotationOffset.makeRotate( osg::DegreesToRadians( 90.0 ), osg::Vec3(1, 0, 0) );   // Rot: (-y, +x , -z)
53
54        //setCameraOffsetTranslation(0.0, -150.0, 50.0);        // Trans: (rechts davon, longitudinal, vertikal)
55        setCameraOffsetTranslation( 150.0, 0.0, 30.0);
56        setCameraOffsetRotation( osg::DegreesToRadians(0.0), osg::DegreesToRadians(-15.0), osg::DegreesToRadians(-90.0) );
57
58        // Geometrynode hinzufügen
59        geometry = new osg::Group();
60        this->addChild( geometry );
61
62        // Labelnode hinzufügen
63        labels = new osg::Geode();
64        this->addChild( labels ); 
65}
66
67visual_object::~visual_object()
68{
69
70}
71
72visual_object* visual_object::createNodeFromXMLConfig(osg::CoordinateSystemNode* sceneRoot_, xmlNode* a_node)
73{
74        if(a_node == NULL)
75                return NULL;
76
77        OSG_NOTIFY( osg::ALWAYS ) << __FUNCTION__ << "Try to creating a new Model.." << std::endl;
78       
79        // Prepare Variables
80        std::string objectname="", filename="", label="";
81        bool dynamic = false;
82        double lat=0.0, lon=0.0, alt=0.0, rot_x=0.0, rot_y=0.0, rot_z=0.0;
83        double cam_trans_x=0.0, cam_trans_y=0.0, cam_trans_z=0.0, cam_rot_x=0.0, cam_rot_y=0.0, cam_rot_z=0.0;
84        double geometry_rot_x=0.0, geometry_rot_y=0.0, geometry_rot_z=0.0;
85        double geometry_scale_x=1.0, geometry_scale_y=1.0, geometry_scale_z=1.0;
86        osg::ref_ptr<osgVisual::object_updater> updater = NULL;
87        std::string updater_lat="", updater_lon="", updater_alt="", updater_rot_x="", updater_rot_y="", updater_rot_z="", updater_label="";
88
89        // extract model properties
90        xmlAttr  *attr = a_node->properties;
91        while ( attr ) 
92        { 
93                std::string attr_name=reinterpret_cast<const char*>(attr->name);
94                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
95                if( attr_name == "objectname" ) objectname = attr_value;
96                if( attr_name == "label" ) label = attr_value;
97                if( attr_name == "dynamic" ) 
98                {
99                        if(attr_value=="yes")
100                                dynamic=true;
101                        else
102                                dynamic=false;
103                }
104                attr = attr->next; 
105        }
106        for (xmlNode *cur_node = a_node->children; cur_node; cur_node = cur_node->next)
107        {
108                std::string node_name=reinterpret_cast<const char*>(cur_node->name);
109
110                if(cur_node->type == XML_ELEMENT_NODE && node_name == "position")
111                {
112                        xmlAttr  *attr = cur_node->properties;
113                        while ( attr ) 
114                        { 
115                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
116                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
117                                if( attr_name == "lat" )
118                                {
119                                        std::stringstream sstr(attr_value);
120                                        sstr >> lat;
121                                }
122                                if( attr_name == "lon" )
123                                {
124                                        std::stringstream sstr(attr_value);
125                                        sstr >> lon;
126                                }
127                                if( attr_name == "alt" ) 
128                                {
129                                        std::stringstream sstr(attr_value);
130                                        sstr >> alt;
131                                }
132                                attr = attr->next; 
133                        }
134                }
135
136                if(cur_node->type == XML_ELEMENT_NODE && node_name == "attitude")
137                {
138                        xmlAttr  *attr = cur_node->properties;
139                        while ( attr ) 
140                        { 
141                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
142                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
143                                if( attr_name == "rot_x" )
144                                {
145                                        std::stringstream sstr(attr_value);
146                                        sstr >> rot_x;
147                                }
148                                if( attr_name == "rot_y" )
149                                {
150                                        std::stringstream sstr(attr_value);
151                                        sstr >> rot_y;
152                                }
153                                if( attr_name == "rot_z" ) 
154                                {
155                                        std::stringstream sstr(attr_value);
156                                        sstr >> rot_z;
157                                }
158                                attr = attr->next; 
159                        }
160                }
161
162                if(cur_node->type == XML_ELEMENT_NODE && node_name == "updater")
163                {
164                        for (xmlNode *sub_cur_node = cur_node->children; sub_cur_node; sub_cur_node = sub_cur_node->next)
165                        {
166                                std::string sub_node_name=reinterpret_cast<const char*>(cur_node->children->name);
167                                if(sub_cur_node->type == XML_ELEMENT_NODE && sub_node_name == "position")
168                                {
169                                        xmlAttr  *attr = sub_cur_node->properties;
170                                        while ( attr ) 
171                                        { 
172                                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
173                                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
174                                                if( attr_name == "lat" )
175                                                        updater_lat = attr_value;
176                                                if( attr_name == "lon" )
177                                                        updater_lon = attr_value;
178                                                if( attr_name == "alt" ) 
179                                                        updater_alt = attr_value;
180                                                attr = attr->next; 
181                                        }
182                                }
183                                if(sub_cur_node->type == XML_ELEMENT_NODE && sub_node_name == "attitude")
184                                {
185                                        xmlAttr  *attr = sub_cur_node->properties;
186                                        while ( attr ) 
187                                        { 
188                                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
189                                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
190                                                if( attr_name == "rot_x" )
191                                                        updater_rot_x = attr_value;
192                                                if( attr_name == "rot_y" )
193                                                        updater_rot_y = attr_value;
194                                                if( attr_name == "rot_z" ) 
195                                                        updater_rot_z = attr_value;
196                                                attr = attr->next; 
197                                        }
198                                }
199                                if(sub_cur_node->type == XML_ELEMENT_NODE && sub_node_name == "label")
200                                {
201                                        xmlAttr  *attr = sub_cur_node->properties;
202                                        while ( attr ) 
203                                        { 
204                                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
205                                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
206                                                if( attr_name == "text" )
207                                                        updater_label = attr_value;
208                                                attr = attr->next; 
209                                        }
210                                }
211                        }
212                }
213
214                if(cur_node->type == XML_ELEMENT_NODE && node_name == "cameraoffset")
215                {
216                        for (xmlNode *sub_cur_node = cur_node->children; sub_cur_node; sub_cur_node = sub_cur_node->next)
217                        {
218                                std::string sub_node_name=reinterpret_cast<const char*>(cur_node->children->name);
219                                if(sub_cur_node->type == XML_ELEMENT_NODE && sub_node_name == "translation")
220                                {
221                                        xmlAttr  *attr = sub_cur_node->properties;
222                                        while ( attr ) 
223                                        { 
224                                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
225                                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
226                                                if( attr_name == "trans_x" )
227                                                {
228                                                        std::stringstream sstr(attr_value);
229                                                        sstr >> cam_trans_x;
230                                                }
231                                                if( attr_name == "trans_y" )
232                                                {
233                                                        std::stringstream sstr(attr_value);
234                                                        sstr >> cam_trans_y;
235                                                }
236                                                if( attr_name == "trans_z" )
237                                                {
238                                                        std::stringstream sstr(attr_value);
239                                                        sstr >> cam_trans_y;
240                                                }
241                                                attr = attr->next; 
242                                        }
243                                }
244                                if(sub_cur_node->type == XML_ELEMENT_NODE && sub_node_name == "rotation")
245                                {
246                                        xmlAttr  *attr = sub_cur_node->properties;
247                                        while ( attr ) 
248                                        { 
249                                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
250                                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
251                                                if( attr_name == "rot_x" )
252                                                {
253                                                        std::stringstream sstr(attr_value);
254                                                        sstr >> cam_rot_x;
255                                                }
256                                                if( attr_name == "rot_y" )
257                                                {
258                                                        std::stringstream sstr(attr_value);
259                                                        sstr >> cam_rot_y;
260                                                }
261                                                if( attr_name == "rot_z" )
262                                                {
263                                                        std::stringstream sstr(attr_value);
264                                                        sstr >> cam_rot_y;
265                                                }
266                                                attr = attr->next; 
267                                        }
268                                }
269                        }
270                }
271
272                if(cur_node->type == XML_ELEMENT_NODE && node_name == "geometry")
273                {
274                        // extract filename
275                        xmlAttr  *attr = cur_node->properties;
276                        while ( attr ) 
277                        { 
278                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
279                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
280                                if( attr_name == "filename" )
281                                        filename = attr_value;
282                                attr = attr->next; 
283                        }
284
285                        // Extract optional settings
286                        for (xmlNode *sub_cur_node = cur_node->children; sub_cur_node; sub_cur_node = sub_cur_node->next)
287                        {
288                                std::string sub_node_name=reinterpret_cast<const char*>(sub_cur_node->name);
289                                if(sub_cur_node->type == XML_ELEMENT_NODE && sub_node_name == "offset")
290                                {
291                                        xmlAttr  *attr = sub_cur_node->properties;
292                                        while ( attr ) 
293                                        { 
294                                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
295                                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
296                                                if( attr_name == "rot_x" )
297                                                {
298                                                        std::stringstream sstr(attr_value);
299                                                        sstr >> geometry_rot_x;
300                                                }
301                                                if( attr_name == "rot_y" )
302                                                {
303                                                        std::stringstream sstr(attr_value);
304                                                        sstr >> geometry_rot_y;
305                                                }
306                                                if( attr_name == "rot_z" )
307                                                {
308                                                        std::stringstream sstr(attr_value);
309                                                        sstr >> geometry_rot_z;
310                                                }
311                                                attr = attr->next; 
312                                        }
313                                }
314                                if(sub_cur_node->type == XML_ELEMENT_NODE && sub_node_name == "scalefactor")
315                                {
316                                        xmlAttr  *attr = sub_cur_node->properties;
317                                        while ( attr ) 
318                                        { 
319                                                std::string attr_name=reinterpret_cast<const char*>(attr->name);
320                                                std::string attr_value=reinterpret_cast<const char*>(attr->children->content);
321                                                if( attr_name == "scale_x" )
322                                                {
323                                                        std::stringstream sstr(attr_value);
324                                                        sstr >> geometry_scale_x;
325                                                }
326                                                if( attr_name == "scale_y" )
327                                                {
328                                                        std::stringstream sstr(attr_value);
329                                                        sstr >> geometry_scale_y;
330                                                }
331                                                if( attr_name == "scale_z" )
332                                                {
333                                                        std::stringstream sstr(attr_value);
334                                                        sstr >> geometry_scale_z;
335                                                }
336                                                attr = attr->next; 
337                                        }
338                                }
339                        }
340                }
341        }
342
343
344
345
346        osgVisual::visual_object* object = new osgVisual::visual_object( sceneRoot_, objectname );
347        object->lat = lat;
348        object->lon = lon;
349        object->alt = alt;
350        object->azimuthAngle_psi = rot_x;
351        object->pitchAngle_theta = rot_y;
352        object->bankAngle_phi = rot_z;
353        if(label!="")
354                object->addLabel("XML_defined_label", label);
355        if(dynamic)
356        {
357                updater = new osgVisual::object_updater(object);
358                object->addUpdater( updater );
359        }
360        object->setCameraOffset( cam_trans_x, cam_trans_y, cam_trans_z, cam_rot_x, cam_rot_y, cam_rot_z);
361        if(filename!="")
362        {
363                object->loadGeometry( filename );
364                object->setGeometryOffset( geometry_rot_x, geometry_rot_y, geometry_rot_z );
365                object->setScale( geometry_scale_x, geometry_scale_y, geometry_scale_z ); 
366        }
367
368        if(updater.valid())
369        {
370                updater->setUpdaterSlotNames( object, updater_lat, updater_lon, updater_alt, updater_rot_x, updater_rot_y, updater_rot_z, updater_label);
371        }
372
373        OSG_NOTIFY( osg::ALWAYS ) << "Done." << std::endl;
374        return object;
375}
376
377void visual_object::setNewPositionAttitude( double lat_, double lon_, double alt_, double azimuthAngle_psi_, double pitchAngle_theta_, double bankAngle_phi_ )
378{
379        lat = lat_;
380        lon = lon_;
381        alt = alt_;
382
383        azimuthAngle_psi = azimuthAngle_psi_;
384        pitchAngle_theta = pitchAngle_theta_;
385        bankAngle_phi = bankAngle_phi_;
386}
387
388void visual_object::setNewPosition( double lat_, double lon_, double alt_ )
389{
390        lat = lat_;
391        lon = lon_;
392        alt = alt_;
393}
394
395void visual_object::setNewAttitude( double azimuthAngle_psi_, double pitchAngle_theta_, double bankAngle_phi_ )
396{
397        azimuthAngle_psi = azimuthAngle_psi_;
398        pitchAngle_theta = pitchAngle_theta_;
399        bankAngle_phi = bankAngle_phi_;
400}
401
402void visual_object::setGeometryOffset( double rotX_, double rotY_, double rotZ_ )
403{
404        geometry_offset_rotation.makeRotate( rotX_, osg::Vec3f(1.0, 0.0, 0.0), 
405                                                rotY_, osg::Vec3f(0.0, 1.0, 0.0),
406                                                rotZ_, osg::Vec3f(0.0, 0.0, 1.0) );
407}
408
409void visual_object::setScale( double scale_ )
410{
411        scaleX = scale_;
412        scaleY = scale_;
413        scaleZ = scale_;
414}
415
416void visual_object::setScale( double scaleX_, double scaleY_, double scaleZ_ )
417{
418        scaleX = scaleX_;
419        scaleY = scaleY_;
420        scaleZ = scaleZ_;
421}
422
423bool visual_object::loadGeometry(std::string filename_)
424{
425        // Check if file exists
426        if( !osgDB::fileExists(filename_) )
427        {
428                OSG_NOTIFY(osg::FATAL) << "Error: Model not loaded. File '" << filename_ << "' does not exist." << std::endl;
429        }
430
431        osg::ref_ptr<osg::Node> tmpModel = osgDB::readNodeFile( filename_ );
432       
433        if( tmpModel.valid() )
434        {
435                // remove old geometry
436                geometry->removeChildren(0, geometry->getNumChildren());
437
438                // add new geometry
439                geometry->addChild( tmpModel.get() );
440                return true;
441        }
442        else
443        {
444                std::cout <<": No model loaded: " << filename_ << std::endl;
445        return false;
446    }
447}
448
449bool visual_object::setGeometry(osg::Node* geometry_)
450{
451        // remove old geometry
452        geometry->removeChildren(0, geometry->getNumChildren());
453
454        // add new geometry
455        geometry->addChild( geometry_ );
456
457        return true;
458}
459
460void visual_object::unsetGeometry()
461{
462        // remove old geometry
463        geometry->removeChildren(0, geometry->getNumChildren());
464}
465
466void visual_object::addUpdater( object_updater* updater_ )
467{
468        if ( updater.valid() )
469                updater->addUpdater( updater_ );
470        else
471                updater = updater_;
472}
473
474void visual_object::clearAllUpdater()
475{
476        // release only first updater. Because smartpointer: Will be deleted if not referenced.
477        if ( updater.valid() )
478                updater = NULL;
479}
480
481std::vector<object_updater*> visual_object::getUpdaterList()
482{
483        // iterate through updater and add all pointer.
484        std::vector<object_updater*> updaterList;
485        osg::ref_ptr<object_updater> tmpUpdater = updater;
486
487        while (tmpUpdater.valid())
488        {
489                updaterList.push_back( tmpUpdater );
490                tmpUpdater = tmpUpdater->getPointer();
491        }
492
493        // return list
494        return updaterList;
495}
496
497void visual_object::visual_objectPositionCallback::operator()(osg::Node* node, osg::NodeVisitor* nv)
498{
499        visual_object* object = dynamic_cast<visual_object*>(node);
500        if ( !object )
501        {
502                OSG_NOTIFY(osg::FATAL) << "ERROR : No object found. Unable to apply this callback!" << std::endl;
503                return;
504        }
505
506        // execute preUpdater to get new data of this object.
507        if ( object->updater.valid() )
508                object->updater->preUpdate(object);
509   
510        // Nodepath from this node to absolute parent (if no endnode specified)
511        osg::NodePath nodePath = nv->getNodePath();
512
513        // If Nodepath != empty, then mt = last element of node path
514        osg::MatrixTransform* mt = nodePath.empty() ? 0 : dynamic_cast<osg::MatrixTransform*>(nodePath.back());
515        if (mt)
516        {
517                osg::CoordinateSystemNode* csn = 0;
518
519                // find coordinate system node from our parental chain: traverse chain and try to convert every node to a csn.
520                unsigned int i;
521                for(i=0; i<nodePath.size() && csn==0; ++i)      // "&& csn" means: exit loop if csn found
522                {
523                        csn = dynamic_cast<osg::CoordinateSystemNode*>(nodePath[i]);    // dynamic_cast returns 0 if dynamic_cast fails.
524                }
525       
526                // Wenn csn gefunden:
527                if (csn)
528                {
529                        // Ellipsoidmodel erfragen
530                        osg::EllipsoidModel* ellipsoid = csn->getEllipsoidModel();
531                        if (ellipsoid)
532                        {
533                                osg::Matrix inheritedMatrix;
534
535                                // durch den _restlichen_ Nodepath durchgehen und alle anfallenden Transformationen durchführen.
536                                for(i+=1; i<nodePath.size()-1; ++i)
537                                {
538                                        osg::Transform* transform = nodePath[i]->asTransform(); // Versuchen, den Node zu einer Transformation zu konvertieren
539                   
540                                        // wenn Node wirklich Trafo, dann die Tranformationsmatrix von Nodekoordinaten nach Global auf inheritedMatrix draufschlagen.
541                                        if (transform) transform->computeLocalToWorldMatrix(inheritedMatrix, nv);
542                                }
543               
544                                osg::Matrixd matrix(inheritedMatrix);
545
546                                // Set position
547                                ellipsoid->computeLocalToWorldTransformFromLatLongHeight(object->lat, object->lon, object->alt, matrix);
548
549                                // Set Upvector for position
550                                double X,Y,Z;
551                                util::calculateXYZAtWGS84Coordinate(object->lat, object->lon, object->alt, csn, X, Y, Z );
552                                object->upVector = ellipsoid->computeLocalUpVector(X,Y,Z);
553
554                                // Set scale
555                                osg::Matrixd scaleMatrix;
556                                scaleMatrix.makeScale( object->scaleX, object->scaleY, object->scaleZ );
557                                matrix.preMult( scaleMatrix );
558
559                                // Set rotation
560                                // rotation von links ranmultiplizieren, entspricht: matrix = rotation * matrix. Da rotation ein Quat ist, wäre die direkte Multiplikation nur über Umwege machbar.
561                                // Rotate Object to Attitude.
562                                osg::Matrixd rotationMatrix;
563                                // Move Model by Azimuth
564                                rotationMatrix.makeRotate( -object->azimuthAngle_psi, osg::Vec3d(0.0, 0.0, 1.0) );
565                                matrix.preMult(rotationMatrix); 
566                                // Move Model by Pitch
567                                rotationMatrix.makeRotate( object->pitchAngle_theta, osg::Vec3d(1.0, 0.0, 0.0) );
568                                matrix.preMult(rotationMatrix);
569                                // Move Model by Bank
570                                rotationMatrix.makeRotate( object->bankAngle_phi, osg::Vec3d(0.0, 1.0, 0.0) );
571                                matrix.preMult(rotationMatrix);
572
573                                // Also update camera matrix (without geometry offset, because camera is interested in the objects matrix, not in the model's matrix.)
574                                object->cameraMatrix = matrix;
575                                /** \todo : Clean up camera matrix management: try to solve it with a single matrix. (each frame two matrix mults less) */
576                                // dont know, why this rotation is necessary - maybe manipulator and node MatrixTransform interpret a matrix in different way?
577                                object->cameraMatrix.preMult( object->cameraTranslationOffset );
578                                object->cameraMatrix.preMult( object->cameraRotationOffset );
579                                                       
580
581                                // Set geometry correction
582                                matrix.preMultRotate( object->geometry_offset_rotation );
583
584                                // Set cumulated object matrix as the matrix of this matrix transform
585                                mt->setMatrix(matrix);
586                        }
587                }       
588        }
589     
590        // Call any nested callbacks.
591        traverse(node,nv);
592
593        // If SLAVE: execute postUpdater to pass new data of this object to dataIO.
594        if( visual_dataIO::getInstance()->isSlave() )
595        {
596                if ( object->updater.valid() )
597                        object->updater->postUpdate(object);
598        }
599
600}   // Callbackfunction [ Operater() ] END
601
602void visual_object::setCameraOffsetTranslation( double x_, double y_, double z_)
603{
604        cameraTranslationOffset.makeTranslate( osg::Vec3d(x_, y_, z_) );        // Trans: (rechts davon, longitudinal, vertikal)
605}
606
607void visual_object::setCameraOffset(double x_, double y_, double z_, double rotX_, double rotY_, double rotZ_)
608{
609        setCameraOffsetTranslation( x_, y_, z_);
610        setCameraOffsetRotation( rotX_, rotY_, rotZ_);
611}
612
613void visual_object::setCameraOffsetRotation(double rotX_, double rotY_, double rotZ_)
614{
615        osg::Matrix tmp;
616        cameraRotationOffset.makeRotate( osg::DegreesToRadians( 90.0 ), osg::Vec3(1, 0, 0) );
617        tmp.makeRotate( -rotZ_, osg::Vec3d(0.0, 1.0, 0.0) );
618        cameraRotationOffset.preMult(tmp);
619        tmp.makeRotate( rotY_, osg::Vec3d(1.0, 0.0, 0.0) );     
620        cameraRotationOffset.preMult(tmp);
621        tmp.makeRotate( -rotX_, osg::Vec3d(0.0, 0.0, 1.0) );   
622        cameraRotationOffset.preMult(tmp);
623}
624
625void visual_object::clearLabels()
626{
627        labels->removeDrawables(0, labels->getNumDrawables());
628}
629
630void visual_object::addLabel(std::string idString_, std::string label_, osg::Vec4 color_, osg::Vec3 offset_)
631{
632        osg::ref_ptr<osgText::Text> text = new osgText::Text();
633
634        text->setName(idString_);
635        text->setText(label_);
636        text->setColor(color_);
637        text->setFont("fonts/arial.ttf");
638        text->setCharacterSizeMode(osgText::Text::OBJECT_COORDS_WITH_MAXIMUM_SCREEN_SIZE_CAPPED_BY_FONT_HEIGHT);
639        text->setAutoRotateToScreen(true);
640        text->setPosition(offset_);
641
642        text->getOrCreateStateSet()->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
643        labels->addDrawable( text );
644}
645
646bool visual_object::removeLabel(std::string idString_)
647{
648        osg::Node* labelToRemove = util::findNamedNode(idString_, this);
649
650        if(labelToRemove)
651        {
652                removeChild( labelToRemove );
653                return true;
654        }
655        else
656                return false;
657}
658
659bool visual_object::updateLabelText(std::string idString_, std::string label_)
660{
661        osg::Node* labelToUpdate = util::findNamedNode(idString_, this);
662
663        if(labelToUpdate)
664        {
665                osgText::Text* text = dynamic_cast<osgText::Text*>(labelToUpdate);
666                if(text)
667                {
668                        text->setText(label_);
669                        return true;
670                }
671                return false;
672        }
673        return false;
674}
675
676osgText::Text* visual_object::getLabel(std::string idString_)
677{
678        osg::Node* labelToFind = util::findNamedNode(idString_, this);
679
680        if(labelToFind)
681        {
682                osgText::Text* text = dynamic_cast<osgText::Text*>(labelToFind);
683                if(text)
684                        return text;
685        }
686        return NULL;
687
688}
689
690bool visual_object::setDrawLabelAsOverlay(std::string idString_, bool drawAsOverlay)
691{
692        osg::Node* labelToFind = util::findNamedNode(idString_, this);
693
694        if(labelToFind)
695        {
696                if (drawAsOverlay)
697                        labelToFind->getOrCreateStateSet()->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
698                else
699                        labelToFind->getOrCreateStateSet()->setMode(GL_DEPTH_TEST,osg::StateAttribute::ON);
700                return true;
701        }
702        else 
703                return false;
704}
705
706bool visual_object::getDrawLabelAsOverlay(std::string idString_)
707{
708        osg::Node* labelToFind = util::findNamedNode(idString_, this);
709
710        if(labelToFind)
711        {
712                if(labelToFind->getOrCreateStateSet()->getMode(GL_DEPTH_TEST) == osg::StateAttribute::OFF)
713                        return false;
714                else 
715                        return true;
716        }
717        return false;
718}
Note: See TracBrowser for help on using the repository browser.