Merge branch 'master' of https://github.com/anthonye2007/hifi

2025-04-20 04:24:07 +02:00 · 2014-07-28 19:53:17 -04:00 · 2014-07-28 19:53:17 -04:00 · c5b824cb4e
commit c5b824cb4e
parent d4a6556917 cd6a73a01c
37 changed files with 624 additions and 385 deletions
--- a/cmake/macros/HifiLibrarySearchHints.cmake
+++ b/cmake/macros/HifiLibrarySearchHints.cmake
@ -0,0 +1,27 @@
+# 
+#  HifiLibrarySearchHints.cmake
+# 
+#  Created by Stephen Birarda on July 24th, 2014
+#  Copyright 2014 High Fidelity, Inc.
+#
+#  Distributed under the Apache License, Version 2.0.
+#  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+# 
+
+macro(HIFI_LIBRARY_SEARCH_HINTS LIBRARY_FOLDER)
+  string(TOUPPER ${LIBRARY_FOLDER} LIBRARY_PREFIX)
+  set(${LIBRARY_PREFIX}_SEARCH_DIRS "")
+  
+  if (${LIBRARY_PREFIX}_ROOT_DIR)
+    set(${LIBRARY_PREFIX}_SEARCH_DIRS "${${LIBRARY_PREFIX}_ROOT_DIR}")
+  endif ()
+  
+  if (DEFINED ENV{${LIBRARY_PREFIX}_ROOT_DIR})
+    set(${LIBRARY_PREFIX}_SEARCH_DIRS "${${LIBRARY_PREFIX}_SEARCH_DIRS}" "$ENV{${LIBRARY_PREFIX}_ROOT_DIR}")
+  endif ()
+  
+  if (DEFINED ENV{HIFI_LIB_DIR})
+    set(${LIBRARY_PREFIX}_SEARCH_DIRS "${${LIBRARY_PREFIX}_SEARCH_DIRS}" "$ENV{HIFI_LIB_DIR}/${LIBRARY_FOLDER}")
+  endif ()
+  
+endmacro(HIFI_LIBRARY_SEARCH_HINTS _library_folder)
--- a/cmake/modules/FindFaceshift.cmake
+++ b/cmake/modules/FindFaceshift.cmake
@ -18,7 +18,8 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 

-set(FACESHIFT_SEARCH_DIRS "${FACESHIFT_ROOT_DIR}" "$ENV{FACESHIFT_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/faceshift")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("faceshift")

 find_path(FACESHIFT_INCLUDE_DIRS fsbinarystream.h PATH_SUFFIXES include HINTS ${FACESHIFT_SEARCH_DIRS})

@ -41,4 +42,4 @@ set(FACESHIFT_LIBRARIES ${FACESHIFT_LIBRARY})
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(FACESHIFT DEFAULT_MSG FACESHIFT_INCLUDE_DIRS FACESHIFT_LIBRARIES)

-mark_as_advanced(FACESHIFT_INCLUDE_DIRS FACESHIFT_LIBRARIES)
+mark_as_advanced(FACESHIFT_INCLUDE_DIRS FACESHIFT_LIBRARIES FACESHIFT_SEARCH_DIRS)
--- a/cmake/modules/FindGLEW.cmake
+++ b/cmake/modules/FindGLEW.cmake
@ -19,12 +19,13 @@
 # 

 if (WIN32)
-  set(WIN_GLEW_SEARCH_DIRS "${GLEW_ROOT_DIR}" "$ENV{GLEW_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/glew")
+  include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+  hifi_library_search_hints("glew")
     
-	find_path(GLEW_INCLUDE_DIRS GL/glew.h PATH_SUFFIXES include HINTS ${WIN_GLEW_SEARCH_DIRS})
+	find_path(GLEW_INCLUDE_DIRS GL/glew.h PATH_SUFFIXES include HINTS ${GLEW_SEARCH_DIRS})
  
-	find_library(GLEW_LIBRARY_RELEASE glew32s PATH_SUFFIXES "lib/Release/Win32" "lib" HINTS ${WIN_GLEW_SEARCH_DIRS})
-  find_library(GLEW_LIBRARY_DEBUG glew32s PATH_SUFFIXES "lib/Debug/Win32" "lib" HINTS ${WIN_GLEW_SEARCH_DIRS})
+	find_library(GLEW_LIBRARY_RELEASE glew32s PATH_SUFFIXES "lib/Release/Win32" "lib" HINTS ${GLEW_SEARCH_DIRS})
+  find_library(GLEW_LIBRARY_DEBUG glew32s PATH_SUFFIXES "lib/Debug/Win32" "lib" HINTS ${GLEW_SEARCH_DIRS})
  
  include(SelectLibraryConfigurations)
  select_library_configurations(GLEW)
@ -35,4 +36,4 @@ set(GLEW_LIBRARIES "${GLEW_LIBRARY}")
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(GLEW DEFAULT_MSG GLEW_INCLUDE_DIRS GLEW_LIBRARIES)

-mark_as_advanced(GLEW_INCLUDE_DIRS GLEW_LIBRARIES)
+mark_as_advanced(GLEW_INCLUDE_DIRS GLEW_LIBRARIES GLEW_SEARCH_DIRS)
--- a/cmake/modules/FindGLM.cmake
+++ b/cmake/modules/FindGLM.cmake
@ -14,13 +14,14 @@
 # 

 # setup hints for GLM search
-set(GLM_HEADER_SEARCH_HINTS "${GLM_ROOT_DIR}" "$ENV{GLM_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/glm")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("glm")

 # locate header
-find_path(GLM_INCLUDE_DIR "glm/glm.hpp" HINTS ${GLM_HEADER_SEARCH_HINTS})
+find_path(GLM_INCLUDE_DIR "glm/glm.hpp" HINTS ${GLM_SEARCH_DIRS})
 set(GLM_INCLUDE_DIRS "${GLM_INCLUDE_DIR}")

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(GLM DEFAULT_MSG GLM_INCLUDE_DIRS)

-mark_as_advanced(GLM_INCLUDE_DIRS)
+mark_as_advanced(GLM_INCLUDE_DIRS GLM_SEARCH_DIRS)
--- a/cmake/modules/FindGLUT.cmake
+++ b/cmake/modules/FindGLUT.cmake
@ -18,16 +18,17 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 

-set(GLUT_HINT_DIRS "${GLUT_ROOT_DIR}" "$ENV{GLUT_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/freeglut")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("freeglut")

 if (WIN32)
-  set(GLUT_HINT_DIRS "${GLUT_HINT_DIRS}" "${OPENGL_INCLUDE_DIR}")
+  set(GLUT_HINT_DIRS "${FREEGLUT_SEARCH_DIRS} ${OPENGL_INCLUDE_DIR}")
  
-  find_path(GLUT_INCLUDE_DIRS GL/glut.h PATH_SUFFIXES include HINTS ${GLUT_HINT_DIRS})
-  find_library(GLUT_LIBRARY freeglut PATH_SUFFIXES lib HINTS ${GLUT_HINT_DIRS})
+  find_path(GLUT_INCLUDE_DIRS GL/glut.h PATH_SUFFIXES include HINTS ${FREEGLUT_SEARCH_DIRS})
+  find_library(GLUT_LIBRARY freeglut PATH_SUFFIXES lib HINTS ${FREEGLUT_SEARCH_DIRS})
 else ()
-  find_path(GLUT_INCLUDE_DIRS GL/glut.h PATH_SUFFIXES include HINTS ${GLUT_HINT_DIRS})
-  find_library(GLUT_LIBRARY glut PATH_SUFFIXES lib HINTS ${GLUT_HINT_DIRS})
+  find_path(GLUT_INCLUDE_DIRS GL/glut.h PATH_SUFFIXES include HINTS ${FREEGLUT_SEARCH_DIRS})
+  find_library(GLUT_LIBRARY glut PATH_SUFFIXES lib HINTS ${FREEGLUT_SEARCH_DIRS})
 endif ()

 include(FindPackageHandleStandardArgs)
@ -35,12 +36,12 @@ include(FindPackageHandleStandardArgs)
 set(GLUT_LIBRARIES "${GLUT_LIBRARY}" "${XMU_LIBRARY}" "${XI_LIBRARY}")

 if (UNIX)
-  find_library(XI_LIBRARY Xi PATH_SUFFIXES lib HINTS ${GLUT_HINT_DIRS})
-  find_library(XMU_LIBRARY Xmu PATH_SUFFIXES lib HINTS ${GLUT_HINT_DIRS})
+  find_library(XI_LIBRARY Xi PATH_SUFFIXES lib HINTS ${FREEGLUT_SEARCH_DIRS})
+  find_library(XMU_LIBRARY Xmu PATH_SUFFIXES lib HINTS ${FREEGLUT_SEARCH_DIRS})
  
  find_package_handle_standard_args(GLUT DEFAULT_MSG GLUT_INCLUDE_DIRS GLUT_LIBRARIES XI_LIBRARY XMU_LIBRARY)
 else ()
  find_package_handle_standard_args(GLUT DEFAULT_MSG GLUT_INCLUDE_DIRS GLUT_LIBRARIES)
 endif ()

-mark_as_advanced(GLUT_INCLUDE_DIRS GLUT_LIBRARIES GLUT_LIBRARY XI_LIBRARY XMU_LIBRARY)
+mark_as_advanced(GLUT_INCLUDE_DIRS GLUT_LIBRARIES GLUT_LIBRARY XI_LIBRARY XMU_LIBRARY FREEGLUT_SEARCH_DIRS)
--- a/cmake/modules/FindLeapMotion.cmake
+++ b/cmake/modules/FindLeapMotion.cmake
@ -12,24 +12,24 @@
 #  Copyright (c) 2014 High Fidelity
 #

-set(LEAPMOTION_SEARCH_DIRS "${LEAPMOTION_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/leapmotion")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("leapmotion")

 find_path(LEAPMOTION_INCLUDE_DIRS Leap.h PATH_SUFFIXES include HINTS ${LEAPMOTION_SEARCH_DIRS})

 if (WIN32)
