player.h

/* -- 2007-05-07 -- 
 *  ardev - an augmented reality library for robot developers
 *  Copyright 2005-2007 - Toby Collett (ardev _at_ plan9.net.nz)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 *
 */
//
// File: ./include/ardev/player.h
// Created by: User <Email>
// Created on: Mon May 10 16:36:21 2004
//

#ifndef _ARDEV_PLAYER_H_
#define _ARDEV_PLAYER_H_

#include <ardev/ardevconfig.h>
#include <ardev/ardev.h>

#ifdef HAVE_PLAYER

#undef signals
#include <libplayerc++/playerc++.h>

#include <deque>

using namespace PlayerCc;
using namespace std;


class PlayerObject
{
        public:
                PlayerObject() {};
                virtual ~PlayerObject() {};
        
                virtual void PlayerInit(PlayerClient * pci) = 0;
                virtual void PlayerTerm() = 0;
};


class PlayerClientInterface : public ARObject
{
        public:
                PlayerClientInterface(const char * PlayerServer="localhost", int PlayerPort=6665);
        
                ~PlayerClientInterface();
        
                int Initialise(bool Active = true);
        
                void Terminate();
                
                void * Main();
        
                PlayerClient * GetPlayerClient() {return Robot;};
        
                void AddChild(PlayerObject & NewChild);
                
                void RemoveChild(PlayerObject & Child);
                
        protected:
                bool Connecting;
                char * PlayerServer;
                int PlayerPort;
                PlayerClient * Robot;
                list<PlayerObject *> Children;
                //bool Connected;
};



class PositionPlayer3d : public PositionObject, public PlayerObject
{
        public:
                PositionPlayer3d(PlayerClientInterface & pci);
                virtual ~PositionPlayer3d();
                
                int Initialise(bool Active = true);
                 
                void Terminate();
        
                ARPosition GetPosition();
        
                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();
        
        protected:
                // PositionPlayer variables
        
                PlayerClientInterface * PlayerInterface; 
                Position3dProxy * Position;     
                ARPosition Pos; 
};

class PositionPlayer : public PositionObject, public PlayerObject
{
        public:
                PositionPlayer(PlayerClientInterface & pci);
                virtual ~PositionPlayer();
                int Initialise(bool Active = true);
                void Terminate();
                ARPosition GetPosition();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();
        
        protected:
                // PositionPlayer variables
        
                PlayerClientInterface * PlayerInterface; 
                Position2dProxy * Position; 
                ARPosition Pos; 
};


class PositionPlayerPTZ : public PositionObject, public PlayerObject
{
        public:
                PositionPlayerPTZ(PlayerClientInterface & pci);
                virtual ~PositionPlayerPTZ();
                int Initialise(bool Active = true);
                void Terminate();

                ARPosition GetPosition();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();
        
        protected:
                PlayerClientInterface * PlayerInterface; 
                PtzProxy * Position; 
                ARPosition Pos; 
};


class RenderPlayerActArray : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerActArray(PlayerClientInterface & pci, const ARColour & aColour, int Index = 0, double Width = 0.05);
                virtual ~RenderPlayerActArray();

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

                void Render();
                
                void RenderTransparent();
                
        private:
                PlayerClientInterface * PlayerInterface; 
                ActArrayProxy * Proxy; 
                int Index; 
                
                double Width; 
};

class RenderPlayerBumper : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerBumper(PlayerClientInterface & pci, int Index = 0, double Height = 0.1);
                virtual ~RenderPlayerBumper();

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

                void RenderTransparent();
                
        private:
                PlayerClientInterface * PlayerInterface; 
                BumperProxy * Bumper; 
                player_bumper_geom_t BumperGeom; 
                
                double Height; 
};


class RenderPlayerIr : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerIr(PlayerClientInterface & pci);
                virtual ~RenderPlayerIr();

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

                void RenderTransparent(); 
                
        private:
                PlayerClientInterface * PlayerInterface; 
                IrProxy * Ir; 
};

class RenderPlayerLaser : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerLaser(PlayerClientInterface & pci, const ARColour & aColour, int aRayInterval = 20, bool aWithOutline = true);
                virtual ~RenderPlayerLaser(); 

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();


                void RenderTransparent(); 

                void Render(); 

                virtual double TraceDistance(const Ray & Offset, const Ray & R, const ARPoint & Rotation);
        
                
        private:
                PlayerClientInterface * PlayerInterface; 
                LaserProxy * Laser; 

                double MaxRange;
                player_pose_t pose;
                
                bool WithOutline;
                int RayInterval;
};

class RenderPlayerLimb : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerLimb(PlayerClientInterface & pci, const ARColour & aColour, int Index = 0, double Radius = 0.05);
                virtual ~RenderPlayerLimb();

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

                void Render();
                
                void RenderTransparent();
                
        private:
                PlayerClientInterface * PlayerInterface; 
                LimbProxy * Proxy; 
                int Index; 
                player_limb_geom_req_t Geom; 
                
                double Radius; 
};

