Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/netp6/src/network/synchronisable/SynchronisableVariable.h @ 4932

Last change on this file since 4932 was 3240, checked in by scheusso, 15 years ago

a lot of cleanup
some bugfixes (Thread, ThreadPool)
the biggest part of the network (~80% cpu time) is now multithreaded (1 thread for each client)

  • Property svn:eol-style set to native
File size: 8.2 KB
RevLine 
[2245]1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
[3084]23 *      Oliver Scheuss
[2245]24 *   Co-authors:
25 *      ...
26 *
27 */
28
29
[3214]30#ifndef _SynchronisableVariable_H__
31#define _SynchronisableVariable_H__
[2245]32
[2307]33#include "network/NetworkPrereqs.h"
34
35#include <cassert>
[3214]36#include <cstring>
[3084]37#include "util/Serialise.h"
38#include "core/GameMode.h"
[2309]39#include "network/synchronisable/NetworkCallbackManager.h"
[2245]40
41namespace orxonox{
42 
43  namespace variableDirection{
44    enum syncdirection{
45      toclient=0x1,
46      toserver=0x2
47    };
48    enum bidirectional{
49      serverMaster=0x1,
50      clientMaster=0x2
51    };
52  }
53 
54  class _NetworkExport SynchronisableVariableBase
55  {
56    public:
[3084]57      virtual uint32_t getData(uint8_t*& mem, uint8_t mode)=0;
[2245]58      virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false)=0;
59      virtual uint32_t getSize(uint8_t mode)=0;
60      virtual void* getReference()=0;
61      virtual uint8_t getMode()=0;
62      virtual ~SynchronisableVariableBase() {}
63    protected:
64      static uint8_t state_;
65  };
66
67  template <class T>
[2307]68  class SynchronisableVariable: public SynchronisableVariableBase
[2245]69  {
70    public:
71      SynchronisableVariable(T& variable, uint8_t syncDirection=variableDirection::toclient, NetworkCallbackBase *cb=0);
72      virtual ~SynchronisableVariable();
73
74      virtual inline uint8_t getMode(){ return mode_; }
[3084]75      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
[2307]76      virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
[2575]77      virtual inline uint32_t getSize(uint8_t mode);
[2307]78      virtual inline void* getReference(){ return (void *)&this->variable_; }
[2245]79    protected:
80     
81      T& variable_;
82      uint8_t mode_;
83      NetworkCallbackBase *callback_;
84  };
85 
86  template <class T>
[2307]87  class SynchronisableVariableBidirectional: public SynchronisableVariable<T>
[2245]88  {
89    public:
90      SynchronisableVariableBidirectional(T& variable, uint8_t master=variableDirection::serverMaster, NetworkCallbackBase *cb=0);
91      virtual ~SynchronisableVariableBidirectional();
92     
93      virtual inline uint8_t getMode(){ return 0x3; } //this basically is a hack ^^
[3084]94      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
[2245]95      virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
[3084]96      virtual inline uint32_t getSize(uint8_t mode);
[2245]97    private:
98      T varBuffer_;
99      uint8_t varReference_;
100  };
101
102  // ================= Unidirectional Part ===============
103
104  template <class T> SynchronisableVariable<T>::SynchronisableVariable(T& variable, uint8_t syncDirection, NetworkCallbackBase *cb):
105      variable_( variable ), mode_( syncDirection ), callback_( cb )
106  {
[3084]107    if ( state_ == 0x0 )
108    {
109      state_ = GameMode::isMaster() ? 0x1 : 0x2;  // set the appropriate mode here
110    }
[2245]111  }
112 
113  template <class T> SynchronisableVariable<T>::~SynchronisableVariable()
114  {
115    if (this->callback_ != 0)
[3240]116    {
[2309]117      NetworkCallbackManager::deleteCallback(this->callback_); //safe call for deletion
[3240]118      // this is neccessary because for example for a Vector3 all 3 components of the vector use the same callback
119    }
[2245]120  }
121
[3084]122  template <class T> inline uint32_t SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
[2245]123  {
[3102]124    if ( mode == this->mode_ )
[3084]125    {
126      saveAndIncrease( this->variable_, mem );
127      return returnSize( this->variable_ );
128    }
129    else
130      return 0;
[2245]131  }
132
133  template <class T> void SynchronisableVariable<T>::putData(uint8_t*& mem, uint8_t mode, bool forceCallback)
134  {
135    assert ( mode == 0x1 || mode == 0x2 );
136    bool callback = false;
137    if ( mode == this->mode_ ) //don't do anything
138      return;
139  // check whether we need to consider a callback
140    if ( this->callback_ != 0 )
141    {
[3084]142      if( forceCallback || !checkEquality( this->variable_, mem ) )
[2245]143        callback = true;
144    }
145  // write the data
[3084]146    loadAndIncrease( this->variable_, mem );
[2245]147  // now do a callback if neccessary
148    if ( callback )
[2309]149      NetworkCallbackManager::triggerCallback( this->callback_ );
[2245]150  }
151
[3084]152  template <class T> inline uint32_t SynchronisableVariable<T>::getSize(uint8_t mode)
[2245]153  {
154    if ( mode == this->mode_ )
[3084]155      return returnSize( this->variable_ );
[2245]156    else
157      return 0;
158  }
159
160
[2307]161
162
[2245]163// ================= Bidirectional Part ================
164
165    template <class T> SynchronisableVariableBidirectional<T>::SynchronisableVariableBidirectional(T& variable, uint8_t master, NetworkCallbackBase *cb):
166    SynchronisableVariable<T>( variable, master, cb ), varBuffer_( variable ), varReference_( 0 )
167    {
168    }
169
170    template <class T> SynchronisableVariableBidirectional<T>::~SynchronisableVariableBidirectional()
171    {
172    }
173
[3084]174    template <class T> uint32_t SynchronisableVariableBidirectional<T>::getData(uint8_t*& mem, uint8_t mode)
[2245]175    {
176      if ( this->mode_ == mode )
177      {   // we are master for this variable and have to check whether to change the varReference
178        if( this->varBuffer_ != this->variable_ )
179        {
180          this->varReference_++;
181          memcpy((void*)&this->varBuffer_, &this->variable_, sizeof(this->variable_));
182        }
183      }
184  // write the reference number to the stream
185      *static_cast<uint8_t*>(mem) = varReference_;
186      mem += sizeof(this->varReference_);
187  // now write the content
[3084]188      saveAndIncrease( this->variable_, mem );
189      return SynchronisableVariableBidirectional::getSize(mode);
[2245]190    }
191
192    template <class T> void SynchronisableVariableBidirectional<T>::putData(uint8_t*& mem, uint8_t mode, bool forceCallback)
193    {
194      bool callback = false;
195      if ( this->mode_ == mode )
196      {   //        MASTER
197        // check that the client (source of the data) has a recent version of this variable
198        if ( *static_cast<uint8_t*>(mem) != this->varReference_ )
199        { // wrong reference number, so discard the data
[3084]200//           COUT(0) << "discharding data" << endl;
[2245]201          mem += getSize( mode ); // SynchronisableVariableBidirectional::getSize returns size of variable + reference
202          return;
203        }
204        else{
205          // apply data
[3084]206          if ( checkEquality( this->variable_, mem+sizeof(varReference_) )==true )
[2245]207          {
[3084]208            mem += getSize( mode );
[2245]209            return;
210          }
211          else
212          {
[3084]213            mem += sizeof(varReference_);
[2245]214            memcpy((void*)&this->varBuffer_, &this->variable_, sizeof(T));
215            if ( this->callback_ != 0 )
216              callback = true;
217          }
218        }
219      }
220      else
221      {   // we are slave for this variable
222        if (*static_cast<uint8_t*>(mem) == this->varReference_ && !forceCallback)
223        {
224          mem += getSize( mode ); //just skip the variable because nothing changed
225          return;
226        }
227        else
228        {
229          this->varReference_ = *static_cast<uint8_t*>(mem);
230          mem += sizeof(varReference_);
[3084]231          if ( checkEquality( this->variable_, mem ) == false )
[2245]232          {
233            // value changed so remark for callback
234            if ( this->callback_ != 0 )
235              callback = true;
236          }
237        }
238      }
239  // now write the data
[3084]240      loadAndIncrease(this->variable_, mem);
[2245]241  // now do a callback if neccessary
242      if ( callback )
[2309]243        NetworkCallbackManager::triggerCallback( this->callback_ );
[2245]244    }
245
[3084]246    template <class T> inline uint32_t SynchronisableVariableBidirectional<T>::getSize(uint8_t mode)
[2245]247    {
[3084]248      return returnSize( this->variable_ ) + sizeof(varReference_);
[2245]249    }
250 
251
252}
253
254
[3214]255#endif /* _SynchronisableVariable_H__ */
Note: See TracBrowser for help on using the repository browser.