1412103843
2 2
12 libp3collide 4 dlaq 12 panda3d.core 
261
274 20 get_collision_origin 0 6 535 36 CollisionSolid::get_collision_origin 0 1 1 0
70
virtual LPoint3f CollisionSolid::get_collision_origin(void) const = 0;

275 12 set_tangible 0 4 535 28 CollisionSolid::set_tangible 0 1 2 1078
// Filename: collisionSolid.I
// Created by:  drose (27Jun00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionSolid::set_tangible
//       Access: Published
//  Description: Sets the current state of the 'tangible' flag.  Set
//               this true to make the solid tangible, so that a
//               CollisionHandlerPusher will not allow another object
//               to intersect it, or false to make it intangible, so
//               that a CollisionHandlerPusher will ignore it except
//               to throw an event.
////////////////////////////////////////////////////////////////////
56
inline void CollisionSolid::set_tangible(bool tangible);

276 11 is_tangible 0 4 535 27 CollisionSolid::is_tangible 0 1 3 541
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::is_tangible
//       Access: Published
//  Description: Returns whether the solid is considered 'tangible' or
//               not.  An intangible solid has no effect in a
//               CollisionHandlerPusher (except to throw an event);
//               it's useful for defining 'trigger' planes and
//               spheres, that cause an effect when passed through.
////////////////////////////////////////////////////////////////////
52
inline bool CollisionSolid::is_tangible(void) const;

277 20 set_effective_normal 0 4 535 36 CollisionSolid::set_effective_normal 0 1 4 720
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::set_effective_normal
//       Access: Published
//  Description: Records a false normal for this CollisionSolid that
//               will be reported by the collision system with all
//               collisions into it, instead of its actual normal.
//               This is useful as a workaround for the problem of an
//               avatar wanting to stand on a sloping ground; by
//               storing a false normal, the ground appears to be
//               perfectly level, and the avatar does not tend to
//               slide down it.
////////////////////////////////////////////////////////////////////
84
inline void CollisionSolid::set_effective_normal(LVector3f const &effective_normal);

278 22 clear_effective_normal 0 4 535 38 CollisionSolid::clear_effective_normal 0 1 5 315
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::clear_effective_normal
//       Access: Published
//  Description: Removes the normal previously set by
//               set_effective_normal().
////////////////////////////////////////////////////////////////////
57
inline void CollisionSolid::clear_effective_normal(void);

279 20 has_effective_normal 0 4 535 36 CollisionSolid::has_effective_normal 0 1 6 337
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::has_effective_normal
//       Access: Published
//  Description: Returns true if a special normal was set by
//               set_effective_normal(), false otherwise.
////////////////////////////////////////////////////////////////////
61
inline bool CollisionSolid::has_effective_normal(void) const;

280 20 get_effective_normal 0 4 535 36 CollisionSolid::get_effective_normal 0 1 7 401
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::get_effective_normal
//       Access: Published
//  Description: Returns the normal that was set by
//               set_effective_normal().  It is an error to call this
//               unless has_effective_normal() returns true.
////////////////////////////////////////////////////////////////////
73
inline LVector3f const &CollisionSolid::get_effective_normal(void) const;

281 28 set_respect_effective_normal 0 4 535 44 CollisionSolid::set_respect_effective_normal 0 1 8 605
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::set_respect_effective_normal
//       Access: Published
//  Description: This is only meaningful for CollisionSolids that will
//               be added to a traverser as colliders.  It is normally
//               true, but if set false, it means that this particular
//               solid does not care about the "effective" normal of
//               other solids it meets, but rather always uses the
//               true normal.
////////////////////////////////////////////////////////////////////
88
inline void CollisionSolid::set_respect_effective_normal(bool respect_effective_normal);

282 28 get_respect_effective_normal 0 4 535 44 CollisionSolid::get_respect_effective_normal 0 1 9 279
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::get_respect_effective_normal
//       Access: Published
//  Description: See set_respect_effective_normal().
////////////////////////////////////////////////////////////////////
69
inline bool CollisionSolid::get_respect_effective_normal(void) const;

283 10 get_bounds 0 4 535 26 CollisionSolid::get_bounds 0 1 10 262
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::get_bounds
//       Access: Protected
//  Description: Returns the solid's bounding volume.
////////////////////////////////////////////////////////////////////
72
ConstPointerTo< BoundingVolume > CollisionSolid::get_bounds(void) const;

284 10 set_bounds 0 4 535 26 CollisionSolid::set_bounds 0 1 11 262
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::set_bounds
//       Access: Protected
//  Description: Returns the solid's bounding volume.
////////////////////////////////////////////////////////////////////
71
void CollisionSolid::set_bounds(BoundingVolume const &bounding_volume);

285 6 output 0 6 535 22 CollisionSolid::output 0 1 12 227
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::output
//       Access: Public, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
56
virtual void CollisionSolid::output(ostream &out) const;

286 5 write 0 6 535 21 CollisionSolid::write 0 2 13 14 226
////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::write
//       Access: Public, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
79
virtual void CollisionSolid::write(ostream &out, int indent_level = (0)) const;

287 14 get_class_type 0 4 535 30 CollisionSolid::get_class_type 0 1 15 0
55
static TypeHandle CollisionSolid::get_class_type(void);

288 12 CollisionBox 0 4 537 26 CollisionBox::CollisionBox 0 2 16 17 1644
// Filename: collisionBox.I
// Created by:  amith tudur (31Jul09)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionBox::Constructor
//       Access: Public
//  Description: Create the Box by giving a Center and distances of
//               of each of the sides of box from the Center.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::Constructor
//       Access: Public
//  Description: Create the Box by Specifying the Diagonal Points
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::Default constructor
//       Access: Protected
//  Description: Creates an invalid Box.  Only used when reading
//               from a bam file.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
162
inline CollisionBox::CollisionBox(LPoint3f const &center, float x, float y, float z);
inline CollisionBox::CollisionBox(LPoint3f const &min, LPoint3f const &max);

289 14 get_num_points 0 4 537 28 CollisionBox::get_num_points 0 1 18 285
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_num_points
//       Access: Published
//  Description: Returns 8: the number of vertices of a rectangular solid.
////////////////////////////////////////////////////////////////////
52
inline int CollisionBox::get_num_points(void) const;

290 14 get_point_aabb 0 4 537 28 CollisionBox::get_point_aabb 0 1 19 284
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_point_aabb
//       Access: Published
//  Description: Returns the nth vertex of the Axis Aligned Bounding Box.
////////////////////////////////////////////////////////////////////
58
inline LPoint3f CollisionBox::get_point_aabb(int n) const;

291 9 get_point 0 4 537 23 CollisionBox::get_point 0 1 20 257
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_point
//       Access: Published
//  Description: Returns the nth vertex of the OBB.
////////////////////////////////////////////////////////////////////
53
inline LPoint3f CollisionBox::get_point(int n) const;

292 14 get_num_planes 0 4 537 28 CollisionBox::get_num_planes 0 1 21 282
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_num_planes
//       Access: Published
//  Description: Returns 6: the number of faces of a rectangular solid.
////////////////////////////////////////////////////////////////////
52
inline int CollisionBox::get_num_planes(void) const;

293 9 set_plane 0 4 537 23 CollisionBox::set_plane 0 1 22 269
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::set_plane
//       Access: Published
//  Description: Creates the nth face of the rectangular solid.
////////////////////////////////////////////////////////////////////
52
inline LPlanef CollisionBox::set_plane(int n) const;

294 9 get_plane 0 4 537 23 CollisionBox::get_plane 0 1 23 269
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_plane
//       Access: Published
//  Description: Returns the nth face of the rectangular solid.
////////////////////////////////////////////////////////////////////
52
inline LPlanef CollisionBox::get_plane(int n) const;

295 10 set_center 0 4 537 24 CollisionBox::set_center 0 2 24 25 448
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::set_center
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::set_center
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
126
inline void CollisionBox::set_center(LPoint3f const &center);
inline void CollisionBox::set_center(float x, float y, float z);

296 10 get_center 0 4 537 24 CollisionBox::get_center 0 1 26 223
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_center
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
60
inline LPoint3f const &CollisionBox::get_center(void) const;

297 10 get_radius 0 4 537 24 CollisionBox::get_radius 0 1 27 223
////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_radius
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
50
inline float CollisionBox::get_radius(void) const;

298 14 get_class_type 0 4 537 28 CollisionBox::get_class_type 0 1 28 0
53
static TypeHandle CollisionBox::get_class_type(void);

299 13 ~CollisionBox 0 4 537 27 CollisionBox::~CollisionBox 0 0 0
34
CollisionBox::~CollisionBox(void);

300 14 get_class_type 0 4 538 32 CollisionHandler::get_class_type 0 1 29 0
57
static TypeHandle CollisionHandler::get_class_type(void);

301 17 ~CollisionHandler 0 4 538 35 CollisionHandler::~CollisionHandler 0 0 0
42
CollisionHandler::~CollisionHandler(void);

302 13 CollisionNode 0 4 540 28 CollisionNode::CollisionNode 0 1 30 454
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::Copy Constructor
//       Access: Protected
//  Description:
////////////////////////////////////////////////////////////////////
63
CollisionNode::CollisionNode(basic_string< char > const &name);

303 16 set_collide_mask 0 4 540 31 CollisionNode::set_collide_mask 0 1 31 821
// Filename: collisionNode.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionNode::set_collide_mask
//       Access: Published
//  Description: Simultaneously sets both the "from" and "into"
//               CollideMask values to the same thing.
////////////////////////////////////////////////////////////////////
78
inline void CollisionNode::set_collide_mask(BitMask< unsigned int, 32 > mask);

304 21 set_from_collide_mask 0 4 540 36 CollisionNode::set_from_collide_mask 0 1 32 509
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::set_from_collide_mask
//       Access: Published
//  Description: Sets the "from" CollideMask.  In order for a
//               collision to be detected from this object into
//               another object, the intersection of this object's
//               "from" mask and the other object's "into" mask must
//               be nonzero.
////////////////////////////////////////////////////////////////////
76
void CollisionNode::set_from_collide_mask(BitMask< unsigned int, 32 > mask);

305 21 set_into_collide_mask 0 4 540 36 CollisionNode::set_into_collide_mask 0 1 33 509
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::set_into_collide_mask
//       Access: Published
//  Description: Sets the "into" CollideMask.  In order for a
//               collision to be detected from another object into
//               this object, the intersection of the other object's
//               "from" mask and this object's "into" mask must be
//               nonzero.
////////////////////////////////////////////////////////////////////
83
inline void CollisionNode::set_into_collide_mask(BitMask< unsigned int, 32 > mask);

306 21 get_from_collide_mask 0 4 540 36 CollisionNode::get_from_collide_mask 0 1 34 520
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_from_collide_mask
//       Access: Published
//  Description: Returns the current "from" CollideMask.  In order for
//               a collision to be detected from this object into
//               another object, the intersection of this object's
//               "from" mask and the other object's "into" mask must
//               be nonzero.
////////////////////////////////////////////////////////////////////
84
inline BitMask< unsigned int, 32 > CollisionNode::get_from_collide_mask(void) const;

307 21 get_into_collide_mask 0 4 540 36 CollisionNode::get_into_collide_mask 0 1 35 520
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_into_collide_mask
//       Access: Published
//  Description: Returns the current "into" CollideMask.  In order for
//               a collision to be detected from another object into
//               this object, the intersection of the other object's
//               "from" mask and this object's "into" mask must be
//               nonzero.
////////////////////////////////////////////////////////////////////
84
inline BitMask< unsigned int, 32 > CollisionNode::get_into_collide_mask(void) const;

308 12 clear_solids 0 4 540 27 CollisionNode::clear_solids 0 1 36 260
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::clear_solids
//       Access: Published
//  Description: Removes all solids from the node.
////////////////////////////////////////////////////////////////////
46
inline void CollisionNode::clear_solids(void);

309 14 get_num_solids 0 4 540 29 CollisionNode::get_num_solids 0 1 37 228
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_num_solids
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
53
inline int CollisionNode::get_num_solids(void) const;

310 9 get_solid 0 4 540 24 CollisionNode::get_solid 0 1 38 223
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_solid
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
78
inline ConstPointerTo< CollisionSolid > CollisionNode::get_solid(int n) const;

311 12 modify_solid 0 4 540 27 CollisionNode::modify_solid 0 1 39 226
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::modify_solid
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
70
inline PointerTo< CollisionSolid > CollisionNode::modify_solid(int n);

312 9 set_solid 0 4 540 24 CollisionNode::set_solid 0 1 40 268
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::set_solid
//       Access: Published
//  Description: Replaces the solid with the indicated index.
////////////////////////////////////////////////////////////////////
67
inline void CollisionNode::set_solid(int n, CollisionSolid *solid);

313 12 remove_solid 0 4 540 27 CollisionNode::remove_solid 0 1 41 340
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::remove_solid
//       Access: Published
//  Description: Removes the solid with the indicated index.  This
//               will shift all subsequent indices down by one.
////////////////////////////////////////////////////////////////////
47
inline void CollisionNode::remove_solid(int n);

314 9 add_solid 0 4 540 24 CollisionNode::add_solid 0 1 42 365
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::add_solid
//       Access: Published
//  Description: Adds the indicated solid to the node.  Returns the
//               index of the new solid within the node's list of
//               solids.
////////////////////////////////////////////////////////////////////
65
inline int CollisionNode::add_solid(CollisionSolid const *solid);

315 17 get_collider_sort 0 4 540 32 CollisionNode::get_collider_sort 0 1 43 350
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_collider_sort
//       Access: Published
//  Description: Returns the collider_sort value that has been set for
//               this particular node.  See set_collider_sort().
////////////////////////////////////////////////////////////////////
56
inline int CollisionNode::get_collider_sort(void) const;

316 17 set_collider_sort 0 4 540 32 CollisionNode::set_collider_sort 0 1 44 977
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::set_collider_sort
//       Access: Published
//  Description: Sets a particular collider_sort value on this node.
//               This controls the order in which colliders (that is,
//               "from nodes") are grouped together for the collision
//               traversal.
//
//               If there are 32 or fewer colliders added to any
//               particular CollisionTraverser, then this value has no
//               meaning.  It is only useful if there are many
//               colliders, which may force the CollisionTraverser to
//               make multiple passes through the data; in that case,
//               it may be a useful optimization to group colliders
//               that have similar bounding volumes together (by
//               giving them similar sort values).
////////////////////////////////////////////////////////////////////
55
inline void CollisionNode::set_collider_sort(int sort);

317 24 get_default_collide_mask 0 4 540 39 CollisionNode::get_default_collide_mask 0 1 45 333
////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_default_collide_mask
//       Access: Published, Static
//  Description: Returns the default into_collide_mask assigned to new
//               CollisionNodes.
////////////////////////////////////////////////////////////////////
88
static inline BitMask< unsigned int, 32 > CollisionNode::get_default_collide_mask(void);

318 14 get_class_type 0 4 540 29 CollisionNode::get_class_type 0 1 46 0
54
static TypeHandle CollisionNode::get_class_type(void);

319 18 CollisionTraverser 0 4 542 38 CollisionTraverser::CollisionTraverser 0 2 47 48 230
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
85
CollisionTraverser::CollisionTraverser(basic_string< char > const &name = ("ctrav"));

320 19 ~CollisionTraverser 0 4 542 39 CollisionTraverser::~CollisionTraverser 0 0 229
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
46
CollisionTraverser::~CollisionTraverser(void);

321 26 set_respect_prev_transform 0 4 542 46 CollisionTraverser::set_respect_prev_transform 0 1 49 1206
// Filename: collisionTraverser.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionTraverser::set_respect_prev_transform
//       Access: Published
//  Description: Sets the flag that indicates whether the
//               prev_transform stored on a node (as updated via
//               set_fluid_pos(), etc.) is respected to calculate
//               collisions.  If this is true, certain types of
//               collision tests will be enhanced by the information
//               about objects in motion.  If this is false, objects
//               are always considered to be static.  The default is
//               false.
////////////////////////////////////////////////////////////////////
70
inline void CollisionTraverser::set_respect_prev_transform(bool flag);

322 26 get_respect_prev_transform 0 4 542 46 CollisionTraverser::get_respect_prev_transform 0 1 50 445
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_respect_prev_transform
//       Access: Published
//  Description: Returns the flag that indicates whether the
//               prev_transform stored on a node is respected to
//               calculate collisions.  See
//               set_respect_prev_transform().
////////////////////////////////////////////////////////////////////
71
inline bool CollisionTraverser::get_respect_prev_transform(void) const;

323 12 add_collider 0 4 542 32 CollisionTraverser::add_collider 0 1 51 779
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::add_collider
//       Access: Published
//  Description: Adds a new CollisionNode, representing an object that
//               will be tested for collisions into other objects,
//               along with the handler that will serve each detected
//               collision.  Each CollisionNode may be served by only
//               one handler at a time, but a given handler may serve
//               many CollisionNodes.
//
//               The handler that serves a particular node may be
//               changed from time to time by calling add_collider()
//               again on the same node.
////////////////////////////////////////////////////////////////////
91
void CollisionTraverser::add_collider(NodePath const &collider, CollisionHandler *handler);

324 15 remove_collider 0 4 542 35 CollisionTraverser::remove_collider 0 1 52 545
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::remove_collider
//       Access: Published
//  Description: Removes the collider (and its associated handler)
//               from the set of CollisionNodes that will be tested
//               each frame for collisions into other objects.
//               Returns true if the definition was found and removed,
//               false if it wasn't present to begin with.
////////////////////////////////////////////////////////////////////
67
bool CollisionTraverser::remove_collider(NodePath const &collider);

325 12 has_collider 0 4 542 32 CollisionTraverser::has_collider 0 1 53 397
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::has_collider
//       Access: Published
//  Description: Returns true if the indicated node is current in the
//               set of nodes that will be tested each frame for
//               collisions into other objects.
////////////////////////////////////////////////////////////////////
70
bool CollisionTraverser::has_collider(NodePath const &collider) const;

326 17 get_num_colliders 0 4 542 37 CollisionTraverser::get_num_colliders 0 1 54 348
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_num_colliders
//       Access: Published
//  Description: Returns the number of CollisionNodes that have been
//               added to the traverser via add_collider().
////////////////////////////////////////////////////////////////////
54
int CollisionTraverser::get_num_colliders(void) const;

327 12 get_collider 0 4 542 32 CollisionTraverser::get_collider 0 1 55 335
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_collider
//       Access: Published
//  Description: Returns the nth CollisionNode that has been
//               added to the traverser via add_collider().
////////////////////////////////////////////////////////////////////
55
NodePath CollisionTraverser::get_collider(int n) const;

328 11 get_handler 0 4 542 31 CollisionTraverser::get_handler 0 1 56 417
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_handler
//       Access: Published
//  Description: Returns the handler that is currently assigned to
//               serve the indicated collision node, or NULL if the
//               node is not on the traverser's set of active nodes.
////////////////////////////////////////////////////////////////////
82
CollisionHandler *CollisionTraverser::get_handler(NodePath const &collider) const;

329 15 clear_colliders 0 4 542 35 CollisionTraverser::clear_colliders 0 1 57 328
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::clear_colliders
//       Access: Published
//  Description: Completely empties the set of collision nodes and
//               their associated handlers.
////////////////////////////////////////////////////////////////////
47
void CollisionTraverser::clear_colliders(void);

330 8 traverse 0 4 542 28 CollisionTraverser::traverse 0 1 58 227
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::traverse
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
56
void CollisionTraverser::traverse(NodePath const &root);

331 12 set_recorder 0 4 542 32 CollisionTraverser::set_recorder 0 1 59 1220
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::set_recorder
//       Access: Published
//  Description: Uses the indicated CollisionRecorder object to start
//               recording the intersection tests made by each
//               subsequent call to traverse() on this object.  A
//               particular CollisionRecorder object can only record
//               one traverser at a time; if this object has already
//               been assigned to another traverser, that assignment
//               is broken.
//
//               This is intended to be used in a debugging mode to
//               try to determine what work is being performed by the
//               collision traversal.  Usually, attaching a recorder
//               will impose significant runtime overhead.
//
//               This does not transfer ownership of the
//               CollisionRecorder pointer; maintenance of that
//               remains the caller's responsibility.  If the
//               CollisionRecorder is destructed, it will cleanly
//               remove itself from the traverser.
////////////////////////////////////////////////////////////////////
67
void CollisionTraverser::set_recorder(CollisionRecorder *recorder);

332 12 has_recorder 0 4 542 32 CollisionTraverser::has_recorder 0 1 60 372
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::has_recorder
//       Access: Published
//  Description: Returns true if the CollisionTraverser has a
//               CollisionRecorder object currently assigned, false
//               otherwise.
////////////////////////////////////////////////////////////////////
57
inline bool CollisionTraverser::has_recorder(void) const;

333 12 get_recorder 0 4 542 32 CollisionTraverser::get_recorder 0 1 61 334
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_recorder
//       Access: Published
//  Description: Returns the CollisionRecorder currently assigned, or
//               NULL if no recorder is assigned.
////////////////////////////////////////////////////////////////////
71
inline CollisionRecorder *CollisionTraverser::get_recorder(void) const;

334 14 clear_recorder 0 4 542 34 CollisionTraverser::clear_recorder 0 1 62 343
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::clear_recorder
//       Access: Published
//  Description: Removes the CollisionRecorder from the traverser and
//               restores normal low-overhead operation.
////////////////////////////////////////////////////////////////////
53
inline void CollisionTraverser::clear_recorder(void);

335 15 show_collisions 0 4 542 35 CollisionTraverser::show_collisions 0 1 63 600
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::show_collisions
//       Access: Published
//  Description: This is a high-level function to create a
//               CollisionVisualizer object to render the collision
//               tests performed by this traverser.  The supplied root
//               should be any node in the scene graph; typically, the
//               top node (e.g. render).  The CollisionVisualizer will
//               be attached to this node.
////////////////////////////////////////////////////////////////////
79
CollisionVisualizer *CollisionTraverser::show_collisions(NodePath const &root);

336 15 hide_collisions 0 4 542 35 CollisionTraverser::hide_collisions 0 1 64 310
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::hide_collisions
//       Access: Published
//  Description: Undoes the effect of a previous call to
//               show_collisions().
////////////////////////////////////////////////////////////////////
47
void CollisionTraverser::hide_collisions(void);

337 6 output 0 4 542 26 CollisionTraverser::output 0 1 65 278
// DO_COLLISION_RECORDING

// DO_COLLISION_RECORDING
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::output
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
52
void CollisionTraverser::output(ostream &out) const;

338 5 write 0 4 542 25 CollisionTraverser::write 0 1 66 224
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::write
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
69
void CollisionTraverser::write(ostream &out, int indent_level) const;

339 14 get_class_type 0 4 542 34 CollisionTraverser::get_class_type 0 1 67 0
59
static TypeHandle CollisionTraverser::get_class_type(void);

340 6 output 0 4 544 25 CollisionRecorder::output 0 1 68 222
////////////////////////////////////////////////////////////////////
//     Function: CollisionRecorder::output
//       Access: Public
//  Description: 
////////////////////////////////////////////////////////////////////
51
void CollisionRecorder::output(ostream &out) const;

341 14 get_class_type 0 4 544 33 CollisionRecorder::get_class_type 0 1 69 0
58
static TypeHandle CollisionRecorder::get_class_type(void);

342 8 get_from 0 4 546 24 CollisionEntry::get_from 0 1 70 331
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_from
//       Access: Published
//  Description: Returns the CollisionSolid pointer for the particular
//               solid that triggered this collision.
////////////////////////////////////////////////////////////////////
66
inline CollisionSolid const *CollisionEntry::get_from(void) const;

343 8 has_into 0 4 546 24 CollisionEntry::has_into 0 1 71 578
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_into
//       Access: Published
//  Description: Returns true if the "into" solid is, in fact, a
//               CollisionSolid, and its pointer is known (in which
//               case get_into() may be called to retrieve it).  If
//               this returns false, the collision was detected into a
//               GeomNode, and there is no CollisionSolid pointer to
//               be retrieved.
////////////////////////////////////////////////////////////////////
49
inline bool CollisionEntry::has_into(void) const;

344 8 get_into 0 4 546 24 CollisionEntry::get_into 0 1 72 515
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_into
//       Access: Published
//  Description: Returns the CollisionSolid pointer for the particular
//               solid was collided into.  This pointer might be NULL
//               if the collision was into a piece of visible
//               geometry, instead of a normal CollisionSolid
//               collision; see has_into().
////////////////////////////////////////////////////////////////////
66
inline CollisionSolid const *CollisionEntry::get_into(void) const;

345 13 get_from_node 0 4 546 29 CollisionEntry::get_from_node 0 1 73 445
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_from_node
//       Access: Published
//  Description: Returns the node that contains the CollisionSolid
//               that triggered this collision.  This will be a node
//               that has been added to a CollisionTraverser via
//               add_collider().
////////////////////////////////////////////////////////////////////
64
inline CollisionNode *CollisionEntry::get_from_node(void) const;

346 13 get_into_node 0 4 546 29 CollisionEntry::get_into_node 0 1 74 532
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_into_node
//       Access: Published
//  Description: Returns the node that contains the CollisionSolid
//               that was collided into.  This returns a PandaNode
//               pointer instead of something more specific, because
//               it might be either a CollisionNode or a GeomNode.
//
//               Also see get_into_node_path().
////////////////////////////////////////////////////////////////////
60
inline PandaNode *CollisionEntry::get_into_node(void) const;

347 18 get_from_node_path 0 4 546 34 CollisionEntry::get_from_node_path 0 1 75 509
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_from_node_path
//       Access: Published
//  Description: Returns the NodePath that represents the
//               CollisionNode that contains the CollisionSolid that
//               triggered this collision.  This will be a NodePath
//               that has been added to a CollisionTraverser via
//               add_collider().
////////////////////////////////////////////////////////////////////
63
inline NodePath CollisionEntry::get_from_node_path(void) const;

348 18 get_into_node_path 0 4 546 34 CollisionEntry::get_into_node_path 0 1 76 651
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_into_node_path
//       Access: Published
//  Description: Returns the NodePath that represents the specific
//               CollisionNode or GeomNode instance that was collided
//               into.  This is the same node returned by
//               get_into_node(), represented as a NodePath; however,
//               it may be more useful because the NodePath can
//               resolve the particular instance of the node, if there
//               is more than one.
////////////////////////////////////////////////////////////////////
63
inline NodePath CollisionEntry::get_into_node_path(void) const;

349 5 set_t 0 4 546 21 CollisionEntry::set_t 0 1 77 309
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_t
//       Access: Published
//  Description: Sets a time value for this collision relative to
//               other CollisionEntries
////////////////////////////////////////////////////////////////////
43
inline void CollisionEntry::set_t(float t);

