• Main Page
  • Modules
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

XnModuleCFunctions.h

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

Generated on Sat Nov 10 2012 07:13:52 for OpenNI 1.3.2 by  doxygen 1.7.1