OpenNI 1.3.2
|
00001 /**************************************************************************** 00002 * * 00003 * OpenNI 1.1 Alpha * 00004 * Copyright (C) 2011 PrimeSense Ltd. * 00005 * * 00006 * This file is part of OpenNI. * 00007 * * 00008 * OpenNI is free software: you can redistribute it and/or modify * 00009 * it under the terms of the GNU Lesser General Public License as published * 00010 * by the Free Software Foundation, either version 3 of the License, or * 00011 * (at your option) any later version. * 00012 * * 00013 * OpenNI is distributed in the hope that it will be useful, * 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 00016 * GNU Lesser General Public License for more details. * 00017 * * 00018 * You should have received a copy of the GNU Lesser General Public License * 00019 * along with OpenNI. If not, see <http://www.gnu.org/licenses/>. * 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 /* XN_MODULE_C_FUNCTIONS_H_ */