350 5 get_t 0 4 546 21 CollisionEntry::get_t 0 1 78 310
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_t
//       Access: Published
//  Description: returns time value for this collision relative to
//               other CollisionEntries
////////////////////////////////////////////////////////////////////
47
inline float CollisionEntry::get_t(void) const;

351 8 collided 0 4 546 24 CollisionEntry::collided 0 1 79 446
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::collided
//       Access: Published
//  Description: returns true if this represents an actual collision
//               as opposed to a potential collision, needed for
//               iterative collision resolution where path of
//               collider changes mid-frame
////////////////////////////////////////////////////////////////////
49
inline bool CollisionEntry::collided(void) const;

352 14 reset_collided 0 4 546 30 CollisionEntry::reset_collided 0 1 80 264
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::reset_collided
//       Access: Published
//  Description: prepare for another collision test
////////////////////////////////////////////////////////////////////
49
inline void CollisionEntry::reset_collided(void);

353 26 get_respect_prev_transform 0 4 546 42 CollisionEntry::get_respect_prev_transform 0 1 81 479
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_respect_prev_transform
//       Access: Published
//  Description: Returns true if the collision was detected by a
//               CollisionTraverser whose respect_prev_transform
//               flag was set true, meaning we should consider motion
//               significant in evaluating collisions.
////////////////////////////////////////////////////////////////////
67
inline bool CollisionEntry::get_respect_prev_transform(void) const;

354 17 set_surface_point 0 4 546 33 CollisionEntry::set_surface_point 0 1 82 445
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_surface_point
//       Access: Published
//  Description: Stores the point, on the surface of the "into"
//               object, at which a collision is detected.
//
//               This point is specified in the coordinate space of
//               the "into" object.
////////////////////////////////////////////////////////////////////
69
inline void CollisionEntry::set_surface_point(LPoint3f const &point);

355 18 set_surface_normal 0 4 546 34 CollisionEntry::set_surface_normal 0 1 83 439
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_surface_normal
//       Access: Published
//  Description: Stores the surface normal of the "into" object at the
//               point of the intersection.
//
//               This normal is specified in the coordinate space of
//               the "into" object.
////////////////////////////////////////////////////////////////////
72
inline void CollisionEntry::set_surface_normal(LVector3f const &normal);

356 18 set_interior_point 0 4 546 34 CollisionEntry::set_interior_point 0 1 84 682
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_interior_point
//       Access: Published
//  Description: Stores the point, within the interior of the "into"
//               object, which represents the depth to which the
//               "from" object has penetrated.  This can also be
//               described as the intersection point on the surface of
//               the "from" object (which is inside the "into"
//               object).
//
//               This point is specified in the coordinate space of
//               the "into" object.
////////////////////////////////////////////////////////////////////
70
inline void CollisionEntry::set_interior_point(LPoint3f const &point);

357 17 has_surface_point 0 4 546 33 CollisionEntry::has_surface_point 0 1 85 441
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_surface_point
//       Access: Published
//  Description: Returns true if the surface point has been specified,
//               false otherwise.  See get_surface_point().  Some
//               types of collisions may not compute the surface
//               point.
////////////////////////////////////////////////////////////////////
58
inline bool CollisionEntry::has_surface_point(void) const;

358 18 has_surface_normal 0 4 546 34 CollisionEntry::has_surface_normal 0 1 86 445
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_surface_normal
//       Access: Published
//  Description: Returns true if the surface normal has been specified,
//               false otherwise.  See get_surface_normal().  Some
//               types of collisions may not compute the surface
//               normal.
////////////////////////////////////////////////////////////////////
59
inline bool CollisionEntry::has_surface_normal(void) const;

359 18 has_interior_point 0 4 546 34 CollisionEntry::has_interior_point 0 1 87 445
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_interior_point
//       Access: Published
//  Description: Returns true if the interior point has been specified,
//               false otherwise.  See get_interior_point().  Some
//               types of collisions may not compute the interior
//               point.
////////////////////////////////////////////////////////////////////
59
inline bool CollisionEntry::has_interior_point(void) const;

360 15 set_contact_pos 0 4 546 31 CollisionEntry::set_contact_pos 0 1 88 455
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_contact_pos
//       Access: Published
//  Description: Stores the position of the "from" object at the
//               instant at which the collision is first detected.
//
//               This position is specified in the coordinate space of
//               the "into" object.
////////////////////////////////////////////////////////////////////
65
inline void CollisionEntry::set_contact_pos(LPoint3f const &pos);

361 18 set_contact_normal 0 4 546 34 CollisionEntry::set_contact_normal 0 1 89 425
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_contact_normal
//       Access: Published
//  Description: Stores the surface normal of the "into" object at the
//               contact pos.
//
//               This normal is specified in the coordinate space of
//               the "into" object.
////////////////////////////////////////////////////////////////////
72
inline void CollisionEntry::set_contact_normal(LVector3f const &normal);

362 15 has_contact_pos 0 4 546 31 CollisionEntry::has_contact_pos 0 1 90 438
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_contact_pos
//       Access: Published
//  Description: Returns true if the contact position has been specified,
//               false otherwise.  See get_contact_pos().  Some
//               types of collisions may not compute the contact
//               pos.
////////////////////////////////////////////////////////////////////
56
inline bool CollisionEntry::has_contact_pos(void) const;

363 18 has_contact_normal 0 4 546 34 CollisionEntry::has_contact_normal 0 1 91 445
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_contact_normal
//       Access: Published
//  Description: Returns true if the contact normal has been specified,
//               false otherwise.  See get_contact_normal().  Some
//               types of collisions may not compute the contact
//               normal.
////////////////////////////////////////////////////////////////////
59
inline bool CollisionEntry::has_contact_normal(void) const;

364 17 get_surface_point 0 4 546 33 CollisionEntry::get_surface_point 0 1 92 638
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_surface_point
//       Access: Published
//  Description: Returns the point, on the surface of the "into"
//               object, at which a collision is detected.  This can
//               be thought of as the first point of intersection.
//               However the contact point is the actual first point of
//               intersection.
//
//               The point will be converted into whichever coordinate
//               space the caller specifies.
////////////////////////////////////////////////////////////////////
72
LPoint3f CollisionEntry::get_surface_point(NodePath const &space) const;

365 18 get_surface_normal 0 4 546 34 CollisionEntry::get_surface_normal 0 1 93 465
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_surface_normal
//       Access: Published
//  Description: Returns the surface normal of the "into" object at
//               the point at which a collision is detected.
//
//               The normal will be converted into whichever coordinate
//               space the caller specifies.
////////////////////////////////////////////////////////////////////
74
LVector3f CollisionEntry::get_surface_normal(NodePath const &space) const;

366 18 get_interior_point 0 4 546 34 CollisionEntry::get_interior_point 0 1 94 772
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_interior_point
//       Access: Published
//  Description: Returns the point, within the interior of the "into"
//               object, which represents the depth to which the
//               "from" object has penetrated.  This can also be
//               described as the intersection point on the surface of
//               the "from" object (which is inside the "into"
//               object).  It can be thought of as the deepest point
//               of intersection.
//
//               The point will be converted into whichever coordinate
//               space the caller specifies.
////////////////////////////////////////////////////////////////////
73
LPoint3f CollisionEntry::get_interior_point(NodePath const &space) const;

367 7 get_all 0 4 546 23 CollisionEntry::get_all 0 1 95 515
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_all
//       Access: Published
//  Description: Simultaneously transforms the surface point, surface
//               normal, and interior point of the collision into the
//               indicated coordinate space.
//
//               Returns true if all three properties are available,
//               or false if any one of them is not.
////////////////////////////////////////////////////////////////////
136
bool CollisionEntry::get_all(NodePath const &space, LPoint3f &surface_point, LVector3f &surface_normal, LPoint3f &interior_point) const;

368 15 get_contact_pos 0 4 546 31 CollisionEntry::get_contact_pos 0 1 96 462
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_contact_pos
//       Access: Published
//  Description: Returns the position of the "from" object at the instant
//               that a collision is first detected.
//
//               The position will be converted into whichever coordinate
//               space the caller specifies.
////////////////////////////////////////////////////////////////////
70
LPoint3f CollisionEntry::get_contact_pos(NodePath const &space) const;

369 18 get_contact_normal 0 4 546 34 CollisionEntry::get_contact_normal 0 1 97 443
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_contact_normal
//       Access: Published
//  Description: Returns the surface normal of the "into" object at
//               the contact position.
//
//               The normal will be converted into whichever coordinate
//               space the caller specifies.
////////////////////////////////////////////////////////////////////
74
LVector3f CollisionEntry::get_contact_normal(NodePath const &space) const;

370 20 get_all_contact_info 0 4 546 36 CollisionEntry::get_all_contact_info 0 1 98 514
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_all_contact_info
//       Access: Published
//  Description: Simultaneously transforms the contact position and
//               contact normal of the collision into the
//               indicated coordinate space.
//
//               Returns true if all three properties are available,
//               or false if any one of them is not.
////////////////////////////////////////////////////////////////////
121
bool CollisionEntry::get_all_contact_info(NodePath const &space, LPoint3f &contact_pos, LVector3f &contact_normal) const;

371 6 output 0 4 546 22 CollisionEntry::output 0 1 99 222
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::output
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
48
void CollisionEntry::output(ostream &out) const;

372 5 write 0 4 546 21 CollisionEntry::write 0 2 100 101 221
////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::write
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
71
void CollisionEntry::write(ostream &out, int indent_level = (0)) const;

373 14 get_class_type 0 4 546 30 CollisionEntry::get_class_type 0 1 102 0
55
static TypeHandle CollisionEntry::get_class_type(void);

374 15 ~CollisionEntry 0 4 546 31 CollisionEntry::~CollisionEntry 0 0 0
38
CollisionEntry::~CollisionEntry(void);

375 14 CollisionPlane 0 4 548 30 CollisionPlane::CollisionPlane 0 2 103 104 1343
// Filename: collisionPlane.I
// Created by:  drose (25Apr00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionPlane::Default Constructor
//       Access: Protected
//  Description: This is only for the convenience of CollisionPolygon.
//               Normally, you should not attempt to create an
//               uninitialized CollisionPlane.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
127
inline CollisionPlane::CollisionPlane(LPlanef const &plane);
inline CollisionPlane::CollisionPlane(CollisionPlane const &copy);

376 10 get_normal 0 4 548 26 CollisionPlane::get_normal 0 1 105 225
////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::get_normal
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
56
inline LVector3f CollisionPlane::get_normal(void) const;

377 13 dist_to_plane 0 4 548 29 CollisionPlane::dist_to_plane 0 1 106 228
////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::dist_to_plane
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
72
inline float CollisionPlane::dist_to_plane(LPoint3f const &point) const;

378 9 set_plane 0 4 548 25 CollisionPlane::set_plane 0 1 107 224
////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::set_plane
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
60
inline void CollisionPlane::set_plane(LPlanef const &plane);

379 9 get_plane 0 4 548 25 CollisionPlane::get_plane 0 1 108 224
////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::get_plane
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
60
inline LPlanef const &CollisionPlane::get_plane(void) const;

380 4 flip 0 4 548 20 CollisionPlane::flip 0 1 109 266
////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::flip
//       Access: Published
//  Description: Convenience method to flip the plane in-place.
////////////////////////////////////////////////////////////////////
39
inline void CollisionPlane::flip(void);

381 14 get_class_type 0 4 548 30 CollisionPlane::get_class_type 0 1 110 0
55
static TypeHandle CollisionPlane::get_class_type(void);

382 15 ~CollisionPlane 0 4 548 31 CollisionPlane::~CollisionPlane 0 0 0
38
CollisionPlane::~CollisionPlane(void);

383 18 CollisionFloorMesh 0 4 549 38 CollisionFloorMesh::CollisionFloorMesh 0 1 111 1113
//: collisionPlane.I
// Created by:  drose (25Apr00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionPlane::Default Constructor
//       Access: Protected
//  Description: This is only for the convenience of CollisionPolygon.
//               Normally, you should not attempt to create an
//               uninitialized CollisionPlane.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionFloorMesh::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
52
inline CollisionFloorMesh::CollisionFloorMesh(void);

384 10 add_vertex 0 4 549 30 CollisionFloorMesh::add_vertex 0 1 112 266
////////////////////////////////////////////////////////////////////
//     Function: CollisionFloorMesh::add_vertex
//       Access: Published
//  Description: store away a vertex to index against
////////////////////////////////////////////////////////////////////
65
inline void CollisionFloorMesh::add_vertex(LPoint3f const &vert);

385 12 add_triangle 0 4 549 32 CollisionFloorMesh::add_triangle 0 1 113 263
////////////////////////////////////////////////////////////////////
//     Function: CollisionFloorMesh::add_triangle
//       Access: Published
//  Description: store a triangle for processing
////////////////////////////////////////////////////////////////////
101
void CollisionFloorMesh::add_triangle(unsigned int pointA, unsigned int pointB, unsigned int pointC);

386 16 get_num_vertices 0 4 549 36 CollisionFloorMesh::get_num_vertices 0 1 114 0
75
inline unsigned int const CollisionFloorMesh::get_num_vertices(void) const;

387 10 get_vertex 0 4 549 30 CollisionFloorMesh::get_vertex 0 1 115 0
79
inline LPoint3f const CollisionFloorMesh::get_vertex(unsigned int index) const;

388 17 get_num_triangles 0 4 549 37 CollisionFloorMesh::get_num_triangles 0 1 116 0
76
inline unsigned int const CollisionFloorMesh::get_num_triangles(void) const;

389 12 get_triangle 0 4 549 32 CollisionFloorMesh::get_triangle 0 1 117 0
81
inline LPoint3d const CollisionFloorMesh::get_triangle(unsigned int index) const;

390 14 get_class_type 0 4 549 34 CollisionFloorMesh::get_class_type 0 1 118 0
59
static TypeHandle CollisionFloorMesh::get_class_type(void);

391 19 ~CollisionFloorMesh 0 4 549 39 CollisionFloorMesh::~CollisionFloorMesh 0 0 0
46
CollisionFloorMesh::~CollisionFloorMesh(void);

392 16 CollisionPolygon 0 4 550 34 CollisionPolygon::CollisionPolygon 0 3 119 120 121 1726
// Filename: collisionPolygon.I
// Created by:  drose (25Apr00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionPolygon::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::Constructor
//       Access: Private
//  Description: Creates an invalid polygon.  Only used when reading
//               from a bam file.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
319
inline CollisionPolygon::CollisionPolygon(LVecBase3f const &a, LVecBase3f const &b, LVecBase3f const &c);
inline CollisionPolygon::CollisionPolygon(LVecBase3f const &a, LVecBase3f const &b, LVecBase3f const &c, LVecBase3f const &d);
inline CollisionPolygon::CollisionPolygon(LPoint3f const *begin, LPoint3f const *end);

393 14 get_num_points 0 4 550 32 CollisionPolygon::get_num_points 0 1 122 304
////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::get_num_points
//       Access: Published
//  Description: Returns the number of vertices of the
//               CollisionPolygon.
////////////////////////////////////////////////////////////////////
56
inline int CollisionPolygon::get_num_points(void) const;

394 9 get_point 0 4 550 27 CollisionPolygon::get_point 0 1 123 315
////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::get_point
//       Access: Published
//  Description: Returns the nth vertex of the CollisionPolygon,
//               expressed in 3-D space.
////////////////////////////////////////////////////////////////////
57
inline LPoint3f CollisionPolygon::get_point(int n) const;

395 13 verify_points 0 4 550 31 CollisionPolygon::verify_points 0 3 124 125 126 1500
////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::verify_points
//       Access: Published, Static
//  Description: Verifies that the indicated set of points will define
//               a valid CollisionPolygon: that is, at least three
//               non-collinear points, with no points repeated.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::verify_points
//       Access: Published, Static
//  Description: Verifies that the indicated set of points will define
//               a valid CollisionPolygon: that is, at least three
//               non-collinear points, with no points repeated.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::verify_points
//       Access: Public, Static
//  Description: Verifies that the indicated set of points will define
//               a valid CollisionPolygon: that is, at least three
//               non-collinear points, with no points repeated.
//
//               This does not check that the polygon defined is
//               convex; that check is made later, once we have
//               projected the points to 2-d space where the decision
//               is easier.
////////////////////////////////////////////////////////////////////
325
static inline bool CollisionPolygon::verify_points(LPoint3f const &a, LPoint3f const &b, LPoint3f const &c);
static inline bool CollisionPolygon::verify_points(LPoint3f const &a, LPoint3f const &b, LPoint3f const &c, LPoint3f const &d);
static bool CollisionPolygon::verify_points(LPoint3f const *begin, LPoint3f const *end);

396 8 is_valid 0 4 550 26 CollisionPolygon::is_valid 0 1 127 365
////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::is_valid
//       Access: Public
//  Description: Returns true if the CollisionPolygon is valid
//               (that is, it has at least three vertices), or false
//               otherwise.
////////////////////////////////////////////////////////////////////
44
bool CollisionPolygon::is_valid(void) const;

397 10 is_concave 0 4 550 28 CollisionPolygon::is_concave 0 1 128 334
////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::is_concave
//       Access: Public
//  Description: Returns true if the CollisionPolygon appears to be
//               concave, or false if it is safely convex.
////////////////////////////////////////////////////////////////////
46
bool CollisionPolygon::is_concave(void) const;

398 14 get_class_type 0 4 550 32 CollisionPolygon::get_class_type 0 1 129 0
57
static TypeHandle CollisionPolygon::get_class_type(void);

399 17 ~CollisionPolygon 0 4 550 35 CollisionPolygon::~CollisionPolygon 0 0 0
42
CollisionPolygon::~CollisionPolygon(void);

400 21 CollisionHandlerEvent 0 4 551 44 CollisionHandlerEvent::CollisionHandlerEvent 0 1 130 416
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::Constructor
//       Access: Public
//  Description: The default CollisionHandlerEvent will throw no
//               events.  Its pattern strings must first be set via a
//               call to add_in_pattern() and/or add_out_pattern().
////////////////////////////////////////////////////////////////////
51
CollisionHandlerEvent::CollisionHandlerEvent(void);

401 17 clear_in_patterns 0 4 551 40 CollisionHandlerEvent::clear_in_patterns 0 1 131 323
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::clear_in_patterns
//       Access: Public
//  Description: Removes all of the previously-added in patterns.  See
//               add_in_pattern.
////////////////////////////////////////////////////////////////////
59
inline void CollisionHandlerEvent::clear_in_patterns(void);

402 14 add_in_pattern 0 4 551 37 CollisionHandlerEvent::add_in_pattern 0 1 132 2355
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::add_in_pattern
//       Access: Public
//  Description: Adds a pattern string to the list of events that will
//               be generated in response to a collision.  The pattern
//               string describes how the event name will be composed.
//               It is a string that may contain any of the following:
//
//                  %fn  - the name of the "from" object's node
//                  %in  - the name of the "into" object's node
//                  %fs  - 't' if "from" is tangible, 'i' if intangible
//                  %is  - 't' if "into" is tangible, 'i' if intangible
//                  %ig  - 'c' if the collision is into a
//                          CollisionNode, 'g' if it is a geom.
//
//                  %(tag)fh - generate event only if "from" node has
//                          the indicated net tag.
//                  %(tag)fx - generate event only if "from" node does 
//                          not have the indicated net tag.
//                  %(tag)ih - generate event only if "into" node has
//                          the indicated net tag.
//                  %(tag)ix - generate event only if "into" node does 
//                          not have the indicated net tag.
//                  %(tag)ft - the indicated net tag value of the "from" node.
//                  %(tag)it - the indicated net tag value of the "into" node.
//
//               Parentheses in the above are literal and should be
//               included in the actual pattern.
//
//               The event name will be based on the in_pattern
//               string specified here, with all occurrences of the
//               above strings replaced with the corresponding values.
//
//               In general, the in_pattern event is thrown on the
//               first detection of a collision between two particular
//               nodes.  In subsequent passes, as long as a collision
//               between those two nodes continues to be detected each
//               frame, the again_pattern is thrown.  The first frame
//               in which the collision is no longer detected, the
//               out_pattern event is thrown.
////////////////////////////////////////////////////////////////////
90
inline void CollisionHandlerEvent::add_in_pattern(basic_string< char > const &in_pattern);

403 14 set_in_pattern 0 4 551 37 CollisionHandlerEvent::set_in_pattern 0 1 133 395
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::set_in_pattern
//       Access: Public
//  Description: This method is deprecated; it completely replaces all
//               the in patterns that have previously been set with
//               the indicated pattern.
////////////////////////////////////////////////////////////////////
90
inline void CollisionHandlerEvent::set_in_pattern(basic_string< char > const &in_pattern);

404 19 get_num_in_patterns 0 4 551 42 CollisionHandlerEvent::get_num_in_patterns 0 1 134 318
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_num_in_patterns
//       Access: Public
//  Description: Returns the number of in pattern strings that have
//               been added.
////////////////////////////////////////////////////////////////////
66
inline int CollisionHandlerEvent::get_num_in_patterns(void) const;

405 14 get_in_pattern 0 4 551 37 CollisionHandlerEvent::get_in_pattern 0 1 135 399
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_in_pattern
//       Access: Public
//  Description: Returns the nth pattern string that indicates how the
//               event names are generated for each collision
//               detected.  See add_in_pattern().
////////////////////////////////////////////////////////////////////
79
inline basic_string< char > CollisionHandlerEvent::get_in_pattern(int n) const;

406 20 clear_again_patterns 0 4 551 43 CollisionHandlerEvent::clear_again_patterns 0 1 136 329
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::clear_again_patterns
//       Access: Public
//  Description: Removes all of the previously-added in patterns.  See
//               add_again_pattern.
////////////////////////////////////////////////////////////////////
62
inline void CollisionHandlerEvent::clear_again_patterns(void);

407 17 add_again_pattern 0 4 551 40 CollisionHandlerEvent::add_again_pattern 0 1 137 1055
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::add_again_pattern
//       Access: Public
//  Description: Adds the pattern string that indicates how the event
//               names are generated when a collision between two
//               particular nodes is *still* detected.  This event is
//               thrown each consecutive time a collision between two
//               particular nodes is detected, starting with the
//               second time.
//
//               In general, the in_pattern event is thrown on the
//               first detection of a collision between two particular
//               nodes.  In subsequent passes, as long as a collision
//               between those two nodes continues to be detected each
//               frame, the again_pattern is thrown.  The first frame
//               in which the collision is no longer detected, the
//               out_pattern event is thrown.
////////////////////////////////////////////////////////////////////
96
inline void CollisionHandlerEvent::add_again_pattern(basic_string< char > const &again_pattern);

408 17 set_again_pattern 0 4 551 40 CollisionHandlerEvent::set_again_pattern 0 1 138 398
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::set_again_pattern
//       Access: Public
//  Description: This method is deprecated; it completely replaces all
//               the in patterns that have previously been set with
//               the indicated pattern.
////////////////////////////////////////////////////////////////////
96
inline void CollisionHandlerEvent::set_again_pattern(basic_string< char > const &again_pattern);

409 22 get_num_again_patterns 0 4 551 45 CollisionHandlerEvent::get_num_again_patterns 0 1 139 321
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_num_again_patterns
//       Access: Public
//  Description: Returns the number of in pattern strings that have
//               been added.
////////////////////////////////////////////////////////////////////
69
inline int CollisionHandlerEvent::get_num_again_patterns(void) const;

410 17 get_again_pattern 0 4 551 40 CollisionHandlerEvent::get_again_pattern 0 1 140 405
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_again_pattern
//       Access: Public
//  Description: Returns the nth pattern string that indicates how the
//               event names are generated for each collision
//               detected.  See add_again_pattern().
////////////////////////////////////////////////////////////////////
82
inline basic_string< char > CollisionHandlerEvent::get_again_pattern(int n) const;

411 18 clear_out_patterns 0 4 551 41 CollisionHandlerEvent::clear_out_patterns 0 1 141 325
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::clear_out_patterns
//       Access: Public
//  Description: Removes all of the previously-added in patterns.  See
//               add_out_pattern.
////////////////////////////////////////////////////////////////////
60
inline void CollisionHandlerEvent::clear_out_patterns(void);

412 15 add_out_pattern 0 4 551 38 CollisionHandlerEvent::add_out_pattern 0 1 142 877
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::add_out_pattern
//       Access: Public
//  Description: Adds the pattern string that indicates how the event
//               names are generated when a collision between two
//               particular nodes is *no longer* detected.
//
//               In general, the in_pattern event is thrown on the
//               first detection of a collision between two particular
//               nodes.  In subsequent passes, as long as a collision
//               between those two nodes continues to be detected each
//               frame, the again_pattern is thrown.  The first frame
//               in which the collision is no longer detected, the
//               out_pattern event is thrown.
////////////////////////////////////////////////////////////////////
92
inline void CollisionHandlerEvent::add_out_pattern(basic_string< char > const &out_pattern);

413 15 set_out_pattern 0 4 551 38 CollisionHandlerEvent::set_out_pattern 0 1 143 396
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::set_out_pattern
//       Access: Public
//  Description: This method is deprecated; it completely replaces all
//               the in patterns that have previously been set with
//               the indicated pattern.
////////////////////////////////////////////////////////////////////
92
inline void CollisionHandlerEvent::set_out_pattern(basic_string< char > const &out_pattern);

414 20 get_num_out_patterns 0 4 551 43 CollisionHandlerEvent::get_num_out_patterns 0 1 144 319
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_num_out_patterns
//       Access: Public
//  Description: Returns the number of in pattern strings that have
//               been added.
////////////////////////////////////////////////////////////////////
67
inline int CollisionHandlerEvent::get_num_out_patterns(void) const;

415 15 get_out_pattern 0 4 551 38 CollisionHandlerEvent::get_out_pattern 0 1 145 401
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_out_pattern
//       Access: Public
//  Description: Returns the nth pattern string that indicates how the
//               event names are generated for each collision
//               detected.  See add_out_pattern().
////////////////////////////////////////////////////////////////////
80
inline basic_string< char > CollisionHandlerEvent::get_out_pattern(int n) const;

416 5 clear 0 4 551 28 CollisionHandlerEvent::clear 0 1 146 887
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::clear
//       Access: Public
//  Description: Empties the list of elements that all colliders are
//               known to be colliding with.  No "out" events will be
//               thrown; if the same collision is detected next frame,
//               a new "in" event will be thrown for each collision.
//
//               This can be called each frame to defeat the
//               persistent "in" event mechanism, which prevents the
//               same "in" event from being thrown repeatedly.
//               However, also see add_again_pattern(), which can be
//               used to set the event that is thrown when a collision
//               is detected for two or more consecutive frames.
////////////////////////////////////////////////////////////////////
40
void CollisionHandlerEvent::clear(void);

417 5 flush 0 4 551 28 CollisionHandlerEvent::flush 0 1 147 272
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::flush
//       Access: Public
//  Description: Same as clear() except "out" events are thrown.
////////////////////////////////////////////////////////////////////
40
void CollisionHandlerEvent::flush(void);

