PME.h

Go to the documentation of this file.

/*
 *  PME.h
 *  Ventriloquist
 *
 *  Created by Doug McCoy on 11/11/04.
 *  Copyright 2004 __MyCompanyName__. All rights reserved.
 *
 */
#ifndef INCLUDE_PME_H
#define INCLUDE_PME_H

#include "CPoint.h"
#include "VBAP.h"
#include "ThreadUtilities.h"
#include "PracticalSocket.h"
#include "CGestalt.h"

//#ifdef DO_TIMING                  // Here are the macros and globals for the timing code
#include <sys/time.h>
#define GET_TIME(val) if (gettimeofday(val, 0) != 0) cout << "Output: Error reading current time" << endl;
#define SUB_TIMES(t1, t2) (((t1->tv_sec - t2->tv_sec) * 1000000) + (t1->tv_usec - t2->tv_usec))
//#endif


using namespace csl;

// for use with sending over sockets
typedef struct {            
    int x;
    int y;
    int z;
    int dx;
    int dy;
    int dz;
    int glove_state;
} controller_str;

typedef enum {
    kStopped,
    kGrabbed,
    kOrbit,
    kDraw, 
    kBounce
} MovementType;

typedef enum {
    kInvalid = -1,
    kClosed  =  0,
    kPoint   =  1,
    kOpen    = 15
} GloveState;


// for use with internal classes
class Controller {
protected:
    CPoint _position;
    CPoint _velocity;
    GloveState glove_state; 
    csl::SynchPthread sync;
    csl::ThreadPthread thread;
//  unsigned short local_port;
    unsigned short foreign_port;
    string foreign_net_address;
    UDPSocket sock;

public:
    Controller( string remote_net_addr, unsigned short remote_port): 
        glove_state(kOpen), foreign_port(remote_port), foreign_net_address(remote_net_addr) {};
    Controller(): glove_state(kOpen) {};
    ~Controller(){};
    void set_remote_addr_and_port( string addr, unsigned short port ){ foreign_port=port; foreign_net_address=addr;};
    void set_data( controller_str &str );
    void get_data( CPoint &p, CPoint &v, GloveState &glove_st );        // get pos and vel and put result into p and v
    void get_position(CPoint &p);
    void * remote_read_func(void *data);        // function to run in separate thread
    void start_reader_thread();
    void get_remote_data();
};

class Orbit {
protected:
    double a;       // semi-major axis
    double n;       // mean motion (radians per unit time)
    double e;       // eccentricity         (0 <= e < 1)
    double i;       // inclination angle    (0 <= i <= pi)
    double omega;   // longitude of ascending node  (0 <= omega < 2pi)
    double w;       // argument of perigee  (0 <= w < 2pi)
    double nu;      // true anomaly         (0 <= v < 2pi)
    CPoint e_vec;   // eccentricity vector
    CPoint n_vec;   // ascending node vector
    double mu;      // gravity coonstant valid for individual instance
    
public:
    Orbit(){};
    ~Orbit(){};
    void calculate_eccentricity( CPoint R,  CPoint V);
    void calculate_orbital_params( CPoint R,  CPoint V);
    void calculate_absolute_position(CPoint &new_position);
    void calculate_new_position_in_orbit();
    void dump();
};

#define MAX_TRACE_LENGTH (100 * 15)     // 100 positions per second for max 15 seconds

class PMESource {
protected:
    Source *source;
    Orbit orbit;
    MovementType current_move_type;
    MovementType next_move_type;
    CPoint trace[MAX_TRACE_LENGTH];
    float bounce_distance;
    CPoint bounce_velocity;
    unsigned current_trace_index;
    unsigned trace_length;
    
public:
    void set_position( CPoint &P );
    CPoint get_position();
    void update_pos();
    void set_orbit(CPoint &R, CPoint &V);
    MovementType get_current_move_type() { return current_move_type; };
    MovementType get_next_move_type() { return next_move_type; };
    void update_move_type(){ current_move_type = next_move_type; };
    void set_next_move_type ( MovementType mov_type);
    void set_current_move_type ( MovementType mov_type);
    void push_trace( CPoint &pos );
    void reset_trace(){ trace_length = current_trace_index = 0; };
    void set_bounce_velocity( CPoint bv){ bounce_velocity = bv; };
    void set_bounce_distance(float bd);
    
    PMESource( Source &s );
    PMESource();
    ~PMESource(){};
};

class PME {
protected:
//  csl::SynchPthread sync;
    csl::ThreadPthread management_thread;
    Controller controller;
    PMESource ** pme_source_list;
    PMESource *grabbed_source;
    unsigned short num_sources;
//  MovementType pme_move_type;
    void update_grabbed_position(CPoint &p);
    bool check_for_grabbed_source( CPoint &p );
    bool keep_processing_sources;
    
public:
    bool add_pme_source( PMESource &s );
    void remove_all_sources() {num_sources=0;};
    void manage_sources();
//  void set_movement_type( MovementType type ){ pme_move_type = type; };
    void set_remote_addr_and_port( string addr, unsigned short port ){ controller.set_remote_addr_and_port(addr, port); };
    static void * management_func(void *data);      // function to run in separate thread
    void start_management_thread();
    void stop_management_thread() ;
    
    PME( string remote_net_addr, unsigned short remote_port);
    PME();
    ~PME();
    
    
};

#endif

---