1412104298
2 2
13 libp3recorder 4 ayCl 12 panda3d.core 
47
47 24 upcast_to_ReferenceCount 0 12 94 38 RecorderBase::upcast_to_ReferenceCount 0 1 4 42
upcast from RecorderBase to ReferenceCount
61
ReferenceCount *RecorderBase::upcast_to_ReferenceCount(void);

48 13 ~RecorderBase 0 6 94 27 RecorderBase::~RecorderBase 0 0 232
////////////////////////////////////////////////////////////////////
//     Function: RecorderBase::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
42
virtual RecorderBase::~RecorderBase(void);

49 12 is_recording 0 4 94 26 RecorderBase::is_recording 0 1 1 934
// Filename: recorderBase.I
// Created by:  drose (24Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: RecorderBase::is_recording
//       Access: Published
//  Description: Returns true if this recorder is presently recording
//               data for saving to a session file, false otherwise.
//               If this is true, record_data() will be called from
//               time to time.
////////////////////////////////////////////////////////////////////
51
inline bool RecorderBase::is_recording(void) const;

50 10 is_playing 0 4 94 24 RecorderBase::is_playing 0 1 2 418
////////////////////////////////////////////////////////////////////
//     Function: RecorderBase::is_playing
//       Access: Published
//  Description: Returns true if this recorder is presently playing back
//               data from session file, false otherwise.  If this is
//               true, play_data() will be called from time to time.
////////////////////////////////////////////////////////////////////
49
inline bool RecorderBase::is_playing(void) const;

51 14 get_class_type 0 4 94 28 RecorderBase::get_class_type 0 1 3 0
53
static TypeHandle RecorderBase::get_class_type(void);

52 18 upcast_to_DataNode 0 12 96 33 MouseRecorder::upcast_to_DataNode 0 1 7 37
upcast from MouseRecorder to DataNode
50
DataNode *MouseRecorder::upcast_to_DataNode(void);

53 25 downcast_to_MouseRecorder 0 12 97 35 DataNode::downcast_to_MouseRecorder 0 1 8 39
downcast from DataNode to MouseRecorder
57
MouseRecorder *DataNode::downcast_to_MouseRecorder(void);

54 22 upcast_to_RecorderBase 0 12 96 37 MouseRecorder::upcast_to_RecorderBase 0 1 9 41
upcast from MouseRecorder to RecorderBase
58
RecorderBase *MouseRecorder::upcast_to_RecorderBase(void);

55 25 downcast_to_MouseRecorder 0 12 94 39 RecorderBase::downcast_to_MouseRecorder 0 1 10 43
downcast from RecorderBase to MouseRecorder
61
MouseRecorder *RecorderBase::downcast_to_MouseRecorder(void);

56 13 MouseRecorder 0 4 96 28 MouseRecorder::MouseRecorder 0 1 5 225
////////////////////////////////////////////////////////////////////
//     Function: MouseRecorder::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
63
MouseRecorder::MouseRecorder(basic_string< char > const &name);

57 14 ~MouseRecorder 0 6 96 29 MouseRecorder::~MouseRecorder 0 0 233
////////////////////////////////////////////////////////////////////
//     Function: MouseRecorder::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
44
virtual MouseRecorder::~MouseRecorder(void);

58 14 get_class_type 0 4 96 29 MouseRecorder::get_class_type 0 1 6 0
54
static TypeHandle MouseRecorder::get_class_type(void);

59 18 RecorderController 0 4 98 38 RecorderController::RecorderController 0 1 11 230
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
45
RecorderController::RecorderController(void);

60 12 begin_record 0 4 98 32 RecorderController::begin_record 0 1 12 375
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::begin_record
//       Access: Published
//  Description: Begins recording data to the indicated filename.  All
//               of the recorders in use should already have been
//               added.
////////////////////////////////////////////////////////////////////
64
bool RecorderController::begin_record(Filename const &filename);

61 14 begin_playback 0 4 98 34 RecorderController::begin_playback 0 1 13 661
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::begin_playback
//       Access: Published
//  Description: Begins playing back data from the indicated filename.
//               All of the recorders in use should already have been
//               added, although this may define additional recorders
//               if they are present in the file (these new recorders
//               will not be used).  This may also undefine recorders
//               that were previously added but are not present in the
//               file.
////////////////////////////////////////////////////////////////////
66
bool RecorderController::begin_playback(Filename const &filename);

62 5 close 0 4 98 25 RecorderController::close 0 1 14 275
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::close
//       Access: Published
//  Description: Finishes recording data to the indicated filename.
////////////////////////////////////////////////////////////////////
37
void RecorderController::close(void);

63 14 get_start_time 0 4 98 34 RecorderController::get_start_time 0 1 15 912
// Filename: recorderController.I
// Created by:  drose (24Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_start_time
//       Access: Published
//  Description: Returns the time (and date) at which the current
//               session was originally recorded (or, in recording
//               mode, the time at which the current session began).
////////////////////////////////////////////////////////////////////
67
inline unsigned int RecorderController::get_start_time(void) const;