418 14 get_class_type 0 4 551 37 CollisionHandlerEvent::get_class_type 0 1 148 0
62
static TypeHandle CollisionHandlerEvent::get_class_type(void);

419 22 ~CollisionHandlerEvent 0 4 551 45 CollisionHandlerEvent::~CollisionHandlerEvent 0 0 0
52
CollisionHandlerEvent::~CollisionHandlerEvent(void);

420 12 add_collider 0 4 552 38 CollisionHandlerPhysical::add_collider 0 2 149 150 1159
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::add_collider
//       Access: Published
//  Description: Adds a new collider to the list with a NodePath
//               that will be updated with the collider's new
//               position, or updates the existing collider with a new
//               NodePath object.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::add_collider
//       Access: Published
//  Description: Adds a new collider to the list with a NodePath
//               that will be updated with the collider's new
//               position, or updates the existing collider with a new
//               NodePath object.
//
//               The indicated DriveInterface will also be updated
//               with the target's new transform each frame.  This
//               method should be used when the target is directly
//               controlled by a DriveInterface.
////////////////////////////////////////////////////////////////////
222
void CollisionHandlerPhysical::add_collider(NodePath const &collider, NodePath const &target);
void CollisionHandlerPhysical::add_collider(NodePath const &collider, NodePath const &target, DriveInterface *drive_interface);

421 15 remove_collider 0 4 552 41 CollisionHandlerPhysical::remove_collider 0 1 151 336
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::remove_collider
//       Access: Published
//  Description: Removes the collider from the list of colliders that
//               this handler knows about.
////////////////////////////////////////////////////////////////////
73
bool CollisionHandlerPhysical::remove_collider(NodePath const &collider);

422 12 has_collider 0 4 552 38 CollisionHandlerPhysical::has_collider 0 1 152 335
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::has_collider
//       Access: Published
//  Description: Returns true if the handler knows about the indicated
//               collider, false otherwise.
////////////////////////////////////////////////////////////////////
76
bool CollisionHandlerPhysical::has_collider(NodePath const &collider) const;

423 15 clear_colliders 0 4 552 41 CollisionHandlerPhysical::clear_colliders 0 1 153 324
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::clear_colliders
//       Access: Published
//  Description: Completely empties the list of colliders this handler
//               knows about.
////////////////////////////////////////////////////////////////////
53
void CollisionHandlerPhysical::clear_colliders(void);

424 10 set_center 0 4 552 36 CollisionHandlerPhysical::set_center 0 1 154 1053
// Filename: collisionHandlerPhysical.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionHandlerPhysical::set_center
//       Access: Published
//  Description: Specifies an arbitrary NodePath that the handler is
//               always considered to be facing.  It does not detect
//               collisions with surfaces that appear to be facing
//               away from this NodePath.  This works best when the
//               collision surfaces in question are polygons.
////////////////////////////////////////////////////////////////////
73
inline void CollisionHandlerPhysical::set_center(NodePath const &center);

425 12 clear_center 0 4 552 38 CollisionHandlerPhysical::clear_center 0 1 155 291
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::clear_center
//       Access: Published
//  Description: Clears the center NodePath specified with set_center.
////////////////////////////////////////////////////////////////////
57
inline void CollisionHandlerPhysical::clear_center(void);

426 10 get_center 0 4 552 36 CollisionHandlerPhysical::get_center 0 1 156 353
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::get_center
//       Access: Published
//  Description: Returns the NodePath specified with set_center, or
//               the empty NodePath if nothing has been specified.
////////////////////////////////////////////////////////////////////
72
inline NodePath const &CollisionHandlerPhysical::get_center(void) const;

427 10 has_center 0 4 552 36 CollisionHandlerPhysical::has_center 0 1 157 334
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::has_center
//       Access: Published
//  Description: Returns true if a NodePath has been specified with
//               set_center(), false otherwise.
////////////////////////////////////////////////////////////////////
61
inline bool CollisionHandlerPhysical::has_center(void) const;

428 11 has_contact 0 4 552 37 CollisionHandlerPhysical::has_contact 0 1 158 537
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::has_contact
//       Access: Public
//  Description: Did the handler make any contacts with anything
//               on the last collision pass?  Depending on how your
//               world is setup, this can be used to tell if the
//               handler is out of the world (i.e. out of bounds).
//               That is the original use of this call.
////////////////////////////////////////////////////////////////////
62
inline bool CollisionHandlerPhysical::has_contact(void) const;

429 14 get_class_type 0 4 552 40 CollisionHandlerPhysical::get_class_type 0 1 159 0
65
static TypeHandle CollisionHandlerPhysical::get_class_type(void);

430 21 CollisionHandlerFloor 0 4 553 44 CollisionHandlerFloor::CollisionHandlerFloor 0 1 160 230
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
51
CollisionHandlerFloor::CollisionHandlerFloor(void);

431 10 set_offset 0 4 553 33 CollisionHandlerFloor::set_offset 0 1 161 910
// Filename: collisionHandlerFloor.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionHandlerFloor::set_offset
//       Access: Public
//  Description: Sets the linear offset to add to (or subtract from)
//               the highest detected collision point to determine the
//               actual height at which to set the collider.
////////////////////////////////////////////////////////////////////
60
inline void CollisionHandlerFloor::set_offset(float offset);

432 10 get_offset 0 4 553 33 CollisionHandlerFloor::get_offset 0 1 162 416
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::get_offset
//       Access: Public
//  Description: Returns the linear offset to add to (or subtract from)
//               the highest detected collision point to determine the
//               actual height at which to set the collider.
////////////////////////////////////////////////////////////////////
59
inline float CollisionHandlerFloor::get_offset(void) const;

433 9 set_reach 0 4 553 32 CollisionHandlerFloor::set_reach 0 1 163 317
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::set_reach
//       Access: Public
//  Description: Sets the reach to add to (or subtract from)
//               the highest collision point
////////////////////////////////////////////////////////////////////
58
inline void CollisionHandlerFloor::set_reach(float reach);

434 9 get_reach 0 4 553 32 CollisionHandlerFloor::get_reach 0 1 164 320
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::get_reach
//       Access: Public
//  Description: Returns the reach to add to (or subtract from)
//               the highest collision point
////////////////////////////////////////////////////////////////////
58
inline float CollisionHandlerFloor::get_reach(void) const;

435 16 set_max_velocity 0 4 553 39 CollisionHandlerFloor::set_max_velocity 0 1 165 469
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::set_max_velocity
//       Access: Public
//  Description: Sets the maximum speed at which the object will be
//               allowed to descend towards a floor below it, in units
//               per second.  Set this to zero to allow it to
//               instantly teleport any distance.
////////////////////////////////////////////////////////////////////
67
inline void CollisionHandlerFloor::set_max_velocity(float max_vel);

436 16 get_max_velocity 0 4 553 39 CollisionHandlerFloor::get_max_velocity 0 1 166 416
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::get_max_velocity
//       Access: Public
//  Description: Retrieves the maximum speed at which the object will
//               be allowed to descend towards a floor below it, in
//               units per second.  See set_max_velocity().
////////////////////////////////////////////////////////////////////
65
inline float CollisionHandlerFloor::get_max_velocity(void) const;

437 14 get_class_type 0 4 553 37 CollisionHandlerFloor::get_class_type 0 1 167 0
62
static TypeHandle CollisionHandlerFloor::get_class_type(void);

438 22 CollisionHandlerPusher 0 4 554 46 CollisionHandlerPusher::CollisionHandlerPusher 0 1 168 231
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPusher::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
53
CollisionHandlerPusher::CollisionHandlerPusher(void);

439 14 set_horizontal 0 4 554 38 CollisionHandlerPusher::set_horizontal 0 1 169 732
// Filename: collisionHandlerPusher.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionHandlerPusher::set_horizontal
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
62
inline void CollisionHandlerPusher::set_horizontal(bool flag);

440 14 get_horizontal 0 4 554 38 CollisionHandlerPusher::get_horizontal 0 1 170 234
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPusher::get_horizontal
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
63
inline bool CollisionHandlerPusher::get_horizontal(void) const;

441 14 get_class_type 0 4 554 38 CollisionHandlerPusher::get_class_type 0 1 171 0
63
static TypeHandle CollisionHandlerPusher::get_class_type(void);

442 27 CollisionHandlerFluidPusher 0 4 555 56 CollisionHandlerFluidPusher::CollisionHandlerFluidPusher 0 1 172 236
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFluidPusher::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
63
CollisionHandlerFluidPusher::CollisionHandlerFluidPusher(void);

443 14 get_class_type 0 4 555 43 CollisionHandlerFluidPusher::get_class_type 0 1 173 0
68
static TypeHandle CollisionHandlerFluidPusher::get_class_type(void);

444 28 ~CollisionHandlerFluidPusher 0 4 555 57 CollisionHandlerFluidPusher::~CollisionHandlerFluidPusher 0 0 0
64
CollisionHandlerFluidPusher::~CollisionHandlerFluidPusher(void);

445 23 CollisionHandlerGravity 0 4 556 48 CollisionHandlerGravity::CollisionHandlerGravity 0 1 174 232
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
55
CollisionHandlerGravity::CollisionHandlerGravity(void);

446 10 set_offset 0 4 556 35 CollisionHandlerGravity::set_offset 0 1 175 914
// Filename: CollisionHandlerGravity.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionHandlerGravity::set_offset
//       Access: Public
//  Description: Sets the linear offset to add to (or subtract from)
//               the highest detected collision point to determine the
//               actual height at which to set the collider.
////////////////////////////////////////////////////////////////////
62
inline void CollisionHandlerGravity::set_offset(float offset);

447 10 get_offset 0 4 556 35 CollisionHandlerGravity::get_offset 0 1 176 418
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_offset
//       Access: Public
//  Description: Returns the linear offset to add to (or subtract from)
//               the highest detected collision point to determine the
//               actual height at which to set the collider.
////////////////////////////////////////////////////////////////////
61
inline float CollisionHandlerGravity::get_offset(void) const;

448 9 set_reach 0 4 556 34 CollisionHandlerGravity::set_reach 0 1 177 319
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_reach
//       Access: Public
//  Description: Sets the reach to add to (or subtract from)
//               the highest collision point
////////////////////////////////////////////////////////////////////
60
inline void CollisionHandlerGravity::set_reach(float reach);

449 9 get_reach 0 4 556 34 CollisionHandlerGravity::get_reach 0 1 178 322
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_reach
//       Access: Public
//  Description: Returns the reach to add to (or subtract from)
//               the highest collision point
////////////////////////////////////////////////////////////////////
60
inline float CollisionHandlerGravity::get_reach(void) const;

450 19 get_airborne_height 0 4 556 44 CollisionHandlerGravity::get_airborne_height 0 1 179 527
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_airborne_height
//       Access: Public
//  Description: Return the height of the object from the ground.
//
//               The object might not necessarily be at rest.  Use
//               is_on_ground() if you want to know whether the
//               object is on the ground and at rest.
//
//               See Also: is_in_outer_space()
////////////////////////////////////////////////////////////////////
70
inline float CollisionHandlerGravity::get_airborne_height(void) const;

451 12 is_on_ground 0 4 556 37 CollisionHandlerGravity::is_on_ground 0 1 180 256
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::is_on_ground
//       Access: Public
//  Description: Is the object at rest?
////////////////////////////////////////////////////////////////////
62
inline bool CollisionHandlerGravity::is_on_ground(void) const;

452 19 get_impact_velocity 0 4 556 44 CollisionHandlerGravity::get_impact_velocity 0 1 181 586
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_impact_velocity
//       Access: Public
//  Description: How hard did the object hit the ground.
//               This value is set on impact with the ground.
//               You may want to watch (poll) on is_on_groun() and
//               when that is true, call get_impact_velocity().
//               Normally I avoid polling, but we are calling
//               is_on_ground() frequently anyway.
////////////////////////////////////////////////////////////////////
70
inline float CollisionHandlerGravity::get_impact_velocity(void) const;

453 18 get_contact_normal 0 4 556 43 CollisionHandlerGravity::get_contact_normal 0 1 182 240
////////////////////////////////////////////////////////////////////
//    Function : CollisionHandlerGravity::get_contact_normal
//      Access : Public
// Description : 
////////////////////////////////////////////////////////////////////
80
inline LVector3f const &CollisionHandlerGravity::get_contact_normal(void) const;

454 12 add_velocity 0 4 556 37 CollisionHandlerGravity::add_velocity 0 1 183 451
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::add_velocity
//       Access: Public
//  Description: Adds the sepcified amount to the current velocity.
//               This is mostly here allow this common operation to
//               be faster for scripting, but it's also more concise
//               even in cpp.
////////////////////////////////////////////////////////////////////
66
inline void CollisionHandlerGravity::add_velocity(float velocity);

455 12 set_velocity 0 4 556 37 CollisionHandlerGravity::set_velocity 0 1 184 269
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_velocity
//       Access: Public
//  Description: Sets the current vertical velocity.
////////////////////////////////////////////////////////////////////
66
inline void CollisionHandlerGravity::set_velocity(float velocity);

456 12 get_velocity 0 4 556 37 CollisionHandlerGravity::get_velocity 0 1 185 681
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_velocity
//       Access: Public
//  Description: Gets the current vertical velocity.
//
//               Generally, negative values mean the object is in
//               free fall; while postive values mean the object has
//               vertical thrust.
//
//               A zero value does not necessarily mean the object
//               on the ground, it may also be weightless and/or at
//               the apex of its jump.
//
//               See Also: is_on_ground() and get_gravity()
////////////////////////////////////////////////////////////////////
63
inline float CollisionHandlerGravity::get_velocity(void) const;

457 11 set_gravity 0 4 556 36 CollisionHandlerGravity::set_gravity 0 1 186 278
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_gravity
//       Access: Public
//  Description: Sets the linear gravity force (always plumb).
////////////////////////////////////////////////////////////////////
64
inline void CollisionHandlerGravity::set_gravity(float gravity);

458 11 get_gravity 0 4 556 36 CollisionHandlerGravity::get_gravity 0 1 187 278
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_gravity
//       Access: Public
//  Description: Gets the linear gravity force (always plumb).
////////////////////////////////////////////////////////////////////
62
inline float CollisionHandlerGravity::get_gravity(void) const;

459 16 set_max_velocity 0 4 556 41 CollisionHandlerGravity::set_max_velocity 0 1 188 471
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_max_velocity
//       Access: Public
//  Description: Sets the maximum speed at which the object will be
//               allowed to descend towards a floor below it, in units
//               per second.  Set this to zero to allow it to
//               instantly teleport any distance.
////////////////////////////////////////////////////////////////////
69
inline void CollisionHandlerGravity::set_max_velocity(float max_vel);

460 16 get_max_velocity 0 4 556 41 CollisionHandlerGravity::get_max_velocity 0 1 189 418
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_max_velocity
//       Access: Public
//  Description: Retrieves the maximum speed at which the object will
//               be allowed to descend towards a floor below it, in
//               units per second.  See set_max_velocity().
////////////////////////////////////////////////////////////////////
67
inline float CollisionHandlerGravity::get_max_velocity(void) const;

461 15 set_legacy_mode 0 4 556 40 CollisionHandlerGravity::set_legacy_mode 0 1 190 517
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_legacy_mode
//       Access: Public
//  Description: Enables old behavior required by Toontown
//               (Sellbot Factory lava room is good test case,
//               lava and conveyor belt specifically). Behavior
//               is to throw enter/exit events only for floor
//               that the toon is in contact with
////////////////////////////////////////////////////////////////////
71
inline void CollisionHandlerGravity::set_legacy_mode(bool legacy_mode);

462 15 get_legacy_mode 0 4 556 40 CollisionHandlerGravity::get_legacy_mode 0 1 191 275
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_legacy_mode
//       Access: Public
//  Description: returns true if legacy mode is enabled
////////////////////////////////////////////////////////////////////
65
inline bool CollisionHandlerGravity::get_legacy_mode(void) const;

463 14 get_class_type 0 4 556 39 CollisionHandlerGravity::get_class_type 0 1 192 0
64
static TypeHandle CollisionHandlerGravity::get_class_type(void);

464 28 CollisionHandlerHighestEvent 0 4 557 58 CollisionHandlerHighestEvent::CollisionHandlerHighestEvent 0 1 193 416
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::Constructor
//       Access: Public
//  Description: The default CollisionHandlerEvent will throw no
//               events.  Its pattern strings must first be set via a
//               call to add_in_pattern() and/or add_out_pattern().
////////////////////////////////////////////////////////////////////
65
CollisionHandlerHighestEvent::CollisionHandlerHighestEvent(void);

465 14 get_class_type 0 4 557 44 CollisionHandlerHighestEvent::get_class_type 0 1 194 0
69
static TypeHandle CollisionHandlerHighestEvent::get_class_type(void);

466 29 ~CollisionHandlerHighestEvent 0 4 557 59 CollisionHandlerHighestEvent::~CollisionHandlerHighestEvent 0 0 0
66
CollisionHandlerHighestEvent::~CollisionHandlerHighestEvent(void);

467 21 CollisionHandlerQueue 0 4 558 44 CollisionHandlerQueue::CollisionHandlerQueue 0 1 195 233
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
51
CollisionHandlerQueue::CollisionHandlerQueue(void);

468 12 sort_entries 0 4 558 35 CollisionHandlerQueue::sort_entries 0 1 196 540
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::sort_entries
//       Access: Published
//  Description: Sorts all the detected collisions front-to-back by
//               from_intersection_point() so that those intersection
//               points closest to the collider's origin (e.g., the
//               center of the CollisionSphere, or the point_a of a
//               CollisionSegment) appear first.
////////////////////////////////////////////////////////////////////
47
void CollisionHandlerQueue::sort_entries(void);

469 13 clear_entries 0 4 558 36 CollisionHandlerQueue::clear_entries 0 1 197 275
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::clear_entries
//       Access: Published
//  Description: Removes all the entries from the queue.
////////////////////////////////////////////////////////////////////
48
void CollisionHandlerQueue::clear_entries(void);

470 15 get_num_entries 0 4 558 38 CollisionHandlerQueue::get_num_entries 0 1 198 313
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::get_num_entries
//       Access: Published
//  Description: Returns the number of CollisionEntries detected last
//               pass.
////////////////////////////////////////////////////////////////////
55
int CollisionHandlerQueue::get_num_entries(void) const;

471 9 get_entry 0 4 558 32 CollisionHandlerQueue::get_entry 0 1 199 282
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::get_entry
//       Access: Published
//  Description: Returns the nth CollisionEntry detected last pass.
////////////////////////////////////////////////////////////////////
62
CollisionEntry *CollisionHandlerQueue::get_entry(int n) const;

472 6 output 0 4 558 29 CollisionHandlerQueue::output 0 1 200 229
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::output
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
55
void CollisionHandlerQueue::output(ostream &out) const;

473 5 write 0 4 558 28 CollisionHandlerQueue::write 0 2 201 202 228
////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::write
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
78
void CollisionHandlerQueue::write(ostream &out, int indent_level = (0)) const;

474 14 get_class_type 0 4 558 37 CollisionHandlerQueue::get_class_type 0 1 203 0
62
static TypeHandle CollisionHandlerQueue::get_class_type(void);

475 22 ~CollisionHandlerQueue 0 4 558 45 CollisionHandlerQueue::~CollisionHandlerQueue 0 0 0
52
CollisionHandlerQueue::~CollisionHandlerQueue(void);

476 15 CollisionSphere 0 4 559 32 CollisionSphere::CollisionSphere 0 2 204 205 1494
// Filename: collisionSphere.I
// Created by:  drose (24Apr00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionSphere::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::Default constructor
//       Access: Protected
//  Description: Creates an invalid sphere.  Only used when reading
//               from a bam file.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
163
inline CollisionSphere::CollisionSphere(LPoint3f const &center, float radius);
inline CollisionSphere::CollisionSphere(float cx, float cy, float cz, float radius);

477 10 set_center 0 4 559 27 CollisionSphere::set_center 0 2 206 207 454
////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::set_center
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::set_center
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
132
inline void CollisionSphere::set_center(LPoint3f const &center);
inline void CollisionSphere::set_center(float x, float y, float z);

478 10 get_center 0 4 559 27 CollisionSphere::get_center 0 1 208 226
////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::get_center
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
63
inline LPoint3f const &CollisionSphere::get_center(void) const;

479 10 set_radius 0 4 559 27 CollisionSphere::set_radius 0 1 209 226
////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::set_radius
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
54
inline void CollisionSphere::set_radius(float radius);

480 10 get_radius 0 4 559 27 CollisionSphere::get_radius 0 1 210 226
////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::get_radius
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
53
inline float CollisionSphere::get_radius(void) const;

481 14 get_class_type 0 4 559 31 CollisionSphere::get_class_type 0 1 211 0
56
static TypeHandle CollisionSphere::get_class_type(void);

482 16 ~CollisionSphere 0 4 559 33 CollisionSphere::~CollisionSphere 0 0 0
40
CollisionSphere::~CollisionSphere(void);

483 18 CollisionInvSphere 0 4 560 38 CollisionInvSphere::CollisionInvSphere 0 2 212 213 1509
// Filename: collisionInvSphere.I
// Created by:  drose (05Jan05)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionInvSphere::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionInvSphere::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionInvSphere::Default constructor
//       Access: Protected
//  Description: Creates an invalid sphere.  Only used when reading
//               from a bam file.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionInvSphere::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
175
inline CollisionInvSphere::CollisionInvSphere(LPoint3f const &center, float radius);
inline CollisionInvSphere::CollisionInvSphere(float cx, float cy, float cz, float radius);

484 14 get_class_type 0 4 560 34 CollisionInvSphere::get_class_type 0 1 214 0
59
static TypeHandle CollisionInvSphere::get_class_type(void);

485 19 ~CollisionInvSphere 0 4 560 39 CollisionInvSphere::~CollisionInvSphere 0 0 0
46
CollisionInvSphere::~CollisionInvSphere(void);

486 12 CollisionRay 0 4 561 26 CollisionRay::CollisionRay 0 3 215 216 217 1609
// Filename: collisionRay.I
// Created by:  drose (22Jun00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionRay::Default Constructor
//       Access: Public
//  Description: Creates an invalid ray.  This isn't terribly useful;
//               it's expected that the user will subsequently adjust
//               the ray via set_origin()/set_direction() or
//               set_from_lens().
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
222
inline CollisionRay::CollisionRay(void);
inline CollisionRay::CollisionRay(LPoint3f const &origin, LVector3f const &direction);
inline CollisionRay::CollisionRay(float ox, float oy, float oz, float dx, float dy, float dz);

487 10 set_origin 0 4 561 24 CollisionRay::set_origin 0 2 218 219 442
////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_origin
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_origin
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
126
inline void CollisionRay::set_origin(LPoint3f const &origin);
inline void CollisionRay::set_origin(float x, float y, float z);

488 10 get_origin 0 4 561 24 CollisionRay::get_origin 0 1 220 220
////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::get_origin
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
60
inline LPoint3f const &CollisionRay::get_origin(void) const;

489 13 set_direction 0 4 561 27 CollisionRay::set_direction 0 2 221 222 448
////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_direction
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_direction
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
136
inline void CollisionRay::set_direction(LVector3f const &direction);
inline void CollisionRay::set_direction(float x, float y, float z);

490 13 get_direction 0 4 561 27 CollisionRay::get_direction 0 1 223 223
////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::get_direction
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
64
inline LVector3f const &CollisionRay::get_direction(void) const;

491 13 set_from_lens 0 4 561 27 CollisionRay::set_from_lens 0 2 224 225 1166
////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_from_lens
//       Access: Public
//  Description: Accepts a LensNode and a 2-d point in the range
//               [-1,1].  Sets the CollisionRay so that it begins at
//               the LensNode's near plane and extends to
//               infinity, making it suitable for picking objects from
//               the screen given a camera and a mouse location.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_from_lens
//       Access: Public
//  Description: Accepts a LensNode and a 2-d point in the range
//               [-1,1].  Sets the CollisionRay so that it begins at
//               the LensNode's near plane and extends to
//               infinity, making it suitable for picking objects from
//               the screen given a camera and a mouse location.
//
//               Returns true if the point was acceptable, false
//               otherwise.
////////////////////////////////////////////////////////////////////
153
bool CollisionRay::set_from_lens(LensNode *camera, LPoint2f const &point);
inline bool CollisionRay::set_from_lens(LensNode *camera, float px, float py);

492 14 get_class_type 0 4 561 28 CollisionRay::get_class_type 0 1 226 0
53
static TypeHandle CollisionRay::get_class_type(void);

493 13 ~CollisionRay 0 4 561 27 CollisionRay::~CollisionRay 0 0 0
34
CollisionRay::~CollisionRay(void);

494 13 CollisionLine 0 4 562 28 CollisionLine::CollisionLine 0 3 227 228 229 1616
// Filename: collisionLine.I
// Created by:  drose (05Jan05)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionLine::Default Constructor
//       Access: Public
//  Description: Creates an invalid line.  This isn't terribly useful;
//               it's expected that the user will subsequently adjust
//               the line via set_origin()/set_direction() or
//               set_from_lens().
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionLine::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionLine::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionLine::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
228
inline CollisionLine::CollisionLine(void);
inline CollisionLine::CollisionLine(LPoint3f const &origin, LVector3f const &direction);
inline CollisionLine::CollisionLine(float ox, float oy, float oz, float dx, float dy, float dz);

495 14 get_class_type 0 4 562 29 CollisionLine::get_class_type 0 1 230 0
54
static TypeHandle CollisionLine::get_class_type(void);

496 14 ~CollisionLine 0 4 562 29 CollisionLine::~CollisionLine 0 0 0
36
CollisionLine::~CollisionLine(void);

497 17 CollisionParabola 0 4 563 36 CollisionParabola::CollisionParabola 0 2 231 232 1338
// Filename: collisionParabola.I
// Created by:  drose (11Oct07)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionParabola::Default Constructor
//       Access: Published
//  Description: Creates an invalid parabola.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::Constructor
//       Access: Published
//  Description: Creates a parabola with the endpoints between t1 and
//               t2 in the parametric space of the parabola.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::Copy Constructor
//       Access: Public
//  Description: 
////////////////////////////////////////////////////////////////////
143
inline CollisionParabola::CollisionParabola(void);
inline CollisionParabola::CollisionParabola(LParabolaf const &parabola, float t1, float t2);

498 12 set_parabola 0 4 563 31 CollisionParabola::set_parabola 0 1 233 274
////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::set_parabola
//       Access: Public
//  Description: Replaces the parabola specified by this solid.
////////////////////////////////////////////////////////////////////
72
inline void CollisionParabola::set_parabola(LParabolaf const &parabola);

499 12 get_parabola 0 4 563 31 CollisionParabola::get_parabola 0 1 234 273
////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::get_parabola
//       Access: Public
//  Description: Returns the parabola specified by this solid.
////////////////////////////////////////////////////////////////////
69
inline LParabolaf const &CollisionParabola::get_parabola(void) const;