class RenderPlayerLocalise : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerLocalise(PlayerClientInterface & pci);
                virtual ~RenderPlayerLocalise(); 

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();
        
                //void Render(); ///< Render the map in GL
                void RenderTransparent(); 
        
        protected:
                PlayerClientInterface * PlayerInterface; 
                LocalizeProxy * Proxy; 

};

class RenderPlayerMap : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerMap(PlayerClientInterface & pci, double _Height = 0);
                virtual ~RenderPlayerMap(); 

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

        
                //void Render(); ///< Render the map in GL
                void RenderTransparent(); 
        
        protected:
                PlayerClientInterface * PlayerInterface; 
                MapProxy * Proxy; 
                double Height; 
                int GlList;
};

class RenderPlayerPath : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerPath(PlayerClientInterface & pci,ARColour & _Colour);
                virtual ~RenderPlayerPath(); 

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

                unsigned int GetHistoryLength() const {return HistoryLength;};
                void SetHistoryLength(const unsigned int NewHistoryLength) {HistoryLength = NewHistoryLength;};
        
                void Render(); 
                void RenderTransparent(); 
        
        protected:
                PlayerClientInterface * PlayerInterface; 
                Position2dProxy * Position; 

                deque<ARPoint> Points; 
        
                unsigned int HistoryLength; 
        
};

class RenderPlayerPTZ : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerPTZ(PlayerClientInterface & pci,double _aspect=1.333, double _fov=0);
                virtual ~RenderPlayerPTZ(); 

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

        
                void Render(); 
                void RenderTransparent(); 
        
        protected:
                PlayerClientInterface * PlayerInterface; 
                PtzProxy * Proxy; 

                double aspect; 
                double fov; 
        
};

class RenderPlayerSonar : public RenderObject, public PlayerObject
{
        public:
                RenderPlayerSonar(PlayerClientInterface & pci, int Index = 0);
                virtual ~RenderPlayerSonar();

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

                void RenderTransparent();
                
        private:
                PlayerClientInterface * PlayerInterface; 
                SonarProxy * Sonar; 
};

class CaptureStage : public CaptureObject, public PlayerObject
{
        public:
                //CaptureStage() {pCamera = NULL; Position = NULL; Open=false; TheMap = -1;};
                CaptureStage(const char * RobotName, CameraObject * camera, PositionObject * CameraPosition, PlayerClientInterface & _PlayerInterface);
                virtual ~CaptureStage();

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

                virtual const ARImage & GetFrame();
                int GetMaxWidth();
                int GetMaxHeight();
                        
        protected:
                bool Open;
                ARImage Frame; 
                CameraObject * pCamera; 
                PositionObject * pCameraPosition; 
                int TheMap; 
                void drawMap(); 
                char * RobotName;
                
                // player client objects
                PlayerClientInterface * PlayerInterface; 
                SimulationProxy * Position; 
                MapProxy * Map; 
};


class CapturePlayer : public CaptureObject
{
        public:
                CapturePlayer(const char * PlayerServer="localhost", int PlayerPort=6665, int CameraIndex = 0);
                virtual ~CapturePlayer();

                void * Main();

                int Initialise(bool Active = true);
                void Terminate();

                void PlayerInit(PlayerClient * pci);
                void PlayerTerm();

                virtual const ARImage & GetFrame();
                int GetMaxWidth();
                int GetMaxHeight();
                        
        protected:
                bool Open;
                ARImage Frame; 
                bool fresh;
                
                // player client objects
                PlayerClient * Robot; 
                CameraProxy * Camera; 
};

// The classes needed for the graphics2d render object
class GraphicsElement
{
        public:
                GraphicsElement() {Type = 0;Filled = false;};
        
                uint32_t Type;
                double r,g,b,a;
                double fr,fg,fb,fa;
                bool Filled;
                vector<player_point_2d_t> Points;
};

class Graphics2DRenderer : public RenderObject
{
        public:
                Graphics2DRenderer() {;};
                ~Graphics2DRenderer() {;};
        
                void Render();
                void RenderTransparent();
                
                vector<GraphicsElement> Elements;
                

};

class Graphics3DRenderer : public RenderObject
{
        public:
                Graphics3DRenderer() {;};
                ~Graphics3DRenderer() {Clear();};
        
                void Clear()
                {
                        for (vector<player_graphics3d_cmd_draw_t *>::const_iterator itr = Elements.begin(); itr != Elements.end(); ++itr)
                        {
                                delete *itr;    
                        }
                        Elements.clear();
                }
        
                void RenderOne(player_graphics3d_cmd_draw_t & item);

                void Render();
                void RenderTransparent();
                
                vector<player_graphics3d_cmd_draw_t *> Elements;
                

};

#endif  // HAVE_PLAYER
#endif  // _ARDEV_PLAYER_H_

---

Generated on Sat May 12 15:25:43 2007 for ardev by  1.5.1