64 15 set_random_seed 0 4 98 35 RecorderController::set_random_seed 0 1 16 472
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::set_random_seed
//       Access: Published
//  Description: Indicates an arbitrary number to be recorded in the
//               session file as a random seed, should the application
//               wish to take advantage of it.  This must be set
//               before begin_record() is called.
////////////////////////////////////////////////////////////////////
65
inline void RecorderController::set_random_seed(int random_seed);

65 15 get_random_seed 0 4 98 35 RecorderController::get_random_seed 0 1 17 444
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_random_seed
//       Access: Published
//  Description: Returns the random seed that was set by a previous
//               call to set_random_seed(), or the number read from
//               the session file after begin_playback() has been
//               called.
////////////////////////////////////////////////////////////////////
59
inline int RecorderController::get_random_seed(void) const;

66 12 is_recording 0 4 98 32 RecorderController::is_recording 0 1 18 324
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::is_recording
//       Access: Published
//  Description: Returns true if the controller has been opened for
//               output, false otherwise.
////////////////////////////////////////////////////////////////////
57
inline bool RecorderController::is_recording(void) const;

67 10 is_playing 0 4 98 30 RecorderController::is_playing 0 1 19 321
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::is_playing
//       Access: Published
//  Description: Returns true if the controller has been opened for
//               input, false otherwise.
////////////////////////////////////////////////////////////////////
55
inline bool RecorderController::is_playing(void) const;

68 7 is_open 0 4 98 27 RecorderController::is_open 0 1 20 335
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::is_open
//       Access: Published
//  Description: Returns true if the controller has been opened for
//               either input or output, false otherwise.
////////////////////////////////////////////////////////////////////
52
inline bool RecorderController::is_open(void) const;

69 12 get_filename 0 4 98 32 RecorderController::get_filename 0 1 21 348
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_filename
//       Access: Published
//  Description: Returns the filename that was passed to the most
//               recent call to begin_record() or begin_playback().
////////////////////////////////////////////////////////////////////
68
inline Filename const &RecorderController::get_filename(void) const;

70 8 is_error 0 4 98 28 RecorderController::is_error 0 1 22 453
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::is_error
//       Access: Published
//  Description: Returns true if the controller has been opened for
//               input or output output and there is an error on the
//               stream, or false if the controller is closed or if
//               there is no problem.
////////////////////////////////////////////////////////////////////
47
inline bool RecorderController::is_error(void);

71 16 get_clock_offset 0 4 98 36 RecorderController::get_clock_offset 0 1 23 456
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_clock_offset
//       Access: Published
//  Description: Returns the delta offset between the actual frame
//               time and the frame time written to the log.  This is
//               essentially the time at which the recording (or
//               playback) started.
////////////////////////////////////////////////////////////////////
63
inline double RecorderController::get_clock_offset(void) const;

72 16 get_frame_offset 0 4 98 36 RecorderController::get_frame_offset 0 1 24 466
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_frame_offset
//       Access: Published
//  Description: Returns the delta offset between the actual frame
//               count and the frame count written to the log.  This is
//               essentially the frame number at which the recording
//               (or playback) started.
////////////////////////////////////////////////////////////////////
60
inline int RecorderController::get_frame_offset(void) const;

73 12 add_recorder 0 4 98 32 RecorderController::add_recorder 0 1 25 654
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::add_recorder
//       Access: Published
//  Description: Adds the named recorder to the set of recorders that
//               are in use.
//
//               If the controller is in recording mode, the named
//               recorder will begin recording its status to the
//               session file.  If the controller is in playback mode
//               and the name and type matches a recorder in the
//               session file, the recorder will begin receiving data.
////////////////////////////////////////////////////////////////////
103
inline void RecorderController::add_recorder(basic_string< char > const &name, RecorderBase *recorder);

74 12 has_recorder 0 4 98 32 RecorderController::has_recorder 0 1 26 643
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::has_recorder
//       Access: Published
//  Description: Returns true if the named recorder has been added to
//               the table by a previous call to add_recorder(), false
//               otherwise. 
//
//               If the controller is in playback mode, this will also
//               return false for a recorder that was found in the
//               session file but was never explicitly added via
//               add_recorder(); see get_recorder().
////////////////////////////////////////////////////////////////////
85
inline bool RecorderController::has_recorder(basic_string< char > const &name) const;

75 12 get_recorder 0 4 98 32 RecorderController::get_recorder 0 1 27 714
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_recorder
//       Access: Published
//  Description: Returns the recorder with the indicated name, or NULL
//               if there is no such recorder.
//
//               If the controller is in playback mode, this may
//               return the recorder matching the indicated name as
//               read from the session file, even if it was never
//               added to the table by the user.  In this case,
//               has_recorder() may return false, but get_recorder()
//               will return a non-NULL value.
////////////////////////////////////////////////////////////////////
94
inline RecorderBase *RecorderController::get_recorder(basic_string< char > const &name) const;