500 6 set_t1 0 4 563 25 CollisionParabola::set_t1 0 1 235 265
////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::set_t1
//       Access: Public
//  Description: Changes the starting point on the parabola.
////////////////////////////////////////////////////////////////////
48
inline void CollisionParabola::set_t1(float t1);

501 6 get_t1 0 4 563 25 CollisionParabola::get_t1 0 1 236 265
////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::get_t1
//       Access: Public
//  Description: Returns the starting point on the parabola.
////////////////////////////////////////////////////////////////////
51
inline float CollisionParabola::get_t1(void) const;

502 6 set_t2 0 4 563 25 CollisionParabola::set_t2 0 1 237 263
////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::set_t2
//       Access: Public
//  Description: Changes the ending point on the parabola.
////////////////////////////////////////////////////////////////////
48
inline void CollisionParabola::set_t2(float t2);

503 6 get_t2 0 4 563 25 CollisionParabola::get_t2 0 1 238 263
////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::get_t2
//       Access: Public
//  Description: Returns the ending point on the parabola.
////////////////////////////////////////////////////////////////////
51
inline float CollisionParabola::get_t2(void) const;

504 14 get_class_type 0 4 563 33 CollisionParabola::get_class_type 0 1 239 0
58
static TypeHandle CollisionParabola::get_class_type(void);

505 18 ~CollisionParabola 0 4 563 37 CollisionParabola::~CollisionParabola 0 0 0
44
CollisionParabola::~CollisionParabola(void);

506 16 CollisionSegment 0 4 564 34 CollisionSegment::CollisionSegment 0 3 240 241 242 1637
// Filename: collisionSegment.I
// Created by:  drose (30Jan01)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionSegment::Default Constructor
//       Access: Public
//  Description: Creates an invalid segment.  This isn't terribly useful;
//               it's expected that the user will subsequently adjust
//               the segment via set_origin()/set_direction() or
//               set_from_lens().
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
233
inline CollisionSegment::CollisionSegment(void);
inline CollisionSegment::CollisionSegment(LPoint3f const &a, LPoint3f const &db);
inline CollisionSegment::CollisionSegment(float ax, float ay, float az, float bx, float by, float bz);

507 11 set_point_a 0 4 564 29 CollisionSegment::set_point_a 0 2 243 244 452
////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_point_a
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_point_a
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
131
inline void CollisionSegment::set_point_a(LPoint3f const &a);
inline void CollisionSegment::set_point_a(float x, float y, float z);

508 11 get_point_a 0 4 564 29 CollisionSegment::get_point_a 0 1 245 225
////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::get_point_a
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
65
inline LPoint3f const &CollisionSegment::get_point_a(void) const;

509 11 set_point_b 0 4 564 29 CollisionSegment::set_point_b 0 2 246 247 452
////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_point_b
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_point_b
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
131
inline void CollisionSegment::set_point_b(LPoint3f const &b);
inline void CollisionSegment::set_point_b(float x, float y, float z);

510 11 get_point_b 0 4 564 29 CollisionSegment::get_point_b 0 1 248 225
////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::get_point_b
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
65
inline LPoint3f const &CollisionSegment::get_point_b(void) const;

511 13 set_from_lens 0 4 564 31 CollisionSegment::set_from_lens 0 2 249 250 1192
////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_from_lens
//       Access: Public
//  Description: Accepts a LensNode and a 2-d point in the range
//               [-1,1].  Sets the CollisionSegment so that it begins at
//               the LensNode's near plane and extends to the
//               far plane, making it suitable for picking objects
//               from the screen given a camera and a mouse location.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_from_lens
//       Access: Public
//  Description: Accepts a LensNode and a 2-d point in the range
//               [-1,1].  Sets the CollisionSegment so that it begins at
//               the LensNode's near plane and extends to the
//               far plane, making it suitable for picking objects
//               from the screen given a camera and a mouse location.
//
//               Returns true if the point was acceptable, false
//               otherwise.
////////////////////////////////////////////////////////////////////
161
bool CollisionSegment::set_from_lens(LensNode *camera, LPoint2f const &point);
inline bool CollisionSegment::set_from_lens(LensNode *camera, float px, float py);

512 14 get_class_type 0 4 564 32 CollisionSegment::get_class_type 0 1 251 0
57
static TypeHandle CollisionSegment::get_class_type(void);

513 17 ~CollisionSegment 0 4 564 35 CollisionSegment::~CollisionSegment 0 0 0
42
CollisionSegment::~CollisionSegment(void);

514 13 CollisionTube 0 4 565 28 CollisionTube::CollisionTube 0 2 252 253 1480
// Filename: collisionTube.I
// Created by:  drose (25Sep03)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionTube::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::Default constructor
//       Access: Private
//  Description: Creates an invalid tube.  Only used when reading
//               from a bam file.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
200
inline CollisionTube::CollisionTube(LPoint3f const &a, LPoint3f const &db, float radius);
inline CollisionTube::CollisionTube(float ax, float ay, float az, float bx, float by, float bz, float radius);

515 11 set_point_a 0 4 565 26 CollisionTube::set_point_a 0 2 254 255 452
////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_point_a
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_point_a
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
125
inline void CollisionTube::set_point_a(LPoint3f const &a);
inline void CollisionTube::set_point_a(float x, float y, float z);

516 11 get_point_a 0 4 565 26 CollisionTube::get_point_a 0 1 256 225
////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::get_point_a
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
62
inline LPoint3f const &CollisionTube::get_point_a(void) const;

517 11 set_point_b 0 4 565 26 CollisionTube::set_point_b 0 2 257 258 452
////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_point_b
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_point_b
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
125
inline void CollisionTube::set_point_b(LPoint3f const &b);
inline void CollisionTube::set_point_b(float x, float y, float z);

518 11 get_point_b 0 4 565 26 CollisionTube::get_point_b 0 1 259 225
////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::get_point_b
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
62
inline LPoint3f const &CollisionTube::get_point_b(void) const;

519 10 set_radius 0 4 565 25 CollisionTube::set_radius 0 1 260 224
////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_radius
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
52
inline void CollisionTube::set_radius(float radius);

520 10 get_radius 0 4 565 25 CollisionTube::get_radius 0 1 261 224
////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::get_radius
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
51
inline float CollisionTube::get_radius(void) const;

521 14 get_class_type 0 4 565 29 CollisionTube::get_class_type 0 1 262 0
54
static TypeHandle CollisionTube::get_class_type(void);

522 14 ~CollisionTube 0 4 565 29 CollisionTube::~CollisionTube 0 0 0
36
CollisionTube::~CollisionTube(void);

523 19 upcast_to_PandaNode 0 12 566 40 CollisionVisualizer::upcast_to_PandaNode 0 1 270 44
upcast from CollisionVisualizer to PandaNode
58
PandaNode *CollisionVisualizer::upcast_to_PandaNode(void);

524 31 downcast_to_CollisionVisualizer 0 12 541 42 PandaNode::downcast_to_CollisionVisualizer 0 1 271 46
downcast from PandaNode to CollisionVisualizer
70
CollisionVisualizer *PandaNode::downcast_to_CollisionVisualizer(void);

525 27 upcast_to_CollisionRecorder 0 12 566 48 CollisionVisualizer::upcast_to_CollisionRecorder 0 1 272 52
upcast from CollisionVisualizer to CollisionRecorder
74
CollisionRecorder *CollisionVisualizer::upcast_to_CollisionRecorder(void);

526 31 downcast_to_CollisionVisualizer 0 12 544 50 CollisionRecorder::downcast_to_CollisionVisualizer 0 1 273 54
downcast from CollisionRecorder to CollisionVisualizer
78
CollisionVisualizer *CollisionRecorder::downcast_to_CollisionVisualizer(void);

527 19 CollisionVisualizer 0 4 566 40 CollisionVisualizer::CollisionVisualizer 0 1 263 231
////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
75
CollisionVisualizer::CollisionVisualizer(basic_string< char > const &name);

528 20 ~CollisionVisualizer 0 6 566 41 CollisionVisualizer::~CollisionVisualizer 0 0 239
////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
56
virtual CollisionVisualizer::~CollisionVisualizer(void);

529 15 set_point_scale 0 4 566 36 CollisionVisualizer::set_point_scale 0 1 264 741
////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::set_point_scale
//       Access: Published
//  Description: Scales the points that are drawn to represent the
//               surface and interior intersection points of the
//               collisions.  By default, these objects are drawn at
//               an arbitrary scale which is appropriate if the window
//               units are the default range -1 .. 1.  Change this
//               scale accordinatly if the window units are measured
//               on some other scale or if you need to observe these
//               objects in a smaller window.
////////////////////////////////////////////////////////////////////
68
inline void CollisionVisualizer::set_point_scale(float point_scale);

530 15 get_point_scale 0 4 566 36 CollisionVisualizer::get_point_scale 0 1 265 284
////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::get_point_scale
//       Access: Published
//  Description: Returns the value last set by set_point_scale().
////////////////////////////////////////////////////////////////////
62
inline float CollisionVisualizer::get_point_scale(void) const;

531 16 set_normal_scale 0 4 566 37 CollisionVisualizer::set_normal_scale 0 1 266 685
////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::set_normal_scale
//       Access: Published
//  Description: Scales the line segments that are drawn to represent
//               the normals of the collisions.  By default, these
//               objects are drawn at an arbitrary scale which is
//               appropriate if the scene units are measured in feet.
//               Change this scale accordinatly if the scene units are
//               measured on some other scale or if you need to
//               observe these normals from farther away.
////////////////////////////////////////////////////////////////////
70
inline void CollisionVisualizer::set_normal_scale(float normal_scale);

532 16 get_normal_scale 0 4 566 37 CollisionVisualizer::get_normal_scale 0 1 267 286
////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::get_normal_scale
//       Access: Published
//  Description: Returns the value last set by set_normal_scale().
////////////////////////////////////////////////////////////////////
63
inline float CollisionVisualizer::get_normal_scale(void) const;

533 5 clear 0 4 566 26 CollisionVisualizer::clear 0 1 268 339
////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::clear
//       Access: Published
//  Description: Removes all the visualization data from a previous
//               traversal and resets the visualizer to empty.
////////////////////////////////////////////////////////////////////
38
void CollisionVisualizer::clear(void);

534 14 get_class_type 0 4 566 35 CollisionVisualizer::get_class_type 0 1 269 0
60
static TypeHandle CollisionVisualizer::get_class_type(void);

