source: osgVisual/src/dataIO/visual_dataIO.cpp @ 66

Last change on this file since 66 was 65, checked in by Torben Dannhauer, 14 years ago

new cluster implementation added: ENet
ENet is a reliable UDP implementation with quite simple usage and high performance for transmission with small or medium size packet.
File size: 9.7 KB
RevLine 
[31]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_dataIO.h"
18
19using namespace osgVisual;
20
21visual_dataIO::visual_dataIO()
22{
23        OSG_NOTIFY( osg::ALWAYS ) << "visual_dataIO constructed" << std::endl;
24
25        initialized = false;
26}
27
28visual_dataIO::~visual_dataIO()
29{
30        OSG_NOTIFY( osg::ALWAYS ) << "visual_dataIO destructed" << std::endl;
31}
32
33visual_dataIO* visual_dataIO::getInstance()
34{
35        static visual_dataIO instance; 
36        return &instance; 
37};
38
39void visual_dataIO::init(osgViewer::Viewer* viewer_, osg::ArgumentParser& arguments_)
40{
41        OSG_NOTIFY( osg::ALWAYS ) << "visual_dataIO init()" << std::endl;
42
43        // Init variables
44        viewer = viewer_;
45
46        // Parse operating Mode
47    if (arguments_.read("-m"))
48        {
49                OSG_NOTIFY( osg::ALWAYS ) << "Configure osgVisual as MASTER" << std::endl;
50                clusterMode = osgVisual::dataIO_cluster::MASTER;
51                // Create Container:
52                slotContainer = new osgVisual::dataIO_transportContainer();
53        }
54        else if (arguments_.read("-s"))
55        {
56                OSG_NOTIFY( osg::ALWAYS ) << "Configure osgVisual as SLAVE" << std::endl;
57                clusterMode = osgVisual::dataIO_cluster::SLAVE;
58                // Slave only recieves container, therefor set this Pointer null.
59                slotContainer = NULL;
60        }
61        else
62        {
63                OSG_NOTIFY( osg::ALWAYS ) << "Configure osgVisual as STANDALONE" << std::endl;
64                clusterMode = osgVisual::dataIO_cluster::STANDALONE;
65                // Create Container:
66                slotContainer = new osgVisual::dataIO_transportContainer();
67        }
68
69        // Create Cluster.
70        #ifdef USE_CLUSTER_DUMMY
71                cluster = new dataIO_clusterDummy();
72        #endif
[58]73        #ifdef USE_CLUSTER_ASIO_TCP_IOSTREAM
74                cluster = new dataIO_clusterAsioTcpIostream();
75        #endif
[31]76        #ifdef USE_CLUSTER_UDP
77                cluster = new dataIO_clusterUDP();
78        #endif
[65]79        #ifdef USE_CLUSTER_ENET
80                cluster = new dataIO_clusterENet();
81        #endif
82        if(cluster.valid())
83                cluster->init(arguments_, clusterMode, slotContainer, true, false);
[31]84
85        // Create extLink.
86        #ifdef USE_EXTLINK_DUMMY
87                extLink = new dataIO_extLinkDummy( dataSlots );
88        #endif
89        #ifdef USE_EXTLINK_VCL
90                extLink = new dataIO_extLinkVCL( dataSlots );
91        #endif
92        extLink->init();
93
94       
95
96        // Install callbacks to perform DataIO activities every frame:
97        //// EventCallback at the absolute beginning of the frame
98        eventCallback = new dataIO_eventCallback(this);
99        viewer->getCamera()->setEventCallback( eventCallback );
100        //// FinalDrawCallback at the end of event and update handling, but BEFORE rendering the frame
101        finalDrawCallback = new dataIO_finalDrawCallback(this);
102        viewer->getCamera()->setFinalDrawCallback( finalDrawCallback );
103
104
105        initialized = true;
106}
107
108void visual_dataIO::shutdown()
109{
110        if(initialized)
111        {
112                OSG_NOTIFY( osg::ALWAYS ) << "Shutdown visual_dataIO..." << std::endl;
113
114                viewer->getCamera()->removeEventCallback( NULL );
115                eventCallback = NULL;
116                viewer->getCamera()->setFinalDrawCallback( NULL );
117                finalDrawCallback = NULL;
118                viewer = NULL;
119
[65]120                if(cluster.valid())
121                        cluster->shutdown();
122                if(extLink.valid())
[31]123                extLink->shutdown();
124        }
125}
126
127void visual_dataIO::dataIO_eventCallback::operator()(osg::Node* node, osg::NodeVisitor* nv)
128{
129        // perform all actions for the eventDrawCallback.
130        OSG_NOTIFY( osg::INFO ) << "---- Executing EventCallback.." <<  std::endl;
131
132        switch( dataIO->clusterMode )
133        {
134                case osgVisual::dataIO_cluster::MASTER : 
135                        {
136                                dataIO->extLink->readTO_OBJvalues();
137                                dataIO->cluster->sendTO_OBJvaluesToSlaves();
138                        }
139                        break;
140                case osgVisual::dataIO_cluster::SLAVE : 
141                        {
142                                dataIO->cluster->readTO_OBJvaluesFromMaster();
143                        }
144                        break;
145                case osgVisual::dataIO_cluster::STANDALONE : 
146                        {
147                                dataIO->extLink->readTO_OBJvalues();
148                        }
149                        break;
150                default:
151                        OSG_NOTIFY( osg::FATAL ) << "ERROR: Unkown clustermode!" <<  std::endl;
152                        break;
153        };
154}
155
156void visual_dataIO::dataIO_finalDrawCallback::operator() (const osg::Camera& camera) const
157{
158        // perform all actions for the initialDrawCallback.
159        OSG_NOTIFY( osg::INFO ) << "---- Executing InitialDrawCallback.." << std::endl;
160
161        switch( dataIO->clusterMode )
162        {
163                case osgVisual::dataIO_cluster::MASTER : 
164                        {
165                                dataIO->extLink->writebackFROM_OBJvalues();
166                                dataIO->cluster->waitForAllReadyToSwap();
167                                dataIO->cluster->sendSwapCommand();
168                        }
169                        break;
170                case osgVisual::dataIO_cluster::SLAVE : 
171                        {
172                                dataIO->cluster->reportAsReadyToSwap();
173                                dataIO->cluster->waitForSwap();
174                        }
175                        break;
176                case osgVisual::dataIO_cluster::STANDALONE : 
177                        {
178                                dataIO->extLink->writebackFROM_OBJvalues();
179                        }
180                        break;
181                default:
182                        OSG_NOTIFY( osg::FATAL ) << "ERROR: visual_dataIO::dataIO_finalDrawCallback::operator() - Unkown clustermode!" <<  std::endl;
183                        break;
184        };
185}
186
187void* visual_dataIO::getSlotPointer(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_, osgVisual::dataIO_slot::varType variableTyp_ )
188{
189        // iterate through slotlist. If found, return pointer, else add slot to list and return pointer
190        for (unsigned int i=0; i<dataSlots.size(); i++)
191        {
192                // Check if this variable name&-type already exists
193                if( dataSlots[i].variableName == variableName_ && dataSlots[i].direction == direction_  && dataSlots[i].variableType ==  variableTyp_)
194                {
195                        //OSG_NOTIFY( osg::INFO ) << "visual_dataIO::getSlotPointer() - Slot found at position " << i << std::endl;
196                        // Return pointer to the value
197                        if (variableTyp_ == osgVisual::dataIO_slot::STRING )
198                                return &(dataSlots[i].sValue);
199                        else
200                                return &(dataSlots[i].value);
201                }
202        }
203
204        // Slot does not exist -> add it to slot list
205        //OSG_NOTIFY( osg::INFO ) << "visual_dataIO::getSlotPointer() - Slot not found, will add as new slot " << std::endl;
206        dataIO_slot newSlot;
207        newSlot.variableName = variableName_;
208        newSlot.variableType = variableTyp_;
209        newSlot.value = 0;
210        newSlot.sValue = "";
211        dataSlots.push_back( newSlot );
212        if (variableTyp_ == osgVisual::dataIO_slot::STRING )
213                return &(dataSlots.back().sValue);
214        else
215        {
216                return &(dataSlots.back().value);
217        }
218}
219
220double visual_dataIO::getSlotDataAsDouble(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_ )
221{
222        // iterate through slotlist. If found, return value
223        for (unsigned int i=0; i<dataSlots.size(); i++)
224        {
225                // Check if this variable name&-type already exists
226                if( dataSlots[i].variableName == variableName_ && dataSlots[i].direction == direction_  && dataSlots[i].variableType == osgVisual::dataIO_slot::DOUBLE )
227                {
228                        //OSG_NOTIFY( osg::INFO ) << "visual_dataIO::getSlotDataAsDouble() - Slot found at position " << i << std::endl;
229                        return dataSlots[i].value;
230                }
231        }
232        return 0;
233}
234
235std::string visual_dataIO::getSlotDataAsString(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_ )
236{
237        // iterate through slotlist. If found, return value
238        for (unsigned int i=0; i<dataSlots.size(); i++)
239        {
240                // Check if this variable name&-type already exists
241                if( dataSlots[i].variableName == variableName_ && dataSlots[i].direction == direction_  && dataSlots[i].variableType == osgVisual::dataIO_slot::STRING )
242                {
243                        //OSG_NOTIFY( osg::INFO ) << "visual_dataIO::getSlotDataAsDouble() - Slot found at position " << i << std::endl;
244                        return dataSlots[i].sValue;
245                }
246        }
247        return "";
248}
249
250void visual_dataIO::setSlotData(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_, std::string sValue_ )
251{
252        bool slotFound = false;
253        // iterate through slotlist. If found, return pointer, else add slot to list
254        for (unsigned int i=0; i<dataSlots.size(); i++)
255        {
256                // Check if this variable name&-type already exists
257                if( dataSlots[i].variableName == variableName_ && dataSlots[i].direction == direction_ && dataSlots[i].variableType ==  osgVisual::dataIO_slot::STRING)
258                {
259                        // Update value
260                        dataSlots[i].sValue = sValue_;
261                        slotFound = true;
262                }
263               
264        }
265
266        if (!slotFound)
267        {
268                // Slot does not exist -> add it to slot list
269                dataIO_slot newSlot;
270                newSlot.variableName = variableName_;
271                newSlot.direction = direction_;
272                newSlot.variableType = osgVisual::dataIO_slot::STRING;
273                newSlot.value = 0;
274                newSlot.sValue = sValue_;
275                dataSlots.push_back( newSlot );
276        }
277}
278
279void visual_dataIO::setSlotData(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_, double value_ )
280{
281        // iterate through slotlist. If found, return pointer, else add slot to list
282        bool slotFound = false;
283        for (unsigned int i=0; i<dataSlots.size(); i++)
284        {
285                // Check if this variableName & -type already exists
286                if( dataSlots[i].variableName == variableName_ && dataSlots[i].direction == direction_ && dataSlots[i].variableType ==  osgVisual::dataIO_slot::DOUBLE)
287                {
288                        // Update value
289                        //OSG_NOTIFY( osg::ALWAYS ) << "setSlotData: " << variableName_ << " - value: " << value_ << std::endl;
290                        dataSlots[i].value = value_;
291                        slotFound = true;
292                }       
293        }
294
295        if (!slotFound)
296        {
297                // Slot does not exist -> add it to slot list
298                dataIO_slot newSlot;
299                newSlot.variableName = variableName_;
300                newSlot.direction = direction_;
301                newSlot.variableType = osgVisual::dataIO_slot::DOUBLE;
302                newSlot.value = value_;
303                newSlot.sValue = "";
304                dataSlots.push_back( newSlot );
305        }
306}
Note: See TracBrowser for help on using the repository browser.