CollisionEntry

Inheritance:

Methods of CollisionEntry:

Methods of TypedWritableReferenceCount:

Methods of TypedWritable:

Methods of TypedObject:

Methods of ReferenceCount:

collided
bool CollisionEntry::collided(void) const;

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

getAll
bool CollisionEntry::get_all(NodePath const &space, LPoint3f &surface_point, LVector3f &surface_normal, LPoint3f &interior_point) const;

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.

getAllContactInfo
bool CollisionEntry::get_all_contact_info(NodePath const &space, LPoint3f &contact_pos, LVector3f &contact_normal) const;

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.

getClassType
static TypeHandle CollisionEntry::get_class_type(void);

Undocumented function.

getContactNormal
LVector3f CollisionEntry::get_contact_normal(NodePath const &space) const;

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.

getContactPos
LPoint3f CollisionEntry::get_contact_pos(NodePath const &space) const;

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.

getFrom
CollisionSolid const *CollisionEntry::get_from(void) const;

Description: Returns the CollisionSolid pointer for the particular solid that triggered this collision.

getFromNode
CollisionNode *CollisionEntry::get_from_node(void) const;

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().

getFromNodePath
NodePath CollisionEntry::get_from_node_path(void) const;

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().

getInteriorPoint
LPoint3f CollisionEntry::get_interior_point(NodePath const &space) const;

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.

getInto
CollisionSolid const *CollisionEntry::get_into(void) const;

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().

getIntoNode
PandaNode *CollisionEntry::get_into_node(void) const;

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().

getIntoNodePath
NodePath CollisionEntry::get_into_node_path(void) const;

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.

getRespectPrevTransform
bool CollisionEntry::get_respect_prev_transform(void) const;

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.

getSurfaceNormal
LVector3f CollisionEntry::get_surface_normal(NodePath const &space) const;

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.

getSurfacePoint
LPoint3f CollisionEntry::get_surface_point(NodePath const &space) const;

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.

getT
float CollisionEntry::get_t(void) const;

Description: returns time value for this collision relative to other CollisionEntries

hasContactNormal
bool CollisionEntry::has_contact_normal(void) const;

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.

hasContactPos
bool CollisionEntry::has_contact_pos(void) const;

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.

hasInteriorPoint
bool CollisionEntry::has_interior_point(void) const;

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.

hasInto
bool CollisionEntry::has_into(void) const;

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.

hasSurfaceNormal
bool CollisionEntry::has_surface_normal(void) const;

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.

hasSurfacePoint
bool CollisionEntry::has_surface_point(void) const;

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.

output
void CollisionEntry::output(ostream &out) const;

Description:

resetCollided
void CollisionEntry::reset_collided(void);

Description: prepare for another collision test

setContactNormal
void CollisionEntry::set_contact_normal(LVector3f const &normal);

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.

setContactPos
void CollisionEntry::set_contact_pos(LPoint3f const &pos);

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.

setInteriorPoint
void CollisionEntry::set_interior_point(LPoint3f const &point);

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.

setSurfaceNormal
void CollisionEntry::set_surface_normal(LVector3f const &normal);

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.

setSurfacePoint
void CollisionEntry::set_surface_point(LPoint3f const &point);

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.

setT
void CollisionEntry::set_t(float t);

Description: Sets a time value for this collision relative to other CollisionEntries

write
void CollisionEntry::write(ostream &out, int indent_level = (0)) const;

Description:

getClassType
static TypeHandle TypedWritableReferenceCount::get_class_type(void);

Undocumented function.

getClassType
static TypeHandle TypedWritable::get_class_type(void);

Undocumented function.

getClassType
static TypeHandle TypedObject::get_class_type(void);

Undocumented function.

getType
virtual TypeHandle TypedObject::get_type(void) const = 0;

Derived classes should override this function to return get_class_type().

getTypeIndex
int TypedObject::get_type_index(void) const;

Description: Returns the internal index number associated with this object's TypeHandle, a unique number for each different type. This is equivalent to get_type().get_index().

isExactType
bool TypedObject::is_exact_type(TypeHandle handle) const;

Description: Returns true if the current object is the indicated type exactly.

isOfType
bool TypedObject::is_of_type(TypeHandle handle) const;

Description: Returns true if the current object is or derives from the indicated type.

getClassType
static TypeHandle ReferenceCount::get_class_type(void);

Undocumented function.

getRefCount
int ReferenceCount::get_ref_count(void) const;

Description: Returns the current reference count.

ref
void ReferenceCount::ref(void) const;

Description: Explicitly increments the reference count. User code should avoid using ref() and unref() directly, which can result in missed reference counts. Instead, let a PointerTo object manage the reference counting automatically.
This function is const, even though it changes the object, because generally fiddling with an object's reference count isn't considered part of fiddling with the object. An object might be const in other ways, but we still need to accurately count the number of references to it.

testRefCountIntegrity
bool ReferenceCount::test_ref_count_integrity(void) const;

Description: Does some easy checks to make sure that the reference count isn't completely bogus. Returns true if ok, false otherwise.

testRefCountNonzero
bool ReferenceCount::test_ref_count_nonzero(void) const;

Description: Does some easy checks to make sure that the reference count isn't zero, or completely bogus. Returns true if ok, false otherwise.

unref
bool ReferenceCount::unref(void) const;

Description: Explicitly decrements the reference count. Note that the object will not be implicitly deleted by unref() simply because the reference count drops to zero. (Having a member function delete itself is problematic; plus, we don't have a virtual destructor anyway.) However, see the helper function unref_delete().
User code should avoid using ref() and unref() directly, which can result in missed reference counts. Instead, let a PointerTo object manage the reference counting automatically.
This function is const, even though it changes the object, because generally fiddling with an object's reference count isn't considered part of fiddling with the object. An object might be const in other ways, but we still need to accurately count the number of references to it.
The return value is true if the new reference count is nonzero, false if it is zero.