OpenNI 1.5.7
XnModuleCFunctions.h
Go to the documentation of this file.
1 /*****************************************************************************
2 * *
3 * OpenNI 1.x Alpha *
4 * Copyright (C) 2012 PrimeSense Ltd. *
5 * *
6 * This file is part of OpenNI. *
7 * *
8 * Licensed under the Apache License, Version 2.0 (the "License"); *
9 * you may not use this file except in compliance with the License. *
10 * You may obtain a copy of the License at *
11 * *
12 * http://www.apache.org/licenses/LICENSE-2.0 *
13 * *
14 * Unless required by applicable law or agreed to in writing, software *
15 * distributed under the License is distributed on an "AS IS" BASIS, *
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
17 * See the License for the specific language governing permissions and *
18 * limitations under the License. *
19 * *
20 *****************************************************************************/
21 #ifndef XN_MODULE_C_FUNCTIONS_H_
22 #define XN_MODULE_C_FUNCTIONS_H_
23 
24 #include "XnModuleCppInterface.h"
25 
26 using namespace xn;
27 
28 #ifdef XN_NO_DYNAMIC_CAST
29 #include "XnDerivedCast.h"
30 #endif
31 
32 #define _XN_VALIDATE_CAPABILITY_INTERFACE_RET(capInterface, retVal) \
33  if (capInterface == NULL) \
34  return retVal;
35 
36 #define _XN_VALIDATE_CAPABILITY_INTERFACE(capInterface) \
37  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(capInterface, XN_STATUS_INVALID_OPERATION)
38 
39 XnBool XN_CALLBACK_TYPE __ModuleIsCapabilitySupported(XnModuleNodeHandle hInstance, const XnChar* strCapabilityName)
40 {
41  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
42  return pNode->IsCapabilitySupported(strCapabilityName);
43 }
44 
45 XnStatus XN_CALLBACK_TYPE __ModuleInitNotifications(XnModuleNodeHandle hInstance, XnNodeNotifications* pNotifications, void* pCookie)
46 {
47  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
49  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
50  return pInterface->NotifyExState(pNotifications, pCookie);
51 }
52 void XN_CALLBACK_TYPE __ModuleStopNotifications(XnModuleNodeHandle hInstance)
53 {
54  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
56  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
57  pInterface->UnregisterExNotifications();
58 }
59 
60 XnStatus XN_CALLBACK_TYPE __ModuleSetLockState(XnModuleNodeHandle hInstance, XnBool bLocked)
61 {
62  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
63  ModuleLockAwareInterface* pInterface = pNode->GetLockAwareInterface();
64  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
65  return pInterface->SetLockState(bLocked);
66 }
67 
68 XnBool XN_CALLBACK_TYPE __ModuleGetLockState(XnModuleNodeHandle hInstance)
69 {
70  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
71  ModuleLockAwareInterface* pInterface = pNode->GetLockAwareInterface();
72  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
73  return pInterface->GetLockState();
74 }
75 
76 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToLockChange(XnModuleNodeHandle hInstance, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
77 {
78  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
79  ModuleLockAwareInterface* pInterface = pNode->GetLockAwareInterface();
80  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
81  return pInterface->RegisterToLockChange(handler, pCookie, *phCallback);
82 }
83 
84 void XN_CALLBACK_TYPE __ModuleUnregisterFromLockChange(XnModuleNodeHandle hInstance, XnCallbackHandle hCallback)
85 {
86  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
87  ModuleLockAwareInterface* pInterface = pNode->GetLockAwareInterface();
88  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
89  pInterface->UnregisterFromLockChange(hCallback);
90 }
91 
92 XnStatus XN_CALLBACK_TYPE __ModuleGetErrorState(XnModuleNodeHandle hInstance)
93 {
94  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
96  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, XN_STATUS_OK);
97  return pInterface->GetErrorState();
98 }
99 
100 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToErrorStateChange(XnModuleNodeHandle hInstance, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
101 {
102  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
103  ModuleErrorStateInterface* pInterface = pNode->GetErrorStateInterface();
104  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
105  return pInterface->RegisterToErrorStateChange(handler, pCookie, *phCallback);
106 }
107 
108 void XN_CALLBACK_TYPE __ModuleUnregisterFromErrorStateChange(XnModuleNodeHandle hInstance, XnCallbackHandle hCallback)
109 {
110  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
111  ModuleErrorStateInterface* pInterface = pNode->GetErrorStateInterface();
112  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
113  pInterface->UnregisterFromErrorStateChange(hCallback);
114 }
115 
116 XnStatus XN_CALLBACK_TYPE __ModuleGeneralIntGetRange(XnModuleNodeHandle hInstance, const XnChar* strCap, XnInt32* pnMin, XnInt32* pnMax, XnInt32* pnStep, XnInt32* pnDefault, XnBool* pbIsAutoSupported)
117 {
118  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
119  ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
120  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
121  return pInterface->GetRange(strCap, *pnMin, *pnMax, *pnStep, *pnDefault, *pbIsAutoSupported);
122 }
123 
124 XnStatus XN_CALLBACK_TYPE __ModuleGeneralIntGet(XnModuleNodeHandle hInstance, const XnChar* strCap, XnInt32* pnValue)
125 {
126  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
127  ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
128  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
129  return pInterface->Get(strCap, *pnValue);
130 }
131 
132 XnStatus XN_CALLBACK_TYPE __ModuleGeneralIntSet(XnModuleNodeHandle hInstance, const XnChar* strCap, XnInt32 nValue)
133 {
134  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
135  ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
136  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
137  return pInterface->Set(strCap, nValue);
138 }
139 
140 XnStatus XN_CALLBACK_TYPE __ModuleGeneralIntRegisterToValueChange
141  (XnModuleNodeHandle hInstance, const XnChar* strCap, XnModuleStateChangedHandler handler,
142  void* pCookie, XnCallbackHandle* phCallback)
143 {
144  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
145  ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
146  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
147  return pInterface->RegisterToValueChange(strCap, handler, pCookie, *phCallback);
148 }
149 
150 void XN_CALLBACK_TYPE __ModuleGeneralIntUnregisterFromValueChange
151  (XnModuleNodeHandle hInstance, const XnChar* strCap, XnCallbackHandle hCallback)
152 {
153  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
154  ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
155  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
156  pInterface->UnregisterFromValueChange(strCap, hCallback);
157 }
158 
159 XnStatus XN_CALLBACK_TYPE __ModuleSetIntProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnUInt64 nValue)
160 {
161  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
162  return pNode->SetIntProperty(strName, nValue);
163 }
164 
165 XnStatus XN_CALLBACK_TYPE __ModuleSetRealProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnDouble dValue)
166 {
167  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
168  return pNode->SetRealProperty(strName, dValue);
169 }
170 
171 XnStatus XN_CALLBACK_TYPE __ModuleSetStringProperty(XnModuleNodeHandle hInstance, const XnChar* strName, const XnChar* strValue)
172 {
173  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
174  return pNode->SetStringProperty(strName, strValue);
175 }
176 
177 XnStatus XN_CALLBACK_TYPE __ModuleSetGeneralProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer)
178 {
179  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
180  return pNode->SetGeneralProperty(strName, nBufferSize, pBuffer);
181 }
182 
183 XnStatus XN_CALLBACK_TYPE __ModuleGetIntProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnUInt64* pnValue)
184 {
185  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
186  return pNode->GetIntProperty(strName, *pnValue);
187 }
188 
189 XnStatus XN_CALLBACK_TYPE __ModuleGetRealProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnDouble* pdValue)
190 {
191  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
192  return pNode->GetRealProperty(strName, *pdValue);
193 }
194 
195 XnStatus XN_CALLBACK_TYPE __ModuleGetStringProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnChar* csValue, XnUInt32 nBufSize)
196 {
197  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
198  return pNode->GetStringProperty(strName, csValue, nBufSize);
199 }
200 
201 XnStatus XN_CALLBACK_TYPE __ModuleGetGeneralProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnUInt32 nBufferSize, void* pBuffer)
202 {
203  ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
204  return pNode->GetGeneralProperty(strName, nBufferSize, pBuffer);
205 }
206 
207 XnStatus XN_CALLBACK_TYPE __ModuleSetOutputStream(XnModuleNodeHandle hInstance, void *pCookie, XnRecorderOutputStreamInterface *pStream)
208 {
209  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
210  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
211  return pNode->SetOutputStream(pCookie, pStream);
212 }
213 
214 XnStatus XN_CALLBACK_TYPE __ModuleSetInputStream(XnModuleNodeHandle hInstance, void *pStreamCookie, XnPlayerInputStreamInterface *pStream)
215 {
216  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
217  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
218  return pNode->SetInputStream(pStreamCookie, pStream);
219 }
220 
221 XnStatus XN_CALLBACK_TYPE __ModuleReadNext(XnModuleNodeHandle hInstance)
222 {
223  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
224  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
225  return pNode->ReadNext();
226 }
227 
228 XnStatus XN_CALLBACK_TYPE __ModuleSetRepeat(XnModuleNodeHandle hInstance, XnBool bRepeat)
229 {
230  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
231  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
232  return pNode->SetRepeat(bRepeat);
233 }
234 
235 XnStatus XN_CALLBACK_TYPE __ModuleSeekToTimeStamp(XnModuleNodeHandle hInstance, XnInt64 nTimeOffset, XnPlayerSeekOrigin origin)
236 {
237  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
238  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
239  return pNode->SeekToTimeStamp(nTimeOffset, origin);
240 }
241 
242 XnStatus XN_CALLBACK_TYPE __ModuleSeekToFrame(XnModuleNodeHandle hInstance, const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)
243 {
244  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
245  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
246  return pNode->SeekToFrame(strNodeName, nFrameOffset, origin);
247 }
248 
249 XnStatus XN_CALLBACK_TYPE __ModuleTellTimestamp(XnModuleNodeHandle hInstance, XnUInt64* pnTimestamp)
250 {
251  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
252  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
253  return pNode->TellTimestamp(*pnTimestamp);
254 }
255 
256 XnStatus XN_CALLBACK_TYPE __ModuleTellFrame(XnModuleNodeHandle hInstance, const XnChar* strNodeName, XnUInt32* pnFrame)
257 {
258  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
259  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
260  return pNode->TellFrame(strNodeName, *pnFrame);
261 }
262 
263 XnStatus XN_CALLBACK_TYPE __ModuleGetNumFrames(XnModuleNodeHandle hInstance, const XnChar* strNodeName, XnUInt32* pnFrames)
264 {
265  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
266  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
267  return pNode->GetNumFrames(strNodeName, *pnFrames);
268 }
269 
270 const XnChar* XN_CALLBACK_TYPE __ModuleGetSupportedFormat(XnModuleNodeHandle hInstance)
271 {
272  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
273  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
274  return pNode->GetSupportedFormat();
275 }
276 
277 XnBool XN_CALLBACK_TYPE __ModuleIsEOF(XnModuleNodeHandle hGenerator)
278 {
279  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
280  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
281  return pNode->IsEOF();
282 }
283 
284 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToEndOfFileReached(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
285 {
286  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
287  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
288  return pNode->RegisterToEndOfFileReached(handler, pCookie, *phCallback);
289 }
290 
291 void XN_CALLBACK_TYPE __ModuleUnregisterFromEndOfFileReached(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
292 {
293  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
294  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
295  pNode->UnregisterFromEndOfFileReached(hCallback);
296 }
297 
298 XnStatus XN_CALLBACK_TYPE __ModuleSetNodeNotifications(XnModuleNodeHandle hInstance, void *pNodeNotificationsCookie, XnNodeNotifications *pNodeNotifications)
299 {
300  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
301  ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
302  return pNode->SetNodeNotifications(pNodeNotificationsCookie, pNodeNotifications);
303 }
304 
305 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeAdded(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, XnProductionNodeType type, XnCodecID compression)
306 {
307  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
308  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
309  return pNode->OnNodeAdded(strNodeName, type, compression);
310 }
311 
312 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeRemoved(XnModuleNodeHandle hGenerator, const XnChar *strNodeName)
313 {
314  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
315  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
316  return pNode->OnNodeRemoved(strNodeName);
317 }
318 
319 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeIntPropChanged(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, const XnChar* strPropName, XnUInt64 nValue)
320 {
321  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
322  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
323  return pNode->OnNodeIntPropChanged(strNodeName, strPropName, nValue);
324 }
325 
326 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeRealPropChanged(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, const XnChar* strPropName, XnDouble dValue)
327 {
328  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
329  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
330  return pNode->OnNodeRealPropChanged(strNodeName, strPropName, dValue);
331 }
332 
333 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeStringPropChanged(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, const XnChar* strPropName, const XnChar* strValue)
334 {
335  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
336  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
337  return pNode->OnNodeStringPropChanged(strNodeName, strPropName, strValue);
338 }
339 
340 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeGeneralPropChanged(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, const XnChar* strPropName, XnUInt32 nBufferSize, const void* pBuffer)
341 {
342  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
343  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
344  return pNode->OnNodeGeneralPropChanged(strNodeName, strPropName, nBufferSize, pBuffer);
345 }
346 
347 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeNewData(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, XnUInt64 nTimeStamp, XnUInt32 nFrame, const void *pData, XnUInt32 nSize)
348 {
349  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
350  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
351  return pNode->OnNodeNewData(strNodeName, nTimeStamp, nFrame, pData, nSize);
352 }
353 
354 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeStateReady(XnModuleNodeHandle hGenerator, const XnChar *strNodeName)
355 {
356  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
357  ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
358  return pNode->OnNodeStateReady(strNodeName);
359 }
360 
361 XnStatus XN_CALLBACK_TYPE __ModuleGetDeviceName(XnModuleNodeHandle hInstance, XnChar* strBuffer, XnUInt32* pnBufferSize)
362 {
363  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
364  ModuleDevice* pNode = dynamic_cast<ModuleDevice*>(pProdNode);
366  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
367  return pInterface->GetDeviceName(strBuffer, *pnBufferSize);
368 }
369 
370 XnStatus XN_CALLBACK_TYPE __ModuleGetVendorSpecificData(XnModuleNodeHandle hInstance, XnChar* strBuffer, XnUInt32* pnBufferSize)
371 {
372  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
373  ModuleDevice* pNode = dynamic_cast<ModuleDevice*>(pProdNode);
375  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
376  return pInterface->GetVendorSpecificData(strBuffer, *pnBufferSize);
377 }
378 
379 XnStatus XN_CALLBACK_TYPE __ModuleGetSerialNumber(XnModuleNodeHandle hInstance, XnChar* strBuffer, XnUInt32* pnBufferSize)
380 {
381  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
382  ModuleDevice* pNode = dynamic_cast<ModuleDevice*>(pProdNode);
384  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
385  return pInterface->GetSerialNumber(strBuffer, *pnBufferSize);
386 }
387 
388 XnStatus XN_CALLBACK_TYPE __ModuleSetMirror(XnModuleNodeHandle hGenerator, XnBool bMirror)
389 {
390  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
391  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
392  ModuleMirrorInterface* pInterface = pNode->GetMirrorInterface();
393  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
394  return pInterface->SetMirror(bMirror);
395 }
396 
397 XnBool XN_CALLBACK_TYPE __ModuleIsMirrored(XnModuleNodeHandle hGenerator)
398 {
399  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
400  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
401  ModuleMirrorInterface* pInterface = pNode->GetMirrorInterface();
402  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
403  return pInterface->IsMirrored();
404 }
405 
406 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToMirrorChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
407 {
408  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
409  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
410  ModuleMirrorInterface* pInterface = pNode->GetMirrorInterface();
411  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
412  return pInterface->RegisterToMirrorChange(handler, pCookie, *phCallback);
413 }
414 
415 void XN_CALLBACK_TYPE __ModuleUnregisterFromMirrorChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
416 {
417  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
418  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
419  ModuleMirrorInterface* pInterface = pNode->GetMirrorInterface();
420  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
421  pInterface->UnregisterFromMirrorChange(hCallback);
422 }
423 
424 XnBool XN_CALLBACK_TYPE __ModuleIsViewPointSupported(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
425 {
426  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
427  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
428  ProductionNode node(hNode);
430  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
431  return pInterface->IsViewPointSupported(node);
432 }
433 
434 XnStatus XN_CALLBACK_TYPE __ModuleSetViewPoint(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
435 {
436  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
437  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
438  ProductionNode node(hNode);
440  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
441  return pInterface->SetViewPoint(node);
442 }
443 
444 XnStatus XN_CALLBACK_TYPE __ModuleResetViewPoint(XnModuleNodeHandle hGenerator)
445 {
446  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
447  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
449  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
450  return pInterface->ResetViewPoint();
451 }
452 
453 XnBool XN_CALLBACK_TYPE __ModuleIsViewPointAs(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
454 {
455  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
456  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
458  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
459  ProductionNode node(hNode);
460  return pInterface->IsViewPointAs(node);
461 }
462 
463 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToViewPointChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
464 {
465  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
466  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
468  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
469  return pInterface->RegisterToViewPointChange(handler, pCookie, *phCallback);
470 }
471 
472 void XN_CALLBACK_TYPE __ModuleUnregisterFromViewPointChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
473 {
474  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
475  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
477  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
478  pInterface->UnregisterFromViewPointChange(hCallback);
479 }
480 
481 XnStatus XN_CALLBACK_TYPE __ModuleGetPixelCoordinatesInViewPoint(XnModuleNodeHandle hGenerator, XnNodeHandle hOther, XnUInt32 x, XnUInt32 y, XnUInt32* pAltX, XnUInt32* pAltY)
482 {
483  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
484  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
486  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
487  ProductionNode node(hOther);
488  return pInterface->GetPixelCoordinatesInViewPoint(node, x, y, *pAltX, *pAltY);
489 }
490 
491 XnBool XN_CALLBACK_TYPE __ModuleCanFrameSyncWith(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
492 {
493  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
494  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
495  ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
496  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
497  ProductionNode node(hNode);
498  return pInterface->CanFrameSyncWith(node);
499 }
500 
501 XnStatus XN_CALLBACK_TYPE __ModuleFrameSyncWith(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
502 {
503  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
504  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
505  ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
506  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
507  ProductionNode node(hNode);
508  return pInterface->FrameSyncWith(node);
509 }
510 
511 XnStatus XN_CALLBACK_TYPE __ModuleStopFrameSyncWith(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
512 {
513  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
514  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
515  ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
516  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
517  ProductionNode node(hNode);
518  return pInterface->StopFrameSyncWith(node);
519 }
520 
521 XnBool XN_CALLBACK_TYPE __ModuleIsFrameSyncedWith(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
522 {
523  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
524  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
525  ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
526  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
527  ProductionNode node(hNode);
528  return pInterface->IsFrameSyncedWith(node);
529 }
530 
531 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToFrameSyncChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
532 {
533  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
534  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
535  ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
536  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
537  return pInterface->RegisterToFrameSyncChange(handler, pCookie, *phCallback);
538 }
539 
540 void XN_CALLBACK_TYPE __ModuleUnregisterFromFrameSyncChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
541 {
542  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
543  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
544  ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
545  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
546  pInterface->UnregisterFromFrameSyncChange(hCallback);
547 }
548 
549 XnStatus XN_CALLBACK_TYPE __ModuleStartGenerating(XnModuleNodeHandle hGenerator)
550 {
551  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
552  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
553  return pNode->StartGenerating();
554 }
555 
556 XnBool XN_CALLBACK_TYPE __ModuleIsGenerating(XnModuleNodeHandle hGenerator)
557 {
558  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
559  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
560  return pNode->IsGenerating();
561 }
562 
563 void XN_CALLBACK_TYPE __ModuleStopGenerating(XnModuleNodeHandle hGenerator)
564 {
565  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
566  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
567  pNode->StopGenerating();
568 }
569 
570 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToGenerationRunningChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
571 {
572  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
573  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
574  return pNode->RegisterToGenerationRunningChange(handler, pCookie, *phCallback);
575 }
576 
577 void XN_CALLBACK_TYPE __ModuleUnregisterFromGenerationRunningChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
578 {
579  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
580  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
581  pNode->UnregisterFromGenerationRunningChange(hCallback);
582 }
583 
584 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToNewDataAvailable(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
585 {
586  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
587  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
588  return pNode->RegisterToNewDataAvailable(handler, pCookie, *phCallback);
589 }
590 
591 void XN_CALLBACK_TYPE __ModuleUnregisterFromNewDataAvailable(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
592 {
593  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
594  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
595  pNode->UnregisterFromNewDataAvailable(hCallback);
596 }
597 
598 XnBool XN_CALLBACK_TYPE __ModuleIsNewDataAvailable(XnModuleNodeHandle hGenerator, XnUInt64* pnTimestamp)
599 {
600  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
601  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
602  return pNode->IsNewDataAvailable(*pnTimestamp);
603 }
604 
605 XnStatus XN_CALLBACK_TYPE __ModuleUpdateData(XnModuleNodeHandle hGenerator)
606 {
607  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
608  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
609  return pNode->UpdateData();
610 }
611 
612 const void* XN_CALLBACK_TYPE __ModuleGetData(XnModuleNodeHandle hGenerator)
613 {
614  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
615  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
616  return pNode->GetData();
617 }
618 
619 XnUInt32 XN_CALLBACK_TYPE __ModuleGetDataSize(XnModuleNodeHandle hGenerator)
620 {
621  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
622  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
623  return pNode->GetDataSize();
624 }
625 
626 XnUInt64 XN_CALLBACK_TYPE __ModuleGetTimestamp(XnModuleNodeHandle hGenerator)
627 {
628  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
629  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
630  return pNode->GetTimestamp();
631 }
632 
633 XnUInt32 XN_CALLBACK_TYPE __ModuleGetFrameID(XnModuleNodeHandle hGenerator)
634 {
635  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
636  ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
637  return pNode->GetFrameID();
638 }
639 
640 XnStatus XN_CALLBACK_TYPE __ModuleSetCropping(XnModuleNodeHandle hGenerator, const XnCropping* pCropping)
641 {
642  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
643  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
644  ModuleCroppingInterface* pInterface = pNode->GetCroppingInterface();
645  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
646  return pInterface->SetCropping(*pCropping);
647 }
648 
649 XnStatus XN_CALLBACK_TYPE __ModuleGetCropping(XnModuleNodeHandle hGenerator, XnCropping* pCropping)
650 {
651  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
652  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
653  ModuleCroppingInterface* pInterface = pNode->GetCroppingInterface();
654  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
655  return pInterface->GetCropping(*pCropping);
656 }
657 
658 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToCroppingChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
659 {
660  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
661  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
662  ModuleCroppingInterface* pInterface = pNode->GetCroppingInterface();
663  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
664  return pInterface->RegisterToCroppingChange(handler, pCookie, *phCallback);
665 }
666 
667 void XN_CALLBACK_TYPE __ModuleUnregisterFromCroppingChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
668 {
669  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
670  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
671  ModuleCroppingInterface* pInterface = pNode->GetCroppingInterface();
672  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
673  pInterface->UnregisterFromCroppingChange(hCallback);
674 }
675 
676 XnStatus XN_CALLBACK_TYPE __ModuleSetPowerLineFrequency(XnModuleNodeHandle hGenerator, XnPowerLineFrequency nFrequency)
677 {
678  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
679  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
681  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
682  return pInterface->SetPowerLineFrequency(nFrequency);
683 }
684 
685 XnPowerLineFrequency XN_CALLBACK_TYPE __ModuleGetPowerLineFrequency(XnModuleNodeHandle hGenerator)
686 {
687  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
688  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
690  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, XN_POWER_LINE_FREQUENCY_OFF);
691  return pInterface->GetPowerLineFrequency();
692 }
693 
694 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPowerLineFrequencyChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
695 {
696  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
697  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
699  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
700  return pInterface->RegisterToPowerLineFrequencyChange(handler, pCookie, *phCallback);
701 }
702 
703 void XN_CALLBACK_TYPE __ModuleUnregisterFromPowerLineFrequencyChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
704 {
705  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
706  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
708  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
709  pInterface->UnregisterFromPowerLineFrequencyChange(hCallback);
710 }
711 
712 XnUInt32 XN_CALLBACK_TYPE __ModuleGetSupportedMapOutputModesCount(XnModuleNodeHandle hGenerator)
713 {
714  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
715  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
716  return pNode->GetSupportedMapOutputModesCount();
717 }
718 
719 XnStatus XN_CALLBACK_TYPE __ModuleGetSupportedMapOutputModes(XnModuleNodeHandle hGenerator, XnMapOutputMode* aModes, XnUInt32* pnCount)
720 {
721  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
722  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
723  return pNode->GetSupportedMapOutputModes(aModes, *pnCount);
724 }
725 
726 XnStatus XN_CALLBACK_TYPE __ModuleSetMapOutputMode(XnModuleNodeHandle hGenerator, const XnMapOutputMode* pOutputMode)
727 {
728  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
729  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
730  return pNode->SetMapOutputMode(*pOutputMode);
731 }
732 
733 XnStatus XN_CALLBACK_TYPE __ModuleGetMapOutputMode(XnModuleNodeHandle hGenerator, XnMapOutputMode* pOutputMode)
734 {
735  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
736  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
737  return pNode->GetMapOutputMode(*pOutputMode);
738 }
739 
740 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToMapOutputModeChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
741 {
742  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
743  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
744  return pNode->RegisterToMapOutputModeChange(handler, pCookie, *phCallback);
745 }
746 
747 void XN_CALLBACK_TYPE __ModuleUnregisterFromMapOutputModeChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
748 {
749  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
750  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
751  pNode->UnregisterFromMapOutputModeChange(hCallback);
752 }
753 
754 XnUInt32 XN_CALLBACK_TYPE __ModuleGetBytesPerPixel(XnModuleNodeHandle hGenerator)
755 {
756  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
757  ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
758  return pNode->GetBytesPerPixel();
759 }
760 
761 XnUInt32 XN_CALLBACK_TYPE __ModuleGetSupportedUserPositionsCount(XnModuleNodeHandle hGenerator)
762 {
763  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
764  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
766  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, 0);
767  return pInterface->GetSupportedUserPositionsCount();
768 }
769 
770 XnStatus XN_CALLBACK_TYPE __ModuleSetUserPosition(XnModuleNodeHandle hGenerator, XnUInt32 nIndex, const XnBoundingBox3D* pPosition)
771 {
772  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
773  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
775  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
776  return pInterface->SetUserPosition(nIndex, *pPosition);
777 }
778 
779 XnStatus XN_CALLBACK_TYPE __ModuleGetUserPosition(XnModuleNodeHandle hGenerator, XnUInt32 nIndex, XnBoundingBox3D* pPosition)
780 {
781  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
782  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
784  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
785  return pInterface->GetUserPosition(nIndex, *pPosition);
786 }
787 
788 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToUserPositionChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
789 {
790  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
791  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
793  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
794  return pInterface->RegisterToUserPositionChange(handler, pCookie, *phCallback);
795 }
796 
797 void XN_CALLBACK_TYPE __ModuleUnregisterFromUserPositionChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
798 {
799  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
800  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
802  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
803  pInterface->UnregisterFromUserPositionChange(hCallback);
804 }
805 
806 XnDepthPixel XN_CALLBACK_TYPE __ModuleGetDeviceMaxDepth(XnModuleNodeHandle hGenerator)
807 {
808  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
809  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
810  return pNode->GetDeviceMaxDepth();
811 }
812 
813 void XN_CALLBACK_TYPE __ModuleGetFieldOfView(XnModuleNodeHandle hGenerator, XnFieldOfView* pFOV)
814 {
815  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
816  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
817  pNode->GetFieldOfView(*pFOV);
818 }
819 
820 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToFieldOfViewChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
821 {
822  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
823  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
824  return pNode->RegisterToFieldOfViewChange(handler, pCookie, *phCallback);
825 }
826 
827 void XN_CALLBACK_TYPE __ModuleUnregisterFromFieldOfViewChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
828 {
829  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
830  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
831  pNode->UnregisterFromFieldOfViewChange(hCallback);
832 }
833 
834 XnDepthPixel* XN_CALLBACK_TYPE __ModuleGetDepthMap(XnModuleNodeHandle hGenerator)
835 {
836  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
837  ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
838  return pNode->GetDepthMap();
839 }
840 
841 XnUInt8* XN_CALLBACK_TYPE __ModuleGetImageMap(XnModuleNodeHandle hGenerator)
842 {
843  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
844  ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
845  return pNode->GetImageMap();
846 }
847 
848 XnBool XN_CALLBACK_TYPE __ModuleIsPixelFormatSupported(XnModuleNodeHandle hGenerator, XnPixelFormat Format)
849 {
850  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
851  ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
852  return pNode->IsPixelFormatSupported(Format);
853 }
854 
855 XnStatus XN_CALLBACK_TYPE __ModuleSetPixelFormat(XnModuleNodeHandle hGenerator, XnPixelFormat Format)
856 {
857  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
858  ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
859  return pNode->SetPixelFormat(Format);
860 }
861 
862 XnPixelFormat XN_CALLBACK_TYPE __ModuleGetPixelFormat(XnModuleNodeHandle hGenerator)
863 {
864  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
865  ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
866  return pNode->GetPixelFormat();
867 }
868 
869 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPixelFormatChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
870 {
871  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
872  ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
873  return pNode->RegisterToPixelFormatChange(handler, pCookie, *phCallback);
874 }
875 
876 void XN_CALLBACK_TYPE __ModuleUnregisterFromPixelFormatChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
877 {
878  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
879  ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
880  pNode->UnregisterFromPixelFormatChange(hCallback);
881 }
882 
883 XnIRPixel* XN_CALLBACK_TYPE __ModuleGetIRMap(XnModuleNodeHandle hGenerator)
884 {
885  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
886  ModuleIRGenerator* pNode = dynamic_cast<ModuleIRGenerator*>(pProdNode);
887  return pNode->GetIRMap();
888 }
889 
890 XnStatus XN_CALLBACK_TYPE __ModuleAddGesture(XnModuleNodeHandle hGenerator, const XnChar* strGesture, XnBoundingBox3D* pArea)
891 {
892  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
893  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
894  return pNode->AddGesture(strGesture, pArea);
895 }
896 
897 XnStatus XN_CALLBACK_TYPE __ModuleRemoveGesture(XnModuleNodeHandle hGenerator, const XnChar* strGesture)
898 {
899  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
900  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
901  return pNode->RemoveGesture(strGesture);
902 }
903 XnStatus XN_CALLBACK_TYPE __ModuleGetActiveGestures(XnModuleNodeHandle hGenerator, XnChar** pstrGestures, XnUInt16* pnGestures)
904 {
905  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
906  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
907  return pNode->GetActiveGestures(pstrGestures, *pnGestures);
908 }
909 XnStatus XN_CALLBACK_TYPE __ModuleGetAllActiveGestures(XnModuleNodeHandle hGenerator, XnChar** pstrGestures, XnUInt32 nNameLength, XnUInt16* pnGestures)
910 {
911  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
912  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
913  return pNode->GetAllActiveGestures(pstrGestures, nNameLength, *pnGestures);
914 }
915 XnStatus XN_CALLBACK_TYPE __ModuleEnumerateGestures(XnModuleNodeHandle hGenerator, XnChar** pstrGestures, XnUInt16* pnGestures)
916 {
917  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
918  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
919  return pNode->EnumerateGestures(pstrGestures, *pnGestures);
920 }
921 XnStatus XN_CALLBACK_TYPE __ModuleEnumerateAllGestures(XnModuleNodeHandle hGenerator, XnChar** pstrGestures, XnUInt32 nNameLength, XnUInt16* pnGestures)
922 {
923  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
924  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
925  return pNode->EnumerateAllGestures(pstrGestures, nNameLength, *pnGestures);
926 }
927 XnBool XN_CALLBACK_TYPE __ModuleIsGestureAvailable(XnModuleNodeHandle hGenerator, const XnChar* strGesture)
928 {
929  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
930  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
931  return pNode->IsGestureAvailable(strGesture);
932 }
933 XnBool XN_CALLBACK_TYPE __ModuleIsGestureProgressSupported(XnModuleNodeHandle hGenerator, const XnChar* strGesture)
934 {
935  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
936  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
937  return pNode->IsGestureProgressSupported(strGesture);
938 }
939 XnStatus XN_CALLBACK_TYPE __ModuleRegisterGestureCallbacks(XnModuleNodeHandle hGenerator, XnModuleGestureRecognized RecognizedCB, XnModuleGestureProgress ProgressCB, void* pCookie, XnCallbackHandle* phCallback)
940 {
941  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
942  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
943  return pNode->RegisterGestureCallbacks(RecognizedCB, ProgressCB, pCookie, *phCallback);
944 }
945 void XN_CALLBACK_TYPE __ModuleUnregisterGestureCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
946 {
947  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
948  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
949  pNode->UnregisterGestureCallbacks(hCallback);
950 }
951 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToGestureChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
952 {
953  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
954  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
955  return pNode->RegisterToGestureChange(handler, pCookie, *phCallback);
956 }
957 void XN_CALLBACK_TYPE __ModuleUnregisterFromGestureChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
958 {
959  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
960  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
961  pNode->UnregisterFromGestureChange(hCallback);
962 }
963 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToGestureIntermediateStageCompleted(XnModuleNodeHandle hGenerator, XnModuleGestureIntermediateStageCompleted handler, void* pCookie, XnCallbackHandle* phCallback)
964 {
965  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
966  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
967  return pNode->RegisterToGestureIntermediateStageCompleted(handler, pCookie, *phCallback);
968 }
969 void XN_CALLBACK_TYPE __ModuleUnregisterFromGestureIntermediateStageCompleted(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
970 {
971  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
972  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
974 }
975 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToGestureReadyForNextIntermediateStage(XnModuleNodeHandle hGenerator, XnModuleGestureReadyForNextIntermediateStage handler, void* pCookie, XnCallbackHandle* phCallback)
976 {
977  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
978  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
979  return pNode->RegisterToGestureReadyForNextIntermediateStage(handler, pCookie, *phCallback);
980 }
981 void XN_CALLBACK_TYPE __ModuleUnregisterFromGestureReadyForNextIntermediateStage(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
982 {
983  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
984  ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
986 }
987 
988 const XnLabel* XN_CALLBACK_TYPE __ModuleGetLabelMap(XnModuleNodeHandle hGenerator)
989 {
990  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
991  ModuleSceneAnalyzer* pNode = dynamic_cast<ModuleSceneAnalyzer*>(pProdNode);
992  return pNode->GetLabelMap();
993 }
994 XnStatus XN_CALLBACK_TYPE __ModuleGetFloor(XnModuleNodeHandle hGenerator, XnPlane3D* pPlane)
995 {
996  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
997  ModuleSceneAnalyzer* pNode = dynamic_cast<ModuleSceneAnalyzer*>(pProdNode);
998  return pNode->GetFloor(*pPlane);
999 }
1000 
1001 XnStatus XN_CALLBACK_TYPE __ModuleRegisterHandCallbacks(XnModuleNodeHandle hGenerator, XnModuleHandCreate CreateCB, XnModuleHandUpdate UpdateCB, XnModuleHandDestroy DestroyCB, void* pCookie, XnCallbackHandle* phCallback)
1002 {
1003  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1004  ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1005  return pNode->RegisterHandCallbacks(CreateCB, UpdateCB, DestroyCB, pCookie, *phCallback);
1006 }
1007 void XN_CALLBACK_TYPE __ModuleUnregisterHandCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1008 {
1009  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1010  ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1011  pNode->UnregisterHandCallbacks(hCallback);
1012 }
1013 XnStatus XN_CALLBACK_TYPE __ModuleStopTracking(XnModuleNodeHandle hGenerator, XnUserID user)
1014 {
1015  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1016  ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1017  return pNode->StopTracking(user);
1018 }
1019 XnStatus XN_CALLBACK_TYPE __ModuleStopTrackingAll(XnModuleNodeHandle hGenerator)
1020 {
1021  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1022  ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1023  return pNode->StopTrackingAll();
1024 }
1025 XnStatus XN_CALLBACK_TYPE __ModuleStartTracking(XnModuleNodeHandle hGenerator, const XnPoint3D* pPosition)
1026 {
1027  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1028  ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1029  return pNode->StartTracking(*pPosition);
1030 }
1031 XnStatus XN_CALLBACK_TYPE __ModuleSetTrackingSmoothing(XnModuleNodeHandle hGenerator, XnFloat fSmoothingFactor)
1032 {
1033  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1034  ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1035  return pNode->SetSmoothing(fSmoothingFactor);
1036 }
1037 
1038 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToHandTouchingFOVEdgeCallback(XnModuleNodeHandle hGenerator, XnModuleHandTouchingFOVEdge handler, void* pCookie, XnCallbackHandle* phCallback)
1039 {
1040  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1041  ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1043  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1044  return pInterface->RegisterToHandTouchingFOVEdge(handler, pCookie, *phCallback);
1045 }
1046 void XN_CALLBACK_TYPE __ModuleUnregisterFromHandTouchingFOVEdgeCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1047 {
1048  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1049  ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1051  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, );
1052  pInterface->UnregisterFromHandTouchingFOVEdge(hCallback);
1053 }
1054 
1055 XnBool XN_CALLBACK_TYPE __ModuleIsJointAvailable(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint)
1056 {
1057  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1058  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1059  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1060  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
1061  return pInterface->IsJointAvailable(eJoint);
1062 }
1063 XnBool XN_CALLBACK_TYPE __ModuleIsProfileAvailable(XnModuleNodeHandle hGenerator, XnSkeletonProfile eProfile)
1064 {
1065  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1066  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1067  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1068  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
1069  return pInterface->IsProfileAvailable(eProfile);
1070 }
1071 XnStatus XN_CALLBACK_TYPE __ModuleSetSkeletonProfile(XnModuleNodeHandle hGenerator, XnSkeletonProfile eProfile)
1072 {
1073  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1074  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1075  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1076  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1077  return pInterface->SetSkeletonProfile(eProfile);
1078 }
1079 XnStatus XN_CALLBACK_TYPE __ModuleSetJointActive(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint, XnBool bState)
1080 {
1081  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1082  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1083  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1084  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1085  return pInterface->SetJointActive(eJoint, bState);
1086 }
1087 XnBool XN_CALLBACK_TYPE __ModuleIsJointActive(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint)
1088 {
1089  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1090  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1091  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1092  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
1093  return pInterface->IsJointActive(eJoint);
1094 }
1095 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToJointConfigurationChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
1096 {
1097  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1098  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1099  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1100  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1101  return pInterface->RegisterToJointConfigurationChange(handler, pCookie, *phCallback);
1102 }
1103 void XN_CALLBACK_TYPE __ModuleUnregisterFromJointConfigurationChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1104 {
1105  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1106  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1107  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1108  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1109  pInterface->UnregisterFromJointConfigurationChange(hCallback);
1110 }
1111 XnStatus XN_CALLBACK_TYPE __ModuleEnumerateActiveJoints(XnModuleNodeHandle hGenerator, XnSkeletonJoint* pJoints, XnUInt16* pnJoints)
1112 {
1113  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1114  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1115  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1116  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1117  return pInterface->EnumerateActiveJoints(pJoints, *pnJoints);
1118 }
1119 XnStatus XN_CALLBACK_TYPE __ModuleGetSkeletonJoint(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation* pJoint)
1120 {
1121  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1122  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1123  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1124  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1125  return pInterface->GetSkeletonJoint(user, eJoint, *pJoint);
1126 }
1127 XnStatus XN_CALLBACK_TYPE __ModuleGetSkeletonJointPosition(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition* pJoint)
1128 {
1129  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1130  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1131  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1132  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1133  return pInterface->GetSkeletonJointPosition(user, eJoint, *pJoint);
1134 }
1135 XnStatus XN_CALLBACK_TYPE __ModuleGetSkeletonJointOrientation(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation* pJoint)
1136 {
1137  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1138  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1139  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1140  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1141  return pInterface->GetSkeletonJointOrientation(user, eJoint, *pJoint);
1142 }
1143 XnBool XN_CALLBACK_TYPE __ModuleIsSkeletonTracking(XnModuleNodeHandle hGenerator, XnUserID user)
1144 {
1145  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1146  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1147  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1148  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
1149  return pInterface->IsTracking(user);
1150 }
1151 XnBool XN_CALLBACK_TYPE __ModuleIsSkeletonCalibrated(XnModuleNodeHandle hGenerator, XnUserID user)
1152 {
1153  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1154  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1155  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1156  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
1157  return pInterface->IsCalibrated(user);
1158 }
1159 XnBool XN_CALLBACK_TYPE __ModuleIsSkeletonCalibrating(XnModuleNodeHandle hGenerator, XnUserID user)
1160 {
1161  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1162  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1163  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1164  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
1165  return pInterface->IsCalibrating(user);
1166 }
1167 
1168 XnStatus XN_CALLBACK_TYPE __ModuleRequestSkeletonCalibration(XnModuleNodeHandle hGenerator, XnUserID user, XnBool bForce)
1169 {
1170  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1171  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1172  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1173  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1174  return pInterface->RequestCalibration(user, bForce);
1175 }
1176 XnStatus XN_CALLBACK_TYPE __ModuleAbortSkeletonCalibration(XnModuleNodeHandle hGenerator, XnUserID user)
1177 {
1178  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1179  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1180  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1181  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1182  return pInterface->AbortCalibration(user);
1183 }
1184 XnStatus XN_CALLBACK_TYPE __ModuleSaveCalibrationDataToFile(XnModuleNodeHandle hGenerator, XnUserID user, const XnChar* strFileName)
1185 {
1186  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1187  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1188  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1189  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1190  return pInterface->SaveCalibrationDataToFile(user, strFileName);
1191 }
1192 XnStatus XN_CALLBACK_TYPE __ModuleLoadCalibrationDataFromFile(XnModuleNodeHandle hGenerator, XnUserID user, const XnChar* strFileName)
1193 {
1194  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1195  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1196  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1197  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1198  return pInterface->LoadCalibrationDataFromFile(user, strFileName);
1199 }
1200 XnStatus XN_CALLBACK_TYPE __ModuleSaveCalibrationData(XnModuleNodeHandle hGenerator, XnUserID user, XnUInt32 nSlot)
1201 {
1202  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1203  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1204  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1205  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1206  return pInterface->SaveCalibrationData(user, nSlot);
1207 }
1208 XnStatus XN_CALLBACK_TYPE __ModuleLoadCalibrationData(XnModuleNodeHandle hGenerator, XnUserID user, XnUInt32 nSlot)
1209 {
1210  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1211  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1212  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1213  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1214  return pInterface->LoadCalibrationData(user, nSlot);
1215 }
1216 XnStatus XN_CALLBACK_TYPE __ModuleClearCalibrationData(XnModuleNodeHandle hGenerator, XnUInt32 nSlot)
1217 {
1218  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1219  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1220  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1221  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1222  return pInterface->ClearCalibrationData(nSlot);
1223 }
1224 XnBool XN_CALLBACK_TYPE __ModuleIsCalibrationData(XnModuleNodeHandle hGenerator, XnUInt32 nSlot)
1225 {
1226  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1227  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1228  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1229  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
1230  return pInterface->IsCalibrationData(nSlot);
1231 }
1232 XnStatus XN_CALLBACK_TYPE __ModuleStartSkeletonTracking(XnModuleNodeHandle hGenerator, XnUserID user)
1233 {
1234  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1235  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1236  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1237  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1238  return pInterface->StartTracking(user);
1239 }
1240 XnStatus XN_CALLBACK_TYPE __ModuleStopSkeletonTracking(XnModuleNodeHandle hGenerator, XnUserID user)
1241 {
1242  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1243  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1244  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1245  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1246  return pInterface->StopTracking(user);
1247 }
1248 XnStatus XN_CALLBACK_TYPE __ModuleResetSkeleton(XnModuleNodeHandle hGenerator, XnUserID user)
1249 {
1250  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1251  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1252  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1253  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1254  return pInterface->Reset(user);
1255 }
1256 XnBool XN_CALLBACK_TYPE __ModuleNeedPoseForSkeletonCalibration(XnModuleNodeHandle hGenerator)
1257 {
1258  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1259  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1260  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1261  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
1262  return pInterface->NeedPoseForCalibration();
1263 }
1264 XnStatus XN_CALLBACK_TYPE __ModuleGetSkeletonCalibrationPose(XnModuleNodeHandle hGenerator, XnChar* strPose)
1265 {
1266  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1267  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1268  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1269  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1270  return pInterface->GetCalibrationPose(strPose);
1271 }
1272 XnStatus XN_CALLBACK_TYPE __ModuleSetSkeletonSmoothing(XnModuleNodeHandle hGenerator, XnFloat fSmoothingFactor)
1273 {
1274  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1275  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1276  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1277  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1278  return pInterface->SetSmoothing(fSmoothingFactor);
1279 }
1280 XnStatus XN_CALLBACK_TYPE __ModuleRegisterCalibrationCallbacks(XnModuleNodeHandle hGenerator, XnModuleCalibrationStart CalibrationStartCB, XnModuleCalibrationEnd CalibrationEndCB, void* pCookie, XnCallbackHandle* phCallback)
1281 {
1282  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1283  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1284  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1285  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1286  return pInterface->RegisterCalibrationCallbacks(CalibrationStartCB, CalibrationEndCB, pCookie, *phCallback);
1287 }
1288 void XN_CALLBACK_TYPE __ModuleUnregisterCalibrationCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1289 {
1290  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1291  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1292  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1293  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1294  pInterface->UnregisterCalibrationCallbacks(hCallback);
1295 }
1296 
1297 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToCalibrationStartCallback(XnModuleNodeHandle hGenerator, XnModuleCalibrationStart handler, void* pCookie, XnCallbackHandle* phCallback)
1298 {
1299  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1300  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1301  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1302  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1303  return pInterface->RegisterToCalibrationStart(handler, pCookie, *phCallback);
1304 }
1305 void XN_CALLBACK_TYPE __ModuleUnregisterFromCalibrationStartCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1306 {
1307  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1308  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1309  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1310  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1311  pInterface->UnregisterFromCalibrationStart(hCallback);
1312 }
1313 
1314 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToCalibrationInProgressCallback(XnModuleNodeHandle hGenerator, XnModuleCalibrationInProgress handler, void* pCookie, XnCallbackHandle* phCallback)
1315 {
1316  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1317  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1318  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1319  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1320  return pInterface->RegisterToCalibrationInProgress(handler, pCookie, *phCallback);
1321 }
1322 void XN_CALLBACK_TYPE __ModuleUnregisterFromCalibrationInProgressCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1323 {
1324  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1325  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1326  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1327  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1328  pInterface->UnregisterFromCalibrationInProgress(hCallback);
1329 }
1330 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToCalibrationCompleteCallback(XnModuleNodeHandle hGenerator, XnModuleCalibrationComplete handler, void* pCookie, XnCallbackHandle* phCallback)
1331 {
1332  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1333  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1334  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1335  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1336  return pInterface->RegisterToCalibrationComplete(handler, pCookie, *phCallback);
1337 }
1338 void XN_CALLBACK_TYPE __ModuleUnregisterFromCalibrationCompleteCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1339 {
1340  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1341  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1342  ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
1343  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1344  pInterface->UnregisterFromCalibrationComplete(hCallback);
1345 }
1347 XnUInt32 XN_CALLBACK_TYPE __ModuleGetNumberOfPoses(XnModuleNodeHandle hGenerator)
1348 {
1349  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1350  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1352  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, 0);
1353  return pInterface->GetNumberOfPoses();
1354 }
1355 XnStatus XN_CALLBACK_TYPE __ModuleGetAvailablePoses(XnModuleNodeHandle hGenerator, XnChar** pstrPoses, XnUInt32* pnPoses)
1356 {
1357  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1358  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1360  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1361  return pInterface->GetAvailablePoses(pstrPoses, *pnPoses);
1362 }
1363 XnStatus XN_CALLBACK_TYPE __ModuleGetAllAvailablePoses(XnModuleNodeHandle hGenerator, XnChar** pstrPoses, XnUInt32 nNameLength, XnUInt32* pnPoses)
1364 {
1365  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1366  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1368  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1369  return pInterface->GetAllAvailablePoses(pstrPoses, nNameLength, *pnPoses);
1370 }
1371 
1372 
1373 XnStatus XN_CALLBACK_TYPE __ModuleStartPoseDetection(XnModuleNodeHandle hGenerator, const XnChar* strPose, XnUserID user)
1374 {
1375  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1376  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1378  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1379  return pInterface->StartPoseDetection(strPose, user);
1380 }
1381 XnStatus XN_CALLBACK_TYPE __ModuleStopPoseDetection(XnModuleNodeHandle hGenerator, XnUserID user)
1382 {
1383  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1384  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1386  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1387  return pInterface->StopPoseDetection(user);
1388 }
1389 XnStatus XN_CALLBACK_TYPE __ModuleStopSinglePoseDetection(XnModuleNodeHandle hGenerator, XnUserID user, const XnChar* strPose)
1390 {
1391  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1392  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1394  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1395  return pInterface->StopSinglePoseDetection(user, strPose);
1396 }
1397 
1398 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPoseCallbacks(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback PoseDetectionStartCB, XnModulePoseDetectionCallback PoseDetectionEndCB, void* pCookie, XnCallbackHandle* phCallback)
1399 {
1400  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1401  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1403  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1404  return pInterface->RegisterToPoseDetectionCallbacks(PoseDetectionStartCB, PoseDetectionEndCB, pCookie, *phCallback);
1405 }
1406 void XN_CALLBACK_TYPE __ModuleUnregisterFromPoseCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1407 {
1408  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1409  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1411  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1412  pInterface->UnregisterFromPoseDetectionCallbacks(hCallback);
1413 }
1414 
1415 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPoseDetected(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback handler, void* pCookie, XnCallbackHandle* phCallback)
1416 {
1417  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1418  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1420  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1421  return pInterface->RegisterToPoseDetected(handler, pCookie, *phCallback);
1422 }
1423 void XN_CALLBACK_TYPE __ModuleUnregisterFromPoseDetected(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1424 {
1425  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1426  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1428  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1429  pInterface->UnregisterFromPoseDetected(hCallback);
1430 }
1431 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToOutOfPose(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback handler, void* pCookie, XnCallbackHandle* phCallback)
1432 {
1433  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1434  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1436  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1437  return pInterface->RegisterToOutOfPose(handler, pCookie, *phCallback);
1438 }
1439 void XN_CALLBACK_TYPE __ModuleUnregisterFromOutOfPose(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1440 {
1441  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1442  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1444  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1445  pInterface->UnregisterFromOutOfPose(hCallback);
1446 }
1447 
1448 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPoseInProgressCallback(XnModuleNodeHandle hGenerator, XnModulePoseDetectionInProgressCallback handler, void* pCookie, XnCallbackHandle* phCallback)
1449 {
1450  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1451  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1453  _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
1454  return pInterface->RegisterToPoseDetectionInProgress(handler, pCookie, *phCallback);
1455 }
1456 void XN_CALLBACK_TYPE __ModuleUnregisterFromPoseInProgressCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1457 {
1458  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1459  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1461  _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
1462  pInterface->UnregisterFromPoseDetectionInProgress(hCallback);
1463 }
1464 
1465 
1466 XnUInt16 XN_CALLBACK_TYPE __ModuleGetNumberOfUsers(XnModuleNodeHandle hGenerator)
1467 {
1468  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1469  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1470  return pNode->GetNumberOfUsers();
1471 }
1472 XnStatus XN_CALLBACK_TYPE __ModuleGetUsers(XnModuleNodeHandle hGenerator, XnUserID* pUsers, XnUInt16* pnUsers)
1473 {
1474  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1475  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1476  return pNode->GetUsers(pUsers, *pnUsers);
1477 }
1478 XnStatus XN_CALLBACK_TYPE __ModuleGetUserCoM(XnModuleNodeHandle hGenerator, XnUserID user, XnPoint3D* pCoM)
1479 {
1480  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1481  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1482  return pNode->GetCoM(user, *pCoM);
1483 }
1484 XnStatus XN_CALLBACK_TYPE __ModuleGetUserPixels(XnModuleNodeHandle hGenerator, XnUserID user, XnSceneMetaData* pScene)
1485 {
1486  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1487  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1488  return pNode->GetUserPixels(user, pScene);
1489 }
1490 XnStatus XN_CALLBACK_TYPE __ModuleRegisterUserCallbacks(XnModuleNodeHandle hGenerator, XnModuleUserHandler NewUserCB, XnModuleUserHandler LostUserCB, void* pCookie, XnCallbackHandle* phCallback)
1491 {
1492  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1493  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1494  return pNode->RegisterUserCallbacks(NewUserCB, LostUserCB, pCookie, *phCallback);
1495 }
1496 void XN_CALLBACK_TYPE __ModuleUnregisterUserCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1497 {
1498  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1499  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1500  pNode->UnregisterUserCallbacks(hCallback);
1501 }
1502 
1503 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToUserExitCallback(XnModuleNodeHandle hGenerator, XnModuleUserHandler handler, void* pCookie, XnCallbackHandle* phCallback)
1504 {
1505  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1506  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1507  return pNode->RegisterToUserExit(handler, pCookie, *phCallback);
1508 }
1509 void XN_CALLBACK_TYPE __ModuleUnregisterFromUserExitCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1510 {
1511  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1512  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1513  pNode->UnregisterFromUserExit(hCallback);
1514 }
1515 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToUserReEnterCallback(XnModuleNodeHandle hGenerator, XnModuleUserHandler handler, void* pCookie, XnCallbackHandle* phCallback)
1516 {
1517  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1518  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1519  return pNode->RegisterToUserReEnter(handler, pCookie, *phCallback);
1520 }
1521 void XN_CALLBACK_TYPE __ModuleUnregisterFromUserReEnterCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1522 {
1523  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1524  ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1525  pNode->UnregisterFromUserReEnter(hCallback);
1526 }
1527 
1528 
1529 XnUChar* XN_CALLBACK_TYPE __ModuleGetAudioBuffer(XnModuleNodeHandle hGenerator)
1530 {
1531  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1532  ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1533  return pNode->GetAudioBuffer();
1534 }
1535 XnUInt32 XN_CALLBACK_TYPE __ModuleGetSupportedWaveOutputModesCount(XnModuleNodeHandle hGenerator)
1536 {
1537  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1538  ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1539  return pNode->GetSupportedWaveOutputModesCount();
1540 }
1541 XnStatus XN_CALLBACK_TYPE __ModuleGetSupportedWaveOutputModes(XnModuleNodeHandle hGenerator, XnWaveOutputMode* aSupportedModes, XnUInt32* pnCount)
1542 {
1543  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1544  ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1545  return pNode->GetSupportedWaveOutputModes(aSupportedModes, *pnCount);
1546 }
1547 XnStatus XN_CALLBACK_TYPE __ModuleSetWaveOutputMode(XnModuleNodeHandle hGenerator, const XnWaveOutputMode* pOutputMode)
1548 {
1549  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1550  ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1551  return pNode->SetWaveOutputMode(*pOutputMode);
1552 }
1553 XnStatus XN_CALLBACK_TYPE __ModuleGetWaveOutputMode(XnModuleNodeHandle hGenerator, XnWaveOutputMode* pOutputMode)
1554 {
1555  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1556  ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1557  return pNode->GetWaveOutputMode(*pOutputMode);
1558 }
1559 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToWaveOutputModeChanges(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
1560 {
1561  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1562  ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1563  return pNode->RegisterToWaveOutputModeChanges(handler, pCookie, *phCallback);
1564 }
1565 void XN_CALLBACK_TYPE __ModuleUnregisterFromWaveOutputModeChanges(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
1566 {
1567  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1568  ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1569  pNode->UnregisterFromWaveOutputModeChanges(hCallback);
1570 }
1571 
1572 XnCodecID XN_CALLBACK_TYPE __ModuleGetCodecID(XnModuleNodeHandle hCodec)
1573 {
1574  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
1575  ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
1576  return pCodec->GetCodecID();
1577 }
1578 XnStatus XN_CALLBACK_TYPE __ModuleCodecInit(XnModuleNodeHandle hCodec, XnNodeHandle hNode)
1579 {
1580  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
1581  ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
1582  return pCodec->Init(ProductionNode(hNode));
1583 }
1584 XnStatus XN_CALLBACK_TYPE __ModuleCompressData(XnModuleNodeHandle hCodec, const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten)
1585 {
1586  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
1587  ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
1588  return pCodec->CompressData(pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
1589 }
1590 XnStatus XN_CALLBACK_TYPE __ModuleDecompressData(XnModuleNodeHandle hCodec, const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten)
1591 {
1592  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
1593  ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
1594  return pCodec->DecompressData(pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
1595 }
1596 
1597 const XnChar* XN_CALLBACK_TYPE __ModuleScriptGetSupportedFormat(XnModuleNodeHandle hScript)
1598 {
1599  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hScript;
1600  ModuleScriptNode* pScript = dynamic_cast<ModuleScriptNode*>(pProdNode);
1601  return pScript->GetSupportedFormat();
1602 }
1603 
1604 XnStatus XN_CALLBACK_TYPE __ModuleLoadScriptFromFile(XnModuleNodeHandle hScript, const XnChar* strFileName)
1605 {
1606  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hScript;
1607  ModuleScriptNode* pScript = dynamic_cast<ModuleScriptNode*>(pProdNode);
1608  return pScript->LoadScriptFromFile(strFileName);
1609 }
1610 
1611 XnStatus XN_CALLBACK_TYPE __ModuleLoadScriptFromString(XnModuleNodeHandle hScript, const XnChar* strScript)
1612 {
1613  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hScript;
1614  ModuleScriptNode* pScript = dynamic_cast<ModuleScriptNode*>(pProdNode);
1615  return pScript->LoadScriptFromString(strScript);
1616 }
1617 
1618 XnStatus XN_CALLBACK_TYPE __ModuleScriptRun(XnModuleNodeHandle hScript, XnNodeInfoList* pCreatedNodes, XnEnumerationErrors* pErrors)
1619 {
1620  ModuleProductionNode* pProdNode = (ModuleProductionNode*)hScript;
1621  ModuleScriptNode* pScript = dynamic_cast<ModuleScriptNode*>(pProdNode);
1622  NodeInfoList createdNodes(pCreatedNodes);
1623  EnumerationErrors errors(pErrors);
1624  return pScript->Run(createdNodes, errors);
1625 }
1626 
1627 void XN_CALLBACK_TYPE __ModuleGetExtendedSerializationInterface(XnModuleExtendedSerializationInterface* pInterface)
1628 {
1629  pInterface->InitNotifications = __ModuleInitNotifications;
1630  pInterface->StopNotifications = __ModuleStopNotifications;
1631 }
1632 
1633 void XN_CALLBACK_TYPE __ModuleGetLockAwareInterface(XnModuleLockAwareInterface* pInterface)
1634 {
1635  pInterface->SetLockState = __ModuleSetLockState;
1636  pInterface->GetLockState = __ModuleGetLockState;
1637  pInterface->RegisterToLockChange = __ModuleRegisterToLockChange;
1638  pInterface->UnregisterFromLockChange = __ModuleUnregisterFromLockChange;
1639 }
1640 
1641 void XN_CALLBACK_TYPE __ModuleGetErrorStateInterface(XnModuleErrorStateInterface* pInterface)
1642 {
1643  pInterface->GetErrorState = __ModuleGetErrorState;
1644  pInterface->RegisterToErrorStateChange = __ModuleRegisterToErrorStateChange;
1645  pInterface->UnregisterFromErrorStateChange = __ModuleUnregisterFromErrorStateChange;
1646 }
1647 
1648 void XN_CALLBACK_TYPE __ModuleGetGeneralIntInterface(XnModuleGeneralIntInterface* pInterface)
1649 {
1650  pInterface->GetRange = __ModuleGeneralIntGetRange;
1651  pInterface->Get = __ModuleGeneralIntGet;
1652  pInterface->Set = __ModuleGeneralIntSet;
1653  pInterface->RegisterToValueChange = __ModuleGeneralIntRegisterToValueChange;
1654  pInterface->UnregisterFromValueChange = __ModuleGeneralIntUnregisterFromValueChange;
1655 }
1656 
1657 void XN_CALLBACK_TYPE __ModuleGetProductionNodeInterface(XnModuleProductionNodeInterface* pInterface)
1658 {
1659  pInterface->IsCapabilitySupported = __ModuleIsCapabilitySupported;
1660  pInterface->SetIntProperty = __ModuleSetIntProperty;
1661  pInterface->SetRealProperty = __ModuleSetRealProperty;
1662  pInterface->SetStringProperty = __ModuleSetStringProperty;
1663  pInterface->SetGeneralProperty = __ModuleSetGeneralProperty;
1664  pInterface->GetIntProperty = __ModuleGetIntProperty;
1665  pInterface->GetRealProperty = __ModuleGetRealProperty;
1666  pInterface->GetStringProperty = __ModuleGetStringProperty;
1667  pInterface->GetGeneralProperty = __ModuleGetGeneralProperty;
1668 
1669  __ModuleGetExtendedSerializationInterface(pInterface->pExtendedSerializationInterface);
1670  __ModuleGetLockAwareInterface(pInterface->pLockAwareInterface);
1671  __ModuleGetErrorStateInterface(pInterface->pErrorStateInterface);
1672  __ModuleGetGeneralIntInterface(pInterface->pGeneralIntInterface);
1673 }
1674 
1675 void XN_CALLBACK_TYPE __ModuleGetDeviceIdentificationInterface(XnModuleDeviceIdentificationInterface* pInterface)
1676 {
1677  pInterface->GetDeviceName = __ModuleGetDeviceName;
1678  pInterface->GetVendorSpecificData = __ModuleGetVendorSpecificData;
1679  pInterface->GetSerialNumber = __ModuleGetSerialNumber;
1680 }
1681 
1682 void XN_CALLBACK_TYPE __ModuleGetDeviceInterface(XnModuleDeviceInterface* pInterface)
1683 {
1684  __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
1685  __ModuleGetDeviceIdentificationInterface(pInterface->pDeviceIdentificationInterface);
1686 }
1687 
1688 void XN_CALLBACK_TYPE __ModuleGetMirrorInterface(XnModuleMirrorInterface* pInterface)
1689 {
1690  pInterface->SetMirror = __ModuleSetMirror;
1691  pInterface->IsMirrored = __ModuleIsMirrored;
1692  pInterface->RegisterToMirrorChange = __ModuleRegisterToMirrorChange;
1693  pInterface->UnregisterFromMirrorChange = __ModuleUnregisterFromMirrorChange;
1694 }
1695 
1696 void XN_CALLBACK_TYPE __ModuleGetAlternativeViewPointInterface(XnModuleAlternativeViewPointInterface* pInterface)
1697 {
1698  pInterface->IsViewPointSupported = __ModuleIsViewPointSupported;
1699  pInterface->SetViewPoint = __ModuleSetViewPoint;
1700  pInterface->ResetViewPoint = __ModuleResetViewPoint;
1701  pInterface->IsViewPointAs = __ModuleIsViewPointAs;
1702  pInterface->RegisterToViewPointChange = __ModuleRegisterToViewPointChange;
1703  pInterface->UnregisterFromViewPointChange = __ModuleUnregisterFromViewPointChange;
1704  pInterface->GetPixelCoordinatesInViewPoint = __ModuleGetPixelCoordinatesInViewPoint;
1705 }
1706 
1707 void XN_CALLBACK_TYPE __ModuleGetFrameSyncInterface(XnModuleFrameSyncInterface* pInterface)
1708 {
1709  pInterface->CanFrameSyncWith = __ModuleCanFrameSyncWith;
1710  pInterface->FrameSyncWith = __ModuleFrameSyncWith;
1711  pInterface->StopFrameSyncWith = __ModuleStopFrameSyncWith;
1712  pInterface->IsFrameSyncedWith = __ModuleIsFrameSyncedWith;
1713  pInterface->RegisterToFrameSyncChange = __ModuleRegisterToFrameSyncChange;
1714  pInterface->UnregisterFromFrameSyncChange = __ModuleUnregisterFromFrameSyncChange;
1715 }
1716 
1717 void XN_CALLBACK_TYPE __ModuleGetGeneratorInterface(XnModuleGeneratorInterface* pInterface)
1718 {
1719  __ModuleGetProductionNodeInterface(pInterface->pProductionNodeInterface);
1720  pInterface->StartGenerating = __ModuleStartGenerating;
1721  pInterface->IsGenerating = __ModuleIsGenerating;
1722  pInterface->StopGenerating = __ModuleStopGenerating;
1723  pInterface->RegisterToGenerationRunningChange = __ModuleRegisterToGenerationRunningChange;
1724  pInterface->UnregisterFromGenerationRunningChange = __ModuleUnregisterFromGenerationRunningChange;
1725  pInterface->RegisterToNewDataAvailable = __ModuleRegisterToNewDataAvailable;
1726  pInterface->UnregisterFromNewDataAvailable = __ModuleUnregisterFromNewDataAvailable;
1727  pInterface->IsNewDataAvailable = __ModuleIsNewDataAvailable;
1728  pInterface->UpdateData = __ModuleUpdateData;
1729  pInterface->GetData = __ModuleGetData;
1730  pInterface->GetDataSize = __ModuleGetDataSize;
1731  pInterface->GetTimestamp = __ModuleGetTimestamp;
1732  pInterface->GetFrameID = __ModuleGetFrameID;
1733  __ModuleGetMirrorInterface(pInterface->pMirrorInterface);
1734  __ModuleGetAlternativeViewPointInterface(pInterface->pAlternativeViewPointInterface);
1735  __ModuleGetFrameSyncInterface(pInterface->pFrameSyncInterface);
1736 }
1737 
1738 void XN_CALLBACK_TYPE __ModuleGetNodeNotificationsInterface(XnNodeNotifications *pInterface)
1739 {
1740  pInterface->OnNodeAdded = __ModuleOnNodeAdded;
1741  pInterface->OnNodeRemoved = __ModuleOnNodeRemoved;
1742  pInterface->OnNodeIntPropChanged = __ModuleOnNodeIntPropChanged;
1743  pInterface->OnNodeRealPropChanged = __ModuleOnNodeRealPropChanged;
1744  pInterface->OnNodeStringPropChanged = __ModuleOnNodeStringPropChanged;
1745  pInterface->OnNodeGeneralPropChanged = __ModuleOnNodeGeneralPropChanged;
1746  pInterface->OnNodeStateReady = __ModuleOnNodeStateReady;
1747  pInterface->OnNodeNewData = __ModuleOnNodeNewData;
1748 }
1749 
1750 void XN_CALLBACK_TYPE __ModuleGetRecorderInterface(XnModuleRecorderInterface* pInterface)
1751 {
1752  pInterface->SetOutputStream = __ModuleSetOutputStream;
1753  __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
1754  __ModuleGetNodeNotificationsInterface(pInterface->pNodeNotifications);
1755 }
1756 
1757 void XN_CALLBACK_TYPE __ModuleGetPlayerInterface(XnModulePlayerInterface* pInterface)
1758 {
1759  __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
1760  pInterface->SetInputStream = __ModuleSetInputStream;
1761  pInterface->ReadNext = __ModuleReadNext;
1762  pInterface->SetNodeNotifications = __ModuleSetNodeNotifications;
1763  pInterface->SetRepeat = __ModuleSetRepeat;
1764  pInterface->SeekToTimeStamp = __ModuleSeekToTimeStamp;
1765  pInterface->SeekToFrame = __ModuleSeekToFrame;
1766  pInterface->TellTimestamp = __ModuleTellTimestamp;
1767  pInterface->TellFrame = __ModuleTellFrame;
1768  pInterface->GetNumFrames = __ModuleGetNumFrames;
1769  pInterface->GetSupportedFormat = __ModuleGetSupportedFormat;
1770  pInterface->IsEOF = __ModuleIsEOF;
1771  pInterface->RegisterToEndOfFileReached = __ModuleRegisterToEndOfFileReached;
1772  pInterface->UnregisterFromEndOfFileReached = __ModuleUnregisterFromEndOfFileReached;
1773 }
1774 
1775 void XN_CALLBACK_TYPE __ModuleGetCroppingInterface(XnModuleCroppingInterface* pInterface)
1776 {
1777  pInterface->SetCropping = __ModuleSetCropping;
1778  pInterface->GetCropping = __ModuleGetCropping;
1779  pInterface->RegisterToCroppingChange = __ModuleRegisterToCroppingChange;
1780  pInterface->UnregisterFromCroppingChange = __ModuleUnregisterFromCroppingChange;
1781 }
1782 
1783 void XN_CALLBACK_TYPE __ModuleGetAntiFlickerInterface(XnModuleAntiFlickerInterface* pInterface)
1784 {
1785  pInterface->SetPowerLineFrequency = __ModuleSetPowerLineFrequency;
1786  pInterface->GetPowerLineFrequency = __ModuleGetPowerLineFrequency;
1787  pInterface->RegisterToPowerLineFrequencyChange = __ModuleRegisterToPowerLineFrequencyChange;
1788  pInterface->UnregisterFromPowerLineFrequencyChange = __ModuleUnregisterFromPowerLineFrequencyChange;
1789 }
1790 
1791 void XN_CALLBACK_TYPE __ModuleGetMapGeneratorInterface(XnModuleMapGeneratorInterface* pInterface)
1792 {
1793  __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
1794  pInterface->GetSupportedMapOutputModesCount = __ModuleGetSupportedMapOutputModesCount;
1795  pInterface->GetSupportedMapOutputModes = __ModuleGetSupportedMapOutputModes;
1796  pInterface->SetMapOutputMode = __ModuleSetMapOutputMode;
1797  pInterface->GetMapOutputMode = __ModuleGetMapOutputMode;
1798  pInterface->RegisterToMapOutputModeChange = __ModuleRegisterToMapOutputModeChange;
1799  pInterface->UnregisterFromMapOutputModeChange = __ModuleUnregisterFromMapOutputModeChange;
1800  pInterface->GetBytesPerPixel = __ModuleGetBytesPerPixel;
1801  __ModuleGetCroppingInterface(pInterface->pCroppingInterface);
1802  __ModuleGetAntiFlickerInterface(pInterface->pAntiFlickerInterface);
1803 }
1804 
1805 void XN_CALLBACK_TYPE __ModuleGetUserPositionInterface(XnModuleUserPositionCapabilityInterface* pInterface)
1806 {
1807  pInterface->GetSupportedUserPositionsCount = __ModuleGetSupportedUserPositionsCount;
1808  pInterface->SetUserPosition = __ModuleSetUserPosition;
1809  pInterface->GetUserPosition = __ModuleGetUserPosition;
1810  pInterface->RegisterToUserPositionChange = __ModuleRegisterToUserPositionChange;
1811  pInterface->UnregisterFromUserPositionChange = __ModuleUnregisterFromUserPositionChange;
1812 }
1813 
1814 void XN_CALLBACK_TYPE __ModuleGetDepthGeneratorInterface(XnModuleDepthGeneratorInterface* pInterface)
1815 {
1816  __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
1817  pInterface->GetDeviceMaxDepth = __ModuleGetDeviceMaxDepth;
1818  pInterface->GetFieldOfView = __ModuleGetFieldOfView;
1819  pInterface->RegisterToFieldOfViewChange = __ModuleRegisterToFieldOfViewChange;
1820  pInterface->UnregisterFromFieldOfViewChange = __ModuleUnregisterFromFieldOfViewChange;
1821  pInterface->GetDepthMap = __ModuleGetDepthMap;
1822  __ModuleGetUserPositionInterface(pInterface->pUserPositionInterface);
1823 }
1824 
1825 void XN_CALLBACK_TYPE __ModuleGetImageGeneratorInterface(XnModuleImageGeneratorInterface* pInterface)
1826 {
1827  __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
1828  pInterface->GetImageMap = __ModuleGetImageMap;
1829  pInterface->IsPixelFormatSupported = __ModuleIsPixelFormatSupported;
1830  pInterface->SetPixelFormat = __ModuleSetPixelFormat;
1831  pInterface->GetPixelFormat = __ModuleGetPixelFormat;
1832  pInterface->RegisterToPixelFormatChange = __ModuleRegisterToPixelFormatChange;
1833  pInterface->UnregisterFromPixelFormatChange = __ModuleUnregisterFromPixelFormatChange;
1834 }
1835 
1836 void XN_CALLBACK_TYPE __ModuleGetIRGeneratorInterface(XnModuleIRGeneratorInterface* pInterface)
1837 {
1838  __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
1839  pInterface->GetIRMap = __ModuleGetIRMap;
1840 }
1841 
1842 void XN_CALLBACK_TYPE __ModuleGetGestureGeneratorInterface(XnModuleGestureGeneratorInterface* pInterface)
1843 {
1844  __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
1845  pInterface->AddGesture = __ModuleAddGesture;
1846  pInterface->RemoveGesture = __ModuleRemoveGesture;
1847  pInterface->GetActiveGestures = __ModuleGetActiveGestures;
1848  pInterface->GetAllActiveGestures = __ModuleGetAllActiveGestures;
1849  pInterface->EnumerateGestures = __ModuleEnumerateGestures;
1850  pInterface->EnumerateAllGestures = __ModuleEnumerateAllGestures;
1851  pInterface->IsGestureAvailable = __ModuleIsGestureAvailable;
1852  pInterface->IsGestureProgressSupported = __ModuleIsGestureProgressSupported;
1853  pInterface->RegisterGestureCallbacks = __ModuleRegisterGestureCallbacks;
1854  pInterface->UnregisterGestureCallbacks = __ModuleUnregisterGestureCallbacks;
1855  pInterface->RegisterToGestureChange = __ModuleRegisterToGestureChange;
1856  pInterface->UnregisterFromGestureChange = __ModuleUnregisterFromGestureChange;
1857 
1858  pInterface->RegisterToGestureIntermediateStageCompleted = __ModuleRegisterToGestureIntermediateStageCompleted;
1859  pInterface->UnregisterFromGestureIntermediateStageCompleted = __ModuleUnregisterFromGestureIntermediateStageCompleted;
1860  pInterface->RegisterToGestureReadyForNextIntermediateStage = __ModuleRegisterToGestureReadyForNextIntermediateStage;
1861  pInterface->UnregisterFromGestureReadyForNextIntermediateStage = __ModuleUnregisterFromGestureReadyForNextIntermediateStage;
1862 }
1863 
1864 void XN_CALLBACK_TYPE __ModuleGetSceneAnalyzerInterface(XnModuleSceneAnalyzerInterface* pInterface)
1865 {
1866  __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
1867  pInterface->GetLabelMap = __ModuleGetLabelMap;
1868  pInterface->GetFloor = __ModuleGetFloor;
1869 }
1870 
1871 void XN_CALLBACK_TYPE __ModuleGetSkeletonInterface(XnModuleSkeletonCapabilityInterface* pInterface)
1872 {
1873  pInterface->IsJointAvailable = __ModuleIsJointAvailable;
1874  pInterface->IsProfileAvailable = __ModuleIsProfileAvailable;
1875  pInterface->SetSkeletonProfile = __ModuleSetSkeletonProfile;
1876  pInterface->SetJointActive = __ModuleSetJointActive;
1877  pInterface->IsJointActive = __ModuleIsJointActive;
1878  pInterface->RegisterToJointConfigurationChange = __ModuleRegisterToJointConfigurationChange;
1879  pInterface->UnregisterFromJointConfigurationChange = __ModuleUnregisterFromJointConfigurationChange;
1880  pInterface->EnumerateActiveJoints = __ModuleEnumerateActiveJoints;
1881  pInterface->GetSkeletonJoint = __ModuleGetSkeletonJoint;
1882  pInterface->GetSkeletonJointPosition = __ModuleGetSkeletonJointPosition;
1883  pInterface->GetSkeletonJointOrientation = __ModuleGetSkeletonJointOrientation;
1884  pInterface->IsTracking = __ModuleIsSkeletonTracking;
1885  pInterface->IsCalibrated = __ModuleIsSkeletonCalibrated;
1886  pInterface->IsCalibrating = __ModuleIsSkeletonCalibrating;
1887  pInterface->RequestCalibration = __ModuleRequestSkeletonCalibration;
1888  pInterface->AbortCalibration = __ModuleAbortSkeletonCalibration;
1889  pInterface->SaveCalibrationDataToFile = __ModuleSaveCalibrationDataToFile;
1890  pInterface->LoadCalibrationDataFromFile = __ModuleLoadCalibrationDataFromFile;
1891  pInterface->SaveCalibrationData = __ModuleSaveCalibrationData;
1892  pInterface->LoadCalibrationData = __ModuleLoadCalibrationData;
1893  pInterface->ClearCalibrationData = __ModuleClearCalibrationData;
1894  pInterface->IsCalibrationData = __ModuleIsCalibrationData;
1895  pInterface->StartTracking = __ModuleStartSkeletonTracking;
1896  pInterface->StopTracking = __ModuleStopSkeletonTracking;
1897  pInterface->Reset = __ModuleResetSkeleton;
1898  pInterface->NeedPoseForCalibration = __ModuleNeedPoseForSkeletonCalibration;
1899  pInterface->GetCalibrationPose = __ModuleGetSkeletonCalibrationPose;
1900  pInterface->SetSmoothing = __ModuleSetSkeletonSmoothing;
1901  pInterface->RegisterCalibrationCallbacks = __ModuleRegisterCalibrationCallbacks;
1902  pInterface->UnregisterCalibrationCallbacks = __ModuleUnregisterCalibrationCallbacks;
1903 
1904  pInterface->RegisterToCalibrationInProgress = __ModuleRegisterToCalibrationInProgressCallback;
1905  pInterface->UnregisterFromCalibrationInProgress = __ModuleUnregisterFromCalibrationInProgressCallback;
1906  pInterface->RegisterToCalibrationComplete = __ModuleRegisterToCalibrationCompleteCallback;
1907  pInterface->UnregisterFromCalibrationComplete = __ModuleUnregisterFromCalibrationCompleteCallback;
1908 
1909  pInterface->RegisterToCalibrationStart = __ModuleRegisterToCalibrationStartCallback;
1910  pInterface->UnregisterFromCalibrationStart = __ModuleUnregisterFromCalibrationStartCallback;
1911 }
1912 
1913 void XN_CALLBACK_TYPE __ModuleGetPoseDetectionInterface(XnModulePoseDetectionCapabilityInterface* pInteface)
1914 {
1915  pInteface->GetNumberOfPoses = __ModuleGetNumberOfPoses;
1916  pInteface->GetAvailablePoses = __ModuleGetAvailablePoses;
1917  pInteface->GetAllAvailablePoses = __ModuleGetAllAvailablePoses;
1918  pInteface->StartPoseDetection = __ModuleStartPoseDetection;
1919  pInteface->StopPoseDetection = __ModuleStopPoseDetection;
1920  pInteface->StopSinglePoseDetection = __ModuleStopSinglePoseDetection;
1921  pInteface->RegisterToPoseCallbacks = __ModuleRegisterToPoseCallbacks;
1922  pInteface->UnregisterFromPoseCallbacks = __ModuleUnregisterFromPoseCallbacks;
1923 
1924  pInteface->RegisterToPoseDetectionInProgress = __ModuleRegisterToPoseInProgressCallback;
1925  pInteface->UnregisterFromPoseDetectionInProgress = __ModuleUnregisterFromPoseInProgressCallback;
1926 
1927  pInteface->RegisterToPoseDetected = __ModuleRegisterToPoseDetected;
1928  pInteface->UnregisterFromPoseDetected = __ModuleUnregisterFromPoseDetected;
1929  pInteface->RegisterToOutOfPose = __ModuleRegisterToOutOfPose;
1930  pInteface->UnregisterFromOutOfPose = __ModuleUnregisterFromOutOfPose;
1931 }
1932 
1933 void XN_CALLBACK_TYPE __ModuleGetUserGeneratorInterface(XnModuleUserGeneratorInterface* pInterface)
1934 {
1935  __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
1936 
1937  pInterface->GetNumberOfUsers = __ModuleGetNumberOfUsers;
1938  pInterface->GetUsers = __ModuleGetUsers;
1939  pInterface->GetCoM = __ModuleGetUserCoM;
1940  pInterface->GetUserPixels = __ModuleGetUserPixels;
1941  pInterface->RegisterUserCallbacks = __ModuleRegisterUserCallbacks;
1942  pInterface->UnregisterUserCallbacks = __ModuleUnregisterUserCallbacks;
1943 
1944  __ModuleGetSkeletonInterface(pInterface->pSkeletonInterface);
1945  __ModuleGetPoseDetectionInterface(pInterface->pPoseDetectionInterface);
1946 
1947  pInterface->RegisterToUserExit = __ModuleRegisterToUserExitCallback;
1948  pInterface->UnregisterFromUserExit = __ModuleUnregisterFromUserExitCallback;
1949  pInterface->RegisterToUserReEnter = __ModuleRegisterToUserReEnterCallback;
1950  pInterface->UnregisterFromUserReEnter = __ModuleUnregisterFromUserReEnterCallback;
1951 }
1952 
1953 void XN_CALLBACK_TYPE __ModuleGetHandTouchingFOVEdgeInterface(XnModuleHandTouchingFOVEdgeCapabilityInterface* pInterface)
1954 {
1955  pInterface->RegisterToHandTouchingFOVEdge = __ModuleRegisterToHandTouchingFOVEdgeCallback;
1956  pInterface->UnregisterFromHandTouchingFOVEdge = __ModuleUnregisterFromHandTouchingFOVEdgeCallback;
1957 }
1958 void XN_CALLBACK_TYPE __ModuleGetHandsGeneratorInterface(XnModuleHandsGeneratorInterface* pInterface)
1959 {
1960  __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
1961 
1962  pInterface->StartTracking = __ModuleStartTracking;
1963  pInterface->StopTracking = __ModuleStopTracking;
1964  pInterface->StopTrackingAll = __ModuleStopTrackingAll;
1965  pInterface->RegisterHandCallbacks = __ModuleRegisterHandCallbacks;
1966  pInterface->UnregisterHandCallbacks = __ModuleUnregisterHandCallbacks;
1967  pInterface->SetSmoothing = __ModuleSetTrackingSmoothing;
1968 
1969  __ModuleGetHandTouchingFOVEdgeInterface(pInterface->pHandTouchingFOVEdgeInterface);
1970 }
1971 
1972 void XN_CALLBACK_TYPE __ModuleGetAudioGeneratorInterface(XnModuleAudioGeneratorInterface* pInterface)
1973 {
1974  __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
1975 
1976  pInterface->GetAudioBuffer = __ModuleGetAudioBuffer;
1977  pInterface->GetSupportedWaveOutputModesCount = __ModuleGetSupportedWaveOutputModesCount;
1978  pInterface->GetSupportedWaveOutputModes = __ModuleGetSupportedWaveOutputModes;
1979  pInterface->SetWaveOutputMode = __ModuleSetWaveOutputMode;
1980  pInterface->GetWaveOutputMode = __ModuleGetWaveOutputMode;
1981  pInterface->RegisterToWaveOutputModeChanges = __ModuleRegisterToWaveOutputModeChanges;
1982  pInterface->UnregisterFromWaveOutputModeChanges = __ModuleUnregisterFromWaveOutputModeChanges;
1983 }
1984 
1985 void XN_CALLBACK_TYPE __ModuleGetCodecInterface(XnModuleCodecInterface* pInterface)
1986 {
1987  __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
1988 
1989  pInterface->GetCodecID = __ModuleGetCodecID;
1990  pInterface->Init = __ModuleCodecInit;
1991  pInterface->CompressData = __ModuleCompressData;
1992  pInterface->DecompressData = __ModuleDecompressData;
1993 }
1994 
1995 void XN_CALLBACK_TYPE __ModuleGetScriptNodeInterface(XnModuleScriptNodeInterface* pInterface)
1996 {
1997  __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
1998 
1999  pInterface->GetSupportedFormat = __ModuleScriptGetSupportedFormat;
2000  pInterface->LoadScriptFromFile = __ModuleLoadScriptFromFile;
2001  pInterface->LoadScriptFromString = __ModuleLoadScriptFromString;
2002  pInterface->Run = __ModuleScriptRun;
2003 }
2004 
2005 #endif /* XN_MODULE_C_FUNCTIONS_H_ */