Added the Solid 3.5 sources to the blender source tree.
[blender.git] / extern / solid / include / SOLID.h
1 /*
2  * SOLID - Software Library for Interference Detection
3  * 
4  * Copyright (C) 2001-2003  Dtecta.  All rights reserved.
5  *
6  * This library may be distributed under the terms of the Q Public License
7  * (QPL) as defined by Trolltech AS of Norway and appearing in the file
8  * LICENSE.QPL included in the packaging of this file.
9  *
10  * This library may be distributed and/or modified under the terms of the
11  * GNU General Public License (GPL) version 2 as published by the Free Software
12  * Foundation and appearing in the file LICENSE.GPL included in the
13  * packaging of this file.
14  *
15  * This library is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
17  *
18  * Commercial use or any other use of this library not covered by either 
19  * the QPL or the GPL requires an additional license from Dtecta. 
20  * Please contact info@dtecta.com for enquiries about the terms of commercial
21  * use of this library.
22  */
23
24 #ifndef SOLID_H
25 #define SOLID_H
26
27 #include "SOLID_types.h"
28
29 #ifdef __cplusplus
30 extern "C" { 
31 #endif
32     
33         DT_DECLARE_HANDLE(DT_ObjectHandle);
34         DT_DECLARE_HANDLE(DT_SceneHandle);
35         DT_DECLARE_HANDLE(DT_ShapeHandle);
36         DT_DECLARE_HANDLE(DT_VertexBaseHandle);
37         DT_DECLARE_HANDLE(DT_RespTableHandle);
38         DT_DECLARE_HANDLE(DT_ArchiveHandle);
39
40         typedef unsigned int DT_ResponseClass;
41
42         typedef enum DT_ResponseType { 
43                 DT_NO_RESPONSE,                  /* No response (obsolete) */              
44                 DT_SIMPLE_RESPONSE,              /* No collision data */
45                 DT_WITNESSED_RESPONSE,           /* A point common to both objects
46                                                                                         is returned as collision data
47                                                                                  */
48                 DT_DEPTH_RESPONSE                /* The penetration depth is returned
49                                                                                         as collision data. The penetration depth
50                                                                                         is the shortest vector over which one 
51                                                                                         object needs to be translated in order
52                                                                                         to bring the objects in touching contact. 
53                                                                                  */ 
54         } DT_ResponseType;
55     
56 /* For witnessed response, the following structure represents a common point. The world 
57    coordinates of 'point1' and 'point2' coincide. 'normal' is the zero vector.
58    
59    For depth response, the following structure represents the penetration depth. 
60    'point1' en 'point2' are the witness points of the penetration depth in world coordinates.
61    The penetration depth vector in world coordinates is represented by 'normal'.
62 */
63
64         typedef struct DT_CollData {
65                 DT_Vector3 point1;               /* Point in object1 in world coordinates */ 
66                 DT_Vector3 point2;               /* Point in object2 in world coordinates */
67                 DT_Vector3 normal;               /* point2 - point1 */ 
68         } DT_CollData;
69
70 /* A response callback is called by SOLID for each pair of collding objects. 'client-data'
71    is a pointer to an arbitrary structure in the client application. The client objects are
72    pointers to structures in the client application associated with the coliding objects.
73    'coll_data' is the collision data computed by SOLID.
74 */
75
76         typedef DT_Bool (*DT_ResponseCallback)(void *client_data,
77                                                                                    void *client_object1,
78                                                                                    void *client_object2,
79                                                                                    const DT_CollData *coll_data);
80                                                                                 
81 /* Shape definition */
82
83
84         extern DECLSPEC DT_ShapeHandle DT_NewBox(DT_Scalar x, DT_Scalar y, DT_Scalar z);
85         extern DECLSPEC DT_ShapeHandle DT_NewCone(DT_Scalar radius, DT_Scalar height);
86         extern DECLSPEC DT_ShapeHandle DT_NewCylinder(DT_Scalar radius, DT_Scalar height);
87         extern DECLSPEC DT_ShapeHandle DT_NewSphere(DT_Scalar radius);
88         extern DECLSPEC DT_ShapeHandle DT_NewPoint(const DT_Vector3 point);
89         extern DECLSPEC DT_ShapeHandle DT_NewLineSegment(const DT_Vector3 source, const DT_Vector3 target);
90         extern DECLSPEC DT_ShapeHandle DT_NewMinkowski(DT_ShapeHandle shape1, DT_ShapeHandle shape2);
91         extern DECLSPEC DT_ShapeHandle DT_NewHull(DT_ShapeHandle shape1, DT_ShapeHandle shape2);
92
93         extern DECLSPEC DT_VertexBaseHandle DT_NewVertexBase(const void *pointer, DT_Size stride);
94         extern DECLSPEC void DT_DeleteVertexBase(DT_VertexBaseHandle vertexBase);       
95         extern DECLSPEC void DT_ChangeVertexBase(DT_VertexBaseHandle vertexBase, const void *pointer);
96
97         extern DECLSPEC DT_ShapeHandle DT_NewComplexShape(DT_VertexBaseHandle vertexBase);
98         extern DECLSPEC void           DT_EndComplexShape();
99
100         extern DECLSPEC DT_ShapeHandle DT_NewPolytope(DT_VertexBaseHandle vertexBase);
101         extern DECLSPEC void           DT_EndPolytope();
102
103         extern DECLSPEC void DT_Begin();
104         extern DECLSPEC void DT_End();
105
106         extern DECLSPEC void DT_Vertex(const DT_Vector3 vertex);
107         extern DECLSPEC void DT_VertexIndex(DT_Index index);
108
109         extern DECLSPEC void DT_VertexIndices(DT_Count count, const DT_Index *indices);
110         extern DECLSPEC void DT_VertexRange(DT_Index first, DT_Count count); 
111
112         extern DECLSPEC void DT_DeleteShape(DT_ShapeHandle shape);
113
114 /* Object  */
115
116         extern DECLSPEC DT_ObjectHandle DT_CreateObject(
117                 void *client_object,      /* pointer to object in client memory */
118                 DT_ShapeHandle shape  /* the shape or geometry of the object */
119                 );
120
121         extern DECLSPEC void DT_DestroyObject(DT_ObjectHandle object);
122
123
124
125         extern DECLSPEC void DT_SetPosition(DT_ObjectHandle object, const DT_Vector3 position);
126         extern DECLSPEC void DT_SetOrientation(DT_ObjectHandle object, const DT_Quaternion orientation);
127         extern DECLSPEC void DT_SetScaling(DT_ObjectHandle object, const DT_Vector3 scaling);
128
129 /* The margin is an offset from the actual shape. The actual geometry of an
130    object is the set of points whose distance to the transformed shape is at 
131    most the  margin. During the lifetime of an object the margin can be 
132    modified. 
133 */
134    
135         extern DECLSPEC void DT_SetMargin(DT_ObjectHandle object, DT_Scalar margin);
136
137
138 /* These commands assume a column-major 4x4 OpenGL matrix representation */
139
140         extern DECLSPEC void DT_SetMatrixf(DT_ObjectHandle object, const float *m); 
141         extern DECLSPEC void DT_GetMatrixf(DT_ObjectHandle object, float *m); 
142
143         extern DECLSPEC void DT_SetMatrixd(DT_ObjectHandle object, const double *m); 
144         extern DECLSPEC void DT_GetMatrixd(DT_ObjectHandle object, double *m); 
145
146         extern DECLSPEC void DT_GetBBox(DT_ObjectHandle object, DT_Vector3 min, DT_Vector3 max);
147
148
149 /* This next command returns the distance between the objects. De returned
150    closest points are given in world coordinates.
151 */
152         extern DECLSPEC DT_Scalar DT_GetClosestPair(DT_ObjectHandle object1, DT_ObjectHandle object2,
153                                                                                                 DT_Vector3 point1, DT_Vector3 point2);  
154
155         extern DECLSPEC DT_Bool   DT_GetCommonPoint(DT_ObjectHandle object1, DT_ObjectHandle object2,
156                                                                                                 DT_Vector3 point);
157
158         extern DECLSPEC DT_Bool   DT_GetPenDepth(DT_ObjectHandle object1, DT_ObjectHandle object2,
159                                                                                          DT_Vector3 point1, DT_Vector3 point2);  
160
161 /* Scene */
162
163         extern DECLSPEC DT_SceneHandle DT_CreateScene(); 
164         extern DECLSPEC void           DT_DestroyScene(DT_SceneHandle scene);
165
166         extern DECLSPEC void DT_AddObject(DT_SceneHandle scene, DT_ObjectHandle object);
167         extern DECLSPEC void DT_RemoveObject(DT_SceneHandle scene, DT_ObjectHandle object);
168
169 /* Note that objects can be assigned to multiple scenes! */
170
171 /* Response */
172
173 /* Response tables are defined independent of the scenes in which they are used.
174    Multiple response tables can be used in one scene, and a response table
175    can be shared among scenes.
176 */
177         extern DECLSPEC DT_RespTableHandle DT_CreateRespTable(); 
178         extern DECLSPEC void               DT_DestroyRespTable(DT_RespTableHandle respTable); 
179
180 /* Responses are defined on (pairs of) response classes. Each response table 
181    maintains its set of response classes.
182 */
183         extern DECLSPEC DT_ResponseClass DT_GenResponseClass(DT_RespTableHandle respTable);
184
185 /* To each object for which a response is defined in the response table a
186    response class needs to be assigned. 
187 */
188
189         extern DECLSPEC void DT_SetResponseClass(DT_RespTableHandle respTable,
190                                                                                          DT_ObjectHandle object,
191                                                                                          DT_ResponseClass responseClass);
192
193         extern DECLSPEC void DT_ClearResponseClass(DT_RespTableHandle respTable, 
194                                                                                            DT_ObjectHandle object);
195
196         extern DECLSPEC void DT_CallResponse(DT_RespTableHandle respTable,
197                                                                                  DT_ObjectHandle object1,
198                                                                                  DT_ObjectHandle object2,
199                                                                                  const DT_CollData *coll_data);
200
201 /* For each pair of objects multiple responses can be defined. A response is a callback
202    together with its response type and client data. */
203     
204 /* Responses can be defined for all pairs of response classes... */
205         extern DECLSPEC void DT_AddDefaultResponse(DT_RespTableHandle respTable,
206                                                                                            DT_ResponseCallback response, 
207                                                                                            DT_ResponseType type, void *client_data);
208
209         extern DECLSPEC void DT_RemoveDefaultResponse(DT_RespTableHandle respTable,
210                                                                                                   DT_ResponseCallback response);
211 /* ...per response class... */
212         extern DECLSPEC void DT_AddClassResponse(DT_RespTableHandle respTable,
213                                                                                          DT_ResponseClass responseClass,
214                                                                                          DT_ResponseCallback response,
215                                                                                          DT_ResponseType type, void *client_data);
216
217         extern DECLSPEC void DT_RemoveClassResponse(DT_RespTableHandle respTable,
218                                                                                                 DT_ResponseClass responseClass,
219                                                                                                 DT_ResponseCallback response);
220
221 /* ... and per pair of response classes...*/
222         extern DECLSPEC void DT_AddPairResponse(DT_RespTableHandle respTable,
223                                                                                         DT_ResponseClass responseClass1,
224                                                                                         DT_ResponseClass responseClass2, 
225                                                                                         DT_ResponseCallback response,
226                                                                                         DT_ResponseType type, void *client_data);
227         extern DECLSPEC void DT_RemovePairResponse(DT_RespTableHandle respTable,
228                                                                                            DT_ResponseClass responseClass1,
229                                                                                            DT_ResponseClass responseClass2,
230                                                                                            DT_ResponseCallback response);
231
232 /* The next command calls the response callbacks for all intersecting pairs of objects in a scene. 
233    'DT_Test' returns the number of pairs of objects for which callbacks have been called. 
234 */
235  
236         extern DECLSPEC DT_Count DT_Test(DT_SceneHandle scene, DT_RespTableHandle respTable);
237
238 /* Set the maximum relative error in the closest points and penetration depth
239    computation. The default for `max_error' is 1.0e-3. Larger errors result
240    in better performance. Non-positive error tolerances are ignored.
241 */ 
242
243         extern DECLSPEC void DT_SetAccuracy(DT_Scalar max_error);
244
245 /* Set the maximum tolerance on relative errors due to rounding.  The default for `tol_error' 
246    is the machine epsilon. Very large tolerances result in false collisions. Setting tol_error too small 
247    results in missed collisions. Non-positive error tolerances are ignored. 
248 */ 
249     
250         extern DECLSPEC void DT_SetTolerance(DT_Scalar tol_error);
251
252
253 /* This function returns the client pointer to the first object in a scene hit by the ray 
254    (actually a line segment) defined by the points 'from' en 'to'. The spot is the hit point 
255    on the object in local coordinates. 'normal' is the normal to the surface of the object in
256    world coordinates. The ignore_client pointer is used to make one of the objects transparent.
257
258    NB: Currently ray tests are implemented for spheres, boxes, and meshes only!!
259 */   
260
261         extern DECLSPEC void *DT_RayCast(DT_SceneHandle scene, void *ignore_client,
262                                                                          const DT_Vector3 source, const DT_Vector3 target,
263                                                                          DT_Scalar max_param, DT_Scalar *param, DT_Vector3 normal);
264
265 /* Similar, only here a single object is tested and a boolean is returned */
266
267         extern DECLSPEC DT_Bool DT_ObjectRayCast(DT_ObjectHandle object,
268                                                                                          const DT_Vector3 source, const DT_Vector3 target,
269                                                                                          DT_Scalar max_param, DT_Scalar *param, DT_Vector3 normal);
270
271
272 #ifdef __cplusplus
273 }
274 #endif
275
276 #endif