76 15 remove_recorder 0 4 98 35 RecorderController::remove_recorder 0 1 28 822
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::remove_recorder
//       Access: Published
//  Description: Removes the named recorder from the table.  Returns
//               true if successful, false if there was no such
//               recorder.
//
//               If the controller is in recording mode, the named
//               recorder will stop recording.  If the controller is
//               in playback mode, the named recorder will
//               disassociate itself from the session file (but if the
//               session file still has data for this name, a default
//               recorder will take its place to decode the data from
//               the session file).
////////////////////////////////////////////////////////////////////
82
inline bool RecorderController::remove_recorder(basic_string< char > const &name);

77 13 set_frame_tie 0 4 98 33 RecorderController::set_frame_tie 0 1 29 895
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::set_frame_tie
//       Access: Published
//  Description: Sets the frame_tie flag.
//
//               When this is true, sessions are played back
//               frame-for-frame, based on the frame count of the
//               recorded session.  This gives the most accurate
//               playback, but the playback rate will vary according
//               to the frame rate of the playback machine.
//
//               When this is false, sessions are played back at real
//               time, based on the clock of the recorded session.
//               This may introduce playback discrepencies if the
//               frames do not fall at exactly the same times as they
//               did in the original.
////////////////////////////////////////////////////////////////////
62
inline void RecorderController::set_frame_tie(bool frame_tie);

78 13 get_frame_tie 0 4 98 33 RecorderController::get_frame_tie 0 1 30 253
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_frame_tie
//       Access: Published
//  Description: See set_frame_tie().
////////////////////////////////////////////////////////////////////
58
inline bool RecorderController::get_frame_tie(void) const;

79 12 record_frame 0 4 98 32 RecorderController::record_frame 0 1 31 341
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::record_frame
//       Access: Published
//  Description: Gets the next frame of data from all of the active
//               recorders and adds it to the output file.
////////////////////////////////////////////////////////////////////
44
void RecorderController::record_frame(void);

80 10 play_frame 0 4 98 30 RecorderController::play_frame 0 1 32 339
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::play_frame
//       Access: Published
//  Description: Gets the next frame of data from all of the active
//               recorders and adds it to the output file.
////////////////////////////////////////////////////////////////////
42
void RecorderController::play_frame(void);

81 14 get_class_type 0 4 98 34 RecorderController::get_class_type 0 1 33 0
59
static TypeHandle RecorderController::get_class_type(void);

82 20 SocketStreamRecorder 0 4 100 42 SocketStreamRecorder::SocketStreamRecorder 0 2 34 35 962
// Filename: socketStreamRecorder.I
// Created by:  drose (28Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
147
inline SocketStreamRecorder::SocketStreamRecorder(void);
inline SocketStreamRecorder::SocketStreamRecorder(SocketStream *stream, bool owns_stream);

83 16 receive_datagram 0 4 100 38 SocketStreamRecorder::receive_datagram 0 1 36 536
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::receive_datagram
//       Access: Public
//  Description: Receives a datagram over the socket by expecting a
//               little-endian 16-bit byte count as a prefix.  If the
//               socket stream is non-blocking, may return false if
//               the data is not available; otherwise, returns false
//               only if the socket closes.
////////////////////////////////////////////////////////////////////
58
bool SocketStreamRecorder::receive_datagram(Datagram &dg);

84 13 send_datagram 0 4 100 35 SocketStreamRecorder::send_datagram 0 1 37 266
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::send_datagram
//       Access: Public
//  Description: See SocketStream::send_datagram().
////////////////////////////////////////////////////////////////////
68
inline bool SocketStreamRecorder::send_datagram(Datagram const &dg);

85 9 is_closed 0 4 100 31 SocketStreamRecorder::is_closed 0 1 38 261
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::is_closed
//       Access: Published
//  Description: See SocketStream::is_closed().
////////////////////////////////////////////////////////////////////
50
inline bool SocketStreamRecorder::is_closed(void);

86 5 close 0 4 100 27 SocketStreamRecorder::close 0 1 39 253
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::close
//       Access: Published
//  Description: See SocketStream::close().
////////////////////////////////////////////////////////////////////
46
inline void SocketStreamRecorder::close(void);

87 15 set_collect_tcp 0 4 100 37 SocketStreamRecorder::set_collect_tcp 0 1 40 273
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::set_collect_tcp
//       Access: Published
//  Description: See SocketStream::set_collect_tcp().
////////////////////////////////////////////////////////////////////
68
inline void SocketStreamRecorder::set_collect_tcp(bool collect_tcp);

88 15 get_collect_tcp 0 4 100 37 SocketStreamRecorder::get_collect_tcp 0 1 41 273
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::get_collect_tcp
//       Access: Published
//  Description: See SocketStream::get_collect_tcp().
////////////////////////////////////////////////////////////////////
62
inline bool SocketStreamRecorder::get_collect_tcp(void) const;

89 24 set_collect_tcp_interval 0 4 100 46 SocketStreamRecorder::set_collect_tcp_interval 0 1 42 291
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::set_collect_tcp_interval
//       Access: Published
//  Description: See SocketStream::set_collect_tcp_interval().
////////////////////////////////////////////////////////////////////
76
inline void SocketStreamRecorder::set_collect_tcp_interval(double interval);

