00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifndef XN_MODULE_C_FUNCTIONS_H_
00023 #define XN_MODULE_C_FUNCTIONS_H_
00024
00025 #include "XnModuleCppInterface.h"
00026
00027 using namespace xn;
00028
00029 #define _XN_VALIDATE_CAPABILITY_INTERFACE_RET(capInterface, retVal) \
00030 if (capInterface == NULL) \
00031 return retVal;
00032
00033 #define _XN_VALIDATE_CAPABILITY_INTERFACE(capInterface) \
00034 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(capInterface, XN_STATUS_INVALID_OPERATION)
00035
00036 XnBool XN_CALLBACK_TYPE __ModuleIsCapabilitySupported(XnModuleNodeHandle hInstance, const XnChar* strCapabilityName)
00037 {
00038 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00039 return pNode->IsCapabilitySupported(strCapabilityName);
00040 }
00041
00042 XnStatus XN_CALLBACK_TYPE __ModuleInitNotifications(XnModuleNodeHandle hInstance, XnNodeNotifications* pNotifications, void* pCookie)
00043 {
00044 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00045 ModuleExtendedSerializationInterface* pInterface = pNode->GetExtendedSerializationInterface();
00046 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00047 return pInterface->NotifyExState(pNotifications, pCookie);
00048 }
00049 void XN_CALLBACK_TYPE __ModuleStopNotifications(XnModuleNodeHandle hInstance)
00050 {
00051 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00052 ModuleExtendedSerializationInterface* pInterface = pNode->GetExtendedSerializationInterface();
00053 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00054 pInterface->UnregisterExNotifications();
00055 }
00056
00057 XnStatus XN_CALLBACK_TYPE __ModuleSetLockState(XnModuleNodeHandle hInstance, XnBool bLocked)
00058 {
00059 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00060 ModuleLockAwareInterface* pInterface = pNode->GetLockAwareInterface();
00061 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00062 return pInterface->SetLockState(bLocked);
00063 }
00064
00065 XnBool XN_CALLBACK_TYPE __ModuleGetLockState(XnModuleNodeHandle hInstance)
00066 {
00067 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00068 ModuleLockAwareInterface* pInterface = pNode->GetLockAwareInterface();
00069 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
00070 return pInterface->GetLockState();
00071 }
00072
00073 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToLockChange(XnModuleNodeHandle hInstance, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00074 {
00075 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00076 ModuleLockAwareInterface* pInterface = pNode->GetLockAwareInterface();
00077 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00078 return pInterface->RegisterToLockChange(handler, pCookie, *phCallback);
00079 }
00080
00081 void XN_CALLBACK_TYPE __ModuleUnregisterFromLockChange(XnModuleNodeHandle hInstance, XnCallbackHandle hCallback)
00082 {
00083 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00084 ModuleLockAwareInterface* pInterface = pNode->GetLockAwareInterface();
00085 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00086 pInterface->UnregisterFromLockChange(hCallback);
00087 }
00088
00089 XnStatus XN_CALLBACK_TYPE __ModuleGetErrorState(XnModuleNodeHandle hInstance)
00090 {
00091 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00092 ModuleErrorStateInterface* pInterface = pNode->GetErrorStateInterface();
00093 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, XN_STATUS_OK);
00094 return pInterface->GetErrorState();
00095 }
00096
00097 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToErrorStateChange(XnModuleNodeHandle hInstance, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00098 {
00099 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00100 ModuleErrorStateInterface* pInterface = pNode->GetErrorStateInterface();
00101 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00102 return pInterface->RegisterToErrorStateChange(handler, pCookie, *phCallback);
00103 }
00104
00105 void XN_CALLBACK_TYPE __ModuleUnregisterFromErrorStateChange(XnModuleNodeHandle hInstance, XnCallbackHandle hCallback)
00106 {
00107 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00108 ModuleErrorStateInterface* pInterface = pNode->GetErrorStateInterface();
00109 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00110 pInterface->UnregisterFromErrorStateChange(hCallback);
00111 }
00112
00113 XnStatus XN_CALLBACK_TYPE __ModuleGeneralIntGetRange(XnModuleNodeHandle hInstance, const XnChar* strCap, XnInt32* pnMin, XnInt32* pnMax, XnInt32* pnStep, XnInt32* pnDefault, XnBool* pbIsAutoSupported)
00114 {
00115 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00116 ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
00117 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00118 return pInterface->GetRange(strCap, *pnMin, *pnMax, *pnStep, *pnDefault, *pbIsAutoSupported);
00119 }
00120
00121 XnStatus XN_CALLBACK_TYPE __ModuleGeneralIntGet(XnModuleNodeHandle hInstance, const XnChar* strCap, XnInt32* pnValue)
00122 {
00123 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00124 ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
00125 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00126 return pInterface->Get(strCap, *pnValue);
00127 }
00128
00129 XnStatus XN_CALLBACK_TYPE __ModuleGeneralIntSet(XnModuleNodeHandle hInstance, const XnChar* strCap, XnInt32 nValue)
00130 {
00131 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00132 ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
00133 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00134 return pInterface->Set(strCap, nValue);
00135 }
00136
00137 XnStatus XN_CALLBACK_TYPE __ModuleGeneralIntRegisterToValueChange
00138 (XnModuleNodeHandle hInstance, const XnChar* strCap, XnModuleStateChangedHandler handler,
00139 void* pCookie, XnCallbackHandle* phCallback)
00140 {
00141 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00142 ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
00143 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00144 return pInterface->RegisterToValueChange(strCap, handler, pCookie, *phCallback);
00145 }
00146
00147 void XN_CALLBACK_TYPE __ModuleGeneralIntUnregisterFromValueChange
00148 (XnModuleNodeHandle hInstance, const XnChar* strCap, XnCallbackHandle hCallback)
00149 {
00150 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00151 ModuleGeneralIntInterface* pInterface = pNode->GetGeneralIntInterface(strCap);
00152 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00153 pInterface->UnregisterFromValueChange(strCap, hCallback);
00154 }
00155
00156 XnStatus XN_CALLBACK_TYPE __ModuleSetIntProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnUInt64 nValue)
00157 {
00158 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00159 return pNode->SetIntProperty(strName, nValue);
00160 }
00161
00162 XnStatus XN_CALLBACK_TYPE __ModuleSetRealProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnDouble dValue)
00163 {
00164 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00165 return pNode->SetRealProperty(strName, dValue);
00166 }
00167
00168 XnStatus XN_CALLBACK_TYPE __ModuleSetStringProperty(XnModuleNodeHandle hInstance, const XnChar* strName, const XnChar* strValue)
00169 {
00170 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00171 return pNode->SetStringProperty(strName, strValue);
00172 }
00173
00174 XnStatus XN_CALLBACK_TYPE __ModuleSetGeneralProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer)
00175 {
00176 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00177 return pNode->SetGeneralProperty(strName, nBufferSize, pBuffer);
00178 }
00179
00180 XnStatus XN_CALLBACK_TYPE __ModuleGetIntProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnUInt64* pnValue)
00181 {
00182 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00183 return pNode->GetIntProperty(strName, *pnValue);
00184 }
00185
00186 XnStatus XN_CALLBACK_TYPE __ModuleGetRealProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnDouble* pdValue)
00187 {
00188 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00189 return pNode->GetRealProperty(strName, *pdValue);
00190 }
00191
00192 XnStatus XN_CALLBACK_TYPE __ModuleGetStringProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnChar* csValue, XnUInt32 nBufSize)
00193 {
00194 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00195 return pNode->GetStringProperty(strName, csValue, nBufSize);
00196 }
00197
00198 XnStatus XN_CALLBACK_TYPE __ModuleGetGeneralProperty(XnModuleNodeHandle hInstance, const XnChar* strName, XnUInt32 nBufferSize, void* pBuffer)
00199 {
00200 ModuleProductionNode* pNode = (ModuleProductionNode*)hInstance;
00201 return pNode->GetGeneralProperty(strName, nBufferSize, pBuffer);
00202 }
00203
00204 XnStatus XN_CALLBACK_TYPE __ModuleSetOutputStream(XnModuleNodeHandle hInstance, void *pCookie, XnRecorderOutputStreamInterface *pStream)
00205 {
00206 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00207 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00208 return pNode->SetOutputStream(pCookie, pStream);
00209 }
00210
00211 XnStatus XN_CALLBACK_TYPE __ModuleSetInputStream(XnModuleNodeHandle hInstance, void *pStreamCookie, XnPlayerInputStreamInterface *pStream)
00212 {
00213 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00214 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00215 return pNode->SetInputStream(pStreamCookie, pStream);
00216 }
00217
00218 XnStatus XN_CALLBACK_TYPE __ModuleReadNext(XnModuleNodeHandle hInstance)
00219 {
00220 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00221 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00222 return pNode->ReadNext();
00223 }
00224
00225 XnStatus XN_CALLBACK_TYPE __ModuleSetRepeat(XnModuleNodeHandle hInstance, XnBool bRepeat)
00226 {
00227 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00228 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00229 return pNode->SetRepeat(bRepeat);
00230 }
00231
00232 XnStatus XN_CALLBACK_TYPE __ModuleSeekToTimeStamp(XnModuleNodeHandle hInstance, XnInt64 nTimeOffset, XnPlayerSeekOrigin origin)
00233 {
00234 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00235 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00236 return pNode->SeekToTimeStamp(nTimeOffset, origin);
00237 }
00238
00239 XnStatus XN_CALLBACK_TYPE __ModuleSeekToFrame(XnModuleNodeHandle hInstance, const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)
00240 {
00241 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00242 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00243 return pNode->SeekToFrame(strNodeName, nFrameOffset, origin);
00244 }
00245
00246 XnStatus XN_CALLBACK_TYPE __ModuleTellTimestamp(XnModuleNodeHandle hInstance, XnUInt64* pnTimestamp)
00247 {
00248 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00249 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00250 return pNode->TellTimestamp(*pnTimestamp);
00251 }
00252
00253 XnStatus XN_CALLBACK_TYPE __ModuleTellFrame(XnModuleNodeHandle hInstance, const XnChar* strNodeName, XnUInt32* pnFrame)
00254 {
00255 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00256 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00257 return pNode->TellFrame(strNodeName, *pnFrame);
00258 }
00259
00260 XnStatus XN_CALLBACK_TYPE __ModuleGetNumFrames(XnModuleNodeHandle hInstance, const XnChar* strNodeName, XnUInt32* pnFrames)
00261 {
00262 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00263 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00264 return pNode->GetNumFrames(strNodeName, *pnFrames);
00265 }
00266
00267 const XnChar* XN_CALLBACK_TYPE __ModuleGetSupportedFormat(XnModuleNodeHandle hInstance)
00268 {
00269 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00270 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00271 return pNode->GetSupportedFormat();
00272 }
00273
00274 XnBool XN_CALLBACK_TYPE __ModuleIsEOF(XnModuleNodeHandle hGenerator)
00275 {
00276 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00277 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00278 return pNode->IsEOF();
00279 }
00280
00281 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToEndOfFileReached(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00282 {
00283 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00284 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00285 return pNode->RegisterToEndOfFileReached(handler, pCookie, *phCallback);
00286 }
00287
00288 void XN_CALLBACK_TYPE __ModuleUnregisterFromEndOfFileReached(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00289 {
00290 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00291 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00292 pNode->UnregisterFromEndOfFileReached(hCallback);
00293 }
00294
00295 XnStatus XN_CALLBACK_TYPE __ModuleSetNodeNotifications(XnModuleNodeHandle hInstance, void *pNodeNotificationsCookie, XnNodeNotifications *pNodeNotifications)
00296 {
00297 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00298 ModulePlayer* pNode = dynamic_cast<ModulePlayer*>(pProdNode);
00299 return pNode->SetNodeNotifications(pNodeNotificationsCookie, pNodeNotifications);
00300 }
00301
00302 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeAdded(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, XnProductionNodeType type, XnCodecID compression)
00303 {
00304 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00305 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00306 return pNode->OnNodeAdded(strNodeName, type, compression);
00307 }
00308
00309 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeRemoved(XnModuleNodeHandle hGenerator, const XnChar *strNodeName)
00310 {
00311 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00312 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00313 return pNode->OnNodeRemoved(strNodeName);
00314 }
00315
00316 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeIntPropChanged(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, const XnChar* strPropName, XnUInt64 nValue)
00317 {
00318 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00319 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00320 return pNode->OnNodeIntPropChanged(strNodeName, strPropName, nValue);
00321 }
00322
00323 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeRealPropChanged(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, const XnChar* strPropName, XnDouble dValue)
00324 {
00325 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00326 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00327 return pNode->OnNodeRealPropChanged(strNodeName, strPropName, dValue);
00328 }
00329
00330 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeStringPropChanged(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, const XnChar* strPropName, const XnChar* strValue)
00331 {
00332 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00333 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00334 return pNode->OnNodeStringPropChanged(strNodeName, strPropName, strValue);
00335 }
00336
00337 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeGeneralPropChanged(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, const XnChar* strPropName, XnUInt32 nBufferSize, const void* pBuffer)
00338 {
00339 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00340 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00341 return pNode->OnNodeGeneralPropChanged(strNodeName, strPropName, nBufferSize, pBuffer);
00342 }
00343
00344 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeNewData(XnModuleNodeHandle hGenerator, const XnChar *strNodeName, XnUInt64 nTimeStamp, XnUInt32 nFrame, const void *pData, XnUInt32 nSize)
00345 {
00346 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00347 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00348 return pNode->OnNodeNewData(strNodeName, nTimeStamp, nFrame, pData, nSize);
00349 }
00350
00351 XnStatus XN_CALLBACK_TYPE __ModuleOnNodeStateReady(XnModuleNodeHandle hGenerator, const XnChar *strNodeName)
00352 {
00353 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00354 ModuleRecorder* pNode = dynamic_cast<ModuleRecorder*>(pProdNode);
00355 return pNode->OnNodeStateReady(strNodeName);
00356 }
00357
00358 XnStatus XN_CALLBACK_TYPE __ModuleGetDeviceName(XnModuleNodeHandle hInstance, XnChar* strBuffer, XnUInt32* pnBufferSize)
00359 {
00360 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00361 ModuleDevice* pNode = dynamic_cast<ModuleDevice*>(pProdNode);
00362 ModuleDeviceIdentificationInterface* pInterface = pNode->GetIdentificationInterface();
00363 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00364 return pInterface->GetDeviceName(strBuffer, *pnBufferSize);
00365 }
00366
00367 XnStatus XN_CALLBACK_TYPE __ModuleGetVendorSpecificData(XnModuleNodeHandle hInstance, XnChar* strBuffer, XnUInt32* pnBufferSize)
00368 {
00369 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00370 ModuleDevice* pNode = dynamic_cast<ModuleDevice*>(pProdNode);
00371 ModuleDeviceIdentificationInterface* pInterface = pNode->GetIdentificationInterface();
00372 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00373 return pInterface->GetVendorSpecificData(strBuffer, *pnBufferSize);
00374 }
00375
00376 XnStatus XN_CALLBACK_TYPE __ModuleGetSerialNumber(XnModuleNodeHandle hInstance, XnChar* strBuffer, XnUInt32* pnBufferSize)
00377 {
00378 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hInstance;
00379 ModuleDevice* pNode = dynamic_cast<ModuleDevice*>(pProdNode);
00380 ModuleDeviceIdentificationInterface* pInterface = pNode->GetIdentificationInterface();
00381 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00382 return pInterface->GetSerialNumber(strBuffer, *pnBufferSize);
00383 }
00384
00385 XnStatus XN_CALLBACK_TYPE __ModuleSetMirror(XnModuleNodeHandle hGenerator, XnBool bMirror)
00386 {
00387 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00388 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00389 ModuleMirrorInterface* pInterface = pNode->GetMirrorInterface();
00390 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00391 return pInterface->SetMirror(bMirror);
00392 }
00393
00394 XnBool XN_CALLBACK_TYPE __ModuleIsMirrored(XnModuleNodeHandle hGenerator)
00395 {
00396 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00397 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00398 ModuleMirrorInterface* pInterface = pNode->GetMirrorInterface();
00399 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
00400 return pInterface->IsMirrored();
00401 }
00402
00403 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToMirrorChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00404 {
00405 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00406 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00407 ModuleMirrorInterface* pInterface = pNode->GetMirrorInterface();
00408 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00409 return pInterface->RegisterToMirrorChange(handler, pCookie, *phCallback);
00410 }
00411
00412 void XN_CALLBACK_TYPE __ModuleUnregisterFromMirrorChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00413 {
00414 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00415 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00416 ModuleMirrorInterface* pInterface = pNode->GetMirrorInterface();
00417 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00418 pInterface->UnregisterFromMirrorChange(hCallback);
00419 }
00420
00421 XnBool XN_CALLBACK_TYPE __ModuleIsViewPointSupported(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
00422 {
00423 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00424 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00425 ProductionNode node(hNode);
00426 ModuleAlternativeViewPointInterface* pInterface = pNode->GetAlternativeViewPointInterface();
00427 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
00428 return pInterface->IsViewPointSupported(node);
00429 }
00430
00431 XnStatus XN_CALLBACK_TYPE __ModuleSetViewPoint(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
00432 {
00433 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00434 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00435 ProductionNode node(hNode);
00436 ModuleAlternativeViewPointInterface* pInterface = pNode->GetAlternativeViewPointInterface();
00437 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00438 return pInterface->SetViewPoint(node);
00439 }
00440
00441 XnStatus XN_CALLBACK_TYPE __ModuleResetViewPoint(XnModuleNodeHandle hGenerator)
00442 {
00443 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00444 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00445 ModuleAlternativeViewPointInterface* pInterface = pNode->GetAlternativeViewPointInterface();
00446 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00447 return pInterface->ResetViewPoint();
00448 }
00449
00450 XnBool XN_CALLBACK_TYPE __ModuleIsViewPointAs(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
00451 {
00452 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00453 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00454 ModuleAlternativeViewPointInterface* pInterface = pNode->GetAlternativeViewPointInterface();
00455 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
00456 ProductionNode node(hNode);
00457 return pInterface->IsViewPointAs(node);
00458 }
00459
00460 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToViewPointChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00461 {
00462 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00463 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00464 ModuleAlternativeViewPointInterface* pInterface = pNode->GetAlternativeViewPointInterface();
00465 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00466 return pInterface->RegisterToViewPointChange(handler, pCookie, *phCallback);
00467 }
00468
00469 void XN_CALLBACK_TYPE __ModuleUnregisterFromViewPointChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00470 {
00471 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00472 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00473 ModuleAlternativeViewPointInterface* pInterface = pNode->GetAlternativeViewPointInterface();
00474 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00475 pInterface->UnregisterFromViewPointChange(hCallback);
00476 }
00477
00478 XnBool XN_CALLBACK_TYPE __ModuleCanFrameSyncWith(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
00479 {
00480 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00481 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00482 ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
00483 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
00484 ProductionNode node(hNode);
00485 return pInterface->CanFrameSyncWith(node);
00486 }
00487
00488 XnStatus XN_CALLBACK_TYPE __ModuleFrameSyncWith(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
00489 {
00490 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00491 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00492 ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
00493 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00494 ProductionNode node(hNode);
00495 return pInterface->FrameSyncWith(node);
00496 }
00497
00498 XnStatus XN_CALLBACK_TYPE __ModuleStopFrameSyncWith(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
00499 {
00500 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00501 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00502 ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
00503 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00504 ProductionNode node(hNode);
00505 return pInterface->StopFrameSyncWith(node);
00506 }
00507
00508 XnBool XN_CALLBACK_TYPE __ModuleIsFrameSyncedWith(XnModuleNodeHandle hGenerator, XnNodeHandle hNode)
00509 {
00510 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00511 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00512 ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
00513 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
00514 ProductionNode node(hNode);
00515 return pInterface->IsFrameSyncedWith(node);
00516 }
00517
00518 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToFrameSyncChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00519 {
00520 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00521 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00522 ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
00523 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00524 return pInterface->RegisterToFrameSyncChange(handler, pCookie, *phCallback);
00525 }
00526
00527 void XN_CALLBACK_TYPE __ModuleUnregisterFromFrameSyncChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00528 {
00529 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00530 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00531 ModuleFrameSyncInterface* pInterface = pNode->GetFrameSyncInterface();
00532 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00533 pInterface->UnregisterFromFrameSyncChange(hCallback);
00534 }
00535
00536 XnStatus XN_CALLBACK_TYPE __ModuleStartGenerating(XnModuleNodeHandle hGenerator)
00537 {
00538 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00539 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00540 return pNode->StartGenerating();
00541 }
00542
00543 XnBool XN_CALLBACK_TYPE __ModuleIsGenerating(XnModuleNodeHandle hGenerator)
00544 {
00545 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00546 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00547 return pNode->IsGenerating();
00548 }
00549
00550 void XN_CALLBACK_TYPE __ModuleStopGenerating(XnModuleNodeHandle hGenerator)
00551 {
00552 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00553 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00554 pNode->StopGenerating();
00555 }
00556
00557 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToGenerationRunningChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00558 {
00559 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00560 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00561 return pNode->RegisterToGenerationRunningChange(handler, pCookie, *phCallback);
00562 }
00563
00564 void XN_CALLBACK_TYPE __ModuleUnregisterFromGenerationRunningChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00565 {
00566 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00567 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00568 pNode->UnregisterFromGenerationRunningChange(hCallback);
00569 }
00570
00571 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToNewDataAvailable(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00572 {
00573 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00574 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00575 return pNode->RegisterToNewDataAvailable(handler, pCookie, *phCallback);
00576 }
00577
00578 void XN_CALLBACK_TYPE __ModuleUnregisterFromNewDataAvailable(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00579 {
00580 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00581 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00582 pNode->UnregisterFromNewDataAvailable(hCallback);
00583 }
00584
00585 XnBool XN_CALLBACK_TYPE __ModuleIsNewDataAvailable(XnModuleNodeHandle hGenerator, XnUInt64* pnTimestamp)
00586 {
00587 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00588 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00589 return pNode->IsNewDataAvailable(*pnTimestamp);
00590 }
00591
00592 XnStatus XN_CALLBACK_TYPE __ModuleUpdateData(XnModuleNodeHandle hGenerator)
00593 {
00594 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00595 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00596 return pNode->UpdateData();
00597 }
00598
00599 const void* XN_CALLBACK_TYPE __ModuleGetData(XnModuleNodeHandle hGenerator)
00600 {
00601 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00602 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00603 return pNode->GetData();
00604 }
00605
00606 XnUInt32 XN_CALLBACK_TYPE __ModuleGetDataSize(XnModuleNodeHandle hGenerator)
00607 {
00608 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00609 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00610 return pNode->GetDataSize();
00611 }
00612
00613 XnUInt64 XN_CALLBACK_TYPE __ModuleGetTimestamp(XnModuleNodeHandle hGenerator)
00614 {
00615 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00616 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00617 return pNode->GetTimestamp();
00618 }
00619
00620 XnUInt32 XN_CALLBACK_TYPE __ModuleGetFrameID(XnModuleNodeHandle hGenerator)
00621 {
00622 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00623 ModuleGenerator* pNode = dynamic_cast<ModuleGenerator*>(pProdNode);
00624 return pNode->GetFrameID();
00625 }
00626
00627 XnStatus XN_CALLBACK_TYPE __ModuleSetCropping(XnModuleNodeHandle hGenerator, const XnCropping* pCropping)
00628 {
00629 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00630 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00631 ModuleCroppingInterface* pInterface = pNode->GetCroppingInterface();
00632 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00633 return pInterface->SetCropping(*pCropping);
00634 }
00635
00636 XnStatus XN_CALLBACK_TYPE __ModuleGetCropping(XnModuleNodeHandle hGenerator, XnCropping* pCropping)
00637 {
00638 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00639 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00640 ModuleCroppingInterface* pInterface = pNode->GetCroppingInterface();
00641 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00642 return pInterface->GetCropping(*pCropping);
00643 }
00644
00645 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToCroppingChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00646 {
00647 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00648 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00649 ModuleCroppingInterface* pInterface = pNode->GetCroppingInterface();
00650 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00651 return pInterface->RegisterToCroppingChange(handler, pCookie, *phCallback);
00652 }
00653
00654 void XN_CALLBACK_TYPE __ModuleUnregisterFromCroppingChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00655 {
00656 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00657 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00658 ModuleCroppingInterface* pInterface = pNode->GetCroppingInterface();
00659 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00660 pInterface->UnregisterFromCroppingChange(hCallback);
00661 }
00662
00663 XnStatus XN_CALLBACK_TYPE __ModuleSetPowerLineFrequency(XnModuleNodeHandle hGenerator, XnPowerLineFrequency nFrequency)
00664 {
00665 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00666 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00667 ModuleAntiFlickerInterface* pInterface = pNode->GetAntiFlickerInterface();
00668 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00669 return pInterface->SetPowerLineFrequency(nFrequency);
00670 }
00671
00672 XnPowerLineFrequency XN_CALLBACK_TYPE __ModuleGetPowerLineFrequency(XnModuleNodeHandle hGenerator)
00673 {
00674 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00675 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00676 ModuleAntiFlickerInterface* pInterface = pNode->GetAntiFlickerInterface();
00677 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, XN_POWER_LINE_FREQUENCY_OFF);
00678 return pInterface->GetPowerLineFrequency();
00679 }
00680
00681 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPowerLineFrequencyChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00682 {
00683 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00684 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00685 ModuleAntiFlickerInterface* pInterface = pNode->GetAntiFlickerInterface();
00686 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00687 return pInterface->RegisterToPowerLineFrequencyChange(handler, pCookie, *phCallback);
00688 }
00689
00690 void XN_CALLBACK_TYPE __ModuleUnregisterFromPowerLineFrequencyChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00691 {
00692 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00693 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00694 ModuleAntiFlickerInterface* pInterface = pNode->GetAntiFlickerInterface();
00695 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00696 pInterface->UnregisterFromPowerLineFrequencyChange(hCallback);
00697 }
00698
00699 XnUInt32 XN_CALLBACK_TYPE __ModuleGetSupportedMapOutputModesCount(XnModuleNodeHandle hGenerator)
00700 {
00701 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00702 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00703 return pNode->GetSupportedMapOutputModesCount();
00704 }
00705
00706 XnStatus XN_CALLBACK_TYPE __ModuleGetSupportedMapOutputModes(XnModuleNodeHandle hGenerator, XnMapOutputMode* aModes, XnUInt32* pnCount)
00707 {
00708 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00709 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00710 return pNode->GetSupportedMapOutputModes(aModes, *pnCount);
00711 }
00712
00713 XnStatus XN_CALLBACK_TYPE __ModuleSetMapOutputMode(XnModuleNodeHandle hGenerator, const XnMapOutputMode* pOutputMode)
00714 {
00715 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00716 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00717 return pNode->SetMapOutputMode(*pOutputMode);
00718 }
00719
00720 XnStatus XN_CALLBACK_TYPE __ModuleGetMapOutputMode(XnModuleNodeHandle hGenerator, XnMapOutputMode* pOutputMode)
00721 {
00722 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00723 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00724 return pNode->GetMapOutputMode(*pOutputMode);
00725 }
00726
00727 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToMapOutputModeChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00728 {
00729 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00730 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00731 return pNode->RegisterToMapOutputModeChange(handler, pCookie, *phCallback);
00732 }
00733
00734 void XN_CALLBACK_TYPE __ModuleUnregisterFromMapOutputModeChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00735 {
00736 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00737 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00738 pNode->UnregisterFromMapOutputModeChange(hCallback);
00739 }
00740
00741 XnUInt32 XN_CALLBACK_TYPE __ModuleGetBytesPerPixel(XnModuleNodeHandle hGenerator)
00742 {
00743 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00744 ModuleMapGenerator* pNode = dynamic_cast<ModuleMapGenerator*>(pProdNode);
00745 return pNode->GetBytesPerPixel();
00746 }
00747
00748 XnUInt32 XN_CALLBACK_TYPE __ModuleGetSupportedUserPositionsCount(XnModuleNodeHandle hGenerator)
00749 {
00750 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00751 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00752 ModuleUserPositionInterface* pInterface = pNode->GetUserPositionInterface();
00753 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, 0);
00754 return pInterface->GetSupportedUserPositionsCount();
00755 }
00756
00757 XnStatus XN_CALLBACK_TYPE __ModuleSetUserPosition(XnModuleNodeHandle hGenerator, XnUInt32 nIndex, const XnBoundingBox3D* pPosition)
00758 {
00759 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00760 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00761 ModuleUserPositionInterface* pInterface = pNode->GetUserPositionInterface();
00762 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00763 return pInterface->SetUserPosition(nIndex, *pPosition);
00764 }
00765
00766 XnStatus XN_CALLBACK_TYPE __ModuleGetUserPosition(XnModuleNodeHandle hGenerator, XnUInt32 nIndex, XnBoundingBox3D* pPosition)
00767 {
00768 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00769 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00770 ModuleUserPositionInterface* pInterface = pNode->GetUserPositionInterface();
00771 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00772 return pInterface->GetUserPosition(nIndex, *pPosition);
00773 }
00774
00775 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToUserPositionChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00776 {
00777 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00778 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00779 ModuleUserPositionInterface* pInterface = pNode->GetUserPositionInterface();
00780 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
00781 return pInterface->RegisterToUserPositionChange(handler, pCookie, *phCallback);
00782 }
00783
00784 void XN_CALLBACK_TYPE __ModuleUnregisterFromUserPositionChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00785 {
00786 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00787 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00788 ModuleUserPositionInterface* pInterface = pNode->GetUserPositionInterface();
00789 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
00790 pInterface->UnregisterFromUserPositionChange(hCallback);
00791 }
00792
00793 XnDepthPixel XN_CALLBACK_TYPE __ModuleGetDeviceMaxDepth(XnModuleNodeHandle hGenerator)
00794 {
00795 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00796 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00797 return pNode->GetDeviceMaxDepth();
00798 }
00799
00800 void XN_CALLBACK_TYPE __ModuleGetFieldOfView(XnModuleNodeHandle hGenerator, XnFieldOfView* pFOV)
00801 {
00802 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00803 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00804 pNode->GetFieldOfView(*pFOV);
00805 }
00806
00807 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToFieldOfViewChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00808 {
00809 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00810 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00811 return pNode->RegisterToFieldOfViewChange(handler, pCookie, *phCallback);
00812 }
00813
00814 void XN_CALLBACK_TYPE __ModuleUnregisterFromFieldOfViewChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00815 {
00816 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00817 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00818 pNode->UnregisterFromFieldOfViewChange(hCallback);
00819 }
00820
00821 XnDepthPixel* XN_CALLBACK_TYPE __ModuleGetDepthMap(XnModuleNodeHandle hGenerator)
00822 {
00823 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00824 ModuleDepthGenerator* pNode = dynamic_cast<ModuleDepthGenerator*>(pProdNode);
00825 return pNode->GetDepthMap();
00826 }
00827
00828 XnUInt8* XN_CALLBACK_TYPE __ModuleGetImageMap(XnModuleNodeHandle hGenerator)
00829 {
00830 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00831 ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
00832 return pNode->GetImageMap();
00833 }
00834
00835 XnBool XN_CALLBACK_TYPE __ModuleIsPixelFormatSupported(XnModuleNodeHandle hGenerator, XnPixelFormat Format)
00836 {
00837 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00838 ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
00839 return pNode->IsPixelFormatSupported(Format);
00840 }
00841
00842 XnStatus XN_CALLBACK_TYPE __ModuleSetPixelFormat(XnModuleNodeHandle hGenerator, XnPixelFormat Format)
00843 {
00844 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00845 ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
00846 return pNode->SetPixelFormat(Format);
00847 }
00848
00849 XnPixelFormat XN_CALLBACK_TYPE __ModuleGetPixelFormat(XnModuleNodeHandle hGenerator)
00850 {
00851 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00852 ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
00853 return pNode->GetPixelFormat();
00854 }
00855
00856 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPixelFormatChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00857 {
00858 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00859 ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
00860 return pNode->RegisterToPixelFormatChange(handler, pCookie, *phCallback);
00861 }
00862
00863 void XN_CALLBACK_TYPE __ModuleUnregisterFromPixelFormatChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00864 {
00865 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00866 ModuleImageGenerator* pNode = dynamic_cast<ModuleImageGenerator*>(pProdNode);
00867 pNode->UnregisterFromPixelFormatChange(hCallback);
00868 }
00869
00870 XnIRPixel* XN_CALLBACK_TYPE __ModuleGetIRMap(XnModuleNodeHandle hGenerator)
00871 {
00872 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00873 ModuleIRGenerator* pNode = dynamic_cast<ModuleIRGenerator*>(pProdNode);
00874 return pNode->GetIRMap();
00875 }
00876
00877 XnStatus XN_CALLBACK_TYPE __ModuleAddGesture(XnModuleNodeHandle hGenerator, const XnChar* strGesture, XnBoundingBox3D* pArea)
00878 {
00879 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00880 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00881 return pNode->AddGesture(strGesture, pArea);
00882 }
00883
00884 XnStatus XN_CALLBACK_TYPE __ModuleRemoveGesture(XnModuleNodeHandle hGenerator, const XnChar* strGesture)
00885 {
00886 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00887 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00888 return pNode->RemoveGesture(strGesture);
00889 }
00890 XnStatus XN_CALLBACK_TYPE __ModuleGetActiveGestures(XnModuleNodeHandle hGenerator, XnChar** pstrGestures, XnUInt16* pnGestures)
00891 {
00892 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00893 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00894 return pNode->GetActiveGestures(pstrGestures, *pnGestures);
00895 }
00896 XnStatus XN_CALLBACK_TYPE __ModuleGetAllActiveGestures(XnModuleNodeHandle hGenerator, XnChar** pstrGestures, XnUInt32 nNameLength, XnUInt16* pnGestures)
00897 {
00898 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00899 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00900 return pNode->GetAllActiveGestures(pstrGestures, nNameLength, *pnGestures);
00901 }
00902 XnStatus XN_CALLBACK_TYPE __ModuleEnumerateGestures(XnModuleNodeHandle hGenerator, XnChar** pstrGestures, XnUInt16* pnGestures)
00903 {
00904 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00905 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00906 return pNode->EnumerateGestures(pstrGestures, *pnGestures);
00907 }
00908 XnStatus XN_CALLBACK_TYPE __ModuleEnumerateAllGestures(XnModuleNodeHandle hGenerator, XnChar** pstrGestures, XnUInt32 nNameLength, XnUInt16* pnGestures)
00909 {
00910 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00911 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00912 return pNode->EnumerateAllGestures(pstrGestures, nNameLength, *pnGestures);
00913 }
00914 XnBool XN_CALLBACK_TYPE __ModuleIsGestureAvailable(XnModuleNodeHandle hGenerator, const XnChar* strGesture)
00915 {
00916 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00917 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00918 return pNode->IsGestureAvailable(strGesture);
00919 }
00920 XnBool XN_CALLBACK_TYPE __ModuleIsGestureProgressSupported(XnModuleNodeHandle hGenerator, const XnChar* strGesture)
00921 {
00922 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00923 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00924 return pNode->IsGestureProgressSupported(strGesture);
00925 }
00926 XnStatus XN_CALLBACK_TYPE __ModuleRegisterGestureCallbacks(XnModuleNodeHandle hGenerator, XnModuleGestureRecognized RecognizedCB, XnModuleGestureProgress ProgressCB, void* pCookie, XnCallbackHandle* phCallback)
00927 {
00928 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00929 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00930 return pNode->RegisterGestureCallbacks(RecognizedCB, ProgressCB, pCookie, *phCallback);
00931 }
00932 void XN_CALLBACK_TYPE __ModuleUnregisterGestureCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00933 {
00934 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00935 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00936 pNode->UnregisterGestureCallbacks(hCallback);
00937 }
00938 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToGestureChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
00939 {
00940 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00941 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00942 return pNode->RegisterToGestureChange(handler, pCookie, *phCallback);
00943 }
00944 void XN_CALLBACK_TYPE __ModuleUnregisterFromGestureChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00945 {
00946 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00947 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00948 pNode->UnregisterFromGestureChange(hCallback);
00949 }
00950 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToGestureIntermediateStageCompleted(XnModuleNodeHandle hGenerator, XnModuleGestureIntermediateStageCompleted handler, void* pCookie, XnCallbackHandle* phCallback)
00951 {
00952 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00953 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00954 return pNode->RegisterToGestureIntermediateStageCompleted(handler, pCookie, *phCallback);
00955 }
00956 void XN_CALLBACK_TYPE __ModuleUnregisterFromGestureIntermediateStageCompleted(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00957 {
00958 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00959 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00960 pNode->UnregisterFromGestureIntermediateStageCompleted(hCallback);
00961 }
00962 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToGestureReadyForNextIntermediateStage(XnModuleNodeHandle hGenerator, XnModuleGestureReadyForNextIntermediateStage handler, void* pCookie, XnCallbackHandle* phCallback)
00963 {
00964 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00965 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00966 return pNode->RegisterToGestureReadyForNextIntermediateStage(handler, pCookie, *phCallback);
00967 }
00968 void XN_CALLBACK_TYPE __ModuleUnregisterFromGestureReadyForNextIntermediateStage(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00969 {
00970 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00971 ModuleGestureGenerator* pNode = dynamic_cast<ModuleGestureGenerator*>(pProdNode);
00972 pNode->UnregisterFromGestureReadyForNextIntermediateStage(hCallback);
00973 }
00974
00975 const XnLabel* XN_CALLBACK_TYPE __ModuleGetLabelMap(XnModuleNodeHandle hGenerator)
00976 {
00977 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00978 ModuleSceneAnalyzer* pNode = dynamic_cast<ModuleSceneAnalyzer*>(pProdNode);
00979 return pNode->GetLabelMap();
00980 }
00981 XnStatus XN_CALLBACK_TYPE __ModuleGetFloor(XnModuleNodeHandle hGenerator, XnPlane3D* pPlane)
00982 {
00983 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00984 ModuleSceneAnalyzer* pNode = dynamic_cast<ModuleSceneAnalyzer*>(pProdNode);
00985 return pNode->GetFloor(*pPlane);
00986 }
00987
00988 XnStatus XN_CALLBACK_TYPE __ModuleRegisterHandCallbacks(XnModuleNodeHandle hGenerator, XnModuleHandCreate CreateCB, XnModuleHandUpdate UpdateCB, XnModuleHandDestroy DestroyCB, void* pCookie, XnCallbackHandle* phCallback)
00989 {
00990 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00991 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
00992 return pNode->RegisterHandCallbacks(CreateCB, UpdateCB, DestroyCB, pCookie, *phCallback);
00993 }
00994 void XN_CALLBACK_TYPE __ModuleUnregisterHandCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
00995 {
00996 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
00997 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
00998 pNode->UnregisterHandCallbacks(hCallback);
00999 }
01000 XnStatus XN_CALLBACK_TYPE __ModuleStopTracking(XnModuleNodeHandle hGenerator, XnUserID user)
01001 {
01002 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01003 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
01004 return pNode->StopTracking(user);
01005 }
01006 XnStatus XN_CALLBACK_TYPE __ModuleStopTrackingAll(XnModuleNodeHandle hGenerator)
01007 {
01008 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01009 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
01010 return pNode->StopTrackingAll();
01011 }
01012 XnStatus XN_CALLBACK_TYPE __ModuleStartTracking(XnModuleNodeHandle hGenerator, const XnPoint3D* pPosition)
01013 {
01014 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01015 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
01016 return pNode->StartTracking(*pPosition);
01017 }
01018 XnStatus XN_CALLBACK_TYPE __ModuleSetTrackingSmoothing(XnModuleNodeHandle hGenerator, XnFloat fSmoothingFactor)
01019 {
01020 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01021 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
01022 return pNode->SetSmoothing(fSmoothingFactor);
01023 }
01024
01025 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToHandTouchingFOVEdgeCallback(XnModuleNodeHandle hGenerator, XnModuleHandTouchingFOVEdge handler, void* pCookie, XnCallbackHandle* phCallback)
01026 {
01027 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01028 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
01029 ModuleHandTouchingFOVEdgeInterface* pInterface = pNode->GetHandTouchingFOVEdgeInterface();
01030 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01031 return pInterface->RegisterToHandTouchingFOVEdge(handler, pCookie, *phCallback);
01032 }
01033 void XN_CALLBACK_TYPE __ModuleUnregisterFromHandTouchingFOVEdgeCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01034 {
01035 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01036 ModuleHandsGenerator* pNode = dynamic_cast<ModuleHandsGenerator*>(pProdNode);
01037 ModuleHandTouchingFOVEdgeInterface* pInterface = pNode->GetHandTouchingFOVEdgeInterface();
01038 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, );
01039 pInterface->UnregisterFromHandTouchingFOVEdge(hCallback);
01040 }
01041
01042 XnBool XN_CALLBACK_TYPE __ModuleIsJointAvailable(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint)
01043 {
01044 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01045 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01046 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01047 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
01048 return pInterface->IsJointAvailable(eJoint);
01049 }
01050 XnBool XN_CALLBACK_TYPE __ModuleIsProfileAvailable(XnModuleNodeHandle hGenerator, XnSkeletonProfile eProfile)
01051 {
01052 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01053 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01054 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01055 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
01056 return pInterface->IsProfileAvailable(eProfile);
01057 }
01058 XnStatus XN_CALLBACK_TYPE __ModuleSetSkeletonProfile(XnModuleNodeHandle hGenerator, XnSkeletonProfile eProfile)
01059 {
01060 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01061 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01062 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01063 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01064 return pInterface->SetSkeletonProfile(eProfile);
01065 }
01066 XnStatus XN_CALLBACK_TYPE __ModuleSetJointActive(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint, XnBool bState)
01067 {
01068 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01069 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01070 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01071 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01072 return pInterface->SetJointActive(eJoint, bState);
01073 }
01074 XnBool XN_CALLBACK_TYPE __ModuleIsJointActive(XnModuleNodeHandle hGenerator, XnSkeletonJoint eJoint)
01075 {
01076 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01077 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01078 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01079 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
01080 return pInterface->IsJointActive(eJoint);
01081 }
01082 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToJointConfigurationChange(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
01083 {
01084 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01085 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01086 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01087 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01088 return pInterface->RegisterToJointConfigurationChange(handler, pCookie, *phCallback);
01089 }
01090 void XN_CALLBACK_TYPE __ModuleUnregisterFromJointConfigurationChange(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01091 {
01092 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01093 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01094 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01095 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01096 pInterface->UnregisterFromJointConfigurationChange(hCallback);
01097 }
01098 XnStatus XN_CALLBACK_TYPE __ModuleEnumerateActiveJoints(XnModuleNodeHandle hGenerator, XnSkeletonJoint* pJoints, XnUInt16* pnJoints)
01099 {
01100 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01101 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01102 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01103 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01104 return pInterface->EnumerateActiveJoints(pJoints, *pnJoints);
01105 }
01106 XnStatus XN_CALLBACK_TYPE __ModuleGetSkeletonJoint(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation* pJoint)
01107 {
01108 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01109 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01110 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01111 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01112 return pInterface->GetSkeletonJoint(user, eJoint, *pJoint);
01113 }
01114 XnStatus XN_CALLBACK_TYPE __ModuleGetSkeletonJointPosition(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition* pJoint)
01115 {
01116 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01117 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01118 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01119 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01120 return pInterface->GetSkeletonJointPosition(user, eJoint, *pJoint);
01121 }
01122 XnStatus XN_CALLBACK_TYPE __ModuleGetSkeletonJointOrientation(XnModuleNodeHandle hGenerator, XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation* pJoint)
01123 {
01124 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01125 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01126 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01127 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01128 return pInterface->GetSkeletonJointOrientation(user, eJoint, *pJoint);
01129 }
01130 XnBool XN_CALLBACK_TYPE __ModuleIsSkeletonTracking(XnModuleNodeHandle hGenerator, XnUserID user)
01131 {
01132 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01133 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01134 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01135 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
01136 return pInterface->IsTracking(user);
01137 }
01138 XnBool XN_CALLBACK_TYPE __ModuleIsSkeletonCalibrated(XnModuleNodeHandle hGenerator, XnUserID user)
01139 {
01140 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01141 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01142 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01143 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
01144 return pInterface->IsCalibrated(user);
01145 }
01146 XnBool XN_CALLBACK_TYPE __ModuleIsSkeletonCalibrating(XnModuleNodeHandle hGenerator, XnUserID user)
01147 {
01148 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01149 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01150 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01151 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
01152 return pInterface->IsCalibrating(user);
01153 }
01154
01155 XnStatus XN_CALLBACK_TYPE __ModuleRequestSkeletonCalibration(XnModuleNodeHandle hGenerator, XnUserID user, XnBool bForce)
01156 {
01157 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01158 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01159 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01160 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01161 return pInterface->RequestCalibration(user, bForce);
01162 }
01163 XnStatus XN_CALLBACK_TYPE __ModuleAbortSkeletonCalibration(XnModuleNodeHandle hGenerator, XnUserID user)
01164 {
01165 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01166 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01167 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01168 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01169 return pInterface->AbortCalibration(user);
01170 }
01171 XnStatus XN_CALLBACK_TYPE __ModuleSaveCalibrationDataToFile(XnModuleNodeHandle hGenerator, XnUserID user, const XnChar* strFileName)
01172 {
01173 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01174 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01175 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01176 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01177 return pInterface->SaveCalibrationDataToFile(user, strFileName);
01178 }
01179 XnStatus XN_CALLBACK_TYPE __ModuleLoadCalibrationDataFromFile(XnModuleNodeHandle hGenerator, XnUserID user, const XnChar* strFileName)
01180 {
01181 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01182 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01183 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01184 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01185 return pInterface->LoadCalibrationDataFromFile(user, strFileName);
01186 }
01187 XnStatus XN_CALLBACK_TYPE __ModuleSaveCalibrationData(XnModuleNodeHandle hGenerator, XnUserID user, XnUInt32 nSlot)
01188 {
01189 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01190 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01191 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01192 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01193 return pInterface->SaveCalibrationData(user, nSlot);
01194 }
01195 XnStatus XN_CALLBACK_TYPE __ModuleLoadCalibrationData(XnModuleNodeHandle hGenerator, XnUserID user, XnUInt32 nSlot)
01196 {
01197 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01198 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01199 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01200 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01201 return pInterface->LoadCalibrationData(user, nSlot);
01202 }
01203 XnStatus XN_CALLBACK_TYPE __ModuleClearCalibrationData(XnModuleNodeHandle hGenerator, XnUInt32 nSlot)
01204 {
01205 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01206 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01207 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01208 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01209 return pInterface->ClearCalibrationData(nSlot);
01210 }
01211 XnBool XN_CALLBACK_TYPE __ModuleIsCalibrationData(XnModuleNodeHandle hGenerator, XnUInt32 nSlot)
01212 {
01213 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01214 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01215 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01216 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
01217 return pInterface->IsCalibrationData(nSlot);
01218 }
01219 XnStatus XN_CALLBACK_TYPE __ModuleStartSkeletonTracking(XnModuleNodeHandle hGenerator, XnUserID user)
01220 {
01221 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01222 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01223 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01224 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01225 return pInterface->StartTracking(user);
01226 }
01227 XnStatus XN_CALLBACK_TYPE __ModuleStopSkeletonTracking(XnModuleNodeHandle hGenerator, XnUserID user)
01228 {
01229 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01230 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01231 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01232 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01233 return pInterface->StopTracking(user);
01234 }
01235 XnStatus XN_CALLBACK_TYPE __ModuleResetSkeleton(XnModuleNodeHandle hGenerator, XnUserID user)
01236 {
01237 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01238 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01239 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01240 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01241 return pInterface->Reset(user);
01242 }
01243 XnBool XN_CALLBACK_TYPE __ModuleNeedPoseForSkeletonCalibration(XnModuleNodeHandle hGenerator)
01244 {
01245 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01246 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01247 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01248 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, FALSE);
01249 return pInterface->NeedPoseForCalibration();
01250 }
01251 XnStatus XN_CALLBACK_TYPE __ModuleGetSkeletonCalibrationPose(XnModuleNodeHandle hGenerator, XnChar* strPose)
01252 {
01253 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01254 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01255 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01256 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01257 return pInterface->GetCalibrationPose(strPose);
01258 }
01259 XnStatus XN_CALLBACK_TYPE __ModuleSetSkeletonSmoothing(XnModuleNodeHandle hGenerator, XnFloat fSmoothingFactor)
01260 {
01261 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01262 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01263 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01264 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01265 return pInterface->SetSmoothing(fSmoothingFactor);
01266 }
01267 XnStatus XN_CALLBACK_TYPE __ModuleRegisterCalibrationCallbacks(XnModuleNodeHandle hGenerator, XnModuleCalibrationStart CalibrationStartCB, XnModuleCalibrationEnd CalibrationEndCB, void* pCookie, XnCallbackHandle* phCallback)
01268 {
01269 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01270 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01271 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01272 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01273 return pInterface->RegisterCalibrationCallbacks(CalibrationStartCB, CalibrationEndCB, pCookie, *phCallback);
01274 }
01275 void XN_CALLBACK_TYPE __ModuleUnregisterCalibrationCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01276 {
01277 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01278 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01279 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01280 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01281 pInterface->UnregisterCalibrationCallbacks(hCallback);
01282 }
01283
01284 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToCalibrationStartCallback(XnModuleNodeHandle hGenerator, XnModuleCalibrationStart handler, void* pCookie, XnCallbackHandle* phCallback)
01285 {
01286 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01287 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01288 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01289 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01290 return pInterface->RegisterToCalibrationStart(handler, pCookie, *phCallback);
01291 }
01292 void XN_CALLBACK_TYPE __ModuleUnregisterFromCalibrationStartCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01293 {
01294 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01295 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01296 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01297 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01298 pInterface->UnregisterFromCalibrationStart(hCallback);
01299 }
01300
01301 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToCalibrationInProgressCallback(XnModuleNodeHandle hGenerator, XnModuleCalibrationInProgress handler, void* pCookie, XnCallbackHandle* phCallback)
01302 {
01303 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01304 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01305 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01306 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01307 return pInterface->RegisterToCalibrationInProgress(handler, pCookie, *phCallback);
01308 }
01309 void XN_CALLBACK_TYPE __ModuleUnregisterFromCalibrationInProgressCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01310 {
01311 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01312 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01313 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01314 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01315 pInterface->UnregisterFromCalibrationInProgress(hCallback);
01316 }
01317 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToCalibrationCompleteCallback(XnModuleNodeHandle hGenerator, XnModuleCalibrationComplete handler, void* pCookie, XnCallbackHandle* phCallback)
01318 {
01319 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01320 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01321 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01322 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01323 return pInterface->RegisterToCalibrationComplete(handler, pCookie, *phCallback);
01324 }
01325 void XN_CALLBACK_TYPE __ModuleUnregisterFromCalibrationCompleteCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01326 {
01327 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01328 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01329 ModuleSkeletonInterface* pInterface = pNode->GetSkeletonInterface();
01330 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01331 pInterface->UnregisterFromCalibrationComplete(hCallback);
01332 }
01334 XnUInt32 XN_CALLBACK_TYPE __ModuleGetNumberOfPoses(XnModuleNodeHandle hGenerator)
01335 {
01336 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01337 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01338 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01339 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface, 0);
01340 return pInterface->GetNumberOfPoses();
01341 }
01342 XnStatus XN_CALLBACK_TYPE __ModuleGetAvailablePoses(XnModuleNodeHandle hGenerator, XnChar** pstrPoses, XnUInt32* pnPoses)
01343 {
01344 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01345 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01346 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01347 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01348 return pInterface->GetAvailablePoses(pstrPoses, *pnPoses);
01349 }
01350 XnStatus XN_CALLBACK_TYPE __ModuleGetAllAvailablePoses(XnModuleNodeHandle hGenerator, XnChar** pstrPoses, XnUInt32 nNameLength, XnUInt32* pnPoses)
01351 {
01352 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01353 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01354 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01355 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01356 return pInterface->GetAllAvailablePoses(pstrPoses, nNameLength, *pnPoses);
01357 }
01358
01359 XnStatus XN_CALLBACK_TYPE __ModuleStartPoseDetection(XnModuleNodeHandle hGenerator, const XnChar* strPose, XnUserID user)
01360 {
01361 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01362 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01363 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01364 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01365 return pInterface->StartPoseDetection(strPose, user);
01366 }
01367 XnStatus XN_CALLBACK_TYPE __ModuleStopPoseDetection(XnModuleNodeHandle hGenerator, XnUserID user)
01368 {
01369 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01370 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01371 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01372 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01373 return pInterface->StopPoseDetection(user);
01374 }
01375
01376 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPoseCallbacks(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback PoseDetectionStartCB, XnModulePoseDetectionCallback PoseDetectionEndCB, void* pCookie, XnCallbackHandle* phCallback)
01377 {
01378 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01379 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01380 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01381 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01382 return pInterface->RegisterToPoseDetectionCallbacks(PoseDetectionStartCB, PoseDetectionEndCB, pCookie, *phCallback);
01383 }
01384 void XN_CALLBACK_TYPE __ModuleUnregisterFromPoseCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01385 {
01386 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01387 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01388 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01389 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01390 pInterface->UnregisterFromPoseDetectionCallbacks(hCallback);
01391 }
01392
01393 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPoseDetected(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback handler, void* pCookie, XnCallbackHandle* phCallback)
01394 {
01395 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01396 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01397 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01398 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01399 return pInterface->RegisterToPoseDetected(handler, pCookie, *phCallback);
01400 }
01401 void XN_CALLBACK_TYPE __ModuleUnregisterFromPoseDetected(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01402 {
01403 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01404 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01405 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01406 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01407 pInterface->UnregisterFromPoseDetected(hCallback);
01408 }
01409 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToOutOfPose(XnModuleNodeHandle hGenerator, XnModulePoseDetectionCallback handler, void* pCookie, XnCallbackHandle* phCallback)
01410 {
01411 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01412 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01413 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01414 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01415 return pInterface->RegisterToOutOfPose(handler, pCookie, *phCallback);
01416 }
01417 void XN_CALLBACK_TYPE __ModuleUnregisterFromOutOfPose(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01418 {
01419 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01420 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01421 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01422 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01423 pInterface->UnregisterFromOutOfPose(hCallback);
01424 }
01425
01426 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToPoseInProgressCallback(XnModuleNodeHandle hGenerator, XnModulePoseDetectionInProgressCallback handler, void* pCookie, XnCallbackHandle* phCallback)
01427 {
01428 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01429 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01430 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01431 _XN_VALIDATE_CAPABILITY_INTERFACE(pInterface);
01432 return pInterface->RegisterToPoseDetectionInProgress(handler, pCookie, *phCallback);
01433 }
01434 void XN_CALLBACK_TYPE __ModuleUnregisterFromPoseInProgressCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01435 {
01436 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01437 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01438 ModulePoseDetectionInteface* pInterface = pNode->GetPoseDetectionInteface();
01439 _XN_VALIDATE_CAPABILITY_INTERFACE_RET(pInterface,);
01440 pInterface->UnregisterFromPoseDetectionInProgress(hCallback);
01441 }
01442
01443
01444 XnUInt16 XN_CALLBACK_TYPE __ModuleGetNumberOfUsers(XnModuleNodeHandle hGenerator)
01445 {
01446 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01447 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01448 return pNode->GetNumberOfUsers();
01449 }
01450 XnStatus XN_CALLBACK_TYPE __ModuleGetUsers(XnModuleNodeHandle hGenerator, XnUserID* pUsers, XnUInt16* pnUsers)
01451 {
01452 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01453 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01454 return pNode->GetUsers(pUsers, *pnUsers);
01455 }
01456 XnStatus XN_CALLBACK_TYPE __ModuleGetUserCoM(XnModuleNodeHandle hGenerator, XnUserID user, XnPoint3D* pCoM)
01457 {
01458 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01459 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01460 return pNode->GetCoM(user, *pCoM);
01461 }
01462 XnStatus XN_CALLBACK_TYPE __ModuleGetUserPixels(XnModuleNodeHandle hGenerator, XnUserID user, XnSceneMetaData* pScene)
01463 {
01464 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01465 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01466 return pNode->GetUserPixels(user, pScene);
01467 }
01468 XnStatus XN_CALLBACK_TYPE __ModuleRegisterUserCallbacks(XnModuleNodeHandle hGenerator, XnModuleUserHandler NewUserCB, XnModuleUserHandler LostUserCB, void* pCookie, XnCallbackHandle* phCallback)
01469 {
01470 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01471 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01472 return pNode->RegisterUserCallbacks(NewUserCB, LostUserCB, pCookie, *phCallback);
01473 }
01474 void XN_CALLBACK_TYPE __ModuleUnregisterUserCallbacks(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01475 {
01476 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01477 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01478 pNode->UnregisterUserCallbacks(hCallback);
01479 }
01480
01481 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToUserExitCallback(XnModuleNodeHandle hGenerator, XnModuleUserHandler handler, void* pCookie, XnCallbackHandle* phCallback)
01482 {
01483 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01484 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01485 return pNode->RegisterToUserExit(handler, pCookie, *phCallback);
01486 }
01487 void XN_CALLBACK_TYPE __ModuleUnregisterFromUserExitCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01488 {
01489 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01490 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01491 pNode->UnregisterFromUserExit(hCallback);
01492 }
01493 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToUserReEnterCallback(XnModuleNodeHandle hGenerator, XnModuleUserHandler handler, void* pCookie, XnCallbackHandle* phCallback)
01494 {
01495 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01496 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01497 return pNode->RegisterToUserReEnter(handler, pCookie, *phCallback);
01498 }
01499 void XN_CALLBACK_TYPE __ModuleUnregisterFromUserReEnterCallback(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01500 {
01501 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01502 ModuleUserGenerator* pNode = dynamic_cast<ModuleUserGenerator*>(pProdNode);
01503 pNode->UnregisterFromUserReEnter(hCallback);
01504 }
01505
01506
01507 XnUChar* XN_CALLBACK_TYPE __ModuleGetAudioBuffer(XnModuleNodeHandle hGenerator)
01508 {
01509 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01510 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
01511 return pNode->GetAudioBuffer();
01512 }
01513 XnUInt32 XN_CALLBACK_TYPE __ModuleGetSupportedWaveOutputModesCount(XnModuleNodeHandle hGenerator)
01514 {
01515 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01516 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
01517 return pNode->GetSupportedWaveOutputModesCount();
01518 }
01519 XnStatus XN_CALLBACK_TYPE __ModuleGetSupportedWaveOutputModes(XnModuleNodeHandle hGenerator, XnWaveOutputMode* aSupportedModes, XnUInt32* pnCount)
01520 {
01521 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01522 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
01523 return pNode->GetSupportedWaveOutputModes(aSupportedModes, *pnCount);
01524 }
01525 XnStatus XN_CALLBACK_TYPE __ModuleSetWaveOutputMode(XnModuleNodeHandle hGenerator, const XnWaveOutputMode* pOutputMode)
01526 {
01527 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01528 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
01529 return pNode->SetWaveOutputMode(*pOutputMode);
01530 }
01531 XnStatus XN_CALLBACK_TYPE __ModuleGetWaveOutputMode(XnModuleNodeHandle hGenerator, XnWaveOutputMode* pOutputMode)
01532 {
01533 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01534 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
01535 return pNode->GetWaveOutputMode(*pOutputMode);
01536 }
01537 XnStatus XN_CALLBACK_TYPE __ModuleRegisterToWaveOutputModeChanges(XnModuleNodeHandle hGenerator, XnModuleStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback)
01538 {
01539 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01540 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
01541 return pNode->RegisterToWaveOutputModeChanges(handler, pCookie, *phCallback);
01542 }
01543 void XN_CALLBACK_TYPE __ModuleUnregisterFromWaveOutputModeChanges(XnModuleNodeHandle hGenerator, XnCallbackHandle hCallback)
01544 {
01545 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hGenerator;
01546 ModuleAudioGenerator* pNode = dynamic_cast<ModuleAudioGenerator*>(pProdNode);
01547 pNode->UnregisterFromWaveOutputModeChanges(hCallback);
01548 }
01549
01550 XnCodecID XN_CALLBACK_TYPE __ModuleGetCodecID(XnModuleNodeHandle hCodec)
01551 {
01552 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
01553 ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
01554 return pCodec->GetCodecID();
01555 }
01556 XnStatus XN_CALLBACK_TYPE __ModuleCodecInit(XnModuleNodeHandle hCodec, XnNodeHandle hNode)
01557 {
01558 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
01559 ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
01560 return pCodec->Init(ProductionNode(hNode));
01561 }
01562 XnStatus XN_CALLBACK_TYPE __ModuleCompressData(XnModuleNodeHandle hCodec, const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten)
01563 {
01564 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
01565 ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
01566 return pCodec->CompressData(pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
01567 }
01568 XnStatus XN_CALLBACK_TYPE __ModuleDecompressData(XnModuleNodeHandle hCodec, const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten)
01569 {
01570 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hCodec;
01571 ModuleCodec* pCodec = dynamic_cast<ModuleCodec*>(pProdNode);
01572 return pCodec->DecompressData(pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
01573 }
01574
01575 const XnChar* XN_CALLBACK_TYPE __ModuleScriptGetSupportedFormat(XnModuleNodeHandle hScript)
01576 {
01577 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hScript;
01578 ModuleScriptNode* pScript = dynamic_cast<ModuleScriptNode*>(pProdNode);
01579 return pScript->GetSupportedFormat();
01580 }
01581
01582 XnStatus XN_CALLBACK_TYPE __ModuleLoadScriptFromFile(XnModuleNodeHandle hScript, const XnChar* strFileName)
01583 {
01584 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hScript;
01585 ModuleScriptNode* pScript = dynamic_cast<ModuleScriptNode*>(pProdNode);
01586 return pScript->LoadScriptFromFile(strFileName);
01587 }
01588
01589 XnStatus XN_CALLBACK_TYPE __ModuleLoadScriptFromString(XnModuleNodeHandle hScript, const XnChar* strScript)
01590 {
01591 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hScript;
01592 ModuleScriptNode* pScript = dynamic_cast<ModuleScriptNode*>(pProdNode);
01593 return pScript->LoadScriptFromString(strScript);
01594 }
01595
01596 XnStatus XN_CALLBACK_TYPE __ModuleScriptRun(XnModuleNodeHandle hScript, XnNodeInfoList* pCreatedNodes, XnEnumerationErrors* pErrors)
01597 {
01598 ModuleProductionNode* pProdNode = (ModuleProductionNode*)hScript;
01599 ModuleScriptNode* pScript = dynamic_cast<ModuleScriptNode*>(pProdNode);
01600 NodeInfoList createdNodes(pCreatedNodes);
01601 EnumerationErrors errors(pErrors);
01602 return pScript->Run(createdNodes, errors);
01603 }
01604
01605 void XN_CALLBACK_TYPE __ModuleGetExtendedSerializationInterface(XnModuleExtendedSerializationInterface* pInterface)
01606 {
01607 pInterface->InitNotifications = __ModuleInitNotifications;
01608 pInterface->StopNotifications = __ModuleStopNotifications;
01609 }
01610
01611 void XN_CALLBACK_TYPE __ModuleGetLockAwareInterface(XnModuleLockAwareInterface* pInterface)
01612 {
01613 pInterface->SetLockState = __ModuleSetLockState;
01614 pInterface->GetLockState = __ModuleGetLockState;
01615 pInterface->RegisterToLockChange = __ModuleRegisterToLockChange;
01616 pInterface->UnregisterFromLockChange = __ModuleUnregisterFromLockChange;
01617 }
01618
01619 void XN_CALLBACK_TYPE __ModuleGetErrorStateInterface(XnModuleErrorStateInterface* pInterface)
01620 {
01621 pInterface->GetErrorState = __ModuleGetErrorState;
01622 pInterface->RegisterToErrorStateChange = __ModuleRegisterToErrorStateChange;
01623 pInterface->UnregisterFromErrorStateChange = __ModuleUnregisterFromErrorStateChange;
01624 }
01625
01626 void XN_CALLBACK_TYPE __ModuleGetGeneralIntInterface(XnModuleGeneralIntInterface* pInterface)
01627 {
01628 pInterface->GetRange = __ModuleGeneralIntGetRange;
01629 pInterface->Get = __ModuleGeneralIntGet;
01630 pInterface->Set = __ModuleGeneralIntSet;
01631 pInterface->RegisterToValueChange = __ModuleGeneralIntRegisterToValueChange;
01632 pInterface->UnregisterFromValueChange = __ModuleGeneralIntUnregisterFromValueChange;
01633 }
01634
01635 void XN_CALLBACK_TYPE __ModuleGetProductionNodeInterface(XnModuleProductionNodeInterface* pInterface)
01636 {
01637 pInterface->IsCapabilitySupported = __ModuleIsCapabilitySupported;
01638 pInterface->SetIntProperty = __ModuleSetIntProperty;
01639 pInterface->SetRealProperty = __ModuleSetRealProperty;
01640 pInterface->SetStringProperty = __ModuleSetStringProperty;
01641 pInterface->SetGeneralProperty = __ModuleSetGeneralProperty;
01642 pInterface->GetIntProperty = __ModuleGetIntProperty;
01643 pInterface->GetRealProperty = __ModuleGetRealProperty;
01644 pInterface->GetStringProperty = __ModuleGetStringProperty;
01645 pInterface->GetGeneralProperty = __ModuleGetGeneralProperty;
01646
01647 __ModuleGetExtendedSerializationInterface(pInterface->pExtendedSerializationInterface);
01648 __ModuleGetLockAwareInterface(pInterface->pLockAwareInterface);
01649 __ModuleGetErrorStateInterface(pInterface->pErrorStateInterface);
01650 __ModuleGetGeneralIntInterface(pInterface->pGeneralIntInterface);
01651 }
01652
01653 void XN_CALLBACK_TYPE __ModuleGetDeviceIdentificationInterface(XnModuleDeviceIdentificationInterface* pInterface)
01654 {
01655 pInterface->GetDeviceName = __ModuleGetDeviceName;
01656 pInterface->GetVendorSpecificData = __ModuleGetVendorSpecificData;
01657 pInterface->GetSerialNumber = __ModuleGetSerialNumber;
01658 }
01659
01660 void XN_CALLBACK_TYPE __ModuleGetDeviceInterface(XnModuleDeviceInterface* pInterface)
01661 {
01662 __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
01663 __ModuleGetDeviceIdentificationInterface(pInterface->pDeviceIdentificationInterface);
01664 }
01665
01666 void XN_CALLBACK_TYPE __ModuleGetMirrorInterface(XnModuleMirrorInterface* pInterface)
01667 {
01668 pInterface->SetMirror = __ModuleSetMirror;
01669 pInterface->IsMirrored = __ModuleIsMirrored;
01670 pInterface->RegisterToMirrorChange = __ModuleRegisterToMirrorChange;
01671 pInterface->UnregisterFromMirrorChange = __ModuleUnregisterFromMirrorChange;
01672 }
01673
01674 void XN_CALLBACK_TYPE __ModuleGetAlternativeViewPointInterface(XnModuleAlternativeViewPointInterface* pInterface)
01675 {
01676 pInterface->IsViewPointSupported = __ModuleIsViewPointSupported;
01677 pInterface->SetViewPoint = __ModuleSetViewPoint;
01678 pInterface->ResetViewPoint = __ModuleResetViewPoint;
01679 pInterface->IsViewPointAs = __ModuleIsViewPointAs;
01680 pInterface->RegisterToViewPointChange = __ModuleRegisterToViewPointChange;
01681 pInterface->UnregisterFromViewPointChange = __ModuleUnregisterFromViewPointChange;
01682 }
01683
01684 void XN_CALLBACK_TYPE __ModuleGetFrameSyncInterface(XnModuleFrameSyncInterface* pInterface)
01685 {
01686 pInterface->CanFrameSyncWith = __ModuleCanFrameSyncWith;
01687 pInterface->FrameSyncWith = __ModuleFrameSyncWith;
01688 pInterface->StopFrameSyncWith = __ModuleStopFrameSyncWith;
01689 pInterface->IsFrameSyncedWith = __ModuleIsFrameSyncedWith;
01690 pInterface->RegisterToFrameSyncChange = __ModuleRegisterToFrameSyncChange;
01691 pInterface->UnregisterFromFrameSyncChange = __ModuleUnregisterFromFrameSyncChange;
01692 }
01693
01694 void XN_CALLBACK_TYPE __ModuleGetGeneratorInterface(XnModuleGeneratorInterface* pInterface)
01695 {
01696 __ModuleGetProductionNodeInterface(pInterface->pProductionNodeInterface);
01697 pInterface->StartGenerating = __ModuleStartGenerating;
01698 pInterface->IsGenerating = __ModuleIsGenerating;
01699 pInterface->StopGenerating = __ModuleStopGenerating;
01700 pInterface->RegisterToGenerationRunningChange = __ModuleRegisterToGenerationRunningChange;
01701 pInterface->UnregisterFromGenerationRunningChange = __ModuleUnregisterFromGenerationRunningChange;
01702 pInterface->RegisterToNewDataAvailable = __ModuleRegisterToNewDataAvailable;
01703 pInterface->UnregisterFromNewDataAvailable = __ModuleUnregisterFromNewDataAvailable;
01704 pInterface->IsNewDataAvailable = __ModuleIsNewDataAvailable;
01705 pInterface->UpdateData = __ModuleUpdateData;
01706 pInterface->GetData = __ModuleGetData;
01707 pInterface->GetDataSize = __ModuleGetDataSize;
01708 pInterface->GetTimestamp = __ModuleGetTimestamp;
01709 pInterface->GetFrameID = __ModuleGetFrameID;
01710 __ModuleGetMirrorInterface(pInterface->pMirrorInterface);
01711 __ModuleGetAlternativeViewPointInterface(pInterface->pAlternativeViewPointInterface);
01712 __ModuleGetFrameSyncInterface(pInterface->pFrameSyncInterface);
01713 }
01714
01715 void XN_CALLBACK_TYPE __ModuleGetNodeNotificationsInterface(XnNodeNotifications *pInterface)
01716 {
01717 pInterface->OnNodeAdded = __ModuleOnNodeAdded;
01718 pInterface->OnNodeRemoved = __ModuleOnNodeRemoved;
01719 pInterface->OnNodeIntPropChanged = __ModuleOnNodeIntPropChanged;
01720 pInterface->OnNodeRealPropChanged = __ModuleOnNodeRealPropChanged;
01721 pInterface->OnNodeStringPropChanged = __ModuleOnNodeStringPropChanged;
01722 pInterface->OnNodeGeneralPropChanged = __ModuleOnNodeGeneralPropChanged;
01723 pInterface->OnNodeStateReady = __ModuleOnNodeStateReady;
01724 pInterface->OnNodeNewData = __ModuleOnNodeNewData;
01725 }
01726
01727 void XN_CALLBACK_TYPE __ModuleGetRecorderInterface(XnModuleRecorderInterface* pInterface)
01728 {
01729 pInterface->SetOutputStream = __ModuleSetOutputStream;
01730 __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
01731 __ModuleGetNodeNotificationsInterface(pInterface->pNodeNotifications);
01732 }
01733
01734 void XN_CALLBACK_TYPE __ModuleGetPlayerInterface(XnModulePlayerInterface* pInterface)
01735 {
01736 __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
01737 pInterface->SetInputStream = __ModuleSetInputStream;
01738 pInterface->ReadNext = __ModuleReadNext;
01739 pInterface->SetNodeNotifications = __ModuleSetNodeNotifications;
01740 pInterface->SetRepeat = __ModuleSetRepeat;
01741 pInterface->SeekToTimeStamp = __ModuleSeekToTimeStamp;
01742 pInterface->SeekToFrame = __ModuleSeekToFrame;
01743 pInterface->TellTimestamp = __ModuleTellTimestamp;
01744 pInterface->TellFrame = __ModuleTellFrame;
01745 pInterface->GetNumFrames = __ModuleGetNumFrames;
01746 pInterface->GetSupportedFormat = __ModuleGetSupportedFormat;
01747 pInterface->IsEOF = __ModuleIsEOF;
01748 pInterface->RegisterToEndOfFileReached = __ModuleRegisterToEndOfFileReached;
01749 pInterface->UnregisterFromEndOfFileReached = __ModuleUnregisterFromEndOfFileReached;
01750 }
01751
01752 void XN_CALLBACK_TYPE __ModuleGetCroppingInterface(XnModuleCroppingInterface* pInterface)
01753 {
01754 pInterface->SetCropping = __ModuleSetCropping;
01755 pInterface->GetCropping = __ModuleGetCropping;
01756 pInterface->RegisterToCroppingChange = __ModuleRegisterToCroppingChange;
01757 pInterface->UnregisterFromCroppingChange = __ModuleUnregisterFromCroppingChange;
01758 }
01759
01760 void XN_CALLBACK_TYPE __ModuleGetAntiFlickerInterface(XnModuleAntiFlickerInterface* pInterface)
01761 {
01762 pInterface->SetPowerLineFrequency = __ModuleSetPowerLineFrequency;
01763 pInterface->GetPowerLineFrequency = __ModuleGetPowerLineFrequency;
01764 pInterface->RegisterToPowerLineFrequencyChange = __ModuleRegisterToPowerLineFrequencyChange;
01765 pInterface->UnregisterFromPowerLineFrequencyChange = __ModuleUnregisterFromPowerLineFrequencyChange;
01766 }
01767
01768 void XN_CALLBACK_TYPE __ModuleGetMapGeneratorInterface(XnModuleMapGeneratorInterface* pInterface)
01769 {
01770 __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
01771 pInterface->GetSupportedMapOutputModesCount = __ModuleGetSupportedMapOutputModesCount;
01772 pInterface->GetSupportedMapOutputModes = __ModuleGetSupportedMapOutputModes;
01773 pInterface->SetMapOutputMode = __ModuleSetMapOutputMode;
01774 pInterface->GetMapOutputMode = __ModuleGetMapOutputMode;
01775 pInterface->RegisterToMapOutputModeChange = __ModuleRegisterToMapOutputModeChange;
01776 pInterface->UnregisterFromMapOutputModeChange = __ModuleUnregisterFromMapOutputModeChange;
01777 pInterface->GetBytesPerPixel = __ModuleGetBytesPerPixel;
01778 __ModuleGetCroppingInterface(pInterface->pCroppingInterface);
01779 __ModuleGetAntiFlickerInterface(pInterface->pAntiFlickerInterface);
01780 }
01781
01782 void XN_CALLBACK_TYPE __ModuleGetUserPositionInterface(XnModuleUserPositionCapabilityInterface* pInterface)
01783 {
01784 pInterface->GetSupportedUserPositionsCount = __ModuleGetSupportedUserPositionsCount;
01785 pInterface->SetUserPosition = __ModuleSetUserPosition;
01786 pInterface->GetUserPosition = __ModuleGetUserPosition;
01787 pInterface->RegisterToUserPositionChange = __ModuleRegisterToUserPositionChange;
01788 pInterface->UnregisterFromUserPositionChange = __ModuleUnregisterFromUserPositionChange;
01789 }
01790
01791 void XN_CALLBACK_TYPE __ModuleGetDepthGeneratorInterface(XnModuleDepthGeneratorInterface* pInterface)
01792 {
01793 __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
01794 pInterface->GetDeviceMaxDepth = __ModuleGetDeviceMaxDepth;
01795 pInterface->GetFieldOfView = __ModuleGetFieldOfView;
01796 pInterface->RegisterToFieldOfViewChange = __ModuleRegisterToFieldOfViewChange;
01797 pInterface->UnregisterFromFieldOfViewChange = __ModuleUnregisterFromFieldOfViewChange;
01798 pInterface->GetDepthMap = __ModuleGetDepthMap;
01799 __ModuleGetUserPositionInterface(pInterface->pUserPositionInterface);
01800 }
01801
01802 void XN_CALLBACK_TYPE __ModuleGetImageGeneratorInterface(XnModuleImageGeneratorInterface* pInterface)
01803 {
01804 __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
01805 pInterface->GetImageMap = __ModuleGetImageMap;
01806 pInterface->IsPixelFormatSupported = __ModuleIsPixelFormatSupported;
01807 pInterface->SetPixelFormat = __ModuleSetPixelFormat;
01808 pInterface->GetPixelFormat = __ModuleGetPixelFormat;
01809 pInterface->RegisterToPixelFormatChange = __ModuleRegisterToPixelFormatChange;
01810 pInterface->UnregisterFromPixelFormatChange = __ModuleUnregisterFromPixelFormatChange;
01811 }
01812
01813 void XN_CALLBACK_TYPE __ModuleGetIRGeneratorInterface(XnModuleIRGeneratorInterface* pInterface)
01814 {
01815 __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
01816 pInterface->GetIRMap = __ModuleGetIRMap;
01817 }
01818
01819 void XN_CALLBACK_TYPE __ModuleGetGestureGeneratorInterface(XnModuleGestureGeneratorInterface* pInterface)
01820 {
01821 __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
01822 pInterface->AddGesture = __ModuleAddGesture;
01823 pInterface->RemoveGesture = __ModuleRemoveGesture;
01824 pInterface->GetActiveGestures = __ModuleGetActiveGestures;
01825 pInterface->GetAllActiveGestures = __ModuleGetAllActiveGestures;
01826 pInterface->EnumerateGestures = __ModuleEnumerateGestures;
01827 pInterface->EnumerateAllGestures = __ModuleEnumerateAllGestures;
01828 pInterface->IsGestureAvailable = __ModuleIsGestureAvailable;
01829 pInterface->IsGestureProgressSupported = __ModuleIsGestureProgressSupported;
01830 pInterface->RegisterGestureCallbacks = __ModuleRegisterGestureCallbacks;
01831 pInterface->UnregisterGestureCallbacks = __ModuleUnregisterGestureCallbacks;
01832 pInterface->RegisterToGestureChange = __ModuleRegisterToGestureChange;
01833 pInterface->UnregisterFromGestureChange = __ModuleUnregisterFromGestureChange;
01834
01835 pInterface->RegisterToGestureIntermediateStageCompleted = __ModuleRegisterToGestureIntermediateStageCompleted;
01836 pInterface->UnregisterFromGestureIntermediateStageCompleted = __ModuleUnregisterFromGestureIntermediateStageCompleted;
01837 pInterface->RegisterToGestureReadyForNextIntermediateStage = __ModuleRegisterToGestureReadyForNextIntermediateStage;
01838 pInterface->UnregisterFromGestureReadyForNextIntermediateStage = __ModuleUnregisterFromGestureReadyForNextIntermediateStage;
01839 }
01840
01841 void XN_CALLBACK_TYPE __ModuleGetSceneAnalyzerInterface(XnModuleSceneAnalyzerInterface* pInterface)
01842 {
01843 __ModuleGetMapGeneratorInterface(pInterface->pMapInterface);
01844 pInterface->GetLabelMap = __ModuleGetLabelMap;
01845 pInterface->GetFloor = __ModuleGetFloor;
01846 }
01847
01848 void XN_CALLBACK_TYPE __ModuleGetSkeletonInterface(XnModuleSkeletonCapabilityInterface* pInterface)
01849 {
01850 pInterface->IsJointAvailable = __ModuleIsJointAvailable;
01851 pInterface->IsProfileAvailable = __ModuleIsProfileAvailable;
01852 pInterface->SetSkeletonProfile = __ModuleSetSkeletonProfile;
01853 pInterface->SetJointActive = __ModuleSetJointActive;
01854 pInterface->IsJointActive = __ModuleIsJointActive;
01855 pInterface->RegisterToJointConfigurationChange = __ModuleRegisterToJointConfigurationChange;
01856 pInterface->UnregisterFromJointConfigurationChange = __ModuleUnregisterFromJointConfigurationChange;
01857 pInterface->EnumerateActiveJoints = __ModuleEnumerateActiveJoints;
01858 pInterface->GetSkeletonJoint = __ModuleGetSkeletonJoint;
01859 pInterface->GetSkeletonJointPosition = __ModuleGetSkeletonJointPosition;
01860 pInterface->GetSkeletonJointOrientation = __ModuleGetSkeletonJointOrientation;
01861 pInterface->IsTracking = __ModuleIsSkeletonTracking;
01862 pInterface->IsCalibrated = __ModuleIsSkeletonCalibrated;
01863 pInterface->IsCalibrating = __ModuleIsSkeletonCalibrating;
01864 pInterface->RequestCalibration = __ModuleRequestSkeletonCalibration;
01865 pInterface->AbortCalibration = __ModuleAbortSkeletonCalibration;
01866 pInterface->SaveCalibrationDataToFile = __ModuleSaveCalibrationDataToFile;
01867 pInterface->LoadCalibrationDataFromFile = __ModuleLoadCalibrationDataFromFile;
01868 pInterface->SaveCalibrationData = __ModuleSaveCalibrationData;
01869 pInterface->LoadCalibrationData = __ModuleLoadCalibrationData;
01870 pInterface->ClearCalibrationData = __ModuleClearCalibrationData;
01871 pInterface->IsCalibrationData = __ModuleIsCalibrationData;
01872 pInterface->StartTracking = __ModuleStartSkeletonTracking;
01873 pInterface->StopTracking = __ModuleStopSkeletonTracking;
01874 pInterface->Reset = __ModuleResetSkeleton;
01875 pInterface->NeedPoseForCalibration = __ModuleNeedPoseForSkeletonCalibration;
01876 pInterface->GetCalibrationPose = __ModuleGetSkeletonCalibrationPose;
01877 pInterface->SetSmoothing = __ModuleSetSkeletonSmoothing;
01878 pInterface->RegisterCalibrationCallbacks = __ModuleRegisterCalibrationCallbacks;
01879 pInterface->UnregisterCalibrationCallbacks = __ModuleUnregisterCalibrationCallbacks;
01880
01881 pInterface->RegisterToCalibrationInProgress = __ModuleRegisterToCalibrationInProgressCallback;
01882 pInterface->UnregisterFromCalibrationInProgress = __ModuleUnregisterFromCalibrationInProgressCallback;
01883 pInterface->RegisterToCalibrationComplete = __ModuleRegisterToCalibrationCompleteCallback;
01884 pInterface->UnregisterFromCalibrationComplete = __ModuleUnregisterFromCalibrationCompleteCallback;
01885
01886 pInterface->RegisterToCalibrationStart = __ModuleRegisterToCalibrationStartCallback;
01887 pInterface->UnregisterFromCalibrationStart = __ModuleUnregisterFromCalibrationStartCallback;
01888 }
01889
01890 void XN_CALLBACK_TYPE __ModuleGetPoseDetectionInterface(XnModulePoseDetectionCapabilityInterface* pInteface)
01891 {
01892 pInteface->GetNumberOfPoses = __ModuleGetNumberOfPoses;
01893 pInteface->GetAvailablePoses = __ModuleGetAvailablePoses;
01894 pInteface->GetAllAvailablePoses = __ModuleGetAllAvailablePoses;
01895 pInteface->StartPoseDetection = __ModuleStartPoseDetection;
01896 pInteface->StopPoseDetection = __ModuleStopPoseDetection;
01897 pInteface->RegisterToPoseCallbacks = __ModuleRegisterToPoseCallbacks;
01898 pInteface->UnregisterFromPoseCallbacks = __ModuleUnregisterFromPoseCallbacks;
01899
01900 pInteface->RegisterToPoseDetectionInProgress = __ModuleRegisterToPoseInProgressCallback;
01901 pInteface->UnregisterFromPoseDetectionInProgress = __ModuleUnregisterFromPoseInProgressCallback;
01902
01903 pInteface->RegisterToPoseDetected = __ModuleRegisterToPoseDetected;
01904 pInteface->UnregisterFromPoseDetected = __ModuleUnregisterFromPoseDetected;
01905 pInteface->RegisterToOutOfPose = __ModuleRegisterToOutOfPose;
01906 pInteface->UnregisterFromOutOfPose = __ModuleUnregisterFromOutOfPose;
01907 }
01908
01909 void XN_CALLBACK_TYPE __ModuleGetUserGeneratorInterface(XnModuleUserGeneratorInterface* pInterface)
01910 {
01911 __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
01912
01913 pInterface->GetNumberOfUsers = __ModuleGetNumberOfUsers;
01914 pInterface->GetUsers = __ModuleGetUsers;
01915 pInterface->GetCoM = __ModuleGetUserCoM;
01916 pInterface->GetUserPixels = __ModuleGetUserPixels;
01917 pInterface->RegisterUserCallbacks = __ModuleRegisterUserCallbacks;
01918 pInterface->UnregisterUserCallbacks = __ModuleUnregisterUserCallbacks;
01919
01920 __ModuleGetSkeletonInterface(pInterface->pSkeletonInterface);
01921 __ModuleGetPoseDetectionInterface(pInterface->pPoseDetectionInterface);
01922
01923 pInterface->RegisterToUserExit = __ModuleRegisterToUserExitCallback;
01924 pInterface->UnregisterFromUserExit = __ModuleUnregisterFromUserExitCallback;
01925 pInterface->RegisterToUserReEnter = __ModuleRegisterToUserReEnterCallback;
01926 pInterface->UnregisterFromUserReEnter = __ModuleUnregisterFromUserReEnterCallback;
01927 }
01928
01929 void XN_CALLBACK_TYPE __ModuleGetHandTouchingFOVEdgeInterface(XnModuleHandTouchingFOVEdgeCapabilityInterface* pInterface)
01930 {
01931 pInterface->RegisterToHandTouchingFOVEdge = __ModuleRegisterToHandTouchingFOVEdgeCallback;
01932 pInterface->UnregisterFromHandTouchingFOVEdge = __ModuleUnregisterFromHandTouchingFOVEdgeCallback;
01933 }
01934 void XN_CALLBACK_TYPE __ModuleGetHandsGeneratorInterface(XnModuleHandsGeneratorInterface* pInterface)
01935 {
01936 __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
01937
01938 pInterface->StartTracking = __ModuleStartTracking;
01939 pInterface->StopTracking = __ModuleStopTracking;
01940 pInterface->StopTrackingAll = __ModuleStopTrackingAll;
01941 pInterface->RegisterHandCallbacks = __ModuleRegisterHandCallbacks;
01942 pInterface->UnregisterHandCallbacks = __ModuleUnregisterHandCallbacks;
01943 pInterface->SetSmoothing = __ModuleSetTrackingSmoothing;
01944
01945 __ModuleGetHandTouchingFOVEdgeInterface(pInterface->pHandTouchingFOVEdgeInterface);
01946 }
01947
01948 void XN_CALLBACK_TYPE __ModuleGetAudioGeneratorInterface(XnModuleAudioGeneratorInterface* pInterface)
01949 {
01950 __ModuleGetGeneratorInterface(pInterface->pGeneratorInterface);
01951
01952 pInterface->GetAudioBuffer = __ModuleGetAudioBuffer;
01953 pInterface->GetSupportedWaveOutputModesCount = __ModuleGetSupportedWaveOutputModesCount;
01954 pInterface->GetSupportedWaveOutputModes = __ModuleGetSupportedWaveOutputModes;
01955 pInterface->SetWaveOutputMode = __ModuleSetWaveOutputMode;
01956 pInterface->GetWaveOutputMode = __ModuleGetWaveOutputMode;
01957 pInterface->RegisterToWaveOutputModeChanges = __ModuleRegisterToWaveOutputModeChanges;
01958 pInterface->UnregisterFromWaveOutputModeChanges = __ModuleUnregisterFromWaveOutputModeChanges;
01959 }
01960
01961 void XN_CALLBACK_TYPE __ModuleGetCodecInterface(XnModuleCodecInterface* pInterface)
01962 {
01963 __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
01964
01965 pInterface->GetCodecID = __ModuleGetCodecID;
01966 pInterface->Init = __ModuleCodecInit;
01967 pInterface->CompressData = __ModuleCompressData;
01968 pInterface->DecompressData = __ModuleDecompressData;
01969 }
01970
01971 void XN_CALLBACK_TYPE __ModuleGetScriptNodeInterface(XnModuleScriptNodeInterface* pInterface)
01972 {
01973 __ModuleGetProductionNodeInterface(pInterface->pProductionNode);
01974
01975 pInterface->GetSupportedFormat = __ModuleScriptGetSupportedFormat;
01976 pInterface->LoadScriptFromFile = __ModuleLoadScriptFromFile;
01977 pInterface->LoadScriptFromString = __ModuleLoadScriptFromString;
01978 pInterface->Run = __ModuleScriptRun;
01979 }
01980
01981 #endif