273
1 14 Dtool_dlaqJNfv 0 7 3 570 0 14 Dtool_dlaqJNfv 0 1 4 this 3 568  
2 14 Dtool_dlaqXfKF 0 4 4 573 0 14 Dtool_dlaqXfKF 1078 // Filename: collisionSolid.I
// Created by:  drose (27Jun00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionSolid::set_tangible
//       Access: Published
//  Description: Sets the current state of the 'tangible' flag.  Set
//               this true to make the solid tangible, so that a
//               CollisionHandlerPusher will not allow another object
//               to intersect it, or false to make it intangible, so
//               that a CollisionHandlerPusher will ignore it except
//               to throw an event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 571  8 tangible 1 572  
3 14 Dtool_dlaqPJ9V 0 6 5 572 0 14 Dtool_dlaqPJ9V 541 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::is_tangible
//       Access: Published
//  Description: Returns whether the solid is considered 'tangible' or
//               not.  An intangible solid has no effect in a
//               CollisionHandlerPusher (except to throw an event);
//               it's useful for defining 'trigger' planes and
//               spheres, that cause an effect when passed through.
//////////////////////////////////////////////////////////////////// 1 4 this 3 568  
4 14 Dtool_dlaqXl2n 0 4 6 573 0 14 Dtool_dlaqXl2n 720 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::set_effective_normal
//       Access: Published
//  Description: Records a false normal for this CollisionSolid that
//               will be reported by the collision system with all
//               collisions into it, instead of its actual normal.
//               This is useful as a workaround for the problem of an
//               avatar wanting to stand on a sloping ground; by
//               storing a false normal, the ground appears to be
//               perfectly level, and the avatar does not tend to
//               slide down it.
//////////////////////////////////////////////////////////////////// 2 4 this 3 571  16 effective_normal 1 574  
5 14 Dtool_dlaqMg6D 0 4 7 573 0 14 Dtool_dlaqMg6D 315 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::clear_effective_normal
//       Access: Published
//  Description: Removes the normal previously set by
//               set_effective_normal().
//////////////////////////////////////////////////////////////////// 1 4 this 3 571  
6 14 Dtool_dlaqUtHP 0 6 8 572 0 14 Dtool_dlaqUtHP 337 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::has_effective_normal
//       Access: Published
//  Description: Returns true if a special normal was set by
//               set_effective_normal(), false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 568  
7 14 Dtool_dlaq8DHC 0 6 9 574 0 14 Dtool_dlaq8DHC 401 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::get_effective_normal
//       Access: Published
//  Description: Returns the normal that was set by
//               set_effective_normal().  It is an error to call this
//               unless has_effective_normal() returns true.
//////////////////////////////////////////////////////////////////// 1 4 this 3 568  
8 14 Dtool_dlaqBuoM 0 4 10 573 0 14 Dtool_dlaqBuoM 605 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::set_respect_effective_normal
//       Access: Published
//  Description: This is only meaningful for CollisionSolids that will
//               be added to a traverser as colliders.  It is normally
//               true, but if set false, it means that this particular
//               solid does not care about the "effective" normal of
//               other solids it meets, but rather always uses the
//               true normal.
//////////////////////////////////////////////////////////////////// 2 4 this 3 571  24 respect_effective_normal 1 572  
9 14 Dtool_dlaqGbQo 0 6 11 572 0 14 Dtool_dlaqGbQo 279 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::get_respect_effective_normal
//       Access: Published
//  Description: See set_respect_effective_normal().
//////////////////////////////////////////////////////////////////// 1 4 this 3 568  
10 14 Dtool_dlaqipKu 0 7 12 579 0 14 Dtool_dlaqipKu 262 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::get_bounds
//       Access: Protected
//  Description: Returns the solid's bounding volume.
//////////////////////////////////////////////////////////////////// 1 4 this 3 568  
11 14 Dtool_dlaqEqPP 0 4 13 573 0 14 Dtool_dlaqEqPP 262 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::set_bounds
//       Access: Protected
//  Description: Returns the solid's bounding volume.
//////////////////////////////////////////////////////////////////// 2 4 this 3 571  15 bounding_volume 1 579  
12 14 Dtool_dlaqdFP2 0 4 14 573 0 14 Dtool_dlaqdFP2 227 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::output
//       Access: Public, Virtual
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 568  3 out 1 580  
13 14 Dtool_dlaqtNak 0 4 15 573 0 14 Dtool_dlaqtNak 226 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::write
//       Access: Public, Virtual
//  Description:
//////////////////////////////////////////////////////////////////// 3 4 this 3 568  3 out 1 580  12 indent_level 1 582  
14 14 Dtool_dlaqSwM3 0 4 15 573 0 14 Dtool_dlaqSwM3 226 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSolid::write
//       Access: Public, Virtual
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 568  3 out 1 580  
15 14 Dtool_dlaqLN1N 0 7 16 584 0 14 Dtool_dlaqLN1N 0 0 
16 14 Dtool_dlaq3_2E 0 7 18 587 299 14 Dtool_dlaq3_2E 270 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::Constructor
//       Access: Public
//  Description: Create the Box by Specifying the Diagonal Points
//////////////////////////////////////////////////////////////////// 2 3 min 1 585  3 max 1 585  
17 14 Dtool_dlaq953K 0 7 18 587 299 14 Dtool_dlaq953K 828 // Filename: collisionBox.I
// Created by:  amith tudur (31Jul09)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionBox::Constructor
//       Access: Public
//  Description: Create the Box by giving a Center and distances of
//               of each of the sides of box from the Center.
//////////////////////////////////////////////////////////////////// 4 6 center 1 585  1 x 1 588  1 y 1 588  1 z 1 588  
18 14 Dtool_dlaqvU6t 0 6 19 582 0 14 Dtool_dlaqvU6t 285 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_num_points
//       Access: Published
//  Description: Returns 8: the number of vertices of a rectangular solid.
//////////////////////////////////////////////////////////////////// 1 4 this 3 589  
19 14 Dtool_dlaqyT6s 0 7 20 570 0 14 Dtool_dlaqyT6s 284 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_point_aabb
//       Access: Published
//  Description: Returns the nth vertex of the Axis Aligned Bounding Box.
//////////////////////////////////////////////////////////////////// 2 4 this 3 589  1 n 1 582  
20 14 Dtool_dlaqxrYP 0 7 21 570 0 14 Dtool_dlaqxrYP 257 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_point
//       Access: Published
//  Description: Returns the nth vertex of the OBB.
//////////////////////////////////////////////////////////////////// 2 4 this 3 589  1 n 1 582  
21 14 Dtool_dlaqey2e 0 6 22 582 0 14 Dtool_dlaqey2e 282 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_num_planes
//       Access: Published
//  Description: Returns 6: the number of faces of a rectangular solid.
//////////////////////////////////////////////////////////////////// 1 4 this 3 589  
22 14 Dtool_dlaq9Hae 0 7 23 592 0 14 Dtool_dlaq9Hae 269 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::set_plane
//       Access: Published
//  Description: Creates the nth face of the rectangular solid.
//////////////////////////////////////////////////////////////////// 2 4 this 3 589  1 n 1 582  
23 14 Dtool_dlaqSSWe 0 7 24 592 0 14 Dtool_dlaqSSWe 269 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_plane
//       Access: Published
//  Description: Returns the nth face of the rectangular solid.
//////////////////////////////////////////////////////////////////// 2 4 this 3 589  1 n 1 582  
24 14 Dtool_dlaqToqZ 0 4 25 573 0 14 Dtool_dlaqToqZ 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::set_center
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 587  6 center 1 585  
25 14 Dtool_dlaqF0ja 0 4 25 573 0 14 Dtool_dlaqF0ja 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::set_center
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 587  1 x 1 588  1 y 1 588  1 z 1 588  
26 14 Dtool_dlaq4vL3 0 6 26 585 0 14 Dtool_dlaq4vL3 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_center
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 589  
27 14 Dtool_dlaqvvqG 0 6 27 588 0 14 Dtool_dlaqvvqG 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionBox::get_radius
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 589  
28 14 Dtool_dlaqfJb_ 0 7 28 584 0 14 Dtool_dlaqfJb_ 0 0 
29 14 Dtool_dlaqemio 0 7 32 584 0 14 Dtool_dlaqemio 0 0 
30 14 Dtool_dlaqx_1r 0 7 36 594 0 14 Dtool_dlaqx_1r 222 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 593  
31 14 Dtool_dlaqxXyb 0 4 37 573 0 14 Dtool_dlaqxXyb 821 // Filename: collisionNode.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionNode::set_collide_mask
//       Access: Published
//  Description: Simultaneously sets both the "from" and "into"
//               CollideMask values to the same thing.
//////////////////////////////////////////////////////////////////// 2 4 this 3 594  4 mask 1 595  
32 14 Dtool_dlaqjgOW 0 4 38 573 0 14 Dtool_dlaqjgOW 509 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::set_from_collide_mask
//       Access: Published
//  Description: Sets the "from" CollideMask.  In order for a
//               collision to be detected from this object into
//               another object, the intersection of this object's
//               "from" mask and the other object's "into" mask must
//               be nonzero.
//////////////////////////////////////////////////////////////////// 2 4 this 3 594  4 mask 1 595  
33 14 Dtool_dlaqYvsW 0 4 39 573 0 14 Dtool_dlaqYvsW 509 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::set_into_collide_mask
//       Access: Published
//  Description: Sets the "into" CollideMask.  In order for a
//               collision to be detected from another object into
//               this object, the intersection of the other object's
//               "from" mask and this object's "into" mask must be
//               nonzero.
//////////////////////////////////////////////////////////////////// 2 4 this 3 594  4 mask 1 595  
34 14 Dtool_dlaqY8vI 0 7 40 595 0 14 Dtool_dlaqY8vI 520 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_from_collide_mask
//       Access: Published
//  Description: Returns the current "from" CollideMask.  In order for
//               a collision to be detected from this object into
//               another object, the intersection of this object's
//               "from" mask and the other object's "into" mask must
//               be nonzero.
//////////////////////////////////////////////////////////////////// 1 4 this 3 597  
35 14 Dtool_dlaqx1PJ 0 7 41 595 0 14 Dtool_dlaqx1PJ 520 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_into_collide_mask
//       Access: Published
//  Description: Returns the current "into" CollideMask.  In order for
//               a collision to be detected from another object into
//               this object, the intersection of the other object's
//               "from" mask and this object's "into" mask must be
//               nonzero.
//////////////////////////////////////////////////////////////////// 1 4 this 3 597  
36 14 Dtool_dlaq7zaG 0 4 42 573 0 14 Dtool_dlaq7zaG 260 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::clear_solids
//       Access: Published
//  Description: Removes all solids from the node.
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
37 14 Dtool_dlaqqYJk 0 6 43 582 0 14 Dtool_dlaqqYJk 228 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_num_solids
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 597  
38 14 Dtool_dlaqjUdZ 0 7 44 568 0 14 Dtool_dlaqjUdZ 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_solid
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 597  1 n 1 582  
39 14 Dtool_dlaqWC9z 0 7 45 571 0 14 Dtool_dlaqWC9z 226 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::modify_solid
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 594  1 n 1 582  
40 14 Dtool_dlaqYq_i 0 4 46 573 0 14 Dtool_dlaqYq_i 268 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::set_solid
//       Access: Published
//  Description: Replaces the solid with the indicated index.
//////////////////////////////////////////////////////////////////// 3 4 this 3 594  1 n 1 582  5 solid 1 571  
41 14 Dtool_dlaqQ94l 0 4 47 573 0 14 Dtool_dlaqQ94l 340 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::remove_solid
//       Access: Published
//  Description: Removes the solid with the indicated index.  This
//               will shift all subsequent indices down by one.
//////////////////////////////////////////////////////////////////// 2 4 this 3 594  1 n 1 582  
42 14 Dtool_dlaqQMTj 0 6 48 582 0 14 Dtool_dlaqQMTj 365 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::add_solid
//       Access: Published
//  Description: Adds the indicated solid to the node.  Returns the
//               index of the new solid within the node's list of
//               solids.
//////////////////////////////////////////////////////////////////// 2 4 this 3 594  5 solid 1 568  
43 14 Dtool_dlaq72rF 0 6 49 582 0 14 Dtool_dlaq72rF 350 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_collider_sort
//       Access: Published
//  Description: Returns the collider_sort value that has been set for
//               this particular node.  See set_collider_sort().
//////////////////////////////////////////////////////////////////// 1 4 this 3 597  
44 14 Dtool_dlaqzuN4 0 4 50 573 0 14 Dtool_dlaqzuN4 977 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::set_collider_sort
//       Access: Published
//  Description: Sets a particular collider_sort value on this node.
//               This controls the order in which colliders (that is,
//               "from nodes") are grouped together for the collision
//               traversal.
//
//               If there are 32 or fewer colliders added to any
//               particular CollisionTraverser, then this value has no
//               meaning.  It is only useful if there are many
//               colliders, which may force the CollisionTraverser to
//               make multiple passes through the data; in that case,
//               it may be a useful optimization to group colliders
//               that have similar bounding volumes together (by
//               giving them similar sort values).
//////////////////////////////////////////////////////////////////// 2 4 this 3 594  4 sort 1 582  
45 14 Dtool_dlaqvD0G 0 7 51 595 0 14 Dtool_dlaqvD0G 333 ////////////////////////////////////////////////////////////////////
//     Function: CollisionNode::get_default_collide_mask
//       Access: Published, Static
//  Description: Returns the default into_collide_mask assigned to new
//               CollisionNodes.
//////////////////////////////////////////////////////////////////// 0 
46 14 Dtool_dlaqjzU3 0 7 52 584 0 14 Dtool_dlaqjzU3 0 0 
47 14 Dtool_dlaqyNSW 0 7 55 599 320 14 Dtool_dlaqyNSW 230 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 593  
48 14 Dtool_dlaqLY8j 0 7 55 599 320 14 Dtool_dlaqLY8j 230 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
49 14 Dtool_dlaqdaty 0 4 57 573 0 14 Dtool_dlaqdaty 1206 // Filename: collisionTraverser.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionTraverser::set_respect_prev_transform
//       Access: Published
//  Description: Sets the flag that indicates whether the
//               prev_transform stored on a node (as updated via
//               set_fluid_pos(), etc.) is respected to calculate
//               collisions.  If this is true, certain types of
//               collision tests will be enhanced by the information
//               about objects in motion.  If this is false, objects
//               are always considered to be static.  The default is
//               false.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  4 flag 1 572  
50 14 Dtool_dlaqlqsH 0 6 58 572 0 14 Dtool_dlaqlqsH 445 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_respect_prev_transform
//       Access: Published
//  Description: Returns the flag that indicates whether the
//               prev_transform stored on a node is respected to
//               calculate collisions.  See
//               set_respect_prev_transform().
//////////////////////////////////////////////////////////////////// 1 4 this 3 600  
51 14 Dtool_dlaq2H3O 0 4 59 573 0 14 Dtool_dlaq2H3O 779 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::add_collider
//       Access: Published
//  Description: Adds a new CollisionNode, representing an object that
//               will be tested for collisions into other objects,
//               along with the handler that will serve each detected
//               collision.  Each CollisionNode may be served by only
//               one handler at a time, but a given handler may serve
//               many CollisionNodes.
//
//               The handler that serves a particular node may be
//               changed from time to time by calling add_collider()
//               again on the same node.
//////////////////////////////////////////////////////////////////// 3 4 this 3 599  8 collider 1 602  7 handler 1 605  
52 14 Dtool_dlaqM6MA 0 6 60 572 0 14 Dtool_dlaqM6MA 545 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::remove_collider
//       Access: Published
//  Description: Removes the collider (and its associated handler)
//               from the set of CollisionNodes that will be tested
//               each frame for collisions into other objects.
//               Returns true if the definition was found and removed,
//               false if it wasn't present to begin with.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  8 collider 1 602  
53 14 Dtool_dlaqWy10 0 6 61 572 0 14 Dtool_dlaqWy10 397 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::has_collider
//       Access: Published
//  Description: Returns true if the indicated node is current in the
//               set of nodes that will be tested each frame for
//               collisions into other objects.
//////////////////////////////////////////////////////////////////// 2 4 this 3 600  8 collider 1 602  
54 14 Dtool_dlaqO3k0 0 6 62 582 0 14 Dtool_dlaqO3k0 348 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_num_colliders
//       Access: Published
//  Description: Returns the number of CollisionNodes that have been
//               added to the traverser via add_collider().
//////////////////////////////////////////////////////////////////// 1 4 this 3 600  
55 14 Dtool_dlaq8iE2 0 7 63 606 0 14 Dtool_dlaq8iE2 335 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_collider
//       Access: Published
//  Description: Returns the nth CollisionNode that has been
//               added to the traverser via add_collider().
//////////////////////////////////////////////////////////////////// 2 4 this 3 600  1 n 1 582  
56 14 Dtool_dlaqHSoX 0 7 64 605 301 14 Dtool_dlaqHSoX 417 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_handler
//       Access: Published
//  Description: Returns the handler that is currently assigned to
//               serve the indicated collision node, or NULL if the
//               node is not on the traverser's set of active nodes.
//////////////////////////////////////////////////////////////////// 2 4 this 3 600  8 collider 1 602  
57 14 Dtool_dlaqz8jc 0 4 65 573 0 14 Dtool_dlaqz8jc 328 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::clear_colliders
//       Access: Published
//  Description: Completely empties the set of collision nodes and
//               their associated handlers.
//////////////////////////////////////////////////////////////////// 1 4 this 3 599  
58 14 Dtool_dlaqIgJi 0 4 66 573 0 14 Dtool_dlaqIgJi 227 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::traverse
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  4 root 1 602  
59 14 Dtool_dlaqhkD3 0 4 67 573 0 14 Dtool_dlaqhkD3 1220 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::set_recorder
//       Access: Published
//  Description: Uses the indicated CollisionRecorder object to start
//               recording the intersection tests made by each
//               subsequent call to traverse() on this object.  A
//               particular CollisionRecorder object can only record
//               one traverser at a time; if this object has already
//               been assigned to another traverser, that assignment
//               is broken.
//
//               This is intended to be used in a debugging mode to
//               try to determine what work is being performed by the
//               collision traversal.  Usually, attaching a recorder
//               will impose significant runtime overhead.
//
//               This does not transfer ownership of the
//               CollisionRecorder pointer; maintenance of that
//               remains the caller's responsibility.  If the
//               CollisionRecorder is destructed, it will cleanly
//               remove itself from the traverser.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  8 recorder 1 607  
60 14 Dtool_dlaqkrr7 0 6 68 572 0 14 Dtool_dlaqkrr7 372 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::has_recorder
//       Access: Published
//  Description: Returns true if the CollisionTraverser has a
//               CollisionRecorder object currently assigned, false
//               otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 600  
61 14 Dtool_dlaquo3a 0 6 69 607 0 14 Dtool_dlaquo3a 334 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::get_recorder
//       Access: Published
//  Description: Returns the CollisionRecorder currently assigned, or
//               NULL if no recorder is assigned.
//////////////////////////////////////////////////////////////////// 1 4 this 3 600  
62 14 Dtool_dlaqQmCi 0 4 70 573 0 14 Dtool_dlaqQmCi 343 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::clear_recorder
//       Access: Published
//  Description: Removes the CollisionRecorder from the traverser and
//               restores normal low-overhead operation.
//////////////////////////////////////////////////////////////////// 1 4 this 3 599  
63 14 Dtool_dlaqdHFN 0 7 71 608 528 14 Dtool_dlaqdHFN 600 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::show_collisions
//       Access: Published
//  Description: This is a high-level function to create a
//               CollisionVisualizer object to render the collision
//               tests performed by this traverser.  The supplied root
//               should be any node in the scene graph; typically, the
//               top node (e.g. render).  The CollisionVisualizer will
//               be attached to this node.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  4 root 1 602  
64 14 Dtool_dlaqMk_a 0 4 72 573 0 14 Dtool_dlaqMk_a 310 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::hide_collisions
//       Access: Published
//  Description: Undoes the effect of a previous call to
//               show_collisions().
//////////////////////////////////////////////////////////////////// 1 4 this 3 599  
65 14 Dtool_dlaqKrH1 0 4 73 573 0 14 Dtool_dlaqKrH1 251 // DO_COLLISION_RECORDING
////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::output
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 600  3 out 1 580  
66 14 Dtool_dlaqFI_7 0 4 74 573 0 14 Dtool_dlaqFI_7 224 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTraverser::write
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 3 4 this 3 600  3 out 1 580  12 indent_level 1 582  
67 14 Dtool_dlaqxNmK 0 7 75 584 0 14 Dtool_dlaqxNmK 0 0 
68 14 Dtool_dlaqrZlp 0 4 78 573 0 14 Dtool_dlaqrZlp 222 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRecorder::output
//       Access: Public
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 609  3 out 1 580  
69 14 Dtool_dlaqyqSE 0 7 79 584 0 14 Dtool_dlaqyqSE 0 0 
70 14 Dtool_dlaqGwYK 0 7 82 568 0 14 Dtool_dlaqGwYK 331 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_from
//       Access: Published
//  Description: Returns the CollisionSolid pointer for the particular
//               solid that triggered this collision.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
71 14 Dtool_dlaquTcn 0 6 83 572 0 14 Dtool_dlaquTcn 578 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_into
//       Access: Published
//  Description: Returns true if the "into" solid is, in fact, a
//               CollisionSolid, and its pointer is known (in which
//               case get_into() may be called to retrieve it).  If
//               this returns false, the collision was detected into a
//               GeomNode, and there is no CollisionSolid pointer to
//               be retrieved.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
72 14 Dtool_dlaqGQba 0 7 84 568 0 14 Dtool_dlaqGQba 515 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_into
//       Access: Published
//  Description: Returns the CollisionSolid pointer for the particular
//               solid was collided into.  This pointer might be NULL
//               if the collision was into a piece of visible
//               geometry, instead of a normal CollisionSolid
//               collision; see has_into().
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
73 14 Dtool_dlaqe4xC 0 7 85 594 0 14 Dtool_dlaqe4xC 445 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_from_node
//       Access: Published
//  Description: Returns the node that contains the CollisionSolid
//               that triggered this collision.  This will be a node
//               that has been added to a CollisionTraverser via
//               add_collider().
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
74 14 Dtool_dlaq_40S 0 7 86 613 0 14 Dtool_dlaq_40S 532 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_into_node
//       Access: Published
//  Description: Returns the node that contains the CollisionSolid
//               that was collided into.  This returns a PandaNode
//               pointer instead of something more specific, because
//               it might be either a CollisionNode or a GeomNode.
//
//               Also see get_into_node_path().
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
75 14 Dtool_dlaqcMQX 0 7 87 606 0 14 Dtool_dlaqcMQX 509 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_from_node_path
//       Access: Published
//  Description: Returns the NodePath that represents the
//               CollisionNode that contains the CollisionSolid that
//               triggered this collision.  This will be a NodePath
//               that has been added to a CollisionTraverser via
//               add_collider().
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
76 14 Dtool_dlaq83Sn 0 7 88 606 0 14 Dtool_dlaq83Sn 651 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_into_node_path
//       Access: Published
//  Description: Returns the NodePath that represents the specific
//               CollisionNode or GeomNode instance that was collided
//               into.  This is the same node returned by
//               get_into_node(), represented as a NodePath; however,
//               it may be more useful because the NodePath can
//               resolve the particular instance of the node, if there
//               is more than one.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
77 14 Dtool_dlaqpr2_ 0 4 89 573 0 14 Dtool_dlaqpr2_ 309 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_t
//       Access: Published
//  Description: Sets a time value for this collision relative to
//               other CollisionEntries
//////////////////////////////////////////////////////////////////// 2 4 this 3 614  1 t 1 588  
78 14 Dtool_dlaqOGlN 0 6 90 588 0 14 Dtool_dlaqOGlN 310 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_t
//       Access: Published
//  Description: returns time value for this collision relative to
//               other CollisionEntries
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
79 14 Dtool_dlaq_RB_ 0 6 91 572 0 14 Dtool_dlaq_RB_ 446 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::collided
//       Access: Published
//  Description: returns true if this represents an actual collision
//               as opposed to a potential collision, needed for
//               iterative collision resolution where path of
//               collider changes mid-frame
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
80 14 Dtool_dlaqZ2MC 0 4 92 573 0 14 Dtool_dlaqZ2MC 264 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::reset_collided
//       Access: Published
//  Description: prepare for another collision test
//////////////////////////////////////////////////////////////////// 1 4 this 3 614  
81 14 Dtool_dlaqRUDs 0 6 93 572 0 14 Dtool_dlaqRUDs 479 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_respect_prev_transform
//       Access: Published
//  Description: Returns true if the collision was detected by a
//               CollisionTraverser whose respect_prev_transform
//               flag was set true, meaning we should consider motion
//               significant in evaluating collisions.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
82 14 Dtool_dlaqhJuh 0 4 94 573 0 14 Dtool_dlaqhJuh 445 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_surface_point
//       Access: Published
//  Description: Stores the point, on the surface of the "into"
//               object, at which a collision is detected.
//
//               This point is specified in the coordinate space of
//               the "into" object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 614  5 point 1 585  
83 14 Dtool_dlaqSvQs 0 4 95 573 0 14 Dtool_dlaqSvQs 439 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_surface_normal
//       Access: Published
//  Description: Stores the surface normal of the "into" object at the
//               point of the intersection.
//
//               This normal is specified in the coordinate space of
//               the "into" object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 614  6 normal 1 574  
84 14 Dtool_dlaqIgiu 0 4 96 573 0 14 Dtool_dlaqIgiu 682 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_interior_point
//       Access: Published
//  Description: Stores the point, within the interior of the "into"
//               object, which represents the depth to which the
//               "from" object has penetrated.  This can also be
//               described as the intersection point on the surface of
//               the "from" object (which is inside the "into"
//               object).
//
//               This point is specified in the coordinate space of
//               the "into" object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 614  5 point 1 585  
85 14 Dtool_dlaqIa3H 0 6 97 572 0 14 Dtool_dlaqIa3H 441 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_surface_point
//       Access: Published
//  Description: Returns true if the surface point has been specified,
//               false otherwise.  See get_surface_point().  Some
//               types of collisions may not compute the surface
//               point.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
86 14 Dtool_dlaqX6_A 0 6 98 572 0 14 Dtool_dlaqX6_A 445 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_surface_normal
//       Access: Published
//  Description: Returns true if the surface normal has been specified,
//               false otherwise.  See get_surface_normal().  Some
//               types of collisions may not compute the surface
//               normal.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
87 14 Dtool_dlaqoXP3 0 6 99 572 0 14 Dtool_dlaqoXP3 445 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_interior_point
//       Access: Published
//  Description: Returns true if the interior point has been specified,
//               false otherwise.  See get_interior_point().  Some
//               types of collisions may not compute the interior
//               point.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
88 14 Dtool_dlaqJFb5 0 4 100 573 0 14 Dtool_dlaqJFb5 455 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_contact_pos
//       Access: Published
//  Description: Stores the position of the "from" object at the
//               instant at which the collision is first detected.
//
//               This position is specified in the coordinate space of
//               the "into" object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 614  3 pos 1 585  
89 14 Dtool_dlaqfp9z 0 4 101 573 0 14 Dtool_dlaqfp9z 425 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::set_contact_normal
//       Access: Published
//  Description: Stores the surface normal of the "into" object at the
//               contact pos.
//
//               This normal is specified in the coordinate space of
//               the "into" object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 614  6 normal 1 574  
90 14 Dtool_dlaqA_VR 0 6 102 572 0 14 Dtool_dlaqA_VR 438 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_contact_pos
//       Access: Published
//  Description: Returns true if the contact position has been specified,
//               false otherwise.  See get_contact_pos().  Some
//               types of collisions may not compute the contact
//               pos.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
91 14 Dtool_dlaqc8rI 0 6 103 572 0 14 Dtool_dlaqc8rI 445 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::has_contact_normal
//       Access: Published
//  Description: Returns true if the contact normal has been specified,
//               false otherwise.  See get_contact_normal().  Some
//               types of collisions may not compute the contact
//               normal.
//////////////////////////////////////////////////////////////////// 1 4 this 3 611  
92 14 Dtool_dlaqhuLD 0 7 104 570 0 14 Dtool_dlaqhuLD 638 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_surface_point
//       Access: Published
//  Description: Returns the point, on the surface of the "into"
//               object, at which a collision is detected.  This can
//               be thought of as the first point of intersection.
//               However the contact point is the actual first point of
//               intersection.
//
//               The point will be converted into whichever coordinate
//               space the caller specifies.
//////////////////////////////////////////////////////////////////// 2 4 this 3 611  5 space 1 602  
93 14 Dtool_dlaqb0T_ 0 7 105 615 0 14 Dtool_dlaqb0T_ 465 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_surface_normal
//       Access: Published
//  Description: Returns the surface normal of the "into" object at
//               the point at which a collision is detected.
//
//               The normal will be converted into whichever coordinate
//               space the caller specifies.
//////////////////////////////////////////////////////////////////// 2 4 this 3 611  5 space 1 602  
94 14 Dtool_dlaqBjl0 0 7 106 570 0 14 Dtool_dlaqBjl0 772 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_interior_point
//       Access: Published
//  Description: Returns the point, within the interior of the "into"
//               object, which represents the depth to which the
//               "from" object has penetrated.  This can also be
//               described as the intersection point on the surface of
//               the "from" object (which is inside the "into"
//               object).  It can be thought of as the deepest point
//               of intersection.
//
//               The point will be converted into whichever coordinate
//               space the caller specifies.
//////////////////////////////////////////////////////////////////// 2 4 this 3 611  5 space 1 602  
95 14 Dtool_dlaq_a_e 0 6 107 572 0 14 Dtool_dlaq_a_e 515 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_all
//       Access: Published
//  Description: Simultaneously transforms the surface point, surface
//               normal, and interior point of the collision into the
//               indicated coordinate space.
//
//               Returns true if all three properties are available,
//               or false if any one of them is not.
//////////////////////////////////////////////////////////////////// 5 4 this 3 611  5 space 1 602  13 surface_point 1 570  14 surface_normal 1 615  14 interior_point 1 570  
96 14 Dtool_dlaq2U26 0 7 108 570 0 14 Dtool_dlaq2U26 462 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_contact_pos
//       Access: Published
//  Description: Returns the position of the "from" object at the instant
//               that a collision is first detected.
//
//               The position will be converted into whichever coordinate
//               space the caller specifies.
//////////////////////////////////////////////////////////////////// 2 4 this 3 611  5 space 1 602  
97 14 Dtool_dlaqM8_F 0 7 109 615 0 14 Dtool_dlaqM8_F 443 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_contact_normal
//       Access: Published
//  Description: Returns the surface normal of the "into" object at
//               the contact position.
//
//               The normal will be converted into whichever coordinate
//               space the caller specifies.
//////////////////////////////////////////////////////////////////// 2 4 this 3 611  5 space 1 602  
98 14 Dtool_dlaqmWGz 0 6 110 572 0 14 Dtool_dlaqmWGz 514 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::get_all_contact_info
//       Access: Published
//  Description: Simultaneously transforms the contact position and
//               contact normal of the collision into the
//               indicated coordinate space.
//
//               Returns true if all three properties are available,
//               or false if any one of them is not.
//////////////////////////////////////////////////////////////////// 4 4 this 3 611  5 space 1 602  11 contact_pos 1 570  14 contact_normal 1 615  
99 14 Dtool_dlaqwXJC 0 4 111 573 0 14 Dtool_dlaqwXJC 222 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::output
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 611  3 out 1 580  
100 14 Dtool_dlaq2JVw 0 4 112 573 0 14 Dtool_dlaq2JVw 221 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::write
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 3 4 this 3 611  3 out 1 580  12 indent_level 1 582  
101 14 Dtool_dlaqJrFD 0 4 112 573 0 14 Dtool_dlaqJrFD 221 ////////////////////////////////////////////////////////////////////
//     Function: CollisionEntry::write
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 611  3 out 1 580  
102 14 Dtool_dlaqSIuZ 0 7 113 584 0 14 Dtool_dlaqSIuZ 0 0 
103 14 Dtool_dlaq21w1 0 7 116 618 382 14 Dtool_dlaq21w1 228 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::Copy Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 616  
104 14 Dtool_dlaqQh2D 0 7 116 618 382 14 Dtool_dlaqQh2D 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 5 plane 1 619  
105 14 Dtool_dlaqmYK9 0 7 117 615 0 14 Dtool_dlaqmYK9 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::get_normal
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 616  
106 14 Dtool_dlaqOb8M 0 6 118 588 0 14 Dtool_dlaqOb8M 228 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::dist_to_plane
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 616  5 point 1 585  
107 14 Dtool_dlaqGJtB 0 4 119 573 0 14 Dtool_dlaqGJtB 224 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::set_plane
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 618  5 plane 1 619  
108 14 Dtool_dlaqr8W5 0 6 120 619 0 14 Dtool_dlaqr8W5 224 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::get_plane
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 616  
109 14 Dtool_dlaq_Rt2 0 4 121 573 0 14 Dtool_dlaq_Rt2 266 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPlane::flip
//       Access: Published
//  Description: Convenience method to flip the plane in-place.
//////////////////////////////////////////////////////////////////// 1 4 this 3 618  
110 14 Dtool_dlaq8byU 0 7 122 584 0 14 Dtool_dlaq8byU 0 0 
111 14 Dtool_dlaqf1c8 0 7 125 621 391 14 Dtool_dlaqf1c8 879 //: collisionPlane.I
// Created by:  drose (25Apr00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionPlane::Default Constructor
//       Access: Protected
//  Description: This is only for the convenience of CollisionPolygon.
//               Normally, you should not attempt to create an
//               uninitialized CollisionPlane.
//////////////////////////////////////////////////////////////////// 0 
112 14 Dtool_dlaqGOOn 0 4 126 573 0 14 Dtool_dlaqGOOn 266 ////////////////////////////////////////////////////////////////////
//     Function: CollisionFloorMesh::add_vertex
//       Access: Published
//  Description: store away a vertex to index against
//////////////////////////////////////////////////////////////////// 2 4 this 3 621  4 vert 1 585  
113 14 Dtool_dlaqjmeu 0 4 127 573 0 14 Dtool_dlaqjmeu 263 ////////////////////////////////////////////////////////////////////
//     Function: CollisionFloorMesh::add_triangle
//       Access: Published
//  Description: store a triangle for processing
//////////////////////////////////////////////////////////////////// 4 4 this 3 621  6 pointA 1 622  6 pointB 1 622  6 pointC 1 622  
114 14 Dtool_dlaqJ7Jg 0 6 128 622 0 14 Dtool_dlaqJ7Jg 0 1 4 this 3 623  
115 14 Dtool_dlaq2Xg6 0 7 129 585 0 14 Dtool_dlaq2Xg6 0 2 4 this 3 623  5 index 1 622  
116 14 Dtool_dlaqcnQl 0 6 130 622 0 14 Dtool_dlaqcnQl 0 1 4 this 3 623  
117 14 Dtool_dlaqHuD2 0 7 131 627 0 14 Dtool_dlaqHuD2 0 2 4 this 3 623  5 index 1 622  
118 14 Dtool_dlaqWn3e 0 7 132 584 0 14 Dtool_dlaqWn3e 0 0 
119 14 Dtool_dlaqLCpw 0 7 135 628 399 14 Dtool_dlaqLCpw 228 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 5 begin 1 585  3 end 1 585  
120 14 Dtool_dlaqdvbe 0 7 135 628 399 14 Dtool_dlaqdvbe 720 // Filename: collisionPolygon.I
// Created by:  drose (25Apr00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionPolygon::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 3 1 a 1 629  1 b 1 629  1 c 1 629  
121 14 Dtool_dlaqU3Jm 0 7 135 628 399 14 Dtool_dlaqU3Jm 228 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 4 1 a 1 629  1 b 1 629  1 c 1 629  1 d 1 629  
122 14 Dtool_dlaqdl51 0 6 136 582 0 14 Dtool_dlaqdl51 304 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::get_num_points
//       Access: Published
//  Description: Returns the number of vertices of the
//               CollisionPolygon.
//////////////////////////////////////////////////////////////////// 1 4 this 3 632  
123 14 Dtool_dlaqSH__ 0 7 137 570 0 14 Dtool_dlaqSH__ 315 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::get_point
//       Access: Published
//  Description: Returns the nth vertex of the CollisionPolygon,
//               expressed in 3-D space.
//////////////////////////////////////////////////////////////////// 2 4 this 3 632  1 n 1 582  
124 14 Dtool_dlaqFHAc 0 6 138 572 0 14 Dtool_dlaqFHAc 650 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::verify_points
//       Access: Public, Static
//  Description: Verifies that the indicated set of points will define
//               a valid CollisionPolygon: that is, at least three
//               non-collinear points, with no points repeated.
//
//               This does not check that the polygon defined is
//               convex; that check is made later, once we have
//               projected the points to 2-d space where the decision
//               is easier.
//////////////////////////////////////////////////////////////////// 2 5 begin 1 585  3 end 1 585  
125 14 Dtool_dlaqxElj 0 6 138 572 0 14 Dtool_dlaqxElj 423 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::verify_points
//       Access: Published, Static
//  Description: Verifies that the indicated set of points will define
//               a valid CollisionPolygon: that is, at least three
//               non-collinear points, with no points repeated.
//////////////////////////////////////////////////////////////////// 3 1 a 1 585  1 b 1 585  1 c 1 585  
126 14 Dtool_dlaqnB07 0 6 138 572 0 14 Dtool_dlaqnB07 423 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::verify_points
//       Access: Published, Static
//  Description: Verifies that the indicated set of points will define
//               a valid CollisionPolygon: that is, at least three
//               non-collinear points, with no points repeated.
//////////////////////////////////////////////////////////////////// 4 1 a 1 585  1 b 1 585  1 c 1 585  1 d 1 585  
127 14 Dtool_dlaqtOV6 0 6 139 572 0 14 Dtool_dlaqtOV6 365 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::is_valid
//       Access: Public
//  Description: Returns true if the CollisionPolygon is valid
//               (that is, it has at least three vertices), or false
//               otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 632  
128 14 Dtool_dlaqKWT1 0 6 140 572 0 14 Dtool_dlaqKWT1 334 ////////////////////////////////////////////////////////////////////
//     Function: CollisionPolygon::is_concave
//       Access: Public
//  Description: Returns true if the CollisionPolygon appears to be
//               concave, or false if it is safely convex.
//////////////////////////////////////////////////////////////////// 1 4 this 3 632  
129 14 Dtool_dlaqI99a 0 7 141 584 0 14 Dtool_dlaqI99a 0 0 
130 14 Dtool_dlaqETvw 0 7 144 634 419 14 Dtool_dlaqETvw 416 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::Constructor
//       Access: Public
//  Description: The default CollisionHandlerEvent will throw no
//               events.  Its pattern strings must first be set via a
//               call to add_in_pattern() and/or add_out_pattern().
//////////////////////////////////////////////////////////////////// 0 
131 14 Dtool_dlaqS2HY 0 4 145 573 0 14 Dtool_dlaqS2HY 323 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::clear_in_patterns
//       Access: Public
//  Description: Removes all of the previously-added in patterns.  See
//               add_in_pattern.
//////////////////////////////////////////////////////////////////// 1 4 this 3 634  
132 14 Dtool_dlaq_2Bj 0 4 146 573 0 14 Dtool_dlaq_2Bj 2355 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::add_in_pattern
//       Access: Public
//  Description: Adds a pattern string to the list of events that will
//               be generated in response to a collision.  The pattern
//               string describes how the event name will be composed.
//               It is a string that may contain any of the following:
//
//                  %fn  - the name of the "from" object's node
//                  %in  - the name of the "into" object's node
//                  %fs  - 't' if "from" is tangible, 'i' if intangible
//                  %is  - 't' if "into" is tangible, 'i' if intangible
//                  %ig  - 'c' if the collision is into a
//                          CollisionNode, 'g' if it is a geom.
//
//                  %(tag)fh - generate event only if "from" node has
//                          the indicated net tag.
//                  %(tag)fx - generate event only if "from" node does 
//                          not have the indicated net tag.
//                  %(tag)ih - generate event only if "into" node has
//                          the indicated net tag.
//                  %(tag)ix - generate event only if "into" node does 
//                          not have the indicated net tag.
//                  %(tag)ft - the indicated net tag value of the "from" node.
//                  %(tag)it - the indicated net tag value of the "into" node.
//
//               Parentheses in the above are literal and should be
//               included in the actual pattern.
//
//               The event name will be based on the in_pattern
//               string specified here, with all occurrences of the
//               above strings replaced with the corresponding values.
//
//               In general, the in_pattern event is thrown on the
//               first detection of a collision between two particular
//               nodes.  In subsequent passes, as long as a collision
//               between those two nodes continues to be detected each
//               frame, the again_pattern is thrown.  The first frame
//               in which the collision is no longer detected, the
//               out_pattern event is thrown.
//////////////////////////////////////////////////////////////////// 2 4 this 3 634  10 in_pattern 1 593  
133 14 Dtool_dlaqkSzo 0 4 147 573 0 14 Dtool_dlaqkSzo 395 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::set_in_pattern
//       Access: Public
//  Description: This method is deprecated; it completely replaces all
//               the in patterns that have previously been set with
//               the indicated pattern.
//////////////////////////////////////////////////////////////////// 2 4 this 3 634  10 in_pattern 1 593  
134 14 Dtool_dlaqc0hf 0 6 148 582 0 14 Dtool_dlaqc0hf 318 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_num_in_patterns
//       Access: Public
//  Description: Returns the number of in pattern strings that have
//               been added.
//////////////////////////////////////////////////////////////////// 1 4 this 3 635  
135 14 Dtool_dlaqlCzc 0 6 149 593 0 14 Dtool_dlaqlCzc 399 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_in_pattern
//       Access: Public
//  Description: Returns the nth pattern string that indicates how the
//               event names are generated for each collision
//               detected.  See add_in_pattern().
//////////////////////////////////////////////////////////////////// 2 4 this 3 635  1 n 1 582  
136 14 Dtool_dlaqf7gg 0 4 150 573 0 14 Dtool_dlaqf7gg 329 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::clear_again_patterns
//       Access: Public
//  Description: Removes all of the previously-added in patterns.  See
//               add_again_pattern.
//////////////////////////////////////////////////////////////////// 1 4 this 3 634  
137 14 Dtool_dlaqUwhr 0 4 151 573 0 14 Dtool_dlaqUwhr 1055 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::add_again_pattern
//       Access: Public
//  Description: Adds the pattern string that indicates how the event
//               names are generated when a collision between two
//               particular nodes is *still* detected.  This event is
//               thrown each consecutive time a collision between two
//               particular nodes is detected, starting with the
//               second time.
//
//               In general, the in_pattern event is thrown on the
//               first detection of a collision between two particular
//               nodes.  In subsequent passes, as long as a collision
//               between those two nodes continues to be detected each
//               frame, the again_pattern is thrown.  The first frame
//               in which the collision is no longer detected, the
//               out_pattern event is thrown.
//////////////////////////////////////////////////////////////////// 2 4 this 3 634  13 again_pattern 1 593  
138 14 Dtool_dlaqGYTx 0 4 152 573 0 14 Dtool_dlaqGYTx 398 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::set_again_pattern
//       Access: Public
//  Description: This method is deprecated; it completely replaces all
//               the in patterns that have previously been set with
//               the indicated pattern.
//////////////////////////////////////////////////////////////////// 2 4 this 3 634  13 again_pattern 1 593  
139 14 Dtool_dlaqti_4 0 6 153 582 0 14 Dtool_dlaqti_4 321 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_num_again_patterns
//       Access: Public
//  Description: Returns the number of in pattern strings that have
//               been added.
//////////////////////////////////////////////////////////////////// 1 4 this 3 635  
140 14 Dtool_dlaqeNwh 0 6 154 593 0 14 Dtool_dlaqeNwh 405 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_again_pattern
//       Access: Public
//  Description: Returns the nth pattern string that indicates how the
//               event names are generated for each collision
//               detected.  See add_again_pattern().
//////////////////////////////////////////////////////////////////// 2 4 this 3 635  1 n 1 582  
141 14 Dtool_dlaqjRM0 0 4 155 573 0 14 Dtool_dlaqjRM0 325 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::clear_out_patterns
//       Access: Public
//  Description: Removes all of the previously-added in patterns.  See
//               add_out_pattern.
//////////////////////////////////////////////////////////////////// 1 4 this 3 634  
142 14 Dtool_dlaqLN0g 0 4 156 573 0 14 Dtool_dlaqLN0g 877 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::add_out_pattern
//       Access: Public
//  Description: Adds the pattern string that indicates how the event
//               names are generated when a collision between two
//               particular nodes is *no longer* detected.
//
//               In general, the in_pattern event is thrown on the
//               first detection of a collision between two particular
//               nodes.  In subsequent passes, as long as a collision
//               between those two nodes continues to be detected each
//               frame, the again_pattern is thrown.  The first frame
//               in which the collision is no longer detected, the
//               out_pattern event is thrown.
//////////////////////////////////////////////////////////////////// 2 4 this 3 634  11 out_pattern 1 593  
143 14 Dtool_dlaqnKnm 0 4 157 573 0 14 Dtool_dlaqnKnm 396 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::set_out_pattern
//       Access: Public
//  Description: This method is deprecated; it completely replaces all
//               the in patterns that have previously been set with
//               the indicated pattern.
//////////////////////////////////////////////////////////////////// 2 4 this 3 634  11 out_pattern 1 593  
144 14 Dtool_dlaqClvc 0 6 158 582 0 14 Dtool_dlaqClvc 319 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_num_out_patterns
//       Access: Public
//  Description: Returns the number of in pattern strings that have
//               been added.
//////////////////////////////////////////////////////////////////// 1 4 this 3 635  
145 14 Dtool_dlaqOFH_ 0 6 159 593 0 14 Dtool_dlaqOFH_ 401 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::get_out_pattern
//       Access: Public
//  Description: Returns the nth pattern string that indicates how the
//               event names are generated for each collision
//               detected.  See add_out_pattern().
//////////////////////////////////////////////////////////////////// 2 4 this 3 635  1 n 1 582  
146 14 Dtool_dlaqvtnS 0 4 160 573 0 14 Dtool_dlaqvtnS 887 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::clear
//       Access: Public
//  Description: Empties the list of elements that all colliders are
//               known to be colliding with.  No "out" events will be
//               thrown; if the same collision is detected next frame,
//               a new "in" event will be thrown for each collision.
//
//               This can be called each frame to defeat the
//               persistent "in" event mechanism, which prevents the
//               same "in" event from being thrown repeatedly.
//               However, also see add_again_pattern(), which can be
//               used to set the event that is thrown when a collision
//               is detected for two or more consecutive frames.
//////////////////////////////////////////////////////////////////// 1 4 this 3 634  
147 14 Dtool_dlaqnPG9 0 4 161 573 0 14 Dtool_dlaqnPG9 272 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::flush
//       Access: Public
//  Description: Same as clear() except "out" events are thrown.
//////////////////////////////////////////////////////////////////// 1 4 this 3 634  
148 14 Dtool_dlaqYcqn 0 7 162 584 0 14 Dtool_dlaqYcqn 0 0 
149 14 Dtool_dlaqGz2x 0 4 165 573 0 14 Dtool_dlaqGz2x 452 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::add_collider
//       Access: Published
//  Description: Adds a new collider to the list with a NodePath
//               that will be updated with the collider's new
//               position, or updates the existing collider with a new
//               NodePath object.
//////////////////////////////////////////////////////////////////// 3 4 this 3 637  8 collider 1 602  6 target 1 602  
150 14 Dtool_dlaqinQs 0 4 165 573 0 14 Dtool_dlaqinQs 705 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::add_collider
//       Access: Published
//  Description: Adds a new collider to the list with a NodePath
//               that will be updated with the collider's new
//               position, or updates the existing collider with a new
//               NodePath object.
//
//               The indicated DriveInterface will also be updated
//               with the target's new transform each frame.  This
//               method should be used when the target is directly
//               controlled by a DriveInterface.
//////////////////////////////////////////////////////////////////// 4 4 this 3 637  8 collider 1 602  6 target 1 602  15 drive_interface 1 638  
151 14 Dtool_dlaq8hFg 0 6 166 572 0 14 Dtool_dlaq8hFg 336 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::remove_collider
//       Access: Published
//  Description: Removes the collider from the list of colliders that
//               this handler knows about.
//////////////////////////////////////////////////////////////////// 2 4 this 3 637  8 collider 1 602  
152 14 Dtool_dlaqtNFK 0 6 167 572 0 14 Dtool_dlaqtNFK 335 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::has_collider
//       Access: Published
//  Description: Returns true if the handler knows about the indicated
//               collider, false otherwise.
//////////////////////////////////////////////////////////////////// 2 4 this 3 640  8 collider 1 602  
153 14 Dtool_dlaqUoUz 0 4 168 573 0 14 Dtool_dlaqUoUz 324 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::clear_colliders
//       Access: Published
//  Description: Completely empties the list of colliders this handler
//               knows about.
//////////////////////////////////////////////////////////////////// 1 4 this 3 637  
154 14 Dtool_dlaq9CVE 0 4 169 573 0 14 Dtool_dlaq9CVE 1053 // Filename: collisionHandlerPhysical.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionHandlerPhysical::set_center
//       Access: Published
//  Description: Specifies an arbitrary NodePath that the handler is
//               always considered to be facing.  It does not detect
//               collisions with surfaces that appear to be facing
//               away from this NodePath.  This works best when the
//               collision surfaces in question are polygons.
//////////////////////////////////////////////////////////////////// 2 4 this 3 637  6 center 1 602  
155 14 Dtool_dlaqRo9a 0 4 170 573 0 14 Dtool_dlaqRo9a 291 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::clear_center
//       Access: Published
//  Description: Clears the center NodePath specified with set_center.
//////////////////////////////////////////////////////////////////// 1 4 this 3 637  
156 14 Dtool_dlaq_dUV 0 6 171 602 0 14 Dtool_dlaq_dUV 353 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::get_center
//       Access: Published
//  Description: Returns the NodePath specified with set_center, or
//               the empty NodePath if nothing has been specified.
//////////////////////////////////////////////////////////////////// 1 4 this 3 640  
157 14 Dtool_dlaqf3XJ 0 6 172 572 0 14 Dtool_dlaqf3XJ 334 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::has_center
//       Access: Published
//  Description: Returns true if a NodePath has been specified with
//               set_center(), false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 640  
158 14 Dtool_dlaqA0o_ 0 6 173 572 0 14 Dtool_dlaqA0o_ 537 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPhysical::has_contact
//       Access: Public
//  Description: Did the handler make any contacts with anything
//               on the last collision pass?  Depending on how your
//               world is setup, this can be used to tell if the
//               handler is out of the world (i.e. out of bounds).
//               That is the original use of this call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 640  
159 14 Dtool_dlaqNl13 0 7 174 584 0 14 Dtool_dlaqNl13 0 0 
160 14 Dtool_dlaq3EUx 0 7 176 642 419 14 Dtool_dlaq3EUx 230 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
161 14 Dtool_dlaq3NQk 0 4 177 573 0 14 Dtool_dlaq3NQk 910 // Filename: collisionHandlerFloor.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionHandlerFloor::set_offset
//       Access: Public
//  Description: Sets the linear offset to add to (or subtract from)
//               the highest detected collision point to determine the
//               actual height at which to set the collider.
//////////////////////////////////////////////////////////////////// 2 4 this 3 642  6 offset 1 588  
162 14 Dtool_dlaqG9Un 0 6 178 588 0 14 Dtool_dlaqG9Un 416 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::get_offset
//       Access: Public
//  Description: Returns the linear offset to add to (or subtract from)
//               the highest detected collision point to determine the
//               actual height at which to set the collider.
//////////////////////////////////////////////////////////////////// 1 4 this 3 643  
163 14 Dtool_dlaqLik1 0 4 179 573 0 14 Dtool_dlaqLik1 317 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::set_reach
//       Access: Public
//  Description: Sets the reach to add to (or subtract from)
//               the highest collision point
//////////////////////////////////////////////////////////////////// 2 4 this 3 642  5 reach 1 588  
164 14 Dtool_dlaqTc80 0 6 180 588 0 14 Dtool_dlaqTc80 320 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::get_reach
//       Access: Public
//  Description: Returns the reach to add to (or subtract from)
//               the highest collision point
//////////////////////////////////////////////////////////////////// 1 4 this 3 643  
165 14 Dtool_dlaq4LRc 0 4 181 573 0 14 Dtool_dlaq4LRc 469 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::set_max_velocity
//       Access: Public
//  Description: Sets the maximum speed at which the object will be
//               allowed to descend towards a floor below it, in units
//               per second.  Set this to zero to allow it to
//               instantly teleport any distance.
//////////////////////////////////////////////////////////////////// 2 4 this 3 642  7 max_vel 1 588  
166 14 Dtool_dlaqS6Z5 0 6 182 588 0 14 Dtool_dlaqS6Z5 416 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFloor::get_max_velocity
//       Access: Public
//  Description: Retrieves the maximum speed at which the object will
//               be allowed to descend towards a floor below it, in
//               units per second.  See set_max_velocity().
//////////////////////////////////////////////////////////////////// 1 4 this 3 643  
167 14 Dtool_dlaqHYw3 0 7 183 584 0 14 Dtool_dlaqHYw3 0 0 
168 14 Dtool_dlaqOYFg 0 7 185 645 419 14 Dtool_dlaqOYFg 231 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPusher::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
169 14 Dtool_dlaqLy7k 0 4 186 573 0 14 Dtool_dlaqLy7k 732 // Filename: collisionHandlerPusher.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionHandlerPusher::set_horizontal
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 645  4 flag 1 572  
170 14 Dtool_dlaq9VDN 0 6 187 572 0 14 Dtool_dlaq9VDN 234 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerPusher::get_horizontal
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 646  
171 14 Dtool_dlaqQVou 0 7 188 584 0 14 Dtool_dlaqQVou 0 0 
172 14 Dtool_dlaqMshf 0 7 190 648 444 14 Dtool_dlaqMshf 236 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerFluidPusher::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
173 14 Dtool_dlaqx8qp 0 7 191 584 0 14 Dtool_dlaqx8qp 0 0 
174 14 Dtool_dlaqy_jT 0 7 194 649 419 14 Dtool_dlaqy_jT 232 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
175 14 Dtool_dlaq5C9R 0 4 195 573 0 14 Dtool_dlaq5C9R 914 // Filename: CollisionHandlerGravity.I
// Created by:  drose (16Mar02)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionHandlerGravity::set_offset
//       Access: Public
//  Description: Sets the linear offset to add to (or subtract from)
//               the highest detected collision point to determine the
//               actual height at which to set the collider.
//////////////////////////////////////////////////////////////////// 2 4 this 3 649  6 offset 1 588  
176 14 Dtool_dlaqu78c 0 6 196 588 0 14 Dtool_dlaqu78c 418 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_offset
//       Access: Public
//  Description: Returns the linear offset to add to (or subtract from)
//               the highest detected collision point to determine the
//               actual height at which to set the collider.
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
177 14 Dtool_dlaqV1C6 0 4 197 573 0 14 Dtool_dlaqV1C6 319 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_reach
//       Access: Public
//  Description: Sets the reach to add to (or subtract from)
//               the highest collision point
//////////////////////////////////////////////////////////////////// 2 4 this 3 649  5 reach 1 588  
178 14 Dtool_dlaq22RV 0 6 198 588 0 14 Dtool_dlaq22RV 322 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_reach
//       Access: Public
//  Description: Returns the reach to add to (or subtract from)
//               the highest collision point
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
179 14 Dtool_dlaqlkVy 0 6 199 588 0 14 Dtool_dlaqlkVy 527 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_airborne_height
//       Access: Public
//  Description: Return the height of the object from the ground.
//
//               The object might not necessarily be at rest.  Use
//               is_on_ground() if you want to know whether the
//               object is on the ground and at rest.
//
//               See Also: is_in_outer_space()
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
180 14 Dtool_dlaqI07o 0 6 200 572 0 14 Dtool_dlaqI07o 256 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::is_on_ground
//       Access: Public
//  Description: Is the object at rest?
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
181 14 Dtool_dlaqbFxY 0 6 201 588 0 14 Dtool_dlaqbFxY 586 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_impact_velocity
//       Access: Public
//  Description: How hard did the object hit the ground.
//               This value is set on impact with the ground.
//               You may want to watch (poll) on is_on_groun() and
//               when that is true, call get_impact_velocity().
//               Normally I avoid polling, but we are calling
//               is_on_ground() frequently anyway.
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
182 14 Dtool_dlaqKQo4 0 6 202 574 0 14 Dtool_dlaqKQo4 240 ////////////////////////////////////////////////////////////////////
//    Function : CollisionHandlerGravity::get_contact_normal
//      Access : Public
// Description : 
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
183 14 Dtool_dlaqwddg 0 4 203 573 0 14 Dtool_dlaqwddg 451 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::add_velocity
//       Access: Public
//  Description: Adds the sepcified amount to the current velocity.
//               This is mostly here allow this common operation to
//               be faster for scripting, but it's also more concise
//               even in cpp.
//////////////////////////////////////////////////////////////////// 2 4 this 3 649  8 velocity 1 588  
184 14 Dtool_dlaqXI_M 0 4 204 573 0 14 Dtool_dlaqXI_M 269 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_velocity
//       Access: Public
//  Description: Sets the current vertical velocity.
//////////////////////////////////////////////////////////////////// 2 4 this 3 649  8 velocity 1 588  
185 14 Dtool_dlaqrnWU 0 6 205 588 0 14 Dtool_dlaqrnWU 681 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_velocity
//       Access: Public
//  Description: Gets the current vertical velocity.
//
//               Generally, negative values mean the object is in
//               free fall; while postive values mean the object has
//               vertical thrust.
//
//               A zero value does not necessarily mean the object
//               on the ground, it may also be weightless and/or at
//               the apex of its jump.
//
//               See Also: is_on_ground() and get_gravity()
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
186 14 Dtool_dlaqmWBh 0 4 206 573 0 14 Dtool_dlaqmWBh 278 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_gravity
//       Access: Public
//  Description: Sets the linear gravity force (always plumb).
//////////////////////////////////////////////////////////////////// 2 4 this 3 649  7 gravity 1 588  
187 14 Dtool_dlaqmZKk 0 6 207 588 0 14 Dtool_dlaqmZKk 278 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_gravity
//       Access: Public
//  Description: Gets the linear gravity force (always plumb).
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
188 14 Dtool_dlaqkg9z 0 4 208 573 0 14 Dtool_dlaqkg9z 471 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_max_velocity
//       Access: Public
//  Description: Sets the maximum speed at which the object will be
//               allowed to descend towards a floor below it, in units
//               per second.  Set this to zero to allow it to
//               instantly teleport any distance.
//////////////////////////////////////////////////////////////////// 2 4 this 3 649  7 max_vel 1 588  
189 14 Dtool_dlaqlxjB 0 6 209 588 0 14 Dtool_dlaqlxjB 418 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_max_velocity
//       Access: Public
//  Description: Retrieves the maximum speed at which the object will
//               be allowed to descend towards a floor below it, in
//               units per second.  See set_max_velocity().
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
190 14 Dtool_dlaqFwa9 0 4 210 573 0 14 Dtool_dlaqFwa9 517 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::set_legacy_mode
//       Access: Public
//  Description: Enables old behavior required by Toontown
//               (Sellbot Factory lava room is good test case,
//               lava and conveyor belt specifically). Behavior
//               is to throw enter/exit events only for floor
//               that the toon is in contact with
//////////////////////////////////////////////////////////////////// 2 4 this 3 649  11 legacy_mode 1 572  
191 14 Dtool_dlaq00fZ 0 6 211 572 0 14 Dtool_dlaq00fZ 275 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerGravity::get_legacy_mode
//       Access: Public
//  Description: returns true if legacy mode is enabled
//////////////////////////////////////////////////////////////////// 1 4 this 3 650  
192 14 Dtool_dlaqJ2aU 0 7 212 584 0 14 Dtool_dlaqJ2aU 0 0 
193 14 Dtool_dlaqETBI 0 7 214 652 466 14 Dtool_dlaqETBI 416 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerEvent::Constructor
//       Access: Public
//  Description: The default CollisionHandlerEvent will throw no
//               events.  Its pattern strings must first be set via a
//               call to add_in_pattern() and/or add_out_pattern().
//////////////////////////////////////////////////////////////////// 0 
194 14 Dtool_dlaqGCHT 0 7 215 584 0 14 Dtool_dlaqGCHT 0 0 
195 14 Dtool_dlaqQGY4 0 7 218 653 475 14 Dtool_dlaqQGY4 233 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
196 14 Dtool_dlaq4_OE 0 4 219 573 0 14 Dtool_dlaq4_OE 540 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::sort_entries
//       Access: Published
//  Description: Sorts all the detected collisions front-to-back by
//               from_intersection_point() so that those intersection
//               points closest to the collider's origin (e.g., the
//               center of the CollisionSphere, or the point_a of a
//               CollisionSegment) appear first.
//////////////////////////////////////////////////////////////////// 1 4 this 3 653  
197 14 Dtool_dlaqZKav 0 4 220 573 0 14 Dtool_dlaqZKav 275 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::clear_entries
//       Access: Published
//  Description: Removes all the entries from the queue.
//////////////////////////////////////////////////////////////////// 1 4 this 3 653  
198 14 Dtool_dlaq0Ndh 0 6 221 582 0 14 Dtool_dlaq0Ndh 313 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::get_num_entries
//       Access: Published
//  Description: Returns the number of CollisionEntries detected last
//               pass.
//////////////////////////////////////////////////////////////////// 1 4 this 3 654  
199 14 Dtool_dlaqbEk_ 0 7 222 614 374 14 Dtool_dlaqbEk_ 282 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::get_entry
//       Access: Published
//  Description: Returns the nth CollisionEntry detected last pass.
//////////////////////////////////////////////////////////////////// 2 4 this 3 654  1 n 1 582  
200 14 Dtool_dlaqLz1_ 0 4 223 573 0 14 Dtool_dlaqLz1_ 229 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::output
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 654  3 out 1 580  
201 14 Dtool_dlaqSF0h 0 4 224 573 0 14 Dtool_dlaqSF0h 228 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::write
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 3 4 this 3 654  3 out 1 580  12 indent_level 1 582  
202 14 Dtool_dlaqz930 0 4 224 573 0 14 Dtool_dlaqz930 228 ////////////////////////////////////////////////////////////////////
//     Function: CollisionHandlerQueue::write
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 654  3 out 1 580  
203 14 Dtool_dlaqmngh 0 7 225 584 0 14 Dtool_dlaqmngh 0 0 
204 14 Dtool_dlaqLNNB 0 7 228 656 482 14 Dtool_dlaqLNNB 715 // Filename: collisionSphere.I
// Created by:  drose (24Apr00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionSphere::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 6 center 1 585  6 radius 1 588  
205 14 Dtool_dlaq2Rzm 0 7 228 656 482 14 Dtool_dlaq2Rzm 224 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 4 2 cx 1 588  2 cy 1 588  2 cz 1 588  6 radius 1 588  
206 14 Dtool_dlaq3CUl 0 4 229 573 0 14 Dtool_dlaq3CUl 226 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::set_center
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 656  6 center 1 585  
207 14 Dtool_dlaqodaV 0 4 229 573 0 14 Dtool_dlaqodaV 226 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::set_center
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 656  1 x 1 588  1 y 1 588  1 z 1 588  
208 14 Dtool_dlaqzgAq 0 6 230 585 0 14 Dtool_dlaqzgAq 226 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::get_center
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 657  
209 14 Dtool_dlaquEwq 0 4 231 573 0 14 Dtool_dlaquEwq 226 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::set_radius
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 656  6 radius 1 588  
210 14 Dtool_dlaqLSzr 0 6 232 588 0 14 Dtool_dlaqLSzr 226 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSphere::get_radius
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 657  
211 14 Dtool_dlaqOm79 0 7 233 584 0 14 Dtool_dlaqOm79 0 0 
212 14 Dtool_dlaq_yWY 0 7 236 659 485 14 Dtool_dlaq_yWY 721 // Filename: collisionInvSphere.I
// Created by:  drose (05Jan05)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionInvSphere::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 6 center 1 585  6 radius 1 588  
213 14 Dtool_dlaqUKHB 0 7 236 659 485 14 Dtool_dlaqUKHB 227 ////////////////////////////////////////////////////////////////////
//     Function: CollisionInvSphere::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 4 2 cx 1 588  2 cy 1 588  2 cz 1 588  6 radius 1 588  
214 14 Dtool_dlaq9Ep8 0 7 237 584 0 14 Dtool_dlaq9Ep8 0 0 
215 14 Dtool_dlaqOnzJ 0 7 240 660 493 14 Dtool_dlaqOnzJ 935 // Filename: collisionRay.I
// Created by:  drose (22Jun00)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionRay::Default Constructor
//       Access: Public
//  Description: Creates an invalid ray.  This isn't terribly useful;
//               it's expected that the user will subsequently adjust
//               the ray via set_origin()/set_direction() or
//               set_from_lens().
//////////////////////////////////////////////////////////////////// 0 
216 14 Dtool_dlaquWsc 0 7 240 660 493 14 Dtool_dlaquWsc 221 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 6 origin 1 585  9 direction 1 574  
217 14 Dtool_dlaqsJco 0 7 240 660 493 14 Dtool_dlaqsJco 221 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 6 2 ox 1 588  2 oy 1 588  2 oz 1 588  2 dx 1 588  2 dy 1 588  2 dz 1 588  
218 14 Dtool_dlaqWQg4 0 4 241 573 0 14 Dtool_dlaqWQg4 220 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_origin
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 660  6 origin 1 585  
219 14 Dtool_dlaqCEZ5 0 4 241 573 0 14 Dtool_dlaqCEZ5 220 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_origin
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 660  1 x 1 588  1 y 1 588  1 z 1 588  
220 14 Dtool_dlaqo7AW 0 6 242 585 0 14 Dtool_dlaqo7AW 220 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::get_origin
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 661  
221 14 Dtool_dlaqFnJ_ 0 4 243 573 0 14 Dtool_dlaqFnJ_ 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_direction
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 660  9 direction 1 574  
222 14 Dtool_dlaqu5k9 0 4 243 573 0 14 Dtool_dlaqu5k9 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_direction
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 660  1 x 1 588  1 y 1 588  1 z 1 588  
223 14 Dtool_dlaqxcuk 0 6 244 574 0 14 Dtool_dlaqxcuk 223 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::get_direction
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 661  
224 14 Dtool_dlaqDz4_ 0 6 245 572 0 14 Dtool_dlaqDz4_ 630 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_from_lens
//       Access: Public
//  Description: Accepts a LensNode and a 2-d point in the range
//               [-1,1].  Sets the CollisionRay so that it begins at
//               the LensNode's near plane and extends to
//               infinity, making it suitable for picking objects from
//               the screen given a camera and a mouse location.
//
//               Returns true if the point was acceptable, false
//               otherwise.
//////////////////////////////////////////////////////////////////// 3 4 this 3 660  6 camera 1 663  5 point 1 665  
225 14 Dtool_dlaqkXhs 0 6 245 572 0 14 Dtool_dlaqkXhs 534 ////////////////////////////////////////////////////////////////////
//     Function: CollisionRay::set_from_lens
//       Access: Public
//  Description: Accepts a LensNode and a 2-d point in the range
//               [-1,1].  Sets the CollisionRay so that it begins at
//               the LensNode's near plane and extends to
//               infinity, making it suitable for picking objects from
//               the screen given a camera and a mouse location.
//////////////////////////////////////////////////////////////////// 4 4 this 3 660  6 camera 1 663  2 px 1 588  2 py 1 588  
226 14 Dtool_dlaqVl1_ 0 7 246 584 0 14 Dtool_dlaqVl1_ 0 0 
227 14 Dtool_dlaqbj0W 0 7 249 668 496 14 Dtool_dlaqbj0W 939 // Filename: collisionLine.I
// Created by:  drose (05Jan05)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionLine::Default Constructor
//       Access: Public
//  Description: Creates an invalid line.  This isn't terribly useful;
//               it's expected that the user will subsequently adjust
//               the line via set_origin()/set_direction() or
//               set_from_lens().
//////////////////////////////////////////////////////////////////// 0 
228 14 Dtool_dlaqkrPl 0 7 249 668 496 14 Dtool_dlaqkrPl 222 ////////////////////////////////////////////////////////////////////
//     Function: CollisionLine::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 6 origin 1 585  9 direction 1 574  
229 14 Dtool_dlaqXh24 0 7 249 668 496 14 Dtool_dlaqXh24 222 ////////////////////////////////////////////////////////////////////
//     Function: CollisionLine::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 6 2 ox 1 588  2 oy 1 588  2 oz 1 588  2 dx 1 588  2 dy 1 588  2 dz 1 588  
230 14 Dtool_dlaqRXQf 0 7 250 584 0 14 Dtool_dlaqRXQf 0 0 
231 14 Dtool_dlaqEYjD 0 7 253 669 505 14 Dtool_dlaqEYjD 759 // Filename: collisionParabola.I
// Created by:  drose (11Oct07)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionParabola::Default Constructor
//       Access: Published
//  Description: Creates an invalid parabola.
//////////////////////////////////////////////////////////////////// 0 
232 14 Dtool_dlaqBc0T 0 7 253 669 505 14 Dtool_dlaqBc0T 343 ////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::Constructor
//       Access: Published
//  Description: Creates a parabola with the endpoints between t1 and
//               t2 in the parametric space of the parabola.
//////////////////////////////////////////////////////////////////// 3 8 parabola 1 670  2 t1 1 588  2 t2 1 588  
233 14 Dtool_dlaqtS5X 0 4 254 573 0 14 Dtool_dlaqtS5X 274 ////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::set_parabola
//       Access: Public
//  Description: Replaces the parabola specified by this solid.
//////////////////////////////////////////////////////////////////// 2 4 this 3 669  8 parabola 1 670  
234 14 Dtool_dlaqy34O 0 6 255 670 0 14 Dtool_dlaqy34O 273 ////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::get_parabola
//       Access: Public
//  Description: Returns the parabola specified by this solid.
//////////////////////////////////////////////////////////////////// 1 4 this 3 673  
235 14 Dtool_dlaqTMv_ 0 4 256 573 0 14 Dtool_dlaqTMv_ 265 ////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::set_t1
//       Access: Public
//  Description: Changes the starting point on the parabola.
//////////////////////////////////////////////////////////////////// 2 4 this 3 669  2 t1 1 588  
236 14 Dtool_dlaqtUNU 0 6 257 588 0 14 Dtool_dlaqtUNU 265 ////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::get_t1
//       Access: Public
//  Description: Returns the starting point on the parabola.
//////////////////////////////////////////////////////////////////// 1 4 this 3 673  
237 14 Dtool_dlaqKew_ 0 4 258 573 0 14 Dtool_dlaqKew_ 263 ////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::set_t2
//       Access: Public
//  Description: Changes the ending point on the parabola.
//////////////////////////////////////////////////////////////////// 2 4 this 3 669  2 t2 1 588  
238 14 Dtool_dlaqkGOU 0 6 259 588 0 14 Dtool_dlaqkGOU 263 ////////////////////////////////////////////////////////////////////
//     Function: CollisionParabola::get_t2
//       Access: Public
//  Description: Returns the ending point on the parabola.
//////////////////////////////////////////////////////////////////// 1 4 this 3 673  
239 14 Dtool_dlaqoAK5 0 7 260 584 0 14 Dtool_dlaqoAK5 0 0 
240 14 Dtool_dlaqG_0_ 0 7 263 675 513 14 Dtool_dlaqG_0_ 951 // Filename: collisionSegment.I
// Created by:  drose (30Jan01)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionSegment::Default Constructor
//       Access: Public
//  Description: Creates an invalid segment.  This isn't terribly useful;
//               it's expected that the user will subsequently adjust
//               the segment via set_origin()/set_direction() or
//               set_from_lens().
//////////////////////////////////////////////////////////////////// 0 
241 14 Dtool_dlaqhcIM 0 7 263 675 513 14 Dtool_dlaqhcIM 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 1 a 1 585  2 db 1 585  
242 14 Dtool_dlaqGSlK 0 7 263 675 513 14 Dtool_dlaqGSlK 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 6 2 ax 1 588  2 ay 1 588  2 az 1 588  2 bx 1 588  2 by 1 588  2 bz 1 588  
243 14 Dtool_dlaq5ebw 0 4 264 573 0 14 Dtool_dlaq5ebw 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_point_a
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 675  1 a 1 585  
244 14 Dtool_dlaqyePy 0 4 264 573 0 14 Dtool_dlaqyePy 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_point_a
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 675  1 x 1 588  1 y 1 588  1 z 1 588  
245 14 Dtool_dlaqxXkX 0 6 265 585 0 14 Dtool_dlaqxXkX 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::get_point_a
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 676  
246 14 Dtool_dlaqyVbM 0 4 266 573 0 14 Dtool_dlaqyVbM 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_point_b
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 675  1 b 1 585  
247 14 Dtool_dlaq1bPO 0 4 266 573 0 14 Dtool_dlaq1bPO 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_point_b
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 675  1 x 1 588  1 y 1 588  1 z 1 588  
248 14 Dtool_dlaq5Kkz 0 6 267 585 0 14 Dtool_dlaq5Kkz 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::get_point_b
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 676  
249 14 Dtool_dlaqlPim 0 6 268 572 0 14 Dtool_dlaqlPim 643 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_from_lens
//       Access: Public
//  Description: Accepts a LensNode and a 2-d point in the range
//               [-1,1].  Sets the CollisionSegment so that it begins at
//               the LensNode's near plane and extends to the
//               far plane, making it suitable for picking objects
//               from the screen given a camera and a mouse location.
//
//               Returns true if the point was acceptable, false
//               otherwise.
//////////////////////////////////////////////////////////////////// 3 4 this 3 675  6 camera 1 663  5 point 1 665  
250 14 Dtool_dlaqq5Ut 0 6 268 572 0 14 Dtool_dlaqq5Ut 547 ////////////////////////////////////////////////////////////////////
//     Function: CollisionSegment::set_from_lens
//       Access: Public
//  Description: Accepts a LensNode and a 2-d point in the range
//               [-1,1].  Sets the CollisionSegment so that it begins at
//               the LensNode's near plane and extends to the
//               far plane, making it suitable for picking objects
//               from the screen given a camera and a mouse location.
//////////////////////////////////////////////////////////////////// 4 4 this 3 675  6 camera 1 663  2 px 1 588  2 py 1 588  
251 14 Dtool_dlaqkImW 0 7 269 584 0 14 Dtool_dlaqkImW 0 0 
252 14 Dtool_dlaqyNS4 0 7 272 678 522 14 Dtool_dlaqyNS4 711 // Filename: collisionTube.I
// Created by:  drose (25Sep03)
//
////////////////////////////////////////////////////////////////////
//
// 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: CollisionTube::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 3 1 a 1 585  2 db 1 585  6 radius 1 588  
253 14 Dtool_dlaqe_eG 0 7 272 678 522 14 Dtool_dlaqe_eG 222 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 7 2 ax 1 588  2 ay 1 588  2 az 1 588  2 bx 1 588  2 by 1 588  2 bz 1 588  6 radius 1 588  
254 14 Dtool_dlaq8Wt6 0 4 273 573 0 14 Dtool_dlaq8Wt6 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_point_a
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 678  1 a 1 585  
255 14 Dtool_dlaq2wJc 0 4 273 573 0 14 Dtool_dlaq2wJc 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_point_a
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 678  1 x 1 588  1 y 1 588  1 z 1 588  
256 14 Dtool_dlaqoxl7 0 6 274 585 0 14 Dtool_dlaqoxl7 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::get_point_a
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 679  
257 14 Dtool_dlaqcSS7 0 4 275 573 0 14 Dtool_dlaqcSS7 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_point_b
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 678  1 b 1 585  
258 14 Dtool_dlaqWPxc 0 4 275 573 0 14 Dtool_dlaqWPxc 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_point_b
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 678  1 x 1 588  1 y 1 588  1 z 1 588  
259 14 Dtool_dlaqI1M8 0 6 276 585 0 14 Dtool_dlaqI1M8 225 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::get_point_b
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 679  
260 14 Dtool_dlaq_G54 0 4 277 573 0 14 Dtool_dlaq_G54 224 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::set_radius
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 678  6 radius 1 588  
261 14 Dtool_dlaqSKpL 0 6 278 588 0 14 Dtool_dlaqSKpL 224 ////////////////////////////////////////////////////////////////////
//     Function: CollisionTube::get_radius
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 679  
262 14 Dtool_dlaqur7C 0 7 279 584 0 14 Dtool_dlaqur7C 0 0 
263 14 Dtool_dlaqXmWq 0 7 286 608 528 14 Dtool_dlaqXmWq 231 ////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 593  
264 14 Dtool_dlaqyFwD 0 4 288 573 0 14 Dtool_dlaqyFwD 741 ////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::set_point_scale
//       Access: Published
//  Description: Scales the points that are drawn to represent the
//               surface and interior intersection points of the
//               collisions.  By default, these objects are drawn at
//               an arbitrary scale which is appropriate if the window
//               units are the default range -1 .. 1.  Change this
//               scale accordinatly if the window units are measured
//               on some other scale or if you need to observe these
//               objects in a smaller window.
//////////////////////////////////////////////////////////////////// 2 4 this 3 608  11 point_scale 1 588  
265 14 Dtool_dlaqrwDZ 0 6 289 588 0 14 Dtool_dlaqrwDZ 284 ////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::get_point_scale
//       Access: Published
//  Description: Returns the value last set by set_point_scale().
//////////////////////////////////////////////////////////////////// 1 4 this 3 681  
266 14 Dtool_dlaqDFe5 0 4 290 573 0 14 Dtool_dlaqDFe5 685 ////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::set_normal_scale
//       Access: Published
//  Description: Scales the line segments that are drawn to represent
//               the normals of the collisions.  By default, these
//               objects are drawn at an arbitrary scale which is
//               appropriate if the scene units are measured in feet.
//               Change this scale accordinatly if the scene units are
//               measured on some other scale or if you need to
//               observe these normals from farther away.
//////////////////////////////////////////////////////////////////// 2 4 this 3 608  12 normal_scale 1 588  
267 14 Dtool_dlaq3tAT 0 6 291 588 0 14 Dtool_dlaq3tAT 286 ////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::get_normal_scale
//       Access: Published
//  Description: Returns the value last set by set_normal_scale().
//////////////////////////////////////////////////////////////////// 1 4 this 3 681  
268 14 Dtool_dlaqvSrC 0 4 292 573 0 14 Dtool_dlaqvSrC 339 ////////////////////////////////////////////////////////////////////
//     Function: CollisionVisualizer::clear
//       Access: Published
//  Description: Removes all the visualization data from a previous
//               traversal and resets the visualizer to empty.
//////////////////////////////////////////////////////////////////// 1 4 this 3 608  
269 14 Dtool_dlaq5C_m 0 7 293 584 0 14 Dtool_dlaq5C_m 0 0 
270 14 Dtool_dlaqq3Vo 0 7 282 613 0 14 Dtool_dlaqq3Vo 0 1 4 this 3 608  
271 14 Dtool_dlaqfx9L 0 7 283 608 528 14 Dtool_dlaqfx9L 0 1 4 this 3 613  
272 14 Dtool_dlaq1mI9 0 6 284 607 0 14 Dtool_dlaq1mI9 0 1 4 this 3 608  
273 14 Dtool_dlaqaJgA 0 7 285 608 528 14 Dtool_dlaqaJgA 0 1 4 this 3 607  
148
535 14 CollisionSolid 0 75777 14 CollisionSolid 14 CollisionSolid 0 0 0 0 0 0 14 274 275 276 277 278 279 280 281 282 283 284 285 286 287 0 0 1 0 536 0 0 0 0 754
////////////////////////////////////////////////////////////////////
//       Class : CollisionSolid
// Description : The abstract base class for all things that can
//               collide with other things in the world, and all the
//               things they can collide with (except geometry).
//
//               This class and its derivatives really work very
//               similarly to the way BoundingVolume and all of its
//               derivatives work.  There's a different subclass for
//               each basic shape of solid, and double-dispatch
//               function calls handle the subset of the N*N
//               intersection tests that we care about.
////////////////////////////////////////////////////////////////////