90 24 get_collect_tcp_interval 0 4 100 46 SocketStreamRecorder::get_collect_tcp_interval 0 1 43 291
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::get_collect_tcp_interval
//       Access: Published
//  Description: See SocketStream::get_collect_tcp_interval().
////////////////////////////////////////////////////////////////////
73
inline double SocketStreamRecorder::get_collect_tcp_interval(void) const;

91 14 consider_flush 0 4 100 36 SocketStreamRecorder::consider_flush 0 1 44 270
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::consider_flush
//       Access: Published
//  Description: See SocketStream::consider_flush()
////////////////////////////////////////////////////////////////////
55
inline bool SocketStreamRecorder::consider_flush(void);

92 5 flush 0 4 100 27 SocketStreamRecorder::flush 0 1 45 252
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::flush
//       Access: Published
//  Description: See SocketStream::flush()
////////////////////////////////////////////////////////////////////
46
inline bool SocketStreamRecorder::flush(void);

93 14 get_class_type 0 4 100 36 SocketStreamRecorder::get_class_type 0 1 46 0
61
static TypeHandle SocketStreamRecorder::get_class_type(void);

46
1 14 Dtool_ayClK8hL 0 6 5 103 0 14 Dtool_ayClK8hL 934 // Filename: recorderBase.I
// Created by:  drose (24Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: RecorderBase::is_recording
//       Access: Published
//  Description: Returns true if this recorder is presently recording
//               data for saving to a session file, false otherwise.
//               If this is true, record_data() will be called from
//               time to time.
//////////////////////////////////////////////////////////////////// 1 4 this 3 101  
2 14 Dtool_ayClYULh 0 6 6 103 0 14 Dtool_ayClYULh 418 ////////////////////////////////////////////////////////////////////
//     Function: RecorderBase::is_playing
//       Access: Published
//  Description: Returns true if this recorder is presently playing back
//               data from session file, false otherwise.  If this is
//               true, play_data() will be called from time to time.
//////////////////////////////////////////////////////////////////// 1 4 this 3 101  
3 14 Dtool_ayClFTOU 0 7 7 105 0 14 Dtool_ayClFTOU 0 0 
4 14 Dtool_ayClY6Qp 0 7 3 107 0 14 Dtool_ayClY6Qp 0 1 4 this 3 106  
5 14 Dtool_ayClqf6S 0 7 14 109 57 14 Dtool_ayClqf6S 225 ////////////////////////////////////////////////////////////////////
//     Function: MouseRecorder::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 108  
6 14 Dtool_ayClHvdt 0 7 16 105 0 14 Dtool_ayClHvdt 0 0 
7 14 Dtool_ayClCU8Q 0 7 10 110 0 14 Dtool_ayClCU8Q 0 1 4 this 3 109  
8 14 Dtool_ayClujBb 0 7 11 109 57 14 Dtool_ayClujBb 0 1 4 this 3 110  
9 14 Dtool_ayClKZwc 0 7 12 106 48 14 Dtool_ayClKZwc 0 1 4 this 3 109  
10 14 Dtool_ayClAqBt 0 7 13 109 57 14 Dtool_ayClAqBt 0 1 4 this 3 106  
11 14 Dtool_ayClgOQz 0 7 19 111 0 14 Dtool_ayClgOQz 230 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
12 14 Dtool_ayClEoI_ 0 6 20 103 0 14 Dtool_ayClEoI_ 375 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::begin_record
//       Access: Published
//  Description: Begins recording data to the indicated filename.  All
//               of the recorders in use should already have been
//               added.
//////////////////////////////////////////////////////////////////// 2 4 this 3 111  8 filename 1 112  
13 14 Dtool_ayClD04q 0 6 21 103 0 14 Dtool_ayClD04q 661 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::begin_playback
//       Access: Published
//  Description: Begins playing back data from the indicated filename.
//               All of the recorders in use should already have been
//               added, although this may define additional recorders
//               if they are present in the file (these new recorders
//               will not be used).  This may also undefine recorders
//               that were previously added but are not present in the
//               file.
//////////////////////////////////////////////////////////////////// 2 4 this 3 111  8 filename 1 112  
14 14 Dtool_ayCl3TyG 0 4 22 115 0 14 Dtool_ayCl3TyG 275 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::close
//       Access: Published
//  Description: Finishes recording data to the indicated filename.
//////////////////////////////////////////////////////////////////// 1 4 this 3 111  
15 14 Dtool_ayCl7lBc 0 6 23 118 0 14 Dtool_ayCl7lBc 912 // Filename: recorderController.I
// Created by:  drose (24Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_start_time
//       Access: Published
//  Description: Returns the time (and date) at which the current
//               session was originally recorded (or, in recording
//               mode, the time at which the current session began).
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
16 14 Dtool_ayClEIcS 0 4 24 115 0 14 Dtool_ayClEIcS 472 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::set_random_seed
//       Access: Published
//  Description: Indicates an arbitrary number to be recorded in the
//               session file as a random seed, should the application
//               wish to take advantage of it.  This must be set
//               before begin_record() is called.
//////////////////////////////////////////////////////////////////// 2 4 this 3 111  11 random_seed 1 119  
17 14 Dtool_ayClzhjD 0 6 25 119 0 14 Dtool_ayClzhjD 444 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_random_seed
//       Access: Published
//  Description: Returns the random seed that was set by a previous
//               call to set_random_seed(), or the number read from
//               the session file after begin_playback() has been
//               called.
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
18 14 Dtool_ayCl3xMb 0 6 26 103 0 14 Dtool_ayCl3xMb 324 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::is_recording
//       Access: Published
//  Description: Returns true if the controller has been opened for
//               output, false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
19 14 Dtool_ayClBF0E 0 6 27 103 0 14 Dtool_ayClBF0E 321 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::is_playing
//       Access: Published
//  Description: Returns true if the controller has been opened for
//               input, false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
20 14 Dtool_ayCl7Ejw 0 6 28 103 0 14 Dtool_ayCl7Ejw 335 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::is_open
//       Access: Published
//  Description: Returns true if the controller has been opened for
//               either input or output, false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
21 14 Dtool_ayClE6J_ 0 6 29 112 0 14 Dtool_ayClE6J_ 348 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_filename
//       Access: Published
//  Description: Returns the filename that was passed to the most
//               recent call to begin_record() or begin_playback().
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
22 14 Dtool_ayClm_or 0 6 30 103 0 14 Dtool_ayClm_or 453 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::is_error
//       Access: Published
//  Description: Returns true if the controller has been opened for
//               input or output output and there is an error on the
//               stream, or false if the controller is closed or if
//               there is no problem.
//////////////////////////////////////////////////////////////////// 1 4 this 3 111  
23 14 Dtool_ayClN6bw 0 6 31 120 0 14 Dtool_ayClN6bw 456 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_clock_offset
//       Access: Published
//  Description: Returns the delta offset between the actual frame
//               time and the frame time written to the log.  This is
//               essentially the time at which the recording (or
//               playback) started.
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
24 14 Dtool_ayClyEgj 0 6 32 119 0 14 Dtool_ayClyEgj 466 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_frame_offset
//       Access: Published
//  Description: Returns the delta offset between the actual frame
//               count and the frame count written to the log.  This is
//               essentially the frame number at which the recording
//               (or playback) started.
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
25 14 Dtool_ayClAnOD 0 4 33 115 0 14 Dtool_ayClAnOD 654 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::add_recorder
//       Access: Published
//  Description: Adds the named recorder to the set of recorders that
//               are in use.
//
//               If the controller is in recording mode, the named
//               recorder will begin recording its status to the
//               session file.  If the controller is in playback mode
//               and the name and type matches a recorder in the
//               session file, the recorder will begin receiving data.
//////////////////////////////////////////////////////////////////// 3 4 this 3 111  4 name 1 108  8 recorder 1 106  
26 14 Dtool_ayClSl_W 0 6 34 103 0 14 Dtool_ayClSl_W 643 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::has_recorder
//       Access: Published
//  Description: Returns true if the named recorder has been added to
//               the table by a previous call to add_recorder(), false
//               otherwise. 
//
//               If the controller is in playback mode, this will also
//               return false for a recorder that was found in the
//               session file but was never explicitly added via
//               add_recorder(); see get_recorder().
//////////////////////////////////////////////////////////////////// 2 4 this 3 116  4 name 1 108  
27 14 Dtool_ayClNjK2 0 7 35 106 48 14 Dtool_ayClNjK2 714 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_recorder
//       Access: Published
//  Description: Returns the recorder with the indicated name, or NULL
//               if there is no such recorder.
//
//               If the controller is in playback mode, this may
//               return the recorder matching the indicated name as
//               read from the session file, even if it was never
//               added to the table by the user.  In this case,
//               has_recorder() may return false, but get_recorder()
//               will return a non-NULL value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 116  4 name 1 108  
28 14 Dtool_ayClcpvX 0 6 36 103 0 14 Dtool_ayClcpvX 822 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::remove_recorder
//       Access: Published
//  Description: Removes the named recorder from the table.  Returns
//               true if successful, false if there was no such
//               recorder.
//
//               If the controller is in recording mode, the named
//               recorder will stop recording.  If the controller is
//               in playback mode, the named recorder will
//               disassociate itself from the session file (but if the
//               session file still has data for this name, a default
//               recorder will take its place to decode the data from
//               the session file).
//////////////////////////////////////////////////////////////////// 2 4 this 3 111  4 name 1 108  
29 14 Dtool_ayClsgOd 0 4 37 115 0 14 Dtool_ayClsgOd 895 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::set_frame_tie
//       Access: Published
//  Description: Sets the frame_tie flag.
//
//               When this is true, sessions are played back
//               frame-for-frame, based on the frame count of the
//               recorded session.  This gives the most accurate
//               playback, but the playback rate will vary according
//               to the frame rate of the playback machine.
//
//               When this is false, sessions are played back at real
//               time, based on the clock of the recorded session.
//               This may introduce playback discrepencies if the
//               frames do not fall at exactly the same times as they
//               did in the original.
//////////////////////////////////////////////////////////////////// 2 4 this 3 111  9 frame_tie 1 103  
30 14 Dtool_ayClzYut 0 6 38 103 0 14 Dtool_ayClzYut 253 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::get_frame_tie
//       Access: Published
//  Description: See set_frame_tie().
//////////////////////////////////////////////////////////////////// 1 4 this 3 116  
31 14 Dtool_ayClDD1N 0 4 39 115 0 14 Dtool_ayClDD1N 341 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::record_frame
//       Access: Published
//  Description: Gets the next frame of data from all of the active
//               recorders and adds it to the output file.
//////////////////////////////////////////////////////////////////// 1 4 this 3 111  
32 14 Dtool_ayClcjvm 0 4 40 115 0 14 Dtool_ayClcjvm 339 ////////////////////////////////////////////////////////////////////
//     Function: RecorderController::play_frame
//       Access: Published
//  Description: Gets the next frame of data from all of the active
//               recorders and adds it to the output file.
//////////////////////////////////////////////////////////////////// 1 4 this 3 111  
33 14 Dtool_ayClnwuH 0 7 41 105 0 14 Dtool_ayClnwuH 0 0 
34 14 Dtool_ayCl4hpl 0 7 43 121 48 14 Dtool_ayCl4hpl 728 // Filename: socketStreamRecorder.I
// Created by:  drose (28Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
35 14 Dtool_ayClsab4 0 7 43 121 48 14 Dtool_ayClsab4 232 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 6 stream 1 122  11 owns_stream 1 103  
36 14 Dtool_ayCl4uRL 0 6 44 103 0 14 Dtool_ayCl4uRL 536 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::receive_datagram
//       Access: Public
//  Description: Receives a datagram over the socket by expecting a
//               little-endian 16-bit byte count as a prefix.  If the
//               socket stream is non-blocking, may return false if
//               the data is not available; otherwise, returns false
//               only if the socket closes.
//////////////////////////////////////////////////////////////////// 2 4 this 3 121  2 dg 1 124  
37 14 Dtool_ayCl9r0L 0 6 45 103 0 14 Dtool_ayCl9r0L 266 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::send_datagram
//       Access: Public
//  Description: See SocketStream::send_datagram().
//////////////////////////////////////////////////////////////////// 2 4 this 3 121  2 dg 1 126  
38 14 Dtool_ayCl5XJQ 0 6 46 103 0 14 Dtool_ayCl5XJQ 261 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::is_closed
//       Access: Published
//  Description: See SocketStream::is_closed().
//////////////////////////////////////////////////////////////////// 1 4 this 3 121  
39 14 Dtool_ayCl2w02 0 4 47 115 0 14 Dtool_ayCl2w02 253 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::close
//       Access: Published
//  Description: See SocketStream::close().
//////////////////////////////////////////////////////////////////// 1 4 this 3 121  
40 14 Dtool_ayClhdjA 0 4 48 115 0 14 Dtool_ayClhdjA 273 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::set_collect_tcp
//       Access: Published
//  Description: See SocketStream::set_collect_tcp().
//////////////////////////////////////////////////////////////////// 2 4 this 3 121  11 collect_tcp 1 103  
41 14 Dtool_ayClg_ig 0 6 49 103 0 14 Dtool_ayClg_ig 273 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::get_collect_tcp
//       Access: Published
//  Description: See SocketStream::get_collect_tcp().
//////////////////////////////////////////////////////////////////// 1 4 this 3 128  
42 14 Dtool_ayClvs9Y 0 4 50 115 0 14 Dtool_ayClvs9Y 291 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::set_collect_tcp_interval
//       Access: Published
//  Description: See SocketStream::set_collect_tcp_interval().
//////////////////////////////////////////////////////////////////// 2 4 this 3 121  8 interval 1 120  
43 14 Dtool_ayCls4oX 0 6 51 120 0 14 Dtool_ayCls4oX 291 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::get_collect_tcp_interval
//       Access: Published
//  Description: See SocketStream::get_collect_tcp_interval().
//////////////////////////////////////////////////////////////////// 1 4 this 3 128  
44 14 Dtool_ayClHOJb 0 6 52 103 0 14 Dtool_ayClHOJb 270 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::consider_flush
//       Access: Published
//  Description: See SocketStream::consider_flush()
//////////////////////////////////////////////////////////////////// 1 4 this 3 121  
45 14 Dtool_ayCl8T3a 0 6 53 103 0 14 Dtool_ayCl8T3a 252 ////////////////////////////////////////////////////////////////////
//     Function: SocketStreamRecorder::flush
//       Access: Published
//  Description: See SocketStream::flush()
//////////////////////////////////////////////////////////////////// 1 4 this 3 121  
46 14 Dtool_ayCltYL0 0 7 54 105 0 14 Dtool_ayCltYL0 0 0 
36
94 12 RecorderBase 0 26625 12 RecorderBase 12 RecorderBase 0 0 0 0 48 0 3 49 50 51 0 0 1 5 95 47 0 0 0 1274
////////////////////////////////////////////////////////////////////
//       Class : RecorderBase
// Description : This is the base class to a number of objects that
//               record particular kinds of user input (like a
//               MouseRecorder) to use in conjunction with a
//               RecorderController to record the user's inputs
//               for a session.
//
//               Note that RecorderBase does not actually inherit from
//               TypedObject, even though it defines get_type().  The
//               assumption is that the classes that derive from
//               RecorderBase might also inherit independently from
//               TypedObject.
//
//               It also does not inherit from TypedWritable, but it
//               defines a method called write_recorder() which is
//               very similar to a TypedWritable's write_datagram().
//               Classes that derive from RecorderBase and also
//               inherit from TypedWritable may choose to remap
//               write_recorder() to do exactly the same thing as
//               write_datagram(), or they may choose to write
//               something slightly different.
////////////////////////////////////////////////////////////////////