-  find_library(LEAPMOTION_LIBRARY_DEBUG "lib/x86/Leapd.lib" HINTS ${LEAPMOTION_SEARCH_DIRS})
-  find_library(LEAPMOTION_LIBRARY_RELEASE "lib/x86/Leap.lib" HINTS ${LEAPMOTION_SEARCH_DIRS})
-endif (WIN32)
-if (APPLE)
-  find_library(LEAPMOTION_LIBRARY_RELEASE "lib/libLeap.dylib" HINTS ${LEAPMOTION_SEARCH_DIRS})
-endif (APPLE)
+  find_library(LEAPMOTION_LIBRARY_DEBUG Leapd PATH_SUFFIXES lib/x86 HINTS ${LEAPMOTION_SEARCH_DIRS})
+  find_library(LEAPMOTION_LIBRARY_RELEASE Leap PATH_SUFFIXES lib/x86 HINTS ${LEAPMOTION_SEARCH_DIRS})
+elseif (APPLE)
+  find_library(LEAPMOTION_LIBRARY_RELEASE Leap PATH_SUFFIXES lib HINTS ${LEAPMOTION_SEARCH_DIRS})
+endif ()

 include(SelectLibraryConfigurations)
 select_library_configurations(LEAPMOTION)

-set(LEAPMOTION_LIBRARIES "${LEAPMOTION_LIBARIES}")
+set(LEAPMOTION_LIBRARIES "${LEAPMOTION_LIBRARY}")

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(LEAPMOTION DEFAULT_MSG LEAPMOTION_INCLUDE_DIRS LEAPMOTION_LIBRARIES)

-mark_as_advanced(LEAPMOTION_INCLUDE_DIRS LEAPMOTION_LIBRARIES)
+mark_as_advanced(LEAPMOTION_INCLUDE_DIRS LEAPMOTION_LIBRARIES LEAPMOTION_SEARCH_DIRS)
--- a/cmake/modules/FindLibOVR.cmake
+++ b/cmake/modules/FindLibOVR.cmake
@ -18,10 +18,11 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 

-set(LIBOVR_SEARCH_DIRS "${LIBOVR_ROOT_DIR}" "$ENV{LIBOVR_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/oculus")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("oculus")

-find_path(LIBOVR_INCLUDE_DIRS OVR.h PATH_SUFFIXES Include HINTS ${LIBOVR_SEARCH_DIRS})
-find_path(LIBOVR_UTIL_INCLUDE_DIR Util_Render_Stereo.h PATH_SUFFIXES Src/Util HINTS ${LIBOVR_SEARCH_DIRS})
+find_path(LIBOVR_INCLUDE_DIRS OVR.h PATH_SUFFIXES Include HINTS ${OCULUS_SEARCH_DIRS})
+find_path(LIBOVR_UTIL_INCLUDE_DIR Util_Render_Stereo.h PATH_SUFFIXES Src/Util HINTS ${OCULUS_SEARCH_DIRS})

 # add the util include dir to the general include dirs
 set(LIBOVR_INCLUDE_DIRS "${LIBOVR_INCLUDE_DIRS}" "${LIBOVR_UTIL_INCLUDE_DIR}")
@ -29,8 +30,8 @@ set(LIBOVR_INCLUDE_DIRS "${LIBOVR_INCLUDE_DIRS}" "${LIBOVR_UTIL_INCLUDE_DIR}")
 include(SelectLibraryConfigurations)

 if (APPLE)
-  find_library(LIBOVR_LIBRARY_DEBUG "Lib/MacOS/Debug/libovr.a" HINTS ${LIBOVR_SEARCH_DIRS})
-  find_library(LIBOVR_LIBRARY_RELEASE "Lib/MacOS/Release/libovr.a" HINTS ${LIBOVR_SEARCH_DIRS})
+  find_library(LIBOVR_LIBRARY_DEBUG "Lib/MacOS/Debug/libovr.a" HINTS ${OCULUS_SEARCH_DIRS})
+  find_library(LIBOVR_LIBRARY_RELEASE "Lib/MacOS/Release/libovr.a" HINTS ${OCULUS_SEARCH_DIRS})
 elseif (UNIX)
  find_library(UDEV_LIBRARY_RELEASE udev /usr/lib/x86_64-linux-gnu/)
  find_library(XINERAMA_LIBRARY_RELEASE Xinerama /usr/lib/x86_64-linux-gnu/)
@ -41,15 +42,15 @@ elseif (UNIX)
    set(LINUX_ARCH_DIR "x86_64")
  endif()
  
-  find_library(LIBOVR_LIBRARY_DEBUG "Lib/Linux/Debug/${LINUX_ARCH_DIR}/libovr.a" HINTS ${LIBOVR_SEARCH_DIRS})
-  find_library(LIBOVR_LIBRARY_RELEASE "Lib/Linux/Release/${LINUX_ARCH_DIR}/libovr.a" HINTS ${LIBOVR_SEARCH_DIRS})
+  find_library(LIBOVR_LIBRARY_DEBUG "Lib/Linux/Debug/${LINUX_ARCH_DIR}/libovr.a" HINTS ${OCULUS_SEARCH_DIRS})
+  find_library(LIBOVR_LIBRARY_RELEASE "Lib/Linux/Release/${LINUX_ARCH_DIR}/libovr.a" HINTS ${OCULUS_SEARCH_DIRS})
  
  select_library_configurations(UDEV)
  select_library_configurations(XINERAMA)
  
 elseif (WIN32)   
-  find_library(LIBOVR_LIBRARY_DEBUG "Lib/Win32/libovrd.lib" HINTS ${LIBOVR_SEARCH_DIRS})   
-  find_library(LIBOVR_LIBRARY_RELEASE "Lib/Win32/libovr.lib" HINTS ${LIBOVR_SEARCH_DIRS})
+  find_library(LIBOVR_LIBRARY_DEBUG "Lib/Win32/libovrd.lib" HINTS ${OCULUS_SEARCH_DIRS})
+  find_library(LIBOVR_LIBRARY_RELEASE "Lib/Win32/libovr.lib" HINTS ${OCULUS_SEARCH_DIRS})
 endif ()

 select_library_configurations(LIBOVR)
@ -63,4 +64,4 @@ elseif ()
  find_package_handle_standard_args(LIBOVR DEFAULT_MSG LIBOVR_INCLUDE_DIRS LIBOVR_UTIL_INCLUDE_DIR LIBOVR_LIBRARIES UDEV_LIBRARY XINERAMA_LIBRARY)
 endif ()

-mark_as_advanced(LIBOVR_INCLUDE_DIRS LIBOVR_LIBRARIES)
+mark_as_advanced(LIBOVR_INCLUDE_DIRS LIBOVR_LIBRARIES OCULUS_SEARCH_DIRS)
--- a/cmake/modules/FindOpenSSL.cmake
+++ b/cmake/modules/FindOpenSSL.cmake
@ -46,7 +46,10 @@ if (WIN32)
  unset(_programfiles)
  set(_OPENSSL_ROOT_HINTS_AND_PATHS HINTS ${_OPENSSL_ROOT_HINTS} PATHS ${_OPENSSL_ROOT_PATHS})
 else ()
-  set(_OPENSSL_ROOT_HINTS_AND_PATHS ${OPENSSL_ROOT_DIR} $ENV{OPENSSL_ROOT_DIR} $ENV{HIFI_LIB_DIR}/openssl)
+  include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+  hifi_library_search_hints("openssl")
+  
+  set(_OPENSSL_ROOT_HINTS_AND_PATHS ${OPENSSL_SEARCH_DIRS})
 endif ()

 find_path(OPENSSL_INCLUDE_DIR NAMES openssl/ssl.h HINTS ${_OPENSSL_ROOT_HINTS_AND_PATHS} ${_OPENSSL_INCLUDEDIR} PATH_SUFFIXES include)
@ -228,4 +231,4 @@ else ()
  )
 endif ()

-mark_as_advanced(OPENSSL_INCLUDE_DIR OPENSSL_LIBRARIES)
+mark_as_advanced(OPENSSL_INCLUDE_DIR OPENSSL_LIBRARIES OPENSSL_SEARCH_DIRS)
--- a/cmake/modules/FindQxmpp.cmake
+++ b/cmake/modules/FindQxmpp.cmake
@ -18,7 +18,8 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 

-set(QXMPP_SEARCH_DIRS "${QXMPP_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/qxmpp")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("qxmpp")

 find_path(QXMPP_INCLUDE_DIRS QXmppClient.h PATH_SUFFIXES include/qxmpp HINTS ${QXMPP_SEARCH_DIRS})

@ -33,4 +34,4 @@ set(QXMPP_LIBRARIES "${QXMPP_LIBRARY}")
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(QXMPP DEFAULT_MSG QXMPP_INCLUDE_DIRS QXMPP_LIBRARIES)

-mark_as_advanced(QXMPP_INCLUDE_DIRS QXMPP_LIBRARIES)
+mark_as_advanced(QXMPP_INCLUDE_DIRS QXMPP_LIBRARIES QXMPP_SEARCH_DIRS)
--- a/cmake/modules/FindRtMidi.cmake
+++ b/cmake/modules/FindRtMidi.cmake
@ -18,7 +18,8 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 

-set(RTMIDI_SEARCH_DIRS "${RTMIDI_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/rtmidi")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("rtmidi")

 find_path(RTMIDI_INCLUDE_DIRS RtMidi.h PATH_SUFFIXES include HINTS ${RTMIDI_SEARCH_DIRS})
 find_library(RTMIDI_LIBRARIES NAMES rtmidi PATH_SUFFIXES lib HINTS ${RTMIDI_SEARCH_DIRS})
