Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-21 17:03:58 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge pull request #4095 from Atlante45/body_not_rotating

Browse source 
Cache size dialog
This commit is contained in:
Andrew Meadows 2015-01-13 10:53:18 -08:00
commit 89dceefd2f
24 changed files with 334 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

111
interface/src/Menu.cpp
View file

@ -11,7 +11,6 @@
#include <cstdlib>
#include <QBoxLayout>
#include <QColorDialog>
#include <QDialogButtonBox>
@ -44,20 +43,26 @@
#include "Audio.h"
#include "audio/AudioIOStatsRenderer.h"
#include "audio/AudioScope.h"
#include "devices/Faceshift.h"
#include "devices/OculusManager.h"
#include "devices/Visage.h"
#include "Menu.h"
#include "scripting/LocationScriptingInterface.h"
#include "scripting/MenuScriptingInterface.h"
#include "Util.h"
#include "ui/AddressBarDialog.h"
#include "ui/AnimationsDialog.h"
#include "ui/AttachmentsDialog.h"
#include "ui/BandwidthDialog.h"
#include "ui/CachesSizeDialog.h"
#include "ui/DataWebDialog.h"
#include "ui/HMDToolsDialog.h"
#include "ui/LodToolsDialog.h"
#include "ui/LoginDialog.h"
#include "ui/OctreeStatsDialog.h"
#include "ui/PreferencesDialog.h"
#include "ui/InfoView.h"
#include "ui/MetavoxelEditor.h"
#include "ui/MetavoxelNetworkSimulator.h"
#include "ui/ModelsBrowser.h"
#include "ui/LoginDialog.h"
#include "ui/NodeBounds.h"
Menu* Menu::_instance = NULL;
@ -79,56 +84,9 @@ Menu* Menu::getInstance() {
return _instance;
}
const float DEFAULT_FACESHIFT_EYE_DEFLECTION = 0.25f;
const QString DEFAULT_FACESHIFT_HOSTNAME = "localhost";
const float DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER = 1.0f;
const int ONE_SECOND_OF_FRAMES = 60;
const int FIVE_SECONDS_OF_FRAMES = 5 * ONE_SECOND_OF_FRAMES;
const QString CONSOLE_TITLE = "Scripting Console";
const float CONSOLE_WINDOW_OPACITY = 0.95f;
const int CONSOLE_WIDTH = 800;
const int CONSOLE_HEIGHT = 200;
Menu::Menu() :
_actionHash(),
_receivedAudioStreamSettings(),
_bandwidthDialog(NULL),
_fieldOfView(DEFAULT_FIELD_OF_VIEW_DEGREES),
_realWorldFieldOfView(DEFAULT_REAL_WORLD_FIELD_OF_VIEW_DEGREES),
_faceshiftEyeDeflection(DEFAULT_FACESHIFT_EYE_DEFLECTION),
_faceshiftHostname(DEFAULT_FACESHIFT_HOSTNAME),
_jsConsole(NULL),
_octreeStatsDialog(NULL),
_lodToolsDialog(NULL),
_hmdToolsDialog(NULL),
_newLocationDialog(NULL),
_userLocationsDialog(NULL),
#if defined(Q_OS_MAC) || defined(Q_OS_WIN)
_speechRecognizer(),
#endif
_octreeSizeScale(DEFAULT_OCTREE_SIZE_SCALE),
_oculusUIAngularSize(DEFAULT_OCULUS_UI_ANGULAR_SIZE),
_sixenseReticleMoveSpeed(DEFAULT_SIXENSE_RETICLE_MOVE_SPEED),
_invertSixenseButtons(DEFAULT_INVERT_SIXENSE_MOUSE_BUTTONS),
_automaticAvatarLOD(true),
_avatarLODDecreaseFPS(DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS),
_avatarLODIncreaseFPS(ADJUST_LOD_UP_FPS),
_avatarLODDistanceMultiplier(DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER),
_boundaryLevelAdjust(0),
_maxOctreePacketsPerSecond(DEFAULT_MAX_OCTREE_PPS),
_lastAdjust(usecTimestampNow()),
_lastAvatarDetailDrop(usecTimestampNow()),
_fpsAverage(FIVE_SECONDS_OF_FRAMES),
_fastFPSAverage(ONE_SECOND_OF_FRAMES),
_loginAction(NULL),
_preferencesDialog(NULL),
_loginDialog(NULL),
_hasLoginDialogDisplayed(false),
_snapshotsLocation(),
_scriptsLocation(),
_walletPrivateKey(),
_shouldRenderTableNeedsRebuilding(true)
_lastAvatarDetailDrop(usecTimestampNow())
{
Application *appInstance = Application::getInstance();
@ -492,6 +450,7 @@ Menu::Menu() :
false,
&UserActivityLogger::getInstance(),
SLOT(disable(bool)));
addActionToQMenuAndActionHash(networkMenu, MenuOption::CachesSize, 0, this, SLOT(cachesSizeDialog()));
addActionToQMenuAndActionHash(developerMenu, MenuOption::WalletPrivateKey, 0, this, SLOT(changePrivateKey()));
@ -619,15 +578,6 @@ Menu::Menu() :
#endif
}
Menu::~Menu() {
bandwidthDetailsClosed();
octreeStatsDetailsClosed();
if (_hmdToolsDialog) {
delete _hmdToolsDialog;
_hmdToolsDialog = NULL;
}
}
void Menu::loadSettings(QSettings* settings) {
bool lockedSettings = false;
if (!settings) {
@ -1153,7 +1103,7 @@ void Menu::bandwidthDetails() {
if (! _bandwidthDialog) {
_bandwidthDialog = new BandwidthDialog(DependencyManager::get<GLCanvas>().data(),
Application::getInstance()->getBandwidthMeter());
connect(_bandwidthDialog, SIGNAL(closed()), SLOT(bandwidthDetailsClosed()));
connect(_bandwidthDialog, SIGNAL(closed()), _bandwidthDialog, SLOT(deleteLater()));
_bandwidthDialog->show();
@ -1253,18 +1203,11 @@ void Menu::audioMuteToggled() {
}
}
void Menu::bandwidthDetailsClosed() {
if (_bandwidthDialog) {
delete _bandwidthDialog;
_bandwidthDialog = NULL;
}
}
void Menu::octreeStatsDetails() {
if (!_octreeStatsDialog) {
_octreeStatsDialog = new OctreeStatsDialog(DependencyManager::get<GLCanvas>().data(),
Application::getInstance()->getOcteeSceneStats());
connect(_octreeStatsDialog, SIGNAL(closed()), SLOT(octreeStatsDetailsClosed()));
connect(_octreeStatsDialog, SIGNAL(closed()), _octreeStatsDialog, SLOT(deleteLater()));
_octreeStatsDialog->show();
if (_hmdToolsDialog) {
_hmdToolsDialog->watchWindow(_octreeStatsDialog->windowHandle());
@ -1273,13 +1216,6 @@ void Menu::octreeStatsDetails() {
_octreeStatsDialog->raise();
}
void Menu::octreeStatsDetailsClosed() {
if (_octreeStatsDialog) {
delete _octreeStatsDialog;
_octreeStatsDialog = NULL;
}
}
QString Menu::getLODFeedbackText() {
// determine granularity feedback
int boundaryLevelAdjust = getBoundaryLevelAdjust();
@ -1443,11 +1379,23 @@ bool Menu::shouldRenderMesh(float largestDimension, float distanceToCamera) {
return (distanceToCamera <= visibleDistanceAtClosestScale);
}
void Menu::cachesSizeDialog() {
qDebug() << "Caches size:" << _cachesSizeDialog.isNull();
if (!_cachesSizeDialog) {
_cachesSizeDialog = new CachesSizeDialog(DependencyManager::get<GLCanvas>().data());
connect(_cachesSizeDialog, SIGNAL(closed()), _cachesSizeDialog, SLOT(deleteLater()));
_cachesSizeDialog->show();
if (_hmdToolsDialog) {
_hmdToolsDialog->watchWindow(_cachesSizeDialog->windowHandle());
}
}
_cachesSizeDialog->raise();
}
void Menu::lodTools() {
if (!_lodToolsDialog) {
_lodToolsDialog = new LodToolsDialog(DependencyManager::get<GLCanvas>().data());
connect(_lodToolsDialog, SIGNAL(closed()), SLOT(lodToolsClosed()));
connect(_lodToolsDialog, SIGNAL(closed()), _lodToolsDialog, SLOT(deleteLater()));
_lodToolsDialog->show();
if (_hmdToolsDialog) {
_hmdToolsDialog->watchWindow(_lodToolsDialog->windowHandle());
@ -1456,13 +1404,6 @@ void Menu::lodTools() {
_lodToolsDialog->raise();
}
void Menu::lodToolsClosed() {
if (_lodToolsDialog) {
delete _lodToolsDialog;
_lodToolsDialog = NULL;
}
}
void Menu::hmdTools(bool showTools) {
if (showTools) {
if (!_hmdToolsDialog) {

115
interface/src/Menu.h
View file

@ -27,14 +27,13 @@
#include "SpeechRecognizer.h"
#endif
#include "ui/AddressBarDialog.h"
#include "devices/Faceshift.h"
#include "devices/SixenseManager.h"
#include "ui/ChatWindow.h"
#include "ui/DataWebDialog.h"
#include "ui/JSConsole.h"
#include "ui/LoginDialog.h"
#include "ui/PreferencesDialog.h"
#include "ui/ScriptEditorWindow.h"
// Make an LOD handler class and move everything overthere
const float ADJUST_LOD_DOWN_FPS = 40.0;
const float ADJUST_LOD_UP_FPS = 55.0;
const float DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS = 30.0f;
@ -50,26 +49,37 @@ const float ADJUST_LOD_MAX_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE;
const float MINIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER = 0.1f;
const float MAXIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER = 15.0f;
const float DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER = 1.0f;
const int ONE_SECOND_OF_FRAMES = 60;
const int FIVE_SECONDS_OF_FRAMES = 5 * ONE_SECOND_OF_FRAMES;
//////////////////////////////////////////////////////////
const float DEFAULT_OCULUS_UI_ANGULAR_SIZE = 72.0f;
const QString SETTINGS_ADDRESS_KEY = "address";
class QSettings;
class AddressBarDialog;
class AnimationsDialog;
class AttachmentsDialog;
class CachesSizeDialog;
class BandwidthDialog;
class DataWebDialog;
class HMDToolsDialog;
class LodToolsDialog;
class LoginDialog;
class OctreeStatsDialog;
class PreferencesDialog;
class MetavoxelEditor;
class MetavoxelNetworkSimulator;
class ChatWindow;
class OctreeStatsDialog;
class MenuItemProperties;
class Menu : public QMenuBar {
Q_OBJECT
public:
static Menu* getInstance();
~Menu();
void triggerOption(const QString& menuOption);
QAction* getActionForOption(const QString& menuOption);
@ -159,6 +169,7 @@ public slots:
void showLoginForCurrentDomain();
void bandwidthDetails();
void octreeStatsDetails();
void cachesSizeDialog();
void lodTools();
void hmdTools(bool showTools);
void loadSettings(QSettings* settings = NULL);
@ -191,9 +202,6 @@ private slots:
void changePrivateKey();
void nameLocation();
void toggleLocationList();
void bandwidthDetailsClosed();
void octreeStatsDetailsClosed();
void lodToolsClosed();
void hmdToolsClosed();
void runTests();
void showMetavoxelEditor();
@ -242,54 +250,63 @@ private:
QHash<QString, QAction*> _actionHash;
InboundAudioStream::Settings _receivedAudioStreamSettings;
BandwidthDialog* _bandwidthDialog;
float _fieldOfView; /// in Degrees, doesn't apply to HMD like Oculus
float _realWorldFieldOfView; // The actual FOV set by the user's monitor size and view distance
float _faceshiftEyeDeflection;
QString _faceshiftHostname;
// in Degrees, doesn't apply to HMD like Oculus
float _fieldOfView = DEFAULT_FIELD_OF_VIEW_DEGREES;
// The actual FOV set by the user's monitor size and view distance
float _realWorldFieldOfView = DEFAULT_REAL_WORLD_FIELD_OF_VIEW_DEGREES;
float _faceshiftEyeDeflection = DEFAULT_FACESHIFT_EYE_DEFLECTION;
QString _faceshiftHostname = DEFAULT_FACESHIFT_HOSTNAME;
QDialog* _jsConsole = nullptr;
#if defined(Q_OS_MAC) || defined(Q_OS_WIN)
SpeechRecognizer _speechRecognizer;
#endif
float _octreeSizeScale = DEFAULT_OCTREE_SIZE_SCALE;
float _oculusUIAngularSize = DEFAULT_OCULUS_UI_ANGULAR_SIZE;
float _sixenseReticleMoveSpeed = DEFAULT_SIXENSE_RETICLE_MOVE_SPEED;
bool _invertSixenseButtons = DEFAULT_INVERT_SIXENSE_MOUSE_BUTTONS;
bool _hasLoginDialogDisplayed = false;
bool _automaticAvatarLOD = true;
float _avatarLODDecreaseFPS = DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS;
float _avatarLODIncreaseFPS = ADJUST_LOD_UP_FPS;
float _avatarLODDistanceMultiplier = DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER;
int _boundaryLevelAdjust = 0;
int _maxOctreePacketsPerSecond = DEFAULT_MAX_OCTREE_PPS;
quint64 _lastAdjust;
quint64 _lastAvatarDetailDrop;
SimpleMovingAverage _fpsAverage = FIVE_SECONDS_OF_FRAMES;
SimpleMovingAverage _fastFPSAverage = ONE_SECOND_OF_FRAMES;
QPointer<AddressBarDialog> _addressBarDialog;
QPointer<AnimationsDialog> _animationsDialog;
QPointer<AttachmentsDialog> _attachmentsDialog;
QPointer<BandwidthDialog> _bandwidthDialog;
QPointer<CachesSizeDialog> _cachesSizeDialog;
QPointer<DataWebDialog> _newLocationDialog;
QPointer<DataWebDialog> _userLocationsDialog;
QPointer<HMDToolsDialog> _hmdToolsDialog;
QPointer<LodToolsDialog> _lodToolsDialog;
QPointer<LoginDialog> _loginDialog;
QPointer<OctreeStatsDialog> _octreeStatsDialog;
QPointer<PreferencesDialog> _preferencesDialog;
QPointer<MetavoxelEditor> _MetavoxelEditor;
QPointer<MetavoxelNetworkSimulator> _metavoxelNetworkSimulator;
QPointer<ScriptEditorWindow> _ScriptEditor;
QPointer<ChatWindow> _chatWindow;
QDialog* _jsConsole;
OctreeStatsDialog* _octreeStatsDialog;
LodToolsDialog* _lodToolsDialog;
HMDToolsDialog* _hmdToolsDialog;
QPointer<DataWebDialog> _newLocationDialog;
QPointer<DataWebDialog> _userLocationsDialog;
#if defined(Q_OS_MAC) || defined(Q_OS_WIN)
SpeechRecognizer _speechRecognizer;
#endif
float _octreeSizeScale;
float _oculusUIAngularSize;
float _sixenseReticleMoveSpeed;
bool _invertSixenseButtons;
bool _automaticAvatarLOD;
float _avatarLODDecreaseFPS;
float _avatarLODIncreaseFPS;
float _avatarLODDistanceMultiplier;
int _boundaryLevelAdjust;
int _maxOctreePacketsPerSecond;
QString replaceLastOccurrence(QChar search, QChar replace, QString string);
quint64 _lastAdjust;
quint64 _lastAvatarDetailDrop;
SimpleMovingAverage _fpsAverage;
SimpleMovingAverage _fastFPSAverage;
QAction* _loginAction;
QPointer<PreferencesDialog> _preferencesDialog;
QPointer<AttachmentsDialog> _attachmentsDialog;
QPointer<AnimationsDialog> _animationsDialog;
QPointer<AddressBarDialog> _addressBarDialog;
QPointer<LoginDialog> _loginDialog;
bool _hasLoginDialogDisplayed;
QAction* _chatAction;
QAction* _loginAction = nullptr;
QAction* _chatAction = nullptr;
QString _snapshotsLocation;
QString _scriptsLocation;
QByteArray _walletPrivateKey;
bool _shouldRenderTableNeedsRebuilding;
bool _shouldRenderTableNeedsRebuilding = true;
QMap<float, float> _shouldRenderTable;
};
namespace MenuOption {
@ -318,6 +335,7 @@ namespace MenuOption {
const QString BandwidthDetails = "Bandwidth Details";
const QString BlueSpeechSphere = "Blue Sphere While Speaking";
const QString CascadedShadows = "Cascaded";
const QString CachesSize = "Caches Size";
const QString Chat = "Chat...";
const QString ChatCircling = "Chat Circling";
const QString CollideAsRagdoll = "Collide With Self (Ragdoll)";
@ -406,7 +424,6 @@ namespace MenuOption {
const QString RenderTargetFramerate40 = "40";
const QString RenderTargetFramerate30 = "30";
const QString RenderTargetFramerateVSyncOn = "V-Sync On";
const QString RenderResolution = "Scale Resolution";
const QString RenderResolutionOne = "1";
const QString RenderResolutionTwoThird = "2/3";

1
interface/src/ModelUploader.cpp
View file

@ -55,7 +55,6 @@ static const QString MODEL_URL = "/api/v1/models";
static const QString SETTING_NAME = "LastModelUploadLocation";
static const long long BYTES_PER_MEGABYTES = 1024 * 1024;
static const unsigned long long MAX_SIZE = 50 * 1024 * BYTES_PER_MEGABYTES; // 50 GB (Virtually remove limit)
static const int MAX_TEXTURE_SIZE = 1024;
static const int TIMEOUT = 1000;

3
interface/src/devices/Faceshift.h
View file

@ -23,6 +23,9 @@
#include "FaceTracker.h"
const float DEFAULT_FACESHIFT_EYE_DEFLECTION = 0.25f;
const QString DEFAULT_FACESHIFT_HOSTNAME = "localhost";
/// Handles interaction with the Faceshift software, which provides head position/orientation and facial features.
class Faceshift : public FaceTracker {
Q_OBJECT

1
interface/src/devices/OculusManager.cpp
View file

@ -13,6 +13,7 @@
#include "InterfaceConfig.h"
#include "OculusManager.h"
#include "ui/overlays/Text3DOverlay.h"
#include <QDesktopWidget>
#include <QGuiApplication>

5
interface/src/devices/OculusManager.h
View file

@ -19,12 +19,9 @@
#include <ProgramObject.h>
#include "ui/overlays/Text3DOverlay.h"
const float DEFAULT_OCULUS_UI_ANGULAR_SIZE = 72.0f;
class Camera;
class PalmData;
class Text3DOverlay;
/// Handles interaction with the Oculus Rift.
class OculusManager {

2
interface/src/devices/SixenseManager.h
View file

@ -25,6 +25,8 @@
#endif
class PalmData;
const unsigned int BUTTON_0 = 1U << 0; // the skinny button between 1 and 2
const unsigned int BUTTON_1 = 1U << 5;
const unsigned int BUTTON_2 = 1U << 6;

1
interface/src/ui/ApplicationOverlay.h
View file

@ -12,6 +12,7 @@
#ifndef hifi_ApplicationOverlay_h
#define hifi_ApplicationOverlay_h
class Camera;
class Overlays;
class QOpenGLFramebufferObject;

85
interface/src/ui/CachesSizeDialog.cpp Normal file
View file

@ -0,0 +1,85 @@
//
// CachesSizeDialog.cpp
//
//
// Created by Clement on 1/12/15.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include <QDoubleSpinBox>
#include <QFormLayout>
#include <QPushButton>
#include <AnimationCache.h>
#include <DependencyManager.h>
#include <GeometryCache.h>
#include <ScriptCache.h>
#include <SoundCache.h>
#include <TextureCache.h>
#include "CachesSizeDialog.h"
QDoubleSpinBox* createDoubleSpinBox(QWidget* parent) {
QDoubleSpinBox* box = new QDoubleSpinBox(parent);
box->setDecimals(0);
box->setRange(MIN_UNUSED_MAX_SIZE / BYTES_PER_MEGABYTES, MAX_UNUSED_MAX_SIZE / BYTES_PER_MEGABYTES);
return box;
}
CachesSizeDialog::CachesSizeDialog(QWidget* parent) :
QDialog(parent, Qt::Window | Qt::WindowCloseButtonHint)
{
setWindowTitle("Caches Size");
// Create layouter
QFormLayout* form = new QFormLayout(this);
setLayout(form);
form->addRow("Animations cache size (MB):", _animations = createDoubleSpinBox(this));
form->addRow("Geometries cache size (MB):", _geometries = createDoubleSpinBox(this));
form->addRow("Scripts cache size (MB):", _scripts = createDoubleSpinBox(this));
form->addRow("Sounds cache size (MB):", _sounds = createDoubleSpinBox(this));
form->addRow("Textures cache size (MB):", _textures = createDoubleSpinBox(this));
resetClicked(true);
// Add a button to reset
QPushButton* confirmButton = new QPushButton("Confirm", this);
QPushButton* resetButton = new QPushButton("Reset", this);
form->addRow(confirmButton, resetButton);
connect(confirmButton, SIGNAL(clicked(bool)), this, SLOT(confirmClicked(bool)));
connect(resetButton, SIGNAL(clicked(bool)), this, SLOT(resetClicked(bool)));
}
void CachesSizeDialog::confirmClicked(bool checked) {
DependencyManager::get<AnimationCache>()->setUnusedResourceCacheSize(_animations->value() * BYTES_PER_MEGABYTES);
DependencyManager::get<GeometryCache>()->setUnusedResourceCacheSize(_geometries->value() * BYTES_PER_MEGABYTES);
ScriptCache::getInstance()->setUnusedResourceCacheSize(_scripts->value() * BYTES_PER_MEGABYTES);
SoundCache::getInstance().setUnusedResourceCacheSize(_sounds->value() * BYTES_PER_MEGABYTES);
DependencyManager::get<TextureCache>()->setUnusedResourceCacheSize(_textures->value() * BYTES_PER_MEGABYTES);
QDialog::close();
}
void CachesSizeDialog::resetClicked(bool checked) {
_animations->setValue(DependencyManager::get<AnimationCache>()->getUnusedResourceCacheSize() / BYTES_PER_MEGABYTES);
_geometries->setValue(DependencyManager::get<GeometryCache>()->getUnusedResourceCacheSize() / BYTES_PER_MEGABYTES);
_scripts->setValue(ScriptCache::getInstance()->getUnusedResourceCacheSize() / BYTES_PER_MEGABYTES);
_sounds->setValue(SoundCache::getInstance().getUnusedResourceCacheSize() / BYTES_PER_MEGABYTES);
_textures->setValue(DependencyManager::get<TextureCache>()->getUnusedResourceCacheSize() / BYTES_PER_MEGABYTES);
}
void CachesSizeDialog::reject() {
// Just regularly close upon ESC
QDialog::close();
}
void CachesSizeDialog::closeEvent(QCloseEvent* event) {
QDialog::closeEvent(event);
emit closed();
}

45
interface/src/ui/CachesSizeDialog.h Normal file
View file

@ -0,0 +1,45 @@
//
// CachesSizeDialog.h
//
//
// Created by Clement on 1/12/15.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_CachesSizeDialog_h
#define hifi_CachesSizeDialog_h
#include <QDialog>
class QDoubleSpinBox;
class CachesSizeDialog : public QDialog {
Q_OBJECT
public:
// Sets up the UI
CachesSizeDialog(QWidget* parent);
signals:
void closed();
public slots:
void reject();
void confirmClicked(bool checked);
void resetClicked(bool checked);
protected:
// Emits a 'closed' signal when this dialog is closed.
void closeEvent(QCloseEvent* event);
private:
QDoubleSpinBox* _animations = nullptr;
QDoubleSpinBox* _geometries = nullptr;
QDoubleSpinBox* _scripts = nullptr;
QDoubleSpinBox* _sounds = nullptr;
QDoubleSpinBox* _textures = nullptr;
};
#endif // hifi_CachesSizeDialog_h

5
interface/src/ui/JSConsole.h
View file

@ -20,6 +20,11 @@
#include "ui_console.h"
#include "ScriptEngine.h"
const QString CONSOLE_TITLE = "Scripting Console";
const float CONSOLE_WINDOW_OPACITY = 0.95f;
const int CONSOLE_WIDTH = 800;
const int CONSOLE_HEIGHT = 200;
class JSConsole : public QWidget {
Q_OBJECT
public:

26
interface/src/ui/LodToolsDialog.cpp
View file

@ -30,9 +30,9 @@ LodToolsDialog::LodToolsDialog(QWidget* parent) :
this->setWindowTitle("LOD Tools");
// Create layouter
QFormLayout* form = new QFormLayout();
QFormLayout* form = new QFormLayout(this);
_lodSize = new QSlider(Qt::Horizontal);
_lodSize = new QSlider(Qt::Horizontal, this);
const int MAX_LOD_SIZE = MAX_LOD_SIZE_MULTIPLIER;
const int MIN_LOD_SIZE = 0;
const int STEP_LOD_SIZE = 1;
@ -50,7 +50,7 @@ LodToolsDialog::LodToolsDialog(QWidget* parent) :
form->addRow("LOD Size Scale:", _lodSize);
connect(_lodSize,SIGNAL(valueChanged(int)),this,SLOT(sizeScaleValueChanged(int)));
_boundaryLevelAdjust = new QSlider(Qt::Horizontal);
_boundaryLevelAdjust = new QSlider(Qt::Horizontal, this);
const int MAX_ADJUST = 10;
const int MIN_ADJUST = 0;
const int STEP_ADJUST = 1;
@ -66,7 +66,7 @@ LodToolsDialog::LodToolsDialog(QWidget* parent) :
connect(_boundaryLevelAdjust,SIGNAL(valueChanged(int)),this,SLOT(boundaryLevelValueChanged(int)));
// Create a label with feedback...
_feedback = new QLabel();
_feedback = new QLabel(this);
QPalette palette = _feedback->palette();
const unsigned redish = 0xfff00000;
palette.setColor(QPalette::WindowText, QColor::fromRgb(redish));
@ -76,21 +76,21 @@ LodToolsDialog::LodToolsDialog(QWidget* parent) :
_feedback->setFixedWidth(FEEDBACK_WIDTH);
form->addRow("You can see... ", _feedback);
form->addRow("Automatic Avatar LOD Adjustment:", _automaticAvatarLOD = new QCheckBox());
form->addRow("Automatic Avatar LOD Adjustment:", _automaticAvatarLOD = new QCheckBox(this));
_automaticAvatarLOD->setChecked(Menu::getInstance()->getAutomaticAvatarLOD());
connect(_automaticAvatarLOD, SIGNAL(toggled(bool)), SLOT(updateAvatarLODControls()));
form->addRow("Decrease Avatar LOD Below FPS:", _avatarLODDecreaseFPS = new QDoubleSpinBox());
form->addRow("Decrease Avatar LOD Below FPS:", _avatarLODDecreaseFPS = new QDoubleSpinBox(this));
_avatarLODDecreaseFPS->setValue(Menu::getInstance()->getAvatarLODDecreaseFPS());
_avatarLODDecreaseFPS->setDecimals(0);
connect(_avatarLODDecreaseFPS, SIGNAL(valueChanged(double)), SLOT(updateAvatarLODValues()));
form->addRow("Increase Avatar LOD Above FPS:", _avatarLODIncreaseFPS = new QDoubleSpinBox());
form->addRow("Increase Avatar LOD Above FPS:", _avatarLODIncreaseFPS = new QDoubleSpinBox(this));
_avatarLODIncreaseFPS->setValue(Menu::getInstance()->getAvatarLODIncreaseFPS());
_avatarLODIncreaseFPS->setDecimals(0);
connect(_avatarLODIncreaseFPS, SIGNAL(valueChanged(double)), SLOT(updateAvatarLODValues()));
form->addRow("Avatar LOD:", _avatarLOD = new QDoubleSpinBox());
form->addRow("Avatar LOD:", _avatarLOD = new QDoubleSpinBox(this));
_avatarLOD->setDecimals(3);
_avatarLOD->setRange(1.0 / MAXIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER, 1.0 / MINIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER);
_avatarLOD->setSingleStep(0.001);
@ -98,21 +98,15 @@ LodToolsDialog::LodToolsDialog(QWidget* parent) :
connect(_avatarLOD, SIGNAL(valueChanged(double)), SLOT(updateAvatarLODValues()));
// Add a button to reset
QPushButton* resetButton = new QPushButton("Reset");
QPushButton* resetButton = new QPushButton("Reset", this);
form->addRow("", resetButton);
connect(resetButton,SIGNAL(clicked(bool)),this,SLOT(resetClicked(bool)));
connect(resetButton, SIGNAL(clicked(bool)), this, SLOT(resetClicked(bool)));
this->QDialog::setLayout(form);
updateAvatarLODControls();
}
LodToolsDialog::~LodToolsDialog() {
delete _feedback;
delete _lodSize;
delete _boundaryLevelAdjust;
}
void LodToolsDialog::reloadSliders() {
_lodSize->setValue(Menu::getInstance()->getOctreeSizeScale() / TREE_SCALE);
_boundaryLevelAdjust->setValue(Menu::getInstance()->getBoundaryLevelAdjust());

7
interface/src/ui/LodToolsDialog.h
View file

@ -13,18 +13,17 @@
#define hifi_LodToolsDialog_h
#include <QDialog>
#include <QLabel>
#include <QSlider>
class QCheckBox;
class QDoubleSpinBox;
class QLabel;
class QSlider;
class LodToolsDialog : public QDialog {
Q_OBJECT
public:
// Sets up the UI
LodToolsDialog(QWidget* parent);
~LodToolsDialog();
signals:
void closed();
@ -41,7 +40,7 @@ public slots:
protected:
// Emits a 'closed' signal when this dialog is closed.
void closeEvent(QCloseEvent*);
void closeEvent(QCloseEvent* event);
private:
QSlider* _lodSize;

2
interface/src/ui/ScriptEditorWindow.cpp
View file

@ -31,8 +31,6 @@
#include "FlowLayout.h"
#include "JSConsole.h"
const int CONSOLE_HEIGHT = 150;
ScriptEditorWindow::ScriptEditorWindow() :
_ScriptEditorWindowUI(new Ui::ScriptEditorWindow),
_loadMenu(new QMenu),

5
libraries/animation/src/AnimationCache.cpp
View file

@ -17,7 +17,10 @@
static int animationPointerMetaTypeId = qRegisterMetaType<AnimationPointer>();
AnimationCache::AnimationCache(QObject* parent) :
ResourceCache(parent) {
ResourceCache(parent)
{
const qint64 ANIMATION_DEFAULT_UNUSED_MAX_SIZE = 50 * BYTES_PER_MEGABYTES;
setUnusedResourceCacheSize(ANIMATION_DEFAULT_UNUSED_MAX_SIZE);
}
AnimationPointer AnimationCache::getAnimation(const QUrl& url) {

3
libraries/audio/src/SoundCache.cpp
View file

@ -23,7 +23,8 @@ SoundCache& SoundCache::getInstance() {
SoundCache::SoundCache(QObject* parent) :
ResourceCache(parent)
{
const qint64 SOUND_DEFAULT_UNUSED_MAX_SIZE = 50 * BYTES_PER_MEGABYTES;
setUnusedResourceCacheSize(SOUND_DEFAULT_UNUSED_MAX_SIZE);
}
SharedSoundPointer SoundCache::getSound(const QUrl& url) {

7
libraries/metavoxels/src/ScriptCache.cpp
View file

@ -109,9 +109,12 @@ ScriptCache* ScriptCache::getInstance() {
}
ScriptCache::ScriptCache() :
_engine(NULL) {
_engine(NULL)
{
setEngine(new QScriptEngine(this));
const qint64 SCRIPT_DEFAULT_UNUSED_MAX_SIZE = 50 * BYTES_PER_MEGABYTES;
setUnusedResourceCacheSize(SCRIPT_DEFAULT_UNUSED_MAX_SIZE);
}
void ScriptCache::setEngine(QScriptEngine* engine) {

73
libraries/networking/src/ResourceCache.cpp
View file

@ -20,11 +20,12 @@
#include "ResourceCache.h"
#define clamp(x, min, max) (((x) < (min)) ? (min) :\
(((x) > (max)) ? (max) :\
(x)))
ResourceCache::ResourceCache(QObject* parent) :
QObject(parent),
_lastLRUKey(0)
{
QObject(parent) {
}
ResourceCache::~ResourceCache() {
@ -32,7 +33,7 @@ ResourceCache::~ResourceCache() {
// list on destruction, so keep clearing until there are no references left
while (!_unusedResources.isEmpty()) {
foreach (const QSharedPointer<Resource>& resource, _unusedResources) {
resource->setCache(NULL);
resource->setCache(nullptr);
}
_unusedResources.clear();
}
@ -72,37 +73,40 @@ QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl&
return resource;
}
void ResourceCache::setUnusedResourceCacheSize(qint64 unusedResourcesMaxSize) {
_unusedResourcesMaxSize = clamp(unusedResourcesMaxSize, MIN_UNUSED_MAX_SIZE, MAX_UNUSED_MAX_SIZE);
reserveUnusedResource(0);
}
void ResourceCache::addUnusedResource(const QSharedPointer<Resource>& resource) {
static const int BYTES_PER_MEGABYTES = 1024 * 1024;
const int RETAINED_RESOURCE_COUNT = 50;
const int RETAINED_RESOURCE_SIZE = 100 * BYTES_PER_MEGABYTES;
while (_unusedResourcesTotalBytes + resource->getBytesTotal() > RETAINED_RESOURCE_SIZE &&
!_unusedResources.empty()) {
// unload the oldest resource
QMap<int, QSharedPointer<Resource> >::iterator it = _unusedResources.begin();
_unusedResourcesTotalBytes -= it.value()->getBytesTotal();
it.value()->setCache(NULL);
_unusedResources.erase(it);
if (resource->getBytesTotal() > _unusedResourcesMaxSize) {
// If it doesn't fit anyway, let's leave whatever is already in the cache.
resource->setCache(nullptr);
return;
}
reserveUnusedResource(resource->getBytesTotal());
if (_unusedResources.size() > RETAINED_RESOURCE_COUNT) {
// unload the oldest resource
QMap<int, QSharedPointer<Resource> >::iterator it = _unusedResources.begin();
it.value()->setCache(NULL);
_unusedResources.erase(it);
}
resource->setLRUKey(++_lastLRUKey);
_unusedResources.insert(resource->getLRUKey(), resource);
_unusedResourcesTotalBytes += resource->getBytesTotal();
_unusedResourcesSize += resource->getBytesTotal();
}
void ResourceCache::removeUnusedResource(const QSharedPointer<Resource>& resource) {
if (_unusedResources.contains(resource->getLRUKey())) {
_unusedResources.remove(resource->getLRUKey());
_unusedResourcesTotalBytes -= resource->getBytesTotal();
_unusedResourcesSize -= resource->getBytesTotal();
}
}
void ResourceCache::reserveUnusedResource(qint64 resourceSize) {
while (!_unusedResources.empty() &&
_unusedResourcesSize + resourceSize > _unusedResourcesMaxSize) {
// unload the oldest resource
QMap<int, QSharedPointer<Resource> >::iterator it = _unusedResources.begin();
_unusedResourcesSize -= it.value()->getBytesTotal();
it.value()->setCache(nullptr);
_unusedResources.erase(it);
}
}
@ -150,9 +154,7 @@ QList<Resource*> ResourceCache::_loadingRequests;
Resource::Resource(const QUrl& url, bool delayLoad) :
_url(url),
_request(url),
_lruKey(0),
_reply(NULL) {
_request(url) {
init();
@ -168,6 +170,7 @@ Resource::~Resource() {
if (_reply) {
ResourceCache::requestCompleted(this);
delete _reply;
_reply = nullptr;
}
}
@ -213,13 +216,13 @@ float Resource::getLoadPriority() {
}
void Resource::refresh() {
if (_reply == NULL && !(_loaded || _failedToLoad)) {
if (_reply == nullptr && !(_loaded || _failedToLoad)) {
return;
}
if (_reply) {
ResourceCache::requestCompleted(this);
delete _reply;
_reply = NULL;
_reply = nullptr;
}
init();
_request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::AlwaysNetwork);
@ -295,10 +298,10 @@ void Resource::handleDownloadProgress(qint64 bytesReceived, qint64 bytesTotal) {
}
_reply->disconnect(this);
QNetworkReply* reply = _reply;
_reply = NULL;
_reply = nullptr;
_replyTimer->disconnect(this);
_replyTimer->deleteLater();
_replyTimer = NULL;
_replyTimer = nullptr;
ResourceCache::requestCompleted(this);
downloadFinished(reply);
@ -330,10 +333,10 @@ void Resource::makeRequest() {
void Resource::handleReplyError(QNetworkReply::NetworkError error, QDebug debug) {
_reply->disconnect(this);
_reply->deleteLater();
_reply = NULL;
_reply = nullptr;
_replyTimer->disconnect(this);
_replyTimer->deleteLater();
_replyTimer = NULL;
_replyTimer = nullptr;
ResourceCache::requestCompleted(this);
// retry for certain types of failures

43
libraries/networking/src/ResourceCache.h
View file

@ -27,6 +27,19 @@ class QTimer;
class Resource;
static const qint64 BYTES_PER_MEGABYTES = 1024 * 1024;
static const qint64 BYTES_PER_GIGABYTES = 1024 * BYTES_PER_MEGABYTES;
// Windows can have troubles allocating that much memory in ram sometimes
// so default cache size at 100 MB on windows (1GB otherwise)
#ifdef Q_OS_WIN32
static const qint64 DEFAULT_UNUSED_MAX_SIZE = 100 * BYTES_PER_MEGABYTES;
#else
static const qint64 DEFAULT_UNUSED_MAX_SIZE = 1024 * BYTES_PER_MEGABYTES;
#endif
static const qint64 MIN_UNUSED_MAX_SIZE = 0;
static const qint64 MAX_UNUSED_MAX_SIZE = 10 * BYTES_PER_GIGABYTES;
/// Base class for resource caches.
class ResourceCache : public QObject {
Q_OBJECT
@ -34,6 +47,9 @@ class ResourceCache : public QObject {
public:
static void setRequestLimit(int limit) { _requestLimit = limit; }
static int getRequestLimit() { return _requestLimit; }
void setUnusedResourceCacheSize(qint64 unusedResourcesMaxSize);
qint64 getUnusedResourceCacheSize() const { return _unusedResourcesMaxSize; }
static const QList<Resource*>& getLoadingRequests() { return _loadingRequests; }
@ -45,8 +61,8 @@ public:
void refresh(const QUrl& url);
protected:
qint64 _unusedResourcesTotalBytes = 0;
qint64 _unusedResourcesMaxSize = DEFAULT_UNUSED_MAX_SIZE;
qint64 _unusedResourcesSize = 0;
QMap<int, QSharedPointer<Resource> > _unusedResources;
/// Loads a resource from the specified URL.
@ -62,16 +78,16 @@ protected:
void addUnusedResource(const QSharedPointer<Resource>& resource);
void removeUnusedResource(const QSharedPointer<Resource>& resource);
void reserveUnusedResource(qint64 resourceSize);
static void attemptRequest(Resource* resource);
static void requestCompleted(Resource* resource);
private:
friend class Resource;
QHash<QUrl, QWeakPointer<Resource> > _resources;
int _lastLRUKey;
int _lastLRUKey = 0;
static int _requestLimit;
static QList<QPointer<Resource> > _pendingRequests;
@ -152,9 +168,9 @@ protected:
QUrl _url;
QNetworkRequest _request;
bool _startedLoading;
bool _failedToLoad;
bool _loaded;
bool _startedLoading = false;
bool _failedToLoad = false;
bool _loaded = false;
QHash<QPointer<QObject>, float> _loadPriorities;
QWeakPointer<Resource> _self;
QPointer<ResourceCache> _cache;
@ -176,13 +192,12 @@ private:
friend class ResourceCache;
int _lruKey;
QNetworkReply* _reply;
QTimer* _replyTimer;
int _index;
qint64 _bytesReceived;
qint64 _bytesTotal;
int _attempts;
int _lruKey = 0;
QNetworkReply* _reply = nullptr;
QTimer* _replyTimer = nullptr;
qint64 _bytesReceived = 0;
qint64 _bytesTotal = 0;
int _attempts = 0;
};
uint qHash(const QPointer<QObject>& value, uint seed = 0);

2
libraries/render-utils/src/GeometryCache.cpp
View file

@ -30,6 +30,8 @@ const int GeometryCache::UNKNOWN_ID = -1;
GeometryCache::GeometryCache() :
_nextID(0)
{
const qint64 GEOMETRY_DEFAULT_UNUSED_MAX_SIZE = DEFAULT_UNUSED_MAX_SIZE;
setUnusedResourceCacheSize(GEOMETRY_DEFAULT_UNUSED_MAX_SIZE);
}
GeometryCache::~GeometryCache() {

4
libraries/render-utils/src/TextureCache.cpp
View file

@ -39,6 +39,8 @@ TextureCache::TextureCache() :
_frameBufferSize(100, 100),
_associatedWidget(NULL)
{
const qint64 TEXTURE_DEFAULT_UNUSED_MAX_SIZE = DEFAULT_UNUSED_MAX_SIZE;
setUnusedResourceCacheSize(TEXTURE_DEFAULT_UNUSED_MAX_SIZE);
}
TextureCache::~TextureCache() {
@ -203,7 +205,7 @@ NetworkTexturePointer TextureCache::getTexture(const QUrl& url, TextureType type
texture->setCache(this);
_dilatableNetworkTextures.insert(url, texture);
} else {
_unusedResources.remove(texture->getLRUKey());
removeUnusedResource(texture);
}
return texture;
}

2
libraries/script-engine/src/EventTypes.h
View file

@ -12,7 +12,7 @@
#ifndef hifi_EventTypes_h
#define hifi_EventTypes_h
#include <qscriptengine.h>
#include <QScriptEngine>
void registerEventTypes(QScriptEngine* engine);

2
libraries/script-engine/src/KeyEvent.h
View file

@ -13,7 +13,7 @@
#define hifi_KeyEvent_h
#include <QKeyEvent>
#include <qscriptvalue.h>
#include <QScriptValue>
class KeyEvent {
public:

2
libraries/shared/src/SharedUtil.h
View file

@ -19,7 +19,7 @@
#include <unistd.h> // not on windows, not needed for mac or windows
#endif
#include <QtCore/QDebug>
#include <QDebug>
const int BYTES_PER_COLOR = 3;
const int BYTES_PER_FLAGS = 1;