95 14 ReferenceCount 0 2049 14 ReferenceCount 14 ReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 425
////////////////////////////////////////////////////////////////////
//       Class : ReferenceCount
// Description : A base class for all things that want to be
//               reference-counted.  ReferenceCount works in
//               conjunction with PointerTo to automatically delete
//               objects when the last pointer to them goes away.
////////////////////////////////////////////////////////////////////

96 13 MouseRecorder 0 26625 13 MouseRecorder 13 MouseRecorder 0 0 0 1 56 57 0 1 58 0 0 2 3 97 52 53 3 94 54 55 0 0 626
////////////////////////////////////////////////////////////////////
//       Class : MouseRecorder
// Description : This object records any data generated by a
//               particular MouseAndKeyboard node on the datagraph for
//               a session for eventual playback via a
//               DataGraphPlayback (and a PlaybackController).  To use
//               it, make it a child of the node you wish to record.
//               It also serves as a pass-through, so that additional
//               child nodes may be parented directly to it.
////////////////////////////////////////////////////////////////////

97 8 DataNode 0 2049 8 DataNode 8 DataNode 0 0 0 0 0 0 0 0 0 0 0 0 695
////////////////////////////////////////////////////////////////////
//       Class : DataNode
// Description : The fundamental type of node for the data graph.  The
//               DataNode class is itself primarily intended as an
//               abstract class; it defines no inputs and no outputs.
//               Most kinds of data nodes will derive from this to
//               specify the inputs and outputs in the constructor.
//
//               DataNode does not attempt to cycle its data with a
//               PipelineCycler.  The data graph is intended to be
//               used only within a single thread.
////////////////////////////////////////////////////////////////////

