RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

further fixes for collision under local root

This commit is contained in:
David Rose 2006-09-07 17:24:20 +00:00
parent 616de46c25
commit a01ef2534c
7 changed files with 136 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
panda/src/collide/collisionHandlerQueue.cxx
View File

@ -18,6 +18,7 @@
#include "collisionHandlerQueue.h"
#include "config_collide.h"
#include "indent.h"
TypeHandle CollisionHandlerQueue::_type_handle;
@ -41,7 +42,7 @@ public:
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::Constructor
// Access: Public
// Access: Published
// Description:
////////////////////////////////////////////////////////////////////
CollisionHandlerQueue::
@ -50,7 +51,7 @@ CollisionHandlerQueue() {
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::begin_group
// Access: Public, Virtual
// Access: Published, Virtual
// Description: Will be called by the CollisionTraverser before a new
// traversal is begun. It instructs the handler to
// reset itself in preparation for a number of
@ -63,7 +64,7 @@ begin_group() {
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::add_entry
// Access: Public, Virtual
// Access: Published, Virtual
// Description: Called between a begin_group() .. end_group()
// sequence for each collision that is detected.
////////////////////////////////////////////////////////////////////
@ -75,7 +76,7 @@ add_entry(CollisionEntry *entry) {
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::sort_entries
// Access: Public
// 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
@ -113,7 +114,7 @@ sort_entries() {
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::clear_entries
// Access: Public
// Access: Published
// Description: Removes all the entries from the queue.
////////////////////////////////////////////////////////////////////
void CollisionHandlerQueue::
@ -123,7 +124,7 @@ clear_entries() {
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::get_num_entries
// Access: Public
// Access: Published
// Description: Returns the number of CollisionEntries detected last
// pass.
////////////////////////////////////////////////////////////////////
@ -134,7 +135,7 @@ get_num_entries() const {
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::get_entry
// Access: Public
// Access: Published
// Description: Returns the nth CollisionEntry detected last pass.
////////////////////////////////////////////////////////////////////
CollisionEntry *CollisionHandlerQueue::
@ -142,3 +143,29 @@ get_entry(int n) const {
nassertr(n >= 0 && n < (int)_entries.size(), NULL);
return _entries[n];
}
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::output
// Access: Published
// Description:
////////////////////////////////////////////////////////////////////
void CollisionHandlerQueue::
output(ostream &out) const {
out << "CollisionHandlerQueue, " << _entries.size() << " entries";
}
////////////////////////////////////////////////////////////////////
// Function: CollisionHandlerQueue::write
// Access: Published
// Description:
////////////////////////////////////////////////////////////////////
void CollisionHandlerQueue::
write(ostream &out, int indent_level) const {
indent(out, indent_level)
<< "CollisionHandlerQueue, " << _entries.size() << " entries:\n";
Entries::const_iterator ei;
for (ei = _entries.begin(); ei != _entries.end(); ++ei) {
(*ei)->write(out, indent_level + 2);
}
}

8
panda/src/collide/collisionHandlerQueue.h
View File

@ -48,6 +48,9 @@ PUBLISHED:
int get_num_entries() const;
CollisionEntry *get_entry(int n) const;
void output(ostream &out) const;
void write(ostream &out, int indent_level = 0) const;
private:
typedef pvector< PT(CollisionEntry) > Entries;
Entries _entries;
@ -70,6 +73,11 @@ private:
static TypeHandle _type_handle;
};
INLINE ostream &operator << (ostream &out, const CollisionHandlerQueue &chq) {
chq.output(out);
return out;
}
#endif

12
panda/src/collide/collisionRecorder.I
View File

@ -16,15 +16,3 @@
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// Function: CollisionRecorder::get_type_index
// Access: Published
// Description: Duplicates the functionality of
// TypedObject::get_type_index().
////////////////////////////////////////////////////////////////////
INLINE int CollisionRecorder::
get_type_index() const {
return get_type().get_index();
}

13
panda/src/collide/collisionRecorder.h
View File

@ -35,7 +35,7 @@ class CollisionEntry;
// class that just provides an interface for recording
// collisions tested and detected each frame.
////////////////////////////////////////////////////////////////////
class EXPCL_PANDA CollisionRecorder {
class EXPCL_PANDA CollisionRecorder : public TypedObject {
protected:
CollisionRecorder();
public:
@ -58,18 +58,15 @@ public:
static TypeHandle get_class_type() {
return _type_handle;
}
static void init_type() {
register_type(_type_handle, "CollisionRecorder");
TypedObject::init_type();
register_type(_type_handle, "CollisionRecorder",
TypedObject::get_class_type());
}
PUBLISHED:
// We have to publish this explicitly because the CollisionRecorder
// object does not inherit from TypedObject.
virtual TypeHandle get_type() const {
return get_class_type();
}
INLINE int get_type_index() const;
virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
private:
static TypeHandle _type_handle;

84
panda/src/collide/collisionVisualizer.I
View File

@ -30,27 +30,83 @@ SolidInfo() {
////////////////////////////////////////////////////////////////////
// Function: CollisionVisualizer::set_viz_scale
// Function: CollisionVisualizer::set_point_scale
// Access: Published
// Description: Scales the objects that are drawn to represent the
// normals and points 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 objects from farther away.
// 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.
////////////////////////////////////////////////////////////////////
INLINE void CollisionVisualizer::
set_viz_scale(float viz_scale) {
_viz_scale = viz_scale;
set_point_scale(float point_scale) {
_point_scale = point_scale;
}
////////////////////////////////////////////////////////////////////
// Function: CollisionVisualizer::get_viz_scale
// Function: CollisionVisualizer::get_point_scale
// Access: Published
// Description: Returns the value last set by set_viz_scale().
// Description: Returns the value last set by set_point_scale().
////////////////////////////////////////////////////////////////////
INLINE float CollisionVisualizer::
get_viz_scale() const {
return _viz_scale;
get_point_scale() const {
return _point_scale;
}
////////////////////////////////////////////////////////////////////
// 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.
////////////////////////////////////////////////////////////////////
INLINE void CollisionVisualizer::
set_normal_scale(float normal_scale) {
_normal_scale = normal_scale;
}
////////////////////////////////////////////////////////////////////
// Function: CollisionVisualizer::get_normal_scale
// Access: Published
// Description: Returns the value last set by set_normal_scale().
////////////////////////////////////////////////////////////////////
INLINE float CollisionVisualizer::
get_normal_scale() const {
return _normal_scale;
}
////////////////////////////////////////////////////////////////////
// Function: CollisionVisualizer::as_typed_object
// Access: Public
// Description: This is provided to disambiguate the typecast to
// TypedObject, since we have two TypedObjects in our
// inheritance chain.
////////////////////////////////////////////////////////////////////
INLINE TypedObject *CollisionVisualizer::
as_typed_object() {
// In fact, it really doesn't matter which one we pick. Arbitrarily
// pick the one that goes through PandaNode.
return PandaNode::as_typed_object();
}
////////////////////////////////////////////////////////////////////
// Function: CollisionVisualizer::as_typed_object
// Access: Public
// Description: This is provided to disambiguate the typecast to
// TypedObject, since we have two TypedObjects in our
// inheritance chain.
////////////////////////////////////////////////////////////////////
INLINE const TypedObject * CollisionVisualizer::
as_typed_object() const {
// In fact, it really doesn't matter which one we pick. Arbitrarily
// pick the one that goes through PandaNode.
return PandaNode::as_typed_object();
}

13
panda/src/collide/collisionVisualizer.cxx
View File

@ -52,7 +52,8 @@ CollisionVisualizer(const string &name) : PandaNode(name) {
// We always want to render the CollisionVisualizer node itself
// (even if it doesn't appear to have any geometry within it).
set_internal_bounds(new OmniBoundingVolume());
_viz_scale = 1.0f;
_point_scale = 1.0f;
_normal_scale = 1.0f;
}
////////////////////////////////////////////////////////////////////
@ -137,6 +138,8 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
// always renders its objects according to their appropriate net
// transform.
xform_data._net_transform = TransformState::make_identity();
xform_data._view_frustum = trav->get_view_frustum();
xform_data._guard_band = trav->get_guard_band();
xform_data.apply_transform_and_state(trav, net_transform,
RenderState::make_empty(),
RenderEffects::make_empty(),
@ -167,7 +170,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
// Now draw all of the detected points.
if (!viz_info._points.empty()) {
CPT(RenderState) empty_state = RenderState::make_empty();
CPT(RenderState) point_state = RenderState::make(RenderModeAttrib::make(RenderModeAttrib::M_unchanged, 1.0f, true));
CPT(RenderState) point_state = RenderState::make(RenderModeAttrib::make(RenderModeAttrib::M_unchanged, 1.0f, false));
PT(GeomVertexArrayFormat) point_array_format =
new GeomVertexArrayFormat(InternalName::get_vertex(), 3,
@ -197,14 +200,14 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
vertex.add_data3f(point._surface_point);
color.add_data4f(1.0f, 0.0f, 0.0f, 1.0f);
size.add_data1f(0.1f * _viz_scale);
size.add_data1f(16.0f * _point_scale);
points->add_next_vertices(1);
points->close_primitive();
if (point._interior_point != point._surface_point) {
vertex.add_data3f(point._interior_point);
color.add_data4f(1.0f, 1.0f, 1.0f, 1.0f);
size.add_data1f(0.05f * _viz_scale);
size.add_data1f(8.0f * _point_scale);
points->add_next_vertices(1);
points->close_primitive();
}
@ -234,7 +237,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
vertex.add_data3f(point._surface_point);
vertex.add_data3f(point._surface_point +
point._surface_normal * _viz_scale);
point._surface_normal * _normal_scale);
color.add_data4f(1.0f, 0.0f, 0.0f, 1.0f);
color.add_data4f(1.0f, 1.0f, 1.0f, 1.0f);
lines->add_next_vertices(2);

14
panda/src/collide/collisionVisualizer.h
View File

@ -43,8 +43,11 @@ PUBLISHED:
CollisionVisualizer(const string &name);
virtual ~CollisionVisualizer();
INLINE void set_viz_scale(float viz_scale);
INLINE float get_viz_scale() const;
INLINE void set_point_scale(float point_scale);
INLINE float get_point_scale() const;
INLINE void set_normal_scale(float normal_scale);
INLINE float get_normal_scale() const;
void clear();
@ -59,6 +62,10 @@ public:
virtual void begin_traversal();
virtual void collision_tested(const CollisionEntry &entry, bool detected);
// To disambiguate the multiple inheritance from TypedObject.
INLINE TypedObject *as_typed_object();
INLINE const TypedObject *as_typed_object() const;
private:
CPT(RenderState) get_viz_state();
@ -88,7 +95,8 @@ private:
typedef pmap<CPT(TransformState), VizInfo> Data;
Data _data;
float _viz_scale;
float _point_scale;
float _normal_scale;
public:
static TypeHandle get_class_type() {