Merged 15170:15635 from trunk (no conflicts or even merges)
[blender.git] / source / gameengine / PyDoc / KX_GameObject.py
index 8d29a70438084f82a1fa14f4ff416686dba1f31c..37c188b7f2249cdfa2ae8ded824f592b92d942de 100644 (file)
@@ -22,12 +22,38 @@ class KX_GameObject:
        @type orientation: 3x3 Matrix [[float]]
        @ivar scaling: The object's scaling factor. list [sx, sy, sz]
        @type scaling: list [sx, sy, sz]
+       @ivar timeOffset: adjust the slowparent delay at runtime.
+       @type timeOffset: float
        """
-       
+       def endObject(visible):
+               """
+               Delete this object, can be used inpace of the EndObject Actuator.
+               The actual removal of the object from the scene is delayed.
+               """     
+       def getVisible(visible):
+               """
+               Gets the game object's visible flag.
+               
+               @type visible: boolean
+               """     
        def setVisible(visible):
                """
                Sets the game object's visible flag.
                
+               @type visible: boolean
+               """
+       def getState():
+               """
+               Gets the game object's state bitmask.
+               
+               @rtype: int
+               @return: the objects state.
+               """     
+       def setState():
+               """
+               Sets the game object's visible flag.
+               The bitmasks for states from 1 to 30 can be set with (1<<0, 1<<1, 1<<2 ... 1<<29)
+               
                @type visible: boolean
                """
        def setPosition(pos):
@@ -50,6 +76,7 @@ class KX_GameObject:
                
                @type orn: 3x3 rotation matrix, or Quaternion.
                @param orn: a rotation matrix specifying the new rotation.
+               @note: When using this matrix with Blender.Mathutils.Matrix() types, it will need to be transposed.
                """
        def alignAxisToVect(vect, axis):
                """
@@ -63,14 +90,26 @@ class KX_GameObject:
                                        - 1: Y axis
                                        - 2: Z axis (default) 
                """
+       def getAxisVect(vect):
+               """
+               Returns the axis vector rotates by the objects worldspace orientation.
+               This is the equivalent if multiplying the vector by the orientation matrix.
+               
+               @type vect: 3d vector.
+               @param vect: a vector to align the axis.
+               @rtype: 3d vector.
+               @return: The vector in relation to the objects rotation.
+
+               """
        def getOrientation():
                """
                Gets the game object's orientation.
                
                @rtype: 3x3 rotation matrix
                @return: The game object's rotation matrix
+               @note: When using this matrix with Blender.Mathutils.Matrix() types, it will need to be transposed.
                """
-       def getLinearVelocity(local):
+       def getLinearVelocity(local = 0):
                """
                Gets the game object's linear velocity.
                
@@ -78,11 +117,24 @@ class KX_GameObject:
                ie no angular velocity component.
                
                @type local: boolean
-               @param local: - False: you get the "global" velocity ie: relative to world orientation.
+               @param local: - False: you get the "global" velocity ie: relative to world orientation (default).
                              - True: you get the "local" velocity ie: relative to object orientation.
                @rtype: list [vx, vy, vz]
                @return: the object's linear velocity.
                """
+       def setLinearVelocity(velocity, local = 0):
+               """
+               Sets the game object's linear velocity.
+               
+               This method sets game object's velocity through it's centre of mass,
+               ie no angular velocity component.
+               
+               @type velocity: 3d vector.
+               @param velocity: linear velocity vector.
+               @type local: boolean
+               @param local: - False: you get the "global" velocity ie: relative to world orientation (default).
+                             - True: you get the "local" velocity ie: relative to object orientation.
+               """
        def getVelocity(point):
                """
                Gets the game object's velocity at the specified point.
@@ -130,16 +182,19 @@ class KX_GameObject:
        def restoreDynamics():
                """
                Resumes physics for this object.
+               @Note: The objects linear velocity will be applied from when the dynamics were suspended.
                """
        def enableRigidBody():
                """
                Enables rigid body physics for this object.
                
                Rigid body physics allows the object to roll on collisions.
+               @Note: This is not working with bullet physics yet.
                """
        def disableRigidBody():
                """
                Disables rigid body physics for this object.
+               @Note: This is not working with bullet physics yet. The angular is removed but rigid body physics can still rotate it later.
                """
        def getParent():
                """
@@ -172,6 +227,12 @@ class KX_GameObject:
                """
                Returns the user data object associated with this game object's physics controller.
                """
+       def getPropertyNames():
+               """
+               Gets a list of all property names.
+               @rtype: list
+               @return: All property names for this object.
+               """
        def getDistanceTo(other):
                """
                Returns the distance to another object or point.
@@ -212,7 +273,7 @@ class KX_GameObject:
                If is casted from/to object center or explicit [x,y,z] points.
                The ray does not have X-Ray capability: the first object hit (other than self object) stops the ray
                If a property was specified and the first object hit does not have that property, there is no hit
-               The     ray ignores collision-free objects
+               The     ray ignores collision-free objects and faces that dont have the collision flag enabled, you can however use ghost objects.
 
                @param to: [x,y,z] or object to which the ray is casted
                @type to: L{KX_GameObject} or 3-tuple