98 18 RecorderController 0 75777 18 RecorderController 18 RecorderController 0 0 0 1 59 0 0 22 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 0 0 1 0 99 0 0 0 0 353
////////////////////////////////////////////////////////////////////
//       Class : RecorderController
// Description : This object manages the process of recording the
//               user's runtime inputs to a bam file so that the
//               session can be recreated later.
////////////////////////////////////////////////////////////////////

99 19 TypedReferenceCount 0 2049 19 TypedReferenceCount 19 TypedReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 710
////////////////////////////////////////////////////////////////////
//       Class : TypedReferenceCount
// Description : A base class for things which need to inherit from
//               both TypedObject and from ReferenceCount.  It's
//               convenient to define this intermediate base class
//               instead of multiply inheriting from the two classes
//               each time they are needed, so that we can sensibly
//               pass around pointers to things which are both
//               TypedObjects and ReferenceCounters.
//               
//               See also TypedObject for detailed instructions.
////////////////////////////////////////////////////////////////////

100 20 SocketStreamRecorder 0 75777 20 SocketStreamRecorder 20 SocketStreamRecorder 0 0 0 1 82 48 0 11 83 84 85 86 87 88 89 90 91 92 93 0 0 1 0 94 0 0 0 0 622
////////////////////////////////////////////////////////////////////
//       Class : SocketStreamRecorder
// Description : Records any data received from the indicated socket
//               stream.  On playback, it will act as if the incoming
//               data is coming over the wire again even if an actual
//               connection is not available.
//
//               Outbound data will not be recorded, but will be sent
//               straight through to the socket if it is connected, or
//               silently ignored if it is not.
////////////////////////////////////////////////////////////////////

