2002-10-12 11:37:38 +00:00
|
|
|
/*
|
|
|
|
* $Id$
|
|
|
|
*
|
2008-04-16 22:40:48 +00:00
|
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
2002-10-12 11:37:38 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
2008-04-16 22:40:48 +00:00
|
|
|
* of the License, or (at your option) any later version.
|
2002-10-12 11:37:38 +00:00
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*
|
|
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* The Original Code is: all of this file.
|
|
|
|
*
|
|
|
|
* Contributor(s): none yet.
|
|
|
|
*
|
2008-04-16 22:40:48 +00:00
|
|
|
* ***** END GPL LICENSE BLOCK *****
|
2002-10-12 11:37:38 +00:00
|
|
|
* General KX game object.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __KX_GAMEOBJECT
|
|
|
|
#define __KX_GAMEOBJECT
|
|
|
|
|
|
|
|
#ifdef WIN32
|
|
|
|
// get rid of this stupid "warning 'this' used in initialiser list", generated by VC when including Solid/Sumo
|
|
|
|
#pragma warning (disable : 4355)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#include "ListValue.h"
|
|
|
|
#include "SCA_IObject.h"
|
|
|
|
#include "SG_Node.h"
|
|
|
|
#include "MT_Transform.h"
|
|
|
|
#include "MT_CmMatrix4x4.h"
|
|
|
|
#include "GEN_Map.h"
|
|
|
|
#include "GEN_HashedPtr.h"
|
2008-04-06 18:30:52 +00:00
|
|
|
#include "KX_Scene.h"
|
2008-06-17 10:06:38 +00:00
|
|
|
#include "KX_KetsjiEngine.h" /* for m_anim_framerate */
|
2008-06-25 14:09:15 +00:00
|
|
|
#include "KX_IPhysicsController.h" /* for suspend/resume */
|
2008-07-15 20:05:23 +00:00
|
|
|
#include "DNA_object_types.h"
|
2008-08-14 08:58:25 +00:00
|
|
|
#include "SCA_LogicManager.h" /* for ConvertPythonToGameObject to search object names */
|
2002-10-12 11:37:38 +00:00
|
|
|
#define KX_OB_DYNAMIC 1
|
|
|
|
|
|
|
|
|
|
|
|
//Forward declarations.
|
|
|
|
struct KX_ClientObjectInfo;
|
|
|
|
class RAS_MeshObject;
|
|
|
|
class KX_IPhysicsController;
|
2008-03-15 17:08:58 +00:00
|
|
|
class PHY_IPhysicsEnvironment;
|
2008-06-18 06:46:49 +00:00
|
|
|
struct Object;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2004-04-24 06:40:15 +00:00
|
|
|
/**
|
|
|
|
* KX_GameObject is the main class for dynamic objects.
|
|
|
|
*/
|
2002-10-12 11:37:38 +00:00
|
|
|
class KX_GameObject : public SCA_IObject
|
|
|
|
{
|
|
|
|
Py_Header;
|
2004-05-16 12:52:54 +00:00
|
|
|
protected:
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2004-04-24 06:40:15 +00:00
|
|
|
bool m_bDyna;
|
|
|
|
KX_ClientObjectInfo* m_pClient_info;
|
|
|
|
STR_String m_name;
|
|
|
|
STR_String m_text;
|
2008-04-30 19:58:44 +00:00
|
|
|
int m_layer;
|
2002-10-12 11:37:38 +00:00
|
|
|
std::vector<RAS_MeshObject*> m_meshes;
|
2008-06-18 06:46:49 +00:00
|
|
|
struct Object* m_pBlenderObject;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2004-04-24 06:40:15 +00:00
|
|
|
bool m_bSuspendDynamics;
|
|
|
|
bool m_bUseObjectColor;
|
2008-05-25 14:37:39 +00:00
|
|
|
bool m_bIsNegativeScaling;
|
2004-04-24 06:40:15 +00:00
|
|
|
MT_Vector4 m_objectColor;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
// Is this object set to be visible? Only useful for the
|
|
|
|
// visibility subsystem right now.
|
2004-04-24 06:40:15 +00:00
|
|
|
bool m_bVisible;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2004-04-24 06:40:15 +00:00
|
|
|
KX_IPhysicsController* m_pPhysicsController1;
|
2008-03-15 17:08:58 +00:00
|
|
|
// used for ray casting
|
|
|
|
PHY_IPhysicsEnvironment* m_pPhysicsEnvironment;
|
|
|
|
STR_String m_testPropName;
|
|
|
|
KX_GameObject* m_pHitObject;
|
|
|
|
|
2004-04-24 06:40:15 +00:00
|
|
|
SG_Node* m_pSGNode;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2004-04-24 06:40:15 +00:00
|
|
|
MT_CmMatrix4x4 m_OpenGL_4x4Matrix;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
public:
|
Patch: [ #2439 ] Makes objects react properly to deformations after a mesh replacement call.
from brian hayward (bthayward)
Detailed description:
Currently, when an armature deformed object's mesh is replaced by the ReplaceMesh actuator, the new mesh fails to deform to the armature's movement.
My patch fixes this by properly replacing the deform controller along with the mesh (when appropriete).
For instance, if one had an animated character using any of the standard deformation techniques (armature, ipo, RVK, or AVK), that character's mesh would currently be prevented from changing mid-game. It could be replaced, but the new mesh would lack the controller which tells it how to deform. If one wanted to dynamiclly add a hat on top of the character's head, it would require storing a secondary prebuilt character (mesh, armature, logic, ect...) on another layer FOR EACH HAT the character could possibly wear, then swapping out the whole character when the hat change was desired. So if you had 4 possible hat/character combos, you would have 4 character meshes, 4 armatures, 4 sets of logic, and so on. I find this lack of flexibility to be unresonable.
With my patch, one could accomplish the same thing mearly by making one version of the character in the main layer, and adding an invisible object atop the character's head (which is parented to the head bone). Then whenever it becomes desirable, one can replace the invisible object's mesh with the desirable hat's mesh, then make it visible. With my patch, the hat object would then continue to deform to the character's head regardless of which hat was currently being worn.
*note 1*
for armature/mesh deformations, the new mesh must have properly assigned vertex groups which match one or more of the bones of the target armature before the replaceMesh call is made. Otherwise the vertices won't react to the armature because they won't know how. (not sure if vertices can be scripted to change groups after the game has started)
*note 2*
The added processing time involved with replacing the object's deform controller is negligible.
2005-04-18 11:44:21 +00:00
|
|
|
bool m_isDeformable;
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
virtual void /* This function should be virtual - derived classed override it */
|
|
|
|
Relink(
|
|
|
|
GEN_Map<GEN_HashedPtr, void*> *map
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Compute an OpenGl compatable 4x4 matrix. Has the
|
|
|
|
* side effect of storing the result internally. The
|
|
|
|
* memory for the matrix remains the property of this class.
|
|
|
|
*/
|
|
|
|
double*
|
|
|
|
GetOpenGLMatrix(
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return a pointer to a MT_CmMatrix4x4 storing the
|
|
|
|
* opengl transformation for this object. This is updated
|
|
|
|
* by a call to GetOpenGLMatrix(). This class owns the
|
|
|
|
* memory for the returned matrix.
|
|
|
|
*/
|
|
|
|
|
|
|
|
MT_CmMatrix4x4*
|
|
|
|
GetOpenGLMatrixPtr(
|
|
|
|
) {
|
|
|
|
return &m_OpenGL_4x4Matrix;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a pointer to the game object that is the parent of
|
|
|
|
* this object. Or NULL if there is no parent. The returned
|
|
|
|
* object is part of a reference counting scheme. Calling
|
|
|
|
* this function ups the reference count on the returned
|
|
|
|
* object. It is the responsibility of the caller to decrement
|
|
|
|
* the reference count when you have finished with it.
|
|
|
|
*/
|
|
|
|
KX_GameObject*
|
|
|
|
GetParent(
|
|
|
|
);
|
|
|
|
|
2008-04-06 18:30:52 +00:00
|
|
|
/**
|
|
|
|
* Sets the parent of this object to a game object
|
|
|
|
*/
|
|
|
|
void SetParent(KX_Scene *scene, KX_GameObject *obj);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes the parent of this object to a game object
|
|
|
|
*/
|
|
|
|
void RemoveParent(KX_Scene *scene);
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Construct a game object. This class also inherits the
|
|
|
|
* default constructors - use those with care!
|
|
|
|
*/
|
|
|
|
|
|
|
|
KX_GameObject(
|
|
|
|
void* sgReplicationInfo,
|
|
|
|
SG_Callbacks callbacks,
|
|
|
|
PyTypeObject* T=&Type
|
|
|
|
);
|
|
|
|
|
|
|
|
virtual
|
|
|
|
~KX_GameObject(
|
|
|
|
);
|
|
|
|
|
|
|
|
CValue*
|
|
|
|
AddRef() {
|
|
|
|
/* temporarily to find memleaks */ return CValue::AddRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @section Stuff which is here due to poor design.
|
|
|
|
* Inherited from CValue and needs an implementation.
|
|
|
|
* Do not expect these functions do to anything sensible.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- does nothing!
|
|
|
|
*/
|
|
|
|
CValue*
|
|
|
|
Calc(
|
|
|
|
VALUE_OPERATOR op,
|
|
|
|
CValue *val
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- does nothing!
|
|
|
|
*/
|
|
|
|
CValue*
|
|
|
|
CalcFinal(
|
|
|
|
VALUE_DATA_TYPE dtype,
|
|
|
|
VALUE_OPERATOR op,
|
|
|
|
CValue *val
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- does nothing!
|
|
|
|
*/
|
|
|
|
const
|
|
|
|
STR_String &
|
|
|
|
GetText(
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- does nothing!
|
|
|
|
*/
|
|
|
|
float
|
|
|
|
GetNumber(
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @section Inherited from CValue. These are the useful
|
|
|
|
* part of the CValue interface that this class implements.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- returns the name of this object.
|
|
|
|
*/
|
|
|
|
STR_String
|
|
|
|
GetName(
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- set the name of this object.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
SetName(
|
|
|
|
STR_String name
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- does nothing.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicaSetName(
|
|
|
|
STR_String name
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- return a new copy of this
|
|
|
|
* instance allocated on the heap. Ownership of the new
|
|
|
|
* object belongs with the caller.
|
|
|
|
*/
|
2004-03-22 22:02:18 +00:00
|
|
|
virtual CValue*
|
2002-10-12 11:37:38 +00:00
|
|
|
GetReplica(
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Inherited from CValue -- Makes sure any internal
|
|
|
|
* data owned by this class is deep copied. Called internally
|
|
|
|
*/
|
2004-03-22 22:02:18 +00:00
|
|
|
virtual void
|
2002-10-12 11:37:38 +00:00
|
|
|
ProcessReplica(
|
|
|
|
KX_GameObject* replica
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the linear velocity of the game object.
|
|
|
|
*/
|
2008-05-06 20:55:55 +00:00
|
|
|
MT_Vector3
|
2002-10-12 11:37:38 +00:00
|
|
|
GetLinearVelocity(
|
2008-05-06 20:55:55 +00:00
|
|
|
bool local=false
|
2002-10-12 11:37:38 +00:00
|
|
|
);
|
|
|
|
|
BGE logic update: new servo control motion actuator, new distance constraint actuator, new orientation constraint actuator, new actuator sensor.
General
=======
- Removal of Damp option in motion actuator (replaced by
Servo control motion).
- No PyDoc at present, will be added soon.
Generalization of the Lvl option
================================
A sensor with the Lvl option selected will always produce an
event at the start of the game or when entering a state or at
object creation. The event will be positive or negative
depending of the sensor condition. A negative pulse makes
sense when used with a NAND controller: it will be converted
into an actuator activation.
Servo control motion
====================
A new variant of the motion actuator allows to control speed
with force. The control if of type "PID" (Propotional, Integral,
Derivate): the force is automatically adapted to achieve the
target speed. All the parameters of the servo controller are
configurable. The result is a great variety of motion style:
anysotropic friction, flying, sliding, pseudo Dloc...
This actuator should be used in preference to Dloc and LinV
as it produces more fluid movements and avoids the collision
problem with Dloc.
LinV : target speed as (X,Y,Z) vector in local or world
coordinates (mostly useful in local coordinates).
Limit: the force can be limited along each axis (in the same
coordinates of LinV). No limitation means that the force
will grow as large as necessary to achieve the target
speed along that axis. Set a max value to limit the
accelaration along an axis (slow start) and set a min
value (negative) to limit the brake force.
P: Proportional coefficient of servo controller, don't set
directly unless you know what you're doing.
I: Integral coefficient of servo controller. Use low value
(<0.1) for slow reaction (sliding), high values (>0.5)
for hard control. The P coefficient will be automatically
set to 60 times the I coefficient (a reasonable value).
D: Derivate coefficient. Leave to 0 unless you know what
you're doing. High values create instability.
Notes: - This actuator works perfectly in zero friction
environment: the PID controller will simulate friction
by applying force as needed.
- This actuator is compatible with simple Drot motion
actuator but not with LinV and Dloc motion.
- (0,0,0) is a valid target speed.
- All parameters are accessible through Python.
Distance constraint actuator
============================
A new variant of the constraint actuator allows to set the
distance and orientation relative to a surface. The controller
uses a ray to detect the surface (or any object) and adapt the
distance and orientation parallel to the surface.
Damp: Time constant (in nb of frames) of distance and
orientation control.
Dist: Select to enable distance control and set target
distance. The object will be position at the given
distance of surface along the ray direction.
Direction: chose a local axis as the ray direction.
Range: length of ray. Objecgt within this distance will be
detected.
N : Select to enable orientation control. The actuator will
change the orientation and the location of the object
so that it is parallel to the surface at the vertical
of the point of contact of the ray.
M/P : Select to enable material detection. Default is property
detection.
Property/Material: name of property/material that the target of
ray must have to be detected. If not set, property/
material filter is disabled and any collisioning object
within range will be detected.
PER : Select to enable persistent operation. Normally the
actuator disables itself automatically if the ray does
not reach a valid target.
time : Maximum activation time of actuator.
0 : unlimited.
>0: number of frames before automatic deactivation.
rotDamp: Time constant (in nb of frame) of orientation control.
0 : use Damp parameter.
>0: use a different time constant for orientation.
Notes: - If neither N nor Dist options are set, the actuator
does not change the position and orientation of the
object; it works as a ray sensor.
- The ray has no "X-ray" capability: if the first object
hit does not have the required property/material, it
returns no hit and the actuator disables itself unless
PER option is enabled.
- This actuator changes the position and orientation but
not the speed of the object. This has an important
implication in a gravity environment: the gravity will
cause the speed to increase although the object seems
to stay still (it is repositioned at each frame).
The gravity must be compensated in one way or another.
the new servo control motion actuator is the simplest
way: set the target speed along the ray axis to 0
and the servo control will automatically compensate
the gravity.
- This actuator changes the orientation of the object
and will conflict with Drot motion unless it is
placed BEFORE the Drot motion actuator (the order of
actuator is important)
- All parameters are accessible through Python.
Orientation constraint
======================
A new variant of the constraint actuator allows to align an
object axis along a global direction.
Damp : Time constant (in nb of frames) of orientation control.
X,Y,Z: Global coordinates of reference direction.
time : Maximum activation time of actuator.
0 : unlimited.
>0: number of frames before automatic deactivation.
Notes: - (X,Y,Z) = (0,0,0) is not a valid direction
- This actuator changes the orientation of the object
and will conflict with Drot motion unless it is placed
BEFORE the Drot motion actuator (the order of
actuator is important).
- This actuator doesn't change the location and speed.
It is compatible with gravity.
- All parameters are accessible through Python.
Actuator sensor
===============
This sensor detects the activation and deactivation of actuators
of the same object. The sensor generates a positive pulse when
the corresponding sensor is activated and a negative pulse when
it is deactivated (the contrary if the Inv option is selected).
This is mostly useful to chain actions and to detect the loss of
contact of the distance motion actuator.
Notes: - Actuators are disabled at the start of the game; if you
want to detect the On-Off transition of an actuator
after it has been activated at least once, unselect the
Lvl and Inv options and use a NAND controller.
- Some actuators deactivates themselves immediately after
being activated. The sensor detects this situation as
an On-Off transition.
- The actuator name can be set through Python.
2008-07-04 08:14:50 +00:00
|
|
|
/**
|
|
|
|
* Return the mass of the object
|
|
|
|
*/
|
|
|
|
MT_Scalar
|
|
|
|
GetMass();
|
|
|
|
|
2008-06-24 19:37:43 +00:00
|
|
|
/**
|
|
|
|
* Return the angular velocity of the game object.
|
|
|
|
*/
|
|
|
|
MT_Vector3
|
|
|
|
GetAngularVelocity(
|
|
|
|
bool local=false
|
|
|
|
);
|
|
|
|
|
2008-06-02 17:31:05 +00:00
|
|
|
/**
|
|
|
|
* Align the object to a given normal.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
AlignAxisToVect(
|
|
|
|
const MT_Vector3& vect,
|
added a factor argument for aligning to vector, this isn't correct since it does linear interpolation of the vector and renormalizes.
(can be improved to rotate correctly but for our use ist ok for now, would also be useful to have an argument to clamp the maximum rotation angle to get a constant rotation speed),
This will used to make franky upright when falling from an angle, to track to a surface when hanging onto a ledge and setting the glide pitch.
Without this rotation is instant and jerky.
currently this is done with Mathutils which isnt available in Blender Player.
def do_rotate_up(own):
own.alignAxisToVect([0,0,1], 2, 0.1)
replaces...
def do_rotate_up(own):
up_nor = Vector(0,0,1)
own_mat = Matrix(*own.getOrientation()).transpose()
own_up = up_nor * own_mat
ang = AngleBetweenVecs(own_up, up_nor)
if ang > 0.005:
# Set orientation
cross = CrossVecs(own_up, up_nor)
new_mat = own_mat * RotationMatrix(ang*0.1, 3, 'r', cross)
own.setOrientation(new_mat.transpose())
M source/gameengine/Ketsji/KX_GameObject.cpp
M source/gameengine/Ketsji/KX_GameObject.h
2008-07-09 09:21:52 +00:00
|
|
|
int axis = 2,
|
|
|
|
float fac = 1.0
|
2008-06-02 17:31:05 +00:00
|
|
|
);
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
/**
|
|
|
|
* Quick'n'dirty obcolor ipo stuff
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
SetObjectColor(
|
|
|
|
const MT_Vector4& rgbavec
|
|
|
|
);
|
|
|
|
|
|
|
|
|
2004-04-08 11:34:50 +00:00
|
|
|
void
|
|
|
|
ResolveCombinedVelocities(
|
|
|
|
const MT_Vector3 & lin_vel,
|
|
|
|
const MT_Vector3 & ang_vel,
|
|
|
|
bool lin_vel_local,
|
|
|
|
bool ang_vel_local
|
|
|
|
);
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
|
2008-03-15 17:08:58 +00:00
|
|
|
/**
|
|
|
|
* @return a pointer to the physics environment in use during the game, for rayCasting
|
|
|
|
*/
|
|
|
|
PHY_IPhysicsEnvironment* GetPhysicsEnvironment()
|
|
|
|
{
|
|
|
|
return m_pPhysicsEnvironment;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetPhysicsEnvironment(PHY_IPhysicsEnvironment* physicsEnvironment)
|
|
|
|
{
|
|
|
|
m_pPhysicsEnvironment = physicsEnvironment;
|
|
|
|
}
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
/**
|
|
|
|
* @return a pointer to the physics controller owned by this class.
|
|
|
|
*/
|
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
KX_IPhysicsController* GetPhysicsController() ;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
void SetPhysicsController(KX_IPhysicsController* physicscontroller,bool isDynamic)
|
|
|
|
{
|
|
|
|
m_bDyna = isDynamic;
|
|
|
|
m_pPhysicsController1 = physicscontroller;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @section Coordinate system manipulation functions
|
|
|
|
*/
|
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
void NodeSetLocalPosition(const MT_Point3& trans );
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
void NodeSetLocalOrientation(const MT_Matrix3x3& rot );
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
void NodeSetLocalScale( const MT_Vector3& scale );
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
void NodeSetRelativeScale( const MT_Vector3& scale );
|
2002-10-12 11:37:38 +00:00
|
|
|
|
BGE logic update: new servo control motion actuator, new distance constraint actuator, new orientation constraint actuator, new actuator sensor.
General
=======
- Removal of Damp option in motion actuator (replaced by
Servo control motion).
- No PyDoc at present, will be added soon.
Generalization of the Lvl option
================================
A sensor with the Lvl option selected will always produce an
event at the start of the game or when entering a state or at
object creation. The event will be positive or negative
depending of the sensor condition. A negative pulse makes
sense when used with a NAND controller: it will be converted
into an actuator activation.
Servo control motion
====================
A new variant of the motion actuator allows to control speed
with force. The control if of type "PID" (Propotional, Integral,
Derivate): the force is automatically adapted to achieve the
target speed. All the parameters of the servo controller are
configurable. The result is a great variety of motion style:
anysotropic friction, flying, sliding, pseudo Dloc...
This actuator should be used in preference to Dloc and LinV
as it produces more fluid movements and avoids the collision
problem with Dloc.
LinV : target speed as (X,Y,Z) vector in local or world
coordinates (mostly useful in local coordinates).
Limit: the force can be limited along each axis (in the same
coordinates of LinV). No limitation means that the force
will grow as large as necessary to achieve the target
speed along that axis. Set a max value to limit the
accelaration along an axis (slow start) and set a min
value (negative) to limit the brake force.
P: Proportional coefficient of servo controller, don't set
directly unless you know what you're doing.
I: Integral coefficient of servo controller. Use low value
(<0.1) for slow reaction (sliding), high values (>0.5)
for hard control. The P coefficient will be automatically
set to 60 times the I coefficient (a reasonable value).
D: Derivate coefficient. Leave to 0 unless you know what
you're doing. High values create instability.
Notes: - This actuator works perfectly in zero friction
environment: the PID controller will simulate friction
by applying force as needed.
- This actuator is compatible with simple Drot motion
actuator but not with LinV and Dloc motion.
- (0,0,0) is a valid target speed.
- All parameters are accessible through Python.
Distance constraint actuator
============================
A new variant of the constraint actuator allows to set the
distance and orientation relative to a surface. The controller
uses a ray to detect the surface (or any object) and adapt the
distance and orientation parallel to the surface.
Damp: Time constant (in nb of frames) of distance and
orientation control.
Dist: Select to enable distance control and set target
distance. The object will be position at the given
distance of surface along the ray direction.
Direction: chose a local axis as the ray direction.
Range: length of ray. Objecgt within this distance will be
detected.
N : Select to enable orientation control. The actuator will
change the orientation and the location of the object
so that it is parallel to the surface at the vertical
of the point of contact of the ray.
M/P : Select to enable material detection. Default is property
detection.
Property/Material: name of property/material that the target of
ray must have to be detected. If not set, property/
material filter is disabled and any collisioning object
within range will be detected.
PER : Select to enable persistent operation. Normally the
actuator disables itself automatically if the ray does
not reach a valid target.
time : Maximum activation time of actuator.
0 : unlimited.
>0: number of frames before automatic deactivation.
rotDamp: Time constant (in nb of frame) of orientation control.
0 : use Damp parameter.
>0: use a different time constant for orientation.
Notes: - If neither N nor Dist options are set, the actuator
does not change the position and orientation of the
object; it works as a ray sensor.
- The ray has no "X-ray" capability: if the first object
hit does not have the required property/material, it
returns no hit and the actuator disables itself unless
PER option is enabled.
- This actuator changes the position and orientation but
not the speed of the object. This has an important
implication in a gravity environment: the gravity will
cause the speed to increase although the object seems
to stay still (it is repositioned at each frame).
The gravity must be compensated in one way or another.
the new servo control motion actuator is the simplest
way: set the target speed along the ray axis to 0
and the servo control will automatically compensate
the gravity.
- This actuator changes the orientation of the object
and will conflict with Drot motion unless it is
placed BEFORE the Drot motion actuator (the order of
actuator is important)
- All parameters are accessible through Python.
Orientation constraint
======================
A new variant of the constraint actuator allows to align an
object axis along a global direction.
Damp : Time constant (in nb of frames) of orientation control.
X,Y,Z: Global coordinates of reference direction.
time : Maximum activation time of actuator.
0 : unlimited.
>0: number of frames before automatic deactivation.
Notes: - (X,Y,Z) = (0,0,0) is not a valid direction
- This actuator changes the orientation of the object
and will conflict with Drot motion unless it is placed
BEFORE the Drot motion actuator (the order of
actuator is important).
- This actuator doesn't change the location and speed.
It is compatible with gravity.
- All parameters are accessible through Python.
Actuator sensor
===============
This sensor detects the activation and deactivation of actuators
of the same object. The sensor generates a positive pulse when
the corresponding sensor is activated and a negative pulse when
it is deactivated (the contrary if the Inv option is selected).
This is mostly useful to chain actions and to detect the loss of
contact of the distance motion actuator.
Notes: - Actuators are disabled at the start of the game; if you
want to detect the On-Off transition of an actuator
after it has been activated at least once, unselect the
Lvl and Inv options and use a NAND controller.
- Some actuators deactivates themselves immediately after
being activated. The sensor detects this situation as
an On-Off transition.
- The actuator name can be set through Python.
2008-07-04 08:14:50 +00:00
|
|
|
// adapt local position so that world position is set to desired position
|
|
|
|
void NodeSetWorldPosition(const MT_Point3& trans);
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
void
|
|
|
|
NodeUpdateGS(
|
|
|
|
double time,
|
|
|
|
bool bInitiator
|
|
|
|
);
|
|
|
|
|
|
|
|
const
|
|
|
|
MT_Matrix3x3&
|
|
|
|
NodeGetWorldOrientation(
|
|
|
|
) const;
|
|
|
|
|
|
|
|
const
|
|
|
|
MT_Vector3&
|
|
|
|
NodeGetWorldScaling(
|
|
|
|
) const;
|
|
|
|
|
|
|
|
const
|
|
|
|
MT_Point3&
|
|
|
|
NodeGetWorldPosition(
|
|
|
|
) const;
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @section scene graph node accessor functions.
|
|
|
|
*/
|
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
SG_Node* GetSGNode( )
|
|
|
|
{
|
2002-10-12 11:37:38 +00:00
|
|
|
return m_pSGNode;
|
|
|
|
}
|
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
const SG_Node* GetSGNode( ) const
|
|
|
|
{
|
2002-10-12 11:37:38 +00:00
|
|
|
return m_pSGNode;
|
|
|
|
}
|
|
|
|
|
2008-06-18 06:46:49 +00:00
|
|
|
/**
|
|
|
|
* @section blender object accessor functions.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct Object* GetBlenderObject( )
|
|
|
|
{
|
|
|
|
return m_pBlenderObject;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetBlenderObject( struct Object* obj)
|
|
|
|
{
|
|
|
|
m_pBlenderObject = obj;
|
|
|
|
}
|
|
|
|
|
2008-07-15 20:05:23 +00:00
|
|
|
bool IsDupliGroup()
|
|
|
|
{
|
|
|
|
return (m_pBlenderObject &&
|
|
|
|
(m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
|
|
|
|
m_pBlenderObject->dup_group != NULL) ? true : false;
|
|
|
|
}
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
/**
|
|
|
|
* Set the Scene graph node for this game object.
|
|
|
|
* warning - it is your responsibility to make sure
|
|
|
|
* all controllers look at this new node. You must
|
|
|
|
* also take care of the memory associated with the
|
|
|
|
* old node. This class takes ownership of the new
|
|
|
|
* node.
|
|
|
|
*/
|
2005-08-22 18:31:19 +00:00
|
|
|
void SetSGNode(SG_Node* node )
|
|
|
|
{
|
|
|
|
m_pSGNode = node;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2005-08-22 18:31:19 +00:00
|
|
|
//Is it a dynamic/physics object ?
|
|
|
|
bool IsDynamic() const
|
|
|
|
{
|
2002-10-12 11:37:38 +00:00
|
|
|
return m_bDyna;
|
|
|
|
}
|
2008-05-14 20:22:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if this object has a vertex parent relationship
|
|
|
|
*/
|
|
|
|
bool IsVertexParent( )
|
|
|
|
{
|
|
|
|
return (m_pSGNode && m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsVertexParent());
|
|
|
|
}
|
|
|
|
|
2008-03-15 17:08:58 +00:00
|
|
|
bool RayHit(KX_ClientObjectInfo* client, MT_Point3& hit_point, MT_Vector3& hit_normal, void * const data);
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @section Physics accessors for this node.
|
|
|
|
*
|
|
|
|
* All these calls get passed directly to the physics controller
|
|
|
|
* owned by this object.
|
|
|
|
* This is real interface bloat. Why not just use the physics controller
|
|
|
|
* directly? I think this is because the python interface is in the wrong
|
|
|
|
* place.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
ApplyForce(
|
|
|
|
const MT_Vector3& force, bool local
|
|
|
|
);
|
|
|
|
|
|
|
|
void
|
|
|
|
ApplyTorque(
|
|
|
|
const MT_Vector3& torque,
|
|
|
|
bool local
|
|
|
|
);
|
|
|
|
|
|
|
|
void
|
|
|
|
ApplyRotation(
|
|
|
|
const MT_Vector3& drot,
|
|
|
|
bool local
|
|
|
|
);
|
|
|
|
|
|
|
|
void
|
|
|
|
ApplyMovement(
|
|
|
|
const MT_Vector3& dloc,
|
|
|
|
bool local
|
|
|
|
);
|
|
|
|
|
|
|
|
void
|
|
|
|
addLinearVelocity(
|
|
|
|
const MT_Vector3& lin_vel,
|
|
|
|
bool local
|
|
|
|
);
|
|
|
|
|
|
|
|
void
|
|
|
|
setLinearVelocity(
|
|
|
|
const MT_Vector3& lin_vel,
|
|
|
|
bool local
|
|
|
|
);
|
|
|
|
|
|
|
|
void
|
|
|
|
setAngularVelocity(
|
|
|
|
const MT_Vector3& ang_vel,
|
|
|
|
bool local
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Update the physics object transform based upon the current SG_Node
|
|
|
|
* position.
|
|
|
|
*/
|
2004-05-26 12:06:41 +00:00
|
|
|
void
|
2002-10-12 11:37:38 +00:00
|
|
|
UpdateTransform(
|
|
|
|
);
|
|
|
|
|
2004-05-26 12:06:41 +00:00
|
|
|
static void UpdateTransformFunc(SG_IObject* node, void* gameobj, void* scene);
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
/**
|
|
|
|
* Only update the transform if it's a non-dynamic object
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
UpdateNonDynas(
|
|
|
|
);
|
|
|
|
|
BGE logic patch: new "Add" mode for Ipo actuator, several corrections in state system.
New Add mode for Ipo actuator
=============================
A new Add button, mutually exclusive with Force button, is available in
the Ipo actuator. When selected, it activates the Add mode that consists
in adding the Ipo curve to the current object situation in world
coordinates, or parent coordinates if the object has a parent. Scale Ipo
curves are multiplied instead of added to the object current scale.
If the local flag is selected, the Ipo curve is added (multiplied) in
the object's local coordinates.
Delta Ipo curves are handled identically to normal Ipo curve and there
is no need to work with Delta Ipo curves provided that you make sure
that the Ipo curve starts from origin. Origin means location 0 for
Location Ipo curve, rotation 0 for Rotation Ipo curve and scale 1 for
Scale Ipo curve.
The "current object situation" means the object's location, rotation
and scale at the start of the Ipo curve. For Loop Stop and Loop End Ipo
actuators, this means at the start of each loop. This initial state is
used as a base during the execution of the Ipo Curve but when the Ipo
curve is restarted (later or immediately in case of Loop mode), the
object current situation at that time is used as the new base.
For reference, here is the exact operation of the Add mode for each
type of Ipo curve (oLoc, oRot, oScale, oMat: object's loc/rot/scale
and orientation matrix at the start of the curve; iLoc, iRot, iScale,
iMat: Ipo curve loc/rot/scale and orientation matrix resulting from
the rotation).
Location
Local=false: newLoc = oLoc+iLoc
Local=true : newLoc = oLoc+oScale*(oMat*iLoc)
Rotation
Local=false: newMat = iMat*oMat
Local=true : newMat = oMat*iMat
Scale
Local=false: newScale = oScale*iScale
Local=true : newScale = oScale*iScale
Add+Local mode is very useful to have dynamic object executing complex
movement relative to their current location/orientation. Of cource,
dynamics should be disabled during the execution of the curve.
Several corrections in state system
===================================
- Object initial state is taken into account when adding object
dynamically
- Fix bug with link count when adding object dynamically
- Fix false on-off detection for Actuator sensor when actuator is
trigged on negative event.
- Fix Parent actuator false activation on negative event
- Loop Ipo curve not restarting at correct frame when start frame is
different from one.
2008-07-08 12:18:43 +00:00
|
|
|
/**
|
|
|
|
* Function to set IPO option at start of IPO
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
InitIPO(
|
|
|
|
bool ipo_as_force,
|
|
|
|
bool ipo_add,
|
|
|
|
bool ipo_local
|
|
|
|
);
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
/**
|
|
|
|
* Odd function to update an ipo. ???
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
UpdateIPO(
|
|
|
|
float curframetime,
|
BGE logic patch: new "Add" mode for Ipo actuator, several corrections in state system.
New Add mode for Ipo actuator
=============================
A new Add button, mutually exclusive with Force button, is available in
the Ipo actuator. When selected, it activates the Add mode that consists
in adding the Ipo curve to the current object situation in world
coordinates, or parent coordinates if the object has a parent. Scale Ipo
curves are multiplied instead of added to the object current scale.
If the local flag is selected, the Ipo curve is added (multiplied) in
the object's local coordinates.
Delta Ipo curves are handled identically to normal Ipo curve and there
is no need to work with Delta Ipo curves provided that you make sure
that the Ipo curve starts from origin. Origin means location 0 for
Location Ipo curve, rotation 0 for Rotation Ipo curve and scale 1 for
Scale Ipo curve.
The "current object situation" means the object's location, rotation
and scale at the start of the Ipo curve. For Loop Stop and Loop End Ipo
actuators, this means at the start of each loop. This initial state is
used as a base during the execution of the Ipo Curve but when the Ipo
curve is restarted (later or immediately in case of Loop mode), the
object current situation at that time is used as the new base.
For reference, here is the exact operation of the Add mode for each
type of Ipo curve (oLoc, oRot, oScale, oMat: object's loc/rot/scale
and orientation matrix at the start of the curve; iLoc, iRot, iScale,
iMat: Ipo curve loc/rot/scale and orientation matrix resulting from
the rotation).
Location
Local=false: newLoc = oLoc+iLoc
Local=true : newLoc = oLoc+oScale*(oMat*iLoc)
Rotation
Local=false: newMat = iMat*oMat
Local=true : newMat = oMat*iMat
Scale
Local=false: newScale = oScale*iScale
Local=true : newScale = oScale*iScale
Add+Local mode is very useful to have dynamic object executing complex
movement relative to their current location/orientation. Of cource,
dynamics should be disabled during the execution of the curve.
Several corrections in state system
===================================
- Object initial state is taken into account when adding object
dynamically
- Fix bug with link count when adding object dynamically
- Fix false on-off detection for Actuator sensor when actuator is
trigged on negative event.
- Fix Parent actuator false activation on negative event
- Loop Ipo curve not restarting at correct frame when start frame is
different from one.
2008-07-08 12:18:43 +00:00
|
|
|
bool recurse
|
2002-10-12 11:37:38 +00:00
|
|
|
);
|
2006-01-06 03:46:54 +00:00
|
|
|
/**
|
|
|
|
* Updates Material Ipo data
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
UpdateMaterialData(
|
2008-07-25 13:45:57 +00:00
|
|
|
dword matname_hash,
|
2006-01-06 03:46:54 +00:00
|
|
|
MT_Vector4 rgba,
|
|
|
|
MT_Vector3 specrgb,
|
|
|
|
MT_Scalar hard,
|
|
|
|
MT_Scalar spec,
|
|
|
|
MT_Scalar ref,
|
|
|
|
MT_Scalar emit,
|
|
|
|
MT_Scalar alpha
|
|
|
|
);
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @section Mesh accessor functions.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Run through the meshes associated with this
|
|
|
|
* object and bucketize them. See RAS_Mesh for
|
|
|
|
* more details on this function. Interesting to
|
|
|
|
* note that polygon bucketizing seems to happen on a per
|
|
|
|
* object basis. Which may explain why there is such
|
|
|
|
* a big performance gain when all static objects
|
|
|
|
* are joined into 1.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
Bucketize(
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Clear the meshes associated with this class
|
|
|
|
* and remove from the bucketing system.
|
|
|
|
* Don't think this actually deletes any of the meshes.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
RemoveMeshes(
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a mesh to the set of meshes associated with this
|
|
|
|
* node. Meshes added in this way are not deleted by this class.
|
|
|
|
* Make sure you call RemoveMeshes() before deleting the
|
|
|
|
* mesh though,
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
AddMesh(
|
|
|
|
RAS_MeshObject* mesh
|
|
|
|
){
|
|
|
|
m_meshes.push_back(mesh);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Pick out a mesh associated with the integer 'num'.
|
|
|
|
*/
|
|
|
|
RAS_MeshObject*
|
|
|
|
GetMesh(
|
|
|
|
int num
|
|
|
|
) const {
|
|
|
|
return m_meshes[num];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the number of meshes currently associated with this
|
|
|
|
* game object.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
GetMeshCount(
|
|
|
|
) const {
|
|
|
|
return m_meshes.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the debug color of the meshes associated with this
|
|
|
|
* class. Does this still work?
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
SetDebugColor(
|
|
|
|
unsigned int bgra
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Reset the debug color of meshes associated with this class.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ResetDebugColor(
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the visibility of the meshes associated with this
|
|
|
|
* object.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
MarkVisible(
|
|
|
|
bool visible
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the visibility according to the visibility flag.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
MarkVisible(
|
|
|
|
void
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Was this object marked visible? (only for the ewxplicit
|
|
|
|
* visibility system).
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
GetVisible(
|
|
|
|
void
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set visibility flag of this object
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
SetVisible(
|
|
|
|
bool b
|
|
|
|
);
|
|
|
|
|
2008-04-30 19:58:44 +00:00
|
|
|
/**
|
|
|
|
* Change the layer of the object (when it is added in another layer
|
|
|
|
* than the original layer)
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
SetLayer(
|
|
|
|
int l
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the object layer
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
GetLayer(
|
|
|
|
void
|
|
|
|
);
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2008-05-25 14:37:39 +00:00
|
|
|
/**
|
|
|
|
* Get the negative scaling state
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
IsNegativeScaling(
|
|
|
|
void
|
|
|
|
) { return m_bIsNegativeScaling; }
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
/**
|
|
|
|
* @section Logic bubbling methods.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stop making progress
|
|
|
|
*/
|
|
|
|
void Suspend(void);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Resume making progress
|
|
|
|
*/
|
|
|
|
void Resume(void);
|
|
|
|
|
2008-06-25 14:09:15 +00:00
|
|
|
void SuspendDynamics(void) {
|
|
|
|
if (m_bSuspendDynamics)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_pPhysicsController1)
|
|
|
|
{
|
|
|
|
m_pPhysicsController1->SuspendDynamics();
|
|
|
|
}
|
|
|
|
m_bSuspendDynamics = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RestoreDynamics(void) {
|
|
|
|
if (!m_bSuspendDynamics)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_pPhysicsController1)
|
|
|
|
{
|
|
|
|
m_pPhysicsController1->RestoreDynamics();
|
|
|
|
}
|
|
|
|
m_bSuspendDynamics = false;
|
|
|
|
}
|
|
|
|
|
2004-03-22 22:02:18 +00:00
|
|
|
KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
|
2002-10-12 11:37:38 +00:00
|
|
|
/**
|
|
|
|
* @section Python interface functions.
|
|
|
|
*/
|
|
|
|
|
|
|
|
virtual
|
|
|
|
PyObject*
|
|
|
|
_getattr(
|
2004-05-16 12:52:54 +00:00
|
|
|
const STR_String& attr
|
2002-10-12 11:37:38 +00:00
|
|
|
);
|
2004-05-26 12:06:41 +00:00
|
|
|
|
|
|
|
virtual
|
|
|
|
int
|
|
|
|
_setattr(
|
|
|
|
const STR_String& attr,
|
|
|
|
PyObject *value
|
|
|
|
); // _setattr method
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2008-07-04 00:05:50 +00:00
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetPosition);
|
|
|
|
KX_PYMETHOD_O(KX_GameObject,SetPosition);
|
2008-08-27 03:34:53 +00:00
|
|
|
KX_PYMETHOD_VARARGS(KX_GameObject,GetLinearVelocity);
|
|
|
|
KX_PYMETHOD_VARARGS(KX_GameObject,SetLinearVelocity);
|
|
|
|
KX_PYMETHOD_VARARGS(KX_GameObject,GetAngularVelocity);
|
|
|
|
KX_PYMETHOD_VARARGS(KX_GameObject,SetAngularVelocity);
|
|
|
|
KX_PYMETHOD_VARARGS(KX_GameObject,GetVelocity);
|
2008-07-04 00:05:50 +00:00
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetMass);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetReactionForce);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetOrientation);
|
|
|
|
KX_PYMETHOD_O(KX_GameObject,SetOrientation);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetVisible);
|
|
|
|
KX_PYMETHOD_O(KX_GameObject,SetVisible);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetState);
|
|
|
|
KX_PYMETHOD_O(KX_GameObject,SetState);
|
2008-08-27 03:34:53 +00:00
|
|
|
KX_PYMETHOD_VARARGS(KX_GameObject,AlignAxisToVect);
|
2008-07-04 00:05:50 +00:00
|
|
|
KX_PYMETHOD_O(KX_GameObject,GetAxisVect);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,SuspendDynamics);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,RestoreDynamics);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,EnableRigidBody);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,DisableRigidBody);
|
2008-08-27 03:34:53 +00:00
|
|
|
KX_PYMETHOD_VARARGS(KX_GameObject,ApplyImpulse);
|
2008-07-04 00:05:50 +00:00
|
|
|
KX_PYMETHOD_O(KX_GameObject,SetCollisionMargin);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetParent);
|
|
|
|
KX_PYMETHOD_O(KX_GameObject,SetParent);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,RemoveParent);
|
2008-07-20 17:18:46 +00:00
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetChildren);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetChildrenRecursive);
|
2008-08-27 03:34:53 +00:00
|
|
|
KX_PYMETHOD_VARARGS(KX_GameObject,GetMesh);
|
2008-07-04 00:05:50 +00:00
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetPhysicsId);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,GetPropertyNames);
|
|
|
|
KX_PYMETHOD_NOARGS(KX_GameObject,EndObject);
|
2008-03-15 17:08:58 +00:00
|
|
|
KX_PYMETHOD_DOC(KX_GameObject,rayCastTo);
|
2008-05-24 22:50:31 +00:00
|
|
|
KX_PYMETHOD_DOC(KX_GameObject,rayCast);
|
2005-01-16 05:55:04 +00:00
|
|
|
KX_PYMETHOD_DOC(KX_GameObject,getDistanceTo);
|
2008-08-03 21:59:36 +00:00
|
|
|
KX_PYMETHOD_DOC(KX_GameObject,getVectTo);
|
2008-06-26 12:39:06 +00:00
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
private :
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Random internal function to convert python function arguments
|
|
|
|
* to 2 vectors.
|
|
|
|
* @return true if conversion was possible.
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool
|
|
|
|
ConvertPythonVectorArgs(
|
|
|
|
PyObject* args,
|
|
|
|
MT_Vector3& pos,
|
|
|
|
MT_Vector3& pos2
|
|
|
|
);
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2008-08-14 08:58:25 +00:00
|
|
|
/* utility conversion function */
|
|
|
|
bool ConvertPythonToGameObject(PyObject * value, KX_GameObject **object, bool py_none_ok);
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
#endif //__KX_GAMEOBJECT
|
|
|
|
|