/** * Callback when display is added to display manager. * @pre Must be in kernel controlling thread. * @note This function can only be called by the display manager * functioning on behalf of a thread the holds the kernel * reconfiguration lock. * This guarantees that we are not rendering currently. * We will most likely be waiting for a render trigger. */ void D3dDrawManager::addDisplay(DisplayPtr disp) { vprASSERT(disp != NULL); // Can't add a null display vprDEBUG(vrjDBG_DRAW_MGR, 0) << "========= vrj::D3dDrawManager::addDisplay: " << disp << std::endl << vprDEBUG_FLUSH; // -- Finish Simulator setup std::vector<vrj::Viewport*>::size_type num_vp(disp->getNumViewports()); std::vector<vrj::Viewport*>::size_type i; for ( i = 0 ; i < num_vp ; ++i ) { Viewport* vp = disp->getViewport(i); if (vp->isSimulator()) { jccl::ConfigElementPtr vp_element = vp->getConfigElement(); SimViewport* sim_vp(NULL); sim_vp = dynamic_cast<SimViewport*>(vp); vprASSERT(NULL != sim_vp); sim_vp->setDrawSimInterface(DrawSimInterfacePtr()); // Create the simulator stuff vprASSERT(1 == vp_element->getNum("simulator_plugin") && "You must supply a simulator plugin."); // Create the simulator stuff jccl::ConfigElementPtr sim_element = vp_element->getProperty<jccl::ConfigElementPtr>("simulator_plugin"); vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CONFIG_LVL) << "D3dDrawManager::addDisplay() creating simulator of type '" << sim_element->getID() << "'\n" << vprDEBUG_FLUSH; DrawSimInterfacePtr new_sim_i( D3dSimInterfaceFactory::instance()->createObject(sim_element->getID()) ); // XXX: Change this to an error once the new simulator loading code is // more robust. -PH (4/13/2003) vprASSERT(NULL != new_sim_i.get() && "Failed to create draw simulator"); sim_vp->setDrawSimInterface(new_sim_i); new_sim_i->initialize(sim_vp); new_sim_i->config(sim_element); } } // -- Create a window for new display // -- Store the window in the wins vector // Create the gl window object. NOTE: The glPipe actually "creates" the opengl window and context later D3dWindow* new_win = new D3dWindow(); new_win->configWindow(disp); // Configure it mNewWins.push_back(new_win); // Add to our local window list //vprASSERT(isValidWindow(new_win)); // Make sure it was added to draw manager }
/** * Updates to the sampled data. * * @pre None. * @post Most recent value is copied over to temp area. */ void TrackdController::updateData() { vprASSERT(mTrackdController != NULL && "Make sure that trackd controller has been initialized"); vprASSERT((unsigned)mTrackdController->numButtons() <= mCurButtons.size()); vprASSERT((unsigned)mTrackdController->numValuators() <= mCurValuators.size() ); for (int i=0;i<mTrackdController->numButtons();i++) { mCurButtons[i] = static_cast<DigitalState::State>(mTrackdController->getButton(i)); mCurButtons[i].setTime(); } for (int j=0;j<mTrackdController->numValuators();j++) { mCurValuators[j] = mTrackdController->getValuator(j); mCurValuators[j].setTime(); } addDigitalSample(mCurButtons); swapDigitalBuffers(); addAnalogSample(mCurValuators); swapAnalogBuffers(); }
bool FastrakStandalone::getStationStatus(const vpr::Uint16 station) { vprASSERT(station >= 1 && station <= 4 && "Station index must between 1-4"); std::string data = boost::lexical_cast<std::string>(station) + "\r"; sendCommand(Fastrak::Command::StationStatus, data); std::vector<vpr::Uint8> data_record; try { mSerialPort->read(data_record, 9, mReadTimeout); } catch (vpr::IOException&) { throw vpr::Exception("Failed to get station status.", VPR_LOCATION); } vprASSERT('2' == data_record[0]); vprASSERT('l' == data_record[2]); mStationStatus.resize(4, false); mStationStatus[0] = boost::lexical_cast<bool>(data_record[3]); mStationStatus[1] = boost::lexical_cast<bool>(data_record[4]); mStationStatus[2] = boost::lexical_cast<bool>(data_record[5]); mStationStatus[3] = boost::lexical_cast<bool>(data_record[6]); // Save the number of active stations. mNumActiveStations = std::count(mStationStatus.begin(), mStationStatus.end(), true); // Fastrak uses 1-4 indexes, but in memory we store as 0-3. return mStationStatus[station-1]; }
void ThreadPosix::setFunctor(const vpr::thread_func_t& functor) { vprASSERT(! mRunning && "Thread already running."); vprASSERT(! functor.empty() && "Invalid functor."); mUserThreadFunctor = functor; }
bool User::config(jccl::ConfigElementPtr element) { vprASSERT(element.get() != NULL); vprASSERT(element->getID() == "user"); vprDEBUG_BEGIN(vrjDBG_KERNEL, vprDBG_STATE_LVL) << "vjUser::config: Creating a new user\n" << vprDEBUG_FLUSH; // Assign user id mUserId = mNextUserId++; // Setup user name mName = element->getName(); // Initialize the head stuff std::string head_alias = element->getProperty<std::string>("head_position"); mHead.init(head_alias); // Initialize interocular distance mInterocularDist = element->getProperty<float>("interocular_distance"); if(mInterocularDist == 0.0f) { vprDEBUG(vrjDBG_KERNEL,vprDBG_CONFIG_LVL) << clrOutNORM(clrRED, "WARNING:") << "User: "******" has interocular distance is set to 0.0f. This is probably not what you wanted.\n" << vprDEBUG_FLUSH; } vprDEBUG(vrjDBG_KERNEL,vprDBG_STATE_LVL) << "id: " << mUserId << " Name:" << mName.c_str() << " head_positon:" << head_alias.c_str() << " interocular_distance:" << mInterocularDist << std::endl << vprDEBUG_FLUSH; return true; }
void ThreadSGI::setFunctor(const vpr::thread_func_t& functor) { vprASSERT(! mRunning && "Thread already running"); vprASSERT(! functor.empty()); mUserThreadFunctor = functor; }
/** * Updates to the sampled data. * * @pre None. * @post Most recent value is copied over to temp area. */ void TrackdController::updateData() { vprASSERT(mTrackdController != NULL && "Make sure that trackd controller has been initialized"); vprASSERT((unsigned)mTrackdController->numButtons() <= mCurButtons.size()); vprASSERT((unsigned)mTrackdController->numValuators() <= mCurValuators.size() ); for (int i=0;i<mTrackdController->numButtons();i++) { mCurButtons[i] = mTrackdController->getButton(i); mCurButtons[i].setTime(); } for (int j=0;j<mTrackdController->numValuators();j++) { // TrackdController doesn't have a sample, so we do // normalization here... float f; this->normalizeMinToMax (mTrackdController->getValuator(j), f); mCurValuators[j] = f; mCurValuators[j].setTime(); } addDigitalSample(mCurButtons); swapDigitalBuffers(); addAnalogSample(mCurValuators); swapAnalogBuffers(); }
/** * Closes the given display. * * @pre disp is a display we know about. * @post disp has been removed from the list of displays * (notifyDrawMgr == true) && (drawMgr != NULL) && (disp is active) * ==> Draw manager has been told to clode the window for the display */ int DisplayManager::closeDisplay(DisplayPtr disp, bool notifyDrawMgr) { vprASSERT(isMemberDisplay(disp)); // Make sure that display actually exists vprDEBUG(vrjDBG_DISP_MGR, vprDBG_STATE_LVL) << "[vrj::DisplayManager::closeDisplay()] Closing display named '" << disp->getName() << "'" << std::endl << vprDEBUG_FLUSH; // Notify the draw manager to get rid of it // Note: if it is not active, then the draw manager doesn't know about it if ((notifyDrawMgr) && (mDrawManager != NULL) && (disp->isActive())) { mDrawManager->removeDisplay(disp); } // Remove it from local data structures size_t num_before_close = mActiveDisplays.size() + mInactiveDisplays.size(); mActiveDisplays.erase( std::remove(mActiveDisplays.begin(), mActiveDisplays.end(), disp), mActiveDisplays.end()); mInactiveDisplays.erase( std::remove(mInactiveDisplays.begin(), mInactiveDisplays.end(), disp), mInactiveDisplays.end()); vprASSERT(num_before_close == (1+mActiveDisplays.size() + mInactiveDisplays.size())); boost::ignore_unused_variable_warning(num_before_close); return 1; }
void Digital::readObject(vpr::ObjectReader* reader) { //std::cout << "[Remote Input Manager] In Digital read" << std::endl; vprASSERT(reader->attribExists("rim.timestamp.delta")); vpr::Uint64 delta = reader->getAttrib<vpr::Uint64>("rim.timestamp.delta"); // ASSERT if this data is really not Digital Data reader->beginTag(Digital::getInputTypeName()); reader->beginAttribute(gadget::tokens::DataTypeAttrib); vpr::Uint16 temp = reader->readUint16(); reader->endAttribute(); // XXX: Should there be error checking for the case when vprASSERT() // is compiled out? -PH 8/21/2003 vprASSERT(temp==MSG_DATA_DIGITAL && "[Remote Input Manager]Not Digital Data"); boost::ignore_unused_variable_warning(temp); std::vector<DigitalData> dataSample; unsigned numDigitalDatas; vpr::Uint32 value; vpr::Uint64 timeStamp; DigitalData temp_digital_data; reader->beginAttribute(gadget::tokens::SampleBufferLenAttrib); unsigned numVectors = reader->readUint16(); reader->endAttribute(); //std::cout << "Stable Digital Buffer Size: " << numVectors << std::endl; mDigitalSamples.lock(); for ( unsigned i=0;i<numVectors;i++ ) { reader->beginTag(gadget::tokens::BufferSampleTag); reader->beginAttribute(gadget::tokens::BufferSampleLenAttrib); numDigitalDatas = reader->readUint16(); reader->endAttribute(); dataSample.clear(); for ( unsigned j=0;j<numDigitalDatas;j++ ) { reader->beginTag(gadget::tokens::DigitalValue); reader->beginAttribute(gadget::tokens::TimeStamp); timeStamp = reader->readUint64(); // read Time Stamp vpr::Uint64 reader->endAttribute(); value = reader->readUint32(); // read Digital Data(int) reader->endTag(); temp_digital_data.setDigital(value); temp_digital_data.setTime(vpr::Interval(timeStamp + delta,vpr::Interval::Usec)); dataSample.push_back(temp_digital_data); } mDigitalSamples.addSample(dataSample); reader->endTag(); } mDigitalSamples.unlock(); mDigitalSamples.swapBuffers(); reader->endTag(); }
void FastrakStandalone::processDataRecord(std::vector<vpr::Uint8>& dataRecord) { unsigned int single_bird_data_size = 28 + 5; // For each station // - Get matrix from data format for(unsigned int i=0; i < mNumActiveStations; ++i) { unsigned int data_offset = (single_bird_data_size*i); vprASSERT(dataRecord[data_offset] == '0'); unsigned int station_index = boost::lexical_cast<unsigned int>(dataRecord[data_offset+1]); //std::cout << "Station: " << station_index << std::endl; vprASSERT(station_index >= 1 && station_index <= 4 && "Invalid station index."); vprASSERT(dataRecord[data_offset+2] == ' '); // Position and orientation offsets into data buffer. unsigned int pos_offset = data_offset + 3; unsigned int ori_offset = data_offset + 3 + 12; gmtl::Vec3f pos; gmtl::Quatf ori; // Get position values. pos[0] = getFloatValue(&dataRecord[pos_offset]); pos[1] = getFloatValue(&dataRecord[pos_offset+4]); pos[2] = getFloatValue(&dataRecord[pos_offset+8]); // Convert translation into meters. if (Fastrak::INCHES == mUnits) { pos *= 0.0254f; } else { pos *= 0.01f; } // Get quaternion for orientation. // NOTE: Fastrak returns quaternions as (W,X,Y,Z) and gmtl // stores them as (X,Y,Z,W) ori[3] = getFloatValue(&dataRecord[ori_offset]); ori[0] = getFloatValue(&dataRecord[ori_offset+4]); ori[1] = getFloatValue(&dataRecord[ori_offset+8]); ori[2] = getFloatValue(&dataRecord[ori_offset+12]); // Create a gmtl::Matrix for easy storage. gmtl::Matrix44f position; gmtl::setRot(position, ori); gmtl::setTrans(position, pos); vprASSERT(4 == mStationData.size()); mStationData[station_index] = position; } }
// Look for items in the active list that don't have their dependencies filled // anymore. // // POST: Any elements in active with dependencies not filled are added to the // the pending list. (A remove and an add are added to the pending). // RETURNS: The number of lost dependencies found. int ConfigManager::scanForLostDependencies() { vprASSERT(0 == mActiveLock.test()); // We can't hold the lock upon entry vpr::DebugOutputGuard og(vprDBG_ALL, vprDBG_CONFIG_LVL, "ConfigManager::scanForLostDependencies()\n", "ConfigManager::scanForLostDependencies() done.\n"); DependencyManager* dep_mgr = DependencyManager::instance(); std::vector<ConfigElementPtr> elements; int num_lost_deps(0); // NOTE: can't hold this lock because the isSatisfied routines make // use of the activeLock as well // NOTE: Make the copy of the elements so that we can iterate without // fear of active changing mActiveLock.acquire(); elements = mActiveConfig.vec(); // Get a copy of the elements mActiveLock.release(); // Now test them for ( unsigned int i=0;i<elements.size();i++ ) { if ( !dep_mgr->isSatisfied(elements[i]) ) // We are not satisfied { vprDEBUG_NEXT(vprDBG_ALL, vprDBG_WARNING_LVL) << elements[i]->getName() << " type: " << elements[i]->getID() << " has lost dependencies.\n" << vprDEBUG_FLUSH; num_lost_deps++; // Keep a count of the number lost deps found // Add the pending removal PendingElement pending; pending.mType = PendingElement::REMOVE; pending.mElement = elements[i]; vprASSERT(1 == mPendingLock.test()); addPending(pending); // Add the pending re-addition // ConfigElementPtr copy_of_element; // Need a copy so that the remove can delete the element // copy_of_element = new ConfigElement(*elements[i]); pending.mType = PendingElement::ADD; pending.mElement = elements[i];//copy_of_element; vprASSERT(1 == mPendingLock.test()); addPending(pending); // Add the add item } } return num_lost_deps; }
void GlWindow::setViewport(float xo, float yo, float xSize, float ySize) { vprASSERT( ((xo+xSize) <= 1.0f) && "X viewport sizes are out of range"); vprASSERT( ((yo+ySize) <= 1.0f) && "Y viewport sizes are out of range"); unsigned ll_x = unsigned(xo * float(mWindowWidth)); unsigned ll_y = unsigned(yo * float(mWindowHeight)); unsigned x_size = unsigned(xSize * float(mWindowWidth)); unsigned y_size = unsigned(ySize * float(mWindowHeight)); glViewport(ll_x, ll_y, x_size, y_size); }
/** * Updates to the sampled data. * * @pre None. * @post Most recent value is copied over to temp area */ void TrackdSensor::updateData() { vprASSERT(mTrackdSensors != NULL && "Make sure that trackd sensors has been initialized"); vprASSERT((unsigned)mTrackdSensors->numSensors() <= mCurSensorValues.size()); for(int i=0;i<mTrackdSensors->numSensors();i++) { mCurSensorValues[i].mPosData = mTrackdSensors->getSensorPos(i); mCurSensorValues[i].setTime(); } // Update the data buffer addPositionSample(mCurSensorValues); swapPositionBuffers(); }
BOOL ExtensionLoaderWGL::wglQueryMaxSwapGroupsNV(HDC hdc, GLuint* maxGroups, GLuint* maxBarriers) { vprASSERT(mWglFuncs->wglQueryMaxSwapGroupsNV != NULL && "Attemped to call unsupported extension."); return mWglFuncs->wglQueryMaxSwapGroupsNV(hdc, maxGroups, maxBarriers); }
/** * Adds the element to the configuration. * * @pre configCanHandle(element) == true * @post (display of same name already loaded) ==> old display closed, new one opened<br> * (display is new) ==> (new display is added)<br> * Draw Manager is notified of the display change. */ bool DisplayManager::configAddDisplay(jccl::ConfigElementPtr element) { vprASSERT(configCanHandle(element)); // We must be able to handle it first of all vprDEBUG_BEGIN(vrjDBG_DISP_MGR,vprDBG_STATE_LVL) << "------- DisplayManager::configAddDisplay -------\n" << vprDEBUG_FLUSH; // Find out if we already have a window of this name // If so, then close it before we open a new one of the same name // This basically allows re-configuration of a window DisplayPtr cur_disp = findDisplayNamed(element->getName()); if (cur_disp != NULL) // We have an old display { vprDEBUG(vrjDBG_DISP_MGR,vprDBG_CONFIG_LVL) << "Removing old window: " << cur_disp->getName().c_str() << vprDEBUG_FLUSH; closeDisplay(cur_disp,true); // Close the display and notify the draw manager to close the window } // --- Add a display (of the correct type) ---- // if (element->getID() == std::string("display_window")) // Display window { DisplayPtr newDisp = Display::create(); // Create the display newDisp->config(element); addDisplay(newDisp,true); // Add it vprDEBUG(vrjDBG_DISP_MGR,vprDBG_STATE_LVL) << "Adding display: " << newDisp->getName().c_str() << std::endl << vprDEBUG_FLUSH; vprDEBUG(vrjDBG_DISP_MGR,vprDBG_STATE_LVL) << "Display: " << newDisp << std::endl << vprDEBUG_FLUSH; } vprDEBUG_END(vrjDBG_DISP_MGR,vprDBG_STATE_LVL) << "------- DisplayManager::configAddDisplay Done. --------\n" << vprDEBUG_FLUSH; return true; }
/** * Removes the element from the current configuration. * @pre configCanHandle(element) == true */ bool DisplayManager::configRemove(jccl::ConfigElementPtr element) { vprASSERT(configCanHandle(element)); const std::string element_type(element->getID()); if ( (element_type == std::string("surfaceDisplay")) || (element_type == std::string("simDisplay")) ) { vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL) << "Element of type: " << element_type << " is no longer supported. Use display_window type instead.\n" << vprDEBUG_FLUSH; return false; } else if (element_type == std::string("display_window")) { return configRemoveDisplay(element); } else if (element_type == std::string("display_system")) { // XXX: Put signal here to tell draw manager to lookup new stuff mDisplaySystemElement.reset(); // Keep track of the display system element return true; // We successfully configured. // This tell processPending to remove it to the active config } else { return false; } }
void ConfigManager::refreshPendingList() { vprASSERT(0 == mPendingCountMutex.test()); mPendingCountMutex.acquire(); mPendingCheckCount = 0; mPendingCountMutex.release(); }
unsigned __stdcall vprThreadFunctorFunction(void* arg) { vpr::thread_func_t& func = *((vpr::thread_func_t*) arg); vprASSERT(! func.empty()); func(); return 0; }
void ConfigManager::debugDumpPending(int debug_level) { vprASSERT(1 == mPendingLock.test()); vprDEBUG(vprDBG_ALL,debug_level) << clrSetNORM(clrGREEN) << "---- Pending list: " << mPendingConfig.size() << " items ----\n" << clrRESET << vprDEBUG_FLUSH; std::list<ConfigManager::PendingElement>::iterator current, end; current = getPendingBegin(); end = getPendingEnd(); while ( current != end ) { ConfigElementPtr cur_element = (*current).mElement; if ( (*current).mType == PendingElement::ADD ) { vprDEBUG_NEXT(vprDBG_ALL,debug_level) << " ADD -->" << vprDEBUG_FLUSH; } else if ( (*current).mType == PendingElement::REMOVE ) { vprDEBUG_NEXT(vprDBG_ALL,debug_level) << "REMOVE -->" << vprDEBUG_FLUSH; } vprDEBUG_CONT(vprDBG_ALL,debug_level) << cur_element->getName() << " type: " << cur_element->getID() << std::endl << vprDEBUG_FLUSH; current++; } vprDEBUG_NEXT(vprDBG_ALL,debug_level) << "----------------------------------\n" << vprDEBUG_FLUSH; }
// Set this thread's priority. void ThreadPosix::setPrio(VPRThreadPriority prio) { #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING sched_param_t sched_param; sched_param.sched_priority = vprThreadPriorityToPOSIX(prio); const int result = pthread_setschedparam(mThread, SCHED_RR, &sched_param); if ( EINVAL == result || ENOTSUP == result ) { std::ostringstream msg_stream; msg_stream << "Invalid priority value " << sched_param.sched_priority; throw vpr::IllegalArgumentException(msg_stream.str(), VPR_LOCATION); } else if ( ESRCH == result ) { throw vpr::IllegalArgumentException( "Cannot set priority for invalid thread", VPR_LOCATION ); } vprASSERT(result == 0); #else boost::ignore_unused_variable_warning(prio); std::cerr << "vpr::ThreadPosix::setPrio(): Not supported\n"; #endif }
// Add an item to the active configuration // NOTE: This DOES NOT process the element it just places it into the active // configuration list. // PRE: Current list must NOT be locked. void ConfigManager::addActive(ConfigElementPtr element) { vprASSERT(0 == mActiveLock.test()); lockActive(); mActiveConfig.vec().push_back(element); unlockActive(); }
void ThreadPosix::join(void** status) { const int result = pthread_join(mThread, status); if ( EINVAL == result ) { throw vpr::IllegalArgumentException("Cannot join an unjoinable thread", VPR_LOCATION); } else if ( ESRCH == result ) { throw vpr::IllegalArgumentException("Cannot join an invalid thread", VPR_LOCATION); } else if ( EDEADLK == result ) { throw vpr::DeadlockException("Deadlock detected when joining thread", VPR_LOCATION); } vprASSERT(result == 0); if ( mCaughtException ) { throw mException; } }
// Get this thread's priority. BaseThread::VPRThreadPriority ThreadPosix::getPrio() const { #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING int policy; sched_param_t fifo_sched_param; const int result = pthread_getschedparam(mThread, &policy, &fifo_sched_param); if ( ESRCH == result ) { throw vpr::IllegalArgumentException( "Cannot query priority for invalid thread", VPR_LOCATION ); } vprASSERT(result == 0); return posixThreadPriorityToVPR(fifo_sched_param.sched_priority); #else std::cerr << "vpr::ThreadPosix::getPrio(): Not supported\n"; return VPR_PRIORITY_NORMAL; #endif }
// Erase an item from the list. // PRE: Active list must be locked && item must be in list. // POST: list = old(list).erase(item) && item is invalid. void ConfigManager::removeActive(const std::string& elementName) { vprASSERT(0 == mActiveLock.test()); lockActive(); mActiveConfig.remove(elementName); unlockActive(); }
bool DataGloveUltraWireless::config(jccl::ConfigElementPtr e) { vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL) << "*** DataGloveUltraWireless::config() ***" << std::endl << vprDEBUG_FLUSH; if(! (Input::config(e) && Analog::config(e) && Command::config(e) ) ) { return false; } mPortName = e->getProperty<std::string>("port"); mBaudRate = e->getProperty<int>("baud"); mPortAEnabled = e->getProperty<bool>("port_a_enabled"); mPortBEnabled = e->getProperty<bool>("port_b_enabled"); mGlove.setGestureThresholds( e->getProperty<float>("gesture_upper_threshold"), e->getProperty<float>("gesture_lower_threshold") ); mGlove.setAutoRangeReset( e->getProperty<bool>("auto_range_reset") ); vprASSERT(mThread == NULL); // This should have been set by Input(c) return true; }
RegistryEntryPtr Registry::findNewestVersionEntry(const std::string& moduleName) const { vprASSERT(moduleName.find(plugin::Info::getSeparator()) == std::string::npos); std::priority_queue< RegistryEntryPtr, std::vector<RegistryEntryPtr>, is_version_less<RegistryEntry> > queue; typedef registry_type::const_iterator iter_type; for ( iter_type i = mRegistry.begin(); i != mRegistry.end(); ++i ) { if ( boost::algorithm::starts_with((*i).first, moduleName) ) { queue.push((*i).second); } } RegistryEntryPtr entry; if ( ! queue.empty() ) { entry = queue.top(); } return entry; }
BOOL ExtensionLoaderWGL::wglQuerySwapGroupNV(HDC hdc, GLuint* group, GLuint* barrier) { vprASSERT(mWglFuncs->wglQuerySwapGroupNV != NULL && "Attemped to call unsupported extension."); return mWglFuncs->wglQuerySwapGroupNV(hdc, group, barrier); }
bool InputWindowXWin::startSampling() { if (mThread != NULL) { vprDEBUG(vprDBG_ERROR,vprDBG_CRITICAL_LVL) << clrOutNORM(clrRED,"ERROR") << ": gadget::InputWindowXWin: startSampling called, when already sampling.\n" << vprDEBUG_FLUSH; vprASSERT(false); } bool started(false); mExitFlag = false; // Create a new thread to handle the control try { mThread = new vpr::Thread(boost::bind(&InputWindowXWin::controlLoop, this)); started = true; } catch (vpr::Exception& ex) { vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL) << clrOutBOLD(clrRED, "ERROR") << ": Failed to spawn thread for X11 input window driver!\n" << vprDEBUG_FLUSH; vprDEBUG_NEXT(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL) << ex.what() << std::endl << vprDEBUG_FLUSH; } return started; }
SemaphorePosix::~SemaphorePosix() { // ---- Delete the semaphore --- // #ifdef VPR_USE_NAMED_SEMAPHORE const int result = sem_close(mSema); vprASSERT(result == 0); sem_unlink(mSemaFile); std::free(mSemaFile); #else const int result = sem_destroy(mSema); vprASSERT(result == 0); std::free(mSema); #endif }
BOOL ExtensionLoaderWGL::wglQueryFrameCountNV(HDC hdc, /*int screen,*/ GLuint* count) { vprASSERT(mWglFuncs->wglQueryFrameCountNV != NULL && "Attemped to call unsupported extension."); return mWglFuncs->wglQueryFrameCountNV(hdc, /*screen,*/ count); }