536 17 CopyOnWriteObject 0 2049 17 CopyOnWriteObject 17 CopyOnWriteObject 0 0 0 0 0 0 0 0 0 0 0 0 376
////////////////////////////////////////////////////////////////////
//       Class : CopyOnWriteObject
// Description : This base class provides basic reference counting,
//               but also can be used with a CopyOnWritePointer to
//               provide get_read_pointer() and get_write_pointer().
////////////////////////////////////////////////////////////////////

537 12 CollisionBox 0 141313 12 CollisionBox 12 CollisionBox 0 0 0 1 288 299 0 10 289 290 291 292 293 294 295 296 297 298 0 0 1 0 535 0 0 0 0 221
////////////////////////////////////////////////////////////////////
//       Class : CollisionBox
// Description : A cuboid collision volume or object.
////////////////////////////////////////////////////////////////////

538 16 CollisionHandler 0 141313 16 CollisionHandler 16 CollisionHandler 0 0 0 0 301 0 1 300 0 0 1 0 539 0 0 0 0 499
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandler
// Description : The abstract interface to a number of classes that
//               decide what to do when a collision is detected.  One
//               of these must be assigned to the CollisionTraverser
//               that is processing collisions in order to specify how
//               to dispatch detected collisions.
////////////////////////////////////////////////////////////////////