101 20 RecorderBase const * 0 8576 20 RecorderBase const * 20 RecorderBase const * 0 0 102 0 0 0 0 0 0 0 0 0 0

102 18 RecorderBase const 0 8832 18 RecorderBase const 18 RecorderBase const 0 0 94 0 0 0 0 0 0 0 0 0 0

103 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0

104 10 TypeHandle 0 2048 10 TypeHandle 10 TypeHandle 0 0 0 0 0 0 0 0 0 0 0 0 1098
////////////////////////////////////////////////////////////////////
//       Class : TypeHandle
// Description : TypeHandle is the identifier used to differentiate
//               C++ class types.  Any C++ classes that inherit from
//               some base class, and must be differentiated at run
//               time, should store a static TypeHandle object that
//               can be queried through a static member function
//               named get_class_type().  Most of the time, it is also
//               desirable to inherit from TypedObject, which provides
//               some virtual functions to return the TypeHandle for a
//               particular instance.
//
//               At its essence, a TypeHandle is simply a unique
//               identifier that is assigned by the TypeRegistry.  The
//               TypeRegistry stores a tree of TypeHandles, so that
//               ancestry of a particular type may be queried, and the
//               type name may be retrieved for run-time display.
////////////////////////////////////////////////////////////////////

105 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 104 0 0 0 0 0 0 0 0 0 0

