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