539 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.
////////////////////////////////////////////////////////////////////

540 13 CollisionNode 0 75777 13 CollisionNode 13 CollisionNode 0 0 0 1 302 0 0 16 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 1 683 0 1 0 541 0 0 0 0 496
////////////////////////////////////////////////////////////////////
//       Class : CollisionNode
// Description : A node in the scene graph that can hold any number of
//               CollisionSolids.  This may either represent a bit of
//               static geometry in the scene that things will collide
//               with, or an animated object twirling around in the
//               world and running into things.
////////////////////////////////////////////////////////////////////

541 9 PandaNode 0 2049 9 PandaNode 9 PandaNode 0 0 0 0 0 0 0 0 0 0 0 0 374
////////////////////////////////////////////////////////////////////
//       Class : PandaNode
// Description : A basic node of the scene graph or data graph.  This
//               is the base class of all specialized nodes, and also
//               serves as a generic node with no special properties.
////////////////////////////////////////////////////////////////////

542 18 CollisionTraverser 0 26625 18 CollisionTraverser 18 CollisionTraverser 0 0 0 1 319 320 0 19 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 1 684 0 1 0 543 0 0 0 0 765
////////////////////////////////////////////////////////////////////
//       Class : CollisionTraverser
// Description : This class manages the traversal through the scene
//               graph to detect collisions.  It holds ownership of a
//               number of collider objects, each of which is a
//               CollisionNode and an associated CollisionHandler.
//
//               When traverse() is called, it begins at the indicated
//               root and detects all collisions with any of its
//               collider objects against nodes at or below the
//               indicated root, calling the appropriate
//               CollisionHandler for each detected collision.
////////////////////////////////////////////////////////////////////

543 7 Namable 0 2049 7 Namable 7 Namable 0 0 0 0 0 0 0 0 0 0 0 0 324
////////////////////////////////////////////////////////////////////
//       Class : Namable
// Description : A base class for all things which can have a name.
//               The name is either empty or nonempty, but it is never
//               NULL.
////////////////////////////////////////////////////////////////////

544 17 CollisionRecorder 0 75777 17 CollisionRecorder 17 CollisionRecorder 0 0 0 0 0 0 2 340 341 0 0 1 0 545 0 0 0 0 431
////////////////////////////////////////////////////////////////////
//       Class : CollisionRecorder
// Description : This class is used to help debug the work the
//               collisions system is doing.  It is a virtual base
//               class that just provides an interface for recording
//               collisions tested and detected each frame.
////////////////////////////////////////////////////////////////////

545 11 TypedObject 0 2049 11 TypedObject 11 TypedObject 0 0 0 0 0 0 0 0 0 0 0 0 3666
////////////////////////////////////////////////////////////////////
//       Class : TypedObject
// Description : This is an abstract class that all classes which
//               use TypeHandle, and also provide virtual functions to
//               support polymorphism, should inherit from.  Each
//               derived class should define get_type(), which should
//               return the specific type of the derived class.
//               Inheriting from this automatically provides support
//               for is_of_type() and is_exact_type().
//               
//               All classes that inherit directly or indirectly from
//               TypedObject should redefine get_type() and
//               force_init_type(), as shown below.  Some classes that
//               do not inherit from TypedObject may still declare
//               TypeHandles for themselves by defining methods called
//               get_class_type() and init_type().  Classes such as
//               these may serve as base classes, but the dynamic type
//               identification system will be limited.  Classes that
//               do not inherit from TypedObject need not define the
//               virtual functions get_type() and force_init_type()
//               (or any other virtual functions).
//               
//               There is a specific layout for defining the
//               overrides from this class.  Keeping the definitions
//               formatted just like these examples will allow
//               someone in the future to use a sed (or similar)
//               script to make global changes, if necessary.  Avoid
//               rearranging the braces or the order of the functions
//               unless you're ready to change them in every file all
//               at once.
//               
//               What follows are some examples that can be used in
//               new classes that you create.
//               
//               @par In the class definition (.h file):
//               @code
//               public:
//                 static TypeHandle get_class_type() {
//                   return _type_handle;
//                 }
//                 static void init_type() {
//                   <<<BaseClassOne>>>::init_type();
//                   <<<BaseClassTwo>>>::init_type();
//                   <<<BaseClassN>>>::init_type();
//                   register_type(_type_handle, "<<<ThisClassStringName>>>",
//                                 <<<BaseClassOne>>>::get_class_type(),
//                                 <<<BaseClassTwo>>>::get_class_type(),
//                                 <<<BaseClassN>>>::get_class_type());
//                 }
//                 virtual TypeHandle get_type() const {
//                   return get_class_type();
//                 }
//                 virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
//               
//               private:
//                 static TypeHandle _type_handle;
//               @endcode
//               
//               @par In the class .cxx file:
//               @code
//               TypeHandle <<<ThisClassStringName>>>::_type_handle;
//               @endcode
//               
//               @par In the class config_<<<PackageName>>>.cxx file:
//               @code
//               ConfigureFn(config_<<<PackageName>>>) {
//                 <<<ClassOne>>>::init_type();
//                 <<<ClassTwo>>>::init_type();
//                 <<<ClassN>>>::init_type();
//               }
//               @endcode
////////////////////////////////////////////////////////////////////

546 14 CollisionEntry 0 141313 14 CollisionEntry 14 CollisionEntry 0 0 0 0 374 0 32 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 0 0 1 0 547 0 0 0 0 731
////////////////////////////////////////////////////////////////////
//       Class : CollisionEntry
// Description : Defines a single collision event.  One of these is
//               created for each collision detected by a
//               CollisionTraverser, to be dealt with by the
//               CollisionHandler.
//
//               A CollisionEntry provides slots for a number of data
//               values (such as intersection point and normal) that
//               might or might not be known for each collision.  It
//               is up to the handler to determine what information is
//               known and to do the right thing with it.
////////////////////////////////////////////////////////////////////

547 27 TypedWritableReferenceCount 0 2049 27 TypedWritableReferenceCount 27 TypedWritableReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 722
////////////////////////////////////////////////////////////////////
//       Class : TypedWritableReferenceCount
// Description : A base class for things which need to inherit from
//               both TypedWritable 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
//               TypedWritables and ReferenceCounters.
//               
//               See also TypedObject for detailed instructions.
////////////////////////////////////////////////////////////////////

548 14 CollisionPlane 0 141313 14 CollisionPlane 14 CollisionPlane 0 0 0 1 375 382 0 6 376 377 378 379 380 381 0 0 1 0 535 0 0 0 0 186
////////////////////////////////////////////////////////////////////
//       Class : CollisionPlane
// Description :
////////////////////////////////////////////////////////////////////

549 18 CollisionFloorMesh 0 141313 18 CollisionFloorMesh 18 CollisionFloorMesh 0 0 0 1 383 391 0 7 384 385 386 387 388 389 390 2 685 686 0 1 0 535 0 0 0 0 318
////////////////////////////////////////////////////////////////////
//       Class : CollisionFloorMesh
// Description : This object represents a solid made entirely of triangles, which
//               will only be tested again z axis aligned rays
////////////////////////////////////////////////////////////////////

550 16 CollisionPolygon 0 141313 16 CollisionPolygon 16 CollisionPolygon 0 0 0 1 392 399 0 6 393 394 395 396 397 398 1 687 0 1 0 548 0 0 0 0 188
////////////////////////////////////////////////////////////////////
//       Class : CollisionPolygon
// Description :
////////////////////////////////////////////////////////////////////

551 21 CollisionHandlerEvent 0 141313 21 CollisionHandlerEvent 21 CollisionHandlerEvent 0 0 0 1 400 419 0 18 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 3 688 689 690 0 1 0 538 0 0 0 0 555
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandlerEvent
// Description : A specialized kind of CollisionHandler that throws an
//               event for each collision detected.  The event thrown
//               may be based on the name of the moving object or the
//               struck object, or both.  The first parameter of the
//               event will be a pointer to the CollisionEntry that
//               triggered it.
////////////////////////////////////////////////////////////////////

552 24 CollisionHandlerPhysical 0 75777 24 CollisionHandlerPhysical 24 CollisionHandlerPhysical 0 0 0 0 419 0 10 420 421 422 423 424 425 426 427 428 429 0 0 1 0 551 0 0 0 0 440
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandlerPhysical
// Description : The abstract base class for a number of
//               CollisionHandlers that have some physical effect on
//               their moving bodies: they need to update the nodes'
//               positions based on the effects of the collision.
////////////////////////////////////////////////////////////////////

553 21 CollisionHandlerFloor 0 75777 21 CollisionHandlerFloor 21 CollisionHandlerFloor 0 0 0 1 430 419 0 7 431 432 433 434 435 436 437 0 0 1 0 552 0 0 0 0 552
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandlerFloor
// Description : A specialized kind of CollisionHandler that sets the
//               Z height of the collider to a fixed linear offset
//               from the highest detected collision point each frame.
//               It's intended to implement walking around on a floor
//               of varying height by casting a ray down from the
//               avatar's head.
////////////////////////////////////////////////////////////////////

554 22 CollisionHandlerPusher 0 75777 22 CollisionHandlerPusher 22 CollisionHandlerPusher 0 0 0 1 438 419 0 3 439 440 441 0 0 1 0 552 0 0 0 0 425
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandlerPusher
// Description : A specialized kind of CollisionHandler that simply
//               pushes back on things that attempt to move into solid
//               walls.  This is the simplest kind of "real-world"
//               collisions you can have.
////////////////////////////////////////////////////////////////////

555 27 CollisionHandlerFluidPusher 0 141313 27 CollisionHandlerFluidPusher 27 CollisionHandlerFluidPusher 0 0 0 1 442 444 0 1 443 0 0 1 0 554 0 0 0 0 359
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandlerFluidPusher
// Description : A CollisionHandlerPusher that makes use of timing
//               and spatial information from fluid collisions to improve
//               collision response
////////////////////////////////////////////////////////////////////

556 23 CollisionHandlerGravity 0 75777 23 CollisionHandlerGravity 23 CollisionHandlerGravity 0 0 0 1 445 419 0 18 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 0 0 1 0 552 0 0 0 0 554
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandlerGravity
// Description : A specialized kind of CollisionHandler that sets the
//               Z height of the collider to a fixed linear offset
//               from the highest detected collision point each frame.
//               It's intended to implement walking around on a floor
//               of varying height by casting a ray down from the
//               avatar's head.
////////////////////////////////////////////////////////////////////

557 28 CollisionHandlerHighestEvent 0 141313 28 CollisionHandlerHighestEvent 28 CollisionHandlerHighestEvent 0 0 0 1 464 466 0 1 465 0 0 1 0 551 0 0 0 0 555
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandlerEvent
// Description : A specialized kind of CollisionHandler that throws an
//               event for each collision detected.  The event thrown
//               may be based on the name of the moving object or the
//               struck object, or both.  The first parameter of the
//               event will be a pointer to the CollisionEntry that
//               triggered it.
////////////////////////////////////////////////////////////////////

558 21 CollisionHandlerQueue 0 141313 21 CollisionHandlerQueue 21 CollisionHandlerQueue 0 0 0 1 467 475 0 7 468 469 470 471 472 473 474 1 691 0 1 0 538 0 0 0 0 571
////////////////////////////////////////////////////////////////////
//       Class : CollisionHandlerQueue
// Description : A special kind of CollisionHandler that does nothing
//               except remember the CollisionEntries detected the
//               last pass.  This set of CollisionEntries may then be
//               queried by the calling function.  It's primarily
//               useful when a simple intersection test is being made,
//               e.g. for picking from the window.
////////////////////////////////////////////////////////////////////

559 15 CollisionSphere 0 141313 15 CollisionSphere 15 CollisionSphere 0 0 0 1 476 482 0 5 477 478 479 480 481 0 0 1 0 535 0 0 0 0 227
////////////////////////////////////////////////////////////////////
//       Class : CollisionSphere
// Description : A spherical collision volume or object.
////////////////////////////////////////////////////////////////////

560 18 CollisionInvSphere 0 141313 18 CollisionInvSphere 18 CollisionInvSphere 0 0 0 1 483 485 0 1 484 0 0 1 0 559 0 0 0 0 527
////////////////////////////////////////////////////////////////////
//       Class : CollisionInvSphere
// Description : An inverted sphere: this is a sphere whose collision
//               surface is the inside surface of the sphere.
//               Everything outside the sphere is solid matter;
//               everything inside is empty space.  Useful for
//               constraining objects to remain within a spherical
//               perimeter.
////////////////////////////////////////////////////////////////////

561 12 CollisionRay 0 141313 12 CollisionRay 12 CollisionRay 0 0 0 1 486 493 0 6 487 488 489 490 491 492 0 0 1 0 535 0 0 0 0 456
////////////////////////////////////////////////////////////////////
//       Class : CollisionRay
// Description : An infinite ray, with a specific origin and
//               direction.  It begins at its origin and continues in
//               one direction to infinity, and it has no radius.
//               Useful for picking from a window, or for gravity
//               effects.
////////////////////////////////////////////////////////////////////

562 13 CollisionLine 0 141313 13 CollisionLine 13 CollisionLine 0 0 0 1 494 496 0 1 495 0 0 1 0 561 0 0 0 0 337
////////////////////////////////////////////////////////////////////
//       Class : CollisionLine
// Description : An infinite line, similar to a CollisionRay, except
//               that it extends in both directions.  It is, however,
//               directional.
////////////////////////////////////////////////////////////////////

563 17 CollisionParabola 0 141313 17 CollisionParabola 17 CollisionParabola 0 0 0 1 497 505 0 7 498 499 500 501 502 503 504 0 0 1 0 535 0 0 0 0 560
////////////////////////////////////////////////////////////////////
//       Class : CollisionParabola
// Description : This defines a parabolic arc, or subset of an arc,
//               similar to the path of a projectile or falling
//               object.  It is finite, having a specific beginning
//               and end, but it is infinitely thin.
//
//               Think of it as a wire bending from point t1 to point
//               t2 along the path of a pre-defined parabola.
////////////////////////////////////////////////////////////////////

564 16 CollisionSegment 0 141313 16 CollisionSegment 16 CollisionSegment 0 0 0 1 506 513 0 6 507 508 509 510 511 512 0 0 1 0 535 0 0 0 0 639
////////////////////////////////////////////////////////////////////
//       Class : CollisionSegment
// Description : A finite line segment, with two specific endpoints
//               but no thickness.  It's similar to a CollisionRay,
//               except it does not continue to infinity.
//
//               It does have an ordering, from point A to point B.
//               If more than a single point of the segment is
//               intersecting a solid, the reported intersection point
//               is generally the closest on the segment to point A.
////////////////////////////////////////////////////////////////////

565 13 CollisionTube 0 141313 13 CollisionTube 13 CollisionTube 0 0 0 1 514 522 0 7 515 516 517 518 519 520 521 0 0 1 0 535 0 0 0 0 468
////////////////////////////////////////////////////////////////////
//       Class : CollisionTube
// Description : This implements a solid roughly in cylindrical shape.
//               It's not called a CollisionCylinder because it's not
//               a true cylinder; specifically, it has rounded ends
//               instead of flat ends.  It looks more like a Contac
//               pill.
////////////////////////////////////////////////////////////////////

