source: osgVisual/trunk/include/dataIO/visual_dataIO.h @ 311

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

Now the trackingID can be updated by the external Link.

File size: 6.3 KB
Line 
1#pragma once
2/* -*-c++-*- osgVisual - Copyright (C) 2009-2011 Torben Dannhauer
3 *
4 * This library is based on OpenSceneGraph, open source and may be redistributed and/or modified under
5 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
6 * (at your option) any later version.  The full license is in LICENSE file
7 * included with this distribution, and on the openscenegraph.org website.
8 *
9 * osgVisual requires for some proprietary modules a license from the correspondig manufacturer.
10 * You have to aquire licenses for all used proprietary modules.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * OpenSceneGraph Public License for more details.
16*/
17
18#include <osg/Notify>
19#include <osg/Referenced>
20#include <osg/ArgumentParser>
21
22#include <osgViewer/Viewer>
23
24// osgVisual specifiy includes
25#include <visual_util.h>
26
27// Cluster
28#include <dataIO_clusterDummy.h>
29#ifdef USE_CLUSTER_ASIO_TCP_IOSTREAM
30        #include <dataIO_clusterAsioTcpIostream.h>
31#endif
32#ifdef USE_CLUSTER_ENET
33        #include <dataIO_clusterENet.h>
34#endif
35       
36
37
38
39//ExtLink
40#include <dataIO_extLinkDummy.h>
41#ifdef USE_EXTLINK_VCL
42        #include <dataIO_extLinkVCL.h>
43#endif
44
45
46// Slot and transportContainer definitions
47#include <dataIO_slot.h>
48#include <dataIO_transportContainer.h>
49
50// XML Parser
51#include <stdio.h>
52#include <libxml/parser.h>
53#include <libxml/tree.h>
54
55// C++ stl libraries
56#include <vector>
57
58
59
60
61namespace osgVisual {
62
63/**
64 * \brief Zentrale Klasse für Datenanbindung des Sichtsystemnodes an das Gesamtsichtsystem bzw. dem Simulator.
65 *
66 * Damit nur eine Klasse instantiiert werden kann, ist diese Klasse als Singleton realisiert.
67 *
68 *
69 * @author Torben Dannhauer
70 * @date  Nov 2009
71 */ 
72class visual_dataIO : public osg::Referenced
73{
74        #include <leakDetection.h>
75private:
76        class dataIO_eventCallback : public osg::NodeCallback
77        {
78        public: 
79                /**
80                 * \brief Constructor, for setting the member variables.
81                 *
82                 * @param dataIO_ : Pointer to the dataIO class.
83                 */ 
84                dataIO_eventCallback(visual_dataIO* dataIO_):dataIO(dataIO_){};
85
86                /**
87                 * \brief This function is executed as callback during event traversal.
88                 *
89                 */ 
90                virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
91        private:
92                visual_dataIO* dataIO;
93        };
94        osg::ref_ptr<dataIO_eventCallback> eventCallback;
95
96        class dataIO_finalDrawCallback : public osg::Camera::DrawCallback
97        {
98        public:
99                /**
100                 * \brief Constructor
101                 *
102                 */ 
103                dataIO_finalDrawCallback(visual_dataIO* dataIO_):dataIO(dataIO_){};
104               
105                /**
106                 * \brief Operator executed at callback
107                 *
108                 */ 
109                virtual void operator () (const osg::Camera& camera) const;
110        private:
111                visual_dataIO* dataIO;
112        };
113
114        osg::ref_ptr<dataIO_finalDrawCallback> finalDrawCallback;
115
116        /**
117         * \brief Constructor: It is private to prevent creating instances via ptr* = new ..().
118         *
119         */ 
120        visual_dataIO();
121
122        /**
123         * \brief Copy-Constuctor: It is private to prevent getting instances via copying dataIO instance.
124         *
125         * @param cc : Instance to copy from.
126         */ 
127        visual_dataIO(const visual_dataIO& cc);
128
129        /**
130         * \brief This function parses the XML config file for dataIO relevant parameters.
131         *
132         * @return : True if parsing was successful.
133         */ 
134        bool processXMLConfiguration(); 
135
136        /**
137         * \brief Todo: required?
138         *
139         * @return
140         */ 
141        osg::Matrixd calcViewMatrix();
142
143        /**
144         * Pointer to the base class of the extLink implementation.
145         */ 
146        osg::ref_ptr<dataIO_extLink> extLink;
147
148        /**
149         * Pointer to the base class of the cluster implementation.
150         */ 
151        osg::ref_ptr<dataIO_cluster> cluster;
152
153        /**
154         * Referenced pointer to the applications viewer.
155         */ 
156        osg::ref_ptr<osgViewer::Viewer> viewer;
157
158        /**
159         * Referenced pointer transport contained user to transport the set of all slots to all rendering machines.
160         */ 
161        osg::ref_ptr<osgVisual::dataIO_transportContainer> slotContainer;
162
163        /**
164         * List of SLOT variables dataIO provides.
165         */ 
166        std::vector<dataIO_slot*> dataSlots;
167
168        /**
169         * Flag to indicate if dataIO is initialized.
170         */ 
171        bool initialized;
172
173        /**
174         * Curent clustermode of the application. Can be MASTER, SLAVE or STANDALONE.
175         */ 
176        osgVisual::dataIO_cluster::clustermode clusterMode;
177
178        /**
179         * XML config filename
180         */ 
181        std::string configFileName;
182
183        /**
184         * The eventCallback-class is friend to be able to work with all dataIO members without setters/getters.
185         */ 
186        friend class dataIO_eventCallback;
187
188        /**
189         *  The FinalDrawCallback-class is friend to be able to work with all dataIO members without setters/getters.
190         */ 
191        friend class dataIO_finalDrawCallback;
192
193public:
194        /**
195         * \brief Public destructor to allow singleton cleanup from extern
196         *
197         */ 
198        ~visual_dataIO();
199
200        /**
201         * \brief This function returns an pointer to the singleton instance of dataIO. If no instance exist, it will be instantiated silently.
202         *
203         * After instantiation, dataIO still needs to bei initiialized to configure working mode etc!
204         *
205         * @return : Pointer to the instance.
206         */ 
207        static visual_dataIO* getInstance();
208
209        void init(osgViewer::Viewer* viewer_, std::string configFileName);
210        void shutdown();
211        bool isMaster(){if (clusterMode==osgVisual::dataIO_cluster::MASTER) return true; else return false;};
212        bool isSlave(){if (clusterMode==osgVisual::dataIO_cluster::SLAVE) return true; else return false;};
213        bool isStandalone(){if (clusterMode==osgVisual::dataIO_cluster::STANDALONE) return true; else return false;};
214
215// SLOT Access functions
216        void* getSlotPointer(std::string slotName_, osgVisual::dataIO_slot::dataDirection direction_, osgVisual::dataIO_slot::varType variableTyp_ );
217        double getSlotDataAsDouble(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_ );
218        std::string getSlotDataAsString(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_ );
219        osgVisual::dataIO_slot* setSlotData(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_, std::string sValue_ );
220        osgVisual::dataIO_slot* setSlotData(std::string variableName_, osgVisual::dataIO_slot::dataDirection direction_, double value_ );
221
222        int getSlotNum() {return dataSlots.size();}
223
224};
225
226
227} // END namespace osgVisual
Note: See TracBrowser for help on using the repository browser.