2011-02-22 10:33:14 +00:00
|
|
|
/*
|
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,
|
2010-02-12 13:34:04 +00:00
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
2002-10-12 11:37:38 +00:00
|
|
|
*
|
|
|
|
* 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 *****
|
2011-02-22 10:33:14 +00:00
|
|
|
*/
|
|
|
|
/** \file SCA_IController.h
|
|
|
|
* \ingroup gamelogic
|
|
|
|
* \brief An abstract object that has some logic, python scripting and
|
|
|
|
* reference counting Note: transformation stuff has been moved to
|
|
|
|
* SceneGraph
|
2002-10-12 11:37:38 +00:00
|
|
|
*/
|
|
|
|
|
2012-02-23 10:41:31 +00:00
|
|
|
#ifndef __SCA_IOBJECT_H__
|
|
|
|
#define __SCA_IOBJECT_H__
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
#include "Value.h"
|
|
|
|
#include <vector>
|
|
|
|
|
2009-09-24 21:22:24 +00:00
|
|
|
class SCA_IObject;
|
2002-10-12 11:37:38 +00:00
|
|
|
class SCA_ISensor;
|
|
|
|
class SCA_IController;
|
|
|
|
class SCA_IActuator;
|
|
|
|
|
2010-10-31 04:11:39 +00:00
|
|
|
#ifdef WITH_PYTHON
|
2004-07-17 05:28:23 +00:00
|
|
|
template<class T> T PyVecTo(PyObject*);
|
2009-09-29 21:42:40 +00:00
|
|
|
#endif
|
2004-07-17 05:28:23 +00:00
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
typedef std::vector<SCA_ISensor *> SCA_SensorList;
|
|
|
|
typedef std::vector<SCA_IController *> SCA_ControllerList;
|
|
|
|
typedef std::vector<SCA_IActuator *> SCA_ActuatorList;
|
2009-09-24 21:22:24 +00:00
|
|
|
typedef std::vector<SCA_IObject *> SCA_ObjectList;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
class SCA_IObject : public CValue
|
|
|
|
{
|
|
|
|
|
2011-11-06 01:39:36 +00:00
|
|
|
Py_Header
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
protected:
|
2009-06-08 20:08:19 +00:00
|
|
|
friend class KX_StateActuator;
|
|
|
|
friend class SCA_IActuator;
|
|
|
|
friend class SCA_IController;
|
2002-10-12 11:37:38 +00:00
|
|
|
SCA_SensorList m_sensors;
|
|
|
|
SCA_ControllerList m_controllers;
|
|
|
|
SCA_ActuatorList m_actuators;
|
2008-04-26 20:41:25 +00:00
|
|
|
SCA_ActuatorList m_registeredActuators; // actuators that use a pointer to this object
|
2009-09-24 21:22:24 +00:00
|
|
|
SCA_ObjectList m_registeredObjects; // objects that hold reference to this object
|
2009-06-08 20:08:19 +00:00
|
|
|
|
|
|
|
// SG_Dlist: element of objects with active actuators
|
|
|
|
// Head: SCA_LogicManager::m_activeActuators
|
|
|
|
// SG_QList: Head of active actuators list on this object
|
|
|
|
// Elements: SCA_IActuator
|
|
|
|
SG_QList m_activeActuators;
|
|
|
|
// SG_Dlist: element of list os lists with active controllers
|
|
|
|
// Head: SCA_LogicManager::m_activeControllers
|
|
|
|
// SG_QList: Head of active controller list on this object
|
|
|
|
// Elements: SCA_IController
|
|
|
|
SG_QList m_activeControllers;
|
|
|
|
// SG_Dlist: element of list of lists of active controllers
|
|
|
|
// Head: SCA_LogicManager::m_activeControllers
|
|
|
|
// SG_QList: Head of active bookmarked controller list globally
|
|
|
|
// Elements: SCA_IController with bookmark option
|
|
|
|
static SG_QList m_activeBookmarkedControllers;
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
static class MT_Point3 m_sDummy;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Ignore activity culling requests?
|
|
|
|
*/
|
|
|
|
bool m_ignore_activity_culling;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Ignore updates?
|
|
|
|
*/
|
|
|
|
bool m_suspended;
|
BGE patch: add state engine support in the logic bricks.
This patch introduces a simple state engine system with the logic bricks. This system features full
backward compatibility, multiple active states, multiple state transitions, automatic disabling of
sensor and actuators, full GUI support and selective display of sensors and actuators.
Note: Python API is available but not documented yet. It will be added asap.
State internals
===============
The state system is object based. The current state mask is stored in the object as a 32 bit value;
each bit set in the mask is an active state. The controllers have a state mask too but only one bit
can be set: a controller belongs to a single state. The game engine will only execute controllers
that belong to active states. Sensors and actuators don't have a state mask but are effectively
attached to states via their links to the controllers. Sensors and actuators can be connected to more
than one state. When a controller becomes inactive because of a state change, its links to sensors
and actuators are temporarily broken (until the state becomes active again). If an actuator gets isolated,
i.e all the links to controllers are broken, it is automatically disabled. If a sensor gets isolated,
the game engine will stop calling it to save CPU. It will also reset the sensor internal state so that
it can react as if the game just started when it gets reconnected to an active controller. For example,
an Always sensor in no pulse mode that is connected to a single state (i.e connected to one or more
controllers of a single state) will generate a pulse each time the state becomes active. This feature is
not available on all sensors, see the notes below.
GUI
===
This system system is fully configurable through the GUI: the object state mask is visible under the
object bar in the controller's colum as an array of buttons just like the 3D view layer mask.
Click on a state bit to only display the controllers of that state. You can select more than one state
with SHIFT-click. The All button sets all the bits so that you can see all the controllers of the object.
The Ini button sets the state mask back to the object default state. You can change the default state
of object by first selecting the desired state mask and storing using the menu under the State button.
If you define a default state mask, it will be loaded into the object state make when you load the blend
file or when you run the game under the blenderplayer. However, when you run the game under Blender,
the current selected state mask will be used as the startup state for the object. This allows you to test
specific state during the game design.
The controller display the state they belong to with a new button in the controller header. When you add
a new controller, it is added by default in the lowest enabled state. You can change the controller state
by clicking on the button and selecting another state. If more than one state is enabled in the object
state mask, controllers are grouped by state for more readibility.
The new Sta button in the sensor and actuator column header allows you to display only the sensors and
actuators that are linked to visible controllers.
A new state actuator is available to modify the state during the game. It defines a bit mask and
the operation to apply on the current object state mask:
Cpy: the bit mask is copied to the object state mask.
Add: the bits that set in the bit mask will be turned on in the object state mask.
Sub: the bits that set in the bit mask will be turned off in the object state mask.
Inv: the bits that set in the bit mask will be inverted in the objecyy state mask.
Notes
=====
- Although states have no name, a simply convention consists in using the name of the first controller
of the state as the state name. The GUI will support that convention by displaying as a hint the name
of the first controller of the state when you move the mouse over a state bit of the object state mask
or of the state actuator bit mask.
- Each object has a state mask and each object can have a state engine but if several objects are
part of a logical group, it is recommended to put the state engine only in the main object and to
link the controllers of that object to the sensors and actuators of the different objects.
- When loading an old blend file, the state mask of all objects and controllers are initialized to 1
so that all the controllers belong to this single state. This ensures backward compatibility with
existing game.
- When the state actuator is activated at the same time as other actuators, these actuators are
guaranteed to execute before being eventually disabled due to the state change. This is useful for
example to send a message or update a property at the time of changing the state.
- Sensors that depend on underlying resource won't reset fully when they are isolated. By the time they
are acticated again, they will behave as follow:
* keyboard sensor: keys already pressed won't be detected. The keyboard sensor is only sensitive
to new key press.
* collision sensor: objects already colliding won't be detected. Only new collisions are
detected.
* near and radar sensor: same as collision sensor.
2008-06-22 14:23:57 +00:00
|
|
|
|
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
|
|
|
/**
|
|
|
|
* init state of object (used when object is created)
|
|
|
|
*/
|
|
|
|
unsigned int m_initState;
|
|
|
|
|
BGE patch: add state engine support in the logic bricks.
This patch introduces a simple state engine system with the logic bricks. This system features full
backward compatibility, multiple active states, multiple state transitions, automatic disabling of
sensor and actuators, full GUI support and selective display of sensors and actuators.
Note: Python API is available but not documented yet. It will be added asap.
State internals
===============
The state system is object based. The current state mask is stored in the object as a 32 bit value;
each bit set in the mask is an active state. The controllers have a state mask too but only one bit
can be set: a controller belongs to a single state. The game engine will only execute controllers
that belong to active states. Sensors and actuators don't have a state mask but are effectively
attached to states via their links to the controllers. Sensors and actuators can be connected to more
than one state. When a controller becomes inactive because of a state change, its links to sensors
and actuators are temporarily broken (until the state becomes active again). If an actuator gets isolated,
i.e all the links to controllers are broken, it is automatically disabled. If a sensor gets isolated,
the game engine will stop calling it to save CPU. It will also reset the sensor internal state so that
it can react as if the game just started when it gets reconnected to an active controller. For example,
an Always sensor in no pulse mode that is connected to a single state (i.e connected to one or more
controllers of a single state) will generate a pulse each time the state becomes active. This feature is
not available on all sensors, see the notes below.
GUI
===
This system system is fully configurable through the GUI: the object state mask is visible under the
object bar in the controller's colum as an array of buttons just like the 3D view layer mask.
Click on a state bit to only display the controllers of that state. You can select more than one state
with SHIFT-click. The All button sets all the bits so that you can see all the controllers of the object.
The Ini button sets the state mask back to the object default state. You can change the default state
of object by first selecting the desired state mask and storing using the menu under the State button.
If you define a default state mask, it will be loaded into the object state make when you load the blend
file or when you run the game under the blenderplayer. However, when you run the game under Blender,
the current selected state mask will be used as the startup state for the object. This allows you to test
specific state during the game design.
The controller display the state they belong to with a new button in the controller header. When you add
a new controller, it is added by default in the lowest enabled state. You can change the controller state
by clicking on the button and selecting another state. If more than one state is enabled in the object
state mask, controllers are grouped by state for more readibility.
The new Sta button in the sensor and actuator column header allows you to display only the sensors and
actuators that are linked to visible controllers.
A new state actuator is available to modify the state during the game. It defines a bit mask and
the operation to apply on the current object state mask:
Cpy: the bit mask is copied to the object state mask.
Add: the bits that set in the bit mask will be turned on in the object state mask.
Sub: the bits that set in the bit mask will be turned off in the object state mask.
Inv: the bits that set in the bit mask will be inverted in the objecyy state mask.
Notes
=====
- Although states have no name, a simply convention consists in using the name of the first controller
of the state as the state name. The GUI will support that convention by displaying as a hint the name
of the first controller of the state when you move the mouse over a state bit of the object state mask
or of the state actuator bit mask.
- Each object has a state mask and each object can have a state engine but if several objects are
part of a logical group, it is recommended to put the state engine only in the main object and to
link the controllers of that object to the sensors and actuators of the different objects.
- When loading an old blend file, the state mask of all objects and controllers are initialized to 1
so that all the controllers belong to this single state. This ensures backward compatibility with
existing game.
- When the state actuator is activated at the same time as other actuators, these actuators are
guaranteed to execute before being eventually disabled due to the state change. This is useful for
example to send a message or update a property at the time of changing the state.
- Sensors that depend on underlying resource won't reset fully when they are isolated. By the time they
are acticated again, they will behave as follow:
* keyboard sensor: keys already pressed won't be detected. The keyboard sensor is only sensitive
to new key press.
* collision sensor: objects already colliding won't be detected. Only new collisions are
detected.
* near and radar sensor: same as collision sensor.
2008-06-22 14:23:57 +00:00
|
|
|
/**
|
|
|
|
* current state = bit mask of state that are active
|
|
|
|
*/
|
|
|
|
unsigned int m_state;
|
|
|
|
|
2009-06-08 20:08:19 +00:00
|
|
|
/**
|
|
|
|
* pointer inside state actuator list for sorting
|
|
|
|
*/
|
|
|
|
SG_QList* m_firstState;
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
public:
|
|
|
|
|
2009-06-28 11:22:26 +00:00
|
|
|
SCA_IObject();
|
2002-10-12 11:37:38 +00:00
|
|
|
virtual ~SCA_IObject();
|
|
|
|
|
2009-06-08 20:08:19 +00:00
|
|
|
SCA_ControllerList& GetControllers()
|
|
|
|
{
|
|
|
|
return m_controllers;
|
|
|
|
}
|
|
|
|
SCA_SensorList& GetSensors()
|
|
|
|
{
|
|
|
|
return m_sensors;
|
|
|
|
}
|
|
|
|
SCA_ActuatorList& GetActuators()
|
|
|
|
{
|
|
|
|
return m_actuators;
|
|
|
|
}
|
|
|
|
SG_QList& GetActiveActuators()
|
|
|
|
{
|
|
|
|
return m_activeActuators;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
void AddSensor(SCA_ISensor* act);
|
2009-06-08 20:08:19 +00:00
|
|
|
void ReserveSensor(int num)
|
|
|
|
{
|
|
|
|
m_sensors.reserve(num);
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
void AddController(SCA_IController* act);
|
2009-06-08 20:08:19 +00:00
|
|
|
void ReserveController(int num)
|
|
|
|
{
|
|
|
|
m_controllers.reserve(num);
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
void AddActuator(SCA_IActuator* act);
|
2009-06-08 20:08:19 +00:00
|
|
|
void ReserveActuator(int num)
|
|
|
|
{
|
|
|
|
m_actuators.reserve(num);
|
|
|
|
}
|
2008-04-26 20:41:25 +00:00
|
|
|
void RegisterActuator(SCA_IActuator* act);
|
|
|
|
void UnregisterActuator(SCA_IActuator* act);
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2009-09-24 21:22:24 +00:00
|
|
|
void RegisterObject(SCA_IObject* objs);
|
|
|
|
void UnregisterObject(SCA_IObject* objs);
|
|
|
|
/**
|
|
|
|
* UnlinkObject(...)
|
|
|
|
* this object is informed that one of the object to which it holds a reference is deleted
|
|
|
|
* returns true if there was indeed a reference.
|
|
|
|
*/
|
|
|
|
virtual bool UnlinkObject(SCA_IObject* clientobj) { return false; }
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
SCA_ISensor* FindSensor(const STR_String& sensorname);
|
|
|
|
SCA_IActuator* FindActuator(const STR_String& actuatorname);
|
|
|
|
SCA_IController* FindController(const STR_String& controllername);
|
|
|
|
|
2009-06-08 20:08:19 +00:00
|
|
|
void SetCurrentTime(float currentTime) {}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2009-09-24 21:22:24 +00:00
|
|
|
virtual void ReParentLogic();
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set whether or not to ignore activity culling requests
|
|
|
|
*/
|
2009-06-08 20:08:19 +00:00
|
|
|
void SetIgnoreActivityCulling(bool b)
|
|
|
|
{
|
|
|
|
m_ignore_activity_culling = b;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set whether or not this object wants to ignore activity culling
|
|
|
|
* requests
|
|
|
|
*/
|
2009-06-08 20:08:19 +00:00
|
|
|
bool GetIgnoreActivityCulling()
|
|
|
|
{
|
|
|
|
return m_ignore_activity_culling;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Suspend all progress.
|
|
|
|
*/
|
|
|
|
void Suspend(void);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Resume progress
|
|
|
|
*/
|
|
|
|
void Resume(void);
|
BGE patch: add state engine support in the logic bricks.
This patch introduces a simple state engine system with the logic bricks. This system features full
backward compatibility, multiple active states, multiple state transitions, automatic disabling of
sensor and actuators, full GUI support and selective display of sensors and actuators.
Note: Python API is available but not documented yet. It will be added asap.
State internals
===============
The state system is object based. The current state mask is stored in the object as a 32 bit value;
each bit set in the mask is an active state. The controllers have a state mask too but only one bit
can be set: a controller belongs to a single state. The game engine will only execute controllers
that belong to active states. Sensors and actuators don't have a state mask but are effectively
attached to states via their links to the controllers. Sensors and actuators can be connected to more
than one state. When a controller becomes inactive because of a state change, its links to sensors
and actuators are temporarily broken (until the state becomes active again). If an actuator gets isolated,
i.e all the links to controllers are broken, it is automatically disabled. If a sensor gets isolated,
the game engine will stop calling it to save CPU. It will also reset the sensor internal state so that
it can react as if the game just started when it gets reconnected to an active controller. For example,
an Always sensor in no pulse mode that is connected to a single state (i.e connected to one or more
controllers of a single state) will generate a pulse each time the state becomes active. This feature is
not available on all sensors, see the notes below.
GUI
===
This system system is fully configurable through the GUI: the object state mask is visible under the
object bar in the controller's colum as an array of buttons just like the 3D view layer mask.
Click on a state bit to only display the controllers of that state. You can select more than one state
with SHIFT-click. The All button sets all the bits so that you can see all the controllers of the object.
The Ini button sets the state mask back to the object default state. You can change the default state
of object by first selecting the desired state mask and storing using the menu under the State button.
If you define a default state mask, it will be loaded into the object state make when you load the blend
file or when you run the game under the blenderplayer. However, when you run the game under Blender,
the current selected state mask will be used as the startup state for the object. This allows you to test
specific state during the game design.
The controller display the state they belong to with a new button in the controller header. When you add
a new controller, it is added by default in the lowest enabled state. You can change the controller state
by clicking on the button and selecting another state. If more than one state is enabled in the object
state mask, controllers are grouped by state for more readibility.
The new Sta button in the sensor and actuator column header allows you to display only the sensors and
actuators that are linked to visible controllers.
A new state actuator is available to modify the state during the game. It defines a bit mask and
the operation to apply on the current object state mask:
Cpy: the bit mask is copied to the object state mask.
Add: the bits that set in the bit mask will be turned on in the object state mask.
Sub: the bits that set in the bit mask will be turned off in the object state mask.
Inv: the bits that set in the bit mask will be inverted in the objecyy state mask.
Notes
=====
- Although states have no name, a simply convention consists in using the name of the first controller
of the state as the state name. The GUI will support that convention by displaying as a hint the name
of the first controller of the state when you move the mouse over a state bit of the object state mask
or of the state actuator bit mask.
- Each object has a state mask and each object can have a state engine but if several objects are
part of a logical group, it is recommended to put the state engine only in the main object and to
link the controllers of that object to the sensors and actuators of the different objects.
- When loading an old blend file, the state mask of all objects and controllers are initialized to 1
so that all the controllers belong to this single state. This ensures backward compatibility with
existing game.
- When the state actuator is activated at the same time as other actuators, these actuators are
guaranteed to execute before being eventually disabled due to the state change. This is useful for
example to send a message or update a property at the time of changing the state.
- Sensors that depend on underlying resource won't reset fully when they are isolated. By the time they
are acticated again, they will behave as follow:
* keyboard sensor: keys already pressed won't be detected. The keyboard sensor is only sensitive
to new key press.
* collision sensor: objects already colliding won't be detected. Only new collisions are
detected.
* near and radar sensor: same as collision sensor.
2008-06-22 14:23:57 +00:00
|
|
|
|
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
|
|
|
/**
|
|
|
|
* Set init state
|
|
|
|
*/
|
|
|
|
void SetInitState(unsigned int initState) { m_initState = initState; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* initialize the state when object is created
|
|
|
|
*/
|
|
|
|
void ResetState(void) { SetState(m_initState); }
|
|
|
|
|
BGE patch: add state engine support in the logic bricks.
This patch introduces a simple state engine system with the logic bricks. This system features full
backward compatibility, multiple active states, multiple state transitions, automatic disabling of
sensor and actuators, full GUI support and selective display of sensors and actuators.
Note: Python API is available but not documented yet. It will be added asap.
State internals
===============
The state system is object based. The current state mask is stored in the object as a 32 bit value;
each bit set in the mask is an active state. The controllers have a state mask too but only one bit
can be set: a controller belongs to a single state. The game engine will only execute controllers
that belong to active states. Sensors and actuators don't have a state mask but are effectively
attached to states via their links to the controllers. Sensors and actuators can be connected to more
than one state. When a controller becomes inactive because of a state change, its links to sensors
and actuators are temporarily broken (until the state becomes active again). If an actuator gets isolated,
i.e all the links to controllers are broken, it is automatically disabled. If a sensor gets isolated,
the game engine will stop calling it to save CPU. It will also reset the sensor internal state so that
it can react as if the game just started when it gets reconnected to an active controller. For example,
an Always sensor in no pulse mode that is connected to a single state (i.e connected to one or more
controllers of a single state) will generate a pulse each time the state becomes active. This feature is
not available on all sensors, see the notes below.
GUI
===
This system system is fully configurable through the GUI: the object state mask is visible under the
object bar in the controller's colum as an array of buttons just like the 3D view layer mask.
Click on a state bit to only display the controllers of that state. You can select more than one state
with SHIFT-click. The All button sets all the bits so that you can see all the controllers of the object.
The Ini button sets the state mask back to the object default state. You can change the default state
of object by first selecting the desired state mask and storing using the menu under the State button.
If you define a default state mask, it will be loaded into the object state make when you load the blend
file or when you run the game under the blenderplayer. However, when you run the game under Blender,
the current selected state mask will be used as the startup state for the object. This allows you to test
specific state during the game design.
The controller display the state they belong to with a new button in the controller header. When you add
a new controller, it is added by default in the lowest enabled state. You can change the controller state
by clicking on the button and selecting another state. If more than one state is enabled in the object
state mask, controllers are grouped by state for more readibility.
The new Sta button in the sensor and actuator column header allows you to display only the sensors and
actuators that are linked to visible controllers.
A new state actuator is available to modify the state during the game. It defines a bit mask and
the operation to apply on the current object state mask:
Cpy: the bit mask is copied to the object state mask.
Add: the bits that set in the bit mask will be turned on in the object state mask.
Sub: the bits that set in the bit mask will be turned off in the object state mask.
Inv: the bits that set in the bit mask will be inverted in the objecyy state mask.
Notes
=====
- Although states have no name, a simply convention consists in using the name of the first controller
of the state as the state name. The GUI will support that convention by displaying as a hint the name
of the first controller of the state when you move the mouse over a state bit of the object state mask
or of the state actuator bit mask.
- Each object has a state mask and each object can have a state engine but if several objects are
part of a logical group, it is recommended to put the state engine only in the main object and to
link the controllers of that object to the sensors and actuators of the different objects.
- When loading an old blend file, the state mask of all objects and controllers are initialized to 1
so that all the controllers belong to this single state. This ensures backward compatibility with
existing game.
- When the state actuator is activated at the same time as other actuators, these actuators are
guaranteed to execute before being eventually disabled due to the state change. This is useful for
example to send a message or update a property at the time of changing the state.
- Sensors that depend on underlying resource won't reset fully when they are isolated. By the time they
are acticated again, they will behave as follow:
* keyboard sensor: keys already pressed won't be detected. The keyboard sensor is only sensitive
to new key press.
* collision sensor: objects already colliding won't be detected. Only new collisions are
detected.
* near and radar sensor: same as collision sensor.
2008-06-22 14:23:57 +00:00
|
|
|
/**
|
|
|
|
* Set the object state
|
|
|
|
*/
|
|
|
|
void SetState(unsigned int state);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the object state
|
|
|
|
*/
|
|
|
|
unsigned int GetState(void) { return m_state; }
|
|
|
|
|
2004-07-17 05:28:23 +00:00
|
|
|
// const class MT_Point3& ConvertPythonPylist(PyObject* pylist);
|
2006-05-11 17:58:23 +00:00
|
|
|
|
|
|
|
virtual int GetGameObjectType() {return -1;}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2006-05-11 17:58:23 +00:00
|
|
|
typedef enum ObjectTypes {
|
2008-06-18 06:46:49 +00:00
|
|
|
OBJ_ARMATURE=0,
|
2009-06-28 11:22:26 +00:00
|
|
|
OBJ_CAMERA=1,
|
2009-09-29 22:49:33 +00:00
|
|
|
OBJ_LIGHT=2,
|
2006-05-11 17:58:23 +00:00
|
|
|
}ObjectTypes;
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
};
|
|
|
|
|
2012-02-23 10:41:31 +00:00
|
|
|
#endif //__SCA_IOBJECT_H__
|
2002-10-12 11:37:38 +00:00
|
|
|
|