void NewMarginWidget::setFacingPages(bool facing, int pagetype) { facingPages = facing; pageType = pagetype; leftMarginLabel->setText(facing == true ? tr( "&Inside:" ) : tr( "&Left:" )); rightMarginLabel->setText(facing == true ? tr( "O&utside:" ) : tr( "&Right:" )); setPreset(); }
// Just override the mandatory create scene method void createScene(void) { // Create our two rendering cameras. Since we're using the ExampleApplication and we want to individually translate/rotate // our two cameras, I'll use the ExampleApplication::mCamera as a virtual camera(it will not render anything) and use it // to translate our selected camera. mVirtualCamera = mCamera; mCameras[0] = mSceneMgr->createCamera("Camera1"); mCameras[1] = mSceneMgr->createCamera("Camera2"); for(Ogre::uint32 k = 0; k < 2; k++) { mCameras[k]->setPosition(mVirtualCamera->getPosition()); mCameras[k]->setOrientation(mVirtualCamera->getOrientation()); mCameras[k]->setAspectRatio(mVirtualCamera->getAspectRatio()/2); // /2 since we're going to use a half-width viewport size mCameras[k]->setFarClipDistance(30000); mCameras[k]->setNearClipDistance(20); } // Remove the existing viewport (created by the ExampleApplication) and create our new viewports mWindow->removeViewport(0); Ogre::Viewport* vp1 = mWindow->addViewport(mCameras[0], 0, 0, 0, 0.5, 1); Ogre::Viewport* vp2 = mWindow->addViewport(mCameras[1], 1, 0.5, 0, 0.5, 1); vp2->setOverlaysEnabled(false); // Create our text area for display SkyX parameters createTextArea(); // Create SkyX mBasicController = new SkyX::BasicController(); mSkyX = new SkyX::SkyX(mSceneMgr, mBasicController); mSkyX->create(); // Distance geometry falling is a feature introduced in SkyX 0.2 // When distance falling is enabled, the geometry linearly falls with the distance and the // amount of falling in world units is determinated by the distance between the cloud field "plane" // and the camera height multiplied by the falling factor. // For this demo, a falling factor of two is good enough for the point of view we're using. That means that if the camera // is at a distance of 100 world units from the cloud field, the fartest geometry will fall 2*100 = 200 world units. // This way the cloud field covers a big part of the sky even if the camera is in at a very low altitude. // The second parameter is the max amount of falling distance in world units. That's needed when for example, you've an // ocean and you don't want to have the volumetric cloud field geometry falling into the water when the camera is underwater. // -1 means that there's not falling limit. mSkyX->getVCloudsManager()->getVClouds()->setDistanceFallingParams(Ogre::Vector2(2,-1)); // Register SkyX listeners mRoot->addFrameListener(mSkyX); // Since our two viewports are created through the mWindow render window, we've just add SkyX as a RenderTargetListener // and SkyX will automatically handle all the multi-camera stuff. // In very specific applications(like editors or when you're using a complex rendering pipeline), you'll need to manually // update the SkyX geometry instead of handle it by using listeners. In these situations just invoke SkyX::notifyCameraRender(...) // before rendering the camera frame. mWindow->addListener(mSkyX); setPreset(mPresets[mCurrentPreset]); }
void MarginWidget::setPageWidthHeight(double width, double height) { rightR->setMaximum(width * m_unitRatio - leftR->value()); leftR->setMaximum(width * m_unitRatio - rightR->value()); pageWidth = width; topR->setMaximum(height * m_unitRatio - bottomR->value()); bottomR->setMaximum(height * m_unitRatio - topR->value()); pageHeight = height; setPreset(); }
void LADSPAPresetSlot::dropEvent(QDropEvent * event) { if (event->mimeData()->hasFormat("application/x-qabstractitemmodeldatalist")) { int row, column; QByteArray encoded = event->mimeData()->data("application/x-qabstractitemmodeldatalist"); QDataStream stream(&encoded, QIODevice::ReadOnly); stream >> row >> column; setPreset(m_pPresetManager->getPreset(row)); }
void NewMarginWidget::setLeft() { double newVal = leftMarginSpinBox->value() / m_unitRatio; rightMarginSpinBox->setMaximum(qMax(0.0, pageWidth * m_unitRatio - leftMarginSpinBox->value())); if (marginLinkButton->isChecked() && savedPresetItem==PresetLayout::none) { marginData.set(newVal, newVal, newVal, newVal); updateMarginSpinValues(); } else marginData.setLeft(newVal); setPreset(); }
void MarginWidget::setBottom() { double newVal = bottomR->value() / m_unitRatio; topR->setMaximum(qMax(0.0, pageHeight * m_unitRatio - bottomR->value())); if (linkMargins->isChecked() && savedPresetItem==PresetLayout::none) { marginData.set(newVal, newVal, newVal, newVal); updateMarginSpinValues(); } else marginData.setBottom(newVal); setPreset(); }
void MarginWidget::setRight() { double newVal = rightR->value() / m_unitRatio; leftR->setMaximum(qMax(0.0, pageWidth * m_unitRatio - rightR->value())); if (linkMargins->isChecked() && savedPresetItem==PresetLayout::none) { marginData.set(newVal, newVal, newVal, newVal); updateMarginSpinValues(); } else marginData.setRight(newVal); setPreset(); }
void synthv1widget_preset::openPreset (void) { synthv1_config *pConfig = synthv1_config::getInstance(); if (pConfig == NULL) return; QString sFilename; const QString sExt(SYNTHV1_TITLE); const QString& sTitle = tr("Open Preset") + " - " SYNTHV1_TITLE; const QString& sFilter = tr("Preset files (*.%1)").arg(sExt); #if 1//QT_VERSION < 0x040400 QFileDialog::Options options = 0; if (pConfig->bDontUseNativeDialogs) options |= QFileDialog::DontUseNativeDialog; sFilename = QFileDialog::getOpenFileName(parentWidget(), sTitle, pConfig->sPresetDir, sFilter, NULL, options); #else QFileDialog fileDialog(nativeParentWidget(), sTitle, pConfig->sPresetDir, sFilter); fileDialog.setAcceptMode(QFileDialog::AcceptOpen); fileDialog.setFileMode(QFileDialog::ExistingFile); fileDialog.setDefaultSuffix(sExt); QList<QUrl> urls(fileDialog.sidebarUrls()); urls.append(QUrl::fromLocalFile(pConfig->sPresetDir)); fileDialog.setSidebarUrls(urls); if (pConfig->bDontUseNativeDialogs) fileDialog.setOptions(QFileDialog::DontUseNativeDialog); if (fileDialog.exec()) sFilename = fileDialog.selectedFiles().first(); #endif if (!sFilename.isEmpty()) { QFileInfo fi(sFilename); if (fi.exists() && queryPreset()) { const QString& sPreset = fi.completeBaseName(); pConfig->setPresetFile(sPreset, sFilename); emit loadPresetFile(sFilename); ++m_iInitPreset; // pConfig->sPreset = sPreset; pConfig->sPresetDir = fi.absolutePath(); setPreset(sPreset); refreshPreset(); } } stabilizePreset(); }
// Check whether current preset may be reset. bool synthv1widget_preset::queryPreset (void) { if (m_iInitPreset == 0) return true; synthv1_config *pConfig = synthv1_config::getInstance(); if (pConfig == NULL) return false; if (m_iDirtyPreset > 0) { const QString sPreset(pConfig->sPreset); if (sPreset.isEmpty()) { if (QMessageBox::warning(this, tr("Warning") + " - " SYNTHV1_TITLE, tr("Some parameters have been changed.\n\n" "Do you want to discard the changes?"), QMessageBox::Discard | QMessageBox::Cancel) == QMessageBox::Cancel) return false; } else { switch (QMessageBox::warning(this, tr("Warning") + " - " SYNTHV1_TITLE, tr("Some preset parameters have been changed:\n\n" "\"%1\".\n\nDo you want to save the changes?") .arg(sPreset), QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel)) { case QMessageBox::Save: savePreset(sPreset); // Fall thru... case QMessageBox::Discard: break; default: // Cancel... setPreset(sPreset); return false; } } } return true; }
ScriptWidget::ScriptWidget(MazeScene *scene, Entity *entity) : m_scene(scene) , m_entity(entity) { new QVBoxLayout(this); m_statusView = new QLineEdit; m_statusView->setReadOnly(true); layout()->addWidget(m_statusView); m_sourceEdit = new QPlainTextEdit; layout()->addWidget(m_sourceEdit); QPushButton *compileButton = new QPushButton(QLatin1String("Compile")); layout()->addWidget(compileButton); QComboBox *combo = new QComboBox; layout()->addWidget(combo); combo->addItem(QLatin1String("Default")); combo->addItem(QLatin1String("Patrol")); combo->addItem(QLatin1String("Follow")); setPreset(0); connect(combo, SIGNAL(currentIndexChanged(int)), this, SLOT(setPreset(int))); connect(compileButton, SIGNAL(clicked()), this, SLOT(updateSource())); m_engine = new QScriptEngine(this); QScriptValue entityObject = m_engine->newQObject(m_entity); m_engine->globalObject().setProperty("entity", entityObject); QScriptValue widgetObject = m_engine->newQObject(this); m_engine->globalObject().setProperty("script", widgetObject); m_engine->globalObject().setProperty("rand", m_engine->newFunction(qsRand)); m_engine->setProcessEventsInterval(5); resize(300, 400); updateSource(); startTimer(50); m_time.start(); }
void MarginWidget::setFacingPages(bool facing, int pagetype) { facingPages = facing; pageType = pagetype; lText->setText(facing == true ? tr( "&Inside:" ) : tr( "&Left:" )); rText->setText(facing == true ? tr( "O&utside:" ) : tr( "&Right:" )); if (useBleeds) { if (facing) { BleedTxt3->setText( tr( "Inside:" ) ); BleedTxt4->setText( tr( "Outside:" ) ); } else { BleedTxt3->setText( tr( "Left:" ) ); BleedTxt4->setText( tr( "Right:" ) ); } } setPreset(); }
void drawInit() { g_DepthDrawColoring[DEPTH_OFF] = "Off"; g_DepthDrawColoring[LINEAR_HISTOGRAM] = "Linear Histogram"; g_DepthDrawColoring[PSYCHEDELIC] = "Psychedelic"; g_DepthDrawColoring[PSYCHEDELIC_SHADES] = "Psychedelic (Millimeters)"; g_DepthDrawColoring[RAINBOW] = "Rainbow"; g_DepthDrawColoring[CYCLIC_RAINBOW] = "Cyclic Rainbow"; g_DepthDrawColoring[CYCLIC_RAINBOW_HISTOGRAM] = "Cyclic Rainbow Histogram"; g_DepthDrawColoring[STANDARD_DEVIATION] = "Standard Deviation"; g_ColorDrawColoring[COLOR_OFF] = "Off"; g_ColorDrawColoring[COLOR_NORMAL] = "Normal"; g_ColorDrawColoring[DEPTH_MASKED_COLOR] = "Depth Masked Color"; CreateRainbowPallet(); setPreset(7); mouseInputRegisterForSelectionRectangle(drawSelectionChanged); mouseInputRegisterForCursorMovement(drawCursorMoved); }
//============================================================================== Equalizer::Equalizer (int insertion_) { sampleRate = 44100; insertion = insertion_; for (int i = 0; i < MAX_EQ_BANDS; i++) { filter[i].Ptype = 0; filter[i].Pfreq = 64; filter[i].Pgain = 64; filter[i].Pq = 64; filter[i].Pstages = 0; filter[i].l = new AnalogFilter (6, 1000.0, 1.0, 0); filter[i].r = new AnalogFilter (6, 1000.0, 1.0, 0); } //default values Ppreset = 0; Pvolume = 0; Pdrywet = 127; setPreset (Ppreset); clean(); }
static int mono_speaker_on( int channel, struct tfa98xx_param_data *speaker, struct tfa98xx_param_data *config, struct tfa98xx_param_data *preset, struct tfa98xx_param_data *eq) { enum Tfa98xx_Error err; FIXEDPT re25; int calibrateDone = 0; /* use the generic slave address for optimizations */ coldStartup(handles[channel]); /*Set to calibration once*/ /* Only needed for really first time calibration */ setOtc(handles[channel], 1); /* Check if MTPEX bit is set for calibration once mode */ if (checkMTPEX(handles[channel]) == 0) { pr_info("%s: DSP not yet calibrated. Calibration will start\n", __func__); /* ensure no audio during special calibration */ err = Tfa98xx_SetMute(handles[channel], Tfa98xx_Mute_Digital); if (err != Tfa98xx_Error_Ok) { pr_err("%s: Tfa98xx_ReadRegister16 failed\n", __func__); return -EINVAL; } } else pr_info("%s: DSP already calibrated\n", __func__); /* load predefined, or fullmodel from file */ setSpeaker(1, &handles[channel], speaker); /* load the settings */ setConfig(1, &handles[channel], config); /* load a preset */ setPreset(1, &handles[channel], preset); /* set the equalizer */ setEQ(1, &handles[channel], eq); err = Tfa98xx_SelectChannel(handles[channel], Tfa98xx_Channel_L_R); if (err != Tfa98xx_Error_Ok) { pr_err("%s: Tfa98xx_SelectChannel failed\n", __func__); return -EINVAL; } /* all settings loaded, signal the DSP to start calibration */ err = Tfa98xx_SetConfigured(handles[channel]); if (err != Tfa98xx_Error_Ok) { pr_err("%s: Tfa98xx_SetConfigured failed\n", __func__); return -EINVAL; } waitCalibration(handles[channel], &calibrateDone); if (calibrateDone) Tfa98xx_DspGetCalibrationImpedance(handles[channel], &re25); else { re25 = 0; err = Tfa98xx_Powerdown(handles[channel], 1); pr_err("%s: Tfa98xx_Powerdown failed, channel=%d\n", __func__, channel); return -EINVAL; } err = Tfa98xx_SetMute(handles[channel], Tfa98xx_Mute_Off); if (err != Tfa98xx_Error_Ok) { pr_err("%s: Tfa98xx_SetMute failed, channel=%d\n", __func__, channel); return -EINVAL; } return 0; }
void setupPreferences() { auto preferences = DependencyManager::get<Preferences>(); MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar(); static const QString AVATAR_BASICS { "Avatar Basics" }; { auto getter = [=]()->QString { return myAvatar->getDisplayName(); }; auto setter = [=](const QString& value) { myAvatar->setDisplayName(value); }; auto preference = new EditPreference(AVATAR_BASICS, "Avatar display name (optional)", getter, setter); preference->setPlaceholderText("Not showing a name"); preferences->addPreference(preference); } { auto getter = [=]()->QString { return myAvatar->getCollisionSoundURL(); }; auto setter = [=](const QString& value) { myAvatar->setCollisionSoundURL(value); }; auto preference = new EditPreference(AVATAR_BASICS, "Avatar collision sound URL (optional)", getter, setter); preference->setPlaceholderText("Enter the URL of a sound to play when you bump into something"); preferences->addPreference(preference); } { auto getter = [=]()->QString { return myAvatar->getFullAvatarURLFromPreferences().toString(); }; auto setter = [=](const QString& value) { myAvatar->useFullAvatarURL(value, ""); }; auto preference = new AvatarPreference(AVATAR_BASICS, "Appearance", getter, setter); preferences->addPreference(preference); } { auto getter = [=]()->bool { return myAvatar->getSnapTurn(); }; auto setter = [=](bool value) { myAvatar->setSnapTurn(value); }; preferences->addPreference(new CheckPreference(AVATAR_BASICS, "Snap turn when in HMD", getter, setter)); } { auto getter = [=]()->bool { return myAvatar->getClearOverlayWhenMoving(); }; auto setter = [=](bool value) { myAvatar->setClearOverlayWhenMoving(value); }; preferences->addPreference(new CheckPreference(AVATAR_BASICS, "Clear overlays when moving", getter, setter)); } // Snapshots static const QString SNAPSHOTS { "Snapshots" }; { auto getter = []()->QString { return Snapshot::snapshotsLocation.get(); }; auto setter = [](const QString& value) { Snapshot::snapshotsLocation.set(value); }; auto preference = new BrowsePreference(SNAPSHOTS, "Put my snapshots here", getter, setter); preferences->addPreference(preference); } // Scripts { auto getter = []()->QString { return DependencyManager::get<ScriptEngines>()->getScriptsLocation(); }; auto setter = [](const QString& value) { DependencyManager::get<ScriptEngines>()->setScriptsLocation(value); }; preferences->addPreference(new BrowsePreference("Scripts", "Load scripts from this directory", getter, setter)); } preferences->addPreference(new ButtonPreference("Scripts", "Load Default Scripts", [] { DependencyManager::get<ScriptEngines>()->loadDefaultScripts(); })); { auto getter = []()->bool { return !Menu::getInstance()->isOptionChecked(MenuOption::DisableActivityLogger); }; auto setter = [](bool value) { Menu::getInstance()->setIsOptionChecked(MenuOption::DisableActivityLogger, !value); }; preferences->addPreference(new CheckPreference("Privacy", "Send data", getter, setter)); } static const QString LOD_TUNING("Level of Detail Tuning"); { auto getter = []()->float { return DependencyManager::get<LODManager>()->getDesktopLODDecreaseFPS(); }; auto setter = [](float value) { DependencyManager::get<LODManager>()->setDesktopLODDecreaseFPS(value); }; auto preference = new SpinnerPreference(LOD_TUNING, "Minimum desktop FPS", getter, setter); preference->setMin(0); preference->setMax(120); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->float { return DependencyManager::get<LODManager>()->getHMDLODDecreaseFPS(); }; auto setter = [](float value) { DependencyManager::get<LODManager>()->setHMDLODDecreaseFPS(value); }; auto preference = new SpinnerPreference(LOD_TUNING, "Minimum HMD FPS", getter, setter); preference->setMin(0); preference->setMax(120); preference->setStep(1); preferences->addPreference(preference); } static const QString AVATAR_TUNING { "Avatar Tuning" }; { auto getter = [=]()->float { return myAvatar->getRealWorldFieldOfView(); }; auto setter = [=](float value) { myAvatar->setRealWorldFieldOfView(value); }; auto preference = new SpinnerPreference(AVATAR_TUNING, "Real world vertical field of view (angular size of monitor)", getter, setter); preference->setMin(1); preference->setMax(180); preferences->addPreference(preference); } { auto getter = []()->float { return qApp->getFieldOfView(); }; auto setter = [](float value) { qApp->setFieldOfView(value); }; auto preference = new SpinnerPreference(AVATAR_TUNING, "Vertical field of view", getter, setter); preference->setMin(1); preference->setMax(180); preference->setStep(1); preferences->addPreference(preference); } { auto getter = [=]()->float { return myAvatar->getUniformScale(); }; auto setter = [=](float value) { myAvatar->setTargetScaleVerbose(value); }; // The hell? auto preference = new SpinnerPreference(AVATAR_TUNING, "Avatar scale (default is 1.0)", getter, setter); preference->setMin(0.01f); preference->setMax(99.9f); preference->setDecimals(2); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->float { return DependencyManager::get<DdeFaceTracker>()->getEyeClosingThreshold(); }; auto setter = [](float value) { DependencyManager::get<DdeFaceTracker>()->setEyeClosingThreshold(value); }; preferences->addPreference(new SliderPreference(AVATAR_TUNING, "Camera binary eyelid threshold", getter, setter)); } { auto getter = []()->float { return FaceTracker::getEyeDeflection(); }; auto setter = [](float value) { FaceTracker::setEyeDeflection(value); }; preferences->addPreference(new SliderPreference(AVATAR_TUNING, "Face tracker eye deflection", getter, setter)); } { auto getter = []()->QString { return DependencyManager::get<Faceshift>()->getHostname(); }; auto setter = [](const QString& value) { DependencyManager::get<Faceshift>()->setHostname(value); }; auto preference = new EditPreference(AVATAR_TUNING, "Faceshift hostname", getter, setter); preference->setPlaceholderText("localhost"); preferences->addPreference(preference); } { auto getter = [=]()->QString { return myAvatar->getAnimGraphOverrideUrl().toString(); }; auto setter = [=](const QString& value) { myAvatar->setAnimGraphOverrideUrl(QUrl(value)); }; auto preference = new EditPreference(AVATAR_TUNING, "Avatar animation JSON", getter, setter); preference->setPlaceholderText("default"); preferences->addPreference(preference); } static const QString AVATAR_CAMERA { "Avatar Camera" }; { auto getter = [=]()->float { return myAvatar->getPitchSpeed(); }; auto setter = [=](float value) { myAvatar->setPitchSpeed(value); }; auto preference = new SpinnerPreference(AVATAR_CAMERA, "Camera pitch speed (degrees/second)", getter, setter); preference->setMin(1.0f); preference->setMax(360.0f); preferences->addPreference(preference); } { auto getter = [=]()->float { return myAvatar->getYawSpeed(); }; auto setter = [=](float value) { myAvatar->setYawSpeed(value); }; auto preference = new SpinnerPreference(AVATAR_CAMERA, "Camera yaw speed (degrees/second)", getter, setter); preference->setMin(1.0f); preference->setMax(360.0f); preferences->addPreference(preference); } static const QString AUDIO("Audio"); { auto getter = []()->bool { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getDynamicJitterBuffers(); }; auto setter = [](bool value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setDynamicJitterBuffers(value); }; preferences->addPreference(new CheckPreference(AUDIO, "Enable dynamic jitter buffers", getter, setter)); } { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getDesiredJitterBufferFrames(); }; auto setter = [](float value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setStaticDesiredJitterBufferFrames(value); }; auto preference = new SpinnerPreference(AUDIO, "Static jitter buffer frames", getter, setter); preference->setMin(0); preference->setMax(10000); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getMaxFramesOverDesired(); }; auto setter = [](float value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setMaxFramesOverDesired(value); }; auto preference = new SpinnerPreference(AUDIO, "Max frames over desired", getter, setter); preference->setMax(10000); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->bool { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getUseStDevForJitterCalc(); }; auto setter = [](bool value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setUseStDevForJitterCalc(value); }; preferences->addPreference(new CheckPreference(AUDIO, "Use standard deviation for dynamic jitter calc", getter, setter)); } { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getWindowStarveThreshold(); }; auto setter = [](float value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setWindowStarveThreshold(value); }; auto preference = new SpinnerPreference(AUDIO, "Window A starve threshold", getter, setter); preference->setMax(10000); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getWindowSecondsForDesiredCalcOnTooManyStarves(); }; auto setter = [](float value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setWindowSecondsForDesiredCalcOnTooManyStarves(value); }; auto preference = new SpinnerPreference(AUDIO, "Window A (raise desired on N starves) seconds", getter, setter); preference->setMax(10000); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getWindowSecondsForDesiredReduction(); }; auto setter = [](float value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setWindowSecondsForDesiredReduction(value); }; auto preference = new SpinnerPreference(AUDIO, "Window B (desired ceiling) seconds", getter, setter); preference->setMax(10000); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->bool { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getRepetitionWithFade(); }; auto setter = [](bool value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setRepetitionWithFade(value); }; preferences->addPreference(new CheckPreference(AUDIO, "Repetition with fade", getter, setter)); } { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getOutputBufferSize(); }; auto setter = [](float value) { DependencyManager::get<AudioClient>()->setOutputBufferSize(value); }; auto preference = new SpinnerPreference(AUDIO, "Output buffer initial size (frames)", getter, setter); preference->setMin(1); preference->setMax(20); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->bool { return DependencyManager::get<AudioClient>()->getOutputStarveDetectionEnabled(); }; auto setter = [](bool value) { DependencyManager::get<AudioClient>()->setOutputStarveDetectionEnabled(value); }; auto preference = new CheckPreference(AUDIO, "Output starve detection (automatic buffer size increase)", getter, setter); preferences->addPreference(preference); } { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getOutputStarveDetectionThreshold(); }; auto setter = [](float value) { DependencyManager::get<AudioClient>()->setOutputStarveDetectionThreshold(value); }; auto preference = new SpinnerPreference(AUDIO, "Output starve detection threshold", getter, setter); preference->setMin(1); preference->setMax(500); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getOutputStarveDetectionPeriod(); }; auto setter = [](float value) { DependencyManager::get<AudioClient>()->setOutputStarveDetectionPeriod(value); }; auto preference = new SpinnerPreference(AUDIO, "Output starve detection period (ms)", getter, setter); preference->setMin(1); preference->setMax((float)999999999); preference->setStep(1); preferences->addPreference(preference); } #if DEV_BUILD || PR_BUILD { auto getter = []()->float { return DependencyManager::get<AudioClient>()->getGateThreshold(); }; auto setter = [](float value) { return DependencyManager::get<AudioClient>()->setGateThreshold(value); }; auto preference = new SpinnerPreference(AUDIO, "Debug gate threshold", getter, setter); preference->setMin(1); preference->setMax((float)100); preference->setStep(1); preferences->addPreference(preference); } #endif { auto getter = []()->float { return qApp->getMaxOctreePacketsPerSecond(); }; auto setter = [](float value) { qApp->setMaxOctreePacketsPerSecond(value); }; auto preference = new SpinnerPreference("Octree", "Max packets sent each second", getter, setter); preference->setMin(60); preference->setMax(6000); preference->setStep(10); preferences->addPreference(preference); } { auto getter = []()->float { return qApp->getApplicationCompositor().getHmdUIAngularSize(); }; auto setter = [](float value) { qApp->getApplicationCompositor().setHmdUIAngularSize(value); }; auto preference = new SpinnerPreference("HMD", "UI horizontal angular size (degrees)", getter, setter); preference->setMin(30); preference->setMax(160); preference->setStep(1); preferences->addPreference(preference); } { auto getter = []()->float { return controller::InputDevice::getReticleMoveSpeed(); }; auto setter = [](float value) { controller::InputDevice::setReticleMoveSpeed(value); }; auto preference = new SpinnerPreference("Sixense Controllers", "Reticle movement speed", getter, setter); preference->setMin(0); preference->setMax(100); preference->setStep(1); preferences->addPreference(preference); } { static const QString RENDER("Graphics"); auto renderConfig = qApp->getRenderEngine()->getConfiguration(); auto ambientOcclusionConfig = renderConfig->getConfig<AmbientOcclusionEffect>(); { auto getter = [ambientOcclusionConfig]()->QString { return ambientOcclusionConfig->getPreset(); }; auto setter = [ambientOcclusionConfig](QString preset) { ambientOcclusionConfig->setPreset(preset); }; auto preference = new ComboBoxPreference(RENDER, "Ambient occlusion", getter, setter); preference->setItems(ambientOcclusionConfig->getPresetList()); preferences->addPreference(preference); } auto shadowConfig = renderConfig->getConfig<RenderShadowTask>(); { auto getter = [shadowConfig]()->QString { return shadowConfig->getPreset(); }; auto setter = [shadowConfig](QString preset) { shadowConfig->setPreset(preset); }; auto preference = new ComboBoxPreference(RENDER, "Shadows", getter, setter); preference->setItems(shadowConfig->getPresetList()); preferences->addPreference(preference); } } { static const QString RENDER("Networking"); auto nodelist = DependencyManager::get<NodeList>(); { static const int MIN_PORT_NUMBER { 0 }; static const int MAX_PORT_NUMBER { 65535 }; auto getter = [nodelist] { return static_cast<int>(nodelist->getSocketLocalPort()); }; auto setter = [nodelist](int preset) { nodelist->setSocketLocalPort(static_cast<quint16>(preset)); }; auto preference = new IntSpinnerPreference(RENDER, "Listening Port", getter, setter); preference->setMin(MIN_PORT_NUMBER); preference->setMax(MAX_PORT_NUMBER); preferences->addPreference(preference); } } }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { setWindowTitle("QML Easing Curve Editor"); SplineEditor *splineEditor = new SplineEditor(this); QWidget *mainWidget = new QWidget(this); setCentralWidget(mainWidget); QHBoxLayout *hboxLayout = new QHBoxLayout(mainWidget); QVBoxLayout *vboxLayout = new QVBoxLayout(); mainWidget->setLayout(hboxLayout); hboxLayout->addLayout(vboxLayout); QWidget *propertyWidget = new QWidget(this); ui_properties.setupUi(propertyWidget); ui_properties.spinBox->setMinimum(50); ui_properties.spinBox->setMaximum(10000); ui_properties.spinBox->setValue(500); hboxLayout->addWidget(propertyWidget); m_placeholder = new QWidget(this); m_placeholder->setFixedSize(quickView.size()); vboxLayout->addWidget(splineEditor); vboxLayout->addWidget(m_placeholder); ui_properties.plainTextEdit->setPlainText(splineEditor->generateCode()); connect(splineEditor, SIGNAL(easingCurveCodeChanged(QString)), ui_properties.plainTextEdit, SLOT(setPlainText(QString))); quickView.rootContext()->setContextProperty(QLatin1String("spinBox"), ui_properties.spinBox); foreach (const QString &name, splineEditor->presetNames()) ui_properties.comboBox->addItem(name); connect(ui_properties.comboBox, SIGNAL(currentIndexChanged(QString)), splineEditor, SLOT(setPreset(QString))); splineEditor->setPreset(ui_properties.comboBox->currentText()); QVBoxLayout *groupBoxLayout = new QVBoxLayout(ui_properties.groupBox); groupBoxLayout->setMargin(0); ui_properties.groupBox->setLayout(groupBoxLayout); groupBoxLayout->addWidget(splineEditor->pointListWidget()); m_splineEditor = splineEditor; connect(ui_properties.plainTextEdit, SIGNAL(textChanged()), this, SLOT(textEditTextChanged())); QDialog* importDialog = new QDialog(this); ui_import.setupUi(importDialog); ui_import.inInfluenceEdit->setValidator(new QDoubleValidator(this)); ui_import.inSlopeEdit->setValidator(new QDoubleValidator(this)); ui_import.outInfluenceEdit->setValidator(new QDoubleValidator(this)); ui_import.outSlopeEdit->setValidator(new QDoubleValidator(this)); connect(ui_properties.importButton, SIGNAL(clicked()), importDialog, SLOT(show())); connect(importDialog, SIGNAL(finished(int)), this, SLOT(importData(int))); connect(this, SIGNAL(close()), this, SLOT(doClose())); initQml(); }
static int stereo_speaker_on( struct tfa98xx_param_data *speaker[2], struct tfa98xx_param_data *config[2], struct tfa98xx_param_data *preset[2], struct tfa98xx_param_data *eq[2]) { enum Tfa98xx_Error err = Tfa98xx_Error_Ok; unsigned char h; FIXEDPT re25; int calibrateDone = 0; /* use the generic slave address for optimizations */ for (h = 0; h < 2; h++) { coldStartup(handles[h]); /*Set to calibration once*/ /* Only needed for really first time calibration */ setOtc(handles[h], 1); /* Check if MTPEX bit is set for calibration once mode */ if (checkMTPEX(handles[h]) == 0) { pr_info("%s: DSP not yet calibrated. Calibration will"\ " start\n", __func__); /* ensure no audio during special calibration */ err = Tfa98xx_SetMute( handles[h], Tfa98xx_Mute_Digital); if (err != Tfa98xx_Error_Ok) { pr_err("%s: Tfa98xx_SetMute failed, h=%d\n", __func__, h); return -EINVAL; } } else pr_info("%s: DSP already calibrated\n", __func__); } /* load predefined, or fullmodel from data */ for (h = 0; h < 2; h++) setSpeaker(1, &handles[h], speaker[h]); /* load the settings */ for (h = 0; h < 2; h++) setConfig(1, &handles[h], config[h]); /* load a preset */ for (h = 0; h < 2; h++) setPreset(1, &handles[h], preset[h]); /* set the equalizer */ for (h = 0; h < 2; h++) setEQ(1, &handles[h], eq[h]); err = set_speaker_lr(handles, speaker_lr); if (err != Tfa98xx_Error_Ok) { pr_err("%s: set_speaker_lr failed\n", __func__); return err; } /* all settings loaded, signal the DSP to start calibration */ for (h = 0; h < 2; h++) { err = Tfa98xx_SetConfigured(handles[h]); if (err != Tfa98xx_Error_Ok) { pr_err("%s: Tfa98xx_SetConfigured failed h=%d\n", __func__, h); return -EINVAL; } } for (h = 0; h < 2; h++) { calibrateDone = 0; waitCalibration(handles[h], &calibrateDone); if (calibrateDone) Tfa98xx_DspGetCalibrationImpedance(handles[h], &re25); else { re25 = 0; err = Tfa98xx_Powerdown(handles[h], 1); pr_err("%s: Calibration failed, power down" \ " and return h=%d\n", __func__, h); return -EINVAL; } pr_info("%s re25:%016llx\n", __func__, re25); err = Tfa98xx_SetMute(handles[h], Tfa98xx_Mute_Off); if (err != Tfa98xx_Error_Ok) { pr_err("%s: Tfa98xx_SetMute failed, h=%d\n", __func__, h); return -EINVAL; } } return 0; }
bool frameStarted(const FrameEvent &e) { mKeyboard->capture(); // Clamp camera(virtual camera) height if (mCamera->getDerivedPosition().y < -400) { mCamera->setPosition(Ogre::Vector3(mCamera->getDerivedPosition().x, -400, mCamera->getDerivedPosition().z)); } else if (mCamera->getDerivedPosition().y > 800) { mCamera->setPosition(Ogre::Vector3(mCamera->getDerivedPosition().x, 800, mCamera->getDerivedPosition().z)); } // Update the selected camera position/orientation mCameras[mSelectedCamera]->setPosition(mVirtualCamera->getPosition()); mCameras[mSelectedCamera]->setOrientation(mVirtualCamera->getOrientation()); // Switch presets if (mKeyboard->isKeyDown(OIS::KC_1) && mKeyBuffer < 0) { mCurrentPreset = 0; setPreset(mPresets[mCurrentPreset]); mKeyBuffer = 0.25f; } else if (mKeyboard->isKeyDown(OIS::KC_2) && mKeyBuffer < 0) { mCurrentPreset = 1; setPreset(mPresets[mCurrentPreset]); mKeyBuffer = 0.25f; } else if (mKeyboard->isKeyDown(OIS::KC_3) && mKeyBuffer < 0) { mCurrentPreset = 2; setPreset(mPresets[mCurrentPreset]); mKeyBuffer = 0.25f; } else if (mKeyboard->isKeyDown(OIS::KC_4) && mKeyBuffer < 0) { mCurrentPreset = 3; setPreset(mPresets[mCurrentPreset]); mKeyBuffer = 0.25f; } else if (mKeyboard->isKeyDown(OIS::KC_5) && mKeyBuffer < 0) { mCurrentPreset = 4; setPreset(mPresets[mCurrentPreset]); mKeyBuffer = 0.25f; } else if (mKeyboard->isKeyDown(OIS::KC_6) && mKeyBuffer < 0) { mCurrentPreset = 5; setPreset(mPresets[mCurrentPreset]); mKeyBuffer = 0.25f; } else if (mKeyboard->isKeyDown(OIS::KC_L) && mKeyBuffer < 0) { mSelectedCamera = 0; mVirtualCamera->setPosition(mCameras[mSelectedCamera]->getPosition()); mVirtualCamera->setOrientation(mCameras[mSelectedCamera]->getOrientation()); mKeyBuffer = 0.25f; } else if (mKeyboard->isKeyDown(OIS::KC_R) && mKeyBuffer < 0) { mSelectedCamera = 1; mVirtualCamera->setPosition(mCameras[mSelectedCamera]->getPosition()); mVirtualCamera->setOrientation(mCameras[mSelectedCamera]->getOrientation()); mKeyBuffer = 0.25f; } mKeyBuffer -= e.timeSinceLastFrame; return true; }
Effect::Effect(Preset p){ Effect(); setPreset(p); }