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);
}
