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
25
26using 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
39XnBool XN_CALLBACK_TYPE __ModuleIsCapabilitySupported(XnModuleNodeHandle hInstance, const XnChar* strCapabilityName)
40{
41 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
42 return pNode->IsCapabilitySupported(strCapabilityName);
43}
44
45XnStatus 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}
52void XN_CALLBACK_TYPE __ModuleStopNotifications(XnModuleNodeHandle hInstance)
53{
54 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
56 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
57 pInterface->UnregisterExNotifications();
58}
59
60XnStatus XN_CALLBACK_TYPE __ModuleSetLockState(XnModuleNodeHandle hInstance, XnBool bLocked)
61{
62 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
64 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
65 return pInterface->SetLockState(bLocked);
66}
67
68XnBool XN_CALLBACK_TYPE __ModuleGetLockState(XnModuleNodeHandle hInstance)
69{
70 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
72 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
73 return pInterface->GetLockState();
74}
75
76XnStatus XN_CALLBACK_TYPE __ModuleRegisterToLockChange(XnModuleNodeHandle hInstance, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
77{
78 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
80 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
81 return pInterface->RegisterToLockChange(handler, pCookie, *phCallback);
82}
83
84void XN_CALLBACK_TYPE __ModuleUnregisterFromLockChange(XnModuleNodeHandle hInstance, XnCallbackHandle hCallback)
85{
86 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
88 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
89 pInterface->UnregisterFromLockChange(hCallback);
90}
91
92XnStatus 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
100XnStatus XN_CALLBACK_TYPE __ModuleRegisterToErrorStateChange(XnModuleNodeHandle hInstance, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
101{
102 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
104 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
105 return pInterface->RegisterToErrorStateChange(handler, pCookie, *phCallback);
106}
107
108void XN_CALLBACK_TYPE __ModuleUnregisterFromErrorStateChange(XnModuleNodeHandle hInstance, XnCallbackHandle hCallback)
109{
110 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
112 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
113 pInterface->UnregisterFromErrorStateChange(hCallback);
114}
115
116XnStatus 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
124XnStatus 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
132XnStatus 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
140XnStatus 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
150void 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
159XnStatus 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
165XnStatus 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
171XnStatus 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
177XnStatus 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
183XnStatus 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
189XnStatus 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
195XnStatus 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
201XnStatus 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
207XnStatus 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
214XnStatus 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
221XnStatus 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
228XnStatus 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
235XnStatus 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
242XnStatus 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
249XnStatus 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
256XnStatus 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
263XnStatus 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
270const 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
277XnBool 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
284XnStatus 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
291void 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
298XnStatus 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
305XnStatus 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
312XnStatus 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
319XnStatus 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
326XnStatus 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
333XnStatus 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
340XnStatus 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
347XnStatus 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
354XnStatus 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
361XnStatus 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
370XnStatus 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
379XnStatus 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
388XnStatus 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
397XnBool 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
406XnStatus 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
415void 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
424XnBool 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
434XnStatus 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
444XnStatus 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
453XnBool 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
463XnStatus 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
472void 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
481XnStatus 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
491XnBool 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
501XnStatus 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
511XnStatus 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
521XnBool 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
531XnStatus 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
540void 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
549XnStatus 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
556XnBool 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
563void XN_CALLBACK_TYPE __ModuleStopGenerating(XnModuleNodeHandle hGenerator)
564{
565 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
566 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
567 pNode->StopGenerating();
568}
569
570XnStatus 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
577void XN_CALLBACK_TYPE __ModuleUnregisterFromGenerationRunningChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
578{
579 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
580 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
582}
583
584XnStatus 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
591void 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
598XnBool 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
605XnStatus 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
612const 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
619XnUInt32 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
626XnUInt64 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
633XnUInt32 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
640XnStatus 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
649XnStatus 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
658XnStatus 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
667void 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
676XnStatus 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
685XnPowerLineFrequency 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
694XnStatus 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
703void 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
712XnUInt32 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
719XnStatus 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
726XnStatus 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
733XnStatus 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
740XnStatus 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
747void 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
754XnUInt32 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
761XnUInt32 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
770XnStatus 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
779XnStatus 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
788XnStatus 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
797void 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
806XnDepthPixel 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
813void 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
820XnStatus 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
827void 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
834XnDepthPixel* 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
841XnUInt8* 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
848XnBool 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
855XnStatus 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
862XnPixelFormat 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
869XnStatus 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
876void 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
883XnIRPixel* 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
890XnStatus 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
897XnStatus 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}
903XnStatus 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}
909XnStatus 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}
915XnStatus 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}
921XnStatus 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}
927XnBool 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}
933XnBool 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}
939XnStatus 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}
945void 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}
951XnStatus 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}
957void 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}
963XnStatus 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}
969void XN_CALLBACK_TYPE __ModuleUnregisterFromGestureIntermediateStageCompleted(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
970{
971 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
972 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
974}
975XnStatus 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}
981void XN_CALLBACK_TYPE __ModuleUnregisterFromGestureReadyForNextIntermediateStage(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
982{
983 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
984 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
986}
987
988const 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}
994XnStatus 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
1001XnStatus 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}
1007void 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}
1013XnStatus 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}
1019XnStatus XN_CALLBACK_TYPE __ModuleStopTrackingAll(XnModuleNodeHandle hGenerator)
1020{
1021 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1022 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
1023 return pNode->StopTrackingAll();
1024}
1025XnStatus 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}
1031XnStatus 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
1038XnStatus 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}
1046void 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
1055XnBool 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}
1063XnBool 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}
1071XnStatus 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}
1079XnStatus 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}
1087XnBool 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}
1095XnStatus 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}
1103void 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}
1111XnStatus 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}
1119XnStatus 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}
1127XnStatus 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}
1135XnStatus 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}
1143XnBool 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}
1151XnBool 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}
1159XnBool 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
1168XnStatus 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}
1176XnStatus 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}
1184XnStatus 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}
1192XnStatus 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}
1200XnStatus 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}
1208XnStatus 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}
1216XnStatus 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}
1224XnBool 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}
1232XnStatus 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}
1240XnStatus 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}
1248XnStatus 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}
1256XnBool 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}
1264XnStatus 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}
1272XnStatus 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}
1280XnStatus 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}
1288void 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
1297XnStatus 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}
1305void 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
1314XnStatus 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}
1322void 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}
1330XnStatus 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}
1338void 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}
1347XnUInt32 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}
1355XnStatus 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}
1363XnStatus 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
1373XnStatus 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}
1381XnStatus 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}
1389XnStatus 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
1398XnStatus 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}
1406void 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
1415XnStatus 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}
1423void 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}
1431XnStatus 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}
1439void 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
1448XnStatus 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}
1456void 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
1466XnUInt16 XN_CALLBACK_TYPE __ModuleGetNumberOfUsers(XnModuleNodeHandle hGenerator)
1467{
1468 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1469 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
1470 return pNode->GetNumberOfUsers();
1471}
1472XnStatus 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}
1478XnStatus 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}
1484XnStatus 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}
1490XnStatus 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}
1496void 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
1503XnStatus 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}
1509void 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}
1515XnStatus 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}
1521void 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
1529XnUChar* XN_CALLBACK_TYPE __ModuleGetAudioBuffer(XnModuleNodeHandle hGenerator)
1530{
1531 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1532 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1533 return pNode->GetAudioBuffer();
1534}
1535XnUInt32 XN_CALLBACK_TYPE __ModuleGetSupportedWaveOutputModesCount(XnModuleNodeHandle hGenerator)
1536{
1537 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
1538 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
1539 return pNode->GetSupportedWaveOutputModesCount();
1540}
1541XnStatus 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}
1547XnStatus 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}
1553XnStatus 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}
1559XnStatus 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}
1565void 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
1572XnCodecID XN_CALLBACK_TYPE __ModuleGetCodecID(XnModuleNodeHandle hCodec)
1573{
1574 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
1575 ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
1576 return pCodec->GetCodecID();
1577}
1578XnStatus 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}
1584XnStatus 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}
1590XnStatus 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
1597const 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
1604XnStatus 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
1611XnStatus 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
1618XnStatus 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
1627void XN_CALLBACK_TYPE __ModuleGetExtendedSerializationInterface(XnModuleExtendedSerializationInterface* pInterface)
1628{
1629 pInterface->InitNotifications = __ModuleInitNotifications;
1630 pInterface->StopNotifications = __ModuleStopNotifications;
1631}
1632
1633void 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
1641void XN_CALLBACK_TYPE __ModuleGetErrorStateInterface(XnModuleErrorStateInterface* pInterface)
1642{
1643 pInterface->GetErrorState = __ModuleGetErrorState;
1644 pInterface->RegisterToErrorStateChange = __ModuleRegisterToErrorStateChange;
1645 pInterface->UnregisterFromErrorStateChange = __ModuleUnregisterFromErrorStateChange;
1646}
1647
1648void 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
1657void 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
1675void XN_CALLBACK_TYPE __ModuleGetDeviceIdentificationInterface(XnModuleDeviceIdentificationInterface* pInterface)
1676{
1677 pInterface->GetDeviceName = __ModuleGetDeviceName;
1678 pInterface->GetVendorSpecificData = __ModuleGetVendorSpecificData;
1679 pInterface->GetSerialNumber = __ModuleGetSerialNumber;
1680}
1681
1682void XN_CALLBACK_TYPE __ModuleGetDeviceInterface(XnModuleDeviceInterface* pInterface)
1683{
1684 __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
1685 __ModuleGetDeviceIdentificationInterface(pInterface->pDeviceIdentificationInterface);
1686}
1687
1688void 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
1696void 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
1707void 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
1717void 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
1738void 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
1750void XN_CALLBACK_TYPE __ModuleGetRecorderInterface(XnModuleRecorderInterface* pInterface)
1751{
1752 pInterface->SetOutputStream = __ModuleSetOutputStream;
1753 __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
1754 __ModuleGetNodeNotificationsInterface(pInterface->pNodeNotifications);
1755}
1756
1757void 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
1775void 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
1783void 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
1791void 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
1805void 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
1814void 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
1825void 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
1836void XN_CALLBACK_TYPE __ModuleGetIRGeneratorInterface(XnModuleIRGeneratorInterface* pInterface)
1837{
1838 __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
1839 pInterface->GetIRMap = __ModuleGetIRMap;
1840}
1841
1842void 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
1864void XN_CALLBACK_TYPE __ModuleGetSceneAnalyzerInterface(XnModuleSceneAnalyzerInterface* pInterface)
1865{
1866 __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
1867 pInterface->GetLabelMap = __ModuleGetLabelMap;
1868 pInterface->GetFloor = __ModuleGetFloor;
1869}
1870
1871void 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
1913void 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
1933void 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
1953void XN_CALLBACK_TYPE __ModuleGetHandTouchingFOVEdgeInterface(XnModuleHandTouchingFOVEdgeCapabilityInterface* pInterface)
1954{
1955 pInterface->RegisterToHandTouchingFOVEdge = __ModuleRegisterToHandTouchingFOVEdgeCallback;
1956 pInterface->UnregisterFromHandTouchingFOVEdge = __ModuleUnregisterFromHandTouchingFOVEdgeCallback;
1957}
1958void 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
1972void 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
1985void 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
1995void 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_ */
void(* XnModuleGestureProgress)(const XnChar *strGesture, const XnPoint3D *pPosition, XnFloat fProgress, void *pCookie)
Definition: XnModuleInterface.h:94
void(* XnModuleHandDestroy)(XnUserID user, XnFloat fTime, void *pCookie)
Definition: XnModuleInterface.h:90
void(* XnModuleStateChangedHandler)(void *pCookie)
Definition: XnModuleInterface.h:79
void(* XnModuleHandCreate)(XnUserID user, const XnPoint3D *pPosition, XnFloat fTime, void *pCookie)
Definition: XnModuleInterface.h:88
void(* XnModuleCalibrationInProgress)(XnUserID user, XnCalibrationStatus calibrationError, void *pCookie)
Definition: XnModuleInterface.h:101
void(* XnModulePoseDetectionCallback)(const XnChar *strPose, XnUserID user, void *pCookie)
Definition: XnModuleInterface.h:105
void(* XnModuleUserHandler)(XnUserID user, void *pCookie)
Definition: XnModuleInterface.h:82
void(* XnModuleGestureReadyForNextIntermediateStage)(const XnChar *strGesture, const XnPoint3D *pPosition, void *pCookie)
Definition: XnModuleInterface.h:96
void(* XnModuleHandUpdate)(XnUserID user, const XnPoint3D *pPosition, XnFloat fTime, void *pCookie)
Definition: XnModuleInterface.h:89
void(* XnModuleCalibrationComplete)(XnUserID user, XnCalibrationStatus calibrationError, void *pCookie)
Definition: XnModuleInterface.h:102
void(* XnModuleHandTouchingFOVEdge)(XnUserID user, const XnPoint3D *pPosition, XnFloat fTime, XnDirection eDir, void *pCookie)
Definition: XnModuleInterface.h:85
void(* XnModuleGestureIntermediateStageCompleted)(const XnChar *strGesture, const XnPoint3D *pPosition, void *pCookie)
Definition: XnModuleInterface.h:95
void(* XnModulePoseDetectionInProgressCallback)(const XnChar *strPose, XnUserID user, XnPoseDetectionStatus poseError, void *pCookie)
Definition: XnModuleInterface.h:106
void(* XnModuleCalibrationStart)(XnUserID user, void *pCookie)
Definition: XnModuleInterface.h:99
void(* XnModuleCalibrationEnd)(XnUserID user, XnBool bSuccess, void *pCookie)
Definition: XnModuleInterface.h:100
void(* XnModuleGestureRecognized)(const XnChar *strGesture, const XnPoint3D *pIDPosition, const XnPoint3D *pEndPosition, void *pCookie)
Definition: XnModuleInterface.h:93
#define FALSE
Definition: XnPlatform.h:89
XnUInt32 XnStatus
Definition: XnStatus.h:33
#define XN_STATUS_OK
Definition: XnStatus.h:36
XnUInt32 XnCodecID
Definition: XnTypes.h:842
void * XnModuleNodeHandle
Definition: XnTypes.h:221
XnPixelFormat
Definition: XnTypes.h:515
XnSkeletonProfile
Definition: XnTypes.h:648
XnPowerLineFrequency
Definition: XnTypes.h:542
@ XN_POWER_LINE_FREQUENCY_OFF
Definition: XnTypes.h:543
XnPlayerSeekOrigin
Definition: XnTypes.h:535
void * XnCallbackHandle
Definition: XnTypes.h:270
XnGrayscale16Pixel XnIRPixel
Definition: XnTypes.h:307
struct XnNodeInfoList XnNodeInfoList
Definition: XnTypes.h:189
XnUInt32 XnUserID
Definition: XnTypes.h:549
XnInt32 XnProductionNodeType
Definition: XnTypes.h:94
XnSkeletonJoint
Definition: XnTypes.h:615
XnUInt16 XnDepthPixel
Definition: XnTypes.h:278
struct XnInternalNodeData * XnNodeHandle
Definition: XnTypes.h:84
XnUInt16 XnLabel
Definition: XnTypes.h:310
Definition: XnCppWrapper.h:8434
Definition: XnModuleCppInterface.h:211
virtual XnStatus SetViewPoint(ProductionNode &other)=0
virtual XnBool IsViewPointSupported(ProductionNode &other)=0
virtual XnBool IsViewPointAs(ProductionNode &other)=0
virtual XnStatus RegisterToViewPointChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual void UnregisterFromViewPointChange(XnCallbackHandle hCallback)=0
virtual XnStatus GetPixelCoordinatesInViewPoint(ProductionNode &other, XnUInt32 x, XnUInt32 y, XnUInt32 &altX, XnUInt32 &altY)=0
Definition: XnModuleCppInterface.h:319
virtual void UnregisterFromPowerLineFrequencyChange(XnCallbackHandle hCallback)=0
virtual XnStatus SetPowerLineFrequency(XnPowerLineFrequency nFrequency)=0
virtual XnStatus RegisterToPowerLineFrequencyChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnPowerLineFrequency GetPowerLineFrequency()=0
Definition: XnModuleCppInterface.h:562
virtual XnUChar * GetAudioBuffer()=0
virtual void UnregisterFromWaveOutputModeChanges(XnCallbackHandle hCallback)=0
virtual XnStatus SetWaveOutputMode(const XnWaveOutputMode &OutputMode)=0
virtual XnUInt32 GetSupportedWaveOutputModesCount()=0
virtual XnStatus GetSupportedWaveOutputModes(XnWaveOutputMode aSupportedModes[], XnUInt32 &nCount)=0
virtual XnStatus RegisterToWaveOutputModeChanges(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus GetWaveOutputMode(XnWaveOutputMode &OutputMode)=0
Definition: XnModuleCppInterface.h:579
virtual XnStatus Init(const ProductionNode &node)=0
virtual XnStatus CompressData(const void *pSrc, XnUInt32 nSrcSize, void *pDst, XnUInt32 nDstSize, XnUInt *pnBytesWritten) const =0
virtual XnStatus DecompressData(const void *pSrc, XnUInt32 nSrcSize, void *pDst, XnUInt32 nDstSize, XnUInt *pnBytesWritten) const =0
virtual XnCodecID GetCodecID() const =0
Definition: XnModuleCppInterface.h:309
virtual XnStatus GetCropping(XnCropping &Cropping)=0
virtual XnStatus SetCropping(const XnCropping &Cropping)=0
virtual void UnregisterFromCroppingChange(XnCallbackHandle hCallback)=0
virtual XnStatus RegisterToCroppingChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
Definition: XnModuleCppInterface.h:358
virtual void GetFieldOfView(XnFieldOfView &FOV)=0
virtual XnDepthPixel * GetDepthMap()=0
virtual XnDepthPixel GetDeviceMaxDepth()=0
virtual XnStatus RegisterToFieldOfViewChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual void UnregisterFromFieldOfViewChange(XnCallbackHandle hCallback)=0
virtual ModuleUserPositionInterface * GetUserPositionInterface()
Definition: XnModuleCppInterface.h:371
Definition: XnModuleCppInterface.h:191
virtual ModuleDeviceIdentificationInterface * GetIdentificationInterface()
Definition: XnModuleCppInterface.h:197
Definition: XnModuleCppInterface.h:182
virtual XnStatus GetSerialNumber(XnChar *strBuffer, XnUInt32 &nBufferSize)=0
virtual XnStatus GetVendorSpecificData(XnChar *strBuffer, XnUInt32 &nBufferSize)=0
virtual XnStatus GetDeviceName(XnChar *strBuffer, XnUInt32 &nBufferSize)=0
Definition: XnModuleCppInterface.h:132
virtual void UnregisterFromErrorStateChange(XnCallbackHandle hCallback)=0
virtual XnStatus RegisterToErrorStateChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus GetErrorState()=0
Definition: XnModuleCppInterface.h:114
virtual XnStatus NotifyExState(XnNodeNotifications *pNotifications, void *pCookie)=0
Definition: XnModuleCppInterface.h:224
virtual XnBool IsFrameSyncedWith(ProductionNode &other)=0
virtual void UnregisterFromFrameSyncChange(XnCallbackHandle hCallback)=0
virtual XnBool CanFrameSyncWith(ProductionNode &other)=0
virtual XnStatus StopFrameSyncWith(ProductionNode &other)=0
virtual XnStatus FrameSyncWith(ProductionNode &other)=0
virtual XnStatus RegisterToFrameSyncChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
Definition: XnModuleCppInterface.h:141
virtual XnStatus Get(const XnChar *strCap, XnInt32 &nValue)=0
virtual void UnregisterFromValueChange(const XnChar *strCap, XnCallbackHandle hCallback)=0
virtual XnInt32 Set(const XnChar *strCap, XnInt32 nValue)=0
virtual XnStatus GetRange(const XnChar *strCap, XnInt32 &nMin, XnInt32 &nMax, XnInt32 &nStep, XnInt32 &nDefault, XnBool &bIsAutoSupported)=0
virtual XnStatus RegisterToValueChange(const XnChar *strCap, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
Definition: XnModuleCppInterface.h:235
virtual ModuleFrameSyncInterface * GetFrameSyncInterface()
Definition: XnModuleCppInterface.h:256
virtual XnBool IsNewDataAvailable(XnUInt64 &nTimestamp)=0
virtual XnStatus RegisterToNewDataAvailable(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnUInt64 GetTimestamp()=0
virtual void UnregisterFromNewDataAvailable(XnCallbackHandle hCallback)=0
virtual void UnregisterFromGenerationRunningChange(XnCallbackHandle hCallback)=0
virtual XnStatus UpdateData()=0
virtual void StopGenerating()=0
virtual const void * GetData()=0
virtual XnBool IsGenerating()=0
virtual XnStatus StartGenerating()=0
virtual ModuleMirrorInterface * GetMirrorInterface()
Definition: XnModuleCppInterface.h:254
virtual XnStatus RegisterToGenerationRunningChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnUInt32 GetFrameID()=0
virtual XnUInt32 GetDataSize()=0
virtual ModuleAlternativeViewPointInterface * GetAlternativeViewPointInterface()
Definition: XnModuleCppInterface.h:255
Definition: XnModuleCppInterface.h:404
virtual XnStatus RegisterGestureCallbacks(XnModuleGestureRecognized RecognizedCB, XnModuleGestureProgress ProgressCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnBool IsGestureProgressSupported(const XnChar *strGesture)=0
virtual XnStatus EnumerateAllGestures(XnChar **pstrGestures, XnUInt32 nNameLength, XnUInt16 &nGestures)=0
virtual XnBool IsGestureAvailable(const XnChar *strGesture)=0
virtual void UnregisterFromGestureIntermediateStageCompleted(XnCallbackHandle hCallback)=0
virtual XnStatus GetAllActiveGestures(XnChar **pstrGestures, XnUInt32 nNameLength, XnUInt16 &nGestures)=0
virtual void UnregisterFromGestureReadyForNextIntermediateStage(XnCallbackHandle hCallback)=0
virtual void UnregisterGestureCallbacks(XnCallbackHandle hCallback)=0
virtual XnStatus RegisterToGestureReadyForNextIntermediateStage(XnModuleGestureReadyForNextIntermediateStage ReadyForNextIntermediateStageCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus RegisterToGestureIntermediateStageCompleted(XnModuleGestureIntermediateStageCompleted GestureIntermediateStageCompletedCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus EnumerateGestures(XnChar **pstrGestures, XnUInt16 &nGestures)=0
virtual XnStatus RegisterToGestureChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus GetActiveGestures(XnChar **pstrGestures, XnUInt16 &nGestures)=0
virtual XnStatus RemoveGesture(const XnChar *strGesture)=0
virtual XnStatus AddGesture(const XnChar *strGesture, XnBoundingBox3D *pArea)=0
virtual void UnregisterFromGestureChange(XnCallbackHandle hCallback)=0
Definition: XnModuleCppInterface.h:444
virtual void UnregisterFromHandTouchingFOVEdge(XnCallbackHandle hCallback)=0
virtual XnStatus RegisterToHandTouchingFOVEdge(XnModuleHandTouchingFOVEdge TouchingFOVEdgeCB, void *pCookie, XnCallbackHandle &hCallback)=0
Definition: XnModuleCppInterface.h:452
virtual void UnregisterHandCallbacks(XnCallbackHandle hCallback)=0
virtual XnStatus StartTracking(const XnPoint3D &ptPosition)=0
virtual XnStatus SetSmoothing(XnFloat fSmoothingFactor)=0
virtual XnStatus RegisterHandCallbacks(XnModuleHandCreate CreateCB, XnModuleHandUpdate UpdateCB, XnModuleHandDestroy DestroyCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus StopTracking(XnUserID user)=0
virtual XnStatus StopTrackingAll()=0
virtual ModuleHandTouchingFOVEdgeInterface * GetHandTouchingFOVEdgeInterface()
Definition: XnModuleCppInterface.h:466
Definition: XnModuleCppInterface.h:392
virtual XnIRPixel * GetIRMap()=0
Definition: XnModuleCppInterface.h:375
virtual XnPixelFormat GetPixelFormat()=0
virtual XnStatus RegisterToPixelFormatChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus SetPixelFormat(XnPixelFormat Format)=0
virtual XnUInt8 * GetImageMap()=0
virtual void UnregisterFromPixelFormatChange(XnCallbackHandle hCallback)=0
virtual XnBool IsPixelFormatSupported(XnPixelFormat Format)=0
Definition: XnModuleCppInterface.h:122
virtual void UnregisterFromLockChange(XnCallbackHandle hCallback)=0
virtual XnBool GetLockState()=0
virtual XnStatus SetLockState(XnBool bLocked)=0
virtual XnStatus RegisterToLockChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
Definition: XnModuleCppInterface.h:329
virtual XnStatus SetMapOutputMode(const XnMapOutputMode &Mode)=0
virtual XnUInt32 GetSupportedMapOutputModesCount()=0
virtual XnStatus RegisterToMapOutputModeChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual ModuleAntiFlickerInterface * GetAntiFlickerInterface()
Definition: XnModuleCppInterface.h:343
virtual void UnregisterFromMapOutputModeChange(XnCallbackHandle hCallback)=0
virtual XnStatus GetSupportedMapOutputModes(XnMapOutputMode aModes[], XnUInt32 &nCount)=0
virtual XnStatus GetMapOutputMode(XnMapOutputMode &Mode)=0
virtual XnUInt32 GetBytesPerPixel()=0
virtual ModuleCroppingInterface * GetCroppingInterface()
Definition: XnModuleCppInterface.h:342
Definition: XnModuleCppInterface.h:201
virtual void UnregisterFromMirrorChange(XnCallbackHandle hCallback)=0
virtual XnStatus RegisterToMirrorChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnBool IsMirrored()=0
virtual XnStatus SetMirror(XnBool bMirror)=0
virtual XnStatus OnNodeAdded(const XnChar *strNodeName, XnProductionNodeType type, XnCodecID compression)=0
virtual XnStatus OnNodeGeneralPropChanged(const XnChar *strNodeName, const XnChar *strPropName, XnUInt32 nBufferSize, const void *pBuffer)=0
virtual XnStatus OnNodeStateReady(const XnChar *strNodeName)=0
virtual XnStatus OnNodeRealPropChanged(const XnChar *strNodeName, const XnChar *strPropName, XnDouble dValue)=0
virtual XnStatus OnNodeIntPropChanged(const XnChar *strNodeName, const XnChar *strPropName, XnUInt64 nValue)=0
virtual XnStatus OnNodeRemoved(const XnChar *strNodeName)=0
virtual XnStatus OnNodeNewData(const XnChar *strNodeName, XnUInt64 nTimeStamp, XnUInt32 nFrame, const void *pData, XnUInt32 nSize)=0
virtual XnStatus OnNodeStringPropChanged(const XnChar *strNodeName, const XnChar *strPropName, const XnChar *strValue)=0
Definition: XnModuleCppInterface.h:286
virtual XnStatus SeekToTimeStamp(XnInt64 nTimeOffset, XnPlayerSeekOrigin origin)=0
virtual XnStatus SetRepeat(XnBool bRepeat)=0
virtual XnStatus RegisterToEndOfFileReached(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus TellTimestamp(XnUInt64 &nTimestamp)=0
virtual XnStatus SeekToFrame(const XnChar *strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)=0
virtual const XnChar * GetSupportedFormat()=0
virtual XnStatus SetInputStream(void *pStreamCookie, XnPlayerInputStreamInterface *pStream)=0
virtual XnBool IsEOF()=0
virtual void UnregisterFromEndOfFileReached(XnCallbackHandle hCallback)=0
virtual XnStatus SetNodeNotifications(void *pNodeNotificationsCookie, XnNodeNotifications *pNodeNotifications)=0
virtual XnStatus TellFrame(const XnChar *strNodeName, XnUInt32 &nFrame)=0
virtual XnUInt32 GetNumFrames(const XnChar *strNodeName, XnUInt32 &nFrames)=0
virtual XnStatus ReadNext()=0
Definition: XnModuleCppInterface.h:514
virtual XnStatus RegisterToOutOfPose(XnModulePoseDetectionCallback handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual void UnregisterFromPoseDetectionCallbacks(XnCallbackHandle hCallback)=0
virtual void UnregisterFromOutOfPose(XnCallbackHandle hCallback)=0
virtual XnUInt32 GetNumberOfPoses()=0
virtual XnStatus GetAvailablePoses(XnChar **pstrPoses, XnUInt32 &nPoses)=0
virtual XnStatus RegisterToPoseDetected(XnModulePoseDetectionCallback handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual void UnregisterFromPoseDetectionInProgress(XnCallbackHandle hCallback)=0
virtual XnStatus RegisterToPoseDetectionCallbacks(XnModulePoseDetectionCallback StartPoseCB, XnModulePoseDetectionCallback EndPoseCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus GetAllAvailablePoses(XnChar **pstrPoses, XnUInt32 nNameLength, XnUInt32 &nPoses)=0
virtual XnStatus RegisterToPoseDetectionInProgress(XnModulePoseDetectionInProgressCallback InProgressCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus StopPoseDetection(XnUserID user)=0
virtual XnStatus StartPoseDetection(const XnChar *strPose, XnUserID user)=0
virtual XnStatus StopSinglePoseDetection(XnUserID user, const XnChar *strPose)=0
virtual void UnregisterFromPoseDetected(XnCallbackHandle hCallback)=0
Definition: XnModuleCppInterface.h:151
virtual ModuleLockAwareInterface * GetLockAwareInterface()
Definition: XnModuleCppInterface.h:171
virtual XnStatus SetRealProperty(const XnChar *, XnDouble)
Definition: XnModuleCppInterface.h:163
virtual ModuleErrorStateInterface * GetErrorStateInterface()
Definition: XnModuleCppInterface.h:172
virtual XnBool IsCapabilitySupported(const XnChar *)
Definition: XnModuleCppInterface.h:161
virtual XnStatus GetIntProperty(const XnChar *, XnUInt64 &) const
Definition: XnModuleCppInterface.h:166
virtual XnStatus SetIntProperty(const XnChar *, XnUInt64)
Definition: XnModuleCppInterface.h:162
virtual XnStatus SetStringProperty(const XnChar *, const XnChar *)
Definition: XnModuleCppInterface.h:164
virtual XnStatus GetGeneralProperty(const XnChar *, XnUInt32, void *) const
Definition: XnModuleCppInterface.h:169
virtual ModuleGeneralIntInterface * GetGeneralIntInterface(const XnChar *)
Definition: XnModuleCppInterface.h:173
virtual XnStatus GetRealProperty(const XnChar *, XnDouble &) const
Definition: XnModuleCppInterface.h:167
virtual ModuleExtendedSerializationInterface * GetExtendedSerializationInterface()
Definition: XnModuleCppInterface.h:170
virtual XnStatus SetGeneralProperty(const XnChar *, XnUInt32, const void *)
Definition: XnModuleCppInterface.h:165
virtual XnStatus GetStringProperty(const XnChar *, XnChar *, XnUInt32) const
Definition: XnModuleCppInterface.h:168
Definition: XnModuleCppInterface.h:276
virtual XnStatus SetOutputStream(void *pCookie, XnRecorderOutputStreamInterface *pStream)=0
Definition: XnModuleCppInterface.h:431
virtual XnStatus GetFloor(XnPlane3D &pPlane)=0
virtual const XnLabel * GetLabelMap()=0
Definition: XnModuleCppInterface.h:592
virtual XnStatus Run(NodeInfoList &createdNodes, EnumerationErrors &errors)=0
virtual XnStatus LoadScriptFromFile(const XnChar *strFileName)=0
virtual const XnChar * GetSupportedFormat()=0
virtual XnStatus LoadScriptFromString(const XnChar *strScript)=0
Definition: XnModuleCppInterface.h:470
virtual void UnregisterFromCalibrationStart(XnCallbackHandle hCallback)=0
virtual XnStatus SetJointActive(XnSkeletonJoint eJoint, XnBool bState)=0
virtual XnStatus GetCalibrationPose(XnChar *strPose)=0
virtual XnBool IsCalibrationData(XnUInt32 nSlot)=0
virtual XnBool IsJointActive(XnSkeletonJoint eJoint)=0
virtual XnStatus RegisterToJointConfigurationChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus RegisterToCalibrationInProgress(XnModuleCalibrationInProgress CalibrationInProgressCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus GetSkeletonJointPosition(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition &pJointPosition)=0
virtual XnStatus SetSmoothing(XnFloat fSmoothingFactor)=0
virtual void UnregisterFromCalibrationInProgress(XnCallbackHandle hCallback)=0
virtual XnStatus StartTracking(XnUserID user)=0
virtual void UnregisterFromCalibrationComplete(XnCallbackHandle hCallback)=0
virtual void UnregisterFromJointConfigurationChange(XnCallbackHandle hCallback)=0
virtual XnStatus SetSkeletonProfile(XnSkeletonProfile eProfile)=0
virtual XnBool IsProfileAvailable(XnSkeletonProfile eProfile)=0
virtual XnStatus SaveCalibrationData(XnUserID user, XnUInt32 nSlot)=0
virtual XnStatus EnumerateActiveJoints(XnSkeletonJoint *pJoints, XnUInt16 &nJoints)=0
virtual XnStatus AbortCalibration(XnUserID user)=0
virtual XnStatus StopTracking(XnUserID user)=0
virtual XnStatus RequestCalibration(XnUserID user, XnBool bForce)=0
virtual XnStatus RegisterToCalibrationStart(XnModuleCalibrationStart handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus LoadCalibrationDataFromFile(XnUserID user, const XnChar *strFileName)=0
virtual XnBool IsJointAvailable(XnSkeletonJoint eJoint)=0
virtual void UnregisterCalibrationCallbacks(XnCallbackHandle hCallback)=0
virtual XnBool NeedPoseForCalibration()=0
virtual XnStatus ClearCalibrationData(XnUInt32 nSlot)=0
virtual XnStatus GetSkeletonJoint(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation &jointTransformation)=0
virtual XnStatus LoadCalibrationData(XnUserID user, XnUInt32 nSlot)=0
virtual XnBool IsCalibrating(XnUserID user)=0
virtual XnStatus RegisterCalibrationCallbacks(XnModuleCalibrationStart CalibrationStartCB, XnModuleCalibrationEnd CalibrationEndCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus SaveCalibrationDataToFile(XnUserID user, const XnChar *strFileName)=0
virtual XnStatus GetSkeletonJointOrientation(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation &pJointOrientation)=0
virtual XnStatus RegisterToCalibrationComplete(XnModuleCalibrationComplete CalibrationCompleteCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus Reset(XnUserID user)=0
virtual XnBool IsCalibrated(XnUserID user)=0
virtual XnBool IsTracking(XnUserID user)=0
Definition: XnModuleCppInterface.h:539
virtual ModuleSkeletonInterface * GetSkeletonInterface()
Definition: XnModuleCppInterface.h:552
virtual XnStatus GetUsers(XnUserID *pUsers, XnUInt16 &nUsers)=0
virtual XnStatus GetCoM(XnUserID user, XnPoint3D &com)=0
virtual void UnregisterFromUserExit(XnCallbackHandle hCallback)=0
virtual XnStatus GetUserPixels(XnUserID user, XnSceneMetaData *pScene)=0
virtual void UnregisterFromUserReEnter(XnCallbackHandle hCallback)=0
virtual XnStatus RegisterToUserReEnter(XnModuleUserHandler UserReEnterCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual ModulePoseDetectionInteface * GetPoseDetectionInteface()
Definition: XnModuleCppInterface.h:553
virtual void UnregisterUserCallbacks(XnCallbackHandle hCallback)=0
virtual XnStatus RegisterToUserExit(XnModuleUserHandler UserExitCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus RegisterUserCallbacks(XnModuleUserHandler NewUserCB, XnModuleUserHandler LostUserCB, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnUInt16 GetNumberOfUsers()=0
Definition: XnModuleCppInterface.h:347
virtual void UnregisterFromUserPositionChange(XnCallbackHandle hCallback)=0
virtual XnStatus GetUserPosition(XnUInt32 nIndex, XnBoundingBox3D &Position)=0
virtual XnStatus RegisterToUserPositionChange(XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle &hCallback)=0
virtual XnStatus SetUserPosition(XnUInt32 nIndex, const XnBoundingBox3D &Position)=0
virtual XnUInt32 GetSupportedUserPositionsCount()=0
Definition: XnCppWrapper.h:2144
Definition: XnCppWrapper.h:2631
struct XnEnumerationErrors XnEnumerationErrors
Definition: XnTypes.h:216
Definition: XnCppWrapper.h:34
Definition: XnTypes.h:481
Definition: XnTypes.h:490
Definition: XnTypes.h:507
Definition: XnTypes.h:436
Definition: XnModuleInterface.h:460
XnStatus(* GetPixelCoordinatesInViewPoint)(XnModuleNodeHandle hGenerator, XnNodeHandle hOther, XnUInt32 x, XnUInt32 y, XnUInt32 *pAltX, XnUInt32 *pAltY)
Definition: XnModuleInterface.h:523
XnStatus(* SetViewPoint)(XnModuleNodeHandle hGenerator, XnNodeHandle hOther)
Definition: XnModuleInterface.h:478
void(* UnregisterFromViewPointChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:511
XnStatus(* ResetViewPoint)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:493
XnStatus(* RegisterToViewPointChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:503
XnBool(* IsViewPointAs)(XnModuleNodeHandle hGenerator, XnNodeHandle hOther)
Definition: XnModuleInterface.h:486
XnBool(* IsViewPointSupported)(XnModuleNodeHandle hGenerator, XnNodeHandle hOther)
Definition: XnModuleInterface.h:470
Definition: XnModuleInterface.h:857
XnPowerLineFrequency(* GetPowerLineFrequency)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:871
XnStatus(* SetPowerLineFrequency)(XnModuleNodeHandle hGenerator, XnPowerLineFrequency nFrequency)
Definition: XnModuleInterface.h:864
XnStatus(* RegisterToPowerLineFrequencyChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:882
void(* UnregisterFromPowerLineFrequencyChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:892
Definition: XnModuleInterface.h:1326
XnStatus(* GetSupportedWaveOutputModes)(XnModuleNodeHandle hGenerator, XnWaveOutputMode *aSupportedModes, XnUInt32 *pnCount)
Definition: XnModuleInterface.h:1331
XnStatus(* RegisterToWaveOutputModeChanges)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1334
XnUChar *(* GetAudioBuffer)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1329
void(* UnregisterFromWaveOutputModeChanges)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1336
XnModuleGeneratorInterface * pGeneratorInterface
Definition: XnModuleInterface.h:1327
XnStatus(* SetWaveOutputMode)(XnModuleNodeHandle hGenerator, const XnWaveOutputMode *OutputMode)
Definition: XnModuleInterface.h:1332
XnStatus(* GetWaveOutputMode)(XnModuleNodeHandle hGenerator, XnWaveOutputMode *OutputMode)
Definition: XnModuleInterface.h:1333
XnUInt32(* GetSupportedWaveOutputModesCount)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1330
Definition: XnModuleInterface.h:1341
XnStatus(* DecompressData)(XnModuleNodeHandle hCodec, const void *pSrc, XnUInt32 nSrcSize, void *pDst, XnUInt32 nDstSize, XnUInt *pnBytesWritten)
Definition: XnModuleInterface.h:1347
XnCodecID(* GetCodecID)(XnModuleNodeHandle hCodec)
Definition: XnModuleInterface.h:1344
XnStatus(* CompressData)(XnModuleNodeHandle hCodec, const void *pSrc, XnUInt32 nSrcSize, void *pDst, XnUInt32 nDstSize, XnUInt *pnBytesWritten)
Definition: XnModuleInterface.h:1346
XnModuleProductionNodeInterface * pProductionNode
Definition: XnModuleInterface.h:1342
XnStatus(* Init)(XnModuleNodeHandle hCodec, XnNodeHandle hNode)
Definition: XnModuleInterface.h:1345
Definition: XnModuleInterface.h:816
XnStatus(* SetCropping)(XnModuleNodeHandle hGenerator, const XnCropping *pCropping)
Definition: XnModuleInterface.h:823
XnStatus(* RegisterToCroppingChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:842
void(* UnregisterFromCroppingChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:852
XnStatus(* GetCropping)(XnModuleNodeHandle hGenerator, XnCropping *pCropping)
Definition: XnModuleInterface.h:831
Definition: XnModuleInterface.h:1039
XnModuleUserPositionCapabilityInterface * pUserPositionInterface
Definition: XnModuleInterface.h:1093
XnModuleMapGeneratorInterface * pMapInterface
Definition: XnModuleInterface.h:1043
void(* GetFieldOfView)(XnModuleNodeHandle hGenerator, XnFieldOfView *pFOV)
Definition: XnModuleInterface.h:1069
XnDepthPixel *(* GetDepthMap)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1051
void(* UnregisterFromFieldOfViewChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1088
XnStatus(* RegisterToFieldOfViewChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1079
XnDepthPixel(* GetDeviceMaxDepth)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1059
Definition: XnModuleInterface.h:369
XnStatus(* GetVendorSpecificData)(XnModuleNodeHandle hInstance, XnChar *strBuffer, XnUInt32 *pnBufferSize)
Definition: XnModuleInterface.h:394
XnStatus(* GetSerialNumber)(XnModuleNodeHandle hInstance, XnChar *strBuffer, XnUInt32 *pnBufferSize)
Definition: XnModuleInterface.h:407
XnStatus(* GetDeviceName)(XnModuleNodeHandle hInstance, XnChar *strBuffer, XnUInt32 *pnBufferSize)
Definition: XnModuleInterface.h:381
Definition: XnModuleInterface.h:412
XnModuleDeviceIdentificationInterface * pDeviceIdentificationInterface
Definition: XnModuleInterface.h:415
XnModuleProductionNodeInterface * pProductionNode
Definition: XnModuleInterface.h:413
Definition: XnModuleInterface.h:235
XnStatus(* GetErrorState)(XnModuleNodeHandle hInstance)
Definition: XnModuleInterface.h:241
XnStatus(* RegisterToErrorStateChange)(XnModuleNodeHandle hInstance, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:252
void(* UnregisterFromErrorStateChange)(XnModuleNodeHandle hInstance, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:262
Definition: XnModuleInterface.h:188
void(* StopNotifications)(XnModuleNodeHandle hInstance)
Definition: XnModuleInterface.h:190
XnStatus(* InitNotifications)(XnModuleNodeHandle hInstance, XnNodeNotifications *pNotifications, void *pCookie)
Definition: XnModuleInterface.h:189
Definition: XnModuleInterface.h:528
void(* UnregisterFromFrameSyncChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:579
XnStatus(* StopFrameSyncWith)(XnModuleNodeHandle hGenerator, XnNodeHandle hOther)
Definition: XnModuleInterface.h:553
XnBool(* CanFrameSyncWith)(XnModuleNodeHandle hGenerator, XnNodeHandle hOther)
Definition: XnModuleInterface.h:537
XnStatus(* FrameSyncWith)(XnModuleNodeHandle hGenerator, XnNodeHandle hOther)
Definition: XnModuleInterface.h:545
XnStatus(* RegisterToFrameSyncChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:571
XnBool(* IsFrameSyncedWith)(XnModuleNodeHandle hGenerator, XnNodeHandle hOther)
Definition: XnModuleInterface.h:561
Definition: XnModuleInterface.h:267
void(* UnregisterFromValueChange)(XnModuleNodeHandle hGenerator, const XnChar *strCap, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:320
XnStatus(* GetRange)(XnModuleNodeHandle hGenerator, const XnChar *strCap, XnInt32 *pnMin, XnInt32 *pnMax, XnInt32 *pnStep, XnInt32 *pnDefault, XnBool *pbIsAutoSupported)
Definition: XnModuleInterface.h:279
XnStatus(* Set)(XnModuleNodeHandle hGenerator, const XnChar *strCap, XnInt32 nValue)
Definition: XnModuleInterface.h:297
XnStatus(* RegisterToValueChange)(XnModuleNodeHandle hGenerator, const XnChar *strCap, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:309
XnStatus(* Get)(XnModuleNodeHandle hGenerator, const XnChar *strCap, XnInt32 *pnValue)
Definition: XnModuleInterface.h:288
Definition: XnModuleInterface.h:585
XnModuleAlternativeViewPointInterface * pAlternativeViewPointInterface
Definition: XnModuleInterface.h:696
void(* StopGenerating)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:613
XnUInt32(* GetDataSize)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:679
void(* UnregisterFromNewDataAvailable)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:654
XnUInt64(* GetTimestamp)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:686
XnStatus(* UpdateData)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:672
XnStatus(* RegisterToNewDataAvailable)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:644
void(* UnregisterFromGenerationRunningChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:634
XnBool(* IsGenerating)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:605
XnStatus(* StartGenerating)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:597
XnStatus(* RegisterToGenerationRunningChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:624
XnModuleProductionNodeInterface * pProductionNodeInterface
Definition: XnModuleInterface.h:589
XnBool(* IsNewDataAvailable)(XnModuleNodeHandle hGenerator, XnUInt64 *pnTimestamp)
Definition: XnModuleInterface.h:663
const void *(* GetData)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:706
XnUInt32(* GetFrameID)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:693
XnModuleFrameSyncInterface * pFrameSyncInterface
Definition: XnModuleInterface.h:698
XnModuleMirrorInterface * pMirrorInterface
Definition: XnModuleInterface.h:695
Definition: XnModuleInterface.h:1171
XnStatus(* EnumerateAllGestures)(XnModuleNodeHandle hGenerator, XnChar **pstrGestures, XnUInt32 nNameLength, XnUInt16 *nGestures)
Definition: XnModuleInterface.h:1186
XnModuleGeneratorInterface * pGeneratorInterface
Definition: XnModuleInterface.h:1172
XnStatus(* RegisterGestureCallbacks)(XnModuleNodeHandle hGenerator, XnModuleGestureRecognized RecognizedCB, XnModuleGestureProgress ProgressCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1180
XnStatus(* AddGesture)(XnModuleNodeHandle hGenerator, const XnChar *strGesture, XnBoundingBox3D *pArea)
Definition: XnModuleInterface.h:1174
XnStatus(* RegisterToGestureReadyForNextIntermediateStage)(XnModuleNodeHandle hGenerator, XnModuleGestureReadyForNextIntermediateStage ReadyForNextIntermediateStageCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1190
XnStatus(* RegisterToGestureChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1182
void(* UnregisterFromGestureChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1183
XnStatus(* GetActiveGestures)(XnModuleNodeHandle hGenerator, XnChar **pstrGestures, XnUInt16 *nGestures)
Definition: XnModuleInterface.h:1176
void(* UnregisterFromGestureReadyForNextIntermediateStage)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1191
XnStatus(* RemoveGesture)(XnModuleNodeHandle hGenerator, const XnChar *strGesture)
Definition: XnModuleInterface.h:1175
void(* UnregisterFromGestureIntermediateStageCompleted)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1189
XnStatus(* GetAllActiveGestures)(XnModuleNodeHandle hGenerator, XnChar **pstrGestures, XnUInt32 nNameLength, XnUInt16 *nGestures)
Definition: XnModuleInterface.h:1185
XnStatus(* EnumerateGestures)(XnModuleNodeHandle hGenerator, XnChar **pstrGestures, XnUInt16 *nGestures)
Definition: XnModuleInterface.h:1177
XnBool(* IsGestureAvailable)(XnModuleNodeHandle hInstance, const XnChar *strGesture)
Definition: XnModuleInterface.h:1178
XnStatus(* RegisterToGestureIntermediateStageCompleted)(XnModuleNodeHandle hGenerator, XnModuleGestureIntermediateStageCompleted GestureIntermediateStageCompletedCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1188
void(* UnregisterGestureCallbacks)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1181
XnBool(* IsGestureProgressSupported)(XnModuleNodeHandle hGenerator, const XnChar *strGesture)
Definition: XnModuleInterface.h:1179
Definition: XnModuleInterface.h:1208
XnStatus(* RegisterToHandTouchingFOVEdge)(XnModuleNodeHandle hGenerator, XnModuleHandTouchingFOVEdge, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1209
void(* UnregisterFromHandTouchingFOVEdge)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1210
Definition: XnModuleInterface.h:1214
XnModuleGeneratorInterface * pGeneratorInterface
Definition: XnModuleInterface.h:1215
XnModuleHandTouchingFOVEdgeCapabilityInterface * pHandTouchingFOVEdgeInterface
Definition: XnModuleInterface.h:1224
XnStatus(* SetSmoothing)(XnModuleNodeHandle hGenerator, XnFloat fSmoothingFactor)
Definition: XnModuleInterface.h:1222
void(* UnregisterHandCallbacks)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1218
XnStatus(* RegisterHandCallbacks)(XnModuleNodeHandle hGenerator, XnModuleHandCreate CreateCB, XnModuleHandUpdate UpdateCB, XnModuleHandDestroy DestroyCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1217
XnStatus(* StartTracking)(XnModuleNodeHandle hGenerator, const XnPoint3D *pPosition)
Definition: XnModuleInterface.h:1221
XnStatus(* StopTracking)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1219
XnStatus(* StopTrackingAll)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1220
Definition: XnModuleInterface.h:1156
XnIRPixel *(* GetIRMap)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1163
XnModuleMapGeneratorInterface * pMapInterface
Definition: XnModuleInterface.h:1160
Definition: XnModuleInterface.h:1099
XnModuleMapGeneratorInterface * pMapInterface
Definition: XnModuleInterface.h:1103
void(* UnregisterFromPixelFormatChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1150
XnPixelFormat(* GetPixelFormat)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1131
XnUInt8 *(* GetImageMap)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1106
XnStatus(* RegisterToPixelFormatChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1141
XnBool(* IsPixelFormatSupported)(XnModuleNodeHandle hGenerator, XnPixelFormat Format)
Definition: XnModuleInterface.h:1116
XnStatus(* SetPixelFormat)(XnModuleNodeHandle hGenerator, XnPixelFormat Format)
Definition: XnModuleInterface.h:1124
Definition: XnModuleInterface.h:195
void(* UnregisterFromLockChange)(XnModuleNodeHandle hInstance, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:230
XnStatus(* SetLockState)(XnModuleNodeHandle hInstance, XnBool bLocked)
Definition: XnModuleInterface.h:202
XnStatus(* RegisterToLockChange)(XnModuleNodeHandle hInstance, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:220
XnBool(* GetLockState)(XnModuleNodeHandle hInstance)
Definition: XnModuleInterface.h:209
Definition: XnModuleInterface.h:897
XnModuleGeneratorInterface * pGeneratorInterface
Definition: XnModuleInterface.h:901
XnUInt32(* GetBytesPerPixel)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:973
XnStatus(* GetMapOutputMode)(XnModuleNodeHandle hGenerator, XnMapOutputMode *pOutputMode)
Definition: XnModuleInterface.h:941
XnStatus(* RegisterToMapOutputModeChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:952
XnStatus(* GetSupportedMapOutputModes)(XnModuleNodeHandle hGenerator, XnMapOutputMode *aModes, XnUInt32 *pnCount)
Definition: XnModuleInterface.h:922
XnUInt32(* GetSupportedMapOutputModesCount)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:910
XnStatus(* SetMapOutputMode)(XnModuleNodeHandle hGenerator, const XnMapOutputMode *pOutputMode)
Definition: XnModuleInterface.h:932
XnModuleAntiFlickerInterface * pAntiFlickerInterface
Definition: XnModuleInterface.h:975
XnModuleCroppingInterface * pCroppingInterface
Definition: XnModuleInterface.h:964
void(* UnregisterFromMapOutputModeChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:962
Definition: XnModuleInterface.h:420
XnBool(* IsMirrored)(XnModuleNodeHandle hInstance)
Definition: XnModuleInterface.h:434
void(* UnregisterFromMirrorChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:455
XnStatus(* SetMirror)(XnModuleNodeHandle hInstance, XnBool bMirror)
Definition: XnModuleInterface.h:427
XnStatus(* RegisterToMirrorChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:445
Definition: XnModuleInterface.h:727
XnStatus(* SetInputStream)(XnModuleNodeHandle hInstance, void *pStreamCookie, XnPlayerInputStreamInterface *pStream)
Definition: XnModuleInterface.h:736
const XnChar *(* GetSupportedFormat)(XnModuleNodeHandle hInstance)
Definition: XnModuleInterface.h:784
void(* UnregisterFromEndOfFileReached)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:808
XnBool(* IsEOF)(XnModuleNodeHandle hInstance)
Definition: XnModuleInterface.h:787
XnStatus(* ReadNext)(XnModuleNodeHandle hInstance)
Definition: XnModuleInterface.h:743
XnStatus(* RegisterToEndOfFileReached)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:798
XnStatus(* SetNodeNotifications)(XnModuleNodeHandle hInstance, void *pNodeNotificationsCookie, XnNodeNotifications *pNodeNotifications)
Definition: XnModuleInterface.h:754
XnStatus(* SeekToFrame)(XnModuleNodeHandle hInstance, const XnChar *strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)
Definition: XnModuleInterface.h:772
XnStatus(* SeekToTimeStamp)(XnModuleNodeHandle hInstance, XnInt64 nTimeOffset, XnPlayerSeekOrigin origin)
Definition: XnModuleInterface.h:769
XnStatus(* TellTimestamp)(XnModuleNodeHandle hInstance, XnUInt64 *pnTimestamp)
Definition: XnModuleInterface.h:775
XnStatus(* GetNumFrames)(XnModuleNodeHandle hInstance, const XnChar *strNodeName, XnUInt32 *pnFrames)
Definition: XnModuleInterface.h:781
XnStatus(* TellFrame)(XnModuleNodeHandle hInstance, const XnChar *strNodeName, XnUInt32 *pnFrame)
Definition: XnModuleInterface.h:778
XnModuleProductionNodeInterface * pProductionNode
Definition: XnModuleInterface.h:810
XnStatus(* SetRepeat)(XnModuleNodeHandle hInstance, XnBool bRepeat)
Definition: XnModuleInterface.h:766
Definition: XnModuleInterface.h:1275
XnStatus(* StopPoseDetection)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1279
XnStatus(* GetAllAvailablePoses)(XnModuleNodeHandle hGenerator, XnChar **pstrPoses, XnUInt32 nNameLength, XnUInt32 *pnPoses)
Definition: XnModuleInterface.h:1283
XnStatus(* RegisterToPoseCallbacks)(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback StartPoseCB, XnModulePoseDetectionCallback EndCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1280
void(* UnregisterFromOutOfPose)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1291
void(* UnregisterFromPoseDetectionInProgress)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1286
XnUInt32(* GetNumberOfPoses)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1276
XnStatus(* RegisterToOutOfPose)(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1290
void(* UnregisterFromPoseDetected)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1289
XnStatus(* RegisterToPoseDetected)(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1288
void(* UnregisterFromPoseCallbacks)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1281
XnStatus(* GetAvailablePoses)(XnModuleNodeHandle hGenerator, XnChar **pstrPoses, XnUInt32 *pnPoses)
Definition: XnModuleInterface.h:1277
XnStatus(* StopSinglePoseDetection)(XnModuleNodeHandle hGenerator, XnUserID user, const XnChar *strPose)
Definition: XnModuleInterface.h:1293
XnStatus(* StartPoseDetection)(XnModuleNodeHandle hGenerator, const XnChar *strPose, XnUserID user)
Definition: XnModuleInterface.h:1278
XnStatus(* RegisterToPoseDetectionInProgress)(XnModuleNodeHandle hGenerator, XnModulePoseDetectionInProgressCallback PoseProgressCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1285
Definition: XnModuleInterface.h:325
XnStatus(* SetStringProperty)(XnModuleNodeHandle hInstance, const XnChar *strName, const XnChar *strValue)
Definition: XnModuleInterface.h:346
XnModuleExtendedSerializationInterface * pExtendedSerializationInterface
Definition: XnModuleInterface.h:361
XnStatus(* SetGeneralProperty)(XnModuleNodeHandle hInstance, const XnChar *strName, XnUInt32 nBufferSize, const void *pBuffer)
Definition: XnModuleInterface.h:347
XnModuleGeneralIntInterface * pGeneralIntInterface
Definition: XnModuleInterface.h:364
XnModuleLockAwareInterface * pLockAwareInterface
Definition: XnModuleInterface.h:362
XnStatus(* SetRealProperty)(XnModuleNodeHandle hInstance, const XnChar *strName, XnDouble dValue)
Definition: XnModuleInterface.h:345
XnStatus(* GetStringProperty)(XnModuleNodeHandle hInstance, const XnChar *strName, XnChar *csValue, XnUInt32 nBufSize)
Definition: XnModuleInterface.h:358
XnStatus(* GetGeneralProperty)(XnModuleNodeHandle hInstance, const XnChar *strName, XnUInt32 nBufferSize, void *pBuffer)
Definition: XnModuleInterface.h:359
XnStatus(* GetRealProperty)(XnModuleNodeHandle hInstance, const XnChar *strName, XnDouble *pdValue)
Definition: XnModuleInterface.h:357
XnModuleErrorStateInterface * pErrorStateInterface
Definition: XnModuleInterface.h:363
XnStatus(* SetIntProperty)(XnModuleNodeHandle hInstance, const XnChar *strName, XnUInt64 nValue)
Definition: XnModuleInterface.h:344
XnStatus(* GetIntProperty)(XnModuleNodeHandle hInstance, const XnChar *strName, XnUInt64 *pnValue)
Definition: XnModuleInterface.h:356
XnBool(* IsCapabilitySupported)(XnModuleNodeHandle hInstance, const XnChar *strCapabilityName)
Definition: XnModuleInterface.h:332
Definition: XnModuleInterface.h:711
XnNodeNotifications * pNodeNotifications
Definition: XnModuleInterface.h:723
XnStatus(* SetOutputStream)(XnModuleNodeHandle hInstance, void *pStreamToken, XnRecorderOutputStreamInterface *pStream)
Definition: XnModuleInterface.h:720
XnModuleProductionNodeInterface * pProductionNode
Definition: XnModuleInterface.h:722
Definition: XnModuleInterface.h:1197
XnStatus(* GetFloor)(XnModuleNodeHandle hGenerator, XnPlane3D *pPlane)
Definition: XnModuleInterface.h:1201
XnModuleMapGeneratorInterface * pMapInterface
Definition: XnModuleInterface.h:1198
const XnLabel *(* GetLabelMap)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1200
Definition: XnModuleInterface.h:1352
const XnChar *(* GetSupportedFormat)(XnModuleNodeHandle hScript)
Definition: XnModuleInterface.h:1355
XnStatus(* Run)(XnModuleNodeHandle hScript, XnNodeInfoList *pCreatedNodes, XnEnumerationErrors *pErrors)
Definition: XnModuleInterface.h:1358
XnModuleProductionNodeInterface * pProductionNode
Definition: XnModuleInterface.h:1353
XnStatus(* LoadScriptFromString)(XnModuleNodeHandle hScript, const XnChar *strScript)
Definition: XnModuleInterface.h:1357
XnStatus(* LoadScriptFromFile)(XnModuleNodeHandle hScript, const XnChar *strFileName)
Definition: XnModuleInterface.h:1356
Definition: XnModuleInterface.h:1232
XnStatus(* StartTracking)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1253
XnBool(* IsJointActive)(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint)
Definition: XnModuleInterface.h:1237
XnBool(* NeedPoseForCalibration)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1256
XnStatus(* SetSmoothing)(XnModuleNodeHandle hGenerator, XnFloat fSmoothingFactor)
Definition: XnModuleInterface.h:1258
void(* UnregisterFromCalibrationInProgress)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1266
XnBool(* IsTracking)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1244
XnStatus(* GetCalibrationPose)(XnModuleNodeHandle hGenerator, XnChar *strPose)
Definition: XnModuleInterface.h:1257
void(* UnregisterFromCalibrationComplete)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1268
XnStatus(* ClearCalibrationData)(XnModuleNodeHandle hGenerator, XnUInt32 nSlot)
Definition: XnModuleInterface.h:1251
XnStatus(* RegisterToCalibrationInProgress)(XnModuleNodeHandle hGenerator, XnModuleCalibrationInProgress CalibrationInProgressCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1265
XnStatus(* RegisterToCalibrationStart)(XnModuleNodeHandle hGenerator, XnModuleCalibrationStart handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1270
XnStatus(* LoadCalibrationData)(XnModuleNodeHandle hGenerator, XnUserID user, XnUInt32 nSlot)
Definition: XnModuleInterface.h:1250
XnBool(* IsCalibrating)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1246
XnStatus(* RegisterCalibrationCallbacks)(XnModuleNodeHandle hGenerator, XnModuleCalibrationStart CalibrationStartCB, XnModuleCalibrationEnd CalibrationEndCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1259
XnStatus(* GetSkeletonJointPosition)(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition *pJoint)
Definition: XnModuleInterface.h:1242
XnBool(* IsJointAvailable)(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint)
Definition: XnModuleInterface.h:1233
XnStatus(* SaveCalibrationData)(XnModuleNodeHandle hGenerator, XnUserID user, XnUInt32 nSlot)
Definition: XnModuleInterface.h:1249
XnStatus(* RegisterToCalibrationComplete)(XnModuleNodeHandle hGenerator, XnModuleCalibrationComplete CalibrationCompleteCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1267
XnBool(* IsCalibrated)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1245
XnStatus(* GetSkeletonJoint)(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation *pJoint)
Definition: XnModuleInterface.h:1241
XnStatus(* Reset)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1255
void(* UnregisterCalibrationCallbacks)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1260
XnStatus(* GetSkeletonJointOrientation)(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation *pJoint)
Definition: XnModuleInterface.h:1243
void(* UnregisterFromCalibrationStart)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1271
XnStatus(* SaveCalibrationDataToFile)(XnModuleNodeHandle hGenerator, XnUserID user, const XnChar *strFileName)
Definition: XnModuleInterface.h:1262
void(* UnregisterFromJointConfigurationChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1239
XnStatus(* AbortCalibration)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1248
XnBool(* IsCalibrationData)(XnModuleNodeHandle hGenerator, XnUInt32 nSlot)
Definition: XnModuleInterface.h:1252
XnStatus(* SetJointActive)(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint, XnBool bState)
Definition: XnModuleInterface.h:1236
XnStatus(* RequestCalibration)(XnModuleNodeHandle hGenerator, XnUserID user, XnBool bForce)
Definition: XnModuleInterface.h:1247
XnBool(* IsProfileAvailable)(XnModuleNodeHandle hGenerator, XnSkeletonProfile eProfile)
Definition: XnModuleInterface.h:1234
XnStatus(* SetSkeletonProfile)(XnModuleNodeHandle hGenerator, XnSkeletonProfile eProfile)
Definition: XnModuleInterface.h:1235
XnStatus(* EnumerateActiveJoints)(XnModuleNodeHandle hGenerator, XnSkeletonJoint *pJoints, XnUInt16 *pnJoints)
Definition: XnModuleInterface.h:1240
XnStatus(* StopTracking)(XnModuleNodeHandle hGenerator, XnUserID user)
Definition: XnModuleInterface.h:1254
XnStatus(* RegisterToJointConfigurationChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1238
XnStatus(* LoadCalibrationDataFromFile)(XnModuleNodeHandle hGenerator, XnUserID user, const XnChar *strFileName)
Definition: XnModuleInterface.h:1263
Definition: XnModuleInterface.h:1298
void(* UnregisterFromUserReEnter)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1320
XnModulePoseDetectionCapabilityInterface * pPoseDetectionInterface
Definition: XnModuleInterface.h:1315
XnUInt16(* GetNumberOfUsers)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:1301
XnStatus(* RegisterToUserExit)(XnModuleNodeHandle hGenerator, XnModuleUserHandler UserExitCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1317
XnStatus(* RegisterToUserReEnter)(XnModuleNodeHandle hGenerator, XnModuleUserHandler UserReEnterCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1319
XnStatus(* GetUsers)(XnModuleNodeHandle hGenerator, XnUserID *pUsers, XnUInt16 *pnUsers)
Definition: XnModuleInterface.h:1302
XnStatus(* GetCoM)(XnModuleNodeHandle hGenerator, XnUserID user, XnPoint3D *pCoM)
Definition: XnModuleInterface.h:1303
void(* UnregisterFromUserExit)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1318
XnModuleSkeletonCapabilityInterface * pSkeletonInterface
Definition: XnModuleInterface.h:1311
XnStatus(* RegisterUserCallbacks)(XnModuleNodeHandle hGenerator, XnModuleUserHandler NewUserCB, XnModuleUserHandler LostUserCB, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1305
XnStatus(* GetUserPixels)(XnModuleNodeHandle hGenerator, XnUserID user, XnSceneMetaData *pScene)
Definition: XnModuleInterface.h:1304
void(* UnregisterUserCallbacks)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1306
XnModuleGeneratorInterface * pGeneratorInterface
Definition: XnModuleInterface.h:1299
Definition: XnModuleInterface.h:983
XnStatus(* RegisterToUserPositionChange)(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void *pCookie, XnCallbackHandle *phCallback)
Definition: XnModuleInterface.h:1023
void(* UnregisterFromUserPositionChange)(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
Definition: XnModuleInterface.h:1033
XnStatus(* SetUserPosition)(XnModuleNodeHandle hGenerator, XnUInt32 nIndex, const XnBoundingBox3D *pPosition)
Definition: XnModuleInterface.h:999
XnUInt32(* GetSupportedUserPositionsCount)(XnModuleNodeHandle hGenerator)
Definition: XnModuleInterface.h:990
XnStatus(* GetUserPosition)(XnModuleNodeHandle hGenerator, XnUInt32 nIndex, XnBoundingBox3D *pPosition)
Definition: XnModuleInterface.h:1012
Definition: XnTypes.h:994
XnStatus(* OnNodeAdded)(void *pCookie, const XnChar *strNodeName, XnProductionNodeType type, XnCodecID compression)
Definition: XnTypes.h:1002
XnStatus(* OnNodeNewData)(void *pCookie, const XnChar *strNodeName, XnUInt64 nTimeStamp, XnUInt32 nFrame, const void *pData, XnUInt32 nSize)
Definition: XnTypes.h:1082
XnStatus(* OnNodeRemoved)(void *pCookie, const XnChar *strNodeName)
Definition: XnTypes.h:1012
XnStatus(* OnNodeStateReady)(void *pCookie, const XnChar *strNodeName)
Definition: XnTypes.h:1070
XnStatus(* OnNodeIntPropChanged)(void *pCookie, const XnChar *strNodeName, const XnChar *strPropName, XnUInt64 nValue)
Definition: XnTypes.h:1023
XnStatus(* OnNodeStringPropChanged)(void *pCookie, const XnChar *strNodeName, const XnChar *strPropName, const XnChar *strValue)
Definition: XnTypes.h:1047
XnStatus(* OnNodeGeneralPropChanged)(void *pCookie, const XnChar *strNodeName, const XnChar *strPropName, XnUInt32 nBufferSize, const void *pBuffer)
Definition: XnTypes.h:1060
XnStatus(* OnNodeRealPropChanged)(void *pCookie, const XnChar *strNodeName, const XnChar *strPropName, XnDouble dValue)
Definition: XnTypes.h:1035
Definition: XnTypes.h:564
Definition: XnTypes.h:925
Definition: XnTypes.h:853
Definition: XnTypes.h:1179
Definition: XnTypes.h:593
Definition: XnTypes.h:577
Definition: XnTypes.h:604
Definition: XnTypes.h:469
Definition: XnTypes.h:459