106 14 RecorderBase * 0 8576 14 RecorderBase * 14 RecorderBase * 0 0 94 0 0 0 0 0 0 0 0 0 0

107 16 ReferenceCount * 0 8576 16 ReferenceCount * 16 ReferenceCount * 0 0 95 0 0 0 0 0 0 0 0 0 0

108 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0

109 15 MouseRecorder * 0 8576 15 MouseRecorder * 15 MouseRecorder * 0 0 96 0 0 0 0 0 0 0 0 0 0

110 10 DataNode * 0 8576 10 DataNode * 10 DataNode * 0 0 97 0 0 0 0 0 0 0 0 0 0

111 20 RecorderController * 0 8576 20 RecorderController * 20 RecorderController * 0 0 98 0 0 0 0 0 0 0 0 0 0

112 16 Filename const * 0 8576 16 Filename const * 16 Filename const * 0 0 113 0 0 0 0 0 0 0 0 0 0

113 14 Filename const 0 8832 14 Filename const 14 Filename const 0 0 114 0 0 0 0 0 0 0 0 0 0

114 8 Filename 0 2048 8 Filename 8 Filename 0 0 0 0 0 0 0 0 0 0 0 0 869
////////////////////////////////////////////////////////////////////
//       Class : Filename
// Description : The name of a file, such as a texture file or an Egg
//               file.  Stores the full pathname, and includes
//               functions for extracting out the directory prefix
//               part and the file extension and stuff.
//
//               A Filename is also aware of the mapping between the
//               Unix-like filename convention we use internally, and
//               the local OS's specific filename convention, and it
//               knows how to perform basic OS-specific I/O, like
//               testing for file existence and searching a
//               searchpath, as well as the best way to open an
//               fstream for reading or writing.
////////////////////////////////////////////////////////////////////

115 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0

116 26 RecorderController const * 0 8576 26 RecorderController const * 26 RecorderController const * 0 0 117 0 0 0 0 0 0 0 0 0 0

117 24 RecorderController const 0 8832 24 RecorderController const 24 RecorderController const 0 0 98 0 0 0 0 0 0 0 0 0 0

118 12 unsigned int 0 8198 12 unsigned int 12 unsigned int 0 1 0 0 0 0 0 0 0 0 0 0 0

119 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0

120 6 double 0 8194 6 double 6 double 0 3 0 0 0 0 0 0 0 0 0 0 0

121 22 SocketStreamRecorder * 0 8576 22 SocketStreamRecorder * 22 SocketStreamRecorder * 0 0 100 0 0 0 0 0 0 0 0 0 0

122 14 SocketStream * 0 8576 14 SocketStream * 14 SocketStream * 0 0 123 0 0 0 0 0 0 0 0 0 0

123 12 SocketStream 0 2048 12 SocketStream 12 SocketStream 0 0 0 0 0 0 0 0 0 0 0 0 285
////////////////////////////////////////////////////////////////////
//       Class : SocketStream
// Description : A base class for iostreams that read and write to a
//               (possibly non-blocking) socket.
////////////////////////////////////////////////////////////////////

124 10 Datagram * 0 8576 10 Datagram * 10 Datagram * 0 0 125 0 0 0 0 0 0 0 0 0 0

125 8 Datagram 0 2048 8 Datagram 8 Datagram 0 0 0 0 0 0 0 0 0 0 0 0 900
////////////////////////////////////////////////////////////////////
//       Class : Datagram
// Description : An ordered list of data elements, formatted in memory
//               for transmission over a socket or writing to a data
//               file.
//
//               Data elements should be added one at a time, in
//               order, to the Datagram.  The nature and contents of
//               the data elements are totally up to the user.  When a
//               Datagram has been transmitted and received, its data
//               elements may be extracted using a DatagramIterator;
//               it is up to the caller to know the correct type of
//               each data element in order.
//
//               A Datagram is itself headerless; it is simply a
//               collection of data elements.
////////////////////////////////////////////////////////////////////

126 16 Datagram const * 0 8576 16 Datagram const * 16 Datagram const * 0 0 127 0 0 0 0 0 0 0 0 0 0

127 14 Datagram const 0 8832 14 Datagram const 14 Datagram const 0 0 125 0 0 0 0 0 0 0 0 0 0

128 28 SocketStreamRecorder const * 0 8576 28 SocketStreamRecorder const * 28 SocketStreamRecorder const * 0 0 129 0 0 0 0 0 0 0 0 0 0

129 26 SocketStreamRecorder const 0 8832 26 SocketStreamRecorder const 26 SocketStreamRecorder const 0 0 100 0 0 0 0 0 0 0 0 0 0

0
0
0
