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