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