source/gameengine/Ketsji/KX_GameObject.h

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): none yet.
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  * General KX game object.
  29  */
  30
  31 #ifndef __KX_GAMEOBJECT
  32 #define __KX_GAMEOBJECT
  33
  34 #ifdef WIN32
  35 // get rid of this stupid "warning 'this' used in initialiser list", generated by VC when including Solid/Sumo
  36 #pragma warning (disable : 4355)
  37 #endif
  38
  39
  40 #include "ListValue.h"
  41 #include "SCA_IObject.h"
  42 #include "SG_Node.h"
  43 #include "MT_Transform.h"
  44 #include "MT_CmMatrix4x4.h"
  45 #include "GEN_Map.h"
  46 #include "GEN_HashedPtr.h"
  47 #include "KX_Scene.h"
  48 #include "KX_KetsjiEngine.h" /* for m_anim_framerate */
  49 #include "KX_IPhysicsController.h" /* for suspend/resume */
  50 #include "DNA_object_types.h"
  51 #include "SCA_LogicManager.h" /* for ConvertPythonToGameObject to search object names */
  52 #define KX_OB_DYNAMIC 1
  53
  54
  55 //Forward declarations.
  56 struct KX_ClientObjectInfo;
  57 class KX_RayCast;
  58 class RAS_MeshObject;
  59 class KX_IPhysicsController;
  60 class PHY_IPhysicsEnvironment;
  61 struct Object;
  62
  63 /**
  64  * KX_GameObject is the main class for dynamic objects.
  65  */
  66 class KX_GameObject : public SCA_IObject
  67 {
  68         Py_Header;
  69 protected:
  70
  71         bool                                                            m_bDyna;
  72         KX_ClientObjectInfo*                            m_pClient_info;
  73         STR_String                                                      m_name;
  74         STR_String                                                      m_text;
  75         int                                                                     m_layer;
  76         std::vector<RAS_MeshObject*>            m_meshes;
  77         struct Object*                                          m_pBlenderObject;
  78         struct Object*                                          m_pBlenderGroupObject;
  79
  80         bool                                                            m_bSuspendDynamics;
  81         bool                                                            m_bUseObjectColor;
  82         bool                                                            m_bIsNegativeScaling;
  83         MT_Vector4                                                      m_objectColor;
  84
  85         // visible = user setting
  86         // culled = while rendering, depending on camera
  87         bool                                                            m_bVisible;
  88         bool                                                            m_bCulled;
  89
  90         KX_IPhysicsController*                          m_pPhysicsController1;
  91         // used for ray casting
  92         PHY_IPhysicsEnvironment*                        m_pPhysicsEnvironment;
  93         STR_String                                                      m_testPropName;
  94         bool                                                            m_xray;
  95         KX_GameObject*                                          m_pHitObject;
  96
  97         SG_Node*                                                        m_pSGNode;
  98
  99         MT_CmMatrix4x4                                          m_OpenGL_4x4Matrix;
 100
 101 public:
 102         bool                                                            m_isDeformable;
 103
 104         virtual void    /* This function should be virtual - derived classed override it */
 105         Relink(
 106                 GEN_Map<GEN_HashedPtr, void*> *map
 107         );
 108
 109         /**
 110          * Compute an OpenGl compatable 4x4 matrix. Has the
 111          * side effect of storing the result internally. The
 112          * memory for the matrix remains the property of this class.
 113          */
 114                 double*
 115         GetOpenGLMatrix(
 116         );
 117
 118         /**
 119          * Return a pointer to a MT_CmMatrix4x4 storing the
 120          * opengl transformation for this object. This is updated
 121          * by a call to GetOpenGLMatrix(). This class owns the
 122          * memory for the returned matrix.
 123          */
 124
 125                 MT_CmMatrix4x4*
 126         GetOpenGLMatrixPtr(
 127         ) {
 128                 return &m_OpenGL_4x4Matrix;
 129         };
 130
 131         /**
 132          * Get a pointer to the game object that is the parent of
 133          * this object. Or NULL if there is no parent. The returned
 134          * object is part of a reference counting scheme. Calling
 135          * this function ups the reference count on the returned
 136          * object. It is the responsibility of the caller to decrement
 137          * the reference count when you have finished with it.
 138          */
 139                 KX_GameObject*
 140         GetParent(
 141         );
 142
 143         /**
 144          * Sets the parent of this object to a game object
 145          */
 146         void SetParent(KX_Scene *scene, KX_GameObject *obj);
 147
 148         /**
 149          * Removes the parent of this object to a game object
 150          */
 151         void RemoveParent(KX_Scene *scene);
 152
 153         /**
 154          * Construct a game object. This class also inherits the
 155          * default constructors - use those with care!
 156          */
 157
 158         KX_GameObject(
 159                 void* sgReplicationInfo,
 160                 SG_Callbacks callbacks,
 161                 PyTypeObject* T=&Type
 162         );
 163
 164         virtual
 165         ~KX_GameObject(
 166         );
 167
 168                 CValue*
 169         AddRef() {
 170                 /* temporarily to find memleaks */ return CValue::AddRef();
 171         }
 172
 173         /**
 174          * @section Stuff which is here due to poor design.
 175          * Inherited from CValue and needs an implementation.
 176          * Do not expect these functions do to anything sensible.
 177          */
 178
 179         /**
 180          * Inherited from CValue -- does nothing!
 181          */
 182                 CValue*
 183         Calc(
 184                 VALUE_OPERATOR op,
 185                 CValue *val
 186         );
 187
 188         /**
 189          * Inherited from CValue -- does nothing!
 190          */
 191                 CValue*
 192         CalcFinal(
 193                 VALUE_DATA_TYPE dtype,
 194                 VALUE_OPERATOR op,
 195                 CValue *val
 196         );
 197
 198         /**
 199          * Inherited from CValue -- does nothing!
 200          */
 201         const
 202                 STR_String &
 203         GetText(
 204         );
 205
 206         /**
 207          * Inherited from CValue -- does nothing!
 208          */
 209                 float
 210         GetNumber(
 211         );
 212
 213         /**
 214          * @section Inherited from CValue. These are the useful
 215          * part of the CValue interface that this class implements.
 216          */
 217
 218         /**
 219          * Inherited from CValue -- returns the name of this object.
 220          */
 221                 STR_String
 222         GetName(
 223         );
 224
 225         /**
 226          * Inherited from CValue -- set the name of this object.
 227          */
 228                 void
 229         SetName(
 230                 STR_String name
 231         );
 232
 233         /**
 234          * Inherited from CValue -- does nothing.
 235          */
 236                 void
 237         ReplicaSetName(
 238                 STR_String name
 239         );
 240
 241         /**
 242          * Inherited from CValue -- return a new copy of this
 243          * instance allocated on the heap. Ownership of the new
 244          * object belongs with the caller.
 245          */
 246         virtual CValue*
 247         GetReplica(
 248         );
 249
 250         /**
 251          * Inherited from CValue -- Makes sure any internal
 252          * data owned by this class is deep copied. Called internally
 253          */
 254         virtual void
 255         ProcessReplica(
 256                 KX_GameObject* replica
 257         );
 258
 259         /**
 260          * Return the linear velocity of the game object.
 261          */
 262                 MT_Vector3
 263         GetLinearVelocity(
 264                 bool local=false
 265         );
 266
 267         /**
 268          * Return the mass of the object
 269          */
 270                 MT_Scalar
 271         GetMass();
 272
 273         /**
 274          * Return the angular velocity of the game object.
 275          */
 276                 MT_Vector3
 277         GetAngularVelocity(
 278                 bool local=false
 279         );
 280
 281         /**
 282          * Align the object to a given normal.
 283          */
 284                 void
 285         AlignAxisToVect(
 286                 const MT_Vector3& vect,
 287                 int axis = 2,
 288                 float fac = 1.0
 289         );
 290
 291         /**
 292          * Quick'n'dirty obcolor ipo stuff
 293          */
 294
 295                 void
 296         SetObjectColor(
 297                 const MT_Vector4& rgbavec
 298         );
 299
 300
 301                 void
 302         ResolveCombinedVelocities(
 303                 const MT_Vector3 & lin_vel,
 304                 const MT_Vector3 & ang_vel,
 305                 bool lin_vel_local,
 306                 bool ang_vel_local
 307         );
 308
 309
 310         /**
 311          * @return a pointer to the physics environment in use during the game, for rayCasting
 312          */
 313         PHY_IPhysicsEnvironment* GetPhysicsEnvironment()
 314         {
 315                 return m_pPhysicsEnvironment;
 316         }
 317
 318         void SetPhysicsEnvironment(PHY_IPhysicsEnvironment* physicsEnvironment)
 319         {
 320                 m_pPhysicsEnvironment = physicsEnvironment;
 321         }
 322
 323         /**
 324          * @return a pointer to the physics controller owned by this class.
 325          */
 326
 327         KX_IPhysicsController* GetPhysicsController() ;
 328
 329         void    SetPhysicsController(KX_IPhysicsController*     physicscontroller,bool isDynamic)
 330         {
 331                 m_bDyna = isDynamic;
 332                 m_pPhysicsController1 = physicscontroller;
 333         }
 334
 335
 336         /**
 337          * @section Coordinate system manipulation functions
 338          */
 339
 340         void    NodeSetLocalPosition(const MT_Point3& trans     );
 341
 342         void    NodeSetLocalOrientation(const MT_Matrix3x3& rot );
 343
 344         void    NodeSetLocalScale(      const MT_Vector3& scale );
 345
 346         void    NodeSetRelativeScale(   const MT_Vector3& scale );
 347
 348         // adapt local position so that world position is set to desired position
 349         void    NodeSetWorldPosition(const MT_Point3& trans);
 350
 351                 void
 352         NodeUpdateGS(
 353                 double time,
 354                 bool bInitiator
 355         );
 356
 357         const
 358                 MT_Matrix3x3&
 359         NodeGetWorldOrientation(
 360         ) const;
 361
 362         const
 363                 MT_Vector3&
 364         NodeGetWorldScaling(
 365         ) const;
 366
 367         const
 368                 MT_Point3&
 369         NodeGetWorldPosition(
 370         ) const;
 371
 372
 373         /**
 374          * @section scene graph node accessor functions.
 375          */
 376
 377         SG_Node*        GetSGNode(      )
 378         {
 379                 return m_pSGNode;
 380         }
 381
 382         const   SG_Node* GetSGNode(     ) const
 383         {
 384                 return m_pSGNode;
 385         }
 386
 387         /**
 388          * @section blender object accessor functions.
 389          */
 390
 391         struct Object* GetBlenderObject( )
 392         {
 393                 return m_pBlenderObject;
 394         }
 395
 396         void SetBlenderObject( struct Object* obj)
 397         {
 398                 m_pBlenderObject = obj;
 399         }
 400
 401         struct Object* GetBlenderGroupObject( )
 402         {
 403                 return m_pBlenderGroupObject;
 404         }
 405
 406         void SetBlenderGroupObject( struct Object* obj)
 407         {
 408                 m_pBlenderGroupObject = obj;
 409         }
 410
 411         bool IsDupliGroup()
 412         {
 413                 return (m_pBlenderObject &&
 414                                 (m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
 415                                 m_pBlenderObject->dup_group != NULL) ? true : false;
 416         }
 417
 418         /**
 419          * Set the Scene graph node for this game object.
 420          * warning - it is your responsibility to make sure
 421          * all controllers look at this new node. You must
 422          * also take care of the memory associated with the
 423          * old node. This class takes ownership of the new
 424          * node.
 425          */
 426                 void    SetSGNode(SG_Node* node )
 427                 {
 428                         m_pSGNode = node;
 429                 }
 430
 431         //Is it a dynamic/physics object ?
 432         bool    IsDynamic() const
 433         {
 434                 return m_bDyna;
 435         }
 436
 437         /**
 438          * Check if this object has a vertex parent relationship
 439          */
 440         bool IsVertexParent( )
 441         {
 442                 return (m_pSGNode && m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsVertexParent());
 443         }
 444
 445         bool RayHit(KX_ClientObjectInfo* client, KX_RayCast* result, void * const data);
 446         bool NeedRayCast(KX_ClientObjectInfo* client);
 447
 448
 449         /**
 450          * @section Physics accessors for this node.
 451          *
 452          * All these calls get passed directly to the physics controller
 453          * owned by this object.
 454          * This is real interface bloat. Why not just use the physics controller
 455          * directly? I think this is because the python interface is in the wrong
 456          * place.
 457          */
 458
 459                 void
 460         ApplyForce(
 461                 const MT_Vector3& force,        bool local
 462         );
 463
 464                 void
 465         ApplyTorque(
 466                 const MT_Vector3& torque,
 467                 bool local
 468         );
 469
 470                 void
 471         ApplyRotation(
 472                 const MT_Vector3& drot,
 473                 bool local
 474         );
 475
 476                 void
 477         ApplyMovement(
 478                 const MT_Vector3& dloc,
 479                 bool local
 480         );
 481
 482                 void
 483         addLinearVelocity(
 484                 const MT_Vector3& lin_vel,
 485                 bool local
 486         );
 487
 488                 void
 489         setLinearVelocity(
 490                 const MT_Vector3& lin_vel,
 491                 bool local
 492         );
 493
 494                 void
 495         setAngularVelocity(
 496                 const MT_Vector3& ang_vel,
 497                 bool local
 498         );
 499
 500         /**
 501          * Update the physics object transform based upon the current SG_Node
 502          * position.
 503          */
 504                 void
 505         UpdateTransform(
 506         );
 507
 508         static void UpdateTransformFunc(SG_IObject* node, void* gameobj, void* scene);
 509
 510         /**
 511          * Only update the transform if it's a non-dynamic object
 512          */
 513                 void
 514         UpdateNonDynas(
 515         );
 516
 517         /**
 518          * Function to set IPO option at start of IPO
 519          */
 520                 void
 521         InitIPO(
 522                 bool ipo_as_force,
 523                 bool ipo_add,
 524                 bool ipo_local
 525         );
 526
 527         /**
 528          * Odd function to update an ipo. ???
 529          */
 530                 void
 531         UpdateIPO(
 532                 float curframetime,
 533                 bool recurse
 534         );
 535         /**
 536          * Updates Material Ipo data
 537          */
 538                 void
 539         UpdateMaterialData(
 540                 dword matname_hash,
 541                 MT_Vector4 rgba,
 542                 MT_Vector3 specrgb,
 543                 MT_Scalar hard,
 544                 MT_Scalar spec,
 545                 MT_Scalar ref,
 546                 MT_Scalar emit,
 547                 MT_Scalar alpha
 548         );
 549
 550         /**
 551          * @section Mesh accessor functions.
 552          */
 553
 554         /**
 555          * Update buckets to indicate that there is a new
 556          * user of this object's meshes.
 557          */
 558                 void
 559         AddMeshUser(
 560         );
 561
 562         /**
 563          * Update buckets with data about the mesh after
 564          * creating or duplicating the object, changing
 565          * visibility, object color, .. .
 566          */
 567                 void
 568         UpdateBuckets(
 569                 bool recursive
 570         );
 571
 572         /**
 573          * Clear the meshes associated with this class
 574          * and remove from the bucketing system.
 575          * Don't think this actually deletes any of the meshes.
 576          */
 577                 void
 578         RemoveMeshes(
 579         );
 580
 581         /**
 582          * Add a mesh to the set of meshes associated with this
 583          * node. Meshes added in this way are not deleted by this class.
 584          * Make sure you call RemoveMeshes() before deleting the
 585          * mesh though,
 586          */
 587                 void
 588         AddMesh(
 589                 RAS_MeshObject* mesh
 590         ){
 591                 m_meshes.push_back(mesh);
 592         }
 593
 594         /**
 595          * Pick out a mesh associated with the integer 'num'.
 596          */
 597                 RAS_MeshObject*
 598         GetMesh(
 599                 int num
 600         ) const {
 601                 return m_meshes[num];
 602         }
 603
 604         /**
 605          * Return the number of meshes currently associated with this
 606          * game object.
 607          */
 608                 int
 609         GetMeshCount(
 610         ) const {
 611                 return m_meshes.size();
 612         }
 613
 614         /**
 615          * Set the debug color of the meshes associated with this
 616          * class. Does this still work?
 617          */
 618                 void
 619         SetDebugColor(
 620                 unsigned int bgra
 621         );
 622
 623         /**
 624          * Reset the debug color of meshes associated with this class.
 625          */
 626                 void
 627         ResetDebugColor(
 628         );
 629
 630         /**
 631          * Was this object marked visible? (only for the explicit
 632          * visibility system).
 633          */
 634                 bool
 635         GetVisible(
 636                 void
 637         );
 638
 639         /**
 640          * Set visibility flag of this object
 641          */
 642                 void
 643         SetVisible(
 644                 bool b,
 645                 bool recursive
 646         );
 647
 648         /**
 649          * Was this object culled?
 650          */
 651                 bool
 652         GetCulled(
 653                 void
 654         );
 655
 656         /**
 657          * Set culled flag of this object
 658          */
 659                 void
 660         SetCulled(
 661                 bool c
 662         );
 663
 664         /**
 665          * Change the layer of the object (when it is added in another layer
 666          * than the original layer)
 667          */
 668                 void
 669         SetLayer(
 670                 int l
 671         );
 672
 673         /**
 674          * Get the object layer
 675          */
 676                 int
 677         GetLayer(
 678                 void
 679         );
 680
 681         /**
 682          * Get the negative scaling state
 683          */
 684                 bool
 685         IsNegativeScaling(
 686                 void
 687         ) { return m_bIsNegativeScaling; }
 688
 689         /**
 690          * Is this a light?
 691          */
 692                 virtual bool
 693         IsLight(
 694                 void
 695         ) { return false; }
 696
 697         /**
 698          * @section Logic bubbling methods.
 699          */
 700
 701         /**
 702          * Stop making progress
 703          */
 704         void Suspend(void);
 705
 706         /**
 707          * Resume making progress
 708          */
 709         void Resume(void);
 710
 711         void SuspendDynamics(void) {
 712                 if (m_bSuspendDynamics)
 713                 {
 714                         return;
 715                 }
 716
 717                 if (m_pPhysicsController1)
 718                 {
 719                         m_pPhysicsController1->SuspendDynamics();
 720                 }
 721                 m_bSuspendDynamics = true;
 722         }
 723
 724         void RestoreDynamics(void) {
 725                 if (!m_bSuspendDynamics)
 726                 {
 727                         return;
 728                 }
 729
 730                 if (m_pPhysicsController1)
 731                 {
 732                         m_pPhysicsController1->RestoreDynamics();
 733                 }
 734                 m_bSuspendDynamics = false;
 735         }
 736
 737         KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
 738         /**
 739          * @section Python interface functions.
 740          */
 741
 742         virtual
 743                 PyObject*
 744         _getattr(
 745                 const STR_String& attr
 746         );
 747
 748         virtual
 749                 int
 750         _setattr(
 751                 const STR_String& attr,
 752                 PyObject *value
 753         );              // _setattr method
 754
 755         KX_PYMETHOD_NOARGS(KX_GameObject,GetPosition);
 756         KX_PYMETHOD_O(KX_GameObject,SetPosition);
 757         KX_PYMETHOD_O(KX_GameObject,SetWorldPosition);
 758         KX_PYMETHOD_VARARGS(KX_GameObject,GetLinearVelocity);
 759         KX_PYMETHOD_VARARGS(KX_GameObject,SetLinearVelocity);
 760         KX_PYMETHOD_VARARGS(KX_GameObject,GetAngularVelocity);
 761         KX_PYMETHOD_VARARGS(KX_GameObject,SetAngularVelocity);
 762         KX_PYMETHOD_VARARGS(KX_GameObject,GetVelocity);
 763         KX_PYMETHOD_NOARGS(KX_GameObject,GetMass);
 764         KX_PYMETHOD_NOARGS(KX_GameObject,GetReactionForce);
 765         KX_PYMETHOD_NOARGS(KX_GameObject,GetOrientation);
 766         KX_PYMETHOD_O(KX_GameObject,SetOrientation);
 767         KX_PYMETHOD_NOARGS(KX_GameObject,GetVisible);
 768         KX_PYMETHOD_VARARGS(KX_GameObject,SetVisible);
 769         KX_PYMETHOD_NOARGS(KX_GameObject,GetState);
 770         KX_PYMETHOD_O(KX_GameObject,SetState);
 771         KX_PYMETHOD_VARARGS(KX_GameObject,AlignAxisToVect);
 772         KX_PYMETHOD_O(KX_GameObject,GetAxisVect);
 773         KX_PYMETHOD_NOARGS(KX_GameObject,SuspendDynamics);
 774         KX_PYMETHOD_NOARGS(KX_GameObject,RestoreDynamics);
 775         KX_PYMETHOD_NOARGS(KX_GameObject,EnableRigidBody);
 776         KX_PYMETHOD_NOARGS(KX_GameObject,DisableRigidBody);
 777         KX_PYMETHOD_VARARGS(KX_GameObject,ApplyImpulse);
 778         KX_PYMETHOD_O(KX_GameObject,SetCollisionMargin);
 779         KX_PYMETHOD_NOARGS(KX_GameObject,GetParent);
 780         KX_PYMETHOD_O(KX_GameObject,SetParent);
 781         KX_PYMETHOD_NOARGS(KX_GameObject,RemoveParent);
 782         KX_PYMETHOD_NOARGS(KX_GameObject,GetChildren);
 783         KX_PYMETHOD_NOARGS(KX_GameObject,GetChildrenRecursive);
 784         KX_PYMETHOD_VARARGS(KX_GameObject,GetMesh);
 785         KX_PYMETHOD_NOARGS(KX_GameObject,GetPhysicsId);
 786         KX_PYMETHOD_NOARGS(KX_GameObject,GetPropertyNames);
 787         KX_PYMETHOD_NOARGS(KX_GameObject,EndObject);
 788         KX_PYMETHOD_DOC(KX_GameObject,rayCastTo);
 789         KX_PYMETHOD_DOC(KX_GameObject,rayCast);
 790         KX_PYMETHOD_DOC(KX_GameObject,getDistanceTo);
 791         KX_PYMETHOD_DOC(KX_GameObject,getVectTo);
 792
 793 private :
 794
 795         /**
 796          * Random internal function to convert python function arguments
 797          * to 2 vectors.
 798          * @return true if conversion was possible.
 799          */
 800
 801                 bool
 802         ConvertPythonVectorArgs(
 803                 PyObject* args,
 804                 MT_Vector3& pos,
 805                 MT_Vector3& pos2
 806         );
 807
 808 };
 809
 810 /* utility conversion function */
 811 bool ConvertPythonToGameObject(PyObject * value, KX_GameObject **object, bool py_none_ok);
 812
 813 #endif //__KX_GAMEOBJECT
 814