00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef COLLISIONSOLID_H
00016 #define COLLISIONSOLID_H
00017
00018 #include "pandabase.h"
00019
00020 #include "config_collide.h"
00021 #include "copyOnWriteObject.h"
00022 #include "luse.h"
00023 #include "pointerTo.h"
00024 #include "renderState.h"
00025 #include "geomNode.h"
00026 #include "lightMutex.h"
00027 #include "lightMutexHolder.h"
00028 #include "pStatCollector.h"
00029
00030 class CollisionHandler;
00031 class CollisionEntry;
00032 class CollisionSphere;
00033 class GeomNode;
00034 class CollisionNode;
00035 class CullTraverserData;
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050 class EXPCL_PANDA_COLLIDE CollisionSolid : public CopyOnWriteObject {
00051 public:
00052 CollisionSolid();
00053 CollisionSolid(const CollisionSolid ©);
00054 virtual ~CollisionSolid();
00055
00056 virtual CollisionSolid *make_copy()=0;
00057 protected:
00058 virtual PT(CopyOnWriteObject) make_cow_copy();
00059
00060 PUBLISHED:
00061 virtual LPoint3 get_collision_origin() const=0;
00062
00063 INLINE void set_tangible(bool tangible);
00064 INLINE bool is_tangible() const;
00065
00066 INLINE void set_effective_normal(const LVector3 &effective_normal);
00067 INLINE void clear_effective_normal();
00068 INLINE bool has_effective_normal() const;
00069 INLINE const LVector3 &get_effective_normal() const;
00070
00071 INLINE void set_respect_effective_normal(bool respect_effective_normal);
00072 INLINE bool get_respect_effective_normal() const;
00073
00074 CPT(BoundingVolume) get_bounds() const;
00075 void set_bounds(const BoundingVolume &bounding_volume);
00076
00077 public:
00078 virtual PT(CollisionEntry)
00079 test_intersection(const CollisionEntry &entry) const;
00080
00081 virtual void xform(const LMatrix4 &mat);
00082
00083 virtual PT(PandaNode) get_viz(const CullTraverser *trav,
00084 const CullTraverserData &data,
00085 bool bounds_only) const;
00086
00087 virtual PStatCollector &get_volume_pcollector();
00088 virtual PStatCollector &get_test_pcollector();
00089
00090 PUBLISHED:
00091 virtual void output(ostream &out) const;
00092 virtual void write(ostream &out, int indent_level = 0) const;
00093
00094 protected:
00095 INLINE bool do_is_tangible() const;
00096 INLINE bool do_has_effective_normal() const;
00097
00098 INLINE void mark_internal_bounds_stale();
00099 virtual PT(BoundingVolume) compute_internal_bounds() const;
00100
00101 virtual PT(CollisionEntry)
00102 test_intersection_from_sphere(const CollisionEntry &entry) const;
00103 virtual PT(CollisionEntry)
00104 test_intersection_from_line(const CollisionEntry &entry) const;
00105 virtual PT(CollisionEntry)
00106 test_intersection_from_ray(const CollisionEntry &entry) const;
00107 virtual PT(CollisionEntry)
00108 test_intersection_from_segment(const CollisionEntry &entry) const;
00109 virtual PT(CollisionEntry)
00110 test_intersection_from_parabola(const CollisionEntry &entry) const;
00111 virtual PT(CollisionEntry)
00112 test_intersection_from_box(const CollisionEntry &entry) const;
00113
00114 static void report_undefined_intersection_test(TypeHandle from_type,
00115 TypeHandle into_type);
00116 static void report_undefined_from_intersection(TypeHandle from_type);
00117
00118 INLINE void mark_viz_stale();
00119 virtual void fill_viz_geom();
00120
00121 CPT(RenderState) get_solid_viz_state();
00122 CPT(RenderState) get_wireframe_viz_state();
00123 CPT(RenderState) get_other_viz_state();
00124 CPT(RenderState) get_solid_bounds_viz_state();
00125 CPT(RenderState) get_wireframe_bounds_viz_state();
00126 CPT(RenderState) get_other_bounds_viz_state();
00127
00128 PT(GeomNode) _viz_geom;
00129 PT(GeomNode) _bounds_viz_geom;
00130
00131 private:
00132 LVector3 _effective_normal;
00133 PT(BoundingVolume) _internal_bounds;
00134
00135
00136
00137 enum Flags {
00138 F_tangible = 0x01,
00139 F_effective_normal = 0x02,
00140 F_viz_geom_stale = 0x04,
00141 F_ignore_effective_normal = 0x08,
00142 F_internal_bounds_stale = 0x10,
00143 };
00144 int _flags;
00145
00146 LightMutex _lock;
00147
00148 static PStatCollector _volume_pcollector;
00149 static PStatCollector _test_pcollector;
00150
00151 public:
00152 virtual void write_datagram(BamWriter* manager, Datagram &me);
00153
00154 protected:
00155 void fillin(DatagramIterator& scan, BamReader* manager);
00156
00157 public:
00158 static TypeHandle get_class_type() {
00159 return _type_handle;
00160 }
00161 static void init_type() {
00162 CopyOnWriteObject::init_type();
00163 register_type(_type_handle, "CollisionSolid",
00164 CopyOnWriteObject::get_class_type());
00165 }
00166 virtual TypeHandle get_type() const {
00167 return get_class_type();
00168 }
00169 virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
00170
00171 private:
00172 static TypeHandle _type_handle;
00173
00174 friend class CollisionSphere;
00175 friend class CollisionLine;
00176 friend class CollisionRay;
00177 friend class CollisionSegment;
00178 friend class CollisionParabola;
00179 friend class CollisionHandlerFluidPusher;
00180 friend class CollisionBox;
00181 };
00182
00183 INLINE ostream &operator << (ostream &out, const CollisionSolid &cs) {
00184 cs.output(out);
00185 return out;
00186 }
00187
00188 #include "collisionSolid.I"
00189
00190 #endif
00191