[1919] | 1 | #ifndef _OGREODEGEOMETRY_H_ |
---|
| 2 | #define _OGREODEGEOMETRY_H_ |
---|
| 3 | |
---|
| 4 | #include "OgreOdePreReqs.h" |
---|
| 5 | |
---|
[1923] | 6 | #include <OgreUserDefinedObject.h> |
---|
| 7 | #include <OgreMovableObject.h> |
---|
| 8 | #include <OgreSceneQuery.h> |
---|
[1919] | 9 | #include "OgreOdeTriangleMeshData.h" |
---|
| 10 | |
---|
| 11 | namespace OgreOde |
---|
| 12 | { |
---|
| 13 | /** |
---|
| 14 | This object is the base class for all Geometry objects in OgreOde. |
---|
| 15 | @remarks |
---|
| 16 | This object is tied either to a Body (acting as collision proxy for a physic object) |
---|
| 17 | or to a Entity Object (which then is physically "static") |
---|
| 18 | @remarks |
---|
| 19 | It extends the OGRE UserDefinedObject to allow reverse links from Ogre::Entity. |
---|
| 20 | Note that this class does not override the UserDefinedObject's getTypeId method |
---|
| 21 | because this class is abstract. |
---|
| 22 | */ |
---|
| 23 | class _OgreOdeExport Geometry : public Ogre::UserDefinedObject, public Ogre::MovableObject |
---|
| 24 | { |
---|
| 25 | friend class Space; |
---|
| 26 | friend class World; |
---|
| 27 | friend class Body; |
---|
| 28 | friend class TransformGeometry; |
---|
| 29 | |
---|
| 30 | public: |
---|
| 31 | enum Class |
---|
| 32 | { |
---|
| 33 | Class_Sphere = dSphereClass, |
---|
| 34 | Class_Box = dBoxClass, |
---|
| 35 | Class_Capsule = dCapsuleClass, |
---|
| 36 | Class_Cylinder = dCCylinderClass, |
---|
| 37 | Class_InfinitePlane = dPlaneClass, |
---|
| 38 | Class_Ray = dRayClass, |
---|
| 39 | Class_TriangleMesh = dTriMeshClass, |
---|
| 40 | Class_Terrain = dHeightfieldClass, |
---|
| 41 | Class_Convex = dConvexClass, |
---|
| 42 | Class_Transform = dGeomTransformClass, |
---|
| 43 | Class_NoGeometry |
---|
| 44 | }; |
---|
| 45 | |
---|
| 46 | public: |
---|
| 47 | Geometry(World *world, Space* space = 0); |
---|
| 48 | virtual ~Geometry(); |
---|
| 49 | |
---|
| 50 | virtual void setBody(Body* body); |
---|
| 51 | Body* getBody(); |
---|
| 52 | |
---|
| 53 | |
---|
| 54 | virtual void setPosition(const Ogre::Vector3& position); |
---|
| 55 | virtual void setOrientation(const Ogre::Quaternion& orientation); |
---|
| 56 | virtual const Ogre::Vector3& getPosition(); |
---|
| 57 | virtual const Ogre::Quaternion& getOrientation(); |
---|
| 58 | virtual const Ogre::AxisAlignedBox& getAxisAlignedBox(); |
---|
| 59 | |
---|
| 60 | |
---|
| 61 | Space* getSpace(); |
---|
| 62 | |
---|
| 63 | void enable(); |
---|
| 64 | void disable(); |
---|
| 65 | bool isEnabled(); |
---|
| 66 | |
---|
| 67 | Geometry::Class getClass() const; |
---|
| 68 | |
---|
| 69 | void setCategoryBitfield(unsigned long bits); |
---|
| 70 | void setCollisionBitfield(unsigned long bits); |
---|
| 71 | unsigned long getCategoryBitfield(); |
---|
| 72 | unsigned long getCollisionBitfield(); |
---|
| 73 | |
---|
| 74 | int collide(Geometry* geometry, CollisionListener* listener = 0); |
---|
| 75 | |
---|
| 76 | void setMaxContacts(unsigned int max_contacts); |
---|
| 77 | unsigned int getMaxContacts() const; |
---|
| 78 | unsigned int getContactHighWaterMark() const; |
---|
| 79 | |
---|
| 80 | void setEncapsulator(Geometry* encapsulator); |
---|
| 81 | Geometry* getEncapsulator(){return _encapsulator;} |
---|
| 82 | |
---|
| 83 | void setUserData(size_t user_data){_user_data = user_data;} |
---|
| 84 | size_t getUserData() const {return _user_data;} |
---|
| 85 | |
---|
| 86 | void setUserObject(UserDefinedObject* object){_user_object = object;} |
---|
| 87 | UserDefinedObject* getUserObject(){return _user_object;} |
---|
| 88 | |
---|
| 89 | virtual size_t getID() const ; |
---|
| 90 | virtual void notify(Body* body); |
---|
| 91 | |
---|
| 92 | |
---|
| 93 | virtual void setDebug(const bool debug); |
---|
| 94 | virtual void createDebugObject(); |
---|
| 95 | virtual void destroyDebugObject(); |
---|
| 96 | void reparentDebugObject(Ogre::Node* node); |
---|
| 97 | |
---|
| 98 | virtual void setDebugContact(const bool debug); |
---|
| 99 | void updateDebugContact(); |
---|
| 100 | |
---|
| 101 | void clearOffset(); |
---|
| 102 | int isOffset(); |
---|
| 103 | |
---|
| 104 | void setOffsetPosition (const Ogre::Vector3 &position); |
---|
| 105 | void setOffsetQuaternion(const Ogre::Quaternion &orientation); |
---|
| 106 | |
---|
| 107 | void setOffsetWorldPosition(const Ogre::Vector3 &position); |
---|
| 108 | void setOffsetWorldQuaternion(const Ogre::Quaternion &orientation) ; |
---|
| 109 | |
---|
| 110 | Ogre::Vector3 getOffsetPosition() ; |
---|
| 111 | Ogre::Quaternion getOffsetQuaternion() ; |
---|
| 112 | |
---|
| 113 | |
---|
| 114 | /** returns mGeometry's AABB |
---|
| 115 | */ |
---|
| 116 | virtual const Ogre::AxisAlignedBox& getBoundingBox(void) const {return _bounding_box; }; |
---|
| 117 | |
---|
| 118 | /** |
---|
| 119 | */ |
---|
| 120 | static const Ogre::String MovableType; |
---|
| 121 | virtual const Ogre::String& getMovableType() const { return MovableType; }; |
---|
| 122 | |
---|
| 123 | /** |
---|
| 124 | */ |
---|
| 125 | virtual Ogre::Real getBoundingRadius(void) const { return Ogre::Real(0.0); } |
---|
| 126 | |
---|
| 127 | /** |
---|
| 128 | */ |
---|
| 129 | virtual void _updateRenderQueue(Ogre::RenderQueue* queue){} |
---|
| 130 | |
---|
| 131 | /** added for Ogre 1.5 |
---|
| 132 | */ |
---|
| 133 | #if OGRE_VERSION >= ((1 << 16) | (5 << 8)) |
---|
| 134 | virtual void visitRenderables(Ogre::Renderable::Visitor* visitor, bool debugRenderables = false){} |
---|
| 135 | #endif |
---|
| 136 | |
---|
| 137 | /** set mParentNode and sets mGeometrys position and orientation to match mParentNode's |
---|
| 138 | */ |
---|
| 139 | virtual void _notifyAttached(Ogre::Node* parent, bool isTagPoint = false); |
---|
| 140 | |
---|
| 141 | /** sets mGeometry position and orientation to match mParentNode's |
---|
| 142 | */ |
---|
| 143 | virtual void _notifyMoved(); |
---|
| 144 | |
---|
| 145 | |
---|
| 146 | virtual const Ogre::String& getName (void) const { return mName; } |
---|
| 147 | |
---|
| 148 | /** setting mName is not important - its not actually being used |
---|
| 149 | it just helps debugging code |
---|
| 150 | */ |
---|
| 151 | void setName (Ogre::String name){ mName = name; } |
---|
| 152 | |
---|
| 153 | |
---|
| 154 | |
---|
| 155 | protected: |
---|
| 156 | dGeomID getGeometryID() const; |
---|
| 157 | void registerGeometry(); |
---|
| 158 | dSpaceID getSpaceID(Space* space) const; |
---|
| 159 | |
---|
| 160 | protected: |
---|
| 161 | Ogre::String mName; |
---|
| 162 | dGeomID _geom; |
---|
| 163 | unsigned int _max_contacts; |
---|
| 164 | unsigned int _contact_high_water_mark; |
---|
| 165 | unsigned int _last_contact_num; |
---|
| 166 | dContact* _contacts; |
---|
| 167 | |
---|
| 168 | DebugObject* _debug_obj; |
---|
| 169 | Ogre::Node* _debug_node; |
---|
| 170 | DebugContact** _debug_contacts; |
---|
| 171 | |
---|
| 172 | Geometry* _encapsulator; |
---|
| 173 | Ogre::AxisAlignedBox _bounding_box; |
---|
| 174 | Ogre::Quaternion _orientation; |
---|
| 175 | Ogre::Vector3 _position; |
---|
| 176 | |
---|
| 177 | static int _geometry_count; |
---|
| 178 | size_t _user_data; |
---|
| 179 | UserDefinedObject* _user_object; |
---|
| 180 | World *_world; |
---|
| 181 | |
---|
| 182 | }; |
---|
| 183 | |
---|
| 184 | //------------------------------------------------------------------------------------------------ |
---|
| 185 | class _OgreOdeExport SphereGeometry:public Geometry |
---|
| 186 | { |
---|
| 187 | public: |
---|
| 188 | SphereGeometry(Ogre::Real radius, World *world, Space* space = 0); |
---|
| 189 | ~SphereGeometry(); |
---|
| 190 | |
---|
| 191 | virtual void createDebugObject(); |
---|
| 192 | |
---|
| 193 | void setRadius(Ogre::Real radius); |
---|
| 194 | Ogre::Real getRadius(); |
---|
| 195 | Ogre::Real getPointDepth(const Ogre::Vector3& point); |
---|
| 196 | /** Return a string identifying the type of user defined object. |
---|
| 197 | @remarks |
---|
| 198 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 199 | */ |
---|
| 200 | const Ogre::String& getTypeName(void) const |
---|
| 201 | {static Ogre::String sName("Geometry Sphere");return sName;}; |
---|
| 202 | |
---|
| 203 | }; |
---|
| 204 | |
---|
| 205 | //------------------------------------------------------------------------------------------------ |
---|
| 206 | class _OgreOdeExport BoxGeometry:public Geometry |
---|
| 207 | { |
---|
| 208 | public: |
---|
| 209 | BoxGeometry(const Ogre::Vector3& size, World *world, Space* space = 0); |
---|
| 210 | ~BoxGeometry(); |
---|
| 211 | |
---|
| 212 | virtual void createDebugObject(); |
---|
| 213 | |
---|
| 214 | void setSize(const Ogre::Vector3& size); |
---|
| 215 | const Ogre::Vector3& getSize(); |
---|
| 216 | Ogre::Real getPointDepth(const Ogre::Vector3& point); |
---|
| 217 | |
---|
| 218 | /** Return a string identifying the type of user defined object. |
---|
| 219 | @remarks |
---|
| 220 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 221 | */ |
---|
| 222 | const Ogre::String& getTypeName(void) const |
---|
| 223 | {static Ogre::String sName("Geometry Box");return sName;}; |
---|
| 224 | |
---|
| 225 | protected: |
---|
| 226 | Ogre::Vector3 _size; |
---|
| 227 | }; |
---|
| 228 | |
---|
| 229 | //------------------------------------------------------------------------------------------------ |
---|
| 230 | class _OgreOdeExport InfinitePlaneGeometry:public Geometry |
---|
| 231 | { |
---|
| 232 | public: |
---|
| 233 | InfinitePlaneGeometry(const Ogre::Plane& plane, World *world, Space* space = 0); |
---|
| 234 | ~InfinitePlaneGeometry(); |
---|
| 235 | |
---|
| 236 | void setDefinition(const Ogre::Plane& plane); |
---|
| 237 | const Ogre::Plane& getDefinition(); |
---|
| 238 | Ogre::Real getPointDepth(const Ogre::Vector3& point); |
---|
| 239 | |
---|
| 240 | void setPosition(const Ogre::Vector3& position); |
---|
| 241 | void setOrientation(const Ogre::Quaternion& orientation); |
---|
| 242 | const Ogre::Vector3& getPosition(); |
---|
| 243 | const Ogre::Quaternion& getOrientation(); |
---|
| 244 | const Ogre::AxisAlignedBox& getAxisAlignedBox(); |
---|
| 245 | |
---|
| 246 | /** Return a string identifying the type of user defined object. |
---|
| 247 | @remarks |
---|
| 248 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 249 | */ |
---|
| 250 | const Ogre::String& getTypeName(void) const |
---|
| 251 | {static Ogre::String sName("Geometry Infinity Plane");return sName;}; |
---|
| 252 | |
---|
| 253 | protected: |
---|
| 254 | Ogre::Plane _plane; |
---|
| 255 | }; |
---|
| 256 | //------------------------------------------------------------------------------------------------ |
---|
| 257 | class _OgreOdeExport CapsuleGeometry:public Geometry |
---|
| 258 | { |
---|
| 259 | public: |
---|
| 260 | CapsuleGeometry(Ogre::Real radius, Ogre::Real length, World *world, Space* space = 0); |
---|
| 261 | ~CapsuleGeometry(); |
---|
| 262 | |
---|
| 263 | virtual void createDebugObject(); |
---|
| 264 | |
---|
| 265 | void setDefinition(Ogre::Real radius, Ogre::Real length); |
---|
| 266 | Ogre::Real getRadius(); |
---|
| 267 | Ogre::Real getLength(); |
---|
| 268 | Ogre::Real getPointDepth(const Ogre::Vector3& point); |
---|
| 269 | |
---|
| 270 | |
---|
| 271 | /** Return a string identifying the type of user defined object. |
---|
| 272 | @remarks |
---|
| 273 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 274 | */ |
---|
| 275 | const Ogre::String& getTypeName(void) const |
---|
| 276 | {static Ogre::String sName("Geometry Capsule");return sName;}; |
---|
| 277 | |
---|
| 278 | }; |
---|
| 279 | //------------------------------------------------------------------------------------------------ |
---|
| 280 | class _OgreOdeExport CylinderGeometry:public Geometry |
---|
| 281 | { |
---|
| 282 | public: |
---|
| 283 | CylinderGeometry(Ogre::Real radius, Ogre::Real length, World *world, Space* space = 0); |
---|
| 284 | ~CylinderGeometry(); |
---|
| 285 | |
---|
| 286 | virtual void createDebugObject(); |
---|
| 287 | |
---|
| 288 | void setDefinition(Ogre::Real radius, Ogre::Real length); |
---|
| 289 | Ogre::Real getRadius(); |
---|
| 290 | Ogre::Real getLength(); |
---|
| 291 | Ogre::Real getPointDepth(const Ogre::Vector3& point); |
---|
| 292 | |
---|
| 293 | /** Return a string identifying the type of user defined object. |
---|
| 294 | @remarks |
---|
| 295 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 296 | */ |
---|
| 297 | const Ogre::String& getTypeName(void) const |
---|
| 298 | {static Ogre::String sName("Geometry Cylinder");return sName;}; |
---|
| 299 | |
---|
| 300 | }; |
---|
| 301 | //------------------------------------------------------------------------------------------------ |
---|
| 302 | class _OgreOdeExport RayGeometry:public Geometry |
---|
| 303 | { |
---|
| 304 | public: |
---|
| 305 | RayGeometry(Ogre::Real length, World *world, Space* space = 0); |
---|
| 306 | ~RayGeometry(); |
---|
| 307 | |
---|
| 308 | virtual void createDebugObject(); |
---|
| 309 | |
---|
| 310 | void setLength(Ogre::Real length); |
---|
| 311 | Ogre::Real getLength(); |
---|
| 312 | void setDefinition(const Ogre::Vector3& start, const Ogre::Vector3& direction); |
---|
| 313 | const Ogre::Vector3& getStart(); |
---|
| 314 | const Ogre::Vector3& getDirection(); |
---|
| 315 | |
---|
| 316 | /** Return a string identifying the type of user defined object. |
---|
| 317 | @remarks |
---|
| 318 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 319 | */ |
---|
| 320 | const Ogre::String& getTypeName(void) const |
---|
| 321 | {static Ogre::String sName("Geometry Ray");return sName;}; |
---|
| 322 | |
---|
| 323 | protected: |
---|
| 324 | Ogre::Vector3 _direction,_start; |
---|
| 325 | }; |
---|
| 326 | |
---|
| 327 | //------------------------------------------------------------------------------------------------ |
---|
| 328 | class _OgreOdeExport TransformGeometry:public Geometry |
---|
| 329 | { |
---|
| 330 | public: |
---|
| 331 | TransformGeometry(World *world, Space* space); |
---|
| 332 | ~TransformGeometry(); |
---|
| 333 | |
---|
| 334 | virtual void createDebugObject(); |
---|
| 335 | virtual void destroyDebugObject(); |
---|
| 336 | |
---|
| 337 | void setEncapsulatedGeometry(Geometry* geometry); |
---|
| 338 | Geometry* getEncapsulatedGeometry() const; |
---|
| 339 | |
---|
| 340 | /** Return a string identifying the type of user defined object. |
---|
| 341 | @remarks |
---|
| 342 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 343 | */ |
---|
| 344 | const Ogre::String& getTypeName(void) const |
---|
| 345 | {static Ogre::String sName("Geometry Transform");return sName;}; |
---|
| 346 | |
---|
| 347 | }; |
---|
| 348 | //------------------------------------------------------------------------------------------------ |
---|
| 349 | class _OgreOdeExport TriangleMeshCollisionListener |
---|
| 350 | { |
---|
| 351 | public: |
---|
| 352 | TriangleMeshCollisionListener(){} |
---|
| 353 | virtual ~TriangleMeshCollisionListener(){} |
---|
| 354 | |
---|
| 355 | virtual bool collide(TriangleMeshGeometry* triangle_mesh, Geometry* geometry, int triangle) {return true;} |
---|
| 356 | }; |
---|
| 357 | |
---|
| 358 | //------------------------------------------------------------------------------------------------ |
---|
| 359 | class _OgreOdeExport TriangleMeshIntersectionListener |
---|
| 360 | { |
---|
| 361 | public: |
---|
| 362 | TriangleMeshIntersectionListener(){} |
---|
| 363 | virtual ~TriangleMeshIntersectionListener(){} |
---|
| 364 | |
---|
| 365 | virtual void intersect(TriangleMeshGeometry* triangle_mesh, Geometry* geometry, const int* triangles, int triangle_count){} |
---|
| 366 | }; |
---|
| 367 | |
---|
| 368 | //------------------------------------------------------------------------------------------------ |
---|
| 369 | class _OgreOdeExport TriangleMeshRayListener |
---|
| 370 | { |
---|
| 371 | public: |
---|
| 372 | TriangleMeshRayListener(){} |
---|
| 373 | virtual ~TriangleMeshRayListener(){} |
---|
| 374 | |
---|
| 375 | virtual bool collide(TriangleMeshGeometry* triangle_mesh, RayGeometry* ray,int triangle, const Ogre::Vector3& uv){return true;} |
---|
| 376 | }; |
---|
| 377 | |
---|
| 378 | //------------------------------------------------------------------------------------------------ |
---|
| 379 | struct _OgreOdeExport TriangleMeshTriangle |
---|
| 380 | { |
---|
| 381 | Ogre::Vector3 v0,v1,v2; |
---|
| 382 | }; |
---|
| 383 | |
---|
| 384 | //------------------------------------------------------------------------------------------------ |
---|
| 385 | class _OgreOdeExport TriangleMeshGeometry:public Geometry |
---|
| 386 | { |
---|
| 387 | public: |
---|
| 388 | TriangleMeshGeometry(const Ogre::Vector3* vertices, |
---|
| 389 | unsigned int vertex_count, |
---|
| 390 | const TriangleIndex* indices, |
---|
| 391 | unsigned int index_count, |
---|
| 392 | World *world, |
---|
| 393 | Space* space = 0); |
---|
| 394 | |
---|
| 395 | TriangleMeshGeometry(TriangleMeshDataPtr dataPtr, World *world, Space* space = 0); |
---|
| 396 | |
---|
| 397 | void changeTriangleMeshData(TriangleMeshDataPtr dataPtr); |
---|
| 398 | |
---|
[1922] | 399 | TriangleMeshDataPtr getTriangleMeshData(){ return _dataPtr; } |
---|
[1919] | 400 | |
---|
| 401 | ~TriangleMeshGeometry(); |
---|
| 402 | |
---|
| 403 | Ogre::Vector3 getPoint(unsigned int index, const Ogre::Vector3& uv); |
---|
| 404 | TriangleMeshTriangle getTriangle(int index); |
---|
| 405 | |
---|
| 406 | void clearTemporalCoherenceCache(); |
---|
| 407 | void enableTemporalCoherence(Geometry::Class geometry_class,bool enable); |
---|
| 408 | bool isTemporalCoherenceEnabled(Geometry::Class geometry_class); |
---|
| 409 | |
---|
| 410 | static int _collisionCallback(dGeomID mesh,dGeomID object,int triangle); |
---|
| 411 | void setCollisionListener(TriangleMeshCollisionListener* collision_listener); |
---|
| 412 | |
---|
| 413 | static void _intersectionCallback(dGeomID mesh,dGeomID object,const int* triangles,int triangle_count); |
---|
| 414 | void setIntersectionListener(TriangleMeshIntersectionListener* intersection_listener); |
---|
| 415 | |
---|
| 416 | static int _rayCallback(dGeomID mesh,dGeomID ray,int triangle,dReal u,dReal v); |
---|
| 417 | void setRayListener(TriangleMeshRayListener* ray_listener); |
---|
| 418 | |
---|
| 419 | virtual void createDebugObject(); |
---|
| 420 | |
---|
| 421 | /** Return a string identifying the type of user defined object. |
---|
| 422 | @remarks |
---|
| 423 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 424 | */ |
---|
| 425 | const Ogre::String& getTypeName(void) const |
---|
| 426 | {static Ogre::String sName("Geometry Trimesh");return sName;}; |
---|
| 427 | |
---|
| 428 | protected: |
---|
| 429 | dTriMeshDataID _data; |
---|
| 430 | dVector3* _vertices; |
---|
| 431 | unsigned int* _indices; |
---|
| 432 | unsigned int _vertex_count; |
---|
| 433 | unsigned int _index_count; |
---|
| 434 | |
---|
| 435 | TriangleMeshDataPtr _dataPtr; |
---|
| 436 | |
---|
| 437 | TriangleMeshCollisionListener* _collision_listener; |
---|
| 438 | TriangleMeshIntersectionListener* _intersection_listener; |
---|
| 439 | TriangleMeshRayListener* _ray_listener; |
---|
| 440 | }; |
---|
| 441 | |
---|
| 442 | //------------------------------------------------------------------------------------------------ |
---|
| 443 | class _OgreOdeExport ConvexGeometry:public Geometry |
---|
| 444 | { |
---|
| 445 | public: |
---|
| 446 | ConvexGeometry(const Ogre::Vector3* vertices, |
---|
| 447 | unsigned int vertex_count, |
---|
| 448 | const unsigned int* indices, |
---|
| 449 | unsigned int index_count, |
---|
| 450 | World *world, |
---|
| 451 | Space* space = 0); |
---|
| 452 | ~ConvexGeometry(); |
---|
| 453 | |
---|
| 454 | |
---|
| 455 | virtual void createDebugObject(); |
---|
| 456 | |
---|
| 457 | /** Return a string identifying the type of user defined object. |
---|
| 458 | @remarks |
---|
| 459 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 460 | */ |
---|
| 461 | const Ogre::String& getTypeName(void) const |
---|
| 462 | {static Ogre::String sName("Geometry Convex");return sName;}; |
---|
| 463 | |
---|
| 464 | protected: |
---|
| 465 | dReal * _vertices; |
---|
| 466 | unsigned int* _indices; |
---|
| 467 | unsigned int _vertex_count; |
---|
| 468 | unsigned int _index_count; |
---|
| 469 | }; |
---|
| 470 | |
---|
| 471 | //------------------------------------------------------------------------------------------------ |
---|
| 472 | class _OgreOdeExport TerrainGeometryHeightListener |
---|
| 473 | { |
---|
| 474 | public: |
---|
| 475 | TerrainGeometryHeightListener(){} |
---|
| 476 | virtual ~TerrainGeometryHeightListener(){} |
---|
| 477 | |
---|
| 478 | virtual Ogre::Real heightAt(const Ogre::Vector3& position) = 0; |
---|
| 479 | }; |
---|
| 480 | |
---|
| 481 | //------------------------------------------------------------------------------------------------ |
---|
| 482 | class _OgreOdeExport TerrainGeometry:public Geometry, public Ogre::RaySceneQueryListener |
---|
| 483 | { |
---|
| 484 | public: |
---|
| 485 | TerrainGeometry(World *world, |
---|
| 486 | Space* space, |
---|
| 487 | const Ogre::Vector3 &scale, |
---|
| 488 | int nodes_per_sideX, |
---|
| 489 | int nodes_per_sideY, |
---|
| 490 | Ogre::Real worldSizeX, |
---|
| 491 | Ogre::Real worldSizeZ, |
---|
| 492 | bool centered, |
---|
| 493 | Ogre::Real thickness = 10.0f); |
---|
| 494 | |
---|
| 495 | ~TerrainGeometry(); |
---|
| 496 | |
---|
| 497 | Ogre::Real getPointDepth(const Ogre::Vector3& point); |
---|
| 498 | const Ogre::Vector3& getPosition(); |
---|
| 499 | const Ogre::Quaternion& getOrientation(); |
---|
| 500 | |
---|
| 501 | static dReal _heightCallback(void* data, dReal x, dReal z); |
---|
| 502 | static dReal _heightCallback(void* data, int x, int z); |
---|
| 503 | void setHeightListener(TerrainGeometryHeightListener* listener); |
---|
| 504 | |
---|
| 505 | inline Ogre::Real getHeightAt(const Ogre::Vector3& position) |
---|
| 506 | { |
---|
| 507 | _num_query++; |
---|
| 508 | const Ogre::Vector3 pos (position.x * _sample_width - (_centered?_halfWorldSizeX:0), |
---|
| 509 | position.y, |
---|
| 510 | position.z * _sample_height - (_centered?_halfWorldSizeZ:0)); |
---|
| 511 | _ray.setOrigin(pos); |
---|
| 512 | _ray_query->setRay(_ray); |
---|
| 513 | _distance_to_terrain = static_cast<Ogre::Real>(0.0); |
---|
| 514 | _ray_query->execute(this); |
---|
| 515 | return position.y - _distance_to_terrain; |
---|
| 516 | } |
---|
| 517 | |
---|
| 518 | bool queryResult(Ogre::MovableObject *obj, Ogre::Real distance); |
---|
| 519 | bool queryResult(Ogre::SceneQuery::WorldFragment *fragment, Ogre::Real distance); |
---|
| 520 | |
---|
| 521 | size_t getNumQueries() const {return _num_query;}; |
---|
| 522 | void resetNumQueries(){_num_query = 0;}; |
---|
| 523 | |
---|
| 524 | /** Return a string identifying the type of user defined object. |
---|
| 525 | @remarks |
---|
| 526 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 527 | */ |
---|
| 528 | const Ogre::String& getTypeName(void) const |
---|
| 529 | {static Ogre::String sName("Geometry Terrain");return sName;}; |
---|
| 530 | |
---|
| 531 | protected: |
---|
| 532 | Ogre::Real _max_height; |
---|
| 533 | Ogre::Real _distance_to_terrain; |
---|
| 534 | Ogre::Real _sample_width, _sample_height; |
---|
| 535 | TerrainGeometryHeightListener* _listener; |
---|
| 536 | Ogre::Ray _ray; |
---|
| 537 | Ogre::RaySceneQuery* _ray_query; |
---|
| 538 | bool _centered; |
---|
| 539 | Ogre::Real _halfWorldSizeX; |
---|
| 540 | Ogre::Real _halfWorldSizeZ; |
---|
| 541 | size_t _num_query; |
---|
| 542 | }; |
---|
| 543 | //------------------------------------------------------------------------------------------------ |
---|
| 544 | class _OgreOdeExport PlaneBoundedRegionGeometryPlaneListener |
---|
| 545 | { |
---|
| 546 | public: |
---|
| 547 | PlaneBoundedRegionGeometryPlaneListener(){} |
---|
| 548 | virtual ~PlaneBoundedRegionGeometryPlaneListener(){} |
---|
| 549 | |
---|
| 550 | virtual std::list<Ogre::Plane>* planesAt(const Ogre::Vector3& position) = 0; |
---|
| 551 | }; |
---|
| 552 | |
---|
| 553 | //------------------------------------------------------------------------------------------------ |
---|
| 554 | class _OgreOdeExport PlaneBoundedRegionGeometry:public Geometry, public Ogre::RaySceneQueryListener |
---|
| 555 | { |
---|
| 556 | public: |
---|
| 557 | PlaneBoundedRegionGeometry(World *world, |
---|
| 558 | Space* space, |
---|
| 559 | const Ogre::AxisAlignedBox &scale); |
---|
| 560 | |
---|
| 561 | ~PlaneBoundedRegionGeometry(); |
---|
| 562 | |
---|
| 563 | Ogre::Real getPointDepth(const Ogre::Vector3& point); |
---|
| 564 | const Ogre::Vector3& getPosition(); |
---|
| 565 | const Ogre::Quaternion& getOrientation(); |
---|
| 566 | |
---|
| 567 | static std::list<Ogre::Plane> * _planeCallback(void* data, dReal x, dReal z); |
---|
| 568 | static std::list<Ogre::Plane> * _planeCallback(void* data, int x, int z); |
---|
| 569 | void setPlaneListener(PlaneBoundedRegionGeometryPlaneListener* listener); |
---|
| 570 | |
---|
| 571 | inline std::list<Ogre::Plane> *planesAt(const Ogre::Vector3& position) |
---|
| 572 | { |
---|
| 573 | _num_query++; |
---|
| 574 | // const Ogre::Vector3 pos (position.x * _sample_width - (_centered?_halfWorldSizeX:0), |
---|
| 575 | // position.y, |
---|
| 576 | // position.z * _sample_height - (_centered?_halfWorldSizeZ:0)); |
---|
| 577 | // _ray.setOrigin(pos); |
---|
| 578 | // _ray_query->setRay(_ray); |
---|
| 579 | // _distance_to_terrain = static_cast<Ogre::Real>(0.0); |
---|
| 580 | // _ray_query->execute(this); |
---|
| 581 | |
---|
| 582 | return _last_query_results; |
---|
| 583 | |
---|
| 584 | } |
---|
| 585 | |
---|
| 586 | bool queryResult(Ogre::MovableObject *obj, Ogre::Real distance); |
---|
| 587 | bool queryResult(Ogre::SceneQuery::WorldFragment *fragment, Ogre::Real distance); |
---|
| 588 | |
---|
| 589 | size_t getNumQueries() const {return _num_query;}; |
---|
| 590 | void resetNumQueries(){_num_query = 0;}; |
---|
| 591 | |
---|
| 592 | /** Return a string identifying the type of user defined object. |
---|
| 593 | @remarks |
---|
| 594 | Used to differentiate between different Bodies, Geometries and prefab_object |
---|
| 595 | */ |
---|
| 596 | const Ogre::String& getTypeName(void) const |
---|
| 597 | {static Ogre::String sName("Geometry Plane Bounded Region");return sName;}; |
---|
| 598 | |
---|
| 599 | protected: |
---|
| 600 | Ogre::Real _max_height; |
---|
| 601 | Ogre::Real _distance_to_terrain; |
---|
| 602 | Ogre::Real _sample_width, _sample_height; |
---|
| 603 | PlaneBoundedRegionGeometryPlaneListener* _listener; |
---|
| 604 | Ogre::Ray _ray; |
---|
| 605 | Ogre::RaySceneQuery* _ray_query; |
---|
| 606 | bool _centered; |
---|
| 607 | Ogre::Real _halfWorldSizeX; |
---|
| 608 | Ogre::Real _halfWorldSizeZ; |
---|
| 609 | size_t _num_query; |
---|
| 610 | |
---|
| 611 | std::list<Ogre::Plane> *_last_query_results; |
---|
| 612 | }; |
---|
| 613 | } |
---|
| 614 | |
---|
| 615 | #endif |
---|