|
4
|
1
|
|
|
2 // written in the D programming language
|
|
|
3
|
|
|
4 module chipmunkd.cpSpaceQuery;
|
|
|
5
|
|
|
6 import chipmunkd.chipmunk;
|
|
15
|
7 import chipmunkd.chipmunk_types;
|
|
4
|
8
|
|
|
9 struct pointQueryContext {
|
|
|
10 cpLayers layers;
|
|
|
11 cpGroup group;
|
|
|
12 cpSpacePointQueryFunc func;
|
|
|
13 void *data;
|
|
|
14 }
|
|
|
15
|
|
|
16 static void
|
|
|
17 pointQueryHelper(cpVect *point, cpShape *shape, pointQueryContext *context)
|
|
|
18 {
|
|
|
19 if(
|
|
|
20 !(shape.group && context.group == shape.group) && (context.layers&shape.layers) &&
|
|
|
21 cpShapePointQuery(shape, *point)
|
|
|
22 ){
|
|
|
23 context.func(shape, context.data);
|
|
|
24 }
|
|
|
25 }
|
|
|
26
|
|
|
27 void
|
|
|
28 cpSpacePointQuery(cpSpace *space, cpVect point, cpLayers layers, cpGroup group, cpSpacePointQueryFunc func, void *data)
|
|
|
29 {
|
|
|
30 pointQueryContext context = {layers, group, func, data};
|
|
23
|
31
|
|
29
|
32 cpSpaceLock(space);{
|
|
23
|
33 cpSpaceHashPointQuery(space.activeShapes, point, cast(cpSpaceHashQueryFunc)&pointQueryHelper, &context);
|
|
|
34 cpSpaceHashPointQuery(space.staticShapes, point, cast(cpSpaceHashQueryFunc)&pointQueryHelper, &context);
|
|
29
|
35 } cpSpaceUnlock(space);
|
|
4
|
36 }
|
|
|
37
|
|
|
38 static void
|
|
|
39 rememberLastPointQuery(cpShape *shape, cpShape **outShape)
|
|
|
40 {
|
|
|
41 if(!shape.sensor) *outShape = shape;
|
|
|
42 }
|
|
|
43
|
|
|
44 cpShape *
|
|
|
45 cpSpacePointQueryFirst(cpSpace *space, cpVect point, cpLayers layers, cpGroup group)
|
|
|
46 {
|
|
|
47 cpShape *shape = null;
|
|
|
48 cpSpacePointQuery(space, point, layers, group, cast(cpSpacePointQueryFunc)&rememberLastPointQuery, &shape);
|
|
|
49
|
|
|
50 return shape;
|
|
|
51 }
|
|
|
52
|
|
|
53 //#pragma mark Segment Query Functions
|
|
|
54
|
|
|
55 struct segQueryContext {
|
|
|
56 cpVect start, end;
|
|
|
57 cpLayers layers;
|
|
|
58 cpGroup group;
|
|
|
59 cpSpaceSegmentQueryFunc func;
|
|
|
60 }
|
|
|
61
|
|
|
62 static cpFloat
|
|
|
63 segQueryFunc(segQueryContext *context, cpShape *shape, void *data)
|
|
|
64 {
|
|
|
65 cpSegmentQueryInfo info;
|
|
|
66
|
|
|
67 if(
|
|
|
68 !(shape.group && context.group == shape.group) && (context.layers&shape.layers) &&
|
|
|
69 cpShapeSegmentQuery(shape, context.start, context.end, &info)
|
|
|
70 ){
|
|
|
71 context.func(shape, info.t, info.n, data);
|
|
|
72 }
|
|
|
73
|
|
|
74 return 1.0f;
|
|
|
75 }
|
|
|
76
|
|
|
77 void
|
|
|
78 cpSpaceSegmentQuery(cpSpace *space, cpVect start, cpVect end, cpLayers layers, cpGroup group, cpSpaceSegmentQueryFunc func, void *data)
|
|
|
79 {
|
|
|
80 segQueryContext context = {
|
|
|
81 start, end,
|
|
|
82 layers, group,
|
|
|
83 func,
|
|
|
84 };
|
|
|
85
|
|
29
|
86 cpSpaceLock(space);{
|
|
23
|
87 cpSpaceHashSegmentQuery(space.staticShapes, &context, start, end, 1.0f, cast(cpSpaceHashSegmentQueryFunc)&segQueryFunc, data);
|
|
|
88 cpSpaceHashSegmentQuery(space.activeShapes, &context, start, end, 1.0f, cast(cpSpaceHashSegmentQueryFunc)&segQueryFunc, data);
|
|
29
|
89 } cpSpaceUnlock(space);
|
|
4
|
90 }
|
|
|
91
|
|
|
92 struct segQueryFirstContext {
|
|
|
93 cpVect start, end;
|
|
|
94 cpLayers layers;
|
|
|
95 cpGroup group;
|
|
|
96 }
|
|
|
97
|
|
|
98 static cpFloat
|
|
|
99 segQueryFirst(segQueryFirstContext *context, cpShape *shape, cpSegmentQueryInfo *_out)
|
|
|
100 {
|
|
|
101 cpSegmentQueryInfo info;
|
|
|
102
|
|
|
103 if(
|
|
|
104 !(shape.group && context.group == shape.group) &&
|
|
|
105 (context.layers&shape.layers) &&
|
|
|
106 !shape.sensor &&
|
|
|
107 cpShapeSegmentQuery(shape, context.start, context.end, &info) &&
|
|
|
108 info.t < _out.t
|
|
|
109 ){
|
|
|
110 *_out = info;
|
|
|
111 }
|
|
|
112
|
|
|
113 return _out.t;
|
|
|
114 }
|
|
|
115
|
|
|
116 cpShape *
|
|
|
117 cpSpaceSegmentQueryFirst(cpSpace *space, cpVect start, cpVect end, cpLayers layers, cpGroup group, cpSegmentQueryInfo *_out)
|
|
|
118 {
|
|
|
119 cpSegmentQueryInfo info = {null, 1.0f, cpvzero};
|
|
|
120 if(_out){
|
|
|
121 (*_out) = info;
|
|
|
122 } else {
|
|
|
123 _out = &info;
|
|
|
124 }
|
|
|
125
|
|
|
126 segQueryFirstContext context = {
|
|
|
127 start, end,
|
|
|
128 layers, group
|
|
|
129 };
|
|
|
130
|
|
|
131 cpSpaceHashSegmentQuery(space.staticShapes, &context, start, end, 1.0f, cast(cpSpaceHashSegmentQueryFunc)&segQueryFirst, _out);
|
|
|
132 cpSpaceHashSegmentQuery(space.activeShapes, &context, start, end, _out.t, cast(cpSpaceHashSegmentQueryFunc)&segQueryFirst, _out);
|
|
|
133
|
|
|
134 return _out.shape;
|
|
|
135 }
|
|
|
136
|
|
|
137 //#pragma mark BB Query functions
|
|
|
138
|
|
|
139 struct bbQueryContext {
|
|
|
140 cpLayers layers;
|
|
|
141 cpGroup group;
|
|
|
142 cpSpaceBBQueryFunc func;
|
|
|
143 void *data;
|
|
|
144 }
|
|
|
145
|
|
|
146 static void
|
|
|
147 bbQueryHelper(cpBB *bb, cpShape *shape, bbQueryContext *context)
|
|
|
148 {
|
|
|
149 if(
|
|
|
150 !(shape.group && context.group == shape.group) && (context.layers&shape.layers) &&
|
|
|
151 cpBBintersects(*bb, shape.bb)
|
|
|
152 ){
|
|
|
153 context.func(shape, context.data);
|
|
|
154 }
|
|
|
155 }
|
|
|
156
|
|
|
157 void
|
|
|
158 cpSpaceBBQuery(cpSpace *space, cpBB bb, cpLayers layers, cpGroup group, cpSpaceBBQueryFunc func, void *data)
|
|
|
159 {
|
|
|
160 bbQueryContext context = {layers, group, func, data};
|
|
23
|
161
|
|
29
|
162 cpSpaceLock(space);{
|
|
4
|
163 cpSpaceHashQuery(space.activeShapes, &bb, bb, cast(cpSpaceHashQueryFunc)&bbQueryHelper, &context);
|
|
|
164 cpSpaceHashQuery(space.staticShapes, &bb, bb, cast(cpSpaceHashQueryFunc)&bbQueryHelper, &context);
|
|
29
|
165 } cpSpaceUnlock(space);
|
|
4
|
166 }
|
|
23
|
167
|
|
|
168 //#pragma mark Shape Query Functions
|
|
|
169
|
|
|
170 struct shapeQueryContext {
|
|
|
171 cpSpaceShapeQueryFunc func;
|
|
|
172 void *data;
|
|
|
173 cpBool anyCollision;
|
|
|
174 }
|
|
|
175
|
|
|
176 // Callback from the spatial hash.
|
|
|
177 static void
|
|
|
178 shapeQueryHelper(cpShape *a, cpShape *b, shapeQueryContext *context)
|
|
|
179 {
|
|
|
180 // Reject any of the simple cases
|
|
|
181 if(
|
|
|
182 (a.group && a.group == b.group) ||
|
|
|
183 !(a.layers & b.layers) ||
|
|
|
184 a.sensor || b.sensor
|
|
|
185 ) return;
|
|
|
186
|
|
|
187 cpContact contacts[CP_MAX_CONTACTS_PER_ARBITER];
|
|
|
188 int numContacts = 0;
|
|
|
189
|
|
|
190 // Shape 'a' should have the lower shape type. (required by cpCollideShapes() )
|
|
|
191 if(a.klass.type <= b.klass.type){
|
|
|
192 numContacts = cpCollideShapes(a, b, contacts.ptr);
|
|
|
193 } else {
|
|
|
194 numContacts = cpCollideShapes(b, a, contacts.ptr);
|
|
|
195 for(int i=0; i<numContacts; i++) contacts[i].n = cpvneg(contacts[i].n);
|
|
|
196 }
|
|
|
197
|
|
|
198 if(numContacts){
|
|
|
199 context.anyCollision = cpTrue;
|
|
|
200
|
|
|
201 if(context.func){
|
|
|
202 cpContactPointSet set; set.count = numContacts;
|
|
|
203 for(int i=0; i<set.count; i++){
|
|
|
204 set.points[i].point = contacts[i].p;
|
|
|
205 set.points[i].normal = contacts[i].p;
|
|
|
206 set.points[i].dist = contacts[i].dist;
|
|
|
207 }
|
|
|
208
|
|
|
209 context.func(b, &set, context.data);
|
|
|
210 }
|
|
|
211 }
|
|
|
212 }
|
|
|
213
|
|
|
214 cpBool
|
|
|
215 cpSpaceShapeQuery(cpSpace *space, cpShape *shape, cpSpaceShapeQueryFunc func, void *data)
|
|
|
216 {
|
|
|
217 cpBB bb = cpShapeCacheBB(shape);
|
|
|
218 shapeQueryContext context = {func, data, cpFalse};
|
|
|
219
|
|
29
|
220 cpSpaceLock(space);{
|
|
23
|
221 cpSpaceHashQuery(space.activeShapes, shape, bb, cast(cpSpaceHashQueryFunc)&shapeQueryHelper, &context);
|
|
|
222 cpSpaceHashQuery(space.staticShapes, shape, bb, cast(cpSpaceHashQueryFunc)&shapeQueryHelper, &context);
|
|
29
|
223 } cpSpaceUnlock(space);
|
|
23
|
224
|
|
|
225 return context.anyCollision;
|
|
|
226 }
|
