Speed up the physics engine: hook the SOLID broad phase, so we can either reject...
[blender.git] / source / gameengine / Physics / Sumo / Fuzzics / include / SM_Scene.h
1 /**
2  * $Id$
3  * Copyright (C) 2001 NaN Technologies B.V.
4  * The physics scene.
5  *
6  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version. The Blender
12  * Foundation also sells licenses for use in proprietary software under
13  * the Blender License.  See http://www.blender.org/BL/ for information
14  * about this.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
26  * All rights reserved.
27  *
28  * The Original Code is: all of this file.
29  *
30  * Contributor(s): none yet.
31  *
32  * ***** END GPL/BL DUAL LICENSE BLOCK *****
33  */
34 #ifndef SM_SCENE_H
35 #define SM_SCENE_H
36
37 #ifdef WIN32
38 #pragma warning (disable : 4786)
39 #endif
40
41 #include <vector>
42 #include <set>
43 #include <utility> //needed for pair
44
45 #include <SOLID/SOLID.h>
46
47 #include "MT_Vector3.h"
48 #include "MT_Point3.h"
49
50 #include "SM_Object.h"
51
52 typedef enum
53 {
54         FH_RESPONSE,
55         SENSOR_RESPONSE,                /* Touch Sensors */
56         CAMERA_RESPONSE,        /* Visibility Culling */
57         OBJECT_RESPONSE,        /* Object Dynamic Geometry Response */
58         STATIC_RESPONSE,        /* Static Geometry Response */
59         
60         NUM_RESPONSE
61 };
62
63 class SM_Scene {
64 public:
65     SM_Scene();
66         
67     ~SM_Scene();
68     
69         DT_RespTableHandle getRespTableHandle() const {
70                 return m_respTable;
71         }
72         
73         const MT_Vector3& getForceField() const {
74                 return m_forceField;
75         }
76
77         MT_Vector3& getForceField() {
78                 return m_forceField;
79         }
80
81         void setForceField(const MT_Vector3& forceField) {
82                 m_forceField = forceField;
83         }
84
85         void addTouchCallback(int response_class, DT_ResponseCallback callback, void *user);
86
87     void addSensor(SM_Object& object);
88     void add(SM_Object& object);
89     void remove(SM_Object& object);
90
91         void addPair(SM_Object *obj1, SM_Object *obj2) {
92                 m_pairList.insert(std::make_pair(obj1, obj2));
93         }
94
95         void clearPairs() {
96                 m_pairList.clear();
97         }
98
99         void setSecondaryRespTable(DT_RespTableHandle secondaryRespTable); 
100         DT_RespTableHandle getSecondaryRespTable() { return m_secondaryRespTable; }
101         
102         void requestCollisionCallback(SM_Object &object);
103
104         void beginFrame();
105         void endFrame();
106
107         // Perform an integration step of duration 'timeStep'.
108         // 'subSampling' is the maximum duration of a substep, i.e.,
109         // The maximum time interval between two collision checks.
110         // 'subSampling' can be used to control aliasing effects
111         // (fast moving objects traversing through walls and such). 
112         bool proceed(MT_Scalar curtime, MT_Scalar ticrate);
113
114         /**
115          * Test whether any objects lie on the line defined by from and
116          * to. The search returns the first such bject starting at from,
117          * or NULL if there was none.
118          * @returns A reference to the object, or NULL if there was none.
119          * @param ignore_client Do not look for collisions with this
120          *        object. This can be useful to avoid self-hits if
121          *        starting from the location of an object.
122          * @param from The start point, in world coordinates, of the search.
123          * @param to The end point, in world coordinates, of the search.
124          * @param result A store to return the point where intersection
125          *        took place (if there was an intersection).
126          * @param normal A store to return the normal of the hit object on
127          *        the location of the intersection, if it took place.
128          */
129         SM_Object *rayTest(void *ignore_client,
130                                            const MT_Point3& from, const MT_Point3& to, 
131                                            MT_Point3& result, MT_Vector3& normal) const;
132
133 private:
134
135         // Clear the user set velocities.
136         void clearObjectCombinedVelocities();
137         // This is the callback for handling collisions of dynamic objects
138         static 
139                 DT_Bool 
140         boing(
141                 void *client_data,  
142                 void *object1,
143                 void *object2,
144                 const DT_CollData *coll_data
145         );
146         
147         /** internal type */
148         typedef std::vector<SM_Object *> T_ObjectList;
149         /** internal type */
150         typedef std::set<std::pair<SM_Object *, SM_Object *> > T_PairList;
151
152         /** Handle to the scene in SOLID */
153         DT_SceneHandle      m_scene;
154         /** Following response table contains the callbacks for the dynmics */
155         DT_RespTableHandle  m_respTable;
156         DT_ResponseClass    m_ResponseClass[NUM_RESPONSE];
157         /**
158          * Following response table contains callbacks for the client (=
159          * game engine) */
160         DT_RespTableHandle  m_secondaryRespTable;  // Handle 
161         DT_ResponseClass    m_secondaryResponseClass[NUM_RESPONSE];
162         
163         /**
164          * Following resposne table contains callbacks for fixing the simulation
165          * ie making sure colliding objects do not intersect.
166          */
167         DT_RespTableHandle  m_fixRespTable;
168         DT_ResponseClass    m_fixResponseClass[NUM_RESPONSE];
169
170         /** The acceleration from the force field */
171         MT_Vector3          m_forceField;
172
173         /**
174          * The list of objects that receive motion updates and do
175          * collision tests. */
176         T_ObjectList        m_objectList;
177
178         /**
179          * A list with pairs of objects that collided the previous
180          * timestep. The list is built during the proceed(). During that
181          * time, it is not valid. */
182         T_PairList          m_pairList;
183         
184         MT_Scalar           m_lastTime;
185 };
186
187 #endif
188