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