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

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

Network sync:
now works:

  • serialization of transport container
  • transport via ENet UDP
  • de-serialization of the transport container.
  • transport of viewmatrix and framenumber to the slave.

ToDo?: apply viewmatrix on slave still do not work.

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