pacs_client.h

Go to the documentation of this file.

/* Copyright, 2001 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_PACS_CLIENT_H
#define NL_PACS_CLIENT_H

#include "stdnet.h"

#include "nel/net/inet_address.h"
#include "nel/net/callback_client.h"
#include "nel/net/naming_client.h"

#include "nel/pacs/u_move_primitive.h"
#include "nel/pacs/u_collision_desc.h"

#define NLNET_PACS_PROTOCOL_VERSION 1

namespace NLNET 
{

TCallbackItem PacsCallbackArray[];

class CPacsClient
{
        friend void cbPacsAnswer (CMessage &msgin, TSockId from, CCallbackNetBase &netbase);
public:

        CPacsClient()
        {
                // No connexion
                _Server=NULL;
        }

        ~CPacsClient()
        {
                disconnect ();
        }

        bool connect ();

        void disconnect ()
        {
                if (_Server)
                {
                        _Server->disconnect ();
                        delete _Server;
                }
        }

        void    initMessage ()
        {
                _Message.clear ();
                _Message.setType ("PACS");
                _Message.serialCheck ((uint32)NLNET_PACS_PROTOCOL_VERSION);
        }

        void    sendMessage ()
        {
                // Checks
                nlassert (_Server);

                // Close the message
                bool nlFalse=false;
                _Message.serial (nlFalse);

                // Send the message
                _Server->send (_Message);
        }

        void    update ()
        {
                // Checks
                nlassert (_Server);

                _Server->update ();
        }


        void rayTest (double p0, double p1, uint32 testId)
        {
                // Append to the current message
                std::string name="RY";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, p0, p1, testId);
        }
        

        void addPrimitive (NLPACS::UMovePrimitive::TUserData id)
        {
                // Append to the current message
                std::string name="AD";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, id);
        }
        
        void removePrimitive (NLPACS::UMovePrimitive::TUserData id)
        {
                // Append to the current message
                std::string name="RV";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, id);
        }
        
        void evalCollision (uint32 evalId, double deltaTime)
        {
                // Append to the current message
                std::string name="EV";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, evalId, deltaTime);
        }

        void testMove (NLPACS::UMovePrimitive::TUserData id, const NLMISC::CVectorD& speed, double deltaTime)
        {
                // Append to the current message
                std::string name="TS";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, id, const_cast<NLMISC::CVectorD&> (speed), deltaTime);
        }
        
        
        void setCurrentPrimitive (NLPACS::UMovePrimitive::TUserData id)
        {
                // Append to the current message
                std::string name="CU";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, id);
        }
        
        void setPrimitiveType (NLPACS::UMovePrimitive::TType type)
        {
                // Append to the current message
                std::string name="TY";
                uint32 t=(uint32)type;
                bool nlTrue=true;
                _Message.serial (nlTrue, name, t);
        }
        
        void setReactionType (NLPACS::UMovePrimitive::TReaction type)
        {
                // Append to the current message
                std::string name="RT";
                uint32 t=(uint32)type;
                bool nlTrue=true;
                _Message.serial (nlTrue, name, t);
        }
        
        void setTriggerType (NLPACS::UMovePrimitive::TTrigger type)
        {
                // Append to the current message
                std::string name="TT";
                uint32 t=(uint32)type;
                bool nlTrue=true;
                _Message.serial (nlTrue, name, t);
        }
        
        void setCollisionMask (NLPACS::UMovePrimitive::TCollisionMask mask)
        {
                // Append to the current message
                std::string name="CT";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, mask);
        }
        
        void setOcclusionMask (NLPACS::UMovePrimitive::TCollisionMask mask)
        {
                // Append to the current message
                std::string name="OT";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, mask);
        }
        
        void setObstacle (bool obstacle)
        {
                // Append to the current message
                std::string name="OB";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, obstacle);
        }
        
        void setOrientation (double orientation)
        {
                // Append to the current message
                std::string name="OR";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, orientation);
        }
        
        void setAbsorption (float absorption)
        {
                // Append to the current message
                std::string name="AB";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, absorption);
        }
        
        void setSize (float width, float depth)
        {
                // Append to the current message
                std::string name="SZ";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, width, depth);
        }
        
        void setHeight (float height)
        {
                // Append to the current message
                std::string name="HE";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, height);
        }
        
        void setRadius (float radius)
        {
                // Append to the current message
                std::string name="RD";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, radius);
        }
        
        void globalMove (const NLMISC::CVectorD& position)
        {
                // Append to the current message
                std::string name="GM";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, const_cast<NLMISC::CVectorD&> (position));
        }
        
        void relativeMove (const NLMISC::CVectorD& speed)
        {
                // Append to the current message
                std::string name="RM";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, const_cast<NLMISC::CVectorD&> (speed));
        }
        
        void getPositionSpeed (NLPACS::UMovePrimitive::TUserData id)
        {
                // Append to the current message
                std::string name="PS";
                bool nlTrue=true;
                _Message.serial (nlTrue, name, id);
        }

protected:


        virtual void    messageCallback ()
        {}

        virtual void    rayTestCallback (uint32 testId, bool testResult)
        {}

        virtual void    triggerCallback (uint32 evalId, const std::vector<NLPACS::UTriggerInfo>& triggerInfo)
        {}

        virtual void    testMoveCallback (NLPACS::UMovePrimitive::TUserData id, bool testResult)
        {}

        virtual void    getPositionSpeedCallback (NLPACS::UMovePrimitive::TUserData id, const NLMISC::CVectorD &position, const NLMISC::CVectorD &speed)
        {}

private:
        CCallbackClient         *_Server;
        CMessage                        _Message;
};

// Callback to listen to the server
static void cbPacsAnswer (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
{
        // Get the client pointer
        CPacsClient *client=(CPacsClient*)(uint)from->appId ();

        // Check stream
        msgin.serialCheck ((uint32)NLNET_PACS_PROTOCOL_VERSION);

        // Message callback
        client->messageCallback ();

        bool again;
        msgin.serial (again);
        
        while (again)
        {
                // Read the message sub string
                std::string subMessage;
                msgin.serial (subMessage);

                // This code can work only if sizeof (uint) == sizeof (void*)
                nlassert (sizeof (uint)==sizeof (void*));

                // Raytrace callback ?
                if (subMessage=="RY")
                {
                        // Read test id and test result
                        uint32 testId;
                        bool testResult;
                        msgin.serial (testId, testResult);

                        // Call the callback
                        client->rayTestCallback (testId, testResult);
                }
                // Trigger callback ?
                else if (subMessage=="TR")
                {
                        // Read eval id and trigger info
                        uint32 evalId;
                        std::vector<NLPACS::UTriggerInfo> triggerInfo;
                        msgin.serial (evalId);
                        msgin.serialCont (triggerInfo);

                        // Call the callback
                        client->triggerCallback (evalId, triggerInfo);
                }
                // Test move callback ?
                else if (subMessage=="TM")
                {
                        // Read the primitive id and test result
                        NLPACS::UMovePrimitive::TUserData id;
                        bool testResult;
                        msgin.serial (id, testResult);
                        
                        // Call the callback    
                        client->testMoveCallback (id, testResult);
                }
                // Test move callback ?
                else if (subMessage=="PS")
                {
                        // Read the primitive id and test result
                        NLPACS::UMovePrimitive::TUserData id;
                        NLMISC::CVectorD position;
                        NLMISC::CVectorD speed;
                        msgin.serial (id, position, speed);
                        
                        // Call the callback    
                        client->getPositionSpeedCallback (id, position, speed);
                }
                else
                        NLMISC::nlError ("Pacs client: unkown sub message string");

                // Next message ?
                msgin.serial (again);
        }
}

static TCallbackItem PacsCallbackArray[] =
{
        { "PACS_ASW", cbPacsAnswer }
};

inline  bool CPacsClient::connect ()
{
        // Create a connexion
        _Server = new CCallbackClient;

        // Look up for PACS service
        CNamingClient::lookupAndConnect ("PS", *_Server);
        if (_Server->connected())
        {
                // Add callback array
                _Server->addCallbackArray (PacsCallbackArray, sizeof (PacsCallbackArray) / sizeof (PacsCallbackArray[0]));

                // This code can work only if sizeof (uint) == sizeof (void*)
                nlassert (sizeof (uint)==sizeof (void*));
                _Server->id ()->setAppId ((uint64)(uint)this);

                // Return ok
                return true;
        }
        else
        {
                return false;
        }
}

} // NLNET


#endif // NL_PACS_CLIENT_H

/* End of pacs_client.h */

---