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