# Home    # nevrax.com   
Nevrax
Nevrax.org
#News
#Mailing-list
#Documentation
#CVS
#Bugs
#License
Docs
 
Documentation  
Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages   Search  

pacs_client.h

Go to the documentation of this file.
00001 
00007 /* Copyright, 2001 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #ifndef NL_PACS_CLIENT_H
00027 #define NL_PACS_CLIENT_H
00028 
00029 #include "stdnet.h"
00030 
00031 #include "nel/net/inet_address.h"
00032 #include "nel/net/callback_client.h"
00033 #include "nel/net/naming_client.h"
00034 
00035 #include "nel/pacs/u_move_primitive.h"
00036 #include "nel/pacs/u_collision_desc.h"
00037 
00038 #define NLNET_PACS_PROTOCOL_VERSION 1
00039 
00040 namespace NLNET 
00041 {
00042 
00043 TCallbackItem PacsCallbackArray[];
00044 
00052 class CPacsClient
00053 {
00054         friend void cbPacsAnswer (CMessage &msgin, TSockId from, CCallbackNetBase &netbase);
00055 public:
00056 
00058         CPacsClient()
00059         {
00060                 // No connexion
00061                 _Server=NULL;
00062         }
00063 
00064         ~CPacsClient()
00065         {
00066                 disconnect ();
00067         }
00068 
00069         bool connect ();
00070 
00071         void disconnect ()
00072         {
00073                 if (_Server)
00074                 {
00075                         _Server->disconnect ();
00076                         delete _Server;
00077                 }
00078         }
00079 
00085         void    initMessage ()
00086         {
00087                 _Message.clear ();
00088                 _Message.setType ("PACS");
00089                 _Message.serialCheck ((uint32)NLNET_PACS_PROTOCOL_VERSION);
00090         }
00091 
00097         void    sendMessage ()
00098         {
00099                 // Checks
00100                 nlassert (_Server);
00101 
00102                 // Close the message
00103                 bool nlFalse=false;
00104                 _Message.serial (nlFalse);
00105 
00106                 // Send the message
00107                 _Server->send (_Message);
00108         }
00109 
00113         void    update ()
00114         {
00115                 // Checks
00116                 nlassert (_Server);
00117 
00118                 _Server->update ();
00119         }
00120 
00122 
00132         void rayTest (double p0, double p1, uint32 testId)
00133         {
00134                 // Append to the current message
00135                 std::string name="RY";
00136                 bool nlTrue=true;
00137                 _Message.serial (nlTrue, name, p0, p1, testId);
00138         }
00139         
00141 
00149         void addPrimitive (NLPACS::UMovePrimitive::TUserData id)
00150         {
00151                 // Append to the current message
00152                 std::string name="AD";
00153                 bool nlTrue=true;
00154                 _Message.serial (nlTrue, name, id);
00155         }
00156         
00164         void removePrimitive (NLPACS::UMovePrimitive::TUserData id)
00165         {
00166                 // Append to the current message
00167                 std::string name="RV";
00168                 bool nlTrue=true;
00169                 _Message.serial (nlTrue, name, id);
00170         }
00171         
00180         void evalCollision (uint32 evalId, double deltaTime)
00181         {
00182                 // Append to the current message
00183                 std::string name="EV";
00184                 bool nlTrue=true;
00185                 _Message.serial (nlTrue, name, evalId, deltaTime);
00186         }
00187 
00197         void testMove (NLPACS::UMovePrimitive::TUserData id, const NLMISC::CVectorD& speed, double deltaTime)
00198         {
00199                 // Append to the current message
00200                 std::string name="TS";
00201                 bool nlTrue=true;
00202                 _Message.serial (nlTrue, name, id, const_cast<NLMISC::CVectorD&> (speed), deltaTime);
00203         }
00204         
00206         
00215         void setCurrentPrimitive (NLPACS::UMovePrimitive::TUserData id)
00216         {
00217                 // Append to the current message
00218                 std::string name="CU";
00219                 bool nlTrue=true;
00220                 _Message.serial (nlTrue, name, id);
00221         }
00222         
00230         void setPrimitiveType (NLPACS::UMovePrimitive::TType type)
00231         {
00232                 // Append to the current message
00233                 std::string name="TY";
00234                 uint32 t=(uint32)type;
00235                 bool nlTrue=true;
00236                 _Message.serial (nlTrue, name, t);
00237         }
00238         
00246         void setReactionType (NLPACS::UMovePrimitive::TReaction type)
00247         {
00248                 // Append to the current message
00249                 std::string name="RT";
00250                 uint32 t=(uint32)type;
00251                 bool nlTrue=true;
00252                 _Message.serial (nlTrue, name, t);
00253         }
00254         
00262         void setTriggerType (NLPACS::UMovePrimitive::TTrigger type)
00263         {
00264                 // Append to the current message
00265                 std::string name="TT";
00266                 uint32 t=(uint32)type;
00267                 bool nlTrue=true;
00268                 _Message.serial (nlTrue, name, t);
00269         }
00270         
00278         void setCollisionMask (NLPACS::UMovePrimitive::TCollisionMask mask)
00279         {
00280                 // Append to the current message
00281                 std::string name="CT";
00282                 bool nlTrue=true;
00283                 _Message.serial (nlTrue, name, mask);
00284         }
00285         
00293         void setOcclusionMask (NLPACS::UMovePrimitive::TCollisionMask mask)
00294         {
00295                 // Append to the current message
00296                 std::string name="OT";
00297                 bool nlTrue=true;
00298                 _Message.serial (nlTrue, name, mask);
00299         }
00300         
00308         void setObstacle (bool obstacle)
00309         {
00310                 // Append to the current message
00311                 std::string name="OB";
00312                 bool nlTrue=true;
00313                 _Message.serial (nlTrue, name, obstacle);
00314         }
00315         
00323         void setOrientation (double orientation)
00324         {
00325                 // Append to the current message
00326                 std::string name="OR";
00327                 bool nlTrue=true;
00328                 _Message.serial (nlTrue, name, orientation);
00329         }
00330         
00338         void setAbsorption (float absorption)
00339         {
00340                 // Append to the current message
00341                 std::string name="AB";
00342                 bool nlTrue=true;
00343                 _Message.serial (nlTrue, name, absorption);
00344         }
00345         
00354         void setSize (float width, float depth)
00355         {
00356                 // Append to the current message
00357                 std::string name="SZ";
00358                 bool nlTrue=true;
00359                 _Message.serial (nlTrue, name, width, depth);
00360         }
00361         
00369         void setHeight (float height)
00370         {
00371                 // Append to the current message
00372                 std::string name="HE";
00373                 bool nlTrue=true;
00374                 _Message.serial (nlTrue, name, height);
00375         }
00376         
00384         void setRadius (float radius)
00385         {
00386                 // Append to the current message
00387                 std::string name="RD";
00388                 bool nlTrue=true;
00389                 _Message.serial (nlTrue, name, radius);
00390         }
00391         
00400         void globalMove (const NLMISC::CVectorD& position)
00401         {
00402                 // Append to the current message
00403                 std::string name="GM";
00404                 bool nlTrue=true;
00405                 _Message.serial (nlTrue, name, const_cast<NLMISC::CVectorD&> (position));
00406         }
00407         
00418         void relativeMove (const NLMISC::CVectorD& speed)
00419         {
00420                 // Append to the current message
00421                 std::string name="RM";
00422                 bool nlTrue=true;
00423                 _Message.serial (nlTrue, name, const_cast<NLMISC::CVectorD&> (speed));
00424         }
00425         
00433         void getPositionSpeed (NLPACS::UMovePrimitive::TUserData id)
00434         {
00435                 // Append to the current message
00436                 std::string name="PS";
00437                 bool nlTrue=true;
00438                 _Message.serial (nlTrue, name, id);
00439         }
00440 
00441 protected:
00442 
00444 
00448         virtual void    messageCallback ()
00449         {}
00450 
00457         virtual void    rayTestCallback (uint32 testId, bool testResult)
00458         {}
00459 
00467         virtual void    triggerCallback (uint32 evalId, const std::vector<NLPACS::UTriggerInfo>& triggerInfo)
00468         {}
00469 
00476         virtual void    testMoveCallback (NLPACS::UMovePrimitive::TUserData id, bool testResult)
00477         {}
00478 
00486         virtual void    getPositionSpeedCallback (NLPACS::UMovePrimitive::TUserData id, const NLMISC::CVectorD &position, const NLMISC::CVectorD &speed)
00487         {}
00488 
00489 private:
00490         CCallbackClient         *_Server;
00491         CMessage                        _Message;
00492 };
00493 
00494 // Callback to listen to the server
00495 static void cbPacsAnswer (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
00496 {
00497         // Get the client pointer
00498         CPacsClient *client=(CPacsClient*)(uint)from->appId ();
00499 
00500         // Check stream
00501         msgin.serialCheck ((uint32)NLNET_PACS_PROTOCOL_VERSION);
00502 
00503         // Message callback
00504         client->messageCallback ();
00505 
00506         bool again;
00507         msgin.serial (again);
00508         
00509         while (again)
00510         {
00511                 // Read the message sub string
00512                 std::string subMessage;
00513                 msgin.serial (subMessage);
00514 
00515                 // This code can work only if sizeof (uint) == sizeof (void*)
00516                 nlassert (sizeof (uint)==sizeof (void*));
00517 
00518                 // Raytrace callback ?
00519                 if (subMessage=="RY")
00520                 {
00521                         // Read test id and test result
00522                         uint32 testId;
00523                         bool testResult;
00524                         msgin.serial (testId, testResult);
00525 
00526                         // Call the callback
00527                         client->rayTestCallback (testId, testResult);
00528                 }
00529                 // Trigger callback ?
00530                 else if (subMessage=="TR")
00531                 {
00532                         // Read eval id and trigger info
00533                         uint32 evalId;
00534                         std::vector<NLPACS::UTriggerInfo> triggerInfo;
00535                         msgin.serial (evalId);
00536                         msgin.serialCont (triggerInfo);
00537 
00538                         // Call the callback
00539                         client->triggerCallback (evalId, triggerInfo);
00540                 }
00541                 // Test move callback ?
00542                 else if (subMessage=="TM")
00543                 {
00544                         // Read the primitive id and test result
00545                         NLPACS::UMovePrimitive::TUserData id;
00546                         bool testResult;
00547                         msgin.serial (id, testResult);
00548                         
00549                         // Call the callback    
00550                         client->testMoveCallback (id, testResult);
00551                 }
00552                 // Test move callback ?
00553                 else if (subMessage=="PS")
00554                 {
00555                         // Read the primitive id and test result
00556                         NLPACS::UMovePrimitive::TUserData id;
00557                         NLMISC::CVectorD position;
00558                         NLMISC::CVectorD speed;
00559                         msgin.serial (id, position, speed);
00560                         
00561                         // Call the callback    
00562                         client->getPositionSpeedCallback (id, position, speed);
00563                 }
00564                 else
00565                         NLMISC::nlError ("Pacs client: unkown sub message string");
00566 
00567                 // Next message ?
00568                 msgin.serial (again);
00569         }
00570 }
00571 
00572 static TCallbackItem PacsCallbackArray[] =
00573 {
00574         { "PACS_ASW", cbPacsAnswer }
00575 };
00576 
00577 inline  bool CPacsClient::connect ()
00578 {
00579         // Create a connexion
00580         _Server = new CCallbackClient;
00581 
00582         // Look up for PACS service
00583         CNamingClient::lookupAndConnect ("PS", *_Server);
00584         if (_Server->connected())
00585         {
00586                 // Add callback array
00587                 _Server->addCallbackArray (PacsCallbackArray, sizeof (PacsCallbackArray) / sizeof (PacsCallbackArray[0]));
00588 
00589                 // This code can work only if sizeof (uint) == sizeof (void*)
00590                 nlassert (sizeof (uint)==sizeof (void*));
00591                 _Server->id ()->setAppId ((uint64)(uint)this);
00592 
00593                 // Return ok
00594                 return true;
00595         }
00596         else
00597         {
00598                 return false;
00599         }
00600 }
00601 
00602 } // NLNET
00603 
00604 
00605 #endif // NL_PACS_CLIENT_H
00606 
00607 /* End of pacs_client.h */