566 19 CollisionVisualizer 0 26625 19 CollisionVisualizer 19 CollisionVisualizer 0 0 0 1 527 528 0 6 529 530 531 532 533 534 0 0 2 3 541 523 524 3 544 525 526 0 0 559
////////////////////////////////////////////////////////////////////
//       Class : CollisionVisualizer
// Description : This class is used to help debug the work the
//               collisions system is doing.  It shows the polygons
//               that are detected as collisions, as well as those
//               that are simply considered for collisions.
//
//               It may be parented anywhere in the scene graph where
//               it will be rendered to achieve this.
////////////////////////////////////////////////////////////////////

567 8 LPoint3f 0 2048 8 LPoint3f 8 LPoint3f 0 0 0 0 0 0 0 0 0 0 0 0 1083
// Filename: lpoint3_src.h
// Created by:  drose (25Sep99)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint3
// Description : This is a three-component point in space (as opposed
//               to a three-component vector, which represents a
//               direction and a distance).  Some of the methods are
//               slightly different between LPoint3 and LVector3; in
//               particular, subtraction of two points yields a
//               vector, while addition of a vector and a point yields
//               a point.
////////////////////////////////////////////////////////////////////

568 22 CollisionSolid const * 0 8576 22 CollisionSolid const * 22 CollisionSolid const * 0 0 569 0 0 0 0 0 0 0 0 0 0

569 20 CollisionSolid const 0 8832 20 CollisionSolid const 20 CollisionSolid const 0 0 535 0 0 0 0 0 0 0 0 0 0

570 10 LPoint3f * 0 8576 10 LPoint3f * 10 LPoint3f * 0 0 567 0 0 0 0 0 0 0 0 0 0

571 16 CollisionSolid * 0 8576 16 CollisionSolid * 16 CollisionSolid * 0 0 535 0 0 0 0 0 0 0 0 0 0

572 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0

573 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0

574 17 LVector3f const * 0 8576 17 LVector3f const * 17 LVector3f const * 0 0 575 0 0 0 0 0 0 0 0 0 0

575 15 LVector3f const 0 8832 15 LVector3f const 15 LVector3f const 0 0 576 0 0 0 0 0 0 0 0 0 0

576 9 LVector3f 0 2048 9 LVector3f 9 LVector3f 0 0 0 0 0 0 0 0 0 0 0 0 1086
// Filename: lvector3_src.h
// Created by:  drose (24Sep99)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LVector3
// Description : This is a three-component vector distance (as opposed
//               to a three-component point, which represents a
//               particular point in space).  Some of the methods are
//               slightly different between LPoint3 and LVector3; in
//               particular, subtraction of two points yields a
//               vector, while addition of a vector and a point yields
//               a point.
////////////////////////////////////////////////////////////////////

577 20 BoundingVolume const 0 8832 20 BoundingVolume const 20 BoundingVolume const 0 0 578 0 0 0 0 0 0 0 0 0 0

578 14 BoundingVolume 0 2048 14 BoundingVolume 14 BoundingVolume 0 0 0 0 0 0 0 0 0 0 0 0 596
////////////////////////////////////////////////////////////////////
//       Class : BoundingVolume
// Description : This is an abstract class for any volume in any sense
//               which can be said to define the locality of reference
//               of a node in a graph, along with all of its
//               descendants.  It is not necessarily a geometric
//               volume (although see GeometricBoundingVolume); this
//               is simply an abstract interface for bounds of any
//               sort.
////////////////////////////////////////////////////////////////////

579 22 BoundingVolume const * 0 8576 22 BoundingVolume const * 22 BoundingVolume const * 0 0 577 0 0 0 0 0 0 0 0 0 0

580 9 ostream * 0 8576 9 ostream * 9 ostream * 0 0 581 0 0 0 0 0 0 0 0 0 0

581 7 ostream 0 2048 7 ostream 7 ostream 0 0 0 0 0 0 0 0 0 0 0 0 0

582 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0

583 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.
////////////////////////////////////////////////////////////////////

584 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 583 0 0 0 0 0 0 0 0 0 0

585 16 LPoint3f const * 0 8576 16 LPoint3f const * 16 LPoint3f const * 0 0 586 0 0 0 0 0 0 0 0 0 0

586 14 LPoint3f const 0 8832 14 LPoint3f const 14 LPoint3f const 0 0 567 0 0 0 0 0 0 0 0 0 0

587 14 CollisionBox * 0 8576 14 CollisionBox * 14 CollisionBox * 0 0 537 0 0 0 0 0 0 0 0 0 0

588 5 float 0 8194 5 float 5 float 0 2 0 0 0 0 0 0 0 0 0 0 0

589 20 CollisionBox const * 0 8576 20 CollisionBox const * 20 CollisionBox const * 0 0 590 0 0 0 0 0 0 0 0 0 0

590 18 CollisionBox const 0 8832 18 CollisionBox const 18 CollisionBox const 0 0 537 0 0 0 0 0 0 0 0 0 0

591 7 LPlanef 0 2048 7 LPlanef 7 LPlanef 0 0 0 0 0 0 0 0 0 0 0 0 786
// Filename: plane_src.h
// Created by:  mike (09Jan97)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPlane
// Description : An abstract mathematical description of a plane.  A
//               plane is defined by the equation Ax + By + Cz + D = 0.
////////////////////////////////////////////////////////////////////

592 9 LPlanef * 0 8576 9 LPlanef * 9 LPlanef * 0 0 591 0 0 0 0 0 0 0 0 0 0

593 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0

594 15 CollisionNode * 0 8576 15 CollisionNode * 15 CollisionNode * 0 0 540 0 0 0 0 0 0 0 0 0 0

595 29 BitMask< unsigned int, 32 > * 0 8576 29 BitMask< unsigned int, 32 > * 29 BitMask< unsigned int, 32 > * 0 0 596 0 0 0 0 0 0 0 0 0 0

596 9 BitMask32 0 2048 27 BitMask< unsigned int, 32 > 27 BitMask< unsigned int, 32 > 0 0 0 0 0 0 0 0 0 0 0 0 0

597 21 CollisionNode const * 0 8576 21 CollisionNode const * 21 CollisionNode const * 0 0 598 0 0 0 0 0 0 0 0 0 0

598 19 CollisionNode const 0 8832 19 CollisionNode const 19 CollisionNode const 0 0 540 0 0 0 0 0 0 0 0 0 0

599 20 CollisionTraverser * 0 8576 20 CollisionTraverser * 20 CollisionTraverser * 0 0 542 0 0 0 0 0 0 0 0 0 0

600 26 CollisionTraverser const * 0 8576 26 CollisionTraverser const * 26 CollisionTraverser const * 0 0 601 0 0 0 0 0 0 0 0 0 0

601 24 CollisionTraverser const 0 8832 24 CollisionTraverser const 24 CollisionTraverser const 0 0 542 0 0 0 0 0 0 0 0 0 0

602 16 NodePath const * 0 8576 16 NodePath const * 16 NodePath const * 0 0 603 0 0 0 0 0 0 0 0 0 0

603 14 NodePath const 0 8832 14 NodePath const 14 NodePath const 0 0 604 0 0 0 0 0 0 0 0 0 0

604 8 NodePath 0 2048 8 NodePath 8 NodePath 0 0 0 0 0 0 0 2 692 693 0 0 0 0 4938
//
// A NodePath is the fundamental unit of high-level interaction with
// the scene graph.  It encapsulates the complete path down to a node
// from some other node, usually the root of the scene graph.  This is
// used to resolve ambiguities associated with instancing.
//
// NodePath also contains a number of handy high-level methods for
// common scene-graph manipulations, such as reparenting, and common
// state changes, such as repositioning.
//
// There are also a number of NodePath methods for finding nodes deep
// within the tree by name or by type.  These take a path string,
// which at its simplest consists of a series of node names separated
// by slashes, like a directory pathname.
//
// Each component of the path string may optionally consist of one of
// the following special names, instead of a node name:
//
//   *          -- matches exactly one node, with any name.
//   **         -- matches any sequence of zero or more nodes.
//   +typename  -- matches any node that is or derives from the given type.
//   -typename  -- matches any node that is the given type exactly.
//   =tag       -- matches any node that has the indicated tag.
//   =tag=value -- matches any node whose tag matches the indicated value.
//
// Furthermore, a node name may itself contain standard filename
// globbing characters, like *, ?, and [a-z], that will be accepted as
// a partial match.  (In fact, the '*' special name may be seen as
// just a special case of this.)  The globbing characters may not be
// used with the typename matches or with tag matches, but they may
// be used to match a tag's value in the =tag=value syntax.
//
// The special characters "@@", appearing at the beginning of a node
// name, indicate a stashed node.  Normally, stashed nodes are not
// returned by a find (but see the special flags, below), but a
// stashed node may be found if it is explicitly named with its
// leading @@ characters.  By extension, "@@*" may be used to identify
// any stashed node.
//
// Examples:
//
// "room//graph" will look for a node named "graph", which is a child
// of an unnamed node, which is a child of a node named "room", which
// is a child of the starting path.
//
// "**/red*" will look for any node anywhere in the tree (below the
// starting path) with a name that begins with "red".
//
// "**/+PartBundleNode/**/head" will look for a node named "head",
// somewhere below a PartBundleNode anywhere in the tree.
//
//
// The search is always potentially ambiguous, even if the special
// wildcard operators are not used, because there may be multiple
// nodes in the tree with the same name.  In general, in the case of
// an ambiguity, the shortest path is preferred; when a method (such
// as extend_by) must choose only only one of several possible paths,
// it will choose the shortest available; on the other hand, when a
// method (such as find_all_matches) is to return all of the matching
// paths, it will sort them so that the shortest paths appear first in
// the output.
//
//
// Special flags.  The entire string may optionally be followed by the
// ";" character, followed by one or more of the following special
// control flags, with no intervening spaces or punctuation:
//
//    -h    Do not return hidden nodes.
//    +h    Do return hidden nodes.
//    -s    Do not return stashed nodes unless explicitly referenced with @@.
//    +s    Return stashed nodes even without any explicit @@ characters.
//    -i    Node name comparisons are not case insensitive: case must match
//          exactly.
//    +i    Node name comparisons are case insensitive: case is not important.
//          This affects matches against the node name only; node type
//          and tag strings are always case sensitive.
//
// The default flags are +h-s-i.
//
////////////////////////////////////////////////////////////////////
//       Class : NodePath
// Description : NodePath is the fundamental system for disambiguating
//               instances, and also provides a higher-level interface
//               for manipulating the scene graph.
//
//               A NodePath is a list of connected nodes from the root
//               of the graph to any sub-node.  Each NodePath
//               therefore uniquely describes one instance of a node.
//
//               NodePaths themselves are lightweight objects that may
//               easily be copied and passed by value.  Their data is
//               stored as a series of NodePathComponents that are
//               stored on the nodes.  Holding a NodePath will keep a
//               reference count to all the nodes in the path.
//               However, if any node in the path is removed or
//               reparented (perhaps through a different NodePath),
//               the NodePath will automatically be updated to reflect
//               the changes.
////////////////////////////////////////////////////////////////////

605 18 CollisionHandler * 0 8576 18 CollisionHandler * 18 CollisionHandler * 0 0 538 0 0 0 0 0 0 0 0 0 0

606 10 NodePath * 0 8576 10 NodePath * 10 NodePath * 0 0 604 0 0 0 0 0 0 0 0 0 0

607 19 CollisionRecorder * 0 8576 19 CollisionRecorder * 19 CollisionRecorder * 0 0 544 0 0 0 0 0 0 0 0 0 0

608 21 CollisionVisualizer * 0 8576 21 CollisionVisualizer * 21 CollisionVisualizer * 0 0 566 0 0 0 0 0 0 0 0 0 0

609 25 CollisionRecorder const * 0 8576 25 CollisionRecorder const * 25 CollisionRecorder const * 0 0 610 0 0 0 0 0 0 0 0 0 0

610 23 CollisionRecorder const 0 8832 23 CollisionRecorder const 23 CollisionRecorder const 0 0 544 0 0 0 0 0 0 0 0 0 0

611 22 CollisionEntry const * 0 8576 22 CollisionEntry const * 22 CollisionEntry const * 0 0 612 0 0 0 0 0 0 0 0 0 0

612 20 CollisionEntry const 0 8832 20 CollisionEntry const 20 CollisionEntry const 0 0 546 0 0 0 0 0 0 0 0 0 0

613 11 PandaNode * 0 8576 11 PandaNode * 11 PandaNode * 0 0 541 0 0 0 0 0 0 0 0 0 0

614 16 CollisionEntry * 0 8576 16 CollisionEntry * 16 CollisionEntry * 0 0 546 0 0 0 0 0 0 0 0 0 0

615 11 LVector3f * 0 8576 11 LVector3f * 11 LVector3f * 0 0 576 0 0 0 0 0 0 0 0 0 0

616 22 CollisionPlane const * 0 8576 22 CollisionPlane const * 22 CollisionPlane const * 0 0 617 0 0 0 0 0 0 0 0 0 0

617 20 CollisionPlane const 0 8832 20 CollisionPlane const 20 CollisionPlane const 0 0 548 0 0 0 0 0 0 0 0 0 0

618 16 CollisionPlane * 0 8576 16 CollisionPlane * 16 CollisionPlane * 0 0 548 0 0 0 0 0 0 0 0 0 0

619 15 LPlanef const * 0 8576 15 LPlanef const * 15 LPlanef const * 0 0 620 0 0 0 0 0 0 0 0 0 0

620 13 LPlanef const 0 8832 13 LPlanef const 13 LPlanef const 0 0 591 0 0 0 0 0 0 0 0 0 0

621 20 CollisionFloorMesh * 0 8576 20 CollisionFloorMesh * 20 CollisionFloorMesh * 0 0 549 0 0 0 0 0 0 0 0 0 0

622 12 unsigned int 0 8198 12 unsigned int 12 unsigned int 0 1 0 0 0 0 0 0 0 0 0 0 0

623 26 CollisionFloorMesh const * 0 8576 26 CollisionFloorMesh const * 26 CollisionFloorMesh const * 0 0 624 0 0 0 0 0 0 0 0 0 0

624 24 CollisionFloorMesh const 0 8832 24 CollisionFloorMesh const 24 CollisionFloorMesh const 0 0 549 0 0 0 0 0 0 0 0 0 0

625 14 LPoint3d const 0 8832 14 LPoint3d const 14 LPoint3d const 0 0 626 0 0 0 0 0 0 0 0 0 0

626 8 LPoint3d 0 2048 8 LPoint3d 8 LPoint3d 0 0 0 0 0 0 0 0 0 0 0 0 1083
// Filename: lpoint3_src.h
// Created by:  drose (25Sep99)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint3
// Description : This is a three-component point in space (as opposed
//               to a three-component vector, which represents a
//               direction and a distance).  Some of the methods are
//               slightly different between LPoint3 and LVector3; in
//               particular, subtraction of two points yields a
//               vector, while addition of a vector and a point yields
//               a point.
////////////////////////////////////////////////////////////////////

627 16 LPoint3d const * 0 8576 16 LPoint3d const * 16 LPoint3d const * 0 0 625 0 0 0 0 0 0 0 0 0 0

628 18 CollisionPolygon * 0 8576 18 CollisionPolygon * 18 CollisionPolygon * 0 0 550 0 0 0 0 0 0 0 0 0 0

629 18 LVecBase3f const * 0 8576 18 LVecBase3f const * 18 LVecBase3f const * 0 0 630 0 0 0 0 0 0 0 0 0 0

630 16 LVecBase3f const 0 8832 16 LVecBase3f const 16 LVecBase3f const 0 0 631 0 0 0 0 0 0 0 0 0 0

631 10 LVecBase3f 0 2048 10 LVecBase3f 10 LVecBase3f 0 0 0 0 0 0 0 0 0 0 0 0 754
// Filename: lvecBase3_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LVecBase3
// Description : This is the base class for all three-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

632 24 CollisionPolygon const * 0 8576 24 CollisionPolygon const * 24 CollisionPolygon const * 0 0 633 0 0 0 0 0 0 0 0 0 0

633 22 CollisionPolygon const 0 8832 22 CollisionPolygon const 22 CollisionPolygon const 0 0 550 0 0 0 0 0 0 0 0 0 0

634 23 CollisionHandlerEvent * 0 8576 23 CollisionHandlerEvent * 23 CollisionHandlerEvent * 0 0 551 0 0 0 0 0 0 0 0 0 0

635 29 CollisionHandlerEvent const * 0 8576 29 CollisionHandlerEvent const * 29 CollisionHandlerEvent const * 0 0 636 0 0 0 0 0 0 0 0 0 0

636 27 CollisionHandlerEvent const 0 8832 27 CollisionHandlerEvent const 27 CollisionHandlerEvent const 0 0 551 0 0 0 0 0 0 0 0 0 0

637 26 CollisionHandlerPhysical * 0 8576 26 CollisionHandlerPhysical * 26 CollisionHandlerPhysical * 0 0 552 0 0 0 0 0 0 0 0 0 0

638 16 DriveInterface * 0 8576 16 DriveInterface * 16 DriveInterface * 0 0 639 0 0 0 0 0 0 0 0 0 0

639 14 DriveInterface 0 2048 14 DriveInterface 14 DriveInterface 0 0 0 0 0 0 0 0 0 0 0 0 411
////////////////////////////////////////////////////////////////////
//       Class : DriveInterface
// Description : This is a TFormer, similar to Trackball, that moves
//               around a transform matrix in response to mouse input.
//               The basic motion is on a horizontal plane, as if
//               driving a vehicle.
////////////////////////////////////////////////////////////////////

640 32 CollisionHandlerPhysical const * 0 8576 32 CollisionHandlerPhysical const * 32 CollisionHandlerPhysical const * 0 0 641 0 0 0 0 0 0 0 0 0 0

641 30 CollisionHandlerPhysical const 0 8832 30 CollisionHandlerPhysical const 30 CollisionHandlerPhysical const 0 0 552 0 0 0 0 0 0 0 0 0 0

642 23 CollisionHandlerFloor * 0 8576 23 CollisionHandlerFloor * 23 CollisionHandlerFloor * 0 0 553 0 0 0 0 0 0 0 0 0 0

643 29 CollisionHandlerFloor const * 0 8576 29 CollisionHandlerFloor const * 29 CollisionHandlerFloor const * 0 0 644 0 0 0 0 0 0 0 0 0 0

644 27 CollisionHandlerFloor const 0 8832 27 CollisionHandlerFloor const 27 CollisionHandlerFloor const 0 0 553 0 0 0 0 0 0 0 0 0 0

645 24 CollisionHandlerPusher * 0 8576 24 CollisionHandlerPusher * 24 CollisionHandlerPusher * 0 0 554 0 0 0 0 0 0 0 0 0 0

646 30 CollisionHandlerPusher const * 0 8576 30 CollisionHandlerPusher const * 30 CollisionHandlerPusher const * 0 0 647 0 0 0 0 0 0 0 0 0 0

647 28 CollisionHandlerPusher const 0 8832 28 CollisionHandlerPusher const 28 CollisionHandlerPusher const 0 0 554 0 0 0 0 0 0 0 0 0 0

648 29 CollisionHandlerFluidPusher * 0 8576 29 CollisionHandlerFluidPusher * 29 CollisionHandlerFluidPusher * 0 0 555 0 0 0 0 0 0 0 0 0 0

649 25 CollisionHandlerGravity * 0 8576 25 CollisionHandlerGravity * 25 CollisionHandlerGravity * 0 0 556 0 0 0 0 0 0 0 0 0 0

650 31 CollisionHandlerGravity const * 0 8576 31 CollisionHandlerGravity const * 31 CollisionHandlerGravity const * 0 0 651 0 0 0 0 0 0 0 0 0 0

651 29 CollisionHandlerGravity const 0 8832 29 CollisionHandlerGravity const 29 CollisionHandlerGravity const 0 0 556 0 0 0 0 0 0 0 0 0 0

652 30 CollisionHandlerHighestEvent * 0 8576 30 CollisionHandlerHighestEvent * 30 CollisionHandlerHighestEvent * 0 0 557 0 0 0 0 0 0 0 0 0 0

653 23 CollisionHandlerQueue * 0 8576 23 CollisionHandlerQueue * 23 CollisionHandlerQueue * 0 0 558 0 0 0 0 0 0 0 0 0 0

654 29 CollisionHandlerQueue const * 0 8576 29 CollisionHandlerQueue const * 29 CollisionHandlerQueue const * 0 0 655 0 0 0 0 0 0 0 0 0 0

655 27 CollisionHandlerQueue const 0 8832 27 CollisionHandlerQueue const 27 CollisionHandlerQueue const 0 0 558 0 0 0 0 0 0 0 0 0 0

656 17 CollisionSphere * 0 8576 17 CollisionSphere * 17 CollisionSphere * 0 0 559 0 0 0 0 0 0 0 0 0 0

657 23 CollisionSphere const * 0 8576 23 CollisionSphere const * 23 CollisionSphere const * 0 0 658 0 0 0 0 0 0 0 0 0 0

658 21 CollisionSphere const 0 8832 21 CollisionSphere const 21 CollisionSphere const 0 0 559 0 0 0 0 0 0 0 0 0 0

659 20 CollisionInvSphere * 0 8576 20 CollisionInvSphere * 20 CollisionInvSphere * 0 0 560 0 0 0 0 0 0 0 0 0 0

660 14 CollisionRay * 0 8576 14 CollisionRay * 14 CollisionRay * 0 0 561 0 0 0 0 0 0 0 0 0 0

661 20 CollisionRay const * 0 8576 20 CollisionRay const * 20 CollisionRay const * 0 0 662 0 0 0 0 0 0 0 0 0 0

662 18 CollisionRay const 0 8832 18 CollisionRay const 18 CollisionRay const 0 0 561 0 0 0 0 0 0 0 0 0 0

663 10 LensNode * 0 8576 10 LensNode * 10 LensNode * 0 0 664 0 0 0 0 0 0 0 0 0 0

664 8 LensNode 0 2048 8 LensNode 8 LensNode 0 0 0 0 0 0 0 0 0 0 0 0 396
////////////////////////////////////////////////////////////////////
//       Class : LensNode
// Description : A node that contains a Lens.  The most important
//               example of this kind of node is a Camera, but other
//               kinds of nodes also contain a lens (for instance, a
//               Spotlight).
////////////////////////////////////////////////////////////////////

665 16 LPoint2f const * 0 8576 16 LPoint2f const * 16 LPoint2f const * 0 0 666 0 0 0 0 0 0 0 0 0 0

666 14 LPoint2f const 0 8832 14 LPoint2f const 14 LPoint2f const 0 0 667 0 0 0 0 0 0 0 0 0 0

667 8 LPoint2f 0 2048 8 LPoint2f 8 LPoint2f 0 0 0 0 0 0 0 0 0 0 0 0 706
// Filename: lpoint2_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint2
// Description : This is a two-component point in space.
////////////////////////////////////////////////////////////////////

668 15 CollisionLine * 0 8576 15 CollisionLine * 15 CollisionLine * 0 0 562 0 0 0 0 0 0 0 0 0 0

669 19 CollisionParabola * 0 8576 19 CollisionParabola * 19 CollisionParabola * 0 0 563 0 0 0 0 0 0 0 0 0 0

670 18 LParabolaf const * 0 8576 18 LParabolaf const * 18 LParabolaf const * 0 0 671 0 0 0 0 0 0 0 0 0 0

671 16 LParabolaf const 0 8832 16 LParabolaf const 16 LParabolaf const 0 0 672 0 0 0 0 0 0 0 0 0 0

672 10 LParabolaf 0 2048 10 LParabolaf 10 LParabolaf 0 0 0 0 0 0 0 0 0 0 0 0 921
// Filename: parabola_src.h
// Created by:  drose (10Oct07)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LParabola
// Description : An abstract mathematical description of a parabola,
//               particularly useful for describing arcs of
//               projectiles.
//
//               The parabolic equation, given parametrically here, is
//               P = At^2 + Bt + C.
////////////////////////////////////////////////////////////////////

673 25 CollisionParabola const * 0 8576 25 CollisionParabola const * 25 CollisionParabola const * 0 0 674 0 0 0 0 0 0 0 0 0 0

674 23 CollisionParabola const 0 8832 23 CollisionParabola const 23 CollisionParabola const 0 0 563 0 0 0 0 0 0 0 0 0 0

675 18 CollisionSegment * 0 8576 18 CollisionSegment * 18 CollisionSegment * 0 0 564 0 0 0 0 0 0 0 0 0 0

676 24 CollisionSegment const * 0 8576 24 CollisionSegment const * 24 CollisionSegment const * 0 0 677 0 0 0 0 0 0 0 0 0 0

677 22 CollisionSegment const 0 8832 22 CollisionSegment const 22 CollisionSegment const 0 0 564 0 0 0 0 0 0 0 0 0 0

678 15 CollisionTube * 0 8576 15 CollisionTube * 15 CollisionTube * 0 0 565 0 0 0 0 0 0 0 0 0 0

679 21 CollisionTube const * 0 8576 21 CollisionTube const * 21 CollisionTube const * 0 0 680 0 0 0 0 0 0 0 0 0 0

680 19 CollisionTube const 0 8832 19 CollisionTube const 19 CollisionTube const 0 0 565 0 0 0 0 0 0 0 0 0 0

681 27 CollisionVisualizer const * 0 8576 27 CollisionVisualizer const * 27 CollisionVisualizer const * 0 0 682 0 0 0 0 0 0 0 0 0 0

682 25 CollisionVisualizer const 0 8832 25 CollisionVisualizer const 25 CollisionVisualizer const 0 0 566 0 0 0 0 0 0 0 0 0 0

0
0
11
683 0 0 34 10 get_solids 14 get_num_solids 9 get_solid 
684 0 0 53 13 get_colliders 17 get_num_colliders 12 get_collider 
685 0 0 124 12 get_vertices 16 get_num_vertices 10 get_vertex 
686 0 0 124 13 get_triangles 17 get_num_triangles 12 get_triangle 
687 0 0 134 10 get_points 14 get_num_points 9 get_point 
688 0 0 143 15 get_in_patterns 19 get_num_in_patterns 14 get_in_pattern 
689 0 0 143 18 get_again_patterns 22 get_num_again_patterns 17 get_again_pattern 
690 0 0 143 16 get_out_patterns 20 get_num_out_patterns 15 get_out_pattern 
691 0 0 217 11 get_entries 15 get_num_entries 9 get_entry 
692 0 0 383 9 get_nodes 13 get_num_nodes 8 get_node 
693 0 0 383 13 get_ancestors 13 get_num_nodes 12 get_ancestor 
