Sneed-Group/Poodletooth-iLand
1
0
Fork 0
mirror of https://github.com/Sneed-Group/Poodletooth-iLand synced 2024-12-26 21:22:27 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions
Poodletooth-iLand/panda/pandac/input/libp3recorder.in

1048 lines
54 KiB
Text
Raw Normal View History

Initial commit
2015-03-03 16:10:12 -06:00
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
Reference in a new issue Copy permalink