Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 6815 in orxonox.OLD for trunk/src/lib


Ignore:
Timestamp:
Jan 28, 2006, 5:11:51 PM (19 years ago)
Author:
bensch
Message:

orxonox/trunk: merged branches/network back to the trunk.
merged with command:
svn merge ​https://svn.orxonox.net/orxonox/branches/network . -r6774:HEAD

no conflicts…
thats what i call orthogonal work

Location:
trunk/src/lib
Files:
12 edited
4 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/coord/p_node.cc

    r6780 r6815  
    10771077  SYNCHELP_READ_BEGIN();
    10781078
    1079   SYNCHELP_READ_FKT( BaseObject::writeState );
     1079  SYNCHELP_READ_FKT( BaseObject::writeState, NWT_PN_BO_WRITESTATE );
    10801080
    10811081//   char * parentName = NULL;
    … …  
    10941094
    10951095  int parentMode;
    1096   SYNCHELP_READ_INT( parentMode );
     1096  SYNCHELP_READ_INT( parentMode, NWT_PN_PARENTMODE );
    10971097  this->setParentMode((PARENT_MODE)parentMode);
    10981098
    10991099  float f1, f2, f3, f4;
    11001100
    1101   SYNCHELP_READ_FLOAT( f1 );
    1102   SYNCHELP_READ_FLOAT( f2 );
    1103   SYNCHELP_READ_FLOAT( f3 );
     1101  SYNCHELP_READ_FLOAT( f1, NWT_PN_COORX );
     1102  SYNCHELP_READ_FLOAT( f2, NWT_PN_COORY );
     1103  SYNCHELP_READ_FLOAT( f3, NWT_PN_COORZ );
    11041104  this->setRelCoor( f1, f2, f3 );
    11051105
    11061106
    1107   SYNCHELP_READ_FLOAT( f1 );
    1108   SYNCHELP_READ_FLOAT( f2 );
    1109   SYNCHELP_READ_FLOAT( f3 );
    1110   SYNCHELP_READ_FLOAT( f4 );
     1107  SYNCHELP_READ_FLOAT( f1, NWT_PN_ROTV );
     1108  SYNCHELP_READ_FLOAT( f2, NWT_PN_ROTX );
     1109  SYNCHELP_READ_FLOAT( f3, NWT_PN_ROTY );
     1110  SYNCHELP_READ_FLOAT( f4, NWT_PN_ROTZ );
    11111111  this->setRelDir( Quaternion( Vector(f2, f3, f4), f1 ) );
    11121112
    … …  
    11401140  SYNCHELP_WRITE_BEGIN();
    11411141
    1142   SYNCHELP_WRITE_FKT( BaseObject::readState );
     1142  SYNCHELP_WRITE_FKT( BaseObject::readState, NWT_PN_BO_WRITESTATE );
    11431143
    11441144//   if ( this->parent )
    … …  
    11511151//   }
    11521152
    1153   SYNCHELP_WRITE_INT( this->parentMode );
    1154 
    1155   SYNCHELP_WRITE_FLOAT( this->relCoordinate.x );
    1156   SYNCHELP_WRITE_FLOAT( this->relCoordinate.y );
    1157   SYNCHELP_WRITE_FLOAT( this->relCoordinate.z );
    1158 
    1159   SYNCHELP_WRITE_FLOAT( this->relDirection.w );
    1160   SYNCHELP_WRITE_FLOAT( this->relDirection.v.x );
    1161   SYNCHELP_WRITE_FLOAT( this->relDirection.v.y );
    1162   SYNCHELP_WRITE_FLOAT( this->relDirection.v.z );
     1153  SYNCHELP_WRITE_INT( this->parentMode, NWT_PN_PARENTMODE );
     1154
     1155  SYNCHELP_WRITE_FLOAT( this->relCoordinate.x, NWT_PN_COORX );
     1156  SYNCHELP_WRITE_FLOAT( this->relCoordinate.y, NWT_PN_COORY );
     1157  SYNCHELP_WRITE_FLOAT( this->relCoordinate.z, NWT_PN_COORZ );
     1158
     1159  SYNCHELP_WRITE_FLOAT( this->relDirection.w, NWT_PN_ROTV );
     1160  SYNCHELP_WRITE_FLOAT( this->relDirection.v.x, NWT_PN_ROTX );
     1161  SYNCHELP_WRITE_FLOAT( this->relDirection.v.y, NWT_PN_ROTY );
     1162  SYNCHELP_WRITE_FLOAT( this->relDirection.v.z, NWT_PN_ROTZ );
    11631163
    11641164//   int n = children.size();
    … …  
    12091209
    12101210  byte flags = 0;
    1211   SYNCHELP_READ_BYTE( flags );
     1211  SYNCHELP_READ_BYTE( flags, NWT_PN_FLAGS );
    12121212  //PRINTF(0)("%s::FLAGS = %d\n", this->getName(), flags);
    12131213
    … …  
    12161216  if ( flags & __FLAG_COOR )
    12171217  {
    1218     SYNCHELP_READ_FLOAT( f1 );
    1219     SYNCHELP_READ_FLOAT( f2 );
    1220     SYNCHELP_READ_FLOAT( f3 );
     1218    SYNCHELP_READ_FLOAT( f1, NWT_PN_SCOORX );
     1219    SYNCHELP_READ_FLOAT( f2, NWT_PN_SCOORY );
     1220    SYNCHELP_READ_FLOAT( f3, NWT_PN_SCOORZ );
    12211221    PRINTF(0)("RCVD COOR: %f %f %f\n", f1, f2, f3);
    12221222    this->setRelCoor( f1, f2, f3 );
    … …  
    12251225  if ( flags & __FLAG_ROT )
    12261226  {
    1227     SYNCHELP_READ_FLOAT( f1 );
    1228     SYNCHELP_READ_FLOAT( f2 );
    1229     SYNCHELP_READ_FLOAT( f3 );
    1230     SYNCHELP_READ_FLOAT( f4 );
     1227    SYNCHELP_READ_FLOAT( f1, NWT_PN_SROTV );
     1228    SYNCHELP_READ_FLOAT( f2, NWT_PN_SROTX );
     1229    SYNCHELP_READ_FLOAT( f3, NWT_PN_SROTY );
     1230    SYNCHELP_READ_FLOAT( f4, NWT_PN_SROTZ );
    12311231    PRINTF(0)("RCVD QUAT: %f %f %f %f\n", f1, f2, f3, f4);
    12321232    //this->setRelDir( Quaternion( Vector(f2, f3, f4), f1 ) );
    … …  
    12501250int PNode::readSync( byte * data, int maxLength )
    12511251{
     1252  //WARNING: if you change this file make sure you also change needsReadSync
    12521253  SYNCHELP_WRITE_BEGIN();
    12531254
    … …  
    12701271
    12711272
    1272   SYNCHELP_WRITE_BYTE( flags );
     1273  SYNCHELP_WRITE_BYTE( flags, NWT_PN_FLAGS );
    12731274  //PRINTF(0)("FLAGS = %d\n", flags);
    12741275
    … …  
    12761277  {
    12771278
    1278     PRINTF(0)("SEND COOR: %f %f %f\n", this->relCoordinate.x, this->relCoordinate.y, this->relCoordinate.z);
    1279 
    1280     SYNCHELP_WRITE_FLOAT( this->relCoordinate.x );
    1281     SYNCHELP_WRITE_FLOAT( this->relCoordinate.y );
    1282     SYNCHELP_WRITE_FLOAT( this->relCoordinate.z );
     1279    //PRINTF(0)("SEND COOR: %f %f %f\n", this->relCoordinate.x, this->relCoordinate.y, this->relCoordinate.z);
     1280
     1281    SYNCHELP_WRITE_FLOAT( this->relCoordinate.x, NWT_PN_SCOORX );
     1282    SYNCHELP_WRITE_FLOAT( this->relCoordinate.y, NWT_PN_SCOORY );
     1283    SYNCHELP_WRITE_FLOAT( this->relCoordinate.z, NWT_PN_SCOORZ );
    12831284
    12841285    coorx = relCoordinate.x;
    … …  
    12901291  {
    12911292
    1292     PRINTF(0)("SEND QUAT: %f %f %f %f\n", this->absDirection.w, this->absDirection.v.x, this->absDirection.v.y, this->absDirection.v.z);
    1293 
    1294     SYNCHELP_WRITE_FLOAT( this->absDirection.w );
    1295     SYNCHELP_WRITE_FLOAT( this->absDirection.v.x );
    1296     SYNCHELP_WRITE_FLOAT( this->absDirection.v.y );
    1297     SYNCHELP_WRITE_FLOAT( this->absDirection.v.z );
     1293    //PRINTF(0)("SEND QUAT: %f %f %f %f\n", this->absDirection.w, this->absDirection.v.x, this->absDirection.v.y, this->absDirection.v.z);
     1294
     1295    SYNCHELP_WRITE_FLOAT( this->absDirection.w, NWT_PN_SROTV );
     1296    SYNCHELP_WRITE_FLOAT( this->absDirection.v.x, NWT_PN_SROTX );
     1297    SYNCHELP_WRITE_FLOAT( this->absDirection.v.y, NWT_PN_SROTY );
     1298    SYNCHELP_WRITE_FLOAT( this->absDirection.v.z, NWT_PN_SROTZ );
    12981299
    12991300    rotw = absDirection.w;
    … …  
    13051306  return SYNCHELP_WRITE_N;
    13061307}
     1308
     1309bool PNode::needsReadSync( )
     1310{
     1311  if ( fabs( coorx - relCoordinate.x ) > __OFFSET_POS ||
     1312       fabs( coory - relCoordinate.y ) > __OFFSET_POS ||
     1313       fabs( coorz - relCoordinate.z ) > __OFFSET_POS )
     1314    return true;
     1315
     1316  if ( fabs( rotw - absDirection.w ) > __OFFSET_ROT ||
     1317       fabs( rotx - absDirection.v.x ) > __OFFSET_ROT ||
     1318       fabs( roty - absDirection.v.y ) > __OFFSET_ROT ||
     1319       fabs( rotz - absDirection.v.z ) > __OFFSET_ROT )
     1320    return true;
     1321 
     1322  return false;
     1323}

  • trunk/src/lib/coord/p_node.h

    r6695 r6815  
    190190  int       writeSync(const byte* data, int length, int sender);
    191191  int       readSync(byte* data, int maxLength );
     192  bool      needsReadSync();
    192193
    193194 private:

  • trunk/src/lib/graphics/Makefile.am

    r6753 r6815  
    99                           render2D/render_2d.cc \
    1010                           render2D/element_2d.cc \
     11                           render2D/billboard.cc \
    1112                           text_engine/text_engine.cc \
    1213                           text_engine/text.cc \
    1314                           text_engine/font.cc \
    1415                           effects/graphics_effect.cc \
    15                            effects/fog_effect.cc
     16                           effects/fog_effect.cc \
     17                           effects/lense_flare.cc
     18
    1619
    1720noinst_HEADERS = graphics_engine.h \
    … …  
    2023                 render2D/render_2d.h \
    2124                 render2D/element_2d.h \
     25                 render2D/billboard.h \
    2226                 text_engine/text_engine.h \
    2327                 text_engine/text.h \
    2428                 text_engine/font.h \
    2529                 effects/graphics_effect.h \
    26                  effects/fog_effect.h
     30                 effects/fog_effect.h \
     31                 effects/lense_flare.h
    2732
    2833

  • trunk/src/lib/graphics/effects/fog_effect.cc

    r6772 r6815  
    6262void FogEffect::loadParams(const TiXmlElement* root)
    6363{
     64  printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.loadParms\n\n");
    6465  GraphicsEffect::loadParams(root);
    6566
    66    LoadParam(root, "fog-effect", this, FogEffect, setFogMode)
     67   LoadParam(root, "fog-mode", this, FogEffect, setFogMode)
    6768       .describe("sets the the fog mode {GL_LINEAR, GL_EXP, GL_EXP2}");
    6869
    … …  
    8788bool FogEffect::activate()
    8889{
     90  printf("fog==============================================>>>>>>>>>>>>>>>>>>>>>>>>...\n\n");
    8991  PRINTF(4)( "Enabling Fog Effect, mode: %i, density: %f, start: %f, end: %f\n", this->fogMode, this->fogDensity,
    9092             this->fogStart, this->fogEnd);
    … …  
    9294  glEnable(GL_FOG);
    9395  {
    94     GLfloat fogColor[4] = {0.5, 0.5, 0.5, 1.0};
     96    GLfloat fogColor[4] = {0.6, 0.6, 0.6, 1.0};
    9597
    9698    glFogi(GL_FOG_MODE, this->fogMode);

  • trunk/src/lib/graphics/effects/graphics_effect.cc

    r6772 r6815  
    7272bool GraphicsEffect::init()
    7373{}
     74
     75
     76
     77/**
     78 * draws the effect, if needed
     79 */
     80void GraphicsEffect::draw() const
     81{}
     82
     83
     84
     85/**
     86 * ticks the effect if there is any time dependancy
     87 */
     88void GraphicsEffect::tick(float dt)
     89{}

  • trunk/src/lib/graphics/effects/graphics_effect.h

    r6772 r6815  
    2525    virtual bool deactivate() = 0;
    2626
    27     inline bool isActivated() { return this->bActivated; }
     27    virtual void draw() const;
     28    virtual void tick(float dt);
     29
     30    inline bool isActivated() const { return this->bActivated; }
    2831
    2932

  • trunk/src/lib/graphics/graphics_engine.cc

    r6780 r6815  
    4141#include "shell_command.h"
    4242
     43
     44#include "parser/tinyxml/tinyxml.h"
     45#include "load_param.h"
     46#include "factory.h"
     47
    4348#ifdef __WIN32__
    4449 #include "class_list.h"
    … …  
    113118  GraphicsEngine::singletonRef = NULL;
    114119}
     120
     121
     122/**
     123 * loads the GraphicsEngine Specific Parameters.
     124 * @param root: the XML-Element to load the Data From
     125 */
     126void GraphicsEngine::loadParams(const TiXmlElement* root)
     127{
     128  LoadParamXML(root, "load-effect", this, GraphicsEngine, loadGraphicsEffectXML)
     129      .describe("loads a graphics effect");
     130}
     131
    115132
    116133/**
    … …  
    150167  this->initVideo(atoi(resolution.getString(0)), atoi(resolution.getString(1)), 16);
    151168
    152   GraphicsEffect* fe = new FogEffect(NULL);
    153   this->loadGraphicsEffect(fe);
    154   fe->activate();
    155   PRINTF(0)("--------------------------------------------------------------\n");
     169//   GraphicsEffect* fe = new FogEffect(NULL);
     170//   this->loadGraphicsEffect(fe);
     171//   fe->activate();
     172//   PRINTF(0)("--------------------------------------------------------------\n");
    156173}
    157174
    … …  
    571588#endif /* NO_TEXT */
    572589
    573 
    574   }
     590  }
     591
    575592  Render2D::getInstance()->tick(dt);
     593
     594  // tick the graphics effects
     595  list<GraphicsEffect*>::iterator it;
     596  for (it = this->graphicsEffects.begin(); it != this->graphicsEffects.end(); it++)
     597    (*it)->tick(dt);
    576598}
    577599
    … …  
    587609  Render2D::getInstance()->draw(E2D_LAYER_ALL);
    588610  Shader::restoreShader();
     611
     612  //draw the graphics
     613  list<GraphicsEffect*>::const_iterator it;
     614  for (it = this->graphicsEffects.begin(); it != this->graphicsEffects.end(); it++)
     615    (*it)->draw();
    589616}
    590617
    … …  
    661688
    662689/**
     690 * @param root The XML-element to load GraphicsEffects from
     691 */
     692void GraphicsEngine::loadGraphicsEffectXML(const TiXmlElement* root)
     693{
     694  const TiXmlElement* element = root->FirstChildElement();
     695
     696  while (element != NULL)
     697  {
     698    Factory::fabricate(element);
     699
     700    element = element->NextSiblingElement();
     701  }
     702}
     703
     704
     705/**
    663706 * loads a GraphicsEffect into the engine
    664707 * @param effect the GraphicsEffect to add

  • trunk/src/lib/graphics/graphics_engine.h

    r6753 r6815  
    2323class WorldEntity;
    2424class GraphicsEffect;
     25class TiXmlElement;
    2526
    2627//! class to handle graphics
    … …  
    3435    /** @returns a Pointer to the only object of this Class */
    3536    inline static GraphicsEngine* getInstance() { if (!GraphicsEngine::singletonRef) GraphicsEngine::singletonRef = new GraphicsEngine();  return GraphicsEngine::singletonRef; };
     37
     38    virtual void loadParams(const TiXmlElement* root);
    3639
    3740    int init();
    … …  
    8386    void process(const Event  &event);
    8487
     88    void loadGraphicsEffectXML(const TiXmlElement* root);
    8589    bool loadGraphicsEffect(GraphicsEffect* effect);
    8690    bool unloadGraphicsEffect(GraphicsEffect* effect);

  • trunk/src/lib/lang/base_object.cc

    r6640 r6815  
    204204    objectName = NULL;
    205205  }
    206   SYNCHELP_READ_STRINGM( this->objectName );
     206  SYNCHELP_READ_STRINGM( this->objectName, NWT_BO_NAME );
    207207  if ( this->objectName && !strcmp(this->objectName, "") )
    208208  {
    … …  
    225225
    226226  //PRINTF(0)("objectname = %s\n", this->objectName);
    227   SYNCHELP_WRITE_STRING( this->objectName );
     227  SYNCHELP_WRITE_STRING( this->objectName, NWT_BO_NAME );
    228228
    229229  return SYNCHELP_WRITE_N;

  • trunk/src/lib/network/handshake.cc

    r6753 r6815  
    9595  if ( !isServer() && hasState( HS_RECVD_VER ) && !hasState( HS_RECVD_HID ) )
    9696  {
    97     if ( length != INTSIZE+INTSIZE )
    98     {
    99       PRINTF(0)("hostID packet has wrong size %d instead of %d\n", length, 1);
    100       setState( HS_COMPLETED );
    101       return 0;
    102     }
     97    /*if ( length != INTSIZE+INTSIZE )
     98    {
     99      PRINTF(0)("hostID packet has wrong size %d instead of %d\n", length, INTSIZE+INTSIZE);
     100      setState( HS_COMPLETED );
     101      return 0;
     102  }*/
    103103
    104104    setState( HS_COMPLETED );
    105105    setState( HS_RECVD_HID );
    106106    this->isOk = true;
    107     SYNCHELP_READ_INT( this->newHostId );
    108     SYNCHELP_READ_INT( this->newNetworkGameManagerId );
     107    SYNCHELP_READ_INT( this->newHostId, NWT_HS_HOST_ID );
     108    SYNCHELP_READ_INT( this->newNetworkGameManagerId, NWT_HS_NGM_ID );
    109109
    110110    if ( newHostId == 0 )
    … …  
    180180      isOk = false;
    181181      //memcpy(data, (byte*)0, 4);
    182       SYNCHELP_WRITE_INT( 0 );
    183       SYNCHELP_WRITE_INT( 0 );
     182      SYNCHELP_WRITE_INT( 0, NWT_HS_HOST_ID);
     183      SYNCHELP_WRITE_INT( 0, NWT_HS_NGM_ID);
    184184    }
    185185    else
    … …  
    187187      isOk = true;
    188188      //memcpy(data, &clientId, 4);
    189       SYNCHELP_WRITE_INT( clientId );
    190       SYNCHELP_WRITE_INT( networkGameManagerId );
     189      SYNCHELP_WRITE_INT( clientId, NWT_HS_HOST_ID );
     190      SYNCHELP_WRITE_INT( networkGameManagerId, NWT_HS_NGM_ID );
    191191    }
    192192    *reciever = clientId;

  • trunk/src/lib/network/network_game_manager.cc

    r6737 r6815  
    167167  if ( !isServer() && !hasRequestedWorld )
    168168  {
    169     SYNCHELP_WRITE_BEGIN();
    170     byte b = NET_REQUEST_ENTITY_LIST;
    171     SYNCHELP_WRITE_BYTE( b );
     169    assert( maxLength >= 1 );
     170    data[0] = NET_REQUEST_ENTITY_LIST;
    172171    hasRequestedWorld = true;
    173     return SYNCHELP_WRITE_N;
     172    return 1;
    174173  }
    175174

  • trunk/src/lib/network/synchronizeable.h

    r6753 r6815  
    2020#define STATE_OUTOFSYNC 2
    2121#define STATE_REQUESTEDSYNC 4
     22
     23enum {
     24  NWT_SS_WE_STATE = 1000000,
     25  NWT_SS_B,
     26  NWT_SS_FLAGS,
     27  NWT_SS_MOUSEDIRX,
     28  NWT_SS_MOUSEDIRY,
     29  NWT_SS_MOUSEDIRZ,
     30  NWT_SS_MOUSEDIRW,
     31  NWT_SS_PN_SYNC,
     32  NWT_SS_VELX,
     33  NWT_SS_VELY,
     34  NWT_SS_VELZ,
     35 
     36  NWT_HS_HOST_ID,
     37  NWT_HS_NGM_ID,
     38 
     39  NWT_PN_BO_WRITESTATE,
     40  NWT_PN_PARENTMODE,
     41  NWT_PN_COORX,
     42  NWT_PN_COORY,
     43  NWT_PN_COORZ,
     44  NWT_PN_ROTX,
     45  NWT_PN_ROTY,
     46  NWT_PN_ROTZ,
     47  NWT_PN_ROTV,
     48 
     49  NWT_PN_FLAGS,
     50  NWT_PN_SCOORX,
     51  NWT_PN_SCOORY,
     52  NWT_PN_SCOORZ,
     53  NWT_PN_SROTX,
     54  NWT_PN_SROTY,
     55  NWT_PN_SROTZ,
     56  NWT_PN_SROTV,
     57 
     58  NWT_BO_NAME,
     59 
     60  NWT_WE_PN_WRITESTATE,
     61  NWT_WE_PN_MODELFILENAME,
     62  NWT_WE_PN_SCALING,
     63 
     64  NWT_GT_WE_STATE,
     65 
     66  NWT_SB_WE_STATE,
     67  NWT_SB_SIZE,
     68  NWT_SB_TEXTURENAME,
     69 
     70  NWT_TER_WE_STATE,
     71 
     72  NWT_PU_WE_STATE,
     73 
     74  NWT_TPU_WE_STATE,
     75 
     76  NWT_LPU_WE_STATE,
     77 
     78  NWT_WPU_WE_STATE,
     79 
     80  NWT_PPU_WE_STATE,
     81  NWT_PPU_TYPE,
     82  NWT_PPU_VALUE,
     83  NWT_PPU_MINVALUE,
     84  NWT_PPU_MAXVALUE,
     85
     86  NWT_WAT_STATE,
     87  NWT_WAT_WE_STATE,
     88  NWT_WAT_SIZEX,
     89  NWT_WAT_SIZEY,
     90  NWT_WAT_RESX,
     91  NWT_WAT_RESY,
     92  NWT_WAT_HEIGHT
     93};
    2294
    2395
    … …  
    58130 *
    59131 */
     132#define SYNCHELP_WRITE_DEBUG(n) {\
     133  __synchelp_write_n = Converter::intToByteArray( n, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
     134  assert( __synchelp_write_n == INTSIZE ); \
     135  __synchelp_write_i += __synchelp_write_n; \
     136}
     137
     138#define SYNCHELP_READ_DEBUG(n) {  \
     139  int nn; \
     140  __synchelp_read_n = Converter::byteArrayToInt( data+__synchelp_read_i, &nn );  \
     141  assert( __synchelp_read_n == INTSIZE ); \
     142  if ( n != nn ) { \
     143    PRINTF(1)("Check your code! read/writes not in right order! read %d instead of %d\n", nn, n); \
     144    assert( false ); \
     145  } \
     146  __synchelp_read_i += __synchelp_read_n; \
     147}
     148
    60149#define SYNCHELP_WRITE_BEGIN()    int __synchelp_write_i = 0; \
    61150                                  int __synchelp_write_n
    62 #define SYNCHELP_WRITE_INT(i) { __synchelp_write_n = \
     151#define SYNCHELP_WRITE_INT(i,n) { SYNCHELP_WRITE_DEBUG(n); \
     152                                __synchelp_write_n = \
    63153                                Converter::intToByteArray( i, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
    64154                                assert( __synchelp_write_n == INTSIZE ); \
    … …  
    70160                                __synchelp_write_i += __synchelp_write_n; \
    71161}
    72 #define SYNCHELP_WRITE_FLOAT(f) { __synchelp_write_n = \
     162#define SYNCHELP_WRITE_FLOAT(f,n) { SYNCHELP_WRITE_DEBUG(n); \
     163                                __synchelp_write_n = \
    73164                                Converter::floatToByteArray( f, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
    74165                                assert( __synchelp_write_n == FLOATSIZE ); \
    … …  
    80171                                __synchelp_write_i += __synchelp_write_n; \
    81172}
    82 #define SYNCHELP_WRITE_BYTE(b) { \
     173#define SYNCHELP_WRITE_BYTE(b,n) { SYNCHELP_WRITE_DEBUG(n); \
     174                                \
    83175                                if (maxLength - __synchelp_write_i < 1) \
    84176{ \
    … …  
    89181                                __synchelp_write_i++; \
    90182}
    91 #define SYNCHELP_WRITE_STRING(s) { if (s!=NULL) {\
     183#define SYNCHELP_WRITE_STRING(s,n) { SYNCHELP_WRITE_DEBUG(n); \
     184                                if (s!=NULL) {\
    92185                                __synchelp_write_n = \
    93186                                Converter::stringToByteArray( s, data+__synchelp_write_i, strlen(s), maxLength-__synchelp_write_i ); \
    … …  
    105198}
    106199#define SYNCHELP_WRITE_N        __synchelp_write_i
    107 #define SYNCHELP_WRITE_FKT(f)   { \
     200#define SYNCHELP_WRITE_FKT(f,n)   { SYNCHELP_WRITE_DEBUG(n); \
    108201                                  __synchelp_write_i += \
    109202                                  f( data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
    … …  
    114207                                  int __synchelp_read_n
    115208
    116 #define SYNCHELP_READ_INT(i)       { \
     209#define SYNCHELP_READ_INT(i,n)       { SYNCHELP_READ_DEBUG(n); \
    117210                                    if ( length-__synchelp_read_i < INTSIZE ) \
    118211{ \
    … …  
    124217                                    __synchelp_read_i += __synchelp_read_n; \
    125218}
    126 #define SYNCHELP_READ_FLOAT(f)    { \
     219#define SYNCHELP_READ_FLOAT(f,n)    { SYNCHELP_READ_DEBUG(n); \
    127220                                    if ( length-__synchelp_read_i < FLOATSIZE ) \
    128221{ \
    … …  
    134227                                    __synchelp_read_i += __synchelp_read_n; \
    135228}
    136 #define SYNCHELP_READ_STRING(s,l)    { \
     229#define SYNCHELP_READ_STRING(s,l,n)    {SYNCHELP_READ_DEBUG(n); \
    137230                                    __synchelp_read_n = Converter::byteArrayToString( data+__synchelp_read_i, s, l );  \
    138231                                    assert( __synchelp_read_n == strlen(s)+INTSIZE ) ;\
    … …  
    144237                                    __synchelp_read_i += __synchelp_read_n; \
    145238}
    146 #define SYNCHELP_READ_STRINGM(s)    { \
     239#define SYNCHELP_READ_STRINGM(s,n)    { SYNCHELP_READ_DEBUG(n); \
    147240                                    __synchelp_read_n = Converter::byteArrayToStringM( data+__synchelp_read_i, s );  \
    148241                                    assert( __synchelp_read_n == strlen(s)+INTSIZE ) ;\
    … …  
    154247                                    __synchelp_read_i += __synchelp_read_n; \
    155248}
    156 #define SYNCHELP_READ_BYTE(b)      { \
     249#define SYNCHELP_READ_BYTE(b,n)      { SYNCHELP_READ_DEBUG(n); \
    157250                                    if ( length-__synchelp_read_i < 1 ) \
    158251{ \
    … …  
    163256                                    __synchelp_read_i ++;  \
    164257}
    165 #define SYNCHELP_READ_FKT(f)   { \
     258#define SYNCHELP_READ_FKT(f,n)   { SYNCHELP_READ_DEBUG(n); \
    166259                                  __synchelp_read_i += \
    167260                                  f( data+__synchelp_read_i, length-__synchelp_read_i, sender); \
    168261                                  }
     262#define SYNCHELP_READ_REMAINING() ( length-__synchelp_read_i )
     263#define SYNCHELP_READ_NEXTBYTE() ( data[__synchelp_read_i] )
    169264#define SYNCHELP_READ_N           __synchelp_read_i
    170265
Note: See TracChangeset for help on using the changeset viewer.