@ -26,4 +27,4 @@ find_library(RTMIDI_LIBRARIES NAMES rtmidi PATH_SUFFIXES lib HINTS ${RTMIDI_SEAR
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(RTMIDI DEFAULT_MSG RTMIDI_INCLUDE_DIRS RTMIDI_LIBRARIES)

-mark_as_advanced(RTMIDI_INCLUDE_DIRS RTMIDI_LIBRARIES)
+mark_as_advanced(RTMIDI_INCLUDE_DIRS RTMIDI_LIBRARIES RTMIDI_SEARCH_DIRS)
--- a/cmake/modules/FindSixense.cmake
+++ b/cmake/modules/FindSixense.cmake
@ -18,7 +18,8 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 

-set(SIXENSE_SEARCH_DIRS "${SIXENSE_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/sixense")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("sixense")

 find_path(SIXENSE_INCLUDE_DIRS sixense.h PATH_SUFFIXES include HINTS ${SIXENSE_SEARCH_DIRS})

@ -41,4 +42,4 @@ set(SIXENSE_LIBRARIES "${SIXENSE_LIBRARY}")
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(SIXENSE DEFAULT_MSG SIXENSE_INCLUDE_DIRS SIXENSE_LIBRARIES)

-mark_as_advanced(SIXENSE_LIBRARIES SIXENSE_INCLUDE_DIRS)
+mark_as_advanced(SIXENSE_LIBRARIES SIXENSE_INCLUDE_DIRS SIXENSE_SEARCH_DIRS)
--- a/cmake/modules/FindVisage.cmake
+++ b/cmake/modules/FindVisage.cmake
@ -18,7 +18,8 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 

-set(VISAGE_SEARCH_DIRS "${VISAGE_ROOT_DIR}" "$ENV{VISAGE_ROOT_DIR}" "$ENV{HIFI_LIB_DIR}/visage")
+include("${MACRO_DIR}/HifiLibrarySearchHints.cmake")
+hifi_library_search_hints("visage")

 find_path(VISAGE_BASE_INCLUDE_DIR VisageTracker2.h PATH_SUFFIXES include HINTS ${VISAGE_SEARCH_DIRS})

@ -53,5 +54,5 @@ set(VISAGE_LIBRARIES "${VISAGE_CORE_LIBRARY}" "${VISAGE_VISION_LIBRARY}" "${VISA
 mark_as_advanced(
  VISAGE_INCLUDE_DIRS VISAGE_LIBRARIES
  VISAGE_BASE_INCLUDE_DIR VISAGE_XML_INCLUDE_DIR VISAGE_OPENCV_INCLUDE_DIR VISAGE_OPENCV2_INCLUDE_DIR
-  VISAGE_CORE_LIBRARY VISAGE_VISION_LIBRARY VISAGE_OPENCV_LIBRARY
+  VISAGE_CORE_LIBRARY VISAGE_VISION_LIBRARY VISAGE_OPENCV_LIBRARY VISAGE_SEARCH_DIRS
 )
--- a/examples/editModels.js
+++ b/examples/editModels.js
@ -804,7 +804,7 @@ function mousePressEvent(event) {
        }
        
    } else if (browser == toolBar.clicked(clickedOverlay)) {
-        var url = Window.s3Browse();
+        var url = Window.s3Browse(".*(fbx|FBX)");
        if (url == null || url == "") {
            return;
        }
--- a/examples/editVoxels.js
+++ b/examples/editVoxels.js
@ -37,7 +37,7 @@ var WHITE_COLOR = { red: 255, green: 255, blue: 255 };
 var MAX_PASTE_VOXEL_SCALE = 256;
 var MIN_PASTE_VOXEL_SCALE = .256;

-var zFightingSizeAdjust = 0.002; // used to adjust preview voxels to prevent z fighting
+var zFightingSizeAdjustRatio = 0.004; // used to adjust preview voxels to prevent z fighting
 var previewLineWidth = 1.5;

 var inspectJsIsRunning = false;
@ -696,79 +696,99 @@ function calculateVoxelFromIntersection(intersection, operation) {
    if (wantDebug) {
        print("wantAddAdjust="+wantAddAdjust);
    }
+
+    var zFightingSizeAdjust = zFightingSizeAdjustRatio * intersection.distance;
    
    // now we also want to calculate the "edge square" for the face for this voxel
    if (intersection.face == "MIN_X_FACE") {
-        
+
        highlightAt.x = x - zFightingSizeAdjust;
+        highlightAt.y = y + zFightingSizeAdjust;
+        highlightAt.z = z + zFightingSizeAdjust;
+        voxelSize -= 2 * zFightingSizeAdjust;
        if (wantAddAdjust) {
            resultVoxel.x -= voxelSize;
        }
        
-        resultVoxel.bottomLeft = {x: highlightAt.x, y: highlightAt.y + zFightingSizeAdjust, z: highlightAt.z + zFightingSizeAdjust };
-        resultVoxel.bottomRight = {x: highlightAt.x, y: highlightAt.y + zFightingSizeAdjust, z: highlightAt.z + voxelSize - zFightingSizeAdjust };
-        resultVoxel.topLeft = {x: highlightAt.x, y: highlightAt.y + voxelSize - zFightingSizeAdjust, z: highlightAt.z + zFightingSizeAdjust };
-        resultVoxel.topRight = {x: highlightAt.x, y: highlightAt.y + voxelSize - zFightingSizeAdjust, z: highlightAt.z + voxelSize - zFightingSizeAdjust };
+        resultVoxel.bottomLeft = {x: highlightAt.x, y: highlightAt.y, z: highlightAt.z };
+        resultVoxel.bottomRight = {x: highlightAt.x, y: highlightAt.y, z: highlightAt.z + voxelSize };
+        resultVoxel.topLeft = {x: highlightAt.x, y: highlightAt.y + voxelSize, z: highlightAt.z };
+        resultVoxel.topRight = {x: highlightAt.x, y: highlightAt.y + voxelSize, z: highlightAt.z + voxelSize };
        
    } else if (intersection.face == "MAX_X_FACE") {
        
        highlightAt.x = x + voxelSize + zFightingSizeAdjust;
+        highlightAt.y = y + zFightingSizeAdjust;
+        highlightAt.z = z + zFightingSizeAdjust;
+        voxelSize -= 2 * zFightingSizeAdjust;
        if (wantAddAdjust) {
            resultVoxel.x += resultVoxel.s;
        }
        
-        resultVoxel.bottomRight = {x: highlightAt.x, y: highlightAt.y + zFightingSizeAdjust, z: highlightAt.z + zFightingSizeAdjust };
-        resultVoxel.bottomLeft = {x: highlightAt.x, y: highlightAt.y + zFightingSizeAdjust, z: highlightAt.z + voxelSize - zFightingSizeAdjust };
-        resultVoxel.topRight = {x: highlightAt.x, y: highlightAt.y + voxelSize - zFightingSizeAdjust, z: highlightAt.z + zFightingSizeAdjust };
-        resultVoxel.topLeft = {x: highlightAt.x, y: highlightAt.y + voxelSize - zFightingSizeAdjust, z: highlightAt.z + voxelSize - zFightingSizeAdjust };
+        resultVoxel.bottomRight = {x: highlightAt.x, y: highlightAt.y, z: highlightAt.z };
+        resultVoxel.bottomLeft = {x: highlightAt.x, y: highlightAt.y, z: highlightAt.z + voxelSize };
+        resultVoxel.topRight = {x: highlightAt.x, y: highlightAt.y + voxelSize, z: highlightAt.z };
+        resultVoxel.topLeft = {x: highlightAt.x, y: highlightAt.y + voxelSize, z: highlightAt.z + voxelSize };
        
    } else if (intersection.face == "MIN_Y_FACE") {
        
+        highlightAt.x = x + zFightingSizeAdjust;
        highlightAt.y = y - zFightingSizeAdjust;
+        highlightAt.z = z + zFightingSizeAdjust;
+        voxelSize -= 2 * zFightingSizeAdjust;
        if (wantAddAdjust) {
            resultVoxel.y -= voxelSize;
        }
        
-        resultVoxel.topRight = {x: highlightAt.x + zFightingSizeAdjust , y: highlightAt.y, z: highlightAt.z + zFightingSizeAdjust  };
-        resultVoxel.topLeft = {x: highlightAt.x + voxelSize - zFightingSizeAdjust, y: highlightAt.y, z: highlightAt.z + zFightingSizeAdjust };
-        resultVoxel.bottomRight = {x: highlightAt.x + zFightingSizeAdjust , y: highlightAt.y, z: highlightAt.z  + voxelSize - zFightingSizeAdjust };
-        resultVoxel.bottomLeft = {x: highlightAt.x + voxelSize - zFightingSizeAdjust , y: highlightAt.y, z: highlightAt.z + voxelSize - zFightingSizeAdjust };
+        resultVoxel.topRight = {x: highlightAt.x , y: highlightAt.y, z: highlightAt.z  };
+        resultVoxel.topLeft = {x: highlightAt.x + voxelSize, y: highlightAt.y, z: highlightAt.z };
+        resultVoxel.bottomRight = {x: highlightAt.x , y: highlightAt.y, z: highlightAt.z  + voxelSize };
+        resultVoxel.bottomLeft = {x: highlightAt.x + voxelSize , y: highlightAt.y, z: highlightAt.z + voxelSize };
        
    } else if (intersection.face == "MAX_Y_FACE") {
        
+        highlightAt.x = x + zFightingSizeAdjust;
        highlightAt.y = y + voxelSize + zFightingSizeAdjust;
+        highlightAt.z = z + zFightingSizeAdjust;
+        voxelSize -= 2 * zFightingSizeAdjust;
        if (wantAddAdjust) {
            resultVoxel.y += voxelSize;
        }
        
-        resultVoxel.bottomRight = {x: highlightAt.x + zFightingSizeAdjust, y: highlightAt.y, z: highlightAt.z + zFightingSizeAdjust };
-        resultVoxel.bottomLeft = {x: highlightAt.x + voxelSize - zFightingSizeAdjust, y: highlightAt.y, z: highlightAt.z + zFightingSizeAdjust};
-        resultVoxel.topRight = {x: highlightAt.x + zFightingSizeAdjust, y: highlightAt.y, z: highlightAt.z  + voxelSize - zFightingSizeAdjust};
-        resultVoxel.topLeft = {x: highlightAt.x + voxelSize - zFightingSizeAdjust, y: highlightAt.y, z: highlightAt.z + voxelSize - zFightingSizeAdjust};
+        resultVoxel.bottomRight = {x: highlightAt.x, y: highlightAt.y, z: highlightAt.z };
+        resultVoxel.bottomLeft = {x: highlightAt.x + voxelSize, y: highlightAt.y, z: highlightAt.z};
+        resultVoxel.topRight = {x: highlightAt.x, y: highlightAt.y, z: highlightAt.z  + voxelSize};
+        resultVoxel.topLeft = {x: highlightAt.x + voxelSize, y: highlightAt.y, z: highlightAt.z + voxelSize};
        
    } else if (intersection.face == "MIN_Z_FACE") {
        
+        highlightAt.x = x + zFightingSizeAdjust;
+        highlightAt.y = y + zFightingSizeAdjust;
        highlightAt.z = z - zFightingSizeAdjust;
+        voxelSize -= 2 * zFightingSizeAdjust;
        if (wantAddAdjust) {
            resultVoxel.z -= voxelSize;
        }
        
-        resultVoxel.bottomRight = {x: highlightAt.x + zFightingSizeAdjust, y: highlightAt.y + zFightingSizeAdjust, z: highlightAt.z };
-        resultVoxel.bottomLeft = {x: highlightAt.x + voxelSize - zFightingSizeAdjust, y: highlightAt.y + zFightingSizeAdjust, z: highlightAt.z};
-        resultVoxel.topRight = {x: highlightAt.x + zFightingSizeAdjust, y: highlightAt.y + voxelSize - zFightingSizeAdjust, z: highlightAt.z };
-        resultVoxel.topLeft = {x: highlightAt.x + voxelSize - zFightingSizeAdjust, y: highlightAt.y + voxelSize - zFightingSizeAdjust, z: highlightAt.z};
+        resultVoxel.bottomRight = {x: highlightAt.x, y: highlightAt.y, z: highlightAt.z };
+        resultVoxel.bottomLeft = {x: highlightAt.x + voxelSize, y: highlightAt.y, z: highlightAt.z};
+        resultVoxel.topRight = {x: highlightAt.x, y: highlightAt.y + voxelSize, z: highlightAt.z };
+        resultVoxel.topLeft = {x: highlightAt.x + voxelSize, y: highlightAt.y + voxelSize, z: highlightAt.z};
        
    } else if (intersection.face == "MAX_Z_FACE") {
        
+        highlightAt.x = x + zFightingSizeAdjust;
+        highlightAt.y = y + zFightingSizeAdjust;
        highlightAt.z = z + voxelSize + zFightingSizeAdjust;
+        voxelSize -= 2 * zFightingSizeAdjust;
        if (wantAddAdjust) {
            resultVoxel.z += voxelSize;
        }
        
-        resultVoxel.bottomLeft = {x: highlightAt.x + zFightingSizeAdjust, y: highlightAt.y + zFightingSizeAdjust, z: highlightAt.z };
-        resultVoxel.bottomRight = {x: highlightAt.x + voxelSize - zFightingSizeAdjust, y: highlightAt.y + zFightingSizeAdjust, z: highlightAt.z};
-        resultVoxel.topLeft = {x: highlightAt.x + zFightingSizeAdjust, y: highlightAt.y + voxelSize - zFightingSizeAdjust, z: highlightAt.z };
-        resultVoxel.topRight = {x: highlightAt.x + voxelSize - zFightingSizeAdjust, y: highlightAt.y + voxelSize - zFightingSizeAdjust, z: highlightAt.z};
+        resultVoxel.bottomLeft = {x: highlightAt.x, y: highlightAt.y, z: highlightAt.z };
+        resultVoxel.bottomRight = {x: highlightAt.x + voxelSize, y: highlightAt.y, z: highlightAt.z};
+        resultVoxel.topLeft = {x: highlightAt.x, y: highlightAt.y + voxelSize, z: highlightAt.z };
+        resultVoxel.topRight = {x: highlightAt.x + voxelSize, y: highlightAt.y + voxelSize, z: highlightAt.z};
        
    }
    
@ -845,7 +865,7 @@ function showPreviewLines() {
            scaleSelector.setScale(intersection.voxel.s);
        }
        moveTools();
-    } else {
+    } else if (intersection.accurate) {
        Overlays.editOverlay(voxelPreview, { visible: false });
        Overlays.editOverlay(linePreviewTop[currentCursor], { visible: false });
        Overlays.editOverlay(linePreviewBottom[currentCursor], { visible: false });
@ -1226,12 +1246,8 @@ function menuItemEvent(menuItem) {
 }

 function mouseMoveEvent(event) {
-
-    if (!editToolsOn) {
-        return;
-    }
-    if (inspectJsIsRunning) {
-        return;
+    if (!editToolsOn || inspectJsIsRunning) {
+      return;
    }
    
    if (event.deviceID == 1500) { // Left Hydra Controller
--- a/interface/CMakeLists.txt
+++ b/interface/CMakeLists.txt
@ -12,15 +12,15 @@ project(${TARGET_NAME})

 # setup for find modules
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/modules/")
-set(FACEPLUS_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/faceplus")
-set(FACESHIFT_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/faceshift")
-set(LIBOVR_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/oculus")
-set(PRIOVR_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/priovr")
-set(SIXENSE_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/sixense")
-set(VISAGE_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/visage")
-set(LEAPMOTION_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/leapmotion")
-set(RTMIDI_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/rtmidi")

+# set a default root dir for each of our optional externals if it was not passed
+set(OPTIONAL_EXTERNALS "faceplus" "faceshift" "oculus" "priovr" "sixense" "visage" "leapmotion" "rtmidi" "qxmpp")
+foreach(EXTERNAL ${OPTIONAL_EXTERNALS})
+  string(TOUPPER ${EXTERNAL} UPPER_EXTERNAL)
+  if (NOT ${UPPER_EXTERNAL}_ROOT_DIR)
+    set(${UPPER_EXTERNAL}_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/${EXTERNAL}")
+  endif ()
+endforeach()

 find_package(Qt5LinguistTools REQUIRED)
 find_package(Qt5LinguistToolsMacros)
@ -134,105 +134,54 @@ find_package(Qxmpp)
 find_package(RtMidi)
 find_package(OpenSSL REQUIRED)

-# include the Sixense library for Razer Hydra if available
-if (SIXENSE_FOUND AND NOT DISABLE_SIXENSE)
-  add_definitions(-DHAVE_SIXENSE)
-  include_directories(SYSTEM "${SIXENSE_INCLUDE_DIRS}")
-  if (APPLE OR UNIX)
-      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${SIXENSE_INCLUDE_DIRS}")
-  endif (APPLE OR UNIX)
-  target_link_libraries(${TARGET_NAME} ${SIXENSE_LIBRARIES})
-endif (SIXENSE_FOUND AND NOT DISABLE_SIXENSE)
-
-# likewise with Visage library for webcam feature tracking
-if (VISAGE_FOUND AND NOT DISABLE_VISAGE)
-  add_definitions(-DHAVE_VISAGE -DVISAGE_STATIC)
-  include_directories(SYSTEM "${VISAGE_INCLUDE_DIRS}")
-  if (APPLE)
-      add_definitions(-DMAC_OS_X)
-      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-comment")
-      include_directories(SYSTEM "${VISAGE_INCLUDE_DIRS}")
-      find_library(AVFoundation AVFoundation)
-      find_library(CoreMedia CoreMedia)
-      find_library(NEW_STD_LIBRARY libc++.dylib /usr/lib/)
-      target_link_libraries(${TARGET_NAME} ${AVFoundation} ${CoreMedia} ${NEW_STD_LIBRARY})
-  endif (APPLE)
-  target_link_libraries(${TARGET_NAME} "${VISAGE_LIBRARIES}")
-endif (VISAGE_FOUND AND NOT DISABLE_VISAGE)
-
-# and with Faceplus library, also for webcam feature tracking
-if (FACEPLUS_FOUND AND NOT DISABLE_FACEPLUS)
-  add_definitions(-DHAVE_FACEPLUS)
-  include_directories(SYSTEM "${FACEPLUS_INCLUDE_DIRS}")
-  target_link_libraries(${TARGET_NAME} "${FACEPLUS_LIBRARIES}")
-endif (FACEPLUS_FOUND AND NOT DISABLE_FACEPLUS)
-
-# and with LibOVR for Oculus Rift
-if (LIBOVR_FOUND AND NOT DISABLE_LIBOVR)
-  add_definitions(-DHAVE_LIBOVR)
-  include_directories(SYSTEM ${LIBOVR_INCLUDE_DIRS})
+# perform standard include and linking for found externals
+foreach(EXTERNAL ${OPTIONAL_EXTERNALS})
+  string(TOUPPER ${EXTERNAL} UPPER_EXTERNAL)
  
-  if (APPLE)
-    foreach(LIBOVR_DIR ${LIBOVR_INCLUDE_DIRS})
-       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${LIBOVR_DIR}")
-    endforeach()
+  if (${UPPER_EXTERNAL} MATCHES "OCULUS")
+    # the oculus directory is named OCULUS and not LIBOVR so hack to fix that here
+    set(UPPER_EXTERNAL "LIBOVR")
  endif ()
  
-  target_link_libraries(${TARGET_NAME} ${LIBOVR_LIBRARIES})
-endif (LIBOVR_FOUND AND NOT DISABLE_LIBOVR)
-
-# and with PrioVR library
-if (PRIOVR_FOUND AND NOT DISABLE_PRIOVR)
-  add_definitions(-DHAVE_PRIOVR)
-  include_directories(SYSTEM "${PRIOVR_INCLUDE_DIRS}")
-  target_link_libraries(${TARGET_NAME} "${PRIOVR_LIBRARIES}")
-endif (PRIOVR_FOUND AND NOT DISABLE_PRIOVR)
-
-# and with LeapMotion library
-if (LEAPMOTION_FOUND AND NOT DISABLE_LEAPMOTION)
-    add_definitions(-DHAVE_LEAPMOTION)
-    include_directories(SYSTEM "${LEAPMOTION_INCLUDE_DIRS}")
-
+  if (${UPPER_EXTERNAL}_FOUND AND NOT DISABLE_${UPPER_EXTERNAL})
+    add_definitions(-DHAVE_${UPPER_EXTERNAL})
+    
+    # include the library directories (ignoring warnings)
+    include_directories(SYSTEM ${${UPPER_EXTERNAL}_INCLUDE_DIRS})
+    
+    # perform the system include hack for OS X to ignore warnings
    if (APPLE)
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${LEAPMOTION_INCLUDE_DIRS}")
+      foreach(EXTERNAL_INCLUDE_DIR  ${${UPPER_EXTERNAL}_INCLUDE_DIRS})
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${EXTERNAL_INCLUDE_DIR}")
+      endforeach()
    endif ()
-    target_link_libraries(${TARGET_NAME} ${LEAPMOTION_LIBRARIES})
-endif (LEAPMOTION_FOUND AND NOT DISABLE_LEAPMOTION)
+    
+    target_link_libraries(${TARGET_NAME} ${${UPPER_EXTERNAL}_LIBRARIES})
+    
+  endif ()
+endforeach()

-# and with SDL for joysticks
-if (SDL_FOUND AND NOT DISABLE_SDL)
-  add_definitions(-DHAVE_SDL)
-  include_directories(SYSTEM "${SDL_INCLUDE_DIR}")
-  target_link_libraries(${TARGET_NAME} "${SDL_LIBRARY}")
-endif (SDL_FOUND AND NOT DISABLE_SDL)
+# special APPLE modifications for Visage library
+if (VISAGE_FOUND AND NOT DISABLE_VISAGE AND APPLE)
+  add_definitions(-DMAC_OS_X)
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-comment")
+  find_library(AVFoundation AVFoundation)
+  find_library(CoreMedia CoreMedia)
+  find_library(NEW_STD_LIBRARY libc++.dylib /usr/lib/)
+  target_link_libraries(${TARGET_NAME} ${AVFoundation} ${CoreMedia} ${NEW_STD_LIBRARY})
+endif ()

-# and with qxmpp for chat
-if (QXMPP_FOUND AND NOT DISABLE_QXMPP)
-  add_definitions(-DHAVE_QXMPP -DQXMPP_STATIC)
-  include_directories(SYSTEM "${QXMPP_INCLUDE_DIRS}")
+# special OS X modifications for RtMidi library
+if (RTMIDI_FOUND AND NOT DISABLE_RTMIDI AND APPLE)  
+  find_library(CoreMIDI CoreMIDI)
+  add_definitions(-D__MACOSX_CORE__)
+  target_link_libraries(${TARGET_NAME} ${CoreMIDI})
+endif ()

-  target_link_libraries(${TARGET_NAME} ${QXMPP_LIBRARIES})
-endif (QXMPP_FOUND AND NOT DISABLE_QXMPP)
-
-# and with RtMidi for RtMidi control
-if (RTMIDI_FOUND AND NOT DISABLE_RTMIDI)
-  add_definitions(-DHAVE_RTMIDI)
-  include_directories(SYSTEM "${RTMIDI_INCLUDE_DIRS}")
-  target_link_libraries(${TARGET_NAME} ${RTMIDI_LIBRARIES})
-  
-  if (APPLE)
-    find_library(CoreMIDI CoreMIDI)
-    add_definitions(-D__MACOSX_CORE__)
-    target_link_libraries(${TARGET_NAME} ${CoreMIDI})
-  endif()
-endif()
-
-# and with Faceshift for depth camera face tracking
-if (FACESHIFT_FOUND AND NOT DISABLE_FACESHIFT)
-  add_definitions(-DHAVE_FACESHIFT)
-  include_directories(SYSTEM "${FACESHIFT_INCLUDE_DIRS}")
-  target_link_libraries(${TARGET_NAME} ${FACESHIFT_LIBRARIES})
-endif()
+if (QXMPP_FOUND AND NOT DISABLE_QXMPP AND WIN32)
+  # assume we're linking a static Qt on windows
+  add_definitions(-DQXMPP_STATIC) 
+endif ()

 # include headers for interface and InterfaceConfig.
 include_directories("${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}/includes")
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@ -524,8 +524,8 @@ void Application::initializeGL() {
    // Before we render anything, let's set up our viewFrustumOffsetCamera with a sufficiently large
    // field of view and near and far clip to make it interesting.
    //viewFrustumOffsetCamera.setFieldOfView(90.0);
-    _viewFrustumOffsetCamera.setNearClip(0.1f);
-    _viewFrustumOffsetCamera.setFarClip(500.0f * TREE_SCALE);
+    _viewFrustumOffsetCamera.setNearClip(DEFAULT_NEAR_CLIP);
+    _viewFrustumOffsetCamera.setFarClip(DEFAULT_FAR_CLIP);

    initDisplay();
    qDebug( "Initialized Display.");
--- a/interface/src/Camera.cpp
+++ b/interface/src/Camera.cpp
@ -47,8 +47,8 @@ Camera::Camera() :
    _targetPosition(0.0f, 0.0f, 0.0f),
    _fieldOfView(DEFAULT_FIELD_OF_VIEW_DEGREES),
    _aspectRatio(16.0f/9.0f),
-    _nearClip(0.08f), // default
-    _farClip(50.0f * TREE_SCALE), // default
+    _nearClip(DEFAULT_NEAR_CLIP), // default
+    _farClip(DEFAULT_FAR_CLIP), // default
    _upShift(0.0f),
    _distance(0.0f),
    _tightness(10.0f), // default
--- a/interface/src/Menu.cpp
+++ b/interface/src/Menu.cpp
@ -242,8 +242,8 @@ Menu::Menu() :

    const QXmppClient& xmppClient = XmppClient::getInstance().getXMPPClient();
    toggleChat();
-    connect(&xmppClient, SIGNAL(connected()), this, SLOT(toggleChat()));
-    connect(&xmppClient, SIGNAL(disconnected()), this, SLOT(toggleChat()));
+    connect(&xmppClient, &QXmppClient::connected, this, &Menu::toggleChat);
+    connect(&xmppClient, &QXmppClient::disconnected, this, &Menu::toggleChat);

    QDir::setCurrent(Application::resourcesPath());
    // init chat window to listen chat
--- a/interface/src/XmppClient.cpp
+++ b/interface/src/XmppClient.cpp
@ -9,7 +9,6 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //

-#ifdef HAVE_QXMPP

 #include <AccountManager.h>

@ -18,6 +17,7 @@
 const QString DEFAULT_XMPP_SERVER = "chat.highfidelity.io";
 const QString DEFAULT_CHAT_ROOM = "public@public-chat.highfidelity.io";

+#ifdef HAVE_QXMPP
 XmppClient::XmppClient() :
    _xmppClient(),
    _xmppMUCManager()
@ -26,6 +26,11 @@ XmppClient::XmppClient() :
    connect(&accountManager, SIGNAL(profileChanged()), this, SLOT(connectToServer()));
    connect(&accountManager, SIGNAL(logoutComplete()), this, SLOT(disconnectFromServer()));
 }
+#else
+XmppClient::XmppClient() {
+    
+}
+#endif

 XmppClient& XmppClient::getInstance() {
    static XmppClient sharedInstance;
@ -33,18 +38,23 @@ XmppClient& XmppClient::getInstance() {
 }

 void XmppClient::xmppConnected() {
+#ifdef HAVE_QXMPP
    _publicChatRoom = _xmppMUCManager.addRoom(DEFAULT_CHAT_ROOM);
    _publicChatRoom->setNickName(AccountManager::getInstance().getAccountInfo().getUsername());
    _publicChatRoom->join();
    emit joinedPublicChatRoom();
+#endif
 }

+#ifdef HAVE_QXMPP
 void XmppClient::xmppError(QXmppClient::Error error) {
    qDebug() << "Error connnecting to XMPP for user "
        << AccountManager::getInstance().getAccountInfo().getUsername() << ": " << error;
 }
+#endif

 void XmppClient::connectToServer() {
+#ifdef HAVE_QXMPP
    disconnectFromServer();

    if (_xmppClient.addExtension(&_xmppMUCManager)) {
@ -55,12 +65,15 @@ void XmppClient::connectToServer() {
    QString user = accountManager.getAccountInfo().getUsername();
    const QString& password = accountManager.getAccountInfo().getXMPPPassword();
    _xmppClient.connectToServer(user + "@" + DEFAULT_XMPP_SERVER, password);
+#endif
 }

 void XmppClient::disconnectFromServer() {
+#ifdef HAVE_QXMPP
    if (_xmppClient.isConnected()) {
        _xmppClient.disconnectFromServer();
    }
+#endif
 }

 XmppClient::XmppClient(const XmppClient& other) {
@ -70,5 +83,3 @@ XmppClient::XmppClient(const XmppClient& other) {
 void XmppClient::operator =(XmppClient const& other) {
    Q_UNUSED(other);
 }
-
-#endif
--- a/interface/src/XmppClient.h
+++ b/interface/src/XmppClient.h
@ -9,31 +9,35 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //

-#ifdef HAVE_QXMPP
-
 #ifndef hifi_XmppClient_h
 #define hifi_XmppClient_h

 #include <QObject>
+
+#ifdef HAVE_QXMPP
 #include <QXmppClient.h>
 #include <QXmppMucManager.h>
+#endif

 /// Generalized threaded processor for handling received inbound packets. 
 class XmppClient : public QObject {
    Q_OBJECT
-
 public:
    static XmppClient& getInstance();

+#ifdef HAVE_QXMPP
    QXmppClient& getXMPPClient() { return _xmppClient; }
    const QXmppMucRoom* getPublicChatRoom() const { return _publicChatRoom; }
-
+#endif
+    
 signals:
    void joinedPublicChatRoom();

 private slots:
    void xmppConnected();
+#ifdef HAVE_QXMPP
    void xmppError(QXmppClient::Error error);
+#endif

    void connectToServer();
    void disconnectFromServer();
@ -43,11 +47,11 @@ private:
    XmppClient(XmppClient const& other); // not implemented
    void operator=(XmppClient const& other); // not implemented

+#ifdef HAVE_QXMPP
    QXmppClient _xmppClient;
    QXmppMucManager _xmppMUCManager;
    QXmppMucRoom* _publicChatRoom;
+#endif
 };

-#endif // __interface__XmppClient__
-
 #endif // hifi_XmppClient_h
--- a/interface/src/avatar/MuscleConstraint.cpp
+++ b/interface/src/avatar/MuscleConstraint.cpp
@ -0,0 +1,34 @@
+//
+//  MuscleConstraint.cpp
+//  interface/src/avatar
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include <SharedUtil.h>
+#include <VerletPoint.h>
+
+#include "MuscleConstraint.h"
+
+const float DEFAULT_MUSCLE_STRENGTH = 0.5f * MAX_MUSCLE_STRENGTH;
+
+MuscleConstraint::MuscleConstraint(VerletPoint* parent, VerletPoint* child)
+        : _rootPoint(parent), _childPoint(child), 
+        _parentIndex(-1), _childndex(-1), _strength(DEFAULT_MUSCLE_STRENGTH) {
+    _childOffset = child->_position - parent->_position;
+}
+
+float MuscleConstraint::enforce() {
+    _childPoint->_position = (1.0f - _strength) * _childPoint->_position + _strength * (_rootPoint->_position + _childOffset);
+    return 0.0f;
+}
+
+void MuscleConstraint::setIndices(int parent, int child) {
+    _parentIndex = parent;
+    _childndex = child;
+}
+
--- a/interface/src/avatar/MuscleConstraint.h
+++ b/interface/src/avatar/MuscleConstraint.h
@ -0,0 +1,43 @@
+//
+//  MuscleConstraint.h
+//  interface/src/avatar
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_MuscleConstraint_h
+#define hifi_MuscleConstraint_h
+
+#include <Constraint.h>
+
+// MuscleConstraint is a simple constraint that pushes the child toward an offset relative to the parent.
+// It does NOT push the parent.
+
+const float MAX_MUSCLE_STRENGTH = 0.5f;
+
+class MuscleConstraint : public Constraint {
+public:
+    MuscleConstraint(VerletPoint* parent, VerletPoint* child);
+    MuscleConstraint(const MuscleConstraint& other);
+    float enforce();
+
+    void setIndices(int parent, int child);
+    int getParentIndex() const { return _parentIndex; }
+    int getChildIndex() const { return _childndex; }
+    void setChildOffset(const glm::vec3& offset) { _childOffset = offset; }
+    void setStrength(float strength) { _strength = glm::clamp(strength, 0.0f, MAX_MUSCLE_STRENGTH); }
+    float getStrength() const { return _strength; }
+private:
+    VerletPoint* _rootPoint;
+    VerletPoint* _childPoint;
+    int _parentIndex;
+    int _childndex;
+    glm::vec3 _childOffset;
+    float _strength;    // a value in range [0,MAX_MUSCLE_STRENGTH]
+};
+
+#endif // hifi_MuscleConstraint_h
--- a/interface/src/avatar/SkeletonModel.cpp
+++ b/interface/src/avatar/SkeletonModel.cpp
@ -14,11 +14,14 @@

 #include <VerletCapsuleShape.h>
 #include <VerletSphereShape.h>
+#include <DistanceConstraint.h>
+#include <FixedConstraint.h>

 #include "Application.h"
 #include "Avatar.h"
 #include "Hand.h"
 #include "Menu.h"
+#include "MuscleConstraint.h"
 #include "SkeletonModel.h"

 SkeletonModel::SkeletonModel(Avatar* owningAvatar, QObject* parent) : 
@ -505,6 +508,7 @@ void SkeletonModel::renderRagdoll() {
 // virtual
 void SkeletonModel::initRagdollPoints() {
    clearRagdollConstraintsAndPoints();
+    _muscleConstraints.clear();

    // one point for each joint
    int numJoints = _jointStates.size();
@ -512,8 +516,7 @@ void SkeletonModel::initRagdollPoints() {
    for (int i = 0; i < numJoints; ++i) {
        const JointState& state = _jointStates.at(i);
        glm::vec3 position = state.getPosition();
-        _ragdollPoints[i]._position = position;
-        _ragdollPoints[i]._lastPosition = position;
+        _ragdollPoints[i].initPosition(position);
    }
 }

@ -523,11 +526,12 @@ void SkeletonModel::buildRagdollConstraints() {
    const int numPoints = _ragdollPoints.size();
    assert(numPoints == _jointStates.size());

+    float minBone = FLT_MAX;
+    float maxBone = -FLT_MAX;
    QMultiMap<int, int> families;
    for (int i = 0; i < numPoints; ++i) {
        const JointState& state = _jointStates.at(i);
-        const FBXJoint& joint = state.getFBXJoint();
-        int parentIndex = joint.parentIndex;
+        int parentIndex = state.getParentIndex();
        if (parentIndex == -1) {
            FixedConstraint* anchor = new FixedConstraint(&(_ragdollPoints[i]), glm::vec3(0.0f));
            _ragdollConstraints.push_back(anchor);
@ -537,20 +541,59 @@ void SkeletonModel::buildRagdollConstraints() {
            _ragdollConstraints.push_back(bone);
            families.insert(parentIndex, i);
        }
+        float boneLength = glm::length(state.getPositionInParentFrame());
+        if (boneLength > maxBone) {
+            maxBone = boneLength;
+        } else if (boneLength < minBone) {
+            minBone = boneLength;
+        }
    }
    // Joints that have multiple children effectively have rigid constraints between the children
-    // in the parent frame, so we add constraints between children in the same family.
+    // in the parent frame, so we add DistanceConstraints between children in the same family.
    QMultiMap<int, int>::iterator itr = families.begin();
    while (itr != families.end()) {
        QList<int> children = families.values(itr.key());
-        if (children.size() > 1) {
-            for (int i = 1; i < children.size(); ++i) {
+        int numChildren = children.size();
+        if (numChildren > 1) {
+            for (int i = 1; i < numChildren; ++i) {
                DistanceConstraint* bone = new DistanceConstraint(&(_ragdollPoints[children[i-1]]), &(_ragdollPoints[children[i]]));
                _ragdollConstraints.push_back(bone);
            }
+            if (numChildren > 2) {
+                DistanceConstraint* bone = new DistanceConstraint(&(_ragdollPoints[children[numChildren-1]]), &(_ragdollPoints[children[0]]));
+                _ragdollConstraints.push_back(bone);
+            }
        }
        ++itr;
    }
+
+    float MAX_STRENGTH = 0.3f;
+    float MIN_STRENGTH = 0.005f;
+    // each joint gets a MuscleConstraint to its parent
+    for (int i = 1; i < numPoints; ++i) {
+        const JointState& state = _jointStates.at(i);
+        int p = state.getParentIndex();
+        if (p == -1) {
+            continue;
+        }
+        MuscleConstraint* constraint = new MuscleConstraint(&(_ragdollPoints[p]), &(_ragdollPoints[i]));
+        _ragdollConstraints.push_back(constraint);
+        _muscleConstraints.push_back(constraint);
+
+        // Short joints are more susceptible to wiggle so we modulate the strength based on the joint's length: 
+        // long = weak and short = strong.
+        constraint->setIndices(p, i);
+        float boneLength = glm::length(state.getPositionInParentFrame());
+
+        float strength = MIN_STRENGTH + (MAX_STRENGTH - MIN_STRENGTH) * (maxBone - boneLength) / (maxBone - minBone);
+        if (!families.contains(i)) {
+            // Although muscles only pull on the children not parents, nevertheless those joints that have
+            // parents AND children are more stable than joints at the end such as fingers.  For such joints we
+            // bestow maximum strength which helps reduce wiggle.
+            strength = MAX_MUSCLE_STRENGTH;
+        }
+        constraint->setStrength(strength);
+    }
    
 }

@ -598,7 +641,8 @@ void SkeletonModel::updateVisibleJointStates() {

 // virtual 
 void SkeletonModel::stepRagdollForward(float deltaTime) {
-    moveShapesTowardJoints(deltaTime);
+    Ragdoll::stepRagdollForward(deltaTime);
+    updateMuscles();
 }

 float DENSITY_OF_WATER = 1000.0f; // kg/m^3
@ -666,14 +710,16 @@ void SkeletonModel::buildShapes() {
    if (_ragdollPoints.size() == numStates) {
        int numJoints = _jointStates.size();
        for (int i = 0; i < numJoints; ++i) {
-            _ragdollPoints[i]._lastPosition = _ragdollPoints.at(i)._position;
-            _ragdollPoints[i]._position = _jointStates.at(i).getPosition();
+            _ragdollPoints[i].initPosition(_jointStates.at(i).getPosition());
        }
    }
    enforceRagdollConstraints();
 }

 void SkeletonModel::moveShapesTowardJoints(float deltaTime) {
+    // KEEP: although we don't currently use this method we may eventually need it to help
+    // unravel a skelton that has become tangled in its constraints.  So let's keep this
+    // around for a while just in case.
    const int numStates = _jointStates.size();
    assert(_jointStates.size() == _ragdollPoints.size());
    if (_ragdollPoints.size() != numStates) {
@ -684,41 +730,26 @@ void SkeletonModel::moveShapesTowardJoints(float deltaTime) {
    const float RAGDOLL_FOLLOWS_JOINTS_TIMESCALE = 0.05f;
    float fraction = glm::clamp(deltaTime / RAGDOLL_FOLLOWS_JOINTS_TIMESCALE, 0.0f, 1.0f);

-    // SIMPLE LINEAR SLAVING -- KEEP this implementation for reference
-    //float oneMinusFraction = 1.0f - fraction; 
-    //for (int i = 0; i < numStates; ++i) {
-    //    _ragdollPoints[i]._lastPosition = _ragdollPoints[i]._position;
-    //    _ragdollPoints[i]._position = oneMinusFraction * _ragdollPoints[i]._position + fraction * _jointStates.at(i).getPosition();
-    //}
-    // SIMPLE LINEAR SLAVING -- KEEP
-
-    // parent-relative linear slaving
+    float oneMinusFraction = 1.0f - fraction; 
    for (int i = 0; i < numStates; ++i) {
-        JointState& state = _jointStates[i];
-        _ragdollPoints[i]._lastPosition = _ragdollPoints.at(i)._position;
+        _ragdollPoints[i].initPosition(oneMinusFraction * _ragdollPoints[i]._position + 
+                fraction * _jointStates.at(i).getPosition());
+    }
+}

-        int p = state.getParentIndex();
-        if (p == -1) {
-            _ragdollPoints[i]._position = glm::vec3(0.0f);
+void SkeletonModel::updateMuscles() {
+    int numConstraints = _muscleConstraints.size();
+    for (int i = 0; i < numConstraints; ++i) {
+        MuscleConstraint* constraint = _muscleConstraints[i];
+        int j = constraint->getParentIndex();
+        if (j == -1) {
            continue;
        }
-        if (state.getDistanceToParent() < EPSILON) {
-            _ragdollPoints[i]._position = _ragdollPoints.at(p)._position;
+        int k = constraint->getChildIndex();
+        if (k == -1) {
            continue;
        }
-
-        glm::vec3 bone = _ragdollPoints.at(i)._lastPosition - _ragdollPoints.at(p)._lastPosition;
-        const JointState& parentState = _jointStates.at(p);
-        glm::vec3 targetBone = state.getPosition() - parentState.getPosition();
-
-        glm::vec3 newBone = (1.0f - fraction) * bone + fraction * targetBone;
-        float boneLength = glm::length(newBone);
-        if (boneLength > EPSILON) {
-            // slam newBone's length to that of the joint helps maintain distance constraints
-            newBone *= state.getDistanceToParent() / boneLength;
-        }
-        // set the new position relative to parent's new position
-        _ragdollPoints[i]._position = _ragdollPoints.at(p)._position + newBone;
+        constraint->setChildOffset(_jointStates.at(k).getPosition() - _jointStates.at(j).getPosition());
    }
 }

@ -738,8 +769,7 @@ void SkeletonModel::computeBoundingShape(const FBXGeometry& geometry) {
        int parentIndex = joint.parentIndex;
        if (parentIndex == -1) {
            transforms[i] = _jointStates[i].getTransform();
-            _ragdollPoints[i]._position = extractTranslation(transforms[i]);
-            _ragdollPoints[i]._lastPosition = _ragdollPoints[i]._position;
+            _ragdollPoints[i].initPosition(extractTranslation(transforms[i]));
            continue;
        }
        
@ -747,8 +777,7 @@ void SkeletonModel::computeBoundingShape(const FBXGeometry& geometry) {
        transforms[i] = transforms[parentIndex] * glm::translate(joint.translation) 
            * joint.preTransform * glm::mat4_cast(modifiedRotation) * joint.postTransform;
        // setting the ragdollPoints here slams the VerletShapes into their default positions
-        _ragdollPoints[i]._position = extractTranslation(transforms[i]);
-        _ragdollPoints[i]._lastPosition = _ragdollPoints[i]._position;
+        _ragdollPoints[i].initPosition(extractTranslation(transforms[i]));
    }

    // compute bounding box that encloses all shapes
--- a/interface/src/avatar/SkeletonModel.h
+++ b/interface/src/avatar/SkeletonModel.h
@ -18,6 +18,7 @@
 #include <Ragdoll.h>

 class Avatar;
+class MuscleConstraint;

 /// A skeleton loaded from a model.
 class SkeletonModel : public Model, public Ragdoll {
@ -100,6 +101,7 @@ public:
    virtual void stepRagdollForward(float deltaTime);

    void moveShapesTowardJoints(float fraction);
+    void updateMuscles();

    void computeBoundingShape(const FBXGeometry& geometry);
    void renderBoundingCollisionShapes(float alpha);
@ -144,6 +146,7 @@ private:

    CapsuleShape _boundingShape;
    glm::vec3 _boundingShapeLocalOffset;
+    QVector<MuscleConstraint*> _muscleConstraints;
 };

 #endif // hifi_SkeletonModel_h
--- a/interface/src/ui/ModelsBrowser.cpp
+++ b/interface/src/ui/ModelsBrowser.cpp
@ -182,7 +182,7 @@ ModelHandler::ModelHandler(ModelType modelsType, QWidget* parent) :
    QObject(parent),
    _initiateExit(false),
    _type(modelsType),
-    _nameFilter(".*(fst|fbx|FST|FBX)")
+    _nameFilter(".*fst")
 {
    // set headers data
    QStringList headerData;
@ -253,7 +253,6 @@ void ModelHandler::downloadFinished() {
        parseHeaders(reply);
    }
    reply->deleteLater();
-    sender()->deleteLater();
 }

 void ModelHandler::queryNewFiles(QString marker) {
--- a/libraries/octree/src/OctreeHeadlessViewer.cpp
+++ b/libraries/octree/src/OctreeHeadlessViewer.cpp
@ -22,7 +22,7 @@ OctreeHeadlessViewer::OctreeHeadlessViewer() :
    _viewFrustum.setFieldOfView(DEFAULT_FIELD_OF_VIEW_DEGREES);
    _viewFrustum.setAspectRatio(DEFAULT_ASPECT_RATIO);
    _viewFrustum.setNearClip(DEFAULT_NEAR_CLIP);
-    _viewFrustum.setFarClip(TREE_SCALE);
+    _viewFrustum.setFarClip(DEFAULT_FAR_CLIP);
 }

 OctreeHeadlessViewer::~OctreeHeadlessViewer() {
--- a/libraries/octree/src/ViewFrustum.cpp
+++ b/libraries/octree/src/ViewFrustum.cpp
@ -36,8 +36,8 @@ ViewFrustum::ViewFrustum() :
    _height(1.0f),
    _fieldOfView(0.0),
    _aspectRatio(1.0f),
-    _nearClip(0.1f),
-    _farClip(500.0f),
+    _nearClip(DEFAULT_NEAR_CLIP),
+    _farClip(DEFAULT_FAR_CLIP),
    _focalLength(0.25f),
    _keyholeRadius(DEFAULT_KEYHOLE_RADIUS),
    _farTopLeft(0,0,0),
--- a/libraries/octree/src/ViewFrustum.h
+++ b/libraries/octree/src/ViewFrustum.h
@ -28,7 +28,7 @@ const float DEFAULT_FIELD_OF_VIEW_DEGREES = 90.0f;
 const float DEFAULT_REAL_WORLD_FIELD_OF_VIEW_DEGREES = 30.f;
 const float DEFAULT_ASPECT_RATIO = 16.f/9.f;
 const float DEFAULT_NEAR_CLIP = 0.08f;
-const float DEFAULT_FAR_CLIP = 50.0f * TREE_SCALE;
+const float DEFAULT_FAR_CLIP = TREE_SCALE;

 class ViewFrustum {
 public:
--- a/libraries/shared/src/Constraint.h
+++ b/libraries/shared/src/Constraint.h
@ -0,0 +1,28 @@
+//
+//  Constraint.h
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_Constraint_h
+#define hifi_Constraint_h
+
+class Constraint {
+public:
+    Constraint() {}
+    virtual ~Constraint() {}
+
+    /// Enforce contraint by moving relevant points.
+    /// \return max distance of point movement
+    virtual float enforce() = 0;
+
+protected:
+    int _type;
+};
+
+#endif // hifi_Constraint_h
--- a/libraries/shared/src/DistanceConstraint.cpp
+++ b/libraries/shared/src/DistanceConstraint.cpp
@ -0,0 +1,43 @@
+//
+//  DistanceConstraint.cpp
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "DistanceConstraint.h"
+#include "SharedUtil.h" // for EPSILON
+#include "VerletPoint.h"
+
+DistanceConstraint::DistanceConstraint(VerletPoint* startPoint, VerletPoint* endPoint) : _distance(-1.0f) {
+    _points[0] = startPoint;
+    _points[1] = endPoint;
+    _distance = glm::distance(_points[0]->_position, _points[1]->_position);
+}
+
+DistanceConstraint::DistanceConstraint(const DistanceConstraint& other) {
+    _distance = other._distance;
+    _points[0] = other._points[0];
+    _points[1] = other._points[1];
+}
+
+void DistanceConstraint::setDistance(float distance) {
+    _distance = fabsf(distance);
+}
+
+float DistanceConstraint::enforce() {
+    // TODO: use a fast distance approximation
+    float newDistance = glm::distance(_points[0]->_position, _points[1]->_position);
+    glm::vec3 direction(0.0f, 1.0f, 0.0f);
+    if (newDistance > EPSILON) {
+        direction = (_points[0]->_position - _points[1]->_position) / newDistance;
+    }
+    glm::vec3 center = 0.5f * (_points[0]->_position + _points[1]->_position);
+    _points[0]->_position = center + (0.5f * _distance) * direction;
+    _points[1]->_position = center - (0.5f * _distance) * direction;
+    return glm::abs(newDistance - _distance);
+}
--- a/libraries/shared/src/DistanceConstraint.h
+++ b/libraries/shared/src/DistanceConstraint.h
@ -0,0 +1,31 @@
+//
+//  DistanceConstraint.h
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_DistanceConstraint_h
+#define hifi_DistanceConstraint_h
+
+#include "Constraint.h"
+
+class VerletPoint;
+
+class DistanceConstraint : public Constraint {
+public:
+    DistanceConstraint(VerletPoint* startPoint, VerletPoint* endPoint);
+    DistanceConstraint(const DistanceConstraint& other);
+    float enforce();
+    void setDistance(float distance);
+    float getDistance() const { return _distance; }
+private:
+    float _distance;
+    VerletPoint* _points[2];
+};
+
+#endif // hifi_DistanceConstraint_h
--- a/libraries/shared/src/FixedConstraint.cpp
+++ b/libraries/shared/src/FixedConstraint.cpp
@ -0,0 +1,35 @@
+//
+//  FixedConstraint.cpp
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "FixedConstraint.h"
+#include "Shape.h"  // for MAX_SHAPE_MASS
+#include "VerletPoint.h"
+
+FixedConstraint::FixedConstraint(VerletPoint* point, const glm::vec3& anchor) : _point(point), _anchor(anchor) {
+}
+
+float FixedConstraint::enforce() {
+    assert(_point != NULL);
+    // TODO: use fast approximate sqrt here
+    float distance = glm::distance(_anchor, _point->_position);
+    _point->_position = _anchor;
+    return distance;
+}
+
+void FixedConstraint::setPoint(VerletPoint* point) {
+    assert(point);
+    _point = point;
+    _point->_mass = MAX_SHAPE_MASS;
+}
+
+void FixedConstraint::setAnchor(const glm::vec3& anchor) {
+    _anchor = anchor;
+}
--- a/libraries/shared/src/FixedConstraint.h
+++ b/libraries/shared/src/FixedConstraint.h
@ -0,0 +1,32 @@
+//
+//  FixedConstraint.h
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_FixedConstraint_h
+#define hifi_FixedConstraint_h
+
+#include <glm/glm.hpp>
+
+#include "Constraint.h"
+
+class VerletPoint;
+
+class FixedConstraint : public Constraint {
+public:
+    FixedConstraint(VerletPoint* point, const glm::vec3& anchor);
+    float enforce();
+    void setPoint(VerletPoint* point);
+    void setAnchor(const glm::vec3& anchor);
+private:
+    VerletPoint* _point;
+    glm::vec3 _anchor;
+};
+
+#endif // hifi_FixedConstraint_h
--- a/libraries/shared/src/Ragdoll.cpp
+++ b/libraries/shared/src/Ragdoll.cpp
@ -11,86 +11,9 @@

 #include "Ragdoll.h"

-#include "CapsuleShape.h"
-#include "CollisionInfo.h"
-#include "SharedUtil.h"
-#include "SphereShape.h"
-
-// ----------------------------------------------------------------------------
-// VerletPoint
-// ----------------------------------------------------------------------------
-void VerletPoint::accumulateDelta(const glm::vec3& delta) {
-    _accumulatedDelta += delta;
-    ++_numDeltas;
-}
-
-void VerletPoint::applyAccumulatedDelta() {
-    if (_numDeltas > 0) { 
-        _position += _accumulatedDelta / (float)_numDeltas;
-        _accumulatedDelta = glm::vec3(0.0f);
-        _numDeltas = 0;
-    }
-}
-
-// ----------------------------------------------------------------------------
-// FixedConstraint
-// ----------------------------------------------------------------------------
-FixedConstraint::FixedConstraint(VerletPoint* point, const glm::vec3& anchor) : _point(point), _anchor(anchor) {
-}
-
-float FixedConstraint::enforce() {
-    assert(_point != NULL);
-    // TODO: use fast approximate sqrt here
-    float distance = glm::distance(_anchor, _point->_position);
-    _point->_position = _anchor;
-    return distance;
-}
-
-void FixedConstraint::setPoint(VerletPoint* point) {
-    assert(point);
-    _point = point;
-    _point->_mass = MAX_SHAPE_MASS;
-}
-
-void FixedConstraint::setAnchor(const glm::vec3& anchor) {
-    _anchor = anchor;
-}
-
-// ----------------------------------------------------------------------------
-// DistanceConstraint
-// ----------------------------------------------------------------------------
-DistanceConstraint::DistanceConstraint(VerletPoint* startPoint, VerletPoint* endPoint) : _distance(-1.0f) {
-    _points[0] = startPoint;
-    _points[1] = endPoint;
-    _distance = glm::distance(_points[0]->_position, _points[1]->_position);
-}
-
-DistanceConstraint::DistanceConstraint(const DistanceConstraint& other) {
-    _distance = other._distance;
-    _points[0] = other._points[0];
-    _points[1] = other._points[1];
-}
-
-void DistanceConstraint::setDistance(float distance) {
-    _distance = fabsf(distance);
-}
-
-float DistanceConstraint::enforce() {
-    // TODO: use a fast distance approximation
-    float newDistance = glm::distance(_points[0]->_position, _points[1]->_position);
-    glm::vec3 direction(0.0f, 1.0f, 0.0f);
-    if (newDistance > EPSILON) {
-        direction = (_points[0]->_position - _points[1]->_position) / newDistance;
-    }
-    glm::vec3 center = 0.5f * (_points[0]->_position + _points[1]->_position);
-    _points[0]->_position = center + (0.5f * _distance) * direction;
-    _points[1]->_position = center - (0.5f * _distance) * direction;
-    return glm::abs(newDistance - _distance);
-}
-
-// ----------------------------------------------------------------------------
-// Ragdoll
-// ----------------------------------------------------------------------------
+#include "Constraint.h"
+#include "DistanceConstraint.h"
+#include "FixedConstraint.h"

 Ragdoll::Ragdoll() {
 }
@ -98,6 +21,13 @@ Ragdoll::Ragdoll() {
 Ragdoll::~Ragdoll() {
    clearRagdollConstraintsAndPoints();
 }
+
+void Ragdoll::stepRagdollForward(float deltaTime) {
+    int numPoints = _ragdollPoints.size();
+    for (int i = 0; i < numPoints; ++i) {
+        _ragdollPoints[i].integrateForward();
+    }
+}
    
 void Ragdoll::clearRagdollConstraintsAndPoints() {
    int numConstraints = _ragdollConstraints.size();
@ -118,4 +48,3 @@ float Ragdoll::enforceRagdollConstraints() {
    }
    return maxDistance;
 }
-
--- a/libraries/shared/src/Ragdoll.h
+++ b/libraries/shared/src/Ragdoll.h
@ -14,67 +14,11 @@

 #include <glm/glm.hpp>
 #include <glm/gtx/quaternion.hpp>
+#include "VerletPoint.h"

 #include <QVector>

-class Shape;
-
-// TODO: Andrew to move VerletPoint class to its own file
-class VerletPoint {
-public:
-    VerletPoint() : _position(0.0f), _lastPosition(0.0f), _mass(1.0f), _accumulatedDelta(0.0f), _numDeltas(0) {}
-
-    void accumulateDelta(const glm::vec3& delta);
-    void applyAccumulatedDelta();
-
-    glm::vec3 getAccumulatedDelta() const { 
-        return (_numDeltas > 0) ?  _accumulatedDelta / (float)_numDeltas : glm::vec3(0.0f);
-    }
-
-    glm::vec3 _position;
-    glm::vec3 _lastPosition;
-    float _mass;
-
-private:
-    glm::vec3 _accumulatedDelta;
-    int _numDeltas;
-};
-
-class Constraint {
-public:
-    Constraint() {}
-    virtual ~Constraint() {}
-
-    /// Enforce contraint by moving relevant points.
-    /// \return max distance of point movement
-    virtual float enforce() = 0;
-
-protected:
-    int _type;
-};
-
-class FixedConstraint : public Constraint {
-public:
-    FixedConstraint(VerletPoint* point, const glm::vec3& anchor);
-    float enforce();
-    void setPoint(VerletPoint* point);
-    void setAnchor(const glm::vec3& anchor);
-private:
-    VerletPoint* _point;
-    glm::vec3 _anchor;
-};
-
-class DistanceConstraint : public Constraint {
-public:
-    DistanceConstraint(VerletPoint* startPoint, VerletPoint* endPoint);
-    DistanceConstraint(const DistanceConstraint& other);
-    float enforce();
-    void setDistance(float distance);
-    float getDistance() const { return _distance; }
-private:
-    float _distance;
-    VerletPoint* _points[2];
-};
+class Constraint;

 class Ragdoll {
 public:
@ -82,7 +26,7 @@ public:
    Ragdoll();
    virtual ~Ragdoll();

-    virtual void stepRagdollForward(float deltaTime) = 0;
+    virtual void stepRagdollForward(float deltaTime);

    /// \return max distance of point movement
    float enforceRagdollConstraints();
--- a/libraries/shared/src/VerletPoint.cpp
+++ b/libraries/shared/src/VerletPoint.cpp
@ -0,0 +1,31 @@
+//
+//  VerletPoint.cpp
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "VerletPoint.h"
+
+void VerletPoint::integrateForward() {
+    glm::vec3 oldPosition = _position;
+    _position += 0.6f * (_position - _lastPosition);
+    _lastPosition = oldPosition;
+}
+
+void VerletPoint::accumulateDelta(const glm::vec3& delta) {
+    _accumulatedDelta += delta;
+    ++_numDeltas;
+}
+
+void VerletPoint::applyAccumulatedDelta() {
+    if (_numDeltas > 0) { 
+        _position += _accumulatedDelta / (float)_numDeltas;
+        _accumulatedDelta = glm::vec3(0.0f);
+        _numDeltas = 0;
+    }
+}
--- a/libraries/shared/src/VerletPoint.h
+++ b/libraries/shared/src/VerletPoint.h
@ -0,0 +1,39 @@
+//
+//  VerletPoint.h
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_VerletPoint_h
+#define hifi_VerletPoint_h
+
+#include <glm/glm.hpp>
+
+class VerletPoint {
+public:
+    VerletPoint() : _position(0.0f), _lastPosition(0.0f), _mass(1.0f), _accumulatedDelta(0.0f), _numDeltas(0) {}
+
+    void initPosition(const glm::vec3& position) { _position = position; _lastPosition = position; }
+    void integrateForward();
+    void accumulateDelta(const glm::vec3& delta);
+    void applyAccumulatedDelta();
+
+    glm::vec3 getAccumulatedDelta() const { 
+        return (_numDeltas > 0) ?  _accumulatedDelta / (float)_numDeltas : glm::vec3(0.0f);
+    }
+
+    glm::vec3 _position;
+    glm::vec3 _lastPosition;
+    float _mass;
+
+private:
+    glm::vec3 _accumulatedDelta;
+    int _numDeltas;
+};
+
+#endif // hifi_VerletPoint_h