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