diff --git a/cmake/modules/MacOSXBundleInfo.plist.in b/cmake/modules/MacOSXBundleInfo.plist.in
new file mode 100644
index 0000000000..1682b6c022
--- /dev/null
+++ b/cmake/modules/MacOSXBundleInfo.plist.in
@@ -0,0 +1,47 @@
+
+
+
+
+ CFBundleDevelopmentRegion
+ English
+ CFBundleExecutable
+ ${MACOSX_BUNDLE_EXECUTABLE_NAME}
+ CFBundleGetInfoString
+ ${MACOSX_BUNDLE_INFO_STRING}
+ CFBundleIconFile
+ ${MACOSX_BUNDLE_ICON_FILE}
+ CFBundleIdentifier
+ ${MACOSX_BUNDLE_GUI_IDENTIFIER}
+ CFBundleInfoDictionaryVersion
+ 6.0
+ CFBundleLongVersionString
+ ${MACOSX_BUNDLE_LONG_VERSION_STRING}
+ CFBundleName
+ ${MACOSX_BUNDLE_BUNDLE_NAME}
+ CFBundlePackageType
+ APPL
+ CFBundleShortVersionString
+ ${MACOSX_BUNDLE_SHORT_VERSION_STRING}
+ CFBundleSignature
+ ????
+ CFBundleVersion
+ ${MACOSX_BUNDLE_BUNDLE_VERSION}
+ CSResourcesFileMapped
+
+ LSRequiresCarbon
+
+ NSHumanReadableCopyright
+ ${MACOSX_BUNDLE_COPYRIGHT}
+ CFBundleURLTypes
+
+
+ CFBundleURLName
+ ${MACOSX_BUNDLE_BUNDLE_NAME} URL
+ CFBundleURLSchemes
+
+ hifi
+
+
+
+
+
diff --git a/examples/overlaysExample.js b/examples/overlaysExample.js
new file mode 100644
index 0000000000..b57f82e7e9
--- /dev/null
+++ b/examples/overlaysExample.js
@@ -0,0 +1,279 @@
+//
+// overlaysExample.js
+// hifi
+//
+// Created by Brad Hefta-Gaub on 2/14/14.
+// Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+// This is an example script that demonstrates use of the Overlays class
+//
+//
+
+
+// The "Swatches" example of this script will create 9 different image overlays, that use the color feature to
+// display different colors as color swatches. The overlays can be clicked on, to change the "selectedSwatch" variable
+// and update the image used for the overlay so that it appears to have a selected indicator.
+// These are our colors...
+var swatchColors = new Array();
+swatchColors[0] = { red: 255, green: 0, blue: 0};
+swatchColors[1] = { red: 0, green: 255, blue: 0};
+swatchColors[2] = { red: 0, green: 0, blue: 255};
+swatchColors[3] = { red: 255, green: 255, blue: 0};
+swatchColors[4] = { red: 255, green: 0, blue: 255};
+swatchColors[5] = { red: 0, green: 255, blue: 255};
+swatchColors[6] = { red: 128, green: 128, blue: 128};
+swatchColors[7] = { red: 128, green: 0, blue: 0};
+swatchColors[8] = { red: 0, green: 240, blue: 240};
+
+// The location of the placement of these overlays
+var swatchesX = 100;
+var swatchesY = 200;
+
+// These will be our "overlay IDs"
+var swatches = new Array();
+var numberOfSwatches = 9;
+var selectedSwatch = 0;
+
+// create the overlays, position them in a row, set their colors, and for the selected one, use a different source image
+// location so that it displays the "selected" marker
+for (s = 0; s < numberOfSwatches; s++) {
+ var imageFromX = 12 + (s * 27);
+ var imageFromY = 0;
+ if (s == selectedSwatch) {
+ imageFromY = 55;
+ }
+
+ swatches[s] = Overlays.addOverlay("image", {
+ x: 100 + (30 * s),
+ y: 200,
+ width: 31,
+ height: 54,
+ subImage: { x: imageFromX, y: imageFromY, width: 30, height: 54 },
+ imageURL: "http://highfidelity-public.s3-us-west-1.amazonaws.com/images/testing-swatches.svg",
+ color: swatchColors[s],
+ alpha: 1
+ });
+}
+
+// This will create a text overlay that when you click on it, the text will change
+var text = Overlays.addOverlay("text", {
+ x: 200,
+ y: 100,
+ width: 150,
+ height: 50,
+ color: { red: 0, green: 0, blue: 0},
+ textColor: { red: 255, green: 0, blue: 0},
+ topMargin: 4,
+ leftMargin: 4,
+ text: "Here is some text.\nAnd a second line."
+ });
+
+// This will create an image overlay, which starts out as invisible
+var toolA = Overlays.addOverlay("image", {
+ x: 100,
+ y: 100,
+ width: 62,
+ height: 40,
+ subImage: { x: 0, y: 0, width: 62, height: 40 },
+ imageURL: "https://s3-us-west-1.amazonaws.com/highfidelity-public/images/hifi-interface-tools.svg",
+ color: { red: 255, green: 255, blue: 255},
+ visible: false
+ });
+
+// This will create a couple of image overlays that make a "slider", we will demonstrate how to trap mouse messages to
+// move the slider
+var slider = Overlays.addOverlay("image", {
+ // alternate form of expressing bounds
+ bounds: { x: 100, y: 300, width: 158, height: 35},
+ imageURL: "https://s3-us-west-1.amazonaws.com/highfidelity-public/images/slider.png",
+ color: { red: 255, green: 255, blue: 255},
+ alpha: 1
+ });
+
+// This is the thumb of our slider
+var minThumbX = 130;
+var maxThumbX = minThumbX + 65;
+var thumbX = (minThumbX + maxThumbX) / 2;
+var thumb = Overlays.addOverlay("image", {
+ x: thumbX,
+ y: 309,
+ width: 18,
+ height: 17,
+ imageURL: "https://s3-us-west-1.amazonaws.com/highfidelity-public/images/thumb.png",
+ color: { red: 255, green: 255, blue: 255},
+ alpha: 1
+ });
+
+
+// We will also demonstrate some 3D overlays. We will create a couple of cubes, spheres, and lines
+// our 3D cube that moves around...
+var cubePosition = { x: 2, y: 0, z: 2 };
+var cubeSize = 5;
+var cubeMove = 0.1;
+var minCubeX = 1;
+var maxCubeX = 20;
+
+var cube = Overlays.addOverlay("cube", {
+ position: cubePosition,
+ size: cubeSize,
+ color: { red: 255, green: 0, blue: 0},
+ alpha: 1,
+ solid: false
+ });
+
+var solidCubePosition = { x: 0, y: 5, z: 0 };
+var solidCubeSize = 2;
+var minSolidCubeX = 0;
+var maxSolidCubeX = 10;
+var solidCubeMove = 0.05;
+var solidCube = Overlays.addOverlay("cube", {
+ position: solidCubePosition,
+ size: solidCubeSize,
+ color: { red: 0, green: 255, blue: 0},
+ alpha: 1,
+ solid: true
+ });
+
+var spherePosition = { x: 5, y: 5, z: 5 };
+var sphereSize = 1;
+var minSphereSize = 0.5;
+var maxSphereSize = 10;
+var sphereSizeChange = 0.05;
+
+var sphere = Overlays.addOverlay("sphere", {
+ position: spherePosition,
+ size: sphereSize,
+ color: { red: 0, green: 0, blue: 255},
+ alpha: 1,
+ solid: false
+ });
+
+var line3d = Overlays.addOverlay("line3d", {
+ position: { x: 0, y: 0, z:0 },
+ end: { x: 10, y: 10, z:10 },
+ color: { red: 0, green: 255, blue: 255},
+ alpha: 1,
+ lineWidth: 5
+ });
+
+
+// When our script shuts down, we should clean up all of our overlays
+function scriptEnding() {
+ Overlays.deleteOverlay(toolA);
+ for (s = 0; s < numberOfSwatches; s++) {
+ Overlays.deleteOverlay(swatches[s]);
+ }
+ Overlays.deleteOverlay(thumb);
+ Overlays.deleteOverlay(slider);
+ Overlays.deleteOverlay(text);
+ Overlays.deleteOverlay(cube);
+ Overlays.deleteOverlay(solidCube);
+ Overlays.deleteOverlay(sphere);
+ Overlays.deleteOverlay(line3d);
+}
+Script.scriptEnding.connect(scriptEnding);
+
+
+var toolAVisible = false;
+var count = 0;
+
+// Our update() function is called at approximately 60fps, and we will use it to animate our various overlays
+function update() {
+ count++;
+
+ // every second or so, toggle the visibility our our blinking tool
+ if (count % 60 == 0) {
+ if (toolAVisible) {
+ toolAVisible = false;
+ } else {
+ toolAVisible = true;
+ }
+ Overlays.editOverlay(toolA, { visible: toolAVisible } );
+ }
+
+ // move our 3D cube
+ cubePosition.x += cubeMove;
+ cubePosition.z += cubeMove;
+ if (cubePosition.x > maxCubeX || cubePosition.x < minCubeX) {
+ cubeMove = cubeMove * -1;
+ }
+ Overlays.editOverlay(cube, { position: cubePosition } );
+
+ // move our solid 3D cube
+ solidCubePosition.x += solidCubeMove;
+ solidCubePosition.z += solidCubeMove;
+ if (solidCubePosition.x > maxSolidCubeX || solidCubePosition.x < minSolidCubeX) {
+ solidCubeMove = solidCubeMove * -1;
+ }
+ Overlays.editOverlay(solidCube, { position: solidCubePosition } );
+
+ // adjust our 3D sphere
+ sphereSize += sphereSizeChange;
+ if (sphereSize > maxSphereSize || sphereSize < minSphereSize) {
+ sphereSizeChange = sphereSizeChange * -1;
+ }
+ Overlays.editOverlay(sphere, { size: sphereSize, solid: (sphereSizeChange < 0) } );
+
+
+ // update our 3D line to go from origin to our avatar's position
+ Overlays.editOverlay(line3d, { end: MyAvatar.position } );
+}
+Script.willSendVisualDataCallback.connect(update);
+
+
+// The slider is handled in the mouse event callbacks.
+var movingSlider = false;
+var thumbClickOffsetX = 0;
+function mouseMoveEvent(event) {
+ if (movingSlider) {
+ newThumbX = event.x - thumbClickOffsetX;
+ if (newThumbX < minThumbX) {
+ newThumbX = minThumbX;
+ }
+ if (newThumbX > maxThumbX) {
+ newThumbX = maxThumbX;
+ }
+ Overlays.editOverlay(thumb, { x: newThumbX } );
+ }
+}
+
+// we also handle click detection in our mousePressEvent()
+function mousePressEvent(event) {
+ var clickedText = false;
+ var clickedOverlay = Overlays.getOverlayAtPoint({x: event.x, y: event.y});
+
+ // If the user clicked on the thumb, handle the slider logic
+ if (clickedOverlay == thumb) {
+ movingSlider = true;
+ thumbClickOffsetX = event.x - thumbX;
+
+ } else if (clickedOverlay == text) { // if the user clicked on the text, update text with where you clicked
+
+ Overlays.editOverlay(text, { text: "you clicked here:\n " + event.x + "," + event.y } );
+ clickedText = true;
+
+ } else { // if the user clicked on one of the color swatches, update the selectedSwatch
+
+ for (s = 0; s < numberOfSwatches; s++) {
+ if (clickedOverlay == swatches[s]) {
+ Overlays.editOverlay(swatches[selectedSwatch], { subImage: { y: 0 } } );
+ Overlays.editOverlay(swatches[s], { subImage: { y: 55 } } );
+ selectedSwatch = s;
+ }
+ }
+ }
+ if (!clickedText) { // if you didn't click on the text, then update the text accordningly
+ Overlays.editOverlay(text, { text: "you didn't click here" } );
+ }
+}
+
+function mouseReleaseEvent(event) {
+ if (movingSlider) {
+ movingSlider = false;
+ }
+}
+
+Controller.mouseMoveEvent.connect(mouseMoveEvent);
+Controller.mousePressEvent.connect(mousePressEvent);
+Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
+
diff --git a/interface/CMakeLists.txt b/interface/CMakeLists.txt
index e000efa695..c3f7ebc286 100644
--- a/interface/CMakeLists.txt
+++ b/interface/CMakeLists.txt
@@ -91,7 +91,13 @@ qt5_wrap_ui(QT_UI_HEADERS ${QT_UI_FILES})
set(INTERFACE_SRCS ${INTERFACE_SRCS} ${QT_UI_HEADERS})
if (APPLE)
+
+ # configure CMake to use a custom Info.plist
+ SET_TARGET_PROPERTIES( ${this_target} PROPERTIES MACOSX_BUNDLE_INFO_PLIST MacOSXBundleInfo.plist.in )
+
set(MACOSX_BUNDLE_BUNDLE_NAME Interface)
+ set(MACOSX_BUNDLE_GUI_IDENTIFIER io.highfidelity.Interface)
+
# set how the icon shows up in the Info.plist file
SET(MACOSX_BUNDLE_ICON_FILE interface.icns)
diff --git a/interface/resources/shaders/perlin_modulate.frag b/interface/resources/shaders/perlin_modulate.frag
index eea0da3671..8ead57c238 100644
--- a/interface/resources/shaders/perlin_modulate.frag
+++ b/interface/resources/shaders/perlin_modulate.frag
@@ -12,7 +12,7 @@
uniform sampler2D permutationNormalTexture;
// the noise frequency
-const float frequency = 1024.0;
+const float frequency = 65536.0; // looks better with current TREE_SCALE, was 1024 when TREE_SCALE was either 512 or 128
// the noise amplitude
const float amplitude = 0.1;
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index f51360cca1..36fd8f9635 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -101,6 +101,8 @@ const QString SKIP_FILENAME = QStandardPaths::writableLocation(QStandardPaths::D
const int STATS_PELS_PER_LINE = 20;
+const QString CUSTOM_URL_SCHEME = "hifi:";
+
void messageHandler(QtMsgType type, const QMessageLogContext& context, const QString& message) {
if (message.size() > 0) {
QString messageWithNewLine = message + "\n";
@@ -289,6 +291,9 @@ Application::Application(int& argc, char** argv, timeval &startup_time) :
_sixenseManager.setFilter(Menu::getInstance()->isOptionChecked(MenuOption::FilterSixense));
checkVersion();
+
+ _overlays.init(_glWidget); // do this before scripts load
+
// do this as late as possible so that all required subsystems are inialized
loadScripts();
@@ -679,6 +684,38 @@ void Application::controlledBroadcastToNodes(const QByteArray& packet, const Nod
}
}
+bool Application::event(QEvent* event) {
+
+ // handle custom URL
+ if (event->type() == QEvent::FileOpen) {
+ QFileOpenEvent* fileEvent = static_cast(event);
+ if (!fileEvent->url().isEmpty() && fileEvent->url().toLocalFile().startsWith(CUSTOM_URL_SCHEME)) {
+ QString destination = fileEvent->url().toLocalFile().remove(CUSTOM_URL_SCHEME);
+ QStringList urlParts = destination.split('/', QString::SkipEmptyParts);
+
+ if (urlParts.count() > 1) {
+ // if url has 2 or more parts, the first one is domain name
+ Menu::getInstance()->goToDomain(urlParts[0]);
+
+ // location coordinates
+ Menu::getInstance()->goToDestination(urlParts[1]);
+ if (urlParts.count() > 2) {
+
+ // location orientation
+ Menu::getInstance()->goToOrientation(urlParts[2]);
+ }
+ } else if (urlParts.count() == 1) {
+
+ // location coordinates
+ Menu::getInstance()->goToDestination(urlParts[0]);
+ }
+ }
+
+ return false;
+ }
+ return QApplication::event(event);
+}
+
void Application::keyPressEvent(QKeyEvent* event) {
_controllerScriptingInterface.emitKeyPressEvent(event); // send events to any registered scripts
@@ -1875,6 +1912,8 @@ void Application::init() {
connect(_rearMirrorTools, SIGNAL(restoreView()), SLOT(restoreMirrorView()));
connect(_rearMirrorTools, SIGNAL(shrinkView()), SLOT(shrinkMirrorView()));
connect(_rearMirrorTools, SIGNAL(resetView()), SLOT(resetSensors()));
+
+
}
void Application::closeMirrorView() {
@@ -2706,7 +2745,13 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
"Application::displaySide() ... voxels...");
if (!Menu::getInstance()->isOptionChecked(MenuOption::DontRenderVoxels)) {
- _voxels.render(Menu::getInstance()->isOptionChecked(MenuOption::VoxelTextures));
+ _voxels.render();
+
+ // double check that our LOD doesn't need to be auto-adjusted
+ // only adjust if our option is set
+ if (Menu::getInstance()->isOptionChecked(MenuOption::AutoAdjustLOD)) {
+ Menu::getInstance()->autoAdjustLOD(_fps);
+ }
}
}
@@ -2797,7 +2842,7 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
_mouseVoxel.s,
_mouseVoxel.s);
- _sharedVoxelSystem.render(true);
+ _sharedVoxelSystem.render();
glPopMatrix();
}
}
@@ -2837,6 +2882,9 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
// give external parties a change to hook in
emit renderingInWorldInterface();
+
+ // render JS/scriptable overlays
+ _overlays.render3D();
}
}
@@ -2983,6 +3031,8 @@ void Application::displayOverlay() {
_pieMenu.render();
}
+ _overlays.render2D();
+
glPopMatrix();
}
@@ -3984,6 +4034,32 @@ void Application::saveScripts() {
settings->endArray();
}
+void Application::stopAllScripts() {
+ // stops all current running scripts
+ QList scriptActions = Menu::getInstance()->getActiveScriptsMenu()->actions();
+ foreach (QAction* scriptAction, scriptActions) {
+ scriptAction->activate(QAction::Trigger);
+ qDebug() << "stopping script..." << scriptAction->text();
+ }
+ _activeScripts.clear();
+}
+
+void Application::reloadAllScripts() {
+ // remember all the current scripts so we can reload them
+ QStringList reloadList = _activeScripts;
+ // reloads all current running scripts
+ QList scriptActions = Menu::getInstance()->getActiveScriptsMenu()->actions();
+ foreach (QAction* scriptAction, scriptActions) {
+ scriptAction->activate(QAction::Trigger);
+ qDebug() << "stopping script..." << scriptAction->text();
+ }
+ _activeScripts.clear();
+ foreach (QString scriptName, reloadList){
+ qDebug() << "reloading script..." << scriptName;
+ loadScript(scriptName);
+ }
+}
+
void Application::removeScriptName(const QString& fileNameString) {
_activeScripts.removeOne(fileNameString);
}
@@ -4034,6 +4110,8 @@ void Application::loadScript(const QString& fileNameString) {
scriptEngine->registerGlobalObject("Camera", cameraScriptable);
connect(scriptEngine, SIGNAL(finished(const QString&)), cameraScriptable, SLOT(deleteLater()));
+ scriptEngine->registerGlobalObject("Overlays", &_overlays);
+
QThread* workerThread = new QThread(this);
// when the worker thread is started, call our engine's run..
diff --git a/interface/src/Application.h b/interface/src/Application.h
index 9984f1b9c1..b1e3af54ec 100644
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@@ -71,6 +71,7 @@
#include "FileLogger.h"
#include "ParticleTreeRenderer.h"
#include "ControllerScriptingInterface.h"
+#include "ui/Overlays.h"
class QAction;
@@ -127,7 +128,9 @@ public:
void touchUpdateEvent(QTouchEvent* event);
void wheelEvent(QWheelEvent* event);
-
+
+ bool event(QEvent* event);
+
void makeVoxel(glm::vec3 position,
float scale,
unsigned char red,
@@ -232,6 +235,8 @@ public slots:
void loadDialog();
void toggleLogDialog();
void initAvatarAndViewFrustum();
+ void stopAllScripts();
+ void reloadAllScripts();
private slots:
void timer();
@@ -488,6 +493,8 @@ private:
void takeSnapshot();
TouchEvent _lastTouchEvent;
+
+ Overlays _overlays;
};
#endif /* defined(__interface__Application__) */
diff --git a/interface/src/Menu.cpp b/interface/src/Menu.cpp
index 4a3733f760..c61b4cbdaf 100644
--- a/interface/src/Menu.cpp
+++ b/interface/src/Menu.cpp
@@ -70,7 +70,8 @@ Menu::Menu() :
_maxVoxels(DEFAULT_MAX_VOXELS_PER_SYSTEM),
_voxelSizeScale(DEFAULT_OCTREE_SIZE_SCALE),
_boundaryLevelAdjust(0),
- _maxVoxelPacketsPerSecond(DEFAULT_MAX_VOXEL_PPS)
+ _maxVoxelPacketsPerSecond(DEFAULT_MAX_VOXEL_PPS),
+ _lastAdjust(usecTimestampNow())
{
Application *appInstance = Application::getInstance();
@@ -93,6 +94,8 @@ Menu::Menu() :
addDisabledActionAndSeparator(fileMenu, "Scripts");
addActionToQMenuAndActionHash(fileMenu, MenuOption::LoadScript, Qt::CTRL | Qt::Key_O, appInstance, SLOT(loadDialog()));
+ addActionToQMenuAndActionHash(fileMenu, MenuOption::StopAllScripts, 0, appInstance, SLOT(stopAllScripts()));
+ addActionToQMenuAndActionHash(fileMenu, MenuOption::ReloadAllScripts, 0, appInstance, SLOT(reloadAllScripts()));
_activeScriptsMenu = fileMenu->addMenu("Running Scripts");
addDisabledActionAndSeparator(fileMenu, "Voxels");
@@ -166,14 +169,7 @@ Menu::Menu() :
addCheckableActionToQMenuAndActionHash(editMenu, MenuOption::ClickToFly);
- QMenu* collisionsOptionsMenu = editMenu->addMenu("Collision Options");
-
- QObject* avatar = appInstance->getAvatar();
- addCheckableActionToQMenuAndActionHash(collisionsOptionsMenu, MenuOption::CollideWithEnvironment, 0, false, avatar, SLOT(updateCollisionFlags()));
- addCheckableActionToQMenuAndActionHash(collisionsOptionsMenu, MenuOption::CollideWithAvatars, 0, false, avatar, SLOT(updateCollisionFlags()));
- addCheckableActionToQMenuAndActionHash(collisionsOptionsMenu, MenuOption::CollideWithVoxels, 0, false, avatar, SLOT(updateCollisionFlags()));
- // TODO: make this option work
- //addCheckableActionToQMenuAndActionHash(collisionsOptionsMenu, MenuOption::CollideWithParticles, 0, false, avatar, SLOT(updateCollisionFlags()));
+ addAvatarCollisionSubMenu(editMenu);
QMenu* toolsMenu = addMenu("Tools");
@@ -316,6 +312,7 @@ Menu::Menu() :
addCheckableActionToQMenuAndActionHash(voxelOptionsMenu, MenuOption::VoxelTextures);
addCheckableActionToQMenuAndActionHash(voxelOptionsMenu, MenuOption::AmbientOcclusion);
addCheckableActionToQMenuAndActionHash(voxelOptionsMenu, MenuOption::DontFadeOnVoxelServerChanges);
+ addCheckableActionToQMenuAndActionHash(voxelOptionsMenu, MenuOption::AutoAdjustLOD);
addActionToQMenuAndActionHash(voxelOptionsMenu, MenuOption::LodTools, Qt::SHIFT | Qt::Key_L, this, SLOT(lodTools()));
QMenu* voxelProtoOptionsMenu = voxelOptionsMenu->addMenu("Voxel Server Protocol Options");
@@ -341,6 +338,8 @@ Menu::Menu() :
SLOT(setTCPEnabled(bool)));
addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::ChatCircling, 0, false);
+ addAvatarCollisionSubMenu(avatarOptionsMenu);
+
QMenu* handOptionsMenu = developerMenu->addMenu("Hand Options");
addCheckableActionToQMenuAndActionHash(handOptionsMenu,
@@ -515,6 +514,11 @@ void Menu::loadSettings(QSettings* settings) {
Application::getInstance()->getProfile()->loadData(settings);
Application::getInstance()->updateWindowTitle();
NodeList::getInstance()->loadData(settings);
+
+ // MyAvatar caches some menu options, so we have to update them whenever we load settings.
+ // TODO: cache more settings in MyAvatar that are checked with very high frequency.
+ MyAvatar* myAvatar = Application::getInstance()->getAvatar();
+ myAvatar->updateCollisionFlags();
}
void Menu::saveSettings(QSettings* settings) {
@@ -882,6 +886,17 @@ void Menu::editPreferences() {
sendFakeEnterEvent();
}
+void Menu::goToDomain(const QString newDomain) {
+ if (NodeList::getInstance()->getDomainHostname() != newDomain) {
+
+ // send a node kill request, indicating to other clients that they should play the "disappeared" effect
+ Application::getInstance()->getAvatar()->sendKillAvatar();
+
+ // give our nodeList the new domain-server hostname
+ NodeList::getInstance()->setDomainHostname(newDomain);
+ }
+}
+
void Menu::goToDomain() {
QString currentDomainHostname = NodeList::getInstance()->getDomainHostname();
@@ -906,17 +921,77 @@ void Menu::goToDomain() {
// the user input a new hostname, use that
newHostname = domainDialog.textValue();
}
-
- // send a node kill request, indicating to other clients that they should play the "disappeared" effect
- Application::getInstance()->getAvatar()->sendKillAvatar();
-
- // give our nodeList the new domain-server hostname
- NodeList::getInstance()->setDomainHostname(domainDialog.textValue());
+
+ goToDomain(newHostname);
}
sendFakeEnterEvent();
}
+void Menu::goToOrientation(QString orientation) {
+
+ if (orientation.isEmpty()) {
+ return;
+ }
+
+ QStringList orientationItems = orientation.split(QRegExp("_|,"), QString::SkipEmptyParts);
+
+ const int NUMBER_OF_ORIENTATION_ITEMS = 4;
+ const int W_ITEM = 0;
+ const int X_ITEM = 1;
+ const int Y_ITEM = 2;
+ const int Z_ITEM = 3;
+
+ if (orientationItems.size() == NUMBER_OF_ORIENTATION_ITEMS) {
+
+ double w = replaceLastOccurrence('-', '.', orientationItems[W_ITEM].trimmed()).toDouble();
+ double x = replaceLastOccurrence('-', '.', orientationItems[X_ITEM].trimmed()).toDouble();
+ double y = replaceLastOccurrence('-', '.', orientationItems[Y_ITEM].trimmed()).toDouble();
+ double z = replaceLastOccurrence('-', '.', orientationItems[Z_ITEM].trimmed()).toDouble();
+
+ glm::quat newAvatarOrientation(w, x, y, z);
+
+ MyAvatar* myAvatar = Application::getInstance()->getAvatar();
+ glm::quat avatarOrientation = myAvatar->getOrientation();
+ if (newAvatarOrientation != avatarOrientation) {
+ myAvatar->setOrientation(newAvatarOrientation);
+ }
+ }
+}
+
+bool Menu::goToDestination(QString destination) {
+
+ QStringList coordinateItems = destination.split(QRegExp("_|,"), QString::SkipEmptyParts);
+
+ const int NUMBER_OF_COORDINATE_ITEMS = 3;
+ const int X_ITEM = 0;
+ const int Y_ITEM = 1;
+ const int Z_ITEM = 2;
+ if (coordinateItems.size() == NUMBER_OF_COORDINATE_ITEMS) {
+
+ double x = replaceLastOccurrence('-', '.', coordinateItems[X_ITEM].trimmed()).toDouble();
+ double y = replaceLastOccurrence('-', '.', coordinateItems[Y_ITEM].trimmed()).toDouble();
+ double z = replaceLastOccurrence('-', '.', coordinateItems[Z_ITEM].trimmed()).toDouble();
+
+ glm::vec3 newAvatarPos(x, y, z);
+
+ MyAvatar* myAvatar = Application::getInstance()->getAvatar();
+ glm::vec3 avatarPos = myAvatar->getPosition();
+ if (newAvatarPos != avatarPos) {
+ // send a node kill request, indicating to other clients that they should play the "disappeared" effect
+ MyAvatar::sendKillAvatar();
+
+ qDebug("Going To Location: %f, %f, %f...", x, y, z);
+ myAvatar->setPosition(newAvatarPos);
+ }
+
+ return true;
+ }
+
+ // no coordinates were parsed
+ return false;
+}
+
void Menu::goTo() {
QInputDialog gotoDialog(Application::getInstance()->getWindow());
@@ -932,31 +1007,8 @@ void Menu::goTo() {
destination = gotoDialog.textValue();
- QStringList coordinateItems = destination.split(QRegExp("_|,"), QString::SkipEmptyParts);
-
- const int NUMBER_OF_COORDINATE_ITEMS = 3;
- const int X_ITEM = 0;
- const int Y_ITEM = 1;
- const int Z_ITEM = 2;
- if (coordinateItems.size() == NUMBER_OF_COORDINATE_ITEMS) {
-
- double x = replaceLastOccurrence('-', '.', coordinateItems[X_ITEM].trimmed()).toDouble();
- double y = replaceLastOccurrence('-', '.', coordinateItems[Y_ITEM].trimmed()).toDouble();
- double z = replaceLastOccurrence('-', '.', coordinateItems[Z_ITEM].trimmed()).toDouble();
-
- glm::vec3 newAvatarPos(x, y, z);
-
- MyAvatar* myAvatar = Application::getInstance()->getAvatar();
- glm::vec3 avatarPos = myAvatar->getPosition();
- if (newAvatarPos != avatarPos) {
- // send a node kill request, indicating to other clients that they should play the "disappeared" effect
- MyAvatar::sendKillAvatar();
-
- qDebug("Going To Location: %f, %f, %f...", x, y, z);
- myAvatar->setPosition(newAvatarPos);
- }
-
- } else {
+ // go to coordinate destination or to Username
+ if (!goToDestination(destination)) {
// there's a username entered by the user, make a request to the data-server
DataServerClient::getValuesForKeysAndUserString(
QStringList()
@@ -987,29 +1039,7 @@ void Menu::goToLocation() {
int dialogReturn = coordinateDialog.exec();
if (dialogReturn == QDialog::Accepted && !coordinateDialog.textValue().isEmpty()) {
- QByteArray newCoordinates;
-
- QString delimiterPattern(",");
- QStringList coordinateItems = coordinateDialog.textValue().split(delimiterPattern);
-
- const int NUMBER_OF_COORDINATE_ITEMS = 3;
- const int X_ITEM = 0;
- const int Y_ITEM = 1;
- const int Z_ITEM = 2;
- if (coordinateItems.size() == NUMBER_OF_COORDINATE_ITEMS) {
- double x = coordinateItems[X_ITEM].toDouble();
- double y = coordinateItems[Y_ITEM].toDouble();
- double z = coordinateItems[Z_ITEM].toDouble();
- glm::vec3 newAvatarPos(x, y, z);
-
- if (newAvatarPos != avatarPos) {
- // send a node kill request, indicating to other clients that they should play the "disappeared" effect
- MyAvatar::sendKillAvatar();
-
- qDebug("Going To Location: %f, %f, %f...", x, y, z);
- myAvatar->setPosition(newAvatarPos);
- }
- }
+ goToDestination(coordinateDialog.textValue());
}
sendFakeEnterEvent();
@@ -1089,14 +1119,38 @@ void Menu::voxelStatsDetailsClosed() {
}
}
+void Menu::autoAdjustLOD(float currentFPS) {
+ bool changed = false;
+ quint64 now = usecTimestampNow();
+ quint64 elapsed = now - _lastAdjust;
+
+ if (elapsed > ADJUST_LOD_DOWN_DELAY && currentFPS < ADJUST_LOD_DOWN_FPS && _voxelSizeScale > ADJUST_LOD_MIN_SIZE_SCALE) {
+ _voxelSizeScale *= ADJUST_LOD_DOWN_BY;
+ changed = true;
+ _lastAdjust = now;
+ qDebug() << "adjusting LOD down... currentFPS=" << currentFPS << "_voxelSizeScale=" << _voxelSizeScale;
+ }
+
+ if (elapsed > ADJUST_LOD_UP_DELAY && currentFPS > ADJUST_LOD_UP_FPS && _voxelSizeScale < ADJUST_LOD_MAX_SIZE_SCALE) {
+ _voxelSizeScale *= ADJUST_LOD_UP_BY;
+ changed = true;
+ _lastAdjust = now;
+ qDebug() << "adjusting LOD up... currentFPS=" << currentFPS << "_voxelSizeScale=" << _voxelSizeScale;
+ }
+
+ if (changed) {
+ if (_lodToolsDialog) {
+ _lodToolsDialog->reloadSliders();
+ }
+ }
+}
+
void Menu::setVoxelSizeScale(float sizeScale) {
_voxelSizeScale = sizeScale;
- Application::getInstance()->getVoxels()->redrawInViewVoxels();
}
void Menu::setBoundaryLevelAdjust(int boundaryLevelAdjust) {
_boundaryLevelAdjust = boundaryLevelAdjust;
- Application::getInstance()->getVoxels()->redrawInViewVoxels();
}
void Menu::lodTools() {
@@ -1178,6 +1232,22 @@ void Menu::updateFrustumRenderModeAction() {
}
}
+void Menu::addAvatarCollisionSubMenu(QMenu* overMenu) {
+ // add avatar collisions subMenu to overMenu
+ QMenu* subMenu = overMenu->addMenu("Collision Options");
+
+ Application* appInstance = Application::getInstance();
+ QObject* avatar = appInstance->getAvatar();
+ addCheckableActionToQMenuAndActionHash(subMenu, MenuOption::CollideWithEnvironment,
+ 0, false, avatar, SLOT(updateCollisionFlags()));
+ addCheckableActionToQMenuAndActionHash(subMenu, MenuOption::CollideWithAvatars,
+ 0, true, avatar, SLOT(updateCollisionFlags()));
+ addCheckableActionToQMenuAndActionHash(subMenu, MenuOption::CollideWithVoxels,
+ 0, false, avatar, SLOT(updateCollisionFlags()));
+ addCheckableActionToQMenuAndActionHash(subMenu, MenuOption::CollideWithParticles,
+ 0, true, avatar, SLOT(updateCollisionFlags()));
+}
+
QString Menu::replaceLastOccurrence(QChar search, QChar replace, QString string) {
int lastIndex;
lastIndex = string.lastIndexOf(search);
@@ -1188,4 +1258,3 @@ QString Menu::replaceLastOccurrence(QChar search, QChar replace, QString string)
return string;
}
-
diff --git a/interface/src/Menu.h b/interface/src/Menu.h
index 19e9fbf49f..986034002d 100644
--- a/interface/src/Menu.h
+++ b/interface/src/Menu.h
@@ -16,6 +16,18 @@
#include
+const float ADJUST_LOD_DOWN_FPS = 40.0;
+const float ADJUST_LOD_UP_FPS = 55.0;
+
+const quint64 ADJUST_LOD_DOWN_DELAY = 1000 * 1000 * 5;
+const quint64 ADJUST_LOD_UP_DELAY = ADJUST_LOD_DOWN_DELAY * 2;
+
+const float ADJUST_LOD_DOWN_BY = 0.9f;
+const float ADJUST_LOD_UP_BY = 1.1f;
+
+const float ADJUST_LOD_MIN_SIZE_SCALE = TREE_SCALE * 1.0f;
+const float ADJUST_LOD_MAX_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE;
+
enum FrustumDrawMode {
FRUSTUM_DRAW_MODE_ALL,
FRUSTUM_DRAW_MODE_VECTORS,
@@ -68,6 +80,7 @@ public:
void handleViewFrustumOffsetKeyModifier(int key);
// User Tweakable LOD Items
+ void autoAdjustLOD(float currentFPS);
void setVoxelSizeScale(float sizeScale);
float getVoxelSizeScale() const { return _voxelSizeScale; }
void setBoundaryLevelAdjust(int boundaryLevelAdjust);
@@ -84,6 +97,9 @@ public:
const char* member = NULL,
QAction::MenuRole role = QAction::NoRole);
virtual void removeAction(QMenu* menu, const QString& actionName);
+ bool goToDestination(QString destination);
+ void goToOrientation(QString orientation);
+ void goToDomain(const QString newDomain);
public slots:
void bandwidthDetails();
@@ -136,6 +152,8 @@ private:
void updateFrustumRenderModeAction();
+ void addAvatarCollisionSubMenu(QMenu* overMenu);
+
QHash _actionHash;
int _audioJitterBufferSamples; /// number of extra samples to wait before starting audio playback
BandwidthDialog* _bandwidthDialog;
@@ -154,6 +172,7 @@ private:
int _maxVoxelPacketsPerSecond;
QMenu* _activeScriptsMenu;
QString replaceLastOccurrence(QChar search, QChar replace, QString string);
+ quint64 _lastAdjust;
};
namespace MenuOption {
@@ -161,6 +180,7 @@ namespace MenuOption {
const QString AmbientOcclusion = "Ambient Occlusion";
const QString Avatars = "Avatars";
const QString Atmosphere = "Atmosphere";
+ const QString AutoAdjustLOD = "Automatically Adjust LOD";
const QString AutomaticallyAuditTree = "Automatically Audit Tree Stats";
const QString Bandwidth = "Bandwidth Display";
const QString BandwidthDetails = "Bandwidth Details";
@@ -243,8 +263,10 @@ namespace MenuOption {
const QString PasteVoxels = "Paste";
const QString PasteToVoxel = "Paste to Voxel...";
const QString PipelineWarnings = "Show Render Pipeline Warnings";
+ const QString PlaySlaps = "Play Slaps";
const QString Preferences = "Preferences...";
const QString RandomizeVoxelColors = "Randomize Voxel TRUE Colors";
+ const QString ReloadAllScripts = "Reload All Scripts";
const QString ResetAvatarSize = "Reset Avatar Size";
const QString ResetSwatchColors = "Reset Swatch Colors";
const QString RunTimingTests = "Run Timing Tests";
@@ -253,11 +275,10 @@ namespace MenuOption {
const QString SettingsExport = "Export Settings";
const QString ShowAllLocalVoxels = "Show All Local Voxels";
const QString ShowTrueColors = "Show TRUE Colors";
- const QString VoxelDrumming = "Voxel Drumming";
- const QString PlaySlaps = "Play Slaps";
const QString SuppressShortTimings = "Suppress Timings Less than 10ms";
const QString Stars = "Stars";
const QString Stats = "Stats";
+ const QString StopAllScripts = "Stop All Scripts";
const QString TestPing = "Test Ping";
const QString TreeStats = "Calculate Tree Stats";
const QString TransmitterDrive = "Transmitter Drive";
@@ -268,6 +289,7 @@ namespace MenuOption {
const QString VoxelAddMode = "Add Voxel Mode";
const QString VoxelColorMode = "Color Voxel Mode";
const QString VoxelDeleteMode = "Delete Voxel Mode";
+ const QString VoxelDrumming = "Voxel Drumming";
const QString VoxelGetColorMode = "Get Color Mode";
const QString VoxelMode = "Cycle Voxel Mode";
const QString VoxelPaintColor = "Voxel Paint Color";
diff --git a/interface/src/Util.h b/interface/src/Util.h
index 09d1fa0484..0c762ccd79 100644
--- a/interface/src/Util.h
+++ b/interface/src/Util.h
@@ -19,15 +19,6 @@
#include
#include
-// the standard sans serif font family
-#define SANS_FONT_FAMILY "Helvetica"
-
-// the standard mono font family
-#define MONO_FONT_FAMILY "Courier"
-
-// the Inconsolata font family
-#define INCONSOLATA_FONT_FAMILY "Inconsolata"
-
void eulerToOrthonormals(glm::vec3 * angles, glm::vec3 * fwd, glm::vec3 * left, glm::vec3 * up);
float azimuth_to(glm::vec3 head_pos, glm::vec3 source_pos);
diff --git a/interface/src/VoxelSystem.cpp b/interface/src/VoxelSystem.cpp
index 1ffc6c3e5e..a3352f36e7 100644
--- a/interface/src/VoxelSystem.cpp
+++ b/interface/src/VoxelSystem.cpp
@@ -57,9 +57,12 @@ GLubyte identityIndicesBack[] = { 4, 5, 6, 4, 6, 7 };
VoxelSystem::VoxelSystem(float treeScale, int maxVoxels)
: NodeData(),
- _treeScale(treeScale),
- _maxVoxels(maxVoxels),
- _initialized(false) {
+ _treeScale(treeScale),
+ _maxVoxels(maxVoxels),
+ _initialized(false),
+ _writeArraysLock(QReadWriteLock::Recursive),
+ _readArraysLock(QReadWriteLock::Recursive)
+ {
_voxelsInReadArrays = _voxelsInWriteArrays = _voxelsUpdated = 0;
_writeRenderFullVBO = true;
@@ -99,6 +102,9 @@ VoxelSystem::VoxelSystem(float treeScale, int maxVoxels)
_culledOnce = false;
_inhideOutOfView = false;
+
+ _lastKnownVoxelSizeScale = DEFAULT_OCTREE_SIZE_SCALE;
+ _lastKnownBoundaryLevelAdjust = 0;
}
void VoxelSystem::elementDeleted(OctreeElement* element) {
@@ -121,6 +127,7 @@ void VoxelSystem::setDisableFastVoxelPipeline(bool disableFastVoxelPipeline) {
void VoxelSystem::elementUpdated(OctreeElement* element) {
VoxelTreeElement* voxel = (VoxelTreeElement*)element;
+
// If we're in SetupNewVoxelsForDrawing() or _writeRenderFullVBO then bail..
if (!_useFastVoxelPipeline || _inSetupNewVoxelsForDrawing || _writeRenderFullVBO) {
return;
@@ -249,6 +256,9 @@ VoxelSystem::~VoxelSystem() {
delete _tree;
}
+
+// This is called by the main application thread on both the initialization of the application and when
+// the preferences dialog box is called/saved
void VoxelSystem::setMaxVoxels(int maxVoxels) {
if (maxVoxels == _maxVoxels) {
return;
@@ -267,6 +277,8 @@ void VoxelSystem::setMaxVoxels(int maxVoxels) {
}
}
+// This is called by the main application thread on both the initialization of the application and when
+// the use voxel shader menu item is chosen
void VoxelSystem::setUseVoxelShader(bool useVoxelShader) {
if (_useVoxelShader == useVoxelShader) {
return;
@@ -330,7 +342,7 @@ void VoxelSystem::setVoxelsAsPoints(bool voxelsAsPoints) {
void VoxelSystem::cleanupVoxelMemory() {
if (_initialized) {
- _bufferWriteLock.lock();
+ _readArraysLock.lockForWrite();
_initialized = false; // no longer initialized
if (_useVoxelShader) {
// these are used when in VoxelShader mode.
@@ -368,7 +380,7 @@ void VoxelSystem::cleanupVoxelMemory() {
delete[] _writeVoxelDirtyArray;
delete[] _readVoxelDirtyArray;
_writeVoxelDirtyArray = _readVoxelDirtyArray = NULL;
- _bufferWriteLock.unlock();
+ _readArraysLock.unlock();
}
}
@@ -401,7 +413,8 @@ void VoxelSystem::setupFaceIndices(GLuint& faceVBOID, GLubyte faceIdentityIndice
}
void VoxelSystem::initVoxelMemory() {
- _bufferWriteLock.lock();
+ _readArraysLock.lockForWrite();
+ _writeArraysLock.lockForWrite();
_memoryUsageRAM = 0;
_memoryUsageVBO = 0; // our VBO allocations as we know them
@@ -516,7 +529,8 @@ void VoxelSystem::initVoxelMemory() {
_initialized = true;
- _bufferWriteLock.unlock();
+ _writeArraysLock.unlock();
+ _readArraysLock.unlock();
}
void VoxelSystem::writeToSVOFile(const char* filename, VoxelTreeElement* element) const {
@@ -646,7 +660,7 @@ void VoxelSystem::setupNewVoxelsForDrawing() {
}
_inSetupNewVoxelsForDrawing = true;
-
+
bool didWriteFullVBO = _writeRenderFullVBO;
if (_tree->isDirty()) {
static char buffer[64] = { 0 };
@@ -673,7 +687,7 @@ void VoxelSystem::setupNewVoxelsForDrawing() {
}
// lock on the buffer write lock so we can't modify the data when the GPU is reading it
- _bufferWriteLock.lock();
+ _readArraysLock.lockForWrite();
if (_voxelsUpdated) {
_voxelsDirty=true;
@@ -682,7 +696,7 @@ void VoxelSystem::setupNewVoxelsForDrawing() {
// copy the newly written data to the arrays designated for reading, only does something if _voxelsDirty && _voxelsUpdated
copyWrittenDataToReadArrays(didWriteFullVBO);
- _bufferWriteLock.unlock();
+ _readArraysLock.unlock();
quint64 end = usecTimestampNow();
int elapsedmsec = (end - start) / 1000;
@@ -713,8 +727,8 @@ void VoxelSystem::setupNewVoxelsForDrawingSingleNode(bool allowBailEarly) {
// lock on the buffer write lock so we can't modify the data when the GPU is reading it
{
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
- "setupNewVoxelsForDrawingSingleNode()... _bufferWriteLock.lock();" );
- _bufferWriteLock.lock();
+ "setupNewVoxelsForDrawingSingleNode()... _readArraysLock.lockForWrite();" );
+ _readArraysLock.lockForWrite();
}
_voxelsDirty = true; // if we got this far, then we can assume some voxels are dirty
@@ -725,7 +739,7 @@ void VoxelSystem::setupNewVoxelsForDrawingSingleNode(bool allowBailEarly) {
// after...
_voxelsUpdated = 0;
- _bufferWriteLock.unlock();
+ _readArraysLock.unlock();
quint64 end = usecTimestampNow();
int elapsedmsec = (end - start) / 1000;
@@ -733,8 +747,73 @@ void VoxelSystem::setupNewVoxelsForDrawingSingleNode(bool allowBailEarly) {
_setupNewVoxelsForDrawingLastElapsed = elapsedmsec;
}
-void VoxelSystem::checkForCulling() {
+
+class recreateVoxelGeometryInViewArgs {
+public:
+ VoxelSystem* thisVoxelSystem;
+ ViewFrustum thisViewFrustum;
+ unsigned long nodesScanned;
+ float voxelSizeScale;
+ int boundaryLevelAdjust;
+
+ recreateVoxelGeometryInViewArgs(VoxelSystem* voxelSystem) :
+ thisVoxelSystem(voxelSystem),
+ thisViewFrustum(*voxelSystem->getViewFrustum()),
+ nodesScanned(0),
+ voxelSizeScale(Menu::getInstance()->getVoxelSizeScale()),
+ boundaryLevelAdjust(Menu::getInstance()->getBoundaryLevelAdjust())
+ {
+ }
+};
+
+// The goal of this operation is to remove any old references to old geometry, and if the voxel
+// should be visible, create new geometry for it.
+bool VoxelSystem::recreateVoxelGeometryInViewOperation(OctreeElement* element, void* extraData) {
+ VoxelTreeElement* voxel = (VoxelTreeElement*)element;
+ recreateVoxelGeometryInViewArgs* args = (recreateVoxelGeometryInViewArgs*)extraData;
+
+ args->nodesScanned++;
+
+ // reset the old geometry...
+ // note: this doesn't "mark the voxel as changed", so it only releases the old buffer index thereby forgetting the
+ // old geometry
+ voxel->setBufferIndex(GLBUFFER_INDEX_UNKNOWN);
+
+ bool shouldRender = voxel->calculateShouldRender(&args->thisViewFrustum, args->voxelSizeScale, args->boundaryLevelAdjust);
+ bool inView = voxel->isInView(args->thisViewFrustum);
+ voxel->setShouldRender(inView && shouldRender);
+ if (shouldRender && inView) {
+ // recreate the geometry
+ args->thisVoxelSystem->updateNodeInArrays(voxel, false, true); // DONT_REUSE_INDEX, FORCE_REDRAW
+ }
+
+ return true; // keep recursing!
+}
+
+
+// TODO: does cleanupRemovedVoxels() ever get called?
+// TODO: other than cleanupRemovedVoxels() is there anyplace we attempt to detect too many abandoned slots???
+void VoxelSystem::recreateVoxelGeometryInView() {
+
+ qDebug() << "recreateVoxelGeometryInView()...";
+
+ recreateVoxelGeometryInViewArgs args(this);
+ _writeArraysLock.lockForWrite(); // don't let anyone read or write our write arrays until we're done
+ _tree->lockForRead(); // don't let anyone change our tree structure until we're run
+
+ // reset our write arrays bookkeeping to think we've got no voxels in it
+ clearFreeBufferIndexes();
+
+ // do we need to reset out _writeVoxelDirtyArray arrays??
+ memset(_writeVoxelDirtyArray, false, _maxVoxels * sizeof(bool));
+
+ _tree->recurseTreeWithOperation(recreateVoxelGeometryInViewOperation,(void*)&args);
+ _tree->unlock();
+ _writeArraysLock.unlock();
+}
+
+void VoxelSystem::checkForCulling() {
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "checkForCulling()");
quint64 start = usecTimestampNow();
@@ -762,7 +841,20 @@ void VoxelSystem::checkForCulling() {
_hasRecentlyChanged = false;
}
- hideOutOfView(forceFullFrustum);
+ // This would be a good place to do a special processing pass, for example, switching the LOD of the scene
+ bool fullRedraw = (_lastKnownVoxelSizeScale != Menu::getInstance()->getVoxelSizeScale() ||
+ _lastKnownBoundaryLevelAdjust != Menu::getInstance()->getBoundaryLevelAdjust());
+
+ // track that these values
+ _lastKnownVoxelSizeScale = Menu::getInstance()->getVoxelSizeScale();
+ _lastKnownBoundaryLevelAdjust = Menu::getInstance()->getBoundaryLevelAdjust();
+
+ if (fullRedraw) {
+ // this will remove all old geometry and recreate the correct geometry for all in view voxels
+ recreateVoxelGeometryInView();
+ } else {
+ hideOutOfView(forceFullFrustum);
+ }
if (forceFullFrustum) {
quint64 endViewCulling = usecTimestampNow();
@@ -880,12 +972,26 @@ void VoxelSystem::copyWrittenDataToReadArrays(bool fullVBOs) {
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
"copyWrittenDataToReadArrays()");
- if (_voxelsDirty && _voxelsUpdated) {
- if (fullVBOs) {
- copyWrittenDataToReadArraysFullVBOs();
+ // attempt to get the writeArraysLock for reading and the readArraysLock for writing
+ // so we can copy from the write to the read... if we fail, that's ok, we'll get it the next
+ // time around, the only side effect is the VBOs won't be updated this frame
+ const int WAIT_FOR_LOCK_IN_MS = 5;
+ if (_readArraysLock.tryLockForWrite(WAIT_FOR_LOCK_IN_MS)) {
+ if (_writeArraysLock.tryLockForRead(WAIT_FOR_LOCK_IN_MS)) {
+ if (_voxelsDirty && _voxelsUpdated) {
+ if (fullVBOs) {
+ copyWrittenDataToReadArraysFullVBOs();
+ } else {
+ copyWrittenDataToReadArraysPartialVBOs();
+ }
+ }
+ _writeArraysLock.unlock();
} else {
- copyWrittenDataToReadArraysPartialVBOs();
+ qDebug() << "couldn't get _writeArraysLock.LockForRead()...";
}
+ _readArraysLock.unlock();
+ } else {
+ qDebug() << "couldn't get _readArraysLock.LockForWrite()...";
}
}
@@ -1141,17 +1247,27 @@ void VoxelSystem::updateVBOs() {
// would like to include _callsToTreesToArrays
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), buffer);
if (_voxelsDirty) {
- if (_readRenderFullVBO) {
- updateFullVBOs();
+
+ // attempt to lock the read arrays, to for copying from them to the actual GPU VBOs.
+ // if we fail to get the lock, that's ok, our VBOs will update on the next frame...
+ const int WAIT_FOR_LOCK_IN_MS = 5;
+ if (_readArraysLock.tryLockForRead(WAIT_FOR_LOCK_IN_MS)) {
+ if (_readRenderFullVBO) {
+ updateFullVBOs();
+ } else {
+ updatePartialVBOs();
+ }
+ _voxelsDirty = false;
+ _readRenderFullVBO = false;
+ _readArraysLock.unlock();
} else {
- updatePartialVBOs();
+ qDebug() << "updateVBOs().... couldn't get _readArraysLock.tryLockForRead()";
}
- _voxelsDirty = false;
- _readRenderFullVBO = false;
}
_callsToTreesToArrays = 0; // clear it
}
+// this should only be called on the main application thread during render
void VoxelSystem::updateVBOSegment(glBufferIndex segmentStart, glBufferIndex segmentEnd) {
bool showWarning = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
PerformanceWarning warn(showWarning, "updateVBOSegment()");
@@ -1197,7 +1313,8 @@ void VoxelSystem::updateVBOSegment(glBufferIndex segmentStart, glBufferIndex seg
}
}
-void VoxelSystem::render(bool texture) {
+void VoxelSystem::render() {
+ bool texture = Menu::getInstance()->isOptionChecked(MenuOption::VoxelTextures);
bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
PerformanceWarning warn(showWarnings, "render()");
@@ -1404,11 +1521,7 @@ void VoxelSystem::killLocalVoxels() {
setupNewVoxelsForDrawing();
}
-void VoxelSystem::redrawInViewVoxels() {
- hideOutOfView(true);
-}
-
-
+// only called on main thread
bool VoxelSystem::clearAllNodesBufferIndexOperation(OctreeElement* element, void* extraData) {
_nodeCount++;
VoxelTreeElement* voxel = (VoxelTreeElement*)element;
@@ -1416,12 +1529,15 @@ bool VoxelSystem::clearAllNodesBufferIndexOperation(OctreeElement* element, void
return true;
}
+// only called on main thread, and also always followed by a call to cleanupVoxelMemory()
+// you shouldn't be calling this on any other thread or without also cleaning up voxel memory
void VoxelSystem::clearAllNodesBufferIndex() {
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
"VoxelSystem::clearAllNodesBufferIndex()");
_nodeCount = 0;
_tree->lockForRead(); // we won't change the tree so it's ok to treat this as a read
_tree->recurseTreeWithOperation(clearAllNodesBufferIndexOperation);
+ clearFreeBufferIndexes(); // this should be called too
_tree->unlock();
if (Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings)) {
qDebug("clearing buffer index of %d nodes", _nodeCount);
diff --git a/interface/src/VoxelSystem.h b/interface/src/VoxelSystem.h
index d1404668bf..121a7f86c4 100644
--- a/interface/src/VoxelSystem.h
+++ b/interface/src/VoxelSystem.h
@@ -53,7 +53,7 @@ public:
virtual void init();
void simulate(float deltaTime) { }
- void render(bool texture);
+ void render();
void changeTree(VoxelTree* newTree);
VoxelTree* getTree() const { return _tree; }
@@ -79,7 +79,6 @@ public:
unsigned long getVoxelMemoryUsageGPU();
void killLocalVoxels();
- void redrawInViewVoxels();
virtual void removeOutOfView();
virtual void hideOutOfView(bool forceFullFrustum = false);
@@ -151,6 +150,7 @@ protected:
static const bool DONT_BAIL_EARLY; // by default we will bail early, if you want to force not bailing, then use this
void setupNewVoxelsForDrawingSingleNode(bool allowBailEarly = true);
void checkForCulling();
+ void recreateVoxelGeometryInView();
glm::vec3 computeVoxelVertex(const glm::vec3& startVertex, float voxelScale, int index) const;
@@ -194,6 +194,7 @@ private:
static bool showAllSubTreeOperation(OctreeElement* element, void* extraData);
static bool showAllLocalVoxelsOperation(OctreeElement* element, void* extraData);
static bool getVoxelEnclosingOperation(OctreeElement* element, void* extraData);
+ static bool recreateVoxelGeometryInViewOperation(OctreeElement* element, void* extraData);
int updateNodeInArrays(VoxelTreeElement* node, bool reuseIndex, bool forceDraw);
int forceRemoveNodeFromArrays(VoxelTreeElement* node);
@@ -211,6 +212,11 @@ private:
GLfloat* _readVerticesArray;
GLubyte* _readColorsArray;
+
+ QReadWriteLock _writeArraysLock;
+ QReadWriteLock _readArraysLock;
+
+
GLfloat* _writeVerticesArray;
GLubyte* _writeColorsArray;
bool* _writeVoxelDirtyArray;
@@ -253,9 +259,6 @@ private:
GLuint _vboIndicesFront;
GLuint _vboIndicesBack;
- QMutex _bufferWriteLock;
- QMutex _treeLock;
-
ViewFrustum _lastKnownViewFrustum;
ViewFrustum _lastStableViewFrustum;
ViewFrustum* _viewFrustum;
@@ -299,6 +302,9 @@ private:
bool _useFastVoxelPipeline;
bool _inhideOutOfView;
+
+ float _lastKnownVoxelSizeScale;
+ int _lastKnownBoundaryLevelAdjust;
};
#endif
diff --git a/interface/src/avatar/Avatar.cpp b/interface/src/avatar/Avatar.cpp
index 18245b8b18..efee7fcc8e 100644
--- a/interface/src/avatar/Avatar.cpp
+++ b/interface/src/avatar/Avatar.cpp
@@ -162,6 +162,7 @@ void Avatar::render(bool forceRenderHead) {
// render body
if (Menu::getInstance()->isOptionChecked(MenuOption::CollisionProxies)) {
_skeletonModel.renderCollisionProxies(1.f);
+ //_head.getFaceModel().renderCollisionProxies(0.5f);
}
if (Menu::getInstance()->isOptionChecked(MenuOption::Avatars)) {
@@ -272,24 +273,19 @@ bool Avatar::findRayIntersection(const glm::vec3& origin, const glm::vec3& direc
}
bool Avatar::findSphereCollisions(const glm::vec3& penetratorCenter, float penetratorRadius,
- ModelCollisionList& collisions, int skeletonSkipIndex) {
- bool didPenetrate = false;
- glm::vec3 skeletonPenetration;
- ModelCollisionInfo collisionInfo;
- if (_skeletonModel.findSphereCollision(penetratorCenter, penetratorRadius, collisionInfo, 1.0f, skeletonSkipIndex)) {
- collisionInfo._model = &_skeletonModel;
- collisions.push_back(collisionInfo);
- didPenetrate = true;
- }
- if (_head.getFaceModel().findSphereCollision(penetratorCenter, penetratorRadius, collisionInfo)) {
- collisionInfo._model = &(_head.getFaceModel());
- collisions.push_back(collisionInfo);
- didPenetrate = true;
- }
- return didPenetrate;
+ CollisionList& collisions, int skeletonSkipIndex) {
+ // Temporarily disabling collisions against the skeleton because the collision proxies up
+ // near the neck are bad and prevent the hand from hitting the face.
+ //return _skeletonModel.findSphereCollisions(penetratorCenter, penetratorRadius, collisions, 1.0f, skeletonSkipIndex);
+ return _head.getFaceModel().findSphereCollisions(penetratorCenter, penetratorRadius, collisions);
}
-bool Avatar::findSphereCollisionWithHands(const glm::vec3& sphereCenter, float sphereRadius, CollisionInfo& collision) {
+bool Avatar::findParticleCollisions(const glm::vec3& particleCenter, float particleRadius, CollisionList& collisions) {
+ if (_collisionFlags & COLLISION_GROUP_PARTICLES) {
+ return false;
+ }
+ bool collided = false;
+ // first do the hand collisions
const HandData* handData = getHandData();
if (handData) {
for (int i = 0; i < NUM_HANDS; i++) {
@@ -307,41 +303,55 @@ bool Avatar::findSphereCollisionWithHands(const glm::vec3& sphereCenter, float s
break;
}
}
+
+ int jointIndex = -1;
glm::vec3 handPosition;
if (i == 0) {
_skeletonModel.getLeftHandPosition(handPosition);
+ jointIndex = _skeletonModel.getLeftHandJointIndex();
}
else {
_skeletonModel.getRightHandPosition(handPosition);
+ jointIndex = _skeletonModel.getRightHandJointIndex();
}
glm::vec3 diskCenter = handPosition + HAND_PADDLE_OFFSET * fingerAxis;
glm::vec3 diskNormal = palm->getNormal();
- float diskThickness = 0.08f;
+ const float DISK_THICKNESS = 0.08f;
// collide against the disk
- if (findSphereDiskPenetration(sphereCenter, sphereRadius,
- diskCenter, HAND_PADDLE_RADIUS, diskThickness, diskNormal,
- collision._penetration)) {
- collision._addedVelocity = palm->getVelocity();
- return true;
+ glm::vec3 penetration;
+ if (findSphereDiskPenetration(particleCenter, particleRadius,
+ diskCenter, HAND_PADDLE_RADIUS, DISK_THICKNESS, diskNormal,
+ penetration)) {
+ CollisionInfo* collision = collisions.getNewCollision();
+ if (collision) {
+ collision->_type = PADDLE_HAND_COLLISION;
+ collision->_flags = jointIndex;
+ collision->_penetration = penetration;
+ collision->_addedVelocity = palm->getVelocity();
+ collided = true;
+ } else {
+ // collisions are full, so we might as well bail now
+ return collided;
+ }
}
}
}
}
- return false;
-}
-
-/* adebug TODO: make this work again
-bool Avatar::findSphereCollisionWithSkeleton(const glm::vec3& sphereCenter, float sphereRadius, CollisionInfo& collision) {
- int jointIndex = _skeletonModel.findSphereCollision(sphereCenter, sphereRadius, collision._penetration);
- if (jointIndex != -1) {
- collision._penetration /= (float)(TREE_SCALE);
- collision._addedVelocity = getVelocity();
- return true;
+ // then collide against the models
+ int preNumCollisions = collisions.size();
+ if (_skeletonModel.findSphereCollisions(particleCenter, particleRadius, collisions)) {
+ // the Model doesn't have velocity info, so we have to set it for each new collision
+ int postNumCollisions = collisions.size();
+ for (int i = preNumCollisions; i < postNumCollisions; ++i) {
+ CollisionInfo* collision = collisions.getCollision(i);
+ collision->_penetration /= (float)(TREE_SCALE);
+ collision->_addedVelocity = getVelocity();
+ }
+ collided = true;
}
- return false;
+ return collided;
}
-*/
void Avatar::setFaceModelURL(const QUrl &faceModelURL) {
AvatarData::setFaceModelURL(faceModelURL);
@@ -426,9 +436,9 @@ void Avatar::updateCollisionFlags() {
if (Menu::getInstance()->isOptionChecked(MenuOption::CollideWithVoxels)) {
_collisionFlags |= COLLISION_GROUP_VOXELS;
}
- //if (Menu::getInstance()->isOptionChecked(MenuOption::CollideWithParticles)) {
- // _collisionFlags |= COLLISION_GROUP_PARTICLES;
- //}
+ if (Menu::getInstance()->isOptionChecked(MenuOption::CollideWithParticles)) {
+ _collisionFlags |= COLLISION_GROUP_PARTICLES;
+ }
}
void Avatar::setScale(float scale) {
@@ -445,20 +455,34 @@ float Avatar::getHeight() const {
return extents.maximum.y - extents.minimum.y;
}
-bool Avatar::isPokeable(ModelCollisionInfo& collision) const {
- // ATM only the Skeleton is pokeable
- // TODO: make poke affect head
- if (collision._model == &_skeletonModel && collision._jointIndex != -1) {
- return _skeletonModel.isPokeable(collision);
+bool Avatar::collisionWouldMoveAvatar(CollisionInfo& collision) const {
+ if (!collision._data || collision._type != MODEL_COLLISION) {
+ return false;
+ }
+ Model* model = static_cast(collision._data);
+ int jointIndex = collision._flags;
+
+ if (model == &(_skeletonModel) && jointIndex != -1) {
+ // collision response of skeleton is temporarily disabled
+ return false;
+ //return _skeletonModel.collisionHitsMoveableJoint(collision);
+ }
+ if (model == &(_head.getFaceModel())) {
+ // ATM we always handle MODEL_COLLISIONS against the face.
+ return true;
}
return false;
}
-bool Avatar::poke(ModelCollisionInfo& collision) {
- if (collision._model == &_skeletonModel && collision._jointIndex != -1) {
- return _skeletonModel.poke(collision);
+void Avatar::applyCollision(CollisionInfo& collision) {
+ if (!collision._data || collision._type != MODEL_COLLISION) {
+ return;
+ }
+ // TODO: make skeleton also respond to collisions
+ Model* model = static_cast(collision._data);
+ if (model == &(_head.getFaceModel())) {
+ _head.applyCollision(collision);
}
- return false;
}
float Avatar::getPelvisFloatingHeight() const {
diff --git a/interface/src/avatar/Avatar.h b/interface/src/avatar/Avatar.h
index 7e8a1d8f64..cc1168ca88 100755
--- a/interface/src/avatar/Avatar.h
+++ b/interface/src/avatar/Avatar.h
@@ -57,8 +57,6 @@ enum ScreenTintLayer {
NUM_SCREEN_TINT_LAYERS
};
-typedef QVector ModelCollisionList;
-
// Where one's own Avatar begins in the world (will be overwritten if avatar data file is found)
// this is basically in the center of the ground plane. Slightly adjusted. This was asked for by
// Grayson as he's building a street around here for demo dinner 2
@@ -97,26 +95,19 @@ public:
/// Checks for penetration between the described sphere and the avatar.
/// \param penetratorCenter the center of the penetration test sphere
/// \param penetratorRadius the radius of the penetration test sphere
- /// \param collisions[out] a list of collisions
+ /// \param collisions[out] a list to which collisions get appended
/// \param skeletonSkipIndex if not -1, the index of a joint to skip (along with its descendents) in the skeleton model
/// \return whether or not the sphere penetrated
bool findSphereCollisions(const glm::vec3& penetratorCenter, float penetratorRadius,
- ModelCollisionList& collisions, int skeletonSkipIndex = -1);
+ CollisionList& collisions, int skeletonSkipIndex = -1);
- /// Checks for collision between the a sphere and the avatar's (paddle) hands.
- /// \param collisionCenter the center of the penetration test sphere
- /// \param collisionRadius the radius of the penetration test sphere
- /// \param collision[out] the details of the collision point
- /// \return whether or not the sphere collided
- bool findSphereCollisionWithHands(const glm::vec3& sphereCenter, float sphereRadius, CollisionInfo& collision);
+ /// Checks for collision between the a spherical particle and the avatar (including paddle hands)
+ /// \param collisionCenter the center of particle's bounding sphere
+ /// \param collisionRadius the radius of particle's bounding sphere
+ /// \param collisions[out] a list to which collisions get appended
+ /// \return whether or not the particle collided
+ bool findParticleCollisions(const glm::vec3& particleCenter, float particleRadius, CollisionList& collisions);
- /// Checks for collision between the a sphere and the avatar's skeleton (including hand capsules).
- /// \param collisionCenter the center of the penetration test sphere
- /// \param collisionRadius the radius of the penetration test sphere
- /// \param collision[out] the details of the collision point
- /// \return whether or not the sphere collided
- //bool findSphereCollisionWithSkeleton(const glm::vec3& sphereCenter, float sphereRadius, CollisionInfo& collision);
-
virtual bool isMyAvatar() { return false; }
virtual void setFaceModelURL(const QUrl& faceModelURL);
@@ -126,14 +117,13 @@ public:
static void renderJointConnectingCone(glm::vec3 position1, glm::vec3 position2, float radius1, float radius2);
- float getHeight() const;
-
/// \return true if we expect the avatar would move as a result of the collision
- bool isPokeable(ModelCollisionInfo& collision) const;
+ bool collisionWouldMoveAvatar(CollisionInfo& collision) const;
/// \param collision a data structure for storing info about collisions against Models
- /// \return true if the collision affects the Avatar models
- bool poke(ModelCollisionInfo& collision);
+ void applyCollision(CollisionInfo& collision);
+
+ float getBoundingRadius() const { return 0.5f * getHeight(); }
public slots:
void updateCollisionFlags();
@@ -165,6 +155,7 @@ protected:
glm::quat computeRotationFromBodyToWorldUp(float proportion = 1.0f) const;
void setScale(float scale);
+ float getHeight() const;
float getPelvisFloatingHeight() const;
float getPelvisToHeadLength() const;
diff --git a/interface/src/avatar/FaceModel.cpp b/interface/src/avatar/FaceModel.cpp
index b041f5bc2d..c9d2565cee 100644
--- a/interface/src/avatar/FaceModel.cpp
+++ b/interface/src/avatar/FaceModel.cpp
@@ -20,6 +20,7 @@ FaceModel::FaceModel(Head* owningHead) :
void FaceModel::simulate(float deltaTime) {
if (!isActive()) {
+ Model::simulate(deltaTime);
return;
}
Avatar* owningAvatar = static_cast(_owningHead->_owningAvatar);
diff --git a/interface/src/avatar/Hand.cpp b/interface/src/avatar/Hand.cpp
index 1239e38818..7c9905557e 100644
--- a/interface/src/avatar/Hand.cpp
+++ b/interface/src/avatar/Hand.cpp
@@ -57,7 +57,6 @@ void Hand::simulate(float deltaTime, bool isMine) {
if (isMine) {
_buckyBalls.simulate(deltaTime);
- updateCollisions();
}
calculateGeometry();
@@ -126,92 +125,111 @@ void Hand::simulate(float deltaTime, bool isMine) {
}
}
-void Hand::updateCollisions() {
- // use position to obtain the left and right palm indices
- int leftPalmIndex, rightPalmIndex;
- getLeftRightPalmIndices(leftPalmIndex, rightPalmIndex);
-
- ModelCollisionList collisions;
- // check for collisions
+// We create a static CollisionList that is recycled for each collision test.
+const float MAX_COLLISIONS_PER_AVATAR = 32;
+static CollisionList handCollisions(MAX_COLLISIONS_PER_AVATAR);
+
+void Hand::collideAgainstAvatar(Avatar* avatar, bool isMyHand) {
+ if (!avatar || avatar == _owningAvatar) {
+ // don't collide with our own hands (that is done elsewhere)
+ return;
+ }
+ float scaledPalmRadius = PALM_COLLISION_RADIUS * _owningAvatar->getScale();
for (size_t i = 0; i < getNumPalms(); i++) {
PalmData& palm = getPalms()[i];
if (!palm.isActive()) {
continue;
}
- float scaledPalmRadius = PALM_COLLISION_RADIUS * _owningAvatar->getScale();
glm::vec3 totalPenetration;
-
- if (Menu::getInstance()->isOptionChecked(MenuOption::CollideWithAvatars)) {
- // check other avatars
- foreach (const AvatarSharedPointer& avatarPointer, Application::getInstance()->getAvatarManager().getAvatarHash()) {
- Avatar* avatar = static_cast(avatarPointer.data());
- if (avatar == _owningAvatar) {
- // don't collid with our own hands
+ if (isMyHand && Menu::getInstance()->isOptionChecked(MenuOption::PlaySlaps)) {
+ // Check for palm collisions
+ glm::vec3 myPalmPosition = palm.getPosition();
+ float palmCollisionDistance = 0.1f;
+ bool wasColliding = palm.getIsCollidingWithPalm();
+ palm.setIsCollidingWithPalm(false);
+ // If 'Play Slaps' is enabled, look for palm-to-palm collisions and make sound
+ for (size_t j = 0; j < avatar->getHand().getNumPalms(); j++) {
+ PalmData& otherPalm = avatar->getHand().getPalms()[j];
+ if (!otherPalm.isActive()) {
continue;
}
- if (Menu::getInstance()->isOptionChecked(MenuOption::PlaySlaps)) {
- // Check for palm collisions
- glm::vec3 myPalmPosition = palm.getPosition();
- float palmCollisionDistance = 0.1f;
- bool wasColliding = palm.getIsCollidingWithPalm();
- palm.setIsCollidingWithPalm(false);
- // If 'Play Slaps' is enabled, look for palm-to-palm collisions and make sound
- for (size_t j = 0; j < avatar->getHand().getNumPalms(); j++) {
- PalmData& otherPalm = avatar->getHand().getPalms()[j];
- if (!otherPalm.isActive()) {
- continue;
- }
- glm::vec3 otherPalmPosition = otherPalm.getPosition();
- if (glm::length(otherPalmPosition - myPalmPosition) < palmCollisionDistance) {
- palm.setIsCollidingWithPalm(true);
- if (!wasColliding) {
- const float PALM_COLLIDE_VOLUME = 1.f;
- const float PALM_COLLIDE_FREQUENCY = 1000.f;
- const float PALM_COLLIDE_DURATION_MAX = 0.75f;
- const float PALM_COLLIDE_DECAY_PER_SAMPLE = 0.01f;
- Application::getInstance()->getAudio()->startDrumSound(PALM_COLLIDE_VOLUME,
- PALM_COLLIDE_FREQUENCY,
- PALM_COLLIDE_DURATION_MAX,
- PALM_COLLIDE_DECAY_PER_SAMPLE);
- // If the other person's palm is in motion, move mine downward to show I was hit
- const float MIN_VELOCITY_FOR_SLAP = 0.05f;
- if (glm::length(otherPalm.getVelocity()) > MIN_VELOCITY_FOR_SLAP) {
- // add slapback here
- }
- }
- }
- }
- }
- if (avatar->findSphereCollisions(palm.getPosition(), scaledPalmRadius, collisions)) {
- for (int j = 0; j < collisions.size(); ++j) {
- // we don't resolve penetrations that would poke the other avatar
- if (!avatar->isPokeable(collisions[j])) {
- totalPenetration = addPenetrations(totalPenetration, collisions[j]._penetration);
+ glm::vec3 otherPalmPosition = otherPalm.getPosition();
+ if (glm::length(otherPalmPosition - myPalmPosition) < palmCollisionDistance) {
+ palm.setIsCollidingWithPalm(true);
+ if (!wasColliding) {
+ const float PALM_COLLIDE_VOLUME = 1.f;
+ const float PALM_COLLIDE_FREQUENCY = 1000.f;
+ const float PALM_COLLIDE_DURATION_MAX = 0.75f;
+ const float PALM_COLLIDE_DECAY_PER_SAMPLE = 0.01f;
+ Application::getInstance()->getAudio()->startDrumSound(PALM_COLLIDE_VOLUME,
+ PALM_COLLIDE_FREQUENCY,
+ PALM_COLLIDE_DURATION_MAX,
+ PALM_COLLIDE_DECAY_PER_SAMPLE);
+ // If the other person's palm is in motion, move mine downward to show I was hit
+ const float MIN_VELOCITY_FOR_SLAP = 0.05f;
+ if (glm::length(otherPalm.getVelocity()) > MIN_VELOCITY_FOR_SLAP) {
+ // add slapback here
}
}
}
}
}
-
- if (Menu::getInstance()->isOptionChecked(MenuOption::HandsCollideWithSelf)) {
- // and the current avatar (ignoring everything below the parent of the parent of the last free joint)
- collisions.clear();
- const Model& skeletonModel = _owningAvatar->getSkeletonModel();
- int skipIndex = skeletonModel.getParentJointIndex(skeletonModel.getParentJointIndex(
- skeletonModel.getLastFreeJointIndex((i == leftPalmIndex) ? skeletonModel.getLeftHandJointIndex() :
- (i == rightPalmIndex) ? skeletonModel.getRightHandJointIndex() : -1)));
- if (_owningAvatar->findSphereCollisions(palm.getPosition(), scaledPalmRadius, collisions, skipIndex)) {
- for (int j = 0; j < collisions.size(); ++j) {
- totalPenetration = addPenetrations(totalPenetration, collisions[j]._penetration);
+ handCollisions.clear();
+ if (avatar->findSphereCollisions(palm.getPosition(), scaledPalmRadius, handCollisions)) {
+ for (int j = 0; j < handCollisions.size(); ++j) {
+ CollisionInfo* collision = handCollisions.getCollision(j);
+ if (isMyHand) {
+ if (!avatar->collisionWouldMoveAvatar(*collision)) {
+ // we resolve the hand from collision when it belongs to MyAvatar AND the other Avatar is
+ // not expected to respond to the collision (hand hit unmovable part of their Avatar)
+ totalPenetration = addPenetrations(totalPenetration, collision->_penetration);
+ }
+ } else {
+ // when !isMyHand then avatar is MyAvatar and we apply the collision
+ // which might not do anything (hand hit unmovable part of MyAvatar) however
+ // we don't resolve the hand's penetration because we expect the remote
+ // simulation to do the right thing.
+ avatar->applyCollision(*collision);
}
}
}
-
- // un-penetrate
- palm.addToPosition(-totalPenetration);
+ if (isMyHand) {
+ // resolve penetration
+ palm.addToPosition(-totalPenetration);
+ }
+ }
+}
- // we recycle the collisions container, so we clear it for the next loop
- collisions.clear();
+void Hand::collideAgainstOurself() {
+ if (!Menu::getInstance()->isOptionChecked(MenuOption::HandsCollideWithSelf)) {
+ return;
+ }
+
+ int leftPalmIndex, rightPalmIndex;
+ getLeftRightPalmIndices(leftPalmIndex, rightPalmIndex);
+ float scaledPalmRadius = PALM_COLLISION_RADIUS * _owningAvatar->getScale();
+
+ for (size_t i = 0; i < getNumPalms(); i++) {
+ PalmData& palm = getPalms()[i];
+ if (!palm.isActive()) {
+ continue;
+ }
+ const Model& skeletonModel = _owningAvatar->getSkeletonModel();
+ // ignoring everything below the parent of the parent of the last free joint
+ int skipIndex = skeletonModel.getParentJointIndex(skeletonModel.getParentJointIndex(
+ skeletonModel.getLastFreeJointIndex((i == leftPalmIndex) ? skeletonModel.getLeftHandJointIndex() :
+ (i == rightPalmIndex) ? skeletonModel.getRightHandJointIndex() : -1)));
+
+ handCollisions.clear();
+ glm::vec3 totalPenetration;
+ if (_owningAvatar->findSphereCollisions(palm.getPosition(), scaledPalmRadius, handCollisions, skipIndex)) {
+ for (int j = 0; j < handCollisions.size(); ++j) {
+ CollisionInfo* collision = handCollisions.getCollision(j);
+ totalPenetration = addPenetrations(totalPenetration, collision->_penetration);
+ }
+ }
+ // resolve penetration
+ palm.addToPosition(-totalPenetration);
}
}
diff --git a/interface/src/avatar/Hand.h b/interface/src/avatar/Hand.h
index c2f49a15e5..5a423630b4 100755
--- a/interface/src/avatar/Hand.h
+++ b/interface/src/avatar/Hand.h
@@ -58,6 +58,9 @@ public:
const glm::vec3& getLeapFingerTipBallPosition (int ball) const { return _leapFingerTipBalls [ball].position;}
const glm::vec3& getLeapFingerRootBallPosition(int ball) const { return _leapFingerRootBalls[ball].position;}
+ void collideAgainstAvatar(Avatar* avatar, bool isMyHand);
+ void collideAgainstOurself();
+
private:
// disallow copies of the Hand, copy of owning Avatar is disallowed too
Hand(const Hand&);
@@ -87,7 +90,6 @@ private:
void renderLeapHands(bool isMine);
void renderLeapFingerTrails();
- void updateCollisions();
void calculateGeometry();
void handleVoxelCollision(PalmData* palm, const glm::vec3& fingerTipPosition, VoxelTreeElement* voxel, float deltaTime);
diff --git a/interface/src/avatar/Head.cpp b/interface/src/avatar/Head.cpp
index e5d4724bb5..ddb0660364 100644
--- a/interface/src/avatar/Head.cpp
+++ b/interface/src/avatar/Head.cpp
@@ -219,6 +219,34 @@ float Head::getTweakedRoll() const {
return glm::clamp(_roll + _tweakedRoll, MIN_HEAD_ROLL, MAX_HEAD_ROLL);
}
+void Head::applyCollision(CollisionInfo& collision) {
+ // HACK: the collision proxies for the FaceModel are bad. As a temporary workaround
+ // we collide against a hard coded collision proxy.
+ // TODO: get a better collision proxy here.
+ const float HEAD_RADIUS = 0.15f;
+ const glm::vec3 HEAD_CENTER = _position;
+
+ // collide the contactPoint against the collision proxy to obtain a new penetration
+ // NOTE: that penetration is in opposite direction (points the way out for the point, not the sphere)
+ glm::vec3 penetration;
+ if (findPointSpherePenetration(collision._contactPoint, HEAD_CENTER, HEAD_RADIUS, penetration)) {
+ // compute lean angles
+ Avatar* owningAvatar = static_cast(_owningAvatar);
+ glm::quat bodyRotation = owningAvatar->getOrientation();
+ glm::vec3 neckPosition;
+ if (owningAvatar->getSkeletonModel().getNeckPosition(neckPosition)) {
+ glm::vec3 xAxis = bodyRotation * glm::vec3(1.f, 0.f, 0.f);
+ glm::vec3 zAxis = bodyRotation * glm::vec3(0.f, 0.f, 1.f);
+ float neckLength = glm::length(_position - neckPosition);
+ if (neckLength > 0.f) {
+ float forward = glm::dot(collision._penetration, zAxis) / neckLength;
+ float sideways = - glm::dot(collision._penetration, xAxis) / neckLength;
+ addLean(sideways, forward);
+ }
+ }
+ }
+}
+
void Head::renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition) {
Application::getInstance()->getGlowEffect()->begin();
diff --git a/interface/src/avatar/Head.h b/interface/src/avatar/Head.h
index 19f9efd8e6..c88e654d95 100644
--- a/interface/src/avatar/Head.h
+++ b/interface/src/avatar/Head.h
@@ -79,6 +79,8 @@ public:
float getTweakedPitch() const;
float getTweakedYaw() const;
float getTweakedRoll() const;
+
+ void applyCollision(CollisionInfo& collisionInfo);
private:
// disallow copies of the Head, copy of owning Avatar is disallowed too
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 0e2625bf0f..6673abe88b 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -112,23 +112,7 @@ void MyAvatar::updateTransmitter(float deltaTime) {
void MyAvatar::update(float deltaTime) {
updateTransmitter(deltaTime);
- // TODO: resurrect touch interactions between avatars
- //// rotate body yaw for yaw received from multitouch
- //setOrientation(getOrientation() * glm::quat(glm::vec3(0, _yawFromTouch, 0)));
- //_yawFromTouch = 0.f;
- //
- //// apply pitch from touch
- //_head.setPitch(_head.getPitch() + _pitchFromTouch);
- //_pitchFromTouch = 0.0f;
- //
- //float TOUCH_YAW_SCALE = -0.25f;
- //float TOUCH_PITCH_SCALE = -12.5f;
- //float FIXED_TOUCH_TIMESTEP = 0.016f;
- //_yawFromTouch += ((_touchAvgX - _lastTouchAvgX) * TOUCH_YAW_SCALE * FIXED_TOUCH_TIMESTEP);
- //_pitchFromTouch += ((_touchAvgY - _lastTouchAvgY) * TOUCH_PITCH_SCALE * FIXED_TOUCH_TIMESTEP);
-
- // Update my avatar's state from gyros
- updateFromGyros(Menu::getInstance()->isOptionChecked(MenuOption::TurnWithHead));
+ updateFromGyros(deltaTime);
// Update head mouse from faceshift if active
Faceshift* faceshift = Application::getInstance()->getFaceshift();
@@ -329,6 +313,7 @@ void MyAvatar::simulate(float deltaTime) {
_position += _velocity * deltaTime;
// update avatar skeleton and simulate hand and head
+ _hand.collideAgainstOurself();
_hand.simulate(deltaTime, true);
_skeletonModel.simulate(deltaTime);
_head.setBodyRotation(glm::vec3(_bodyPitch, _bodyYaw, _bodyRoll));
@@ -348,7 +333,7 @@ void MyAvatar::simulate(float deltaTime) {
const float MAX_PITCH = 90.0f;
// Update avatar head rotation with sensor data
-void MyAvatar::updateFromGyros(bool turnWithHead) {
+void MyAvatar::updateFromGyros(float deltaTime) {
Faceshift* faceshift = Application::getInstance()->getFaceshift();
glm::vec3 estimatedPosition, estimatedRotation;
@@ -356,7 +341,7 @@ void MyAvatar::updateFromGyros(bool turnWithHead) {
estimatedPosition = faceshift->getHeadTranslation();
estimatedRotation = safeEulerAngles(faceshift->getHeadRotation());
// Rotate the body if the head is turned beyond the screen
- if (turnWithHead) {
+ if (Menu::getInstance()->isOptionChecked(MenuOption::TurnWithHead)) {
const float FACESHIFT_YAW_TURN_SENSITIVITY = 0.5f;
const float FACESHIFT_MIN_YAW_TURN = 15.f;
const float FACESHIFT_MAX_YAW_TURN = 50.f;
@@ -371,11 +356,12 @@ void MyAvatar::updateFromGyros(bool turnWithHead) {
}
} else {
// restore rotation, lean to neutral positions
- const float RESTORE_RATE = 0.05f;
- _head.setYaw(glm::mix(_head.getYaw(), 0.0f, RESTORE_RATE));
- _head.setRoll(glm::mix(_head.getRoll(), 0.0f, RESTORE_RATE));
- _head.setLeanSideways(glm::mix(_head.getLeanSideways(), 0.0f, RESTORE_RATE));
- _head.setLeanForward(glm::mix(_head.getLeanForward(), 0.0f, RESTORE_RATE));
+ const float RESTORE_PERIOD = 1.f; // seconds
+ float restorePercentage = glm::clamp(deltaTime/RESTORE_PERIOD, 0.f, 1.f);
+ _head.setYaw(glm::mix(_head.getYaw(), 0.0f, restorePercentage));
+ _head.setRoll(glm::mix(_head.getRoll(), 0.0f, restorePercentage));
+ _head.setLeanSideways(glm::mix(_head.getLeanSideways(), 0.0f, restorePercentage));
+ _head.setLeanForward(glm::mix(_head.getLeanForward(), 0.0f, restorePercentage));
return;
}
@@ -854,7 +840,6 @@ void MyAvatar::updateCollisionWithEnvironment(float deltaTime, float radius) {
}
}
-
void MyAvatar::updateCollisionWithVoxels(float deltaTime, float radius) {
const float VOXEL_ELASTICITY = 0.4f;
const float VOXEL_DAMPING = 0.0f;
@@ -970,7 +955,7 @@ void MyAvatar::updateCollisionWithAvatars(float deltaTime) {
// no need to compute a bunch of stuff if we have one or fewer avatars
return;
}
- float myBoundingRadius = 0.5f * getHeight();
+ float myBoundingRadius = getBoundingRadius();
// HACK: body-body collision uses two coaxial capsules with axes parallel to y-axis
// TODO: make the collision work without assuming avatar orientation
@@ -990,7 +975,7 @@ void MyAvatar::updateCollisionWithAvatars(float deltaTime) {
if (_distanceToNearestAvatar > distance) {
_distanceToNearestAvatar = distance;
}
- float theirBoundingRadius = 0.5f * avatar->getHeight();
+ float theirBoundingRadius = avatar->getBoundingRadius();
if (distance < myBoundingRadius + theirBoundingRadius) {
Extents theirStaticExtents = _skeletonModel.getStaticExtents();
glm::vec3 staticScale = theirStaticExtents.maximum - theirStaticExtents.minimum;
@@ -1002,8 +987,13 @@ void MyAvatar::updateCollisionWithAvatars(float deltaTime) {
avatar->getPosition(), theirCapsuleRadius, theirCapsuleHeight, penetration)) {
// move the avatar out by half the penetration
setPosition(_position - 0.5f * penetration);
- glm::vec3 pushOut = 0.5f * penetration;
}
+
+ // collide our hands against them
+ _hand.collideAgainstAvatar(avatar, true);
+
+ // collide their hands against us
+ avatar->getHand().collideAgainstAvatar(this, false);
}
}
}
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index 8f4f96ffcf..d8cb4c05aa 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -34,7 +34,7 @@ public:
void reset();
void update(float deltaTime);
void simulate(float deltaTime);
- void updateFromGyros(bool turnWithHead);
+ void updateFromGyros(float deltaTime);
void updateTransmitter(float deltaTime);
void render(bool forceRenderHead);
diff --git a/interface/src/avatar/SkeletonModel.cpp b/interface/src/avatar/SkeletonModel.cpp
index ac08c52b49..9bf2e0f727 100644
--- a/interface/src/avatar/SkeletonModel.cpp
+++ b/interface/src/avatar/SkeletonModel.cpp
@@ -21,9 +21,9 @@ SkeletonModel::SkeletonModel(Avatar* owningAvatar) :
void SkeletonModel::simulate(float deltaTime) {
if (!isActive()) {
+ Model::simulate(deltaTime);
return;
}
-
setTranslation(_owningAvatar->getPosition());
setRotation(_owningAvatar->getOrientation() * glm::angleAxis(180.0f, 0.0f, 1.0f, 0.0f));
const float MODEL_SCALE = 0.0006f;
@@ -36,23 +36,24 @@ void SkeletonModel::simulate(float deltaTime) {
HandData& hand = _owningAvatar->getHand();
hand.getLeftRightPalmIndices(leftPalmIndex, rightPalmIndex);
- const float HAND_RESTORATION_RATE = 0.25f;
+ const float HAND_RESTORATION_PERIOD = 1.f; // seconds
+ float handRestorePercent = glm::clamp(deltaTime / HAND_RESTORATION_PERIOD, 0.f, 1.f);
const FBXGeometry& geometry = _geometry->getFBXGeometry();
if (leftPalmIndex == -1) {
// no Leap data; set hands from mouse
if (_owningAvatar->getHandState() == HAND_STATE_NULL) {
- restoreRightHandPosition(HAND_RESTORATION_RATE);
+ restoreRightHandPosition(handRestorePercent);
} else {
applyHandPosition(geometry.rightHandJointIndex, _owningAvatar->getHandPosition());
}
- restoreLeftHandPosition(HAND_RESTORATION_RATE);
+ restoreLeftHandPosition(handRestorePercent);
} else if (leftPalmIndex == rightPalmIndex) {
// right hand only
applyPalmData(geometry.rightHandJointIndex, geometry.rightFingerJointIndices, geometry.rightFingertipJointIndices,
hand.getPalms()[leftPalmIndex]);
- restoreLeftHandPosition(HAND_RESTORATION_RATE);
+ restoreLeftHandPosition(handRestorePercent);
} else {
applyPalmData(geometry.leftHandJointIndex, geometry.leftFingerJointIndices, geometry.leftFingertipJointIndices,
diff --git a/interface/src/renderer/GeometryCache.cpp b/interface/src/renderer/GeometryCache.cpp
index dfe6949438..78cc657018 100644
--- a/interface/src/renderer/GeometryCache.cpp
+++ b/interface/src/renderer/GeometryCache.cpp
@@ -294,23 +294,34 @@ QSharedPointer GeometryCache::getGeometry(const QUrl& url, cons
if (geometry.isNull()) {
geometry = QSharedPointer(new NetworkGeometry(url, fallback.isValid() ?
getGeometry(fallback) : QSharedPointer()));
+ geometry->setLODParent(geometry);
_networkGeometry.insert(url, geometry);
}
return geometry;
}
-NetworkGeometry::NetworkGeometry(const QUrl& url, const QSharedPointer& fallback) :
+const float NetworkGeometry::NO_HYSTERESIS = -1.0f;
+
+NetworkGeometry::NetworkGeometry(const QUrl& url, const QSharedPointer& fallback,
+ const QVariantHash& mapping, const QUrl& textureBase) :
_request(url),
_reply(NULL),
- _textureBase(url),
+ _mapping(mapping),
+ _textureBase(textureBase.isValid() ? textureBase : url),
_fallback(fallback),
+ _startedLoading(false),
+ _failedToLoad(false),
_attempts(0) {
if (!url.isValid()) {
return;
}
_request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
- makeRequest();
+
+ // if we already have a mapping (because we're an LOD), hold off on loading until we're requested
+ if (mapping.isEmpty()) {
+ makeRequest();
+ }
}
NetworkGeometry::~NetworkGeometry() {
@@ -319,6 +330,52 @@ NetworkGeometry::~NetworkGeometry() {
}
}
+QSharedPointer NetworkGeometry::getLODOrFallback(float distance, float& hysteresis) const {
+ if (_lodParent.data() != this) {
+ return _lodParent.data()->getLODOrFallback(distance, hysteresis);
+ }
+ if (_failedToLoad && _fallback) {
+ return _fallback;
+ }
+ QSharedPointer lod = _lodParent;
+ float lodDistance = 0.0f;
+ QMap >::const_iterator it = _lods.upperBound(distance);
+ if (it != _lods.constBegin()) {
+ it = it - 1;
+ lod = it.value();
+ lodDistance = it.key();
+ }
+ if (hysteresis != NO_HYSTERESIS && hysteresis != lodDistance) {
+ // if we previously selected a different distance, make sure we've moved far enough to justify switching
+ const float HYSTERESIS_PROPORTION = 0.1f;
+ if (glm::abs(distance - qMax(hysteresis, lodDistance)) / fabsf(hysteresis - lodDistance) < HYSTERESIS_PROPORTION) {
+ return getLODOrFallback(hysteresis, hysteresis);
+ }
+ }
+ if (lod->isLoaded()) {
+ hysteresis = lodDistance;
+ return lod;
+ }
+ // if the ideal LOD isn't loaded, we need to make sure it's started to load, and possibly return the closest loaded one
+ if (!lod->_startedLoading) {
+ lod->makeRequest();
+ }
+ float closestDistance = FLT_MAX;
+ if (isLoaded()) {
+ lod = _lodParent;
+ closestDistance = distance;
+ }
+ for (it = _lods.constBegin(); it != _lods.constEnd(); it++) {
+ float distanceToLOD = glm::abs(distance - it.key());
+ if (it.value()->isLoaded() && distanceToLOD < closestDistance) {
+ lod = it.value();
+ closestDistance = distanceToLOD;
+ }
+ }
+ hysteresis = NO_HYSTERESIS;
+ return lod;
+}
+
glm::vec4 NetworkGeometry::computeAverageColor() const {
glm::vec4 totalColor;
int totalTriangles = 0;
@@ -344,6 +401,7 @@ glm::vec4 NetworkGeometry::computeAverageColor() const {
}
void NetworkGeometry::makeRequest() {
+ _startedLoading = true;
_reply = Application::getInstance()->getNetworkAccessManager()->get(_request);
connect(_reply, SIGNAL(downloadProgress(qint64,qint64)), SLOT(handleDownloadProgress(qint64,qint64)));
@@ -367,7 +425,8 @@ void NetworkGeometry::handleDownloadProgress(qint64 bytesReceived, qint64 bytesT
QString filename = _mapping.value("filename").toString();
if (filename.isNull()) {
qDebug() << "Mapping file " << url << " has no filename.";
- maybeLoadFallback();
+ _failedToLoad = true;
+
} else {
QString texdir = _mapping.value("texdir").toString();
if (!texdir.isNull()) {
@@ -376,8 +435,20 @@ void NetworkGeometry::handleDownloadProgress(qint64 bytesReceived, qint64 bytesT
}
_textureBase = url.resolved(texdir);
}
+ QVariantHash lods = _mapping.value("lod").toHash();
+ for (QVariantHash::const_iterator it = lods.begin(); it != lods.end(); it++) {
+ QSharedPointer geometry(new NetworkGeometry(url.resolved(it.key()),
+ QSharedPointer(), _mapping, _textureBase));
+ geometry->setLODParent(_lodParent);
+ _lods.insert(it.value().toFloat(), geometry);
+ }
_request.setUrl(url.resolved(filename));
- makeRequest();
+
+ // make the request immediately only if we have no LODs to switch between
+ _startedLoading = false;
+ if (_lods.isEmpty()) {
+ makeRequest();
+ }
}
return;
}
@@ -387,7 +458,7 @@ void NetworkGeometry::handleDownloadProgress(qint64 bytesReceived, qint64 bytesT
} catch (const QString& error) {
qDebug() << "Error reading " << url << ": " << error;
- maybeLoadFallback();
+ _failedToLoad = true;
return;
}
@@ -481,8 +552,6 @@ void NetworkGeometry::handleDownloadProgress(qint64 bytesReceived, qint64 bytesT
_meshes.append(networkMesh);
}
-
- emit loaded();
}
void NetworkGeometry::handleReplyError() {
@@ -515,28 +584,12 @@ void NetworkGeometry::handleReplyError() {
// fall through to final failure
}
default:
- maybeLoadFallback();
+ _failedToLoad = true;
break;
}
}
-void NetworkGeometry::loadFallback() {
- _geometry = _fallback->_geometry;
- _meshes = _fallback->_meshes;
- emit loaded();
-}
-
-void NetworkGeometry::maybeLoadFallback() {
- if (_fallback) {
- if (_fallback->isLoaded()) {
- loadFallback();
- } else {
- connect(_fallback.data(), SIGNAL(loaded()), SLOT(loadFallback()));
- }
- }
-}
-
bool NetworkMeshPart::isTranslucent() const {
return diffuseTexture && diffuseTexture->isTranslucent();
}
diff --git a/interface/src/renderer/GeometryCache.h b/interface/src/renderer/GeometryCache.h
index 0587831721..ef53fe9c3e 100644
--- a/interface/src/renderer/GeometryCache.h
+++ b/interface/src/renderer/GeometryCache.h
@@ -13,6 +13,7 @@
#include "InterfaceConfig.h"
#include
+#include
#include
#include
#include
@@ -61,41 +62,52 @@ class NetworkGeometry : public QObject {
public:
- NetworkGeometry(const QUrl& url, const QSharedPointer& fallback);
+ /// A hysteresis value indicating that we have no state memory.
+ static const float NO_HYSTERESIS;
+
+ NetworkGeometry(const QUrl& url, const QSharedPointer& fallback,
+ const QVariantHash& mapping = QVariantHash(), const QUrl& textureBase = QUrl());
~NetworkGeometry();
+ /// Checks whether the geometry is fulled loaded.
bool isLoaded() const { return !_geometry.joints.isEmpty(); }
+ /// Returns a pointer to the geometry appropriate for the specified distance.
+ /// \param hysteresis a hysteresis parameter that prevents rapid model switching
+ QSharedPointer getLODOrFallback(float distance, float& hysteresis) const;
+
const FBXGeometry& getFBXGeometry() const { return _geometry; }
const QVector& getMeshes() const { return _meshes; }
/// Returns the average color of all meshes in the geometry.
glm::vec4 computeAverageColor() const;
-signals:
-
- void loaded();
-
private slots:
void makeRequest();
void handleDownloadProgress(qint64 bytesReceived, qint64 bytesTotal);
void handleReplyError();
- void loadFallback();
private:
- void maybeLoadFallback();
+ friend class GeometryCache;
+
+ void setLODParent(const QWeakPointer& lodParent) { _lodParent = lodParent; }
QNetworkRequest _request;
QNetworkReply* _reply;
QVariantHash _mapping;
QUrl _textureBase;
QSharedPointer _fallback;
+ bool _startedLoading;
+ bool _failedToLoad;
int _attempts;
+ QMap > _lods;
FBXGeometry _geometry;
QVector _meshes;
+
+ QWeakPointer _lodParent;
};
/// The state associated with a single mesh part.
diff --git a/interface/src/renderer/Model.cpp b/interface/src/renderer/Model.cpp
index 18654a6efc..48e1d0f70c 100644
--- a/interface/src/renderer/Model.cpp
+++ b/interface/src/renderer/Model.cpp
@@ -90,6 +90,16 @@ void Model::reset() {
}
void Model::simulate(float deltaTime) {
+ // update our LOD
+ if (_geometry) {
+ QSharedPointer geometry = _geometry->getLODOrFallback(glm::distance(_translation,
+ Application::getInstance()->getCamera()->getPosition()), _lodHysteresis);
+ if (_geometry != geometry) {
+ deleteGeometry();
+ _dilatedTextures.clear();
+ _geometry = geometry;
+ }
+ }
if (!isActive()) {
return;
}
@@ -409,8 +419,9 @@ void Model::setURL(const QUrl& url, const QUrl& fallback) {
// delete our local geometry and custom textures
deleteGeometry();
_dilatedTextures.clear();
+ _lodHysteresis = NetworkGeometry::NO_HYSTERESIS;
- _geometry = Application::getInstance()->getGeometryCache()->getGeometry(url, fallback);
+ _baseGeometry = _geometry = Application::getInstance()->getGeometryCache()->getGeometry(url, fallback);
}
glm::vec4 Model::computeAverageColor() const {
@@ -446,9 +457,9 @@ bool Model::findRayIntersection(const glm::vec3& origin, const glm::vec3& direct
return false;
}
-bool Model::findSphereCollision(const glm::vec3& penetratorCenter, float penetratorRadius,
- ModelCollisionInfo& collisionInfo, float boneScale, int skipIndex) const {
- int jointIndex = -1;
+bool Model::findSphereCollisions(const glm::vec3& penetratorCenter, float penetratorRadius,
+ CollisionList& collisions, float boneScale, int skipIndex) const {
+ bool collided = false;
const glm::vec3 relativeCenter = penetratorCenter - _translation;
const FBXGeometry& geometry = _geometry->getFBXGeometry();
glm::vec3 totalPenetration;
@@ -477,19 +488,22 @@ bool Model::findSphereCollision(const glm::vec3& penetratorCenter, float penetra
if (findSphereCapsuleConePenetration(relativeCenter, penetratorRadius, start, end,
startRadius, endRadius, bonePenetration)) {
totalPenetration = addPenetrations(totalPenetration, bonePenetration);
- // TODO: Andrew to try to keep the joint furthest toward the root
- jointIndex = i;
+ CollisionInfo* collision = collisions.getNewCollision();
+ if (collision) {
+ collision->_type = MODEL_COLLISION;
+ collision->_data = (void*)(this);
+ collision->_flags = i;
+ collision->_contactPoint = penetratorCenter + penetratorRadius * glm::normalize(totalPenetration);
+ collision->_penetration = totalPenetration;
+ collided = true;
+ } else {
+ // collisions are full, so we might as well break
+ break;
+ }
}
outerContinue: ;
}
- if (jointIndex != -1) {
- // don't store collisionInfo._model at this stage, let the outer context do that
- collisionInfo._penetration = totalPenetration;
- collisionInfo._jointIndex = jointIndex;
- collisionInfo._contactPoint = penetratorCenter + penetratorRadius * glm::normalize(totalPenetration);
- return true;
- }
- return false;
+ return collided;
}
void Model::updateJointState(int index) {
@@ -722,24 +736,30 @@ void Model::renderCollisionProxies(float alpha) {
glPopMatrix();
}
-bool Model::isPokeable(ModelCollisionInfo& collision) const {
- // the joint is pokable by a collision if it exists and is free to move
- const FBXJoint& joint = _geometry->getFBXGeometry().joints[collision._jointIndex];
- if (joint.parentIndex == -1 || _jointStates.isEmpty()) {
- return false;
+bool Model::collisionHitsMoveableJoint(CollisionInfo& collision) const {
+ if (collision._type == MODEL_COLLISION) {
+ // the joint is pokable by a collision if it exists and is free to move
+ const FBXJoint& joint = _geometry->getFBXGeometry().joints[collision._flags];
+ if (joint.parentIndex == -1 || _jointStates.isEmpty()) {
+ return false;
+ }
+ // an empty freeLineage means the joint can't move
+ const FBXGeometry& geometry = _geometry->getFBXGeometry();
+ int jointIndex = collision._flags;
+ const QVector& freeLineage = geometry.joints.at(jointIndex).freeLineage;
+ return !freeLineage.isEmpty();
}
- // an empty freeLineage means the joint can't move
- const FBXGeometry& geometry = _geometry->getFBXGeometry();
- const QVector& freeLineage = geometry.joints.at(collision._jointIndex).freeLineage;
- return !freeLineage.isEmpty();
+ return false;
}
-bool Model::poke(ModelCollisionInfo& collision) {
- // This needs work. At the moment it can wiggle joints that are free to move (such as arms)
- // but unmovable joints (such as torso) cannot be influenced at all.
+void Model::applyCollision(CollisionInfo& collision) {
+ if (collision._type != MODEL_COLLISION) {
+ return;
+ }
+
glm::vec3 jointPosition(0.f);
- if (getJointPosition(collision._jointIndex, jointPosition)) {
- int jointIndex = collision._jointIndex;
+ int jointIndex = collision._flags;
+ if (getJointPosition(jointIndex, jointPosition)) {
const FBXJoint& joint = _geometry->getFBXGeometry().joints[jointIndex];
if (joint.parentIndex != -1) {
// compute the approximate distance (travel) that the joint needs to move
@@ -758,11 +778,10 @@ bool Model::poke(ModelCollisionInfo& collision) {
getJointPosition(jointIndex, end);
glm::vec3 newEnd = start + glm::angleAxis(glm::degrees(angle), axis) * (end - start);
// try to move it
- return setJointPosition(jointIndex, newEnd, -1, true);
+ setJointPosition(jointIndex, newEnd, -1, true);
}
}
}
- return false;
}
void Model::deleteGeometry() {
@@ -793,6 +812,10 @@ void Model::renderMeshes(float alpha, bool translucent) {
const FBXMesh& mesh = geometry.meshes.at(i);
int vertexCount = mesh.vertices.size();
+ if (vertexCount == 0) {
+ // sanity check
+ continue;
+ }
const_cast(networkMesh.vertexBuffer).bind();
@@ -902,11 +925,11 @@ void Model::renderMeshes(float alpha, bool translucent) {
qint64 offset = 0;
for (int j = 0; j < networkMesh.parts.size(); j++) {
const NetworkMeshPart& networkPart = networkMesh.parts.at(j);
+ const FBXMeshPart& part = mesh.parts.at(j);
if (networkPart.isTranslucent() != translucent) {
+ offset += (part.quadIndices.size() + part.triangleIndices.size()) * sizeof(int);
continue;
}
- const FBXMeshPart& part = mesh.parts.at(j);
-
// apply material properties
glm::vec4 diffuse = glm::vec4(part.diffuseColor, alpha);
glm::vec4 specular = glm::vec4(part.specularColor, alpha);
diff --git a/interface/src/renderer/Model.h b/interface/src/renderer/Model.h
index 003cdfe3e5..1d1cdc22a7 100644
--- a/interface/src/renderer/Model.h
+++ b/interface/src/renderer/Model.h
@@ -17,16 +17,6 @@
#include "ProgramObject.h"
#include "TextureCache.h"
-class Model;
-
-// TODO: Andrew to move this into its own file
-class ModelCollisionInfo : public CollisionInfo {
-public:
- ModelCollisionInfo() : CollisionInfo(), _model(NULL), _jointIndex(-1) {}
- Model* _model;
- int _jointIndex;
-};
-
/// A generic 3D model displaying geometry loaded from a URL.
class Model : public QObject {
Q_OBJECT
@@ -162,17 +152,18 @@ public:
bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance) const;
- bool findSphereCollision(const glm::vec3& penetratorCenter, float penetratorRadius,
- ModelCollisionInfo& collision, float boneScale = 1.0f, int skipIndex = -1) const;
+ bool findSphereCollisions(const glm::vec3& penetratorCenter, float penetratorRadius,
+ CollisionList& collisions, float boneScale = 1.0f, int skipIndex = -1) const;
void renderCollisionProxies(float alpha);
- /// \return true if the collision would move the model
- bool isPokeable(ModelCollisionInfo& collision) const;
+ /// \param collision details about the collisions
+ /// \return true if the collision is against a moveable joint
+ bool collisionHitsMoveableJoint(CollisionInfo& collision) const;
- /// \param collisionInfo info about the collision
- /// \return true if collision affects the Model
- bool poke(ModelCollisionInfo& collisionInfo);
+ /// \param collision details about the collision
+ /// Use the collision to affect the model
+ void applyCollision(CollisionInfo& collision);
protected:
@@ -236,6 +227,9 @@ private:
void deleteGeometry();
void renderMeshes(float alpha, bool translucent);
+ QSharedPointer _baseGeometry;
+ float _lodHysteresis;
+
float _pupilDilation;
std::vector _blendshapeCoefficients;
diff --git a/interface/src/ui/Base3DOverlay.cpp b/interface/src/ui/Base3DOverlay.cpp
new file mode 100644
index 0000000000..67e7ea25f2
--- /dev/null
+++ b/interface/src/ui/Base3DOverlay.cpp
@@ -0,0 +1,61 @@
+//
+// Base3DOverlay.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+
+#include "Base3DOverlay.h"
+#include "TextRenderer.h"
+
+const glm::vec3 DEFAULT_POSITION = glm::vec3(0.0f, 0.0f, 0.0f);
+const float DEFAULT_LINE_WIDTH = 1.0f;
+
+Base3DOverlay::Base3DOverlay() :
+ _position(DEFAULT_POSITION),
+ _lineWidth(DEFAULT_LINE_WIDTH)
+{
+}
+
+Base3DOverlay::~Base3DOverlay() {
+}
+
+void Base3DOverlay::setProperties(const QScriptValue& properties) {
+ Overlay::setProperties(properties);
+
+ QScriptValue position = properties.property("position");
+
+ // if "position" property was not there, check to see if they included aliases: start, point, p1
+ if (!position.isValid()) {
+ position = properties.property("start");
+ if (!position.isValid()) {
+ position = properties.property("p1");
+ if (!position.isValid()) {
+ position = properties.property("point");
+ }
+ }
+ }
+
+ if (position.isValid()) {
+ QScriptValue x = position.property("x");
+ QScriptValue y = position.property("y");
+ QScriptValue z = position.property("z");
+ if (x.isValid() && y.isValid() && z.isValid()) {
+ glm::vec3 newPosition;
+ newPosition.x = x.toVariant().toFloat();
+ newPosition.y = y.toVariant().toFloat();
+ newPosition.z = z.toVariant().toFloat();
+ setPosition(newPosition);
+ }
+ }
+
+ if (properties.property("lineWidth").isValid()) {
+ setLineWidth(properties.property("lineWidth").toVariant().toFloat());
+ }
+}
diff --git a/interface/src/ui/Base3DOverlay.h b/interface/src/ui/Base3DOverlay.h
new file mode 100644
index 0000000000..286193393c
--- /dev/null
+++ b/interface/src/ui/Base3DOverlay.h
@@ -0,0 +1,36 @@
+//
+// Base3DOverlay.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Base3DOverlay__
+#define __interface__Base3DOverlay__
+
+#include "Overlay.h"
+
+class Base3DOverlay : public Overlay {
+ Q_OBJECT
+
+public:
+ Base3DOverlay();
+ ~Base3DOverlay();
+
+ // getters
+ const glm::vec3& getPosition() const { return _position; }
+ float getLineWidth() const { return _lineWidth; }
+
+ // setters
+ void setPosition(const glm::vec3& position) { _position = position; }
+ void setLineWidth(float lineWidth) { _lineWidth = lineWidth; }
+
+ virtual void setProperties(const QScriptValue& properties);
+
+protected:
+ glm::vec3 _position;
+ float _lineWidth;
+};
+
+
+#endif /* defined(__interface__Base3DOverlay__) */
diff --git a/interface/src/ui/Cube3DOverlay.cpp b/interface/src/ui/Cube3DOverlay.cpp
new file mode 100644
index 0000000000..992a18e451
--- /dev/null
+++ b/interface/src/ui/Cube3DOverlay.cpp
@@ -0,0 +1,44 @@
+//
+// Cube3DOverlay.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+
+#include "Cube3DOverlay.h"
+
+Cube3DOverlay::Cube3DOverlay() {
+}
+
+Cube3DOverlay::~Cube3DOverlay() {
+}
+
+void Cube3DOverlay::render() {
+ if (!_visible) {
+ return; // do nothing if we're not visible
+ }
+
+ const float MAX_COLOR = 255;
+ glColor4f(_color.red / MAX_COLOR, _color.green / MAX_COLOR, _color.blue / MAX_COLOR, _alpha);
+
+
+ glDisable(GL_LIGHTING);
+ glPushMatrix();
+ glTranslatef(_position.x + _size * 0.5f,
+ _position.y + _size * 0.5f,
+ _position.z + _size * 0.5f);
+ glLineWidth(_lineWidth);
+ if (_isSolid) {
+ glutSolidCube(_size);
+ } else {
+ glutWireCube(_size);
+ }
+ glPopMatrix();
+
+}
diff --git a/interface/src/ui/Cube3DOverlay.h b/interface/src/ui/Cube3DOverlay.h
new file mode 100644
index 0000000000..a1705d47d0
--- /dev/null
+++ b/interface/src/ui/Cube3DOverlay.h
@@ -0,0 +1,23 @@
+//
+// Cube3DOverlay.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Cube3DOverlay__
+#define __interface__Cube3DOverlay__
+
+#include "Volume3DOverlay.h"
+
+class Cube3DOverlay : public Volume3DOverlay {
+ Q_OBJECT
+
+public:
+ Cube3DOverlay();
+ ~Cube3DOverlay();
+ virtual void render();
+};
+
+
+#endif /* defined(__interface__Cube3DOverlay__) */
diff --git a/interface/src/ui/ImageOverlay.cpp b/interface/src/ui/ImageOverlay.cpp
new file mode 100644
index 0000000000..178383749b
--- /dev/null
+++ b/interface/src/ui/ImageOverlay.cpp
@@ -0,0 +1,145 @@
+//
+// ImageOverlay.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+#include
+#include
+
+#include "ImageOverlay.h"
+
+ImageOverlay::ImageOverlay() :
+ _textureID(0),
+ _renderImage(false),
+ _textureBound(false),
+ _wantClipFromImage(false)
+{
+}
+
+ImageOverlay::~ImageOverlay() {
+ if (_parent && _textureID) {
+ // do we need to call this?
+ //_parent->deleteTexture(_textureID);
+ }
+}
+
+// TODO: handle setting image multiple times, how do we manage releasing the bound texture?
+void ImageOverlay::setImageURL(const QUrl& url) {
+ // TODO: are we creating too many QNetworkAccessManager() when multiple calls to setImageURL are made?
+ QNetworkAccessManager* manager = new QNetworkAccessManager(this);
+ connect(manager, SIGNAL(finished(QNetworkReply*)), this, SLOT(replyFinished(QNetworkReply*)));
+ manager->get(QNetworkRequest(url));
+}
+
+void ImageOverlay::replyFinished(QNetworkReply* reply) {
+
+ // replace our byte array with the downloaded data
+ QByteArray rawData = reply->readAll();
+ _textureImage.loadFromData(rawData);
+ _renderImage = true;
+
+}
+
+void ImageOverlay::render() {
+ if (!_visible) {
+ return; // do nothing if we're not visible
+ }
+ if (_renderImage && !_textureBound) {
+ _textureID = _parent->bindTexture(_textureImage);
+ _textureBound = true;
+ }
+
+ if (_renderImage) {
+ glEnable(GL_TEXTURE_2D);
+ glBindTexture(GL_TEXTURE_2D, _textureID);
+ }
+ const float MAX_COLOR = 255;
+ glColor4f(_color.red / MAX_COLOR, _color.green / MAX_COLOR, _color.blue / MAX_COLOR, _alpha);
+
+ float imageWidth = _textureImage.width();
+ float imageHeight = _textureImage.height();
+
+ QRect fromImage;
+ if (_wantClipFromImage) {
+ fromImage = _fromImage;
+ } else {
+ fromImage.setX(0);
+ fromImage.setY(0);
+ fromImage.setWidth(imageWidth);
+ fromImage.setHeight(imageHeight);
+ }
+ float x = fromImage.x() / imageWidth;
+ float y = fromImage.y() / imageHeight;
+ float w = fromImage.width() / imageWidth; // ?? is this what we want? not sure
+ float h = fromImage.height() / imageHeight;
+
+ glBegin(GL_QUADS);
+ if (_renderImage) {
+ glTexCoord2f(x, 1.0f - y);
+ }
+ glVertex2f(_bounds.left(), _bounds.top());
+
+ if (_renderImage) {
+ glTexCoord2f(x + w, 1.0f - y);
+ }
+ glVertex2f(_bounds.right(), _bounds.top());
+
+ if (_renderImage) {
+ glTexCoord2f(x + w, 1.0f - (y + h));
+ }
+ glVertex2f(_bounds.right(), _bounds.bottom());
+
+ if (_renderImage) {
+ glTexCoord2f(x, 1.0f - (y + h));
+ }
+ glVertex2f(_bounds.left(), _bounds.bottom());
+ glEnd();
+ if (_renderImage) {
+ glDisable(GL_TEXTURE_2D);
+ }
+}
+
+void ImageOverlay::setProperties(const QScriptValue& properties) {
+ Overlay2D::setProperties(properties);
+
+ QScriptValue subImageBounds = properties.property("subImage");
+ if (subImageBounds.isValid()) {
+ QRect oldSubImageRect = _fromImage;
+ QRect subImageRect = _fromImage;
+ if (subImageBounds.property("x").isValid()) {
+ subImageRect.setX(subImageBounds.property("x").toVariant().toInt());
+ } else {
+ subImageRect.setX(oldSubImageRect.x());
+ }
+ if (subImageBounds.property("y").isValid()) {
+ subImageRect.setY(subImageBounds.property("y").toVariant().toInt());
+ } else {
+ subImageRect.setY(oldSubImageRect.y());
+ }
+ if (subImageBounds.property("width").isValid()) {
+ subImageRect.setWidth(subImageBounds.property("width").toVariant().toInt());
+ } else {
+ subImageRect.setWidth(oldSubImageRect.width());
+ }
+ if (subImageBounds.property("height").isValid()) {
+ subImageRect.setHeight(subImageBounds.property("height").toVariant().toInt());
+ } else {
+ subImageRect.setHeight(oldSubImageRect.height());
+ }
+ setClipFromSource(subImageRect);
+ }
+
+ QScriptValue imageURL = properties.property("imageURL");
+ if (imageURL.isValid()) {
+ setImageURL(imageURL.toVariant().toString());
+ }
+}
+
+
diff --git a/interface/src/ui/ImageOverlay.h b/interface/src/ui/ImageOverlay.h
new file mode 100644
index 0000000000..77cac3b3c6
--- /dev/null
+++ b/interface/src/ui/ImageOverlay.h
@@ -0,0 +1,60 @@
+//
+// ImageOverlay.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__ImageOverlay__
+#define __interface__ImageOverlay__
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+#include "Overlay.h"
+#include "Overlay2D.h"
+
+class ImageOverlay : public Overlay2D {
+ Q_OBJECT
+
+public:
+ ImageOverlay();
+ ~ImageOverlay();
+ virtual void render();
+
+ // getters
+ const QRect& getClipFromSource() const { return _fromImage; }
+ const QUrl& getImageURL() const { return _imageURL; }
+
+ // setters
+ void setClipFromSource(const QRect& bounds) { _fromImage = bounds; _wantClipFromImage = true; }
+ void setImageURL(const QUrl& url);
+ virtual void setProperties(const QScriptValue& properties);
+
+private slots:
+ void replyFinished(QNetworkReply* reply); // we actually want to hide this...
+
+private:
+
+ QUrl _imageURL;
+ QImage _textureImage;
+ GLuint _textureID;
+ QRect _fromImage; // where from in the image to sample
+ bool _renderImage; // is there an image associated with this overlay, or is it just a colored rectangle
+ bool _textureBound; // has the texture been bound
+ bool _wantClipFromImage;
+};
+
+
+#endif /* defined(__interface__ImageOverlay__) */
diff --git a/interface/src/ui/Line3DOverlay.cpp b/interface/src/ui/Line3DOverlay.cpp
new file mode 100644
index 0000000000..c357233329
--- /dev/null
+++ b/interface/src/ui/Line3DOverlay.cpp
@@ -0,0 +1,60 @@
+//
+// Line3DOverlay.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include "Line3DOverlay.h"
+
+
+Line3DOverlay::Line3DOverlay() {
+}
+
+Line3DOverlay::~Line3DOverlay() {
+}
+
+void Line3DOverlay::render() {
+ if (!_visible) {
+ return; // do nothing if we're not visible
+ }
+
+ const float MAX_COLOR = 255;
+ glDisable(GL_LIGHTING);
+ glLineWidth(_lineWidth);
+ glColor4f(_color.red / MAX_COLOR, _color.green / MAX_COLOR, _color.blue / MAX_COLOR, _alpha);
+
+ glBegin(GL_LINES);
+ glVertex3f(_position.x, _position.y, _position.z);
+ glVertex3f(_end.x, _end.y, _end.z);
+ glEnd();
+ glEnable(GL_LIGHTING);
+}
+
+void Line3DOverlay::setProperties(const QScriptValue& properties) {
+ Base3DOverlay::setProperties(properties);
+
+ QScriptValue end = properties.property("end");
+ // if "end" property was not there, check to see if they included aliases: endPoint, or p2
+ if (!end.isValid()) {
+ end = properties.property("endPoint");
+ if (!end.isValid()) {
+ end = properties.property("p2");
+ }
+ }
+ if (end.isValid()) {
+ QScriptValue x = end.property("x");
+ QScriptValue y = end.property("y");
+ QScriptValue z = end.property("z");
+ if (x.isValid() && y.isValid() && z.isValid()) {
+ glm::vec3 newEnd;
+ newEnd.x = x.toVariant().toFloat();
+ newEnd.y = y.toVariant().toFloat();
+ newEnd.z = z.toVariant().toFloat();
+ setEnd(newEnd);
+ }
+ }
+}
diff --git a/interface/src/ui/Line3DOverlay.h b/interface/src/ui/Line3DOverlay.h
new file mode 100644
index 0000000000..d52b639d59
--- /dev/null
+++ b/interface/src/ui/Line3DOverlay.h
@@ -0,0 +1,34 @@
+//
+// Line3DOverlay.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Line3DOverlay__
+#define __interface__Line3DOverlay__
+
+#include "Base3DOverlay.h"
+
+class Line3DOverlay : public Base3DOverlay {
+ Q_OBJECT
+
+public:
+ Line3DOverlay();
+ ~Line3DOverlay();
+ virtual void render();
+
+ // getters
+ const glm::vec3& getEnd() const { return _end; }
+
+ // setters
+ void setEnd(const glm::vec3& end) { _end = end; }
+
+ virtual void setProperties(const QScriptValue& properties);
+
+protected:
+ glm::vec3 _end;
+};
+
+
+#endif /* defined(__interface__Line3DOverlay__) */
diff --git a/interface/src/ui/LodToolsDialog.cpp b/interface/src/ui/LodToolsDialog.cpp
index 788f7e5561..4cf4a29bf1 100644
--- a/interface/src/ui/LodToolsDialog.cpp
+++ b/interface/src/ui/LodToolsDialog.cpp
@@ -121,6 +121,12 @@ LodToolsDialog::~LodToolsDialog() {
delete _boundaryLevelAdjust;
}
+void LodToolsDialog::reloadSliders() {
+ _lodSize->setValue(Menu::getInstance()->getVoxelSizeScale() / TREE_SCALE);
+ _boundaryLevelAdjust->setValue(Menu::getInstance()->getBoundaryLevelAdjust());
+ _feedback->setText(getFeedbackText());
+}
+
void LodToolsDialog::sizeScaleValueChanged(int value) {
float realValue = value * TREE_SCALE;
Menu::getInstance()->setVoxelSizeScale(realValue);
diff --git a/interface/src/ui/LodToolsDialog.h b/interface/src/ui/LodToolsDialog.h
index ee14196188..ee96cffd7e 100644
--- a/interface/src/ui/LodToolsDialog.h
+++ b/interface/src/ui/LodToolsDialog.h
@@ -28,6 +28,7 @@ public slots:
void sizeScaleValueChanged(int value);
void boundaryLevelValueChanged(int value);
void resetClicked(bool checked);
+ void reloadSliders();
protected:
diff --git a/interface/src/ui/Overlay.cpp b/interface/src/ui/Overlay.cpp
new file mode 100644
index 0000000000..40da2253f4
--- /dev/null
+++ b/interface/src/ui/Overlay.cpp
@@ -0,0 +1,55 @@
+//
+// Overlay.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+#include
+#include
+
+#include "Overlay.h"
+
+
+Overlay::Overlay() :
+ _parent(NULL),
+ _alpha(DEFAULT_ALPHA),
+ _color(DEFAULT_BACKGROUND_COLOR),
+ _visible(true)
+{
+}
+
+void Overlay::init(QGLWidget* parent) {
+ _parent = parent;
+}
+
+
+Overlay::~Overlay() {
+}
+
+void Overlay::setProperties(const QScriptValue& properties) {
+ QScriptValue color = properties.property("color");
+ if (color.isValid()) {
+ QScriptValue red = color.property("red");
+ QScriptValue green = color.property("green");
+ QScriptValue blue = color.property("blue");
+ if (red.isValid() && green.isValid() && blue.isValid()) {
+ _color.red = red.toVariant().toInt();
+ _color.green = green.toVariant().toInt();
+ _color.blue = blue.toVariant().toInt();
+ }
+ }
+
+ if (properties.property("alpha").isValid()) {
+ setAlpha(properties.property("alpha").toVariant().toFloat());
+ }
+
+ if (properties.property("visible").isValid()) {
+ setVisible(properties.property("visible").toVariant().toBool());
+ }
+}
diff --git a/interface/src/ui/Overlay.h b/interface/src/ui/Overlay.h
new file mode 100644
index 0000000000..df898ec741
--- /dev/null
+++ b/interface/src/ui/Overlay.h
@@ -0,0 +1,53 @@
+//
+// Overlay.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Overlay__
+#define __interface__Overlay__
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+#include
+#include
+
+#include // for xColor
+
+const xColor DEFAULT_BACKGROUND_COLOR = { 255, 255, 255 };
+const float DEFAULT_ALPHA = 0.7f;
+
+class Overlay : public QObject {
+ Q_OBJECT
+
+public:
+ Overlay();
+ ~Overlay();
+ void init(QGLWidget* parent);
+ virtual void render() = 0;
+
+ // getters
+ bool getVisible() const { return _visible; }
+ const xColor& getColor() const { return _color; }
+ float getAlpha() const { return _alpha; }
+
+ // setters
+ void setVisible(bool visible) { _visible = visible; }
+ void setColor(const xColor& color) { _color = color; }
+ void setAlpha(float alpha) { _alpha = alpha; }
+
+ virtual void setProperties(const QScriptValue& properties);
+
+protected:
+ QGLWidget* _parent;
+ float _alpha;
+ xColor _color;
+ bool _visible; // should the overlay be drawn at all
+};
+
+
+#endif /* defined(__interface__Overlay__) */
diff --git a/interface/src/ui/Overlay2D.cpp b/interface/src/ui/Overlay2D.cpp
new file mode 100644
index 0000000000..0c459811c4
--- /dev/null
+++ b/interface/src/ui/Overlay2D.cpp
@@ -0,0 +1,63 @@
+//
+// Overlay2D.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+#include
+#include
+
+#include "Overlay2D.h"
+
+
+Overlay2D::Overlay2D() {
+}
+
+Overlay2D::~Overlay2D() {
+}
+
+void Overlay2D::setProperties(const QScriptValue& properties) {
+ Overlay::setProperties(properties);
+
+ QScriptValue bounds = properties.property("bounds");
+ if (bounds.isValid()) {
+ QRect boundsRect;
+ boundsRect.setX(bounds.property("x").toVariant().toInt());
+ boundsRect.setY(bounds.property("y").toVariant().toInt());
+ boundsRect.setWidth(bounds.property("width").toVariant().toInt());
+ boundsRect.setHeight(bounds.property("height").toVariant().toInt());
+ setBounds(boundsRect);
+ } else {
+ QRect oldBounds = getBounds();
+ QRect newBounds = oldBounds;
+
+ if (properties.property("x").isValid()) {
+ newBounds.setX(properties.property("x").toVariant().toInt());
+ } else {
+ newBounds.setX(oldBounds.x());
+ }
+ if (properties.property("y").isValid()) {
+ newBounds.setY(properties.property("y").toVariant().toInt());
+ } else {
+ newBounds.setY(oldBounds.y());
+ }
+ if (properties.property("width").isValid()) {
+ newBounds.setWidth(properties.property("width").toVariant().toInt());
+ } else {
+ newBounds.setWidth(oldBounds.width());
+ }
+ if (properties.property("height").isValid()) {
+ newBounds.setHeight(properties.property("height").toVariant().toInt());
+ } else {
+ newBounds.setHeight(oldBounds.height());
+ }
+ setBounds(newBounds);
+ //qDebug() << "set bounds to " << getBounds();
+ }
+}
diff --git a/interface/src/ui/Overlay2D.h b/interface/src/ui/Overlay2D.h
new file mode 100644
index 0000000000..3da8f8bca4
--- /dev/null
+++ b/interface/src/ui/Overlay2D.h
@@ -0,0 +1,51 @@
+//
+// Overlay2D.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Overlay2D__
+#define __interface__Overlay2D__
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+#include
+#include
+
+#include // for xColor
+
+#include "Overlay.h"
+
+class Overlay2D : public Overlay {
+ Q_OBJECT
+
+public:
+ Overlay2D();
+ ~Overlay2D();
+
+ // getters
+ int getX() const { return _bounds.x(); }
+ int getY() const { return _bounds.y(); }
+ int getWidth() const { return _bounds.width(); }
+ int getHeight() const { return _bounds.height(); }
+ const QRect& getBounds() const { return _bounds; }
+
+ // setters
+ void setX(int x) { _bounds.setX(x); }
+ void setY(int y) { _bounds.setY(y); }
+ void setWidth(int width) { _bounds.setWidth(width); }
+ void setHeight(int height) { _bounds.setHeight(height); }
+ void setBounds(const QRect& bounds) { _bounds = bounds; }
+
+ virtual void setProperties(const QScriptValue& properties);
+
+protected:
+ QRect _bounds; // where on the screen to draw
+};
+
+
+#endif /* defined(__interface__Overlay2D__) */
diff --git a/interface/src/ui/Overlays.cpp b/interface/src/ui/Overlays.cpp
new file mode 100644
index 0000000000..c35c4fc5ec
--- /dev/null
+++ b/interface/src/ui/Overlays.cpp
@@ -0,0 +1,129 @@
+//
+// Overlays.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+
+#include "Cube3DOverlay.h"
+#include "ImageOverlay.h"
+#include "Line3DOverlay.h"
+#include "Overlays.h"
+#include "Sphere3DOverlay.h"
+#include "TextOverlay.h"
+
+
+unsigned int Overlays::_nextOverlayID = 1;
+
+Overlays::Overlays() {
+}
+
+Overlays::~Overlays() {
+}
+
+void Overlays::init(QGLWidget* parent) {
+ _parent = parent;
+}
+
+void Overlays::render2D() {
+ foreach(Overlay* thisOverlay, _overlays2D) {
+ thisOverlay->render();
+ }
+}
+
+void Overlays::render3D() {
+ foreach(Overlay* thisOverlay, _overlays3D) {
+ thisOverlay->render();
+ }
+}
+
+// TODO: make multi-threaded safe
+unsigned int Overlays::addOverlay(const QString& type, const QScriptValue& properties) {
+ unsigned int thisID = 0;
+ bool created = false;
+ bool is3D = false;
+ Overlay* thisOverlay = NULL;
+
+ if (type == "image") {
+ thisOverlay = new ImageOverlay();
+ thisOverlay->init(_parent);
+ thisOverlay->setProperties(properties);
+ created = true;
+ } else if (type == "text") {
+ thisOverlay = new TextOverlay();
+ thisOverlay->init(_parent);
+ thisOverlay->setProperties(properties);
+ created = true;
+ } else if (type == "cube") {
+ thisOverlay = new Cube3DOverlay();
+ thisOverlay->init(_parent);
+ thisOverlay->setProperties(properties);
+ created = true;
+ is3D = true;
+ } else if (type == "sphere") {
+ thisOverlay = new Sphere3DOverlay();
+ thisOverlay->init(_parent);
+ thisOverlay->setProperties(properties);
+ created = true;
+ is3D = true;
+ } else if (type == "line3d") {
+ thisOverlay = new Line3DOverlay();
+ thisOverlay->init(_parent);
+ thisOverlay->setProperties(properties);
+ created = true;
+ is3D = true;
+ }
+
+ if (created) {
+ thisID = _nextOverlayID;
+ _nextOverlayID++;
+ if (is3D) {
+ _overlays3D[thisID] = thisOverlay;
+ } else {
+ _overlays2D[thisID] = thisOverlay;
+ }
+ }
+
+ return thisID;
+}
+
+// TODO: make multi-threaded safe
+bool Overlays::editOverlay(unsigned int id, const QScriptValue& properties) {
+ Overlay* thisOverlay = NULL;
+ if (_overlays2D.contains(id)) {
+ thisOverlay = _overlays2D[id];
+ } else if (_overlays3D.contains(id)) {
+ thisOverlay = _overlays3D[id];
+ }
+ if (thisOverlay) {
+ thisOverlay->setProperties(properties);
+ return true;
+ }
+ return false;
+}
+
+// TODO: make multi-threaded safe
+void Overlays::deleteOverlay(unsigned int id) {
+ if (_overlays2D.contains(id)) {
+ _overlays2D.erase(_overlays2D.find(id));
+ } else if (_overlays3D.contains(id)) {
+ _overlays3D.erase(_overlays3D.find(id));
+ }
+}
+
+unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
+ QMapIterator i(_overlays2D);
+ i.toBack();
+ while (i.hasPrevious()) {
+ i.previous();
+ unsigned int thisID = i.key();
+ Overlay2D* thisOverlay = static_cast(i.value());
+ if (thisOverlay->getVisible() && thisOverlay->getBounds().contains(point.x, point.y, false)) {
+ return thisID;
+ }
+ }
+ return 0; // not found
+}
+
+
diff --git a/interface/src/ui/Overlays.h b/interface/src/ui/Overlays.h
new file mode 100644
index 0000000000..cfd84fd44b
--- /dev/null
+++ b/interface/src/ui/Overlays.h
@@ -0,0 +1,46 @@
+//
+// Overlays.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Overlays__
+#define __interface__Overlays__
+
+#include
+
+#include "Overlay.h"
+
+class Overlays : public QObject {
+ Q_OBJECT
+public:
+ Overlays();
+ ~Overlays();
+ void init(QGLWidget* parent);
+ void render3D();
+ void render2D();
+
+public slots:
+ /// adds an overlay with the specific properties
+ unsigned int addOverlay(const QString& type, const QScriptValue& properties);
+
+ /// edits an overlay updating only the included properties, will return the identified OverlayID in case of
+ /// successful edit, if the input id is for an unknown overlay this function will have no effect
+ bool editOverlay(unsigned int id, const QScriptValue& properties);
+
+ /// deletes a particle
+ void deleteOverlay(unsigned int id);
+
+ /// returns the top most overlay at the screen point, or 0 if not overlay at that point
+ unsigned int getOverlayAtPoint(const glm::vec2& point);
+
+private:
+ QMap _overlays2D;
+ QMap _overlays3D;
+ static unsigned int _nextOverlayID;
+ QGLWidget* _parent;
+};
+
+
+#endif /* defined(__interface__Overlays__) */
diff --git a/interface/src/ui/Sphere3DOverlay.cpp b/interface/src/ui/Sphere3DOverlay.cpp
new file mode 100644
index 0000000000..7fded5bedb
--- /dev/null
+++ b/interface/src/ui/Sphere3DOverlay.cpp
@@ -0,0 +1,45 @@
+//
+// Sphere3DOverlay.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+
+#include "Sphere3DOverlay.h"
+
+Sphere3DOverlay::Sphere3DOverlay() {
+}
+
+Sphere3DOverlay::~Sphere3DOverlay() {
+}
+
+void Sphere3DOverlay::render() {
+ if (!_visible) {
+ return; // do nothing if we're not visible
+ }
+
+ const float MAX_COLOR = 255;
+ glColor4f(_color.red / MAX_COLOR, _color.green / MAX_COLOR, _color.blue / MAX_COLOR, _alpha);
+
+
+ glDisable(GL_LIGHTING);
+ glPushMatrix();
+ glTranslatef(_position.x + _size * 0.5f,
+ _position.y + _size * 0.5f,
+ _position.z + _size * 0.5f);
+ glLineWidth(_lineWidth);
+ const int slices = 15;
+ if (_isSolid) {
+ glutSolidSphere(_size, slices, slices);
+ } else {
+ glutWireSphere(_size, slices, slices);
+ }
+ glPopMatrix();
+
+}
diff --git a/interface/src/ui/Sphere3DOverlay.h b/interface/src/ui/Sphere3DOverlay.h
new file mode 100644
index 0000000000..58ed0d7776
--- /dev/null
+++ b/interface/src/ui/Sphere3DOverlay.h
@@ -0,0 +1,23 @@
+//
+// Sphere3DOverlay.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Sphere3DOverlay__
+#define __interface__Sphere3DOverlay__
+
+#include "Volume3DOverlay.h"
+
+class Sphere3DOverlay : public Volume3DOverlay {
+ Q_OBJECT
+
+public:
+ Sphere3DOverlay();
+ ~Sphere3DOverlay();
+ virtual void render();
+};
+
+
+#endif /* defined(__interface__Sphere3DOverlay__) */
diff --git a/interface/src/ui/TextOverlay.cpp b/interface/src/ui/TextOverlay.cpp
new file mode 100644
index 0000000000..edaec6849a
--- /dev/null
+++ b/interface/src/ui/TextOverlay.cpp
@@ -0,0 +1,82 @@
+//
+// TextOverlay.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+
+#include "TextOverlay.h"
+#include "TextRenderer.h"
+
+TextOverlay::TextOverlay() :
+ _leftMargin(DEFAULT_MARGIN),
+ _topMargin(DEFAULT_MARGIN)
+{
+}
+
+TextOverlay::~TextOverlay() {
+}
+
+void TextOverlay::render() {
+ if (!_visible) {
+ return; // do nothing if we're not visible
+ }
+
+ const float MAX_COLOR = 255;
+ glColor4f(_color.red / MAX_COLOR, _color.green / MAX_COLOR, _color.blue / MAX_COLOR, _alpha);
+
+ glBegin(GL_QUADS);
+ glVertex2f(_bounds.left(), _bounds.top());
+ glVertex2f(_bounds.right(), _bounds.top());
+ glVertex2f(_bounds.right(), _bounds.bottom());
+ glVertex2f(_bounds.left(), _bounds.bottom());
+ glEnd();
+
+ //TextRenderer(const char* family, int pointSize = -1, int weight = -1, bool italic = false,
+ // EffectType effect = NO_EFFECT, int effectThickness = 1);
+
+ TextRenderer textRenderer(SANS_FONT_FAMILY, 11, 50);
+ const int leftAdjust = -1; // required to make text render relative to left edge of bounds
+ const int topAdjust = -2; // required to make text render relative to top edge of bounds
+ int x = _bounds.left() + _leftMargin + leftAdjust;
+ int y = _bounds.top() + _topMargin + topAdjust;
+
+ glColor3f(1.0f, 1.0f, 1.0f);
+ QStringList lines = _text.split("\n");
+ int lineOffset = 0;
+ foreach(QString thisLine, lines) {
+ if (lineOffset == 0) {
+ lineOffset = textRenderer.calculateHeight(qPrintable(thisLine));
+ }
+ lineOffset += textRenderer.draw(x, y + lineOffset, qPrintable(thisLine));
+
+ const int lineGap = 2;
+ lineOffset += lineGap;
+ }
+
+}
+
+void TextOverlay::setProperties(const QScriptValue& properties) {
+ Overlay2D::setProperties(properties);
+
+ QScriptValue text = properties.property("text");
+ if (text.isValid()) {
+ setText(text.toVariant().toString());
+ }
+
+ if (properties.property("leftMargin").isValid()) {
+ setLeftMargin(properties.property("leftMargin").toVariant().toInt());
+ }
+
+ if (properties.property("topMargin").isValid()) {
+ setTopMargin(properties.property("topMargin").toVariant().toInt());
+ }
+}
+
+
diff --git a/interface/src/ui/TextOverlay.h b/interface/src/ui/TextOverlay.h
new file mode 100644
index 0000000000..d565aeb70d
--- /dev/null
+++ b/interface/src/ui/TextOverlay.h
@@ -0,0 +1,59 @@
+//
+// TextOverlay.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__TextOverlay__
+#define __interface__TextOverlay__
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+#include "Overlay.h"
+#include "Overlay2D.h"
+
+const int DEFAULT_MARGIN = 10;
+
+class TextOverlay : public Overlay2D {
+ Q_OBJECT
+
+public:
+ TextOverlay();
+ ~TextOverlay();
+ virtual void render();
+
+ // getters
+ const QString& getText() const { return _text; }
+ int getLeftMargin() const { return _leftMargin; }
+ int getTopMargin() const { return _topMargin; }
+
+ // setters
+ void setText(const QString& text) { _text = text; }
+ void setLeftMargin(int margin) { _leftMargin = margin; }
+ void setTopMargin(int margin) { _topMargin = margin; }
+
+ virtual void setProperties(const QScriptValue& properties);
+
+private:
+
+ QString _text;
+ int _leftMargin;
+ int _topMargin;
+
+};
+
+
+#endif /* defined(__interface__TextOverlay__) */
diff --git a/interface/src/ui/TextRenderer.cpp b/interface/src/ui/TextRenderer.cpp
index 65056799e2..cacd730fd6 100644
--- a/interface/src/ui/TextRenderer.cpp
+++ b/interface/src/ui/TextRenderer.cpp
@@ -8,6 +8,8 @@
#include
#include
#include
+#include
+#include
#include "InterfaceConfig.h"
#include "TextRenderer.h"
@@ -30,10 +32,25 @@ TextRenderer::~TextRenderer() {
glDeleteTextures(_allTextureIDs.size(), _allTextureIDs.constData());
}
-void TextRenderer::draw(int x, int y, const char* str) {
+int TextRenderer::calculateHeight(const char* str) {
+ int maxHeight = 0;
+ for (const char* ch = str; *ch != 0; ch++) {
+ const Glyph& glyph = getGlyph(*ch);
+ if (glyph.textureID() == 0) {
+ continue;
+ }
+
+ if (glyph.bounds().height() > maxHeight) {
+ maxHeight = glyph.bounds().height();
+ }
+ }
+ return maxHeight;
+}
+int TextRenderer::draw(int x, int y, const char* str) {
glEnable(GL_TEXTURE_2D);
+ int maxHeight = 0;
for (const char* ch = str; *ch != 0; ch++) {
const Glyph& glyph = getGlyph(*ch);
if (glyph.textureID() == 0) {
@@ -41,19 +58,23 @@ void TextRenderer::draw(int x, int y, const char* str) {
continue;
}
+ if (glyph.bounds().height() > maxHeight) {
+ maxHeight = glyph.bounds().height();
+ }
+
glBindTexture(GL_TEXTURE_2D, glyph.textureID());
-
+
int left = x + glyph.bounds().x();
int right = x + glyph.bounds().x() + glyph.bounds().width();
int bottom = y + glyph.bounds().y();
int top = y + glyph.bounds().y() + glyph.bounds().height();
-
+
float scale = 1.0 / IMAGE_SIZE;
float ls = glyph.location().x() * scale;
float rs = (glyph.location().x() + glyph.bounds().width()) * scale;
float bt = glyph.location().y() * scale;
float tt = (glyph.location().y() + glyph.bounds().height()) * scale;
-
+
glBegin(GL_QUADS);
glTexCoord2f(ls, bt);
glVertex2f(left, bottom);
@@ -64,12 +85,13 @@ void TextRenderer::draw(int x, int y, const char* str) {
glTexCoord2f(ls, tt);
glVertex2f(left, top);
glEnd();
-
+
x += glyph.width();
}
-
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
+
+ return maxHeight;
}
int TextRenderer::computeWidth(char ch)
diff --git a/interface/src/ui/TextRenderer.h b/interface/src/ui/TextRenderer.h
index ff484066d8..d6c24c1ce8 100644
--- a/interface/src/ui/TextRenderer.h
+++ b/interface/src/ui/TextRenderer.h
@@ -20,6 +20,16 @@
// a special "character" that renders as a solid block
const char SOLID_BLOCK_CHAR = 127;
+// the standard sans serif font family
+#define SANS_FONT_FAMILY "Helvetica"
+
+// the standard mono font family
+#define MONO_FONT_FAMILY "Courier"
+
+// the Inconsolata font family
+#define INCONSOLATA_FONT_FAMILY "Inconsolata"
+
+
class Glyph;
class TextRenderer {
@@ -33,7 +43,11 @@ public:
const QFontMetrics& metrics() const { return _metrics; }
- void draw(int x, int y, const char* str);
+ // returns the height of the tallest character
+ int calculateHeight(const char* str);
+
+ // also returns the height of the tallest character
+ int draw(int x, int y, const char* str);
int computeWidth(char ch);
int computeWidth(const char* str);
diff --git a/interface/src/ui/Volume3DOverlay.cpp b/interface/src/ui/Volume3DOverlay.cpp
new file mode 100644
index 0000000000..dbc1582cc5
--- /dev/null
+++ b/interface/src/ui/Volume3DOverlay.cpp
@@ -0,0 +1,47 @@
+//
+// Volume3DOverlay.cpp
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+
+#include "Volume3DOverlay.h"
+
+const float DEFAULT_SIZE = 1.0f;
+const bool DEFAULT_IS_SOLID = false;
+
+Volume3DOverlay::Volume3DOverlay() :
+ _size(DEFAULT_SIZE),
+ _isSolid(DEFAULT_IS_SOLID)
+{
+}
+
+Volume3DOverlay::~Volume3DOverlay() {
+}
+
+void Volume3DOverlay::setProperties(const QScriptValue& properties) {
+ Base3DOverlay::setProperties(properties);
+
+ if (properties.property("size").isValid()) {
+ setSize(properties.property("size").toVariant().toFloat());
+ }
+
+ if (properties.property("isSolid").isValid()) {
+ setIsSolid(properties.property("isSolid").toVariant().toBool());
+ }
+ if (properties.property("isWire").isValid()) {
+ setIsSolid(!properties.property("isWire").toVariant().toBool());
+ }
+ if (properties.property("solid").isValid()) {
+ setIsSolid(properties.property("solid").toVariant().toBool());
+ }
+ if (properties.property("wire").isValid()) {
+ setIsSolid(!properties.property("wire").toVariant().toBool());
+ }
+}
diff --git a/interface/src/ui/Volume3DOverlay.h b/interface/src/ui/Volume3DOverlay.h
new file mode 100644
index 0000000000..8badbf2c33
--- /dev/null
+++ b/interface/src/ui/Volume3DOverlay.h
@@ -0,0 +1,42 @@
+//
+// Volume3DOverlay.h
+// interface
+//
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__Volume3DOverlay__
+#define __interface__Volume3DOverlay__
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include
+#include
+
+#include "Base3DOverlay.h"
+
+class Volume3DOverlay : public Base3DOverlay {
+ Q_OBJECT
+
+public:
+ Volume3DOverlay();
+ ~Volume3DOverlay();
+
+ // getters
+ float getSize() const { return _size; }
+ bool getIsSolid() const { return _isSolid; }
+
+ // setters
+ void setSize(float size) { _size = size; }
+ void setIsSolid(bool isSolid) { _isSolid = isSolid; }
+
+ virtual void setProperties(const QScriptValue& properties);
+
+protected:
+ float _size;
+ bool _isSolid;
+};
+
+
+#endif /* defined(__interface__Volume3DOverlay__) */
diff --git a/libraries/avatars/src/AvatarData.h b/libraries/avatars/src/AvatarData.h
index 6492d9b7ad..5c48d8ae36 100755
--- a/libraries/avatars/src/AvatarData.h
+++ b/libraries/avatars/src/AvatarData.h
@@ -135,14 +135,10 @@ public:
virtual const glm::vec3& getVelocity() const { return vec3Zero; }
- virtual bool findSphereCollisionWithHands(const glm::vec3& sphereCenter, float sphereRadius, CollisionInfo& collision) {
+ virtual bool findParticleCollisions(const glm::vec3& particleCenter, float particleRadius, CollisionList& collisions) {
return false;
}
- virtual bool findSphereCollisionWithSkeleton(const glm::vec3& sphereCenter, float sphereRadius, CollisionInfo& collision) {
- return false;
- }
-
bool hasIdentityChangedAfterParsing(const QByteArray& packet);
QByteArray identityByteArray();
@@ -150,6 +146,8 @@ public:
const QUrl& getSkeletonModelURL() const { return _skeletonModelURL; }
virtual void setFaceModelURL(const QUrl& faceModelURL);
virtual void setSkeletonModelURL(const QUrl& skeletonModelURL);
+
+ virtual float getBoundingRadius() const { return 1.f; }
protected:
glm::vec3 _position;
diff --git a/libraries/avatars/src/AvatarHashMap.cpp b/libraries/avatars/src/AvatarHashMap.cpp
index 72ada7d421..82485691c5 100644
--- a/libraries/avatars/src/AvatarHashMap.cpp
+++ b/libraries/avatars/src/AvatarHashMap.cpp
@@ -2,7 +2,7 @@
// AvatarHashMap.cpp
// hifi
//
-// Created by Stephen AndrewMeadows on 1/28/2014.
+// Created by AndrewMeadows on 1/28/2014.
// Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
//
diff --git a/libraries/avatars/src/HeadData.cpp b/libraries/avatars/src/HeadData.cpp
index f863d6b592..62e8276bd3 100644
--- a/libraries/avatars/src/HeadData.cpp
+++ b/libraries/avatars/src/HeadData.cpp
@@ -45,10 +45,3 @@ void HeadData::addLean(float sideways, float forwards) {
_leanForward += forwards;
}
-bool HeadData::findSpherePenetration(const glm::vec3& penetratorCenter, float penetratorRadius, glm::vec3& penetration) const {
- // we would like to update this to determine collisions/penetrations with the Avatar's head sphere...
- // but right now it does not appear as if the HeadData has a position and radius.
- // this is a placeholder for now.
- return false;
-}
-
diff --git a/libraries/avatars/src/HeadData.h b/libraries/avatars/src/HeadData.h
index fde684bbf1..0f096059c0 100644
--- a/libraries/avatars/src/HeadData.h
+++ b/libraries/avatars/src/HeadData.h
@@ -58,13 +58,6 @@ public:
void setLookAtPosition(const glm::vec3& lookAtPosition) { _lookAtPosition = lookAtPosition; }
friend class AvatarData;
-
- /// Checks for penetration between the described sphere and the hand.
- /// \param penetratorCenter the center of the penetration test sphere
- /// \param penetratorRadius the radius of the penetration test sphere
- /// \param penetration[out] the vector in which to store the penetration
- /// \return whether or not the sphere penetrated
- bool findSpherePenetration(const glm::vec3& penetratorCenter, float penetratorRadius, glm::vec3& penetration) const;
protected:
float _yaw;
diff --git a/libraries/octree/src/OctreeSceneStats.cpp b/libraries/octree/src/OctreeSceneStats.cpp
index 59287e3c5c..8a5a731cff 100644
--- a/libraries/octree/src/OctreeSceneStats.cpp
+++ b/libraries/octree/src/OctreeSceneStats.cpp
@@ -791,7 +791,6 @@ const char* OctreeSceneStats::getItemValue(Item item) {
break;
}
default:
- sprintf(_itemValueBuffer, "");
break;
}
return _itemValueBuffer;
diff --git a/libraries/octree/src/OctreeScriptingInterface.cpp b/libraries/octree/src/OctreeScriptingInterface.cpp
index 553ab961df..1ed82564b6 100644
--- a/libraries/octree/src/OctreeScriptingInterface.cpp
+++ b/libraries/octree/src/OctreeScriptingInterface.cpp
@@ -11,7 +11,12 @@
#include "OctreeScriptingInterface.h"
OctreeScriptingInterface::OctreeScriptingInterface(OctreeEditPacketSender* packetSender,
- JurisdictionListener* jurisdictionListener)
+ JurisdictionListener* jurisdictionListener) :
+ _packetSender(NULL),
+ _jurisdictionListener(NULL),
+ _managedPacketSender(false),
+ _managedJurisdictionListener(false),
+ _initialized(false)
{
setPacketSender(packetSender);
setJurisdictionListener(jurisdictionListener);
@@ -45,6 +50,9 @@ void OctreeScriptingInterface::setJurisdictionListener(JurisdictionListener* jur
}
void OctreeScriptingInterface::init() {
+ if (_initialized) {
+ return;
+ }
if (_jurisdictionListener) {
_managedJurisdictionListener = false;
} else {
@@ -64,5 +72,5 @@ void OctreeScriptingInterface::init() {
if (QCoreApplication::instance()) {
connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(cleanupManagedObjects()));
}
-
+ _initialized = true;
}
diff --git a/libraries/octree/src/OctreeScriptingInterface.h b/libraries/octree/src/OctreeScriptingInterface.h
index 34eddd8bed..3c832cbae8 100644
--- a/libraries/octree/src/OctreeScriptingInterface.h
+++ b/libraries/octree/src/OctreeScriptingInterface.h
@@ -93,6 +93,7 @@ protected:
JurisdictionListener* _jurisdictionListener;
bool _managedPacketSender;
bool _managedJurisdictionListener;
+ bool _initialized;
};
#endif /* defined(__hifi__OctreeScriptingInterface__) */
diff --git a/libraries/particles/src/ParticleCollisionSystem.cpp b/libraries/particles/src/ParticleCollisionSystem.cpp
index bb0260c2bf..2d272a8f1f 100644
--- a/libraries/particles/src/ParticleCollisionSystem.cpp
+++ b/libraries/particles/src/ParticleCollisionSystem.cpp
@@ -19,9 +19,11 @@
#include "ParticleEditPacketSender.h"
#include "ParticleTree.h"
+const int MAX_COLLISIONS_PER_PARTICLE = 16;
+
ParticleCollisionSystem::ParticleCollisionSystem(ParticleEditPacketSender* packetSender,
ParticleTree* particles, VoxelTree* voxels, AbstractAudioInterface* audio,
- AvatarHashMap* avatars) {
+ AvatarHashMap* avatars) : _collisions(MAX_COLLISIONS_PER_PARTICLE) {
init(packetSender, particles, voxels, audio, avatars);
}
@@ -181,39 +183,53 @@ void ParticleCollisionSystem::updateCollisionWithAvatars(Particle* particle) {
const float COLLISION_FREQUENCY = 0.5f;
glm::vec3 penetration;
+ _collisions.clear();
foreach (const AvatarSharedPointer& avatarPointer, _avatars->getAvatarHash()) {
AvatarData* avatar = avatarPointer.data();
- CollisionInfo collisionInfo;
- collisionInfo._damping = DAMPING;
- collisionInfo._elasticity = ELASTICITY;
- if (avatar->findSphereCollisionWithHands(center, radius, collisionInfo)) {
- // TODO: Andrew to resurrect particles-vs-avatar body collisions
- //avatar->findSphereCollisionWithSkeleton(center, radius, collisionInfo)) {
- collisionInfo._addedVelocity /= (float)(TREE_SCALE);
- glm::vec3 relativeVelocity = collisionInfo._addedVelocity - particle->getVelocity();
- if (glm::dot(relativeVelocity, collisionInfo._penetration) < 0.f) {
- // only collide when particle and collision point are moving toward each other
- // (doing this prevents some "collision snagging" when particle penetrates the object)
- // HACK BEGIN: to allow paddle hands to "hold" particles we attenuate soft collisions against the avatar.
- // NOTE: the physics are wrong (particles cannot roll) but it IS possible to catch a slow moving particle.
- // TODO: make this less hacky when we have more per-collision details
- float elasticity = ELASTICITY;
- float attenuationFactor = glm::length(collisionInfo._addedVelocity) / HALTING_SPEED;
- float damping = DAMPING;
- if (attenuationFactor < 1.f) {
- collisionInfo._addedVelocity *= attenuationFactor;
- elasticity *= attenuationFactor;
- // NOTE: the math below keeps the damping piecewise continuous,
- // while ramping it up to 1.0 when attenuationFactor = 0
- damping = DAMPING + (1.f - attenuationFactor) * (1.f - DAMPING);
+ // use a very generous bounding radius since the arms can stretch
+ float totalRadius = 2.f * avatar->getBoundingRadius() + radius;
+ glm::vec3 relativePosition = center - avatar->getPosition();
+ if (glm::dot(relativePosition, relativePosition) > (totalRadius * totalRadius)) {
+ continue;
+ }
+
+ if (avatar->findParticleCollisions(center, radius, _collisions)) {
+ int numCollisions = _collisions.size();
+ for (int i = 0; i < numCollisions; ++i) {
+ CollisionInfo* collision = _collisions.getCollision(i);
+ collision->_damping = DAMPING;
+ collision->_elasticity = ELASTICITY;
+
+ collision->_addedVelocity /= (float)(TREE_SCALE);
+ glm::vec3 relativeVelocity = collision->_addedVelocity - particle->getVelocity();
+
+ if (glm::dot(relativeVelocity, collision->_penetration) <= 0.f) {
+ // only collide when particle and collision point are moving toward each other
+ // (doing this prevents some "collision snagging" when particle penetrates the object)
+
+ // HACK BEGIN: to allow paddle hands to "hold" particles we attenuate soft collisions against them.
+ if (collision->_type == PADDLE_HAND_COLLISION) {
+ // NOTE: the physics are wrong (particles cannot roll) but it IS possible to catch a slow moving particle.
+ // TODO: make this less hacky when we have more per-collision details
+ float elasticity = ELASTICITY;
+ float attenuationFactor = glm::length(collision->_addedVelocity) / HALTING_SPEED;
+ float damping = DAMPING;
+ if (attenuationFactor < 1.f) {
+ collision->_addedVelocity *= attenuationFactor;
+ elasticity *= attenuationFactor;
+ // NOTE: the math below keeps the damping piecewise continuous,
+ // while ramping it up to 1 when attenuationFactor = 0
+ damping = DAMPING + (1.f - attenuationFactor) * (1.f - DAMPING);
+ }
+ }
+ // HACK END
+
+ updateCollisionSound(particle, collision->_penetration, COLLISION_FREQUENCY);
+ collision->_penetration /= (float)(TREE_SCALE);
+ particle->applyHardCollision(*collision);
+ queueParticlePropertiesUpdate(particle);
}
- // HACK END
-
- updateCollisionSound(particle, collisionInfo._penetration, COLLISION_FREQUENCY);
- collisionInfo._penetration /= (float)(TREE_SCALE);
- particle->applyHardCollision(collisionInfo);
- queueParticlePropertiesUpdate(particle);
}
}
}
diff --git a/libraries/particles/src/ParticleCollisionSystem.h b/libraries/particles/src/ParticleCollisionSystem.h
index c525d3ddfc..3bff843743 100644
--- a/libraries/particles/src/ParticleCollisionSystem.h
+++ b/libraries/particles/src/ParticleCollisionSystem.h
@@ -66,6 +66,7 @@ private:
VoxelTree* _voxels;
AbstractAudioInterface* _audio;
AvatarHashMap* _avatars;
+ CollisionList _collisions;
};
#endif /* defined(__hifi__ParticleCollisionSystem__) */
diff --git a/libraries/shared/src/CollisionInfo.cpp b/libraries/shared/src/CollisionInfo.cpp
new file mode 100644
index 0000000000..5d74d591c6
--- /dev/null
+++ b/libraries/shared/src/CollisionInfo.cpp
@@ -0,0 +1,42 @@
+//
+// CollisionInfo.cpp
+// hifi
+//
+// Created by Andrew Meadows on 2014.02.14
+// Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+#include "CollisionInfo.h"
+
+CollisionList::CollisionList(int maxSize) :
+ _maxSize(maxSize),
+ _size(0) {
+ _collisions.resize(_maxSize);
+}
+
+CollisionInfo* CollisionList::getNewCollision() {
+ // return pointer to existing CollisionInfo, or NULL of list is full
+ return (_size < _maxSize) ? &(_collisions[++_size]) : NULL;
+}
+
+CollisionInfo* CollisionList::getCollision(int index) {
+ return (index > -1 && index < _size) ? &(_collisions[index]) : NULL;
+}
+
+void CollisionList::clear() {
+ for (int i = 0; i < _size; ++i) {
+ // we only clear the important stuff
+ CollisionInfo& collision = _collisions[i];
+ collision._type = BASE_COLLISION;
+ collision._data = NULL; // CollisionInfo does not own whatever this points to.
+ collision._flags = 0;
+ // we rely on the consumer to properly overwrite these fields when the collision is "created"
+ //collision._damping;
+ //collision._elasticity;
+ //collision._contactPoint;
+ //collision._penetration;
+ //collision._addedVelocity;
+ }
+ _size = 0;
+}
+
diff --git a/libraries/shared/src/CollisionInfo.h b/libraries/shared/src/CollisionInfo.h
index 1fa95cd83a..acd127435c 100644
--- a/libraries/shared/src/CollisionInfo.h
+++ b/libraries/shared/src/CollisionInfo.h
@@ -11,15 +11,42 @@
#include
-const uint32_t COLLISION_GROUP_ENVIRONMENT = 1U << 0;
-const uint32_t COLLISION_GROUP_AVATARS = 1U << 1;
-const uint32_t COLLISION_GROUP_VOXELS = 1U << 2;
-const uint32_t COLLISION_GROUP_PARTICLES = 1U << 3;
+#include
+
+enum CollisionType {
+ BASE_COLLISION = 0,
+ PADDLE_HAND_COLLISION,
+ MODEL_COLLISION,
+};
+
+const quint32 COLLISION_GROUP_ENVIRONMENT = 1U << 0;
+const quint32 COLLISION_GROUP_AVATARS = 1U << 1;
+const quint32 COLLISION_GROUP_VOXELS = 1U << 2;
+const quint32 COLLISION_GROUP_PARTICLES = 1U << 3;
+
+// CollisionInfo contains details about the collision between two things: BodyA and BodyB.
+// The assumption is that the context that analyzes the collision knows about BodyA but
+// does not necessarily know about BodyB. Hence the data storred in the CollisionInfo
+// is expected to be relative to BodyA (for example the penetration points from A into B).
class CollisionInfo {
public:
CollisionInfo()
- : _damping(0.f),
+ : _type(0),
+ _data(NULL),
+ _flags(0),
+ _damping(0.f),
+ _elasticity(1.f),
+ _contactPoint(0.f),
+ _penetration(0.f),
+ _addedVelocity(0.f) {
+ }
+
+ CollisionInfo(qint32 type)
+ : _type(type),
+ _data(NULL),
+ _flags(0),
+ _damping(0.f),
_elasticity(1.f),
_contactPoint(0.f),
_penetration(0.f),
@@ -28,13 +55,40 @@ public:
~CollisionInfo() {}
- //glm::vec3 _normal;
- float _damping;
- float _elasticity;
- glm::vec3 _contactPoint; // world-frame point on bodyA that is deepest into bodyB
- glm::vec3 _penetration; // depth that bodyA penetrates into bodyB
- glm::vec3 _addedVelocity;
+ qint32 _type; // type of Collision (will determine what is supposed to be in _data and _flags)
+ void* _data; // pointer to user supplied data
+ quint32 _flags; // 32 bits for whatever
+
+ float _damping; // range [0,1] of friction coeficient
+ float _elasticity; // range [0,1] of energy conservation
+ glm::vec3 _contactPoint; // world-frame point on BodyA that is deepest into BodyB
+ glm::vec3 _penetration; // depth that BodyA penetrates into BodyB
+ glm::vec3 _addedVelocity; // velocity of BodyB
};
+// CollisionList is intended to be a recycled container. Fill the CollisionInfo's,
+// use them, and then clear them for the next frame or context.
+
+class CollisionList {
+public:
+ CollisionList(int maxSize);
+
+ /// \return pointer to next collision. NULL if list is full.
+ CollisionInfo* getNewCollision();
+
+ /// \return pointer to collision by index. NULL if index out of bounds.
+ CollisionInfo* getCollision(int index);
+
+ /// \return number of valid collisions
+ int size() const { return _size; }
+
+ /// Clear valid collisions.
+ void clear();
+
+private:
+ int _maxSize;
+ int _size;
+ QVector _collisions;
+};
#endif /* defined(__hifi__CollisionInfo__) */
diff --git a/libraries/shared/src/PerfStat.h b/libraries/shared/src/PerfStat.h
index fffb095021..a7a10b97b8 100644
--- a/libraries/shared/src/PerfStat.h
+++ b/libraries/shared/src/PerfStat.h
@@ -45,6 +45,8 @@ public:
_alwaysDisplay(alwaysDisplay),
_runningTotal(runningTotal),
_totalCalls(totalCalls) { }
+
+ quint64 elapsed() const { return (usecTimestampNow() - _start); };
~PerformanceWarning();