krisyotam/overte

CMakeLists.txt+1−1

@@ -49,7 +49,7 @@ if (WIN32) · 48 unmodified lines
49	else ()	49	else ()
50	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -fno-strict-aliasing -Wno-unused-parameter")	50	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -fno-strict-aliasing -Wno-unused-parameter")
51	if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)	51	if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
52	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb")	52	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb -Woverloaded-virtual -Wdouble-promotion")
53	endif ()	53	endif ()
54	endif(WIN32)	54	endif(WIN32)
55		55

assignment-client/src/audio/AudioMixerClientData.cpp+4−4

@@ -295,10 +295,10 @@ void AudioMixerClientData::printUpstreamDownstreamStats() const { · 294 unmodified lines
295		295
296	void AudioMixerClientData::printAudioStreamStats(const AudioStreamStats& streamStats) const {	296	void AudioMixerClientData::printAudioStreamStats(const AudioStreamStats& streamStats) const {
297	printf(" Packet loss \| overall: %5.2f%% (%d lost), last_30s: %5.2f%% (%d lost)\n",	297	printf(" Packet loss \| overall: %5.2f%% (%d lost), last_30s: %5.2f%% (%d lost)\n",
298	streamStats._packetStreamStats.getLostRate() * 100.0f,	298	(double)(streamStats._packetStreamStats.getLostRate() * 100.0f),
299	streamStats._packetStreamStats._lost,	299	streamStats._packetStreamStats._lost,
300	streamStats._packetStreamWindowStats.getLostRate() * 100.0f,	300	(double)(streamStats._packetStreamWindowStats.getLostRate() * 100.0f),
301	streamStats._packetStreamWindowStats._lost);	301	streamStats._packetStreamWindowStats._lost);
302		302
303	printf(" Ringbuffer frames \| desired: %u, avg_available(10s): %u, available: %u\n",	303	printf(" Ringbuffer frames \| desired: %u, avg_available(10s): %u, available: %u\n",
304	streamStats._desiredJitterBufferFrames,	304	streamStats._desiredJitterBufferFrames,

assignment-client/src/octree/OctreeServer.cpp+135−130

cmake/externals/LibOVR/CMakeLists.txt+7−3

   ExternalProject_Add(
     ${EXTERNAL_NAME}
-    URL http://static.oculus.com/sdk-downloads/ovr_sdk_win_0.5.0.1.zip
+    URL http://static.oculus.com/sdk-downloads/0.6.0.0/1431634088/ovr_sdk_win_0.6.0.0.zip
-    URL_MD5 d3fc4c02db9be5ff08af4ef4c97b32f9
+    URL_MD5 a3dfdab037a854fdcf7e6033fa8d7028
     CONFIGURE_COMMAND ""
     BUILD_COMMAND ""
     INSTALL_COMMAND ""
   # FIXME need to account for different architectures
   set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS ${SOURCE_DIR}/LibOVR/Include CACHE TYPE INTERNAL)
-  set(${EXTERNAL_NAME_UPPER}_LIBRARIES ${SOURCE_DIR}/LibOVR/Lib/Windows/Win32/Release/VS2013/LibOVR.lib CACHE TYPE INTERNAL)
+  if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+    set(${EXTERNAL_NAME_UPPER}_LIBRARIES ${SOURCE_DIR}/LibOVR/Lib/Windows/x64/Release/VS2013/LibOVR.lib CACHE TYPE INTERNAL)
+  else()
+    set(${EXTERNAL_NAME_UPPER}_LIBRARIES ${SOURCE_DIR}/LibOVR/Lib/Windows/Win32/Release/VS2013/LibOVR.lib CACHE TYPE INTERNAL)
+  endif()
 elseif(APPLE)

cmake/externals/boostconfig/CMakeLists.txt+7−7

@@ -3,13 +3,13 @@ string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER) · 2 unmodified lines
3		3
4	include(ExternalProject)	4	include(ExternalProject)
5	ExternalProject_Add(	5	ExternalProject_Add(
6	${EXTERNAL_NAME}	6	${EXTERNAL_NAME}
7	URL https://github.com/boostorg/config/archive/boost-1.58.0.zip	7	URL https://github.com/boostorg/config/archive/boost-1.58.0.zip
8	URL_MD5 42fa673bae2b7645a22736445e80eb8d	8	URL_MD5 42fa673bae2b7645a22736445e80eb8d
9	CONFIGURE_COMMAND ""	9	CONFIGURE_COMMAND ""
10	BUILD_COMMAND ""	10	BUILD_COMMAND ""
11	INSTALL_COMMAND ""	11	INSTALL_COMMAND ""
12	LOG_DOWNLOAD 1	12	LOG_DOWNLOAD 1
13	)	13	)
14		14
15	ExternalProject_Get_Property(${EXTERNAL_NAME} SOURCE_DIR)	15	ExternalProject_Get_Property(${EXTERNAL_NAME} SOURCE_DIR)

cmake/externals/glew/CMakeLists.txt+10−5

@@ -16,11 +16,16 @@ if (WIN32) · 15 unmodified lines
16		16
17	string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)	17	string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)
18	set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS ${SOURCE_DIR}/include CACHE PATH "List of glew include directories")	18	set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS ${SOURCE_DIR}/include CACHE PATH "List of glew include directories")
19		19
20	set(_LIB_DIR ${SOURCE_DIR}/lib/Release/Win32)	20	if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
21		21	set(_LIB_DIR ${SOURCE_DIR}/lib/Release/x64)
		22	set(${EXTERNAL_NAME_UPPER}_DLL_PATH ${SOURCE_DIR}/bin/Release/x64 CACHE FILEPATH "Location of GLEW DLL")
		23	else()
		24	set(_LIB_DIR ${SOURCE_DIR}/lib/Release/Win32)
		25	set(${EXTERNAL_NAME_UPPER}_DLL_PATH ${SOURCE_DIR}/bin/Release/Win32 CACHE FILEPATH "Location of GLEW DLL")
		26	endif()
		27
22	set(${EXTERNAL_NAME_UPPER}_LIBRARY_RELEASE ${_LIB_DIR}/glew32.lib CACHE FILEPATH "Location of GLEW release library")	28	set(${EXTERNAL_NAME_UPPER}_LIBRARY_RELEASE ${_LIB_DIR}/glew32.lib CACHE FILEPATH "Location of GLEW release library")
23	set(${EXTERNAL_NAME_UPPER}_LIBRARY_DEBUG "" CACHE FILEPATH "Location of GLEW debug library")	29	set(${EXTERNAL_NAME_UPPER}_LIBRARY_DEBUG "" CACHE FILEPATH "Location of GLEW debug library")
24		30
25	set(${EXTERNAL_NAME_UPPER}_DLL_PATH ${SOURCE_DIR}/bin/Release/Win32 CACHE FILEPATH "Location of GLEW DLL")
26	endif ()	31	endif ()

cmake/externals/oglplus/CMakeLists.txt+7−7

@@ -3,13 +3,13 @@ string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER) · 2 unmodified lines
3		3
4	include(ExternalProject)	4	include(ExternalProject)
5	ExternalProject_Add(	5	ExternalProject_Add(
6	${EXTERNAL_NAME}	6	${EXTERNAL_NAME}
7	URL http://softlayer-dal.dl.sourceforge.net/project/oglplus/oglplus-0.61.x/oglplus-0.61.0.zip	7	GIT_REPOSITORY https://github.com/matus-chochlik/oglplus.git
8	URL_MD5 bb55038c36c660d2b6c7be380414fa60	8	GIT_TAG a2681383928b1166f176512cbe0f95e96fe68d08
9	CONFIGURE_COMMAND ""	9	CONFIGURE_COMMAND ""
10	BUILD_COMMAND ""	10	BUILD_COMMAND ""
11	INSTALL_COMMAND ""	11	INSTALL_COMMAND ""
12	LOG_DOWNLOAD 1	12	LOG_DOWNLOAD 1
13	)	13	)
14		14
15	ExternalProject_Get_Property(${EXTERNAL_NAME} SOURCE_DIR)	15	ExternalProject_Get_Property(${EXTERNAL_NAME} SOURCE_DIR)

cmake/externals/tbb/CMakeLists.txt+7−2

   )
 elseif (WIN32)
-  set(_TBB_LIB_DIR "${SOURCE_DIR}/lib/ia32/vc12")
+  if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+    set(_TBB_LIB_DIR "${SOURCE_DIR}/lib/intel64/vc12")
+    set(${EXTERNAL_NAME_UPPER}_DLL_PATH "${SOURCE_DIR}/bin/intel64/vc12" CACHE PATH "Path to TBB DLLs")
+  else()
+    set(_TBB_LIB_DIR "${SOURCE_DIR}/lib/ia32/vc12")
+    set(${EXTERNAL_NAME_UPPER}_DLL_PATH "${SOURCE_DIR}/bin/ia32/vc12" CACHE PATH "Path to TBB DLLs")
+  endif()
   set(_LIB_EXT "lib")
-  set(${EXTERNAL_NAME_UPPER}_DLL_PATH "${SOURCE_DIR}/bin/ia32/vc12" CACHE PATH "Path to TBB DLLs")
 elseif (ANDROID)
   set(_TBB_LIB_DIR "${SOURCE_DIR}/lib")
   set(_LIB_PREFIX "lib")

cmake/macros/SetupHifiOpenGL.cmake+43−0

@@ -0,0 +1,43 @@
	1
	2
	3	macro(SETUP_HIFI_OPENGL)
	4
	5	if (APPLE)
	6
	7	# link in required OS X frameworks and include the right GL headers
	8	find_library(OpenGL OpenGL)
	9	target_link_libraries(${TARGET_NAME} ${OpenGL})
	10
	11	elseif (WIN32)
	12
	13	add_dependency_external_projects(glew)
	14	find_package(GLEW REQUIRED)
	15	target_include_directories(${TARGET_NAME} PUBLIC ${GLEW_INCLUDE_DIRS})
	16	target_link_libraries(${TARGET_NAME} ${GLEW_LIBRARIES} opengl32.lib)
	17
	18	if (USE_NSIGHT)
	19	# try to find the Nsight package and add it to the build if we find it
	20	find_package(NSIGHT)
	21	if (NSIGHT_FOUND)
	22	include_directories(${NSIGHT_INCLUDE_DIRS})
	23	add_definitions(-DNSIGHT_FOUND)
	24	target_link_libraries(${TARGET_NAME} "${NSIGHT_LIBRARIES}")
	25	endif()
	26	endif()
	27
	28	elseif(ANDROID)
	29
	30	target_link_libraries(${TARGET_NAME} "-lGLESv3" "-lEGL")
	31
	32	else()
	33
	34	find_package(OpenGL REQUIRED)
	35	if (${OPENGL_INCLUDE_DIR})
	36	include_directories(SYSTEM "${OPENGL_INCLUDE_DIR}")
	37	endif()
	38	target_link_libraries(${TARGET_NAME} "${OPENGL_LIBRARY}")
	39	target_include_directories(${TARGET_NAME} PUBLIC ${OPENGL_INCLUDE_DIR})
	40
	41	endif()
	42
	43	endmacro()

cmake/modules/FindFaceshift.cmake+5−1

 elseif (UNIX)
   set(ARCH_DIR "UNIX")
 elseif (WIN32)
-  set(ARCH_DIR "Win32")
+  if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+    set(ARCH_DIR "x64")
+  else()
+    set(ARCH_DIR "Win32")
+  endif()
 endif ()
 find_library(FACESHIFT_LIBRARY_RELEASE NAME faceshift PATH_SUFFIXES lib/${ARCH_DIR} HINTS ${FACESHIFT_SEARCH_DIRS})

cmake/modules/FindNSIGHT.cmake+16−6

 #
 if (WIN32)
+    if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+        set(ARCH_DIR "x64")
+        set(ARCH_NAME "64")
+    else()
+        set(ARCH_DIR "Win32")
+        set(ARCH_NAME "32")
+    endif()
 	find_path(NSIGHT_INCLUDE_DIRS
 		NAMES
 			nvToolsExt.h
 		PATHS
 		 	"C:/Program Files/NVIDIA Corporation/NvToolsExt")
-	find_library(NSIGHT_LIBRARY_RELEASE nvToolsExt32_1
+	find_library(NSIGHT_LIBRARY_RELEASE "nvToolsExt${ARCH_NAME}_1"
 	 	PATH_SUFFIXES
-	 		"lib/Win32" "lib"
+	 		"lib/${ARCH_DIR}" "lib"
 	 	PATHS
 	 		"C:/Program Files/NVIDIA Corporation/NvToolsExt")
-	find_library(NSIGHT_LIBRARY_DEBUG nvToolsExt32_1
+	find_library(NSIGHT_LIBRARY_DEBUG "nvToolsExt${ARCH_NAME}_1"
 	 	PATH_SUFFIXES
-	 		"lib/Win32" "lib"
+	 		"lib/${ARCH_DIR}" "lib"
 	 	PATHS
 	 		"C:/Program Files/NVIDIA Corporation/NvToolsExt")
+  add_paths_to_fixup_libs("C:/Program Files/NVIDIA Corporation/NvToolsExt/bin/${ARCH_DIR}")
   include(SelectLibraryConfigurations)
   select_library_configurations(NSIGHT)
 endif ()

cmake/modules/FindSixense.cmake+13−5

   find_library(SIXENSE_LIBRARY_RELEASE lib/linux_x64/release/libsixense_x64.so HINTS ${SIXENSE_SEARCH_DIRS})
   # find_library(SIXENSE_LIBRARY_DEBUG lib/linux_x64/debug/libsixensed_x64.so HINTS ${SIXENSE_SEARCH_DIRS})
 elseif (WIN32)
-  find_library(SIXENSE_LIBRARY_RELEASE lib/win32/release_dll/sixense.lib HINTS ${SIXENSE_SEARCH_DIRS})
+    if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-  find_library(SIXENSE_LIBRARY_DEBUG lib/win32/debug_dll/sixensed.lib HINTS ${SIXENSE_SEARCH_DIRS})
+        set(ARCH_DIR "x64")
+        set(ARCH_SUFFIX "_x64")
+    else()
+        set(ARCH_DIR "Win32")
+        set(ARCH_SUFFIX "")
+    endif()
+  find_library(SIXENSE_LIBRARY_RELEASE "lib/${ARCH_DIR}/release_dll/sixense${ARCH_SUFFIX}.lib" HINTS ${SIXENSE_SEARCH_DIRS})
+  find_library(SIXENSE_LIBRARY_DEBUG "lib/${ARCH_DIR}/debug_dll/sixensed.lib" HINTS ${SIXENSE_SEARCH_DIRS})
-  find_path(SIXENSE_DEBUG_DLL_PATH sixensed.dll PATH_SUFFIXES bin/win32/debug_dll HINTS ${SIXENSE_SEARCH_DIRS})
+  find_path(SIXENSE_DEBUG_DLL_PATH "sixensed${ARCH_SUFFIX}.dll" PATH_SUFFIXES bin/${ARCH_DIR}/debug_dll HINTS ${SIXENSE_SEARCH_DIRS})
-  find_path(SIXENSE_RELEASE_DLL_PATH sixense.dll PATH_SUFFIXES bin/win32/release_dll HINTS ${SIXENSE_SEARCH_DIRS})
+  find_path(SIXENSE_RELEASE_DLL_PATH "sixense${ARCH_SUFFIX}.dll" PATH_SUFFIXES bin/${ARCH_DIR}/release_dll HINTS ${SIXENSE_SEARCH_DIRS})
-  find_path(SIXENSE_DEVICE_DLL_PATH DeviceDLL.dll PATH_SUFFIXES samples/win32/sixense_simple3d HINTS ${SIXENSE_SEARCH_DIRS})
+  find_path(SIXENSE_DEVICE_DLL_PATH DeviceDLL.dll PATH_SUFFIXES samples/${ARCH_DIR}/sixense_simple3d HINTS ${SIXENSE_SEARCH_DIRS})
 endif ()
 include(SelectLibraryConfigurations)

cmake/modules/FindTBB.cmake+1−1

@@ -49,7 +49,7 @@ elseif (UNIX AND NOT ANDROID) · 48 unmodified lines
49	endif ()	49	endif ()
50		50
51	elseif (WIN32)	51	elseif (WIN32)
52	if (CMAKE_CL_64)	52	if(CMAKE_SIZEOF_VOID_P EQUAL 8)
53	set(_TBB_ARCH_DIR "intel64")	53	set(_TBB_ARCH_DIR "intel64")
54	else()	54	else()
55	set(_TBB_ARCH_DIR "ia32")	55	set(_TBB_ARCH_DIR "ia32")

examples/controllers/hydra/gun.js+7−9

 var screenSize = Controller.getViewportDimensions();
 var startX = screenSize.x / 2 - (NUM_BUTTONS * (BUTTON_SIZE + PADDING)) / 2;
 Script.include(["../../libraries/toolBars.js"]);
-const persistKey = "highfidelity.gun.toolbar.position";
+var toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL, "highfidelity.gun.toolbar", function (screenSize) {
-var toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL);
+    return {
-toolBar.save = function () {
+        x: startX,
-    Settings.setValue(persistKey, JSON.stringify([toolBar.x, toolBar.y]));
+        y: (screenSize.y - (BUTTON_SIZE + PADDING)),
-};
+    };
-var old = JSON.parse(Settings.getValue(persistKey) || '0');
+});
 var reticle = Overlays.addOverlay("image", {
                     x: screenSize.x / 2 - (BUTTON_SIZE / 2),
                     y: screenSize.y / 2 - (BUTTON_SIZE / 2),
                 });
 var offButton = toolBar.addOverlay("image", {
-                    x: old ? old[0] : startX,
-                    y: old ? old[1] : (screenSize.y - (BUTTON_SIZE + PADDING)),
                     width: BUTTON_SIZE,
                     height: BUTTON_SIZE,
                     imageURL: HIFI_PUBLIC_BUCKET + "images/gun/close.svg",
 }
 function shootBullet(position, velocity, grenade) {
-    var BULLET_SIZE = 0.10;
+    var BULLET_SIZE = .09;
     var BULLET_LIFETIME = 10.0;
     var BULLET_GRAVITY = -0.25;
     var GRENADE_VELOCITY = 15.0;

examples/defaultScripts.js+0−1

@@ -16,7 +16,6 @@ Script.load("lobby.js"); · 15 unmodified lines
16	Script.load("notifications.js");	16	Script.load("notifications.js");
17	Script.load("users.js");	17	Script.load("users.js");
18	Script.load("grab.js");	18	Script.load("grab.js");
19	Script.load("pointer.js");
20	Script.load("directory.js");	19	Script.load("directory.js");
21	Script.load("mouseLook.js");	20	Script.load("mouseLook.js");
22	Script.load("hmdControls.js");	21	Script.load("hmdControls.js");

examples/dice.js+6−8

@@ -33,15 +33,13 @@ var BUTTON_SIZE = 32; · 32 unmodified lines
33	var PADDING = 3;	33	var PADDING = 3;
34		34
35	Script.include(["libraries/toolBars.js"]);	35	Script.include(["libraries/toolBars.js"]);
36	var toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL);	36	var toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL, "highfidelity.dice.toolbar", function (screenSize) {
37	const persistKey = "highfidelity.dice.toolbar.position";	37	return {
38	toolBar.save = function () {	38	x: (screenSize.x / 2 - BUTTON_SIZE * 2 + PADDING),
39	Settings.setValue(persistKey, JSON.stringify([toolBar.x, toolBar.y]));	39	y: (screenSize.y - (BUTTON_SIZE + PADDING))
40	};	40	};
41	var old = JSON.parse(Settings.getValue(persistKey) \|\| '0');	41	});
42	var offButton = toolBar.addOverlay("image", {	42	var offButton = toolBar.addOverlay("image", {
43	x: old ? old[0] : (screenSize.x / 2 - BUTTON_SIZE * 2 + PADDING),
44	y: old ? old[1] : (screenSize.y - (BUTTON_SIZE + PADDING)),
45	width: BUTTON_SIZE,	43	width: BUTTON_SIZE,
46	height: BUTTON_SIZE,	44	height: BUTTON_SIZE,
47	imageURL: HIFI_PUBLIC_BUCKET + "images/close.png",	45	imageURL: HIFI_PUBLIC_BUCKET + "images/close.png",

examples/edit.js+7−35

     lightOverlayManager.updatePositions();
 });
-var windowDimensions = Controller.getViewportDimensions();
 var toolIconUrl = HIFI_PUBLIC_BUCKET + "images/tools/";
 var toolHeight = 50;
 var toolWidth = 50;
         browseMarketplaceButton;
     function initialize() {
-        toolBar = new ToolBar(0, 0, ToolBar.VERTICAL);
+        toolBar = new ToolBar(0, 0, ToolBar.VERTICAL, "highfidelity.edit.toolbar", function (windowDimensions, toolbar) {
+            return {
+                x: windowDimensions.x - 8 - toolbar.width,
+                y: (windowDimensions.y - toolbar.height) / 2
+            };
+        });
         browseMarketplaceButton = toolBar.addTool({
             imageURL: toolIconUrl + "marketplace.svg",
         }
     }
-    const persistKey = "highfidelity.edit.toolbar.position";
-    that.move = function () {
-        var newViewPort,
-            toolsX,
-            toolsY;
-        newViewPort = Controller.getViewportDimensions();
-        if (toolBar === undefined) {
-            initialize();
-            toolBar.save = function () {
-                Settings.setValue(persistKey, JSON.stringify([toolBar.x, toolBar.y]));
-            };
-            var old = JSON.parse(Settings.getValue(persistKey) || '0');
-            if (old) {
-                windowDimensions = newViewPort;
-                toolBar.move(old[0], old[1]);
-                return;
-            }
-        } else if (windowDimensions.x === newViewPort.x &&
-                   windowDimensions.y === newViewPort.y) {
-            return;
-        }
-        windowDimensions = newViewPort;
-        toolsX = windowDimensions.x - 8 - toolBar.width;
-        toolsY = (windowDimensions.y - toolBar.height) / 2;
-        toolBar.move(toolsX, toolsY);
-    };
     var newModelButtonDown = false;
     var browseMarketplaceButtonDown = false;
     that.mousePressEvent = function (event) {
         toolBar.cleanup();
     };
+    initialize();
     return that;
 }());
 // Do some stuff regularly, like check for placement of various overlays
 Script.update.connect(function (deltaTime) {
-    toolBar.move();
     progressDialog.move();
     selectionDisplay.checkMove();
     var dOrientation = Math.abs(Quat.dot(Camera.orientation, lastOrientation) - 1);

examples/html/style.css+12−14

@@ -8,7 +8,7 @@ body { · 7 unmodified lines
8	background-color: rgb(76, 76, 76);	8	background-color: rgb(76, 76, 76);
9	color: rgb(204, 204, 204);	9	color: rgb(204, 204, 204);
10	font-family: Arial;	10	font-family: Arial;
11	font-size: 8.25pt;	11	font-size: 9.0pt;
12		12
13	-webkit-touch-callout: none;	13	-webkit-touch-callout: none;
14	-webkit-user-select: none;	14	-webkit-user-select: none;
@@ -58,6 +58,7 @@ body { · 43 unmodified lines
58		58
59	.multi-property-section {	59	.multi-property-section {
60	}	60	}
		61
61	.property-section {	62	.property-section {
62	display: block;	63	display: block;
63	margin: 10 10;	64	margin: 10 10;
@@ -132,7 +133,7 @@ input.no-spin::-webkit-inner-spin-button { · 68 unmodified lines
132	table#entity-table {	133	table#entity-table {
133	border-collapse: collapse;	134	border-collapse: collapse;
134	font-family: Sans-Serif;	135	font-family: Sans-Serif;
135	font-size: 7.5pt;	136	font-size: 9pt;
136	width: 100%;	137	width: 100%;
137	}	138	}
138		139
@@ -156,7 +157,7 @@ table#entity-table { · 17 unmodified lines
156	}	157	}
157		158
158	#entity-table td {	159	#entity-table td {
159	font-size: 8.25pt;	160	font-size: 9.0pt;
160	border: 0pt black solid;	161	border: 0pt black solid;
161	word-wrap: nowrap;	162	word-wrap: nowrap;
162	white-space: nowrap;	163	white-space: nowrap;
@@ -176,14 +177,14 @@ th#entity-type { · 13 unmodified lines
176		177
177	div.input-area {	178	div.input-area {
178	display: inline-block;	179	display: inline-block;
179	font-size: 7.5pt;	180	font-size: 9pt;
180	}	181	}
181		182
182	input {	183	input {
183	}	184	}
184		185
185	#type {	186	#type {
186	font-size: 10.5pt;	187	font-size: 9.0pt;
187	}	188	}
188		189
189	#type label {	190	#type label {
@@ -191,14 +192,14 @@ input { · 1 unmodified line
191	}	192	}
192		193
193	input, textarea {	194	input, textarea {
194	background-color: rgb(102, 102, 102);	195	background-color: rgb(63, 63, 63);
195	color: rgb(204, 204, 204);	196	color: rgb(255, 255, 255);
196	border: none;	197	border: none;
197	font-size: 7.5pt;	198	font-size: 9pt;
198	}	199	}
199		200
200	input:disabled, textarea:disabled {	201	input:disabled, textarea:disabled {
201	background-color: rgb(102, 102, 102);	202	background-color: rgb(63, 63, 63);
202	color: rgb(160, 160, 160);	203	color: rgb(160, 160, 160);
203	}	204	}
204		205
@@ -224,7 +225,7 @@ input:disabled, textarea:disabled { · 19 unmodified lines
224	#properties-list .property {	225	#properties-list .property {
225	padding: 4pt;	226	padding: 4pt;
226	border-bottom: 0.75pt solid rgb(63, 63, 63);	227	border-bottom: 0.75pt solid rgb(63, 63, 63);
227	min-height: 1em;	228	min-height: 12pt;
228	}	229	}
229		230
230		231
@@ -245,7 +246,6 @@ table#properties-list { · 14 unmodified lines
245	font-weight: bold;	246	font-weight: bold;
246	overflow: hidden;	247	overflow: hidden;
247	text-overflow: ellipsis;	248	text-overflow: ellipsis;
248
249	vertical-align: middle;	249	vertical-align: middle;
250	height: 1.2em;	250	height: 1.2em;
251	}	251	}
@@ -270,9 +270,7 @@ div.inner { · 18 unmodified lines
270	}	270	}
271		271
272	td {	272	td {
273		273	vertical-align: top;
274
275	vertical-align: top;
276	}	274	}
277		275
278	#no-entities {	276	#no-entities {

examples/libraries/toolBars.js+47−6

@@ -126,7 +126,7 @@ Tool.prototype = new Overlay2D; · 125 unmodified lines
126	Tool.IMAGE_HEIGHT = 50;	126	Tool.IMAGE_HEIGHT = 50;
127	Tool.IMAGE_WIDTH = 50;	127	Tool.IMAGE_WIDTH = 50;
128		128
129	ToolBar = function(x, y, direction) {	129	ToolBar = function(x, y, direction, optionalPersistenceKey, optionalInitialPositionFunction) {
130	this.tools = new Array();	130	this.tools = new Array();
131	this.x = x;	131	this.x = x;
132	this.y = y;	132	this.y = y;
@@ -336,7 +336,7 @@ ToolBar = function(x, y, direction) { · 203 unmodified lines
336	return (that.x <= x) && (x <= (that.x + that.width)) &&	336	return (that.x <= x) && (x <= (that.x + that.width)) &&
337	(that.y <= y) && (y <= (that.y + that.height));	337	(that.y <= y) && (y <= (that.y + that.height));
338	}	338	}
339	that.hover = function (enable) {	339	that.hover = function (enable) { // Can be overriden or extended by clients.
340	that.isHovering = enable;	340	that.isHovering = enable;
341	if (that.back) {	341	if (that.back) {
342	if (enable) {	342	if (enable) {
@@ -348,6 +348,26 @@ ToolBar = function(x, y, direction) { · 5 unmodified lines
348	});	348	});
349	}	349	}
350	};	350	};
		351	that.windowDimensions = Controller.getViewportDimensions();
		352	// Maybe fixme: Keeping the same percent of the window size isn't always the right thing.
		353	// For example, maybe we want "keep the same percentage to whatever two edges are closest to the edge of screen".
		354	// If we change that, the places to do so are onResizeViewport, save (maybe), and the initial move based on Settings, below.
		355	that.onResizeViewport = function (newSize) { // Can be overridden or extended by clients.
		356	var fractionX = that.x / that.windowDimensions.x;
		357	var fractionY = that.y / that.windowDimensions.y;
		358	that.windowDimensions = newSize \|\| Controller.getViewportDimensions();
		359	that.move(fractionX * that.windowDimensions.x, fractionY * that.windowDimensions.y);
		360	};
		361	if (optionalPersistenceKey) {
		362	this.fractionKey = optionalPersistenceKey + '.fraction';
		363	this.save = function () {
		364	var screenSize = Controller.getViewportDimensions();
		365	var fraction = {x: that.x / screenSize.x, y: that.y / screenSize.y};
		366	Settings.setValue(this.fractionKey, JSON.stringify(fraction));
		367	}
		368	} else {
		369	this.save = function () { }; // Called on move. Can be overriden or extended by clients.
		370	}
351	// These are currently only doing that which is necessary for toolbar hover and toolbar drag.	371	// These are currently only doing that which is necessary for toolbar hover and toolbar drag.
352	// They have not yet been extended to tool hover/click/release, etc.	372	// They have not yet been extended to tool hover/click/release, etc.
353	this.mousePressEvent = function (event) {	373	this.mousePressEvent = function (event) {
@@ -375,15 +395,19 @@ ToolBar = function(x, y, direction) { · 21 unmodified lines
375	}	395	}
376	that.move(that.dragOffsetX + event.x, that.dragOffsetY + event.y);	396	that.move(that.dragOffsetX + event.x, that.dragOffsetY + event.y);
377	};	397	};
		398	that.checkResize = function () { // Can be overriden or extended, but usually not. See onResizeViewport.
		399	var currentWindowSize = Controller.getViewportDimensions();
		400	if ((currentWindowSize.x !== that.windowDimensions.x) \|\| (currentWindowSize.y !== that.windowDimensions.y)) {
		401	that.onResizeViewport(currentWindowSize);
		402	}
		403	};
378	Controller.mousePressEvent.connect(this.mousePressEvent);	404	Controller.mousePressEvent.connect(this.mousePressEvent);
379	Controller.mouseMoveEvent.connect(this.mouseMove);	405	Controller.mouseMoveEvent.connect(this.mouseMove);
380	// Called on move. A different approach would be to have all this on the prototype,	406	Script.update.connect(that.checkResize);
381	// and let apps extend where needed. Ex. app defines its toolbar.move() to call this.__proto__.move and then save.
382	this.save = function () { };
383	// This compatability hack breaks the model, but makes converting existing scripts easier:	407	// This compatability hack breaks the model, but makes converting existing scripts easier:
384	this.addOverlay = function (ignored, oldSchoolProperties) {	408	this.addOverlay = function (ignored, oldSchoolProperties) {
385	var properties = JSON.parse(JSON.stringify(oldSchoolProperties)); // a copy	409	var properties = JSON.parse(JSON.stringify(oldSchoolProperties)); // a copy
386	if (that.numberOfTools() === 0) {	410	if ((that.numberOfTools() === 0) && (properties.x != undefined) && (properties.y != undefined)) {
387	that.move(properties.x, properties.y);	411	that.move(properties.x, properties.y);
388	}	412	}
389	delete properties.x;	413	delete properties.x;
@@ -392,6 +416,23 @@ ToolBar = function(x, y, direction) { · 2 unmodified lines
392	var id = that.tools[index].overlay();	416	var id = that.tools[index].overlay();
393	return id;	417	return id;
394	}	418	}
		419	if (this.fractionKey \|\| optionalInitialPositionFunction) {
		420	var savedFraction = JSON.parse(Settings.getValue(this.fractionKey) \|\| '0'); // getValue can answer empty string
		421	var screenSize = Controller.getViewportDimensions();
		422	if (savedFraction) {
		423	// If we have saved data, keep the toolbar at the same proportion of the screen width/height.
		424	that.move(savedFraction.x * screenSize.x, savedFraction.y * screenSize.y);
		425	} else if (!optionalInitialPositionFunction) {
		426	print("No initPosition(screenSize, intializedToolbar) specified for ToolBar");
		427	} else {
		428	// Call the optionalInitialPositionFunctinon() AFTER the client has had a chance to set up.
		429	var that = this;
		430	Script.setTimeout(function () {
		431	var position = optionalInitialPositionFunction(screenSize, that);
		432	that.move(position.x, position.y);
		433	}, 0);
		434	}
		435	}
395	}	436	}
396	ToolBar.SPACING = 4;	437	ToolBar.SPACING = 4;
397	ToolBar.VERTICAL = 0;	438	ToolBar.VERTICAL = 0;

examples/mouseLook.js+38−19

 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
-HIFI_PUBLIC_BUCKET = "http://s3.amazonaws.com/hifi-public/";
 var lastX = Window.getCursorPositionX();
 var lastY = Window.getCursorPositionY();
 var yawFromMouse = 0;
     	}
     }
+    function findInput(name) {
+        var availableInputs = Controller.getAvailableInputs(keyboardID);
+        for (i = 0; i < availableInputs.length; i++) {
+            if (availableInputs[i].inputName == name) {
+                return availableInputs[i].input;
+            }
+        }
+        // If the input isn't found, it will default to the first available input
+        return availableInputs[0].input;
+    }
+    function findAction(name) {
+        var actions = Controller.getAllActions();
+        for (var i = 0; i < actions.length; i++) {
+            if (actions[i].actionName == name) {
+                return i;
+            }
+        }
+        // If the action isn't found, it will default to the first available action
+        return 0;
+    }
     function updateMapping() {
     	if (keyboardID != 0) {
     		if (active) {
                 yawSpeed = 0;
                 pitchSpeed = 0;
-                var a = Controller.getAvailableInputs(keyboardID)[10].input.channel;
+                var a = findInput("A").channel;
-                var d = Controller.getAvailableInputs(keyboardID)[13].input.channel;
+                var d = findInput("D").channel;
-                var left = Controller.getAvailableInputs(keyboardID)[36].input.channel;
+                var left = findInput("Left").channel;
-                var right = Controller.getAvailableInputs(keyboardID)[38].input.channel;
+                var right = findInput("Right").channel;
-                var shift = Controller.getAvailableInputs(keyboardID)[41].input.channel;
+                var shift = findInput("Shift").channel;
-                for (i = 6; i <= 9; i++) {
+                for (var i = findAction("YAW_LEFT"); i <= findAction("YAW_RIGHT"); i++) {
                     var inputChannels = Controller.getAllActions()[i].inputChannels;
-                    for (j = 0; j < inputChannels.length; j++) {
+                    for (var j = 0; j < inputChannels.length; j++) {
                         var inputChannel = inputChannels[j];
                         // make a, d, left, and right strafe
                         if ((inputChannel.input.channel == a || inputChannel.input.channel == left) && inputChannel.modifier.device == 0) {
                             Controller.removeInputChannel(inputChannel);
-                            inputChannel.action = 2;
+                            inputChannel.action = findAction("LATERAL_LEFT");
                             Controller.addInputChannel(inputChannel);
                         } else if ((inputChannel.input.channel == d || inputChannel.input.channel == right) && inputChannel.modifier.device == 0) {
                             Controller.removeInputChannel(inputChannel);
-                            inputChannel.action = 3;
+                            inputChannel.action = findAction("LATERAL_RIGHT");
                             Controller.addInputChannel(inputChannel);
                         }
                     }
                 }
-                // make shift + a/d/left/right change yaw/pitch
+                for (var i = findAction("LATERAL_LEFT"); i <= findAction("LATERAL_RIGHT"); i++) {
-                for (i = 2; i <= 3; i++) {
                     var inputChannels = Controller.getAllActions()[i].inputChannels;
-                    for (j = 0; j < inputChannels.length; j++) {
+                    for (var j = 0; j < inputChannels.length; j++) {
                         var inputChannel = inputChannels[j];
+                        // make shift + a/d/left/right change yaw/pitch
                         if ((inputChannel.input.channel == a || inputChannel.input.channel == left) && inputChannel.modifier.channel == shift) {
                             Controller.removeInputChannel(inputChannel);
-                            inputChannel.action = 6;
+                            inputChannel.action = findAction("YAW_LEFT");
                             Controller.addInputChannel(inputChannel);
                         } else if ((inputChannel.input.channel == d || inputChannel.input.channel == right) && inputChannel.modifier.channel == shift) {
                             Controller.removeInputChannel(inputChannel);
-                            inputChannel.action = 7;
+                            inputChannel.action = findAction("YAW_RIGHT");
                             Controller.addInputChannel(inputChannel);
                         }
                     }
     }
     function resetCursorPosition() {
-        var newX = Window.x + Window.innerWidth / 2;
+        var newX = Window.x + Window.innerWidth / 2.0;
-        var newY = Window.y + Window.innerHeight / 2;
+        var newY = Window.y + Window.innerHeight / 2.0;
         Window.setCursorPosition(newX, newY);
         lastX = newX;
         lastY = newY;

examples/paint.js+44−339

@@ -10,17 +10,16 @@ · 9 unmodified lines
10	//	10	//
11	// Distributed under the Apache License, Version 2.0.	11	// Distributed under the Apache License, Version 2.0.
12	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html	12	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
13	//	13
14	Script.include('lineRider.js')	14	var LINE_DIMENSIONS = 5;
15	var MAX_POINTS_PER_LINE = 30;	15	var LIFETIME = 6000;
16	var LINE_LIFETIME = 60 * 5 //5 minute lifetime
17		16
18	var colorPalette = [{	17	var colorPalette = [{
19	red: 236,	18	red: 236,
20	green: 208,	19	green: 208,
21	blue: 120	20	blue: 120
22	}, {	21	}, {
23	red: 217,	22	red: 214,
24	green: 91,	23	green: 91,
25	blue: 67	24	blue: 67
26	}, {	25	}, {
@@ -40,15 +39,6 @@ var colorPalette = [{ · 13 unmodified lines
40	var currentColorIndex = 0;	39	var currentColorIndex = 0;
41	var currentColor = colorPalette[currentColorIndex];	40	var currentColor = colorPalette[currentColorIndex];
42		41
43
44
45	if (hydraCheck() === true) {
46	HydraPaint();
47	} else {
48	MousePaint();
49	}
50
51
52	function cycleColor() {	42	function cycleColor() {
53	currentColor = colorPalette[++currentColorIndex];	43	currentColor = colorPalette[++currentColorIndex];
54	if (currentColorIndex === colorPalette.length - 1) {	44	if (currentColorIndex === colorPalette.length - 1) {
@@ -57,42 +47,17 @@ function cycleColor() { · 2 unmodified lines
57		47
58	}	48	}
59		49
60	function hydraCheck() {	50	MousePaint();
61	var numberOfButtons = Controller.getNumberOfButtons();
62	var numberOfTriggers = Controller.getNumberOfTriggers();
63	var numberOfSpatialControls = Controller.getNumberOfSpatialControls();
64	var controllersPerTrigger = numberOfSpatialControls / numberOfTriggers;
65	hydrasConnected = (numberOfButtons == 12 && numberOfTriggers == 2 && controllersPerTrigger == 2);
66	return hydrasConnected; //hydrasConnected;
67	}
68
69	//********** Mouse Paint ************************
70		51
71	function MousePaint() {	52	function MousePaint() {
72	var DRAWING_DISTANCE = 2;	53	var DRAWING_DISTANCE = 5;
73	var lines = [];	54	var lines = [];
74	var deletedLines = [];
75	var isDrawing = false;	55	var isDrawing = false;
76	var path = [];
77
78	var lineRider = new LineRider();
79	lineRider.addStartHandler(function() {
80	var points = [];
81	//create points array from list of all points in path
82	path.forEach(function(point) {
83	points.push(point);
84	});
85	lineRider.setPath(points);
86	});
87
88
89		56
90	var LINE_WIDTH = 7;	57	var LINE_WIDTH = 7;
91	var line;	58	var line, linePosition;
92	var points = [];
93
94		59
95	var BRUSH_SIZE = 0.02;	60	var BRUSH_SIZE = .05;
96		61
97	var brush = Entities.addEntity({	62	var brush = Entities.addEntity({
98	type: 'Sphere',	63	type: 'Sphere',
@@ -110,51 +75,42 @@ function MousePaint() { · 11 unmodified lines
110	});	75	});
111		76
112		77
113	function newLine(point) {	78	function newLine(position) {
		79	linePosition = position;
114	line = Entities.addEntity({	80	line = Entities.addEntity({
115	position: MyAvatar.position,	81	position: position,
116	type: "Line",	82	type: "Line",
117	color: currentColor,	83	color: currentColor,
118	dimensions: {	84	dimensions: {
119	x: 10,	85	x: LINE_DIMENSIONS,
120	y: 10,	86	y: LINE_DIMENSIONS,
121	z: 10	87	z: LINE_DIMENSIONS
122	},	88	},
		89	linePoints: [],
123	lineWidth: LINE_WIDTH,	90	lineWidth: LINE_WIDTH,
124	lifetime: LINE_LIFETIME	91	lifetime: LIFETIME
125	});	92	});
126	points = [];
127	if (point) {
128
129	points.push(point);
130	path.push(point);
131	}
132	lines.push(line);	93	lines.push(line);
133	}	94	}
134		95
135		96
136	function mouseMoveEvent(event) {	97	function mouseMoveEvent(event) {
137		98
		99	var worldPoint = computeWorldPoint(event);
		100	Entities.editEntity(brush, {
		101	position: worldPoint
		102	});
		103
138	if (!isDrawing) {	104	if (!isDrawing) {
139	return;	105	return;
140	}	106	}
141		107
142	var pickRay = Camera.computePickRay(event.x, event.y);	108	var localPoint = computeLocalPoint(event)
143	var addVector = Vec3.multiply(Vec3.normalize(pickRay.direction), DRAWING_DISTANCE);	109	var success = Entities.appendPoint(line, localPoint);
144	var point = Vec3.sum(Camera.getPosition(), addVector);
145	points.push(point);
146	path.push(point);
147	Entities.editEntity(line, {
148	linePoints: points
149	});
150	Entities.editEntity(brush, {
151	position: point
152	});
153
154		110
155	if (points.length === MAX_POINTS_PER_LINE) {	111	if (!success) {
156	//We need to start a new line!	112	newLine(worldPoint);
157	newLine(point);	113	Entities.appendPoint(line, computeLocalPoint(event));
158	}	114	}
159	}	115	}
160		116
@@ -171,17 +127,26 @@ function MousePaint() { · 10 unmodified lines
171	lines.push(restoredLine);	127	lines.push(restoredLine);
172	}	128	}
173		129
		130	function computeWorldPoint(event) {
		131	var pickRay = Camera.computePickRay(event.x, event.y);
		132	var addVector = Vec3.multiply(Vec3.normalize(pickRay.direction), DRAWING_DISTANCE);
		133	return Vec3.sum(Camera.getPosition(), addVector);
		134	}
		135
		136	function computeLocalPoint(event) {
		137
		138	var localPoint = Vec3.subtract(computeWorldPoint(event), linePosition);
		139	return localPoint;
		140	}
		141
174	function mousePressEvent(event) {	142	function mousePressEvent(event) {
175	if(!event.isLeftButton) {	143	if (!event.isLeftButton) {
176	isDrawing = false;	144	isDrawing = false;
177	return;	145	return;
178	}	146	}
179	lineRider.mousePressEvent(event);	147	newLine(computeWorldPoint(event));
180	path = [];
181	newLine();
182	isDrawing = true;	148	isDrawing = true;
183		149
184
185	}	150	}
186		151
187	function mouseReleaseEvent() {	152	function mouseReleaseEvent() {
@@ -198,21 +163,21 @@ function MousePaint() { · 10 unmodified lines
198	if (event.text === "z") {	163	if (event.text === "z") {
199	undoStroke();	164	undoStroke();
200	}	165	}
201	if(event.text === "x") {	166	if (event.text === "x") {
202	redoStroke();	167	redoStroke();
203	}	168	}
204	}	169	}
205		170
		171
		172
206	function cleanup() {	173	function cleanup() {
207	lines.forEach(function(line) {	174	lines.forEach(function(line) {
208	Entities.deleteEntity(line);	175	// Entities.deleteEntity(line);
209	});	176	});
210	Entities.deleteEntity(brush);	177	Entities.deleteEntity(brush);
211	lineRider.cleanup();
212		178
213	}	179	}
214		180
215
216	Controller.mousePressEvent.connect(mousePressEvent);	181	Controller.mousePressEvent.connect(mousePressEvent);
217	Controller.mouseReleaseEvent.connect(mouseReleaseEvent);	182	Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
218	Controller.mouseMoveEvent.connect(mouseMoveEvent);	183	Controller.mouseMoveEvent.connect(mouseMoveEvent);
@@ -222,266 +187,6 @@ function MousePaint() { · 3 unmodified lines
222	}	187	}
223		188
224		189
225
226	//***************HYDRA PAINT *****************************************
227
228
229
230	function HydraPaint() {
231
232
233
234	var lineRider = new LineRider();
235	lineRider.addStartHandler(function() {
236	var points = [];
237	//create points array from list of all points in path
238	rightController.path.forEach(function(point) {
239	points.push(point);
240	});
241	lineRider.setPath(points);
242	});
243
244	var LEFT = 0;
245	var RIGHT = 1;
246
247	var currentTime = 0;
248
249
250	var minBrushSize = .02;
251	var maxBrushSize = .04
252
253
254	var minLineWidth = 5;
255	var maxLineWidth = 10;
256	var currentLineWidth = minLineWidth;
257	var MIN_PAINT_TRIGGER_THRESHOLD = .01;
258	var COLOR_CHANGE_TIME_FACTOR = 0.1;
259
260	var RIGHT_BUTTON_1 = 7
261	var RIGHT_BUTTON_2 = 8
262	var RIGHT_BUTTON_3 = 9;
263	var RIGHT_BUTTON_4 = 10
264
265	var LEFT_BUTTON_1 = 1;
266	var LEFT_BUTTON_2 = 2;
267	var LEFT_BUTTON_3 = 3;
268	var LEFT_BUTTON_4 = 4;
269
270	var STROKE_SMOOTH_FACTOR = 1;
271
272	var MIN_DRAW_DISTANCE = 0.2;
273	var MAX_DRAW_DISTANCE = 0.4;
274
275	function controller(side, undoButton, redoButton, cycleColorButton, startRideButton) {
276	this.triggerHeld = false;
277	this.triggerThreshold = 0.9;
278	this.side = side;
279	this.palm = 2 * side;
280	this.tip = 2 * side + 1;
281	this.trigger = side;
282	this.lines = [];
283	this.deletedLines = [] //just an array of properties objects
284	this.isPainting = false;
285
286	this.undoButton = undoButton;
287	this.undoButtonPressed = false;
288	this.prevUndoButtonPressed = false;
289
290	this.redoButton = redoButton;
291	this.redoButtonPressed = false;
292	this.prevRedoButtonPressed = false;
293
294	this.cycleColorButton = cycleColorButton;
295	this.cycleColorButtonPressed = false;
296	this.prevColorCycleButtonPressed = false;
297
298	this.startRideButton = startRideButton;
299	this.startRideButtonPressed = false;
300	this.prevStartRideButtonPressed = false;
301
302	this.strokeCount = 0;
303	this.currentBrushSize = minBrushSize;
304	this.points = [];
305	this.path = [];
306
307	this.brush = Entities.addEntity({
308	type: 'Sphere',
309	position: {
310	x: 0,
311	y: 0,
312	z: 0
313	},
314	color: currentColor,
315	dimensions: {
316	x: minBrushSize,
317	y: minBrushSize,
318	z: minBrushSize
319	}
320	});
321
322
323	this.newLine = function(point) {
324	this.line = Entities.addEntity({
325	position: MyAvatar.position,
326	type: "Line",
327	color: currentColor,
328	dimensions: {
329	x: 10,
330	y: 10,
331	z: 10
332	},
333	lineWidth: 5,
334	lifetime: LINE_LIFETIME
335	});
336	this.points = [];
337	if (point) {
338	this.points.push(point);
339	this.path.push(point);
340	}
341	this.lines.push(this.line);
342	}
343
344	this.update = function(deltaTime) {
345	this.updateControllerState();
346	this.avatarPalmOffset = Vec3.subtract(this.palmPosition, MyAvatar.position);
347	this.projectedForwardDistance = Vec3.dot(Quat.getFront(Camera.getOrientation()), this.avatarPalmOffset);
348	this.mappedPalmOffset = map(this.projectedForwardDistance, -.5, .5, MIN_DRAW_DISTANCE, MAX_DRAW_DISTANCE);
349	this.tipDirection = Vec3.normalize(Vec3.subtract(this.tipPosition, this.palmPosition));
350	this.offsetVector = Vec3.multiply(this.mappedPalmOffset, this.tipDirection);
351	this.drawPoint = Vec3.sum(this.palmPosition, this.offsetVector);
352	this.currentBrushSize = map(this.triggerValue, 0, 1, minBrushSize, maxBrushSize);
353	Entities.editEntity(this.brush, {
354	position: this.drawPoint,
355	dimensions: {
356	x: this.currentBrushSize,
357	y: this.currentBrushSize,
358	z: this.currentBrushSize
359	},
360	color: currentColor
361	});
362	if (this.triggerValue > MIN_PAINT_TRIGGER_THRESHOLD) {
363	if (!this.isPainting) {
364	this.isPainting = true;
365	this.newLine();
366	this.path = [];
367	}
368	if (this.strokeCount % STROKE_SMOOTH_FACTOR === 0) {
369	this.paint(this.drawPoint);
370	}
371	this.strokeCount++;
372	} else if (this.triggerValue < MIN_PAINT_TRIGGER_THRESHOLD && this.isPainting) {
373	this.releaseTrigger();
374	}
375
376	this.oldPalmPosition = this.palmPosition;
377	this.oldTipPosition = this.tipPosition;
378	}
379
380	this.releaseTrigger = function() {
381	this.isPainting = false;
382
383	}
384
385
386	this.updateControllerState = function() {
387	this.undoButtonPressed = Controller.isButtonPressed(this.undoButton);
388	this.redoButtonPressed = Controller.isButtonPressed(this.redoButton);
389	this.cycleColorButtonPressed = Controller.isButtonPressed(this.cycleColorButton);
390	this.startRideButtonPressed = Controller.isButtonPressed(this.startRideButton);
391
392	//This logic gives us button release
393	if (this.prevUndoButtonPressed === true && this.undoButtonPressed === false) {
394	//User released undo button, so undo
395	this.undoStroke();
396	}
397	if (this.prevRedoButtonPressed === true && this.redoButtonPressed === false) {
398	this.redoStroke();
399	}
400
401	if (this.prevCycleColorButtonPressed === true && this.cycleColorButtonPressed === false) {
402	cycleColor();
403	Entities.editEntity(this.brush, {
404	color: currentColor
405	});
406	}
407	if (this.prevStartRideButtonPressed === true && this.startRideButtonPressed === false) {
408	lineRider.toggleRide();
409	}
410	this.prevRedoButtonPressed = this.redoButtonPressed;
411	this.prevUndoButtonPressed = this.undoButtonPressed;
412	this.prevCycleColorButtonPressed = this.cycleColorButtonPressed;
413	this.prevStartRideButtonPressed = this.startRideButtonPressed;
414
415	this.palmPosition = Controller.getSpatialControlPosition(this.palm);
416	this.tipPosition = Controller.getSpatialControlPosition(this.tip);
417	this.triggerValue = Controller.getTriggerValue(this.trigger);
418	}
419
420	this.undoStroke = function() {
421	var deletedLine = this.lines.pop();
422	var deletedLineProps = Entities.getEntityProperties(deletedLine);
423	this.deletedLines.push(deletedLineProps);
424	Entities.deleteEntity(deletedLine);
425	}
426
427	this.redoStroke = function() {
428	var restoredLine = Entities.addEntity(this.deletedLines.pop());
429	Entities.addEntity(restoredLine);
430	this.lines.push(restoredLine);
431	}
432
433	this.paint = function(point) {
434
435	currentLineWidth = map(this.triggerValue, 0, 1, minLineWidth, maxLineWidth);
436	this.points.push(point);
437	this.path.push(point);
438	Entities.editEntity(this.line, {
439	linePoints: this.points,
440	lineWidth: currentLineWidth,
441	});
442	if (this.points.length > MAX_POINTS_PER_LINE) {
443	this.newLine(point);
444	}
445	}
446
447	this.cleanup = function() {
448	Entities.deleteEntity(this.brush);
449	this.lines.forEach(function(line) {
450	Entities.deleteEntity(line);
451	});
452	}
453	}
454
455	function update(deltaTime) {
456	rightController.update(deltaTime);
457	leftController.update(deltaTime);
458	currentTime += deltaTime;
459	}
460
461	function cleanup() {
462	rightController.cleanup();
463	leftController.cleanup();
464	lineRider.cleanup();
465	}
466
467	function mousePressEvent(event) {
468	lineRider.mousePressEvent(event);
469	}
470
471	function vectorIsZero(v) {
472	return v.x === 0 && v.y === 0 && v.z === 0;
473	}
474
475
476	var rightController = new controller(RIGHT, RIGHT_BUTTON_3, RIGHT_BUTTON_4, RIGHT_BUTTON_1, RIGHT_BUTTON_2);
477	var leftController = new controller(LEFT, LEFT_BUTTON_3, LEFT_BUTTON_4, LEFT_BUTTON_1, LEFT_BUTTON_2);
478
479	Script.update.connect(update);
480	Script.scriptEnding.connect(cleanup);
481	Controller.mousePressEvent.connect(mousePressEvent);
482
483	}
484
485	function randFloat(low, high) {	190	function randFloat(low, high) {
486	return low + Math.random() * (high - low);	191	return low + Math.random() * (high - low);
487	}	192	}

examples/pointer.js+3−9

 };
 HIFI_PUBLIC_BUCKET = "http://s3.amazonaws.com/hifi-public/";
-var screenSize = Controller.getViewportDimensions();
 var userCanPoint = false;
 Script.include(["libraries/toolBars.js"]);
-const persistKey = "highfidelity.pointer.toolbar.position";
+var toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL, "highfidelity.pointer.toolbar", function (screenSize) {
-var toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL);
+    return {x: screenSize.x / 2 - BUTTON_SIZE * 2 + PADDING, y: screenSize.y - (BUTTON_SIZE + PADDING)},
-toolBar.save = function () {
+});
-    Settings.setValue(persistKey, JSON.stringify([toolBar.x, toolBar.y]));
-};
-var old = JSON.parse(Settings.getValue(persistKey) || '0');
 var pointerButton = toolBar.addOverlay("image", {
-  x: old ? old[0] : screenSize.x / 2 - BUTTON_SIZE * 2 + PADDING,
-  y: old ? old[1] : screenSize.y - (BUTTON_SIZE + PADDING),
   width: BUTTON_SIZE,
   height: BUTTON_SIZE,
   imageURL: HIFI_PUBLIC_BUCKET + "images/laser.png",

examples/stick.js+3−1

         type: "Model",
         modelURL: "https://hifi-public.s3.amazonaws.com/eric/models/stick.fbx",
         compoundShapeURL: "https://hifi-public.s3.amazonaws.com/eric/models/stick.obj",
-        dimensions: {x: .11, y: .11, z: .59},
+        dimensions: {x: .11, y: .11, z: 1.0},
         position: MyAvatar.getRightPalmPosition(), // initial position doesn't matter, as long as it's close
         rotation: MyAvatar.orientation,
         damping: .1,
+        collisionSoundURL: "http://public.highfidelity.io/sounds/Collisions-hitsandslaps/67LCollision07.wav",
+        restitution: 0.01,
         collisionsWillMove: true
     });
     actionID = Entities.addAction("hold", stickID, {relativePosition: {x: 0.0, y: 0.0, z: -0.9},

examples/utilities.js+39−35

@@ -9,48 +9,52 @@ · 8 unmodified lines
9	// Distributed under the Apache License, Version 2.0.	9	// Distributed under the Apache License, Version 2.0.
10	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html	10	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
11		11
12	function hslToRgb(hslColor) {
13	var h = hslColor.hue;
14	var s = hslColor.sat;
15	var l = hslColor.light;
16	var r, g, b;
17
18	if (s == 0) {
19	r = g = b = l; // achromatic
20	} else {
21	var hue2rgb = function hue2rgb(p, q, t) {
22	if (t < 0) t += 1;
23	if (t > 1) t -= 1;
24	if (t < 1 / 6) return p + (q - p) * 6 * t;
25	if (t < 1 / 2) return q;
26	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
27	return p;
28	}
29
30	var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
31	var p = 2 * l - q;
32	r = hue2rgb(p, q, h + 1 / 3);
33	g = hue2rgb(p, q, h);
34	b = hue2rgb(p, q, h - 1 / 3);
35	}
36		12
37	return {
38	red: Math.round(r * 255),
39	green: Math.round(g * 255),
40	blue: Math.round(b * 255)
41	};
42		13
		14	map = function(value, min1, max1, min2, max2) {
		15	return min2 + (max2 - min2) * ((value - min1) / (max1 - min1));
43	}	16	}
44		17
45	function map(value, min1, max1, min2, max2) {	18	hslToRgb = function(hslColor) {
46	return min2 + (max2 - min2) * ((value - min1) / (max1 - min1));	19	var h = hslColor.hue;
		20	var s = hslColor.sat;
		21	var l = hslColor.light;
		22	var r, g, b;
		23
		24	if (s == 0) {
		25	r = g = b = l; // achromatic
		26	} else {
		27	var hue2rgb = function hue2rgb(p, q, t) {
		28	if (t < 0) t += 1;
		29	if (t > 1) t -= 1;
		30	if (t < 1 / 6) return p + (q - p) * 6 * t;
		31	if (t < 1 / 2) return q;
		32	if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
		33	return p;
		34	}
		35
		36	var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
		37	var p = 2 * l - q;
		38	r = hue2rgb(p, q, h + 1 / 3);
		39	g = hue2rgb(p, q, h);
		40	b = hue2rgb(p, q, h - 1 / 3);
		41	}
		42
		43	return {
		44	red: Math.round(r * 255),
		45	green: Math.round(g * 255),
		46	blue: Math.round(b * 255)
		47	};
		48
47	}	49	}
48		50
49	function randFloat(low, high) {	51
50	return low + Math.random() * (high - low);	52
		53	randFloat = function(low, high) {
		54	return low + Math.random() * (high - low);
51	}	55	}
52		56
53		57
54	function randInt(low, high) {	58	randInt = function(low, high) {
55	return Math.floor(randFloat(low, high));	59	return Math.floor(randFloat(low, high));
56	}	60	}

examples/utilities/tools/cookies.js+25−0

@@ -120,6 +120,23 @@ Slider = function(x,y,width,thumbSize) { · 119 unmodified lines
120		120
121	this.onValueChanged = function(value) {};	121	this.onValueChanged = function(value) {};
122		122
		123	this.setMaxValue = function(maxValue) {
		124	if (this.maxValue == maxValue) {
		125	return;
		126	}
		127	var currentVal = this.getValue();
		128	this.maxValue = maxValue;
		129	this.setValue(currentVal);
		130	}
		131	this.setMinValue = function(minValue) {
		132	if (this.minValue == minValue) {
		133	return;
		134	}
		135	var currentVal = this.getValue();
		136	this.minValue = minValue;
		137	this.setValue(currentVal);
		138	}
		139
123	this.destroy = function() {	140	this.destroy = function() {
124	Overlays.deleteOverlay(this.background);	141	Overlays.deleteOverlay(this.background);
125	Overlays.deleteOverlay(this.thumb);	142	Overlays.deleteOverlay(this.thumb);
@@ -613,6 +630,14 @@ Panel = function(x, y) { · 487 unmodified lines
613	return null;	630	return null;
614	}	631	}
615		632
		633	this.getWidget = function(name) {
		634	var item = this.items[name];
		635	if (item != null) {
		636	return item.widget;
		637	}
		638	return null;
		639	}
		640
616	this.update = function(name) {	641	this.update = function(name) {
617	var item = this.items[name];	642	var item = this.items[name];
618	if (item != null) {	643	if (item != null) {

examples/utilities/tools/renderEngineDebug.js+42−39

@@ -10,25 +10,7 @@ · 9 unmodified lines
10		10
11	Script.include("cookies.js");	11	Script.include("cookies.js");
12		12
13	var panel = new Panel(10, 400);	13	var panel = new Panel(10, 800);
14
15	panel.newCheckbox("Enable Cull Opaque",
16	function(value) { Scene.setEngineCullOpaque((value != 0)); },
17	function() { return Scene.doEngineCullOpaque(); },
18	function(value) { return (value); }
19	);
20
21	panel.newCheckbox("Enable Sort Opaque",
22	function(value) { Scene.setEngineSortOpaque((value != 0)); },
23	function() { return Scene.doEngineSortOpaque(); },
24	function(value) { return (value); }
25	);
26
27	panel.newCheckbox("Enable Render Opaque",
28	function(value) { Scene.setEngineRenderOpaque((value != 0)); },
29	function() { return Scene.doEngineRenderOpaque(); },
30	function(value) { return (value); }
31	);
32		14
33	panel.newSlider("Num Feed Opaques", 0, 1000,	15	panel.newSlider("Num Feed Opaques", 0, 1000,
34	function(value) { },	16	function(value) { },
@@ -48,49 +30,70 @@ panel.newSlider("Max Drawn Opaques", -1, 1000, · 13 unmodified lines
48	function(value) { return (value); }	30	function(value) { return (value); }
49	);	31	);
50		32
51	panel.newCheckbox("Enable Cull Transparent",	33	panel.newSlider("Num Feed Transparents", 0, 100,
52	function(value) { Scene.setEngineCullTransparent((value != 0)); },	34	function(value) { },
53	function() { return Scene.doEngineCullTransparent(); },	35	function() { return Scene.getEngineNumFeedTransparentItems(); },
54	function(value) { return (value); }	36	function(value) { return (value); }
55	);	37	);
56		38
57	panel.newCheckbox("Enable Sort Transparent",	39	panel.newSlider("Num Drawn Transparents", 0, 100,
58	function(value) { Scene.setEngineSortTransparent((value != 0)); },	40	function(value) { },
59	function() { return Scene.doEngineSortTransparent(); },	41	function() { return Scene.getEngineNumDrawnTransparentItems(); },
60	function(value) { return (value); }	42	function(value) { return (value); }
61	);	43	);
62		44
63	panel.newCheckbox("Enable Render Transparent",	45	panel.newSlider("Max Drawn Transparents", -1, 100,
64	function(value) { Scene.setEngineRenderTransparent((value != 0)); },	46	function(value) { Scene.setEngineMaxDrawnTransparentItems(value); },
65	function() { return Scene.doEngineRenderTransparent(); },	47	function() { return Scene.getEngineMaxDrawnTransparentItems(); },
66	function(value) { return (value); }	48	function(value) { return (value); }
67	);	49	);
68		50
69	panel.newSlider("Num Feed Transparents", 0, 100,	51	panel.newSlider("Num Feed Overlay3Ds", 0, 100,
70	function(value) { },	52	function(value) { },
71	function() { return Scene.getEngineNumFeedTransparentItems(); },	53	function() { return Scene.getEngineNumFeedOverlay3DItems(); },
72	function(value) { return (value); }	54	function(value) { return (value); }
73	);	55	);
74		56
75	panel.newSlider("Num Drawn Transparents", 0, 100,	57	panel.newSlider("Num Drawn Overlay3Ds", 0, 100,
76	function(value) { },	58	function(value) { },
77	function() { return Scene.getEngineNumDrawnTransparentItems(); },	59	function() { return Scene.getEngineNumDrawnOverlay3DItems(); },
78	function(value) { return (value); }	60	function(value) { return (value); }
79	);	61	);
80		62
81	panel.newSlider("Max Drawn Transparents", -1, 100,	63	panel.newSlider("Max Drawn Overlay3Ds", -1, 100,
82	function(value) { Scene.setEngineMaxDrawnTransparentItems(value); },	64	function(value) { Scene.setEngineMaxDrawnOverlay3DItems(value); },
83	function() { return Scene.getEngineMaxDrawnTransparentItems(); },	65	function() { return Scene.getEngineMaxDrawnOverlay3DItems(); },
84	function(value) { return (value); }	66	function(value) { return (value); }
85	);	67	);
86		68
87	var tickTackPeriod = 500;	69	var tickTackPeriod = 500;
88		70
89	function updateCounters() {	71	function updateCounters() {
90	panel.set("Num Feed Opaques", panel.get("Num Feed Opaques"));	72	var numFeedOpaques = panel.get("Num Feed Opaques");
91	panel.set("Num Drawn Opaques", panel.get("Num Drawn Opaques"));	73	var numFeedTransparents = panel.get("Num Feed Transparents");
92	panel.set("Num Feed Transparents", panel.get("Num Feed Transparents"));	74	var numFeedOverlay3Ds = panel.get("Num Feed Overlay3Ds");
93	panel.set("Num Drawn Transparents", panel.get("Num Drawn Transparents"));	75
		76	panel.set("Num Feed Opaques", numFeedOpaques);
		77	panel.set("Num Drawn Opaques", panel.get("Num Drawn Opaques"));
		78	panel.set("Num Feed Transparents", numFeedTransparents);
		79	panel.set("Num Drawn Transparents", panel.get("Num Drawn Transparents"));
		80	panel.set("Num Feed Overlay3Ds", numFeedOverlay3Ds);
		81	panel.set("Num Drawn Overlay3Ds", panel.get("Num Drawn Overlay3Ds"));
		82
		83	var numMax = Math.max(numFeedOpaques * 1.2, 1);
		84	panel.getWidget("Num Feed Opaques").setMaxValue(numMax);
		85	panel.getWidget("Num Drawn Opaques").setMaxValue(numMax);
		86	panel.getWidget("Max Drawn Opaques").setMaxValue(numMax);
		87
		88	numMax = Math.max(numFeedTransparents * 1.2, 1);
		89	panel.getWidget("Num Feed Transparents").setMaxValue(numMax);
		90	panel.getWidget("Num Drawn Transparents").setMaxValue(numMax);
		91	panel.getWidget("Max Drawn Transparents").setMaxValue(numMax);
		92
		93	numMax = Math.max(numFeedOverlay3Ds * 1.2, 1);
		94	panel.getWidget("Num Feed Overlay3Ds").setMaxValue(numMax);
		95	panel.getWidget("Num Drawn Overlay3Ds").setMaxValue(numMax);
		96	panel.getWidget("Max Drawn Overlay3Ds").setMaxValue(numMax);
94	}	97	}
95	Script.setInterval(updateCounters, tickTackPeriod);	98	Script.setInterval(updateCounters, tickTackPeriod);
96		99

interface/resources/images/address-bar.svg+21−5

    viewBox="0 0 1440 200"
    id="svg4136"
    inkscape:version="0.91 r13725"
-   sodipodi:docname="address-bar.svg">
+   sodipodi:docname="address-bar.002.svg">
   <metadata
      id="metadata4144">
     <rdf:RDF>
      guidetolerance="10"
      inkscape:pageopacity="0"
      inkscape:pageshadow="2"
-     inkscape:window-width="1840"
+     inkscape:window-width="1835"
      inkscape:window-height="1057"
      id="namedview4140"
      showgrid="false"
-     inkscape:zoom="0.8671875"
+     inkscape:zoom="0.61319416"
-     inkscape:cx="707.02439"
+     inkscape:cx="132.58366"
      inkscape:cy="52.468468"
-     inkscape:window-x="72"
+     inkscape:window-x="77"
      inkscape:window-y="-8"
      inkscape:window-maximized="1"
      inkscape:current-layer="svg4136" />
      y="30"
      rx="16.025024"
      ry="17.019567" />
+  <rect
+     style="fill:#dadada;fill-opacity:1;stroke:#cbcbcb;stroke-width:0.33821851;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
+     id="rect4135"
+     width="292.86267"
+     height="139.66179"
+     x="150.32542"
+     y="30.169102"
+     rx="16.817432"
+     ry="20.612938" />
   <circle
      style="fill:#b8b8b8;fill-opacity:1;stroke:none;stroke-opacity:1"
      id="path4146"
      d="m 100,36.000005 c -22.1,0 -40,17.9 -40,39.999995 0,30 40,88 40,88 0,0 40,-58 40,-88 0,-22.099995 -17.9,-39.999995 -40,-39.999995 z m 0,22 c 9.9,0 18,8.099995 18,17.999995 0,9.9 -8.1,18 -18,18 -9.9,0 -18,-8.1 -18,-18 0,-9.9 8.1,-17.999995 18,-17.999995 z"
      id="path4138"
      inkscape:connector-curvature="0" />
+  <rect
+     style="fill:#bdbdbd;fill-opacity:1;stroke:none;stroke-width:0.30000001;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
+     id="rect4136"
+     width="4"
+     height="100"
+     x="310.12924"
+     y="50" />
 </svg>

interface/resources/images/arrow.png+0−0

Binary file not shown.

interface/resources/images/left-arrow.svg+50−0

@@ -0,0 +1,50 @@
	1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
	2	<!-- Generator: Adobe Illustrator 18.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
	3
	4	<svg
	5	xmlns:dc="http://purl.org/dc/elements/1.1/"
	6	xmlns:cc="http://creativecommons.org/ns#"
	7	xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
	8	xmlns:svg="http://www.w3.org/2000/svg"
	9	xmlns="http://www.w3.org/2000/svg"
	10	xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
	11	xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
	12	version="1.1"
	13	id="Layer_1"
	14	x="0px"
	15	y="0px"
	16	viewBox="133.1 714.2 21.3 33.4"
	17	enable-background="new 133.1 714.2 21.3 33.4"
	18	xml:space="preserve"
	19	inkscape:version="0.91 r13725"
	20	sodipodi:docname="left-arrow.svg"><metadata
	21	id="metadata13"><rdf:RDF><cc:Work
	22	rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
	23	rdf:resource="http://purl.org/dc/dcmitype/StillImage" /></cc:Work></rdf:RDF></metadata><defs
	24	id="defs11" /><sodipodi:namedview
	25	pagecolor="#ffffff"
	26	bordercolor="#666666"
	27	borderopacity="1"
	28	objecttolerance="10"
	29	gridtolerance="10"
	30	guidetolerance="10"
	31	inkscape:pageopacity="0"
	32	inkscape:pageshadow="2"
	33	inkscape:window-width="1835"
	34	inkscape:window-height="1057"
	35	id="namedview9"
	36	showgrid="false"
	37	inkscape:zoom="7.0658679"
	38	inkscape:cx="10.65"
	39	inkscape:cy="16.700001"
	40	inkscape:window-x="77"
	41	inkscape:window-y="-8"
	42	inkscape:window-maximized="1"
	43	inkscape:current-layer="Layer_1" /><g
	44	id="g3"
	45	transform="matrix(-1,0,0,1,287.5,0)"><g
	46	id="g5"><path
	47	d="m 133.1,714.2 21.3,16.7 -21.3,16.7 0,-33.4 z"
	48	id="path7"
	49	inkscape:connector-curvature="0"
	50	style="fill:#535353" /></g></g></svg>

interface/resources/images/redarrow.svg+11−0

@@ -0,0 +1,11 @@
	1	<?xml version="1.0" encoding="utf-8"?>
	2	<!-- Generator: Adobe Illustrator 18.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
	3	<svg version="1.1" id="Layer_1" xmlns:xl="http://www.w3.org/1999/xlink"
	4	xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="133.1 714.2 21.3 33.4"
	5	enable-background="new 133.1 714.2 21.3 33.4" xml:space="preserve">
	6	<g>
	7	<g>
	8	<path fill="#FF5353" d="M133.1,714.2l21.3,16.7l-21.3,16.7V714.2z"/>
	9	</g>
	10	</g>
	11	</svg>

interface/resources/images/redarrow_reversed.svg+11−0

@@ -0,0 +1,11 @@
	1	<?xml version="1.0" encoding="utf-8"?>
	2	<!-- Generator: Adobe Illustrator 18.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
	3	<svg version="1.1" id="Layer_1" xmlns:xl="http://www.w3.org/1999/xlink"
	4	xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="225.8 714.2 326.5 512"
	5	enable-background="new 225.8 714.2 326.5 512" xml:space="preserve">
	6	<g>
	7	<g>
	8	<path fill="#FF5353" d="M552.4,1226.2l-326.5-256l326.5-256V1226.2z"/>
	9	</g>
	10	</g>
	11	</svg>

interface/resources/images/right-arrow.svg+11−0

@@ -0,0 +1,11 @@
	1	<?xml version="1.0" encoding="utf-8"?>
	2	<!-- Generator: Adobe Illustrator 18.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
	3	<svg version="1.1" id="Layer_1" xmlns:xl="http://www.w3.org/1999/xlink"
	4	xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="133.1 714.2 21.3 33.4"
	5	enable-background="new 133.1 714.2 21.3 33.4" xml:space="preserve">
	6	<g>
	7	<g>
	8	<path fill="#535353" d="M133.1,714.2l21.3,16.7l-21.3,16.7V714.2z"/>
	9	</g>
	10	</g>
	11	</svg>

interface/resources/qml/AddressBarDialog.qml+68−22

@@ -30,6 +30,7 @@ DialogContainer { · 29 unmodified lines
30	property int maximumX: parent ? parent.width - width : 0	30	property int maximumX: parent ? parent.width - width : 0
31	property int maximumY: parent ? parent.height - height : 0	31	property int maximumY: parent ? parent.height - height : 0
32		32
		33
33	AddressBarDialog {	34	AddressBarDialog {
34	id: addressBarDialog	35	id: addressBarDialog
35		36
@@ -45,28 +46,6 @@ DialogContainer { · 9 unmodified lines
45	property int inputAreaHeight: 56.0 * root.scale // Height of the background's input area	46	property int inputAreaHeight: 56.0 * root.scale // Height of the background's input area
46	property int inputAreaStep: (height - inputAreaHeight) / 2	47	property int inputAreaStep: (height - inputAreaHeight) / 2
47		48
48	TextInput {
49	id: addressLine
50
51	anchors {
52	fill: parent
53	leftMargin: parent.height + hifi.layout.spacing * 2
54	rightMargin: hifi.layout.spacing * 2
55	topMargin: parent.inputAreaStep + hifi.layout.spacing
56	bottomMargin: parent.inputAreaStep + hifi.layout.spacing
57
58	}
59
60	font.pixelSize: hifi.fonts.pixelSize * root.scale
61
62	helperText: "Go to: place, @user, /path, network address"
63
64	onAccepted: {
65	event.accepted = true // Generates erroneous error in program log, "ReferenceError: event is not defined".
66	addressBarDialog.loadAddress(addressLine.text)
67	}
68	}
69
70	MouseArea {	49	MouseArea {
71	// Drag the icon	50	// Drag the icon
72	width: parent.height	51	width: parent.height
@@ -96,6 +75,73 @@ DialogContainer { · 23 unmodified lines
96	maximumY: root.parent ? root.maximumY + parent.inputAreaStep : 0	75	maximumY: root.parent ? root.maximumY + parent.inputAreaStep : 0
97	}	76	}
98	}	77	}
		78
		79	Image {
		80	id: backArrow
		81
		82	source: addressBarDialog.backEnabled ? "../images/left-arrow.svg" : "../images/redarrow_reversed.svg"
		83
		84	anchors {
		85	fill: parent
		86	leftMargin: parent.height + hifi.layout.spacing + 6
		87	rightMargin: parent.height + hifi.layout.spacing * 60
		88	topMargin: parent.inputAreaStep + parent.inputAreaStep + hifi.layout.spacing
		89	bottomMargin: parent.inputAreaStep + parent.inputAreaStep + hifi.layout.spacing
		90	}
		91
		92	MouseArea {
		93	anchors.fill: parent
		94	acceptedButtons: Qt.LeftButton
		95	onClicked: {
		96	addressBarDialog.loadBack()
		97	}
		98	}
		99	}
		100
		101	Image {
		102	id: forwardArrow
		103
		104	source: addressBarDialog.forwardEnabled ? "../images/right-arrow.svg" : "../images/redarrow.svg"
		105
		106	anchors {
		107	fill: parent
		108	leftMargin: parent.height + hifi.layout.spacing * 9
		109	rightMargin: parent.height + hifi.layout.spacing * 53
		110	topMargin: parent.inputAreaStep + parent.inputAreaStep + hifi.layout.spacing
		111	bottomMargin: parent.inputAreaStep + parent.inputAreaStep + hifi.layout.spacing
		112	}
		113
		114	MouseArea {
		115	anchors.fill: parent
		116	acceptedButtons: Qt.LeftButton
		117	onClicked: {
		118	addressBarDialog.loadForward()
		119	}
		120	}
		121	}
		122
		123	TextInput {
		124	id: addressLine
		125
		126	anchors {
		127	fill: parent
		128	leftMargin: parent.height + parent.height + hifi.layout.spacing * 5
		129	rightMargin: hifi.layout.spacing * 2
		130	topMargin: parent.inputAreaStep + hifi.layout.spacing
		131	bottomMargin: parent.inputAreaStep + hifi.layout.spacing
		132
		133	}
		134
		135	font.pixelSize: hifi.fonts.pixelSize * root.scale * 0.75
		136
		137	helperText: "Go to: place, @user, /path, network address"
		138
		139	onAccepted: {
		140	event.accepted = true // Generates erroneous error in program log, "ReferenceError: event is not defined".
		141	addressBarDialog.loadAddress(addressLine.text)
		142	}
		143	}
		144
99	}	145	}
100	}	146	}
101		147

interface/resources/qml/AvatarInputs.qml+177−0

@@ -0,0 +1,177 @@
	1	//
	2	// Created by Bradley Austin Davis on 2015/06/19
	3	// Copyright 2015 High Fidelity, Inc.
	4	//
	5	// Distributed under the Apache License, Version 2.0.
	6	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	7	//
	8
	9	import Hifi 1.0 as Hifi
	10	import QtQuick 2.4
	11	import QtQuick.Controls 1.3
	12	import QtGraphicalEffects 1.0
	13
	14	Hifi.AvatarInputs {
	15	id: root
	16	objectName: "AvatarInputs"
	17	anchors.fill: parent
	18
	19	// width: 800
	20	// height: 600
	21	// color: "black"
	22	readonly property int iconPadding: 5
	23	readonly property int mirrorHeight: 215
	24	readonly property int mirrorWidth: 265
	25	readonly property int mirrorTopPad: iconPadding
	26	readonly property int mirrorLeftPad: 10
	27	readonly property int iconSize: 24
	28
	29	Item {
	30	id: mirror
	31	width: root.mirrorWidth
	32	height: root.mirrorVisible ? root.mirrorHeight : 0
	33	visible: root.mirrorVisible
	34	anchors.left: parent.left
	35	anchors.leftMargin: root.mirrorLeftPad
	36	anchors.top: parent.top
	37	anchors.topMargin: root.mirrorTopPad
	38	clip: true
	39
	40	MouseArea {
	41	id: hover
	42	anchors.fill: parent
	43	hoverEnabled: true
	44	propagateComposedEvents: true
	45	}
	46
	47	Image {
	48	id: closeMirror
	49	visible: hover.containsMouse
	50	width: root.iconSize
	51	height: root.iconSize
	52	anchors.top: parent.top
	53	anchors.topMargin: root.iconPadding
	54	anchors.left: parent.left
	55	anchors.leftMargin: root.iconPadding
	56	source: "../images/close.svg"
	57	MouseArea {
	58	anchors.fill: parent
	59	onClicked: {
	60	root.closeMirror();
	61	}
	62	}
	63	}
	64
	65	Image {
	66	id: zoomIn
	67	visible: hover.containsMouse
	68	width: root.iconSize
	69	height: root.iconSize
	70	anchors.bottom: parent.bottom
	71	anchors.bottomMargin: root.iconPadding
	72	anchors.left: parent.left
	73	anchors.leftMargin: root.iconPadding
	74	source: root.mirrorZoomed ? "../images/minus.svg" : "../images/plus.svg"
	75	MouseArea {
	76	anchors.fill: parent
	77	onClicked: {
	78	root.toggleZoom();
	79	}
	80	}
	81	}
	82	}
	83
	84	Item {
	85	width: root.mirrorWidth
	86	height: 44
	87
	88	x: root.mirrorLeftPad
	89	y: root.mirrorVisible ? root.mirrorTopPad + root.mirrorHeight : 5
	90
	91
	92
	93	Rectangle {
	94	anchors.fill: parent
	95	color: root.mirrorVisible ? (root.audioClipping ? "red" : "#696969") : "#00000000"
	96
	97	Image {
	98	id: faceMute
	99	width: root.iconSize
	100	height: root.iconSize
	101	visible: root.cameraEnabled
	102	anchors.left: parent.left
	103	anchors.leftMargin: root.iconPadding
	104	anchors.verticalCenter: parent.verticalCenter
	105	source: root.cameraMuted ? "../images/face-mute.svg" : "../images/face.svg"
	106	MouseArea {
	107	anchors.fill: parent
	108	onClicked: {
	109	root.toggleCameraMute()
	110	}
	111	onDoubleClicked: {
	112	root.resetSensors();
	113	}
	114	}
	115	}
	116
	117	Image {
	118	id: micMute
	119	width: root.iconSize
	120	height: root.iconSize
	121	anchors.left: root.cameraEnabled ? faceMute.right : parent.left
	122	anchors.leftMargin: root.iconPadding
	123	anchors.verticalCenter: parent.verticalCenter
	124	source: root.audioMuted ? "../images/mic-mute.svg" : "../images/mic.svg"
	125	MouseArea {
	126	anchors.fill: parent
	127	onClicked: {
	128	root.toggleAudioMute()
	129	}
	130	}
	131	}
	132
	133	Item {
	134	id: audioMeter
	135	anchors.verticalCenter: parent.verticalCenter
	136	anchors.left: micMute.right
	137	anchors.leftMargin: root.iconPadding
	138	anchors.right: parent.right
	139	anchors.rightMargin: root.iconPadding
	140	height: 8
	141	Rectangle {
	142	id: blueRect
	143	color: "blue"
	144	anchors.top: parent.top
	145	anchors.bottom: parent.bottom
	146	anchors.left: parent.left
	147	width: parent.width / 4
	148	}
	149	Rectangle {
	150	id: greenRect
	151	color: "green"
	152	anchors.top: parent.top
	153	anchors.bottom: parent.bottom
	154	anchors.left: blueRect.right
	155	anchors.right: redRect.left
	156	}
	157	Rectangle {
	158	id: redRect
	159	color: "red"
	160	anchors.top: parent.top
	161	anchors.bottom: parent.bottom
	162	anchors.right: parent.right
	163	width: parent.width / 5
	164	}
	165	Rectangle {
	166	z: 100
	167	anchors.top: parent.top
	168	anchors.bottom: parent.bottom
	169	anchors.right: parent.right
	170	width: (1.0 - root.audioLevel) * parent.width
	171	color: "black"
	172	}
	173	}
	174	}
	175	}
	176	}
	177

interface/resources/qml/Stats.qml+258−0

@@ -0,0 +1,258 @@
	1	import Hifi 1.0 as Hifi
	2	import QtQuick 2.3
	3	import QtQuick.Controls 1.2
	4
	5	Item {
	6	anchors.fill: parent
	7	anchors.leftMargin: 300
	8	Hifi.Stats {
	9	id: root
	10	objectName: "Stats"
	11	implicitHeight: row.height
	12	implicitWidth: row.width
	13
	14	anchors.horizontalCenter: parent.horizontalCenter
	15
	16	readonly property int sTATS_GENERAL_MIN_WIDTH: 165
	17	readonly property int sTATS_PING_MIN_WIDTH: 190
	18	readonly property int sTATS_GEO_MIN_WIDTH: 240
	19	readonly property int sTATS_OCTREE_MIN_WIDTH: 410
	20	readonly property int fontSize: 12
	21	readonly property string fontColor: "white"
	22	readonly property string bgColor: "#99333333"
	23
	24	Row {
	25	id: row
	26	spacing: 8
	27	Rectangle {
	28	width: generalCol.width + 8;
	29	height: generalCol.height + 8;
	30	color: root.bgColor;
	31
	32	MouseArea {
	33	anchors.fill: parent
	34	onClicked: { root.expanded = !root.expanded; }
	35	}
	36
	37	Column {
	38	id: generalCol
	39	spacing: 4; x: 4; y: 4;
	40	width: sTATS_GENERAL_MIN_WIDTH
	41	Text {
	42	color: root.fontColor;
	43	font.pixelSize: root.fontSize
	44	text: "Servers: " + root.serverCount
	45	}
	46	Text {
	47	color: root.fontColor;
	48	font.pixelSize: root.fontSize
	49	text: "Avatars: " + root.avatarCount
	50	}
	51	Text {
	52	color: root.fontColor;
	53	font.pixelSize: root.fontSize
	54	text: "Framerate: " + root.framerate
	55	}
	56	Text {
	57	color: root.fontColor;
	58	font.pixelSize: root.fontSize
	59	text: "Packets In/Out: " + root.packetInCount + "/" + root.packetOutCount
	60	}
	61	Text {
	62	color: root.fontColor;
	63	font.pixelSize: root.fontSize
	64	text: "Mbps In/Out: " + root.mbpsIn.toFixed(2) + "/" + root.mbpsOut.toFixed(2)
	65	}
	66	}
	67	}
	68
	69	Rectangle {
	70	width: pingCol.width + 8
	71	height: pingCol.height + 8
	72	color: root.bgColor;
	73	visible: root.audioPing != -2
	74	MouseArea {
	75	anchors.fill: parent
	76	onClicked: { root.expanded = !root.expanded; }
	77	}
	78	Column {
	79	id: pingCol
	80	spacing: 4; x: 4; y: 4;
	81	width: sTATS_PING_MIN_WIDTH
	82	Text {
	83	color: root.fontColor
	84	font.pixelSize: root.fontSize
	85	text: "Audio ping: " + root.audioPing
	86	}
	87	Text {
	88	color: root.fontColor
	89	font.pixelSize: root.fontSize
	90	text: "Avatar ping: " + root.avatarPing
	91	}
	92	Text {
	93	color: root.fontColor
	94	font.pixelSize: root.fontSize
	95	text: "Entities avg ping: " + root.entitiesPing
	96	}
	97	Text {
	98	color: root.fontColor
	99	font.pixelSize: root.fontSize
	100	visible: root.expanded;
	101	text: "Voxel max ping: " + 0
	102	}
	103	}
	104	}
	105
	106	Rectangle {
	107	width: geoCol.width + 8
	108	height: geoCol.height + 8
	109	color: root.bgColor;
	110	MouseArea {
	111	anchors.fill: parent
	112	onClicked: { root.expanded = !root.expanded; }
	113	}
	114	Column {
	115	id: geoCol
	116	spacing: 4; x: 4; y: 4;
	117	width: sTATS_GEO_MIN_WIDTH
	118	Text {
	119	color: root.fontColor;
	120	font.pixelSize: root.fontSize
	121	text: "Position: " + root.position.x.toFixed(1) + ", " +
	122	root.position.y.toFixed(1) + ", " + root.position.z.toFixed(1)
	123	}
	124	Text {
	125	color: root.fontColor;
	126	font.pixelSize: root.fontSize
	127	text: "Velocity: " + root.velocity.toFixed(1)
	128	}
	129	Text {
	130	color: root.fontColor;
	131	font.pixelSize: root.fontSize
	132	text: "Yaw: " + root.yaw.toFixed(1)
	133	}
	134	Text {
	135	color: root.fontColor;
	136	font.pixelSize: root.fontSize
	137	visible: root.expanded;
	138	text: "Avatar Mixer: " + root.avatarMixerKbps + " kbps, " +
	139	root.avatarMixerPps + "pps";
	140	}
	141	Text {
	142	color: root.fontColor;
	143	font.pixelSize: root.fontSize
	144	visible: root.expanded;
	145	text: "Downloads: ";
	146	}
	147	}
	148	}
	149	Rectangle {
	150	width: octreeCol.width + 8
	151	height: octreeCol.height + 8
	152	color: root.bgColor;
	153	MouseArea {
	154	anchors.fill: parent
	155	onClicked: { root.expanded = !root.expanded; }
	156	}
	157	Column {
	158	id: octreeCol
	159	spacing: 4; x: 4; y: 4;
	160	width: sTATS_OCTREE_MIN_WIDTH
	161	Text {
	162	color: root.fontColor;
	163	font.pixelSize: root.fontSize
	164	text: "Triangles: " + root.triangles +
	165	" / Quads: " + root.quads + " / Material Switches: " + root.materialSwitches
	166	}
	167	Text {
	168	color: root.fontColor;
	169	font.pixelSize: root.fontSize
	170	visible: root.expanded;
	171	text: "\tMesh Parts Rendered Opaque: " + root.meshOpaque +
	172	" / Translucent: " + root.meshTranslucent;
	173	}
	174	Text {
	175	color: root.fontColor;
	176	font.pixelSize: root.fontSize
	177	visible: root.expanded;
	178	text: "\tOpaque considered: " + root.opaqueConsidered +
	179	" / Out of view: " + root.opaqueOutOfView + " / Too small: " + root.opaqueTooSmall;
	180	}
	181	Text {
	182	color: root.fontColor;
	183	font.pixelSize: root.fontSize
	184	visible: !root.expanded
	185	text: "Octree Elements Server: " + root.serverElements +
	186	" Local: " + root.localElements;
	187	}
	188	Text {
	189	color: root.fontColor;
	190	font.pixelSize: root.fontSize
	191	visible: root.expanded
	192	text: "Octree Sending Mode: " + root.sendingMode;
	193	}
	194	Text {
	195	color: root.fontColor;
	196	font.pixelSize: root.fontSize
	197	visible: root.expanded
	198	text: "Octree Packets to Process: " + root.packetStats;
	199	}
	200	Text {
	201	color: root.fontColor;
	202	font.pixelSize: root.fontSize
	203	visible: root.expanded
	204	text: "Octree Elements - ";
	205	}
	206	Text {
	207	color: root.fontColor;
	208	font.pixelSize: root.fontSize
	209	visible: root.expanded
	210	text: "\tServer: " + root.serverElements +
	211	" Internal: " + root.serverInternal +
	212	" Leaves: " + root.serverLeaves;
	213	}
	214	Text {
	215	color: root.fontColor;
	216	font.pixelSize: root.fontSize
	217	visible: root.expanded
	218	text: "\tLocal: " + root.localElements +
	219	" Internal: " + root.localInternal +
	220	" Leaves: " + root.localLeaves;
	221	}
	222	Text {
	223	color: root.fontColor;
	224	font.pixelSize: root.fontSize
	225	visible: root.expanded
	226	text: "LOD: " + root.lodStatus;
	227	}
	228	}
	229	}
	230	}
	231
	232	Rectangle {
	233	y: 250
	234	visible: root.timingExpanded
	235	width: perfText.width + 8
	236	height: perfText.height + 8
	237	color: root.bgColor;
	238	Text {
	239	x: 4; y: 4
	240	id: perfText
	241	color: root.fontColor
	242	font.family: root.monospaceFont
	243	font.pixelSize: 12
	244	text: "------------------------------------------ Function " +
	245	"--------------------------------------- --msecs- -calls--\n" +
	246	root.timingStats;
	247	}
	248	}
	249
	250	Connections {
	251	target: root.parent
	252	onWidthChanged: {
	253	root.x = root.parent.width - root.width;
	254	}
	255	}
	256	}
	257
	258	}

interface/resources/qml/Tooltip.qml+31−0

@@ -0,0 +1,31 @@
	1	import Hifi 1.0 as Hifi
	2	import QtQuick 2.3 as Original
	3	import "controls"
	4	import "styles"
	5
	6	Hifi.Tooltip {
	7	id: root
	8	HifiConstants { id: hifi }
	9	// FIXME adjust position based on the edges of the screen
	10	x: (lastMousePosition.x > surfaceSize.width/2) ? lastMousePosition.x - 140 : lastMousePosition.x + 20
	11	//y: lastMousePosition.y + 5
	12	y: (lastMousePosition.y > surfaceSize.height/2) ? lastMousePosition.y - 70 : lastMousePosition.y + 5
	13	implicitWidth: border.implicitWidth
	14	implicitHeight: border.implicitHeight
	15
	16	Border {
	17	id: border
	18	anchors.fill: parent
	19	implicitWidth: text.implicitWidth
	20	implicitHeight: Math.max(text.implicitHeight, 64)
	21
	22	Text {
	23	id: text
	24	anchors.fill: parent
	25	anchors.margins: 16
	26	font.pixelSize: hifi.fonts.pixelSize / 2
	27	text: root.text
	28	wrapMode: Original.Text.WordWrap
	29	}
	30	}
	31	}

interface/src/Application.cpp+115−156

@@ -66,6 +66,9 @@ · 65 unmodified lines
66	#include <EntityScriptingInterface.h>	66	#include <EntityScriptingInterface.h>
67	#include <ErrorDialog.h>	67	#include <ErrorDialog.h>
68	#include <GlowEffect.h>	68	#include <GlowEffect.h>
		69	#include <gpu/Batch.h>
		70	#include <gpu/Context.h>
		71	#include <gpu/GLBackend.h>
69	#include <HFActionEvent.h>	72	#include <HFActionEvent.h>
70	#include <HFBackEvent.h>	73	#include <HFBackEvent.h>
71	#include <InfoView.h>	74	#include <InfoView.h>
@@ -83,12 +86,14 @@ · 11 unmodified lines
83	#include <PerfStat.h>	86	#include <PerfStat.h>
84	#include <PhysicsEngine.h>	87	#include <PhysicsEngine.h>
85	#include <ProgramObject.h>	88	#include <ProgramObject.h>
		89	#include <RenderDeferredTask.h>
86	#include <ResourceCache.h>	90	#include <ResourceCache.h>
87	#include <SceneScriptingInterface.h>	91	#include <SceneScriptingInterface.h>
88	#include <ScriptCache.h>	92	#include <ScriptCache.h>
89	#include <SettingHandle.h>	93	#include <SettingHandle.h>
90	#include <SoundCache.h>	94	#include <SoundCache.h>
91	#include <TextRenderer.h>	95	#include <TextRenderer.h>
		96	#include <Tooltip.h>
92	#include <UserActivityLogger.h>	97	#include <UserActivityLogger.h>
93	#include <UUID.h>	98	#include <UUID.h>
94	#include <VrMenu.h>	99	#include <VrMenu.h>
@@ -106,11 +111,9 @@ · 11 unmodified lines
106		111
107	#include "avatar/AvatarManager.h"	112	#include "avatar/AvatarManager.h"
108		113
109	#include "audio/AudioToolBox.h"
110	#include "audio/AudioIOStatsRenderer.h"	114	#include "audio/AudioIOStatsRenderer.h"
111	#include "audio/AudioScope.h"	115	#include "audio/AudioScope.h"
112		116
113	#include "devices/CameraToolBox.h"
114	#include "devices/DdeFaceTracker.h"	117	#include "devices/DdeFaceTracker.h"
115	#include "devices/Faceshift.h"	118	#include "devices/Faceshift.h"
116	#include "devices/Leapmotion.h"	119	#include "devices/Leapmotion.h"
@@ -120,12 +123,6 @@ · 3 unmodified lines
120	#include "devices/OculusManager.h"	123	#include "devices/OculusManager.h"
121	#include "devices/TV3DManager.h"	124	#include "devices/TV3DManager.h"
122		125
123	#include "gpu/Batch.h"
124	#include "gpu/Context.h"
125	#include "gpu/GLBackend.h"
126
127	#include "RenderDeferredTask.h"
128
129	#include "scripting/AccountScriptingInterface.h"	126	#include "scripting/AccountScriptingInterface.h"
130	#include "scripting/AudioDeviceScriptingInterface.h"	127	#include "scripting/AudioDeviceScriptingInterface.h"
131	#include "scripting/ClipboardScriptingInterface.h"	128	#include "scripting/ClipboardScriptingInterface.h"
@@ -141,6 +138,7 @@ · 9 unmodified lines
141	#include "SpeechRecognizer.h"	138	#include "SpeechRecognizer.h"
142	#endif	139	#endif
143		140
		141	#include "ui/AvatarInputs.h"
144	#include "ui/DataWebDialog.h"	142	#include "ui/DataWebDialog.h"
145	#include "ui/DialogsManager.h"	143	#include "ui/DialogsManager.h"
146	#include "ui/LoginDialog.h"	144	#include "ui/LoginDialog.h"
@@ -281,8 +279,6 @@ bool setupEssentials(int& argc, char** argv) { · 134 unmodified lines
281	auto animationCache = DependencyManager::set<AnimationCache>();	279	auto animationCache = DependencyManager::set<AnimationCache>();
282	auto ddeFaceTracker = DependencyManager::set<DdeFaceTracker>();	280	auto ddeFaceTracker = DependencyManager::set<DdeFaceTracker>();
283	auto modelBlender = DependencyManager::set<ModelBlender>();	281	auto modelBlender = DependencyManager::set<ModelBlender>();
284	auto audioToolBox = DependencyManager::set<AudioToolBox>();
285	auto cameraToolBox = DependencyManager::set<CameraToolBox>();
286	auto avatarManager = DependencyManager::set<AvatarManager>();	282	auto avatarManager = DependencyManager::set<AvatarManager>();
287	auto lodManager = DependencyManager::set<LODManager>();	283	auto lodManager = DependencyManager::set<LODManager>();
288	auto jsConsole = DependencyManager::set<StandAloneJSConsole>();	284	auto jsConsole = DependencyManager::set<StandAloneJSConsole>();
@@ -335,8 +331,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) : · 46 unmodified lines
335	_cursorVisible(true),	331	_cursorVisible(true),
336	_lastMouseMove(usecTimestampNow()),	332	_lastMouseMove(usecTimestampNow()),
337	_lastMouseMoveWasSimulated(false),	333	_lastMouseMoveWasSimulated(false),
338	_touchAvgX(0.0f),
339	_touchAvgY(0.0f),
340	_isTouchPressed(false),	334	_isTouchPressed(false),
341	_mousePressed(false),	335	_mousePressed(false),
342	_enableProcessOctreeThread(true),	336	_enableProcessOctreeThread(true),
@@ -814,9 +808,9 @@ void Application::initializeGL() { · 471 unmodified lines
814	_idleLoopStdev.reset();	808	_idleLoopStdev.reset();
815		809
816	if (_justStarted) {	810	if (_justStarted) {
817	float startupTime = (float)_applicationStartupTime.elapsed() / 1000.0;	811	float startupTime = (float)_applicationStartupTime.elapsed() / 1000.0f;
818	_justStarted = false;	812	_justStarted = false;
819	qCDebug(interfaceapp, "Startup time: %4.2f seconds.", startupTime);	813	qCDebug(interfaceapp, "Startup time: %4.2f seconds.", (double)startupTime);
820	}	814	}
821		815
822	// update before the first render	816	// update before the first render
@@ -831,6 +825,7 @@ void Application::initializeUi() { · 8 unmodified lines
831	LoginDialog::registerType();	825	LoginDialog::registerType();
832	MessageDialog::registerType();	826	MessageDialog::registerType();
833	VrMenu::registerType();	827	VrMenu::registerType();
		828	Tooltip::registerType();
834	UpdateDialog::registerType();	829	UpdateDialog::registerType();
835		830
836	auto offscreenUi = DependencyManager::get<OffscreenUi>();	831	auto offscreenUi = DependencyManager::get<OffscreenUi>();
@@ -844,7 +839,7 @@ void Application::initializeUi() { · 7 unmodified lines
844	VrMenu::executeQueuedLambdas();	839	VrMenu::executeQueuedLambdas();
845	offscreenUi->setMouseTranslator([this](const QPointF& p){	840	offscreenUi->setMouseTranslator([this](const QPointF& p){
846	if (OculusManager::isConnected()) {	841	if (OculusManager::isConnected()) {
847	glm::vec2 pos = _applicationOverlay.screenToOverlay(toGlm(p));	842	glm::vec2 pos = _compositor.screenToOverlay(toGlm(p));
848	return QPointF(pos.x, pos.y);	843	return QPointF(pos.x, pos.y);
849	}	844	}
850	return QPointF(p);	845	return QPointF(p);
@@ -877,6 +872,7 @@ void Application::paintGL() { · 26 unmodified lines
877	OculusManager::beginFrameTiming();	872	OculusManager::beginFrameTiming();
878	}	873	}
879		874
		875
880	PerformanceWarning::setSuppressShortTimings(Menu::getInstance()->isOptionChecked(MenuOption::SuppressShortTimings));	876	PerformanceWarning::setSuppressShortTimings(Menu::getInstance()->isOptionChecked(MenuOption::SuppressShortTimings));
881	bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);	877	bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
882	PerformanceWarning warn(showWarnings, "Application::paintGL()");	878	PerformanceWarning warn(showWarnings, "Application::paintGL()");
@@ -884,6 +880,12 @@ void Application::paintGL() { · 1 unmodified line
884		880
885	{	881	{
886	PerformanceTimer perfTimer("renderOverlay");	882	PerformanceTimer perfTimer("renderOverlay");
		883	/*
		884	gpu::Context context(new gpu::GLBackend());
		885	RenderArgs renderArgs(&context, nullptr, getViewFrustum(), lodManager->getOctreeSizeScale(),
		886	lodManager->getBoundaryLevelAdjust(), RenderArgs::DEFAULT_RENDER_MODE,
		887	RenderArgs::MONO, RenderArgs::RENDER_DEBUG_NONE);
		888	*/
887	_applicationOverlay.renderOverlay(&renderArgs);	889	_applicationOverlay.renderOverlay(&renderArgs);
888	}	890	}
889		891
@@ -912,13 +914,18 @@ void Application::paintGL() { · 22 unmodified lines
912	}	914	}
913		915
914	} else if (_myCamera.getMode() == CAMERA_MODE_THIRD_PERSON) {	916	} else if (_myCamera.getMode() == CAMERA_MODE_THIRD_PERSON) {
915	_myCamera.setPosition(_myAvatar->getDefaultEyePosition() +
916	_myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, 1.0f) * _myAvatar->getBoomLength() * _myAvatar->getScale());
917	if (OculusManager::isConnected()) {	917	if (OculusManager::isConnected()) {
918	_myCamera.setRotation(_myAvatar->getWorldAlignedOrientation());	918	_myCamera.setRotation(_myAvatar->getWorldAlignedOrientation());
919	} else {	919	} else {
920	_myCamera.setRotation(_myAvatar->getHead()->getOrientation());	920	_myCamera.setRotation(_myAvatar->getHead()->getOrientation());
921	}	921	}
		922	if (Menu::getInstance()->isOptionChecked(MenuOption::CenterPlayerInView)) {
		923	_myCamera.setPosition(_myAvatar->getDefaultEyePosition() +
		924	_myCamera.getRotation() * glm::vec3(0.0f, 0.0f, 1.0f) * _myAvatar->getBoomLength() * _myAvatar->getScale());
		925	} else {
		926	_myCamera.setPosition(_myAvatar->getDefaultEyePosition() +
		927	_myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, 1.0f) * _myAvatar->getBoomLength() * _myAvatar->getScale());
		928	}
922		929
923	} else if (_myCamera.getMode() == CAMERA_MODE_MIRROR) {	930	} else if (_myCamera.getMode() == CAMERA_MODE_MIRROR) {
924	_myCamera.setRotation(_myAvatar->getWorldAlignedOrientation() * glm::quat(glm::vec3(0.0f, PI + _rotateMirror, 0.0f)));	931	_myCamera.setRotation(_myAvatar->getWorldAlignedOrientation() * glm::quat(glm::vec3(0.0f, PI + _rotateMirror, 0.0f)));
@@ -967,9 +974,7 @@ void Application::paintGL() { · 42 unmodified lines
967	glPopMatrix();	974	glPopMatrix();
968		975
969	renderArgs._renderMode = RenderArgs::MIRROR_RENDER_MODE;	976	renderArgs._renderMode = RenderArgs::MIRROR_RENDER_MODE;
970	if (Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror)) {	977	if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
971	_rearMirrorTools->render(&renderArgs, true, _glWidget->mapFromGlobal(QCursor::pos()));
972	} else if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
973	renderRearViewMirror(&renderArgs, _mirrorViewRect);	978	renderRearViewMirror(&renderArgs, _mirrorViewRect);
974	}	979	}
975		980
@@ -977,6 +982,7 @@ void Application::paintGL() { · 1 unmodified line
977		982
978	auto finalFbo = DependencyManager::get<GlowEffect>()->render(&renderArgs);	983	auto finalFbo = DependencyManager::get<GlowEffect>()->render(&renderArgs);
979		984
		985
980	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);	986	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
981	glBindFramebuffer(GL_READ_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(finalFbo));	987	glBindFramebuffer(GL_READ_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(finalFbo));
982	glBlitFramebuffer(0, 0, _renderResolution.x, _renderResolution.y,	988	glBlitFramebuffer(0, 0, _renderResolution.x, _renderResolution.y,
@@ -984,9 +990,10 @@ void Application::paintGL() { · 1 unmodified line
984	GL_COLOR_BUFFER_BIT, GL_NEAREST);	990	GL_COLOR_BUFFER_BIT, GL_NEAREST);
985	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);	991	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
986		992
987	_applicationOverlay.displayOverlayTexture();	993	_compositor.displayOverlayTexture(&renderArgs);
988	}	994	}
989		995
		996
990	if (!OculusManager::isConnected() \|\| OculusManager::allowSwap()) {	997	if (!OculusManager::isConnected() \|\| OculusManager::allowSwap()) {
991	_glWidget->swapBuffers();	998	_glWidget->swapBuffers();
992	}	999	}
@@ -1044,27 +1051,24 @@ void Application::resizeGL() { · 51 unmodified lines
1044	} else {	1051	} else {
1045	renderSize = _glWidget->getDeviceSize() * getRenderResolutionScale();	1052	renderSize = _glWidget->getDeviceSize() * getRenderResolutionScale();
1046	}	1053	}
1047	if (_renderResolution == toGlm(renderSize)) {
1048	return;
1049	}
1050		1054
1051	_renderResolution = toGlm(renderSize);	1055	if (_renderResolution != toGlm(renderSize)) {
1052	DependencyManager::get<TextureCache>()->setFrameBufferSize(renderSize);	1056	_renderResolution = toGlm(renderSize);
1053	resetCamerasOnResizeGL(_myCamera, _renderResolution);	1057	DependencyManager::get<TextureCache>()->setFrameBufferSize(renderSize);
		1058	resetCamerasOnResizeGL(_myCamera, _renderResolution);
1054		1059
1055	glViewport(0, 0, _renderResolution.x, _renderResolution.y); // shouldn't this account for the menu???	1060	glViewport(0, 0, _renderResolution.x, _renderResolution.y); // shouldn't this account for the menu???
1056		1061
1057	updateProjectionMatrix();	1062	updateProjectionMatrix();
1058	glLoadIdentity();	1063	glLoadIdentity();
		1064	}
1059		1065
1060	auto offscreenUi = DependencyManager::get<OffscreenUi>();	1066	auto offscreenUi = DependencyManager::get<OffscreenUi>();
1061	offscreenUi->resize(_glWidget->size());	1067
		1068	auto canvasSize = _glWidget->size();
		1069	offscreenUi->resize(canvasSize);
1062	_glWidget->makeCurrent();	1070	_glWidget->makeCurrent();
1063		1071
1064	// update Stats width
1065	// let's set horizontal offset to give stats some margin to mirror
1066	int horizontalOffset = MIRROR_VIEW_WIDTH + MIRROR_VIEW_LEFT_PADDING * 2;
1067	Stats::getInstance()->resetWidth(_renderResolution.x, horizontalOffset);
1068	}	1072	}
1069		1073
1070	void Application::updateProjectionMatrix() {	1074	void Application::updateProjectionMatrix() {
@@ -1568,27 +1572,9 @@ void Application::mousePressEvent(QMouseEvent* event, unsigned int deviceID) { · 497 unmodified lines
1568	_keyboardMouseDevice.mousePressEvent(event);	1572	_keyboardMouseDevice.mousePressEvent(event);
1569		1573
1570	if (event->button() == Qt::LeftButton) {	1574	if (event->button() == Qt::LeftButton) {
1571	_mouseDragStartedX = getTrueMouseX();	1575	_mouseDragStarted = getTrueMouse();
1572	_mouseDragStartedY = getTrueMouseY();
1573	_mousePressed = true;	1576	_mousePressed = true;
1574		1577
1575	if (mouseOnScreen()) {
1576	if (DependencyManager::get<AudioToolBox>()->mousePressEvent(getMouseX(), getMouseY())) {
1577	// stop propagation
1578	return;
1579	}
1580
1581	if (DependencyManager::get<CameraToolBox>()->mousePressEvent(getMouseX(), getMouseY())) {
1582	// stop propagation
1583	return;
1584	}
1585
1586	if (_rearMirrorTools->mousePressEvent(getMouseX(), getMouseY())) {
1587	// stop propagation
1588	return;
1589	}
1590	}
1591
1592	// nobody handled this - make it an action event on the _window object	1578	// nobody handled this - make it an action event on the _window object
1593	HFActionEvent actionEvent(HFActionEvent::startType(),	1579	HFActionEvent actionEvent(HFActionEvent::startType(),
1594	computePickRay(event->x(), event->y()));	1580	computePickRay(event->x(), event->y()));
@@ -1606,16 +1592,7 @@ void Application::mouseDoublePressEvent(QMouseEvent* event, unsigned int deviceI · 11 unmodified lines
1606	return;	1592	return;
1607	}	1593	}
1608		1594
1609	if (activeWindow() == _window) {	1595	_controllerScriptingInterface.emitMouseDoublePressEvent(event);
1610	if (event->button() == Qt::LeftButton) {
1611	if (mouseOnScreen()) {
1612	if (DependencyManager::get<CameraToolBox>()->mouseDoublePressEvent(getMouseX(), getMouseY())) {
1613	// stop propagation
1614	return;
1615	}
1616	}
1617	}
1618	}
1619	}	1596	}
1620		1597
1621	void Application::mouseReleaseEvent(QMouseEvent* event, unsigned int deviceID) {	1598	void Application::mouseReleaseEvent(QMouseEvent* event, unsigned int deviceID) {
@@ -1637,13 +1614,6 @@ void Application::mouseReleaseEvent(QMouseEvent* event, unsigned int deviceID) { · 15 unmodified lines
1637	if (event->button() == Qt::LeftButton) {	1614	if (event->button() == Qt::LeftButton) {
1638	_mousePressed = false;	1615	_mousePressed = false;
1639		1616
1640	if (Menu::getInstance()->isOptionChecked(MenuOption::Stats) && mouseOnScreen()) {
1641	// let's set horizontal offset to give stats some margin to mirror
1642	int horizontalOffset = MIRROR_VIEW_WIDTH;
1643	Stats::getInstance()->checkClick(getMouseX(), getMouseY(),
1644	getMouseDragStartedX(), getMouseDragStartedY(), horizontalOffset);
1645	}
1646
1647	// fire an action end event	1617	// fire an action end event
1648	HFActionEvent actionEvent(HFActionEvent::endType(),	1618	HFActionEvent actionEvent(HFActionEvent::endType(),
1649	computePickRay(event->x(), event->y()));	1619	computePickRay(event->x(), event->y()));
@@ -1671,22 +1641,18 @@ void Application::touchUpdateEvent(QTouchEvent* event) { · 21 unmodified lines
1671	bool validTouch = false;	1641	bool validTouch = false;
1672	if (activeWindow() == _window) {	1642	if (activeWindow() == _window) {
1673	const QList<QTouchEvent::TouchPoint>& tPoints = event->touchPoints();	1643	const QList<QTouchEvent::TouchPoint>& tPoints = event->touchPoints();
1674	_touchAvgX = 0.0f;	1644	_touchAvg = vec2();
1675	_touchAvgY = 0.0f;
1676	int numTouches = tPoints.count();	1645	int numTouches = tPoints.count();
1677	if (numTouches > 1) {	1646	if (numTouches > 1) {
1678	for (int i = 0; i < numTouches; ++i) {	1647	for (int i = 0; i < numTouches; ++i) {
1679	_touchAvgX += tPoints[i].pos().x();	1648	_touchAvg += toGlm(tPoints[i].pos());
1680	_touchAvgY += tPoints[i].pos().y();
1681	}	1649	}
1682	_touchAvgX /= (float)(numTouches);	1650	_touchAvg /= (float)(numTouches);
1683	_touchAvgY /= (float)(numTouches);
1684	validTouch = true;	1651	validTouch = true;
1685	}	1652	}
1686	}	1653	}
1687	if (!_isTouchPressed) {	1654	if (!_isTouchPressed) {
1688	_touchDragStartedAvgX = _touchAvgX;	1655	_touchDragStartedAvg = _touchAvg;
1689	_touchDragStartedAvgY = _touchAvgY;
1690	}	1656	}
1691	_isTouchPressed = validTouch;	1657	_isTouchPressed = validTouch;
1692	}	1658	}
@@ -1722,8 +1688,7 @@ void Application::touchEndEvent(QTouchEvent* event) { · 29 unmodified lines
1722	_keyboardMouseDevice.touchEndEvent(event);	1688	_keyboardMouseDevice.touchEndEvent(event);
1723		1689
1724	// put any application specific touch behavior below here..	1690	// put any application specific touch behavior below here..
1725	_touchDragStartedAvgX = _touchAvgX;	1691	_touchDragStartedAvg = _touchAvg;
1726	_touchDragStartedAvgY = _touchAvgY;
1727	_isTouchPressed = false;	1692	_isTouchPressed = false;
1728		1693
1729	}	1694	}
@@ -1872,9 +1837,9 @@ void Application::setFullscreen(bool fullscreen) { · 142 unmodified lines
1872	Menu::getInstance()->getActionForOption(MenuOption::Fullscreen)->setChecked(fullscreen);	1837	Menu::getInstance()->getActionForOption(MenuOption::Fullscreen)->setChecked(fullscreen);
1873	}	1838	}
1874		1839
1875	// The following code block is useful on platforms that can have a visible	1840	// The following code block is useful on platforms that can have a visible
1876	// app menu in a fullscreen window. However the OSX mechanism hides the	1841	// app menu in a fullscreen window. However the OSX mechanism hides the
1877	// application menu for fullscreen apps, so the check is not required.	1842	// application menu for fullscreen apps, so the check is not required.
1878	#ifndef Q_OS_MAC	1843	#ifndef Q_OS_MAC
1879	if (Menu::getInstance()->isOptionChecked(MenuOption::EnableVRMode)) {	1844	if (Menu::getInstance()->isOptionChecked(MenuOption::EnableVRMode)) {
1880	if (fullscreen) {	1845	if (fullscreen) {
@@ -1939,16 +1904,15 @@ void Application::setEnableVRMode(bool enableVRMode) { · 58 unmodified lines
1939	// attempt to reconnect the Oculus manager - it's possible this was a workaround	1904	// attempt to reconnect the Oculus manager - it's possible this was a workaround
1940	// for the sixense crash	1905	// for the sixense crash
1941	OculusManager::disconnect();	1906	OculusManager::disconnect();
1942	OculusManager::connect();	1907	OculusManager::connect(_glWidget->context()->contextHandle());
		1908	_glWidget->setFocus();
		1909	_glWidget->makeCurrent();
		1910	glClear(GL_COLOR_BUFFER_BIT);
1943	}	1911	}
1944	OculusManager::recalibrate();	1912	OculusManager::recalibrate();
1945	} else {	1913	} else {
1946	OculusManager::abandonCalibration();	1914	OculusManager::abandonCalibration();
1947		1915	OculusManager::disconnect();
1948	_mirrorCamera.setHmdPosition(glm::vec3());
1949	_mirrorCamera.setHmdRotation(glm::quat());
1950	_myCamera.setHmdPosition(glm::vec3());
1951	_myCamera.setHmdRotation(glm::quat());
1952	}	1916	}
1953		1917
1954	resizeGL();	1918	resizeGL();
@@ -1960,44 +1924,34 @@ void Application::setLowVelocityFilter(bool lowVelocityFilter) { · 5 unmodified lines
1960		1924
1961	bool Application::mouseOnScreen() const {	1925	bool Application::mouseOnScreen() const {
1962	if (OculusManager::isConnected()) {	1926	if (OculusManager::isConnected()) {
1963	return getMouseX() >= 0 && getMouseX() <= _glWidget->getDeviceWidth() &&	1927	ivec2 mouse = getMouse();
1964	getMouseY() >= 0 && getMouseY() <= _glWidget->getDeviceHeight();	1928	if (!glm::all(glm::greaterThanEqual(mouse, ivec2()))) {
		1929	return false;
		1930	}
		1931	ivec2 size = toGlm(_glWidget->getDeviceSize());
		1932	if (!glm::all(glm::lessThanEqual(mouse, size))) {
		1933	return false;
		1934	}
1965	}	1935	}
1966	return true;	1936	return true;
1967	}	1937	}
1968		1938
1969	int Application::getMouseX() const {	1939	ivec2 Application::getMouse() const {
1970	if (OculusManager::isConnected()) {
1971	glm::vec2 pos = _applicationOverlay.screenToOverlay(glm::vec2(getTrueMouseX(), getTrueMouseY()));
1972	return pos.x;
1973	}
1974	return getTrueMouseX();
1975	}
1976
1977	int Application::getMouseY() const {
1978	if (OculusManager::isConnected()) {	1940	if (OculusManager::isConnected()) {
1979	glm::vec2 pos = _applicationOverlay.screenToOverlay(glm::vec2(getTrueMouseX(), getTrueMouseY()));	1941	return _compositor.screenToOverlay(getTrueMouse());
1980	return pos.y;
1981	}	1942	}
1982	return getTrueMouseY();	1943	return getTrueMouse();
1983	}	1944	}
1984		1945
1985	int Application::getMouseDragStartedX() const {	1946	ivec2 Application::getMouseDragStarted() const {
1986	if (OculusManager::isConnected()) {	1947	if (OculusManager::isConnected()) {
1987	glm::vec2 pos = _applicationOverlay.screenToOverlay(glm::vec2(getTrueMouseDragStartedX(),	1948	return _compositor.screenToOverlay(getTrueMouseDragStarted());
1988	getTrueMouseDragStartedY()));
1989	return pos.x;
1990	}	1949	}
1991	return getTrueMouseDragStartedX();	1950	return getTrueMouseDragStarted();
1992	}	1951	}
1993		1952
1994	int Application::getMouseDragStartedY() const {	1953	ivec2 Application::getTrueMouseDragStarted() const {
1995	if (OculusManager::isConnected()) {	1954	return _mouseDragStarted;
1996	glm::vec2 pos = _applicationOverlay.screenToOverlay(glm::vec2(getTrueMouseDragStartedX(),
1997	getTrueMouseDragStartedY()));
1998	return pos.y;
1999	}
2000	return getTrueMouseDragStartedY();
2001	}	1955	}
2002		1956
2003	FaceTracker* Application::getActiveFaceTracker() {	1957	FaceTracker* Application::getActiveFaceTracker() {
@@ -2179,13 +2133,6 @@ void Application::init() { · 175 unmodified lines
2179		2133
2180	_mirrorCamera.setMode(CAMERA_MODE_MIRROR);	2134	_mirrorCamera.setMode(CAMERA_MODE_MIRROR);
2181		2135
2182	OculusManager::connect();
2183	if (OculusManager::isConnected()) {
2184	QMetaObject::invokeMethod(Menu::getInstance()->getActionForOption(MenuOption::Fullscreen),
2185	"trigger",
2186	Qt::QueuedConnection);
2187	}
2188
2189	TV3DManager::connect();	2136	TV3DManager::connect();
2190	if (TV3DManager::isConnected()) {	2137	if (TV3DManager::isConnected()) {
2191	QMetaObject::invokeMethod(Menu::getInstance()->getActionForOption(MenuOption::Fullscreen),	2138	QMetaObject::invokeMethod(Menu::getInstance()->getActionForOption(MenuOption::Fullscreen),
@@ -2249,13 +2196,6 @@ void Application::init() { · 57 unmodified lines
2249	_entityClipboardRenderer.setViewFrustum(getViewFrustum());	2196	_entityClipboardRenderer.setViewFrustum(getViewFrustum());
2250	_entityClipboardRenderer.setTree(&_entityClipboard);	2197	_entityClipboardRenderer.setTree(&_entityClipboard);
2251		2198
2252	_rearMirrorTools = new RearMirrorTools(_mirrorViewRect);
2253
2254	connect(_rearMirrorTools, SIGNAL(closeView()), SLOT(closeMirrorView()));
2255	connect(_rearMirrorTools, SIGNAL(restoreView()), SLOT(restoreMirrorView()));
2256	connect(_rearMirrorTools, SIGNAL(shrinkView()), SLOT(shrinkMirrorView()));
2257	connect(_rearMirrorTools, SIGNAL(resetView()), SLOT(resetSensors()));
2258
2259	// initialize the GlowEffect with our widget	2199	// initialize the GlowEffect with our widget
2260	bool glow = Menu::getInstance()->isOptionChecked(MenuOption::EnableGlowEffect);	2200	bool glow = Menu::getInstance()->isOptionChecked(MenuOption::EnableGlowEffect);
2261	DependencyManager::get<GlowEffect>()->init(glow);	2201	DependencyManager::get<GlowEffect>()->init(glow);
@@ -2434,6 +2374,12 @@ void Application::cameraMenuChanged() { · 172 unmodified lines
2434	}	2374	}
2435	}	2375	}
2436		2376
		2377	void Application::rotationModeChanged() {
		2378	if (!Menu::getInstance()->isOptionChecked(MenuOption::CenterPlayerInView)) {
		2379	_myAvatar->setHeadPitch(0);
		2380	}
		2381	}
		2382
2437	void Application::updateCamera(float deltaTime) {	2383	void Application::updateCamera(float deltaTime) {
2438	PerformanceTimer perfTimer("updateCamera");	2384	PerformanceTimer perfTimer("updateCamera");
2439	bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);	2385	bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
@@ -3155,7 +3101,7 @@ PickRay Application::computePickRay(float x, float y) const { · 715 unmodified lines
3155	y /= size.y;	3101	y /= size.y;
3156	PickRay result;	3102	PickRay result;
3157	if (isHMDMode()) {	3103	if (isHMDMode()) {
3158	getApplicationOverlay().computeHmdPickRay(glm::vec2(x, y), result.origin, result.direction);	3104	getApplicationCompositor().computeHmdPickRay(glm::vec2(x, y), result.origin, result.direction);
3159	} else {	3105	} else {
3160	if (QThread::currentThread() == activeRenderingThread) {	3106	if (QThread::currentThread() == activeRenderingThread) {
3161	getDisplayViewFrustum()->computePickRay(x, y, result.origin, result.direction);	3107	getDisplayViewFrustum()->computePickRay(x, y, result.origin, result.direction);
@@ -3184,13 +3130,11 @@ QImage Application::renderAvatarBillboard(RenderArgs* renderArgs) { · 22 unmodified lines
3184	renderRearViewMirror(renderArgs, QRect(0, _glWidget->getDeviceHeight() - BILLBOARD_SIZE,	3130	renderRearViewMirror(renderArgs, QRect(0, _glWidget->getDeviceHeight() - BILLBOARD_SIZE,
3185	BILLBOARD_SIZE, BILLBOARD_SIZE),	3131	BILLBOARD_SIZE, BILLBOARD_SIZE),
3186	true);	3132	true);
3187
3188	QImage image(BILLBOARD_SIZE, BILLBOARD_SIZE, QImage::Format_ARGB32);	3133	QImage image(BILLBOARD_SIZE, BILLBOARD_SIZE, QImage::Format_ARGB32);
3189	glReadPixels(0, 0, BILLBOARD_SIZE, BILLBOARD_SIZE, GL_BGRA, GL_UNSIGNED_BYTE, image.bits());	3134	glReadPixels(0, 0, BILLBOARD_SIZE, BILLBOARD_SIZE, GL_BGRA, GL_UNSIGNED_BYTE, image.bits());
3190	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);	3135	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
3191		3136
3192	glBindFramebuffer(GL_FRAMEBUFFER, 0);	3137	glBindFramebuffer(GL_FRAMEBUFFER, 0);
3193
3194	return image;	3138	return image;
3195	}	3139	}
3196		3140
@@ -3386,9 +3330,8 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se · 189 unmodified lines
3386		3330
3387	// flip x if in mirror mode (also requires reversing winding order for backface culling)	3331	// flip x if in mirror mode (also requires reversing winding order for backface culling)
3388	if (theCamera.getMode() == CAMERA_MODE_MIRROR) {	3332	if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
3389	glScalef(-1.0f, 1.0f, 1.0f);	3333	//glScalef(-1.0f, 1.0f, 1.0f);
3390	glFrontFace(GL_CW);	3334	//glFrontFace(GL_CW);
3391
3392	} else {	3335	} else {
3393	glFrontFace(GL_CCW);	3336	glFrontFace(GL_CCW);
3394	}	3337	}
@@ -3411,7 +3354,7 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se · 16 unmodified lines
3411	viewTransform.setTranslation(theCamera.getPosition());	3354	viewTransform.setTranslation(theCamera.getPosition());
3412	viewTransform.setRotation(rotation);	3355	viewTransform.setRotation(rotation);
3413	if (theCamera.getMode() == CAMERA_MODE_MIRROR) {	3356	if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
3414	viewTransform.setScale(Transform::Vec3(-1.0f, 1.0f, 1.0f));	3357	// viewTransform.setScale(Transform::Vec3(-1.0f, 1.0f, 1.0f));
3415	}	3358	}
3416	if (renderArgs->_renderSide != RenderArgs::MONO) {	3359	if (renderArgs->_renderSide != RenderArgs::MONO) {
3417	glm::mat4 invView = glm::inverse(_untranslatedViewMatrix);	3360	glm::mat4 invView = glm::inverse(_untranslatedViewMatrix);
@@ -3548,6 +3491,7 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se · 130 unmodified lines
3548		3491
3549	renderContext._maxDrawnOpaqueItems = sceneInterface->getEngineMaxDrawnOpaqueItems();	3492	renderContext._maxDrawnOpaqueItems = sceneInterface->getEngineMaxDrawnOpaqueItems();
3550	renderContext._maxDrawnTransparentItems = sceneInterface->getEngineMaxDrawnTransparentItems();	3493	renderContext._maxDrawnTransparentItems = sceneInterface->getEngineMaxDrawnTransparentItems();
		3494	renderContext._maxDrawnOverlay3DItems = sceneInterface->getEngineMaxDrawnOverlay3DItems();
3551		3495
3552	renderArgs->_shouldRender = LODManager::shouldRender;	3496	renderArgs->_shouldRender = LODManager::shouldRender;
3553		3497
@@ -3564,7 +3508,9 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se · 10 unmodified lines
3564		3508
3565	sceneInterface->setEngineFeedTransparentItems(engineRC->_numFeedTransparentItems);	3509	sceneInterface->setEngineFeedTransparentItems(engineRC->_numFeedTransparentItems);
3566	sceneInterface->setEngineDrawnTransparentItems(engineRC->_numDrawnTransparentItems);	3510	sceneInterface->setEngineDrawnTransparentItems(engineRC->_numDrawnTransparentItems);
3567		3511
		3512	sceneInterface->setEngineFeedOverlay3DItems(engineRC->_numFeedOverlay3DItems);
		3513	sceneInterface->setEngineDrawnOverlay3DItems(engineRC->_numDrawnOverlay3DItems);
3568	}	3514	}
3569	//Render the sixense lasers	3515	//Render the sixense lasers
3570	if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseLasers)) {	3516	if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseLasers)) {
@@ -3672,8 +3618,8 @@ glm::vec2 Application::getScaledScreenPoint(glm::vec2 projectedPoint) { · 101 unmodified lines
3672	// +-----------------------+	3618	// +-----------------------+
3673	// -1,-1 1,-1	3619	// -1,-1 1,-1
3674		3620
3675	glm::vec2 screenPoint((projectedPoint.x + 1.0) * horizontalScale,	3621	glm::vec2 screenPoint((projectedPoint.x + 1.0f) * horizontalScale,
3676	((projectedPoint.y + 1.0) * -verticalScale) + _glWidget->getDeviceHeight());	3622	((projectedPoint.y + 1.0f) * -verticalScale) + _glWidget->getDeviceHeight());
3677		3623
3678	return screenPoint;	3624	return screenPoint;
3679	}	3625	}
@@ -3691,7 +3637,7 @@ void Application::renderRearViewMirror(RenderArgs* renderArgs, const QRect& regi · 11 unmodified lines
3691	_mirrorCamera.setPosition(_myAvatar->getPosition() +	3637	_mirrorCamera.setPosition(_myAvatar->getPosition() +
3692	_myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, -1.0f) * BILLBOARD_DISTANCE * _myAvatar->getScale());	3638	_myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, -1.0f) * BILLBOARD_DISTANCE * _myAvatar->getScale());
3693		3639
3694	} else if (RearMirrorTools::rearViewZoomLevel.get() == BODY) {	3640	} else if (!AvatarInputs::getInstance()->mirrorZoomed()) {
3695	_mirrorCamera.setPosition(_myAvatar->getChestPosition() +	3641	_mirrorCamera.setPosition(_myAvatar->getChestPosition() +
3696	_myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, -1.0f) * MIRROR_REARVIEW_BODY_DISTANCE * _myAvatar->getScale());	3642	_myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, -1.0f) * MIRROR_REARVIEW_BODY_DISTANCE * _myAvatar->getScale());
3697		3643
@@ -3726,7 +3672,7 @@ void Application::renderRearViewMirror(RenderArgs* renderArgs, const QRect& regi · 28 unmodified lines
3726	} else {	3672	} else {
3727	// if not rendering the billboard, the region is in device independent coordinates; must convert to device	3673	// if not rendering the billboard, the region is in device independent coordinates; must convert to device
3728	QSize size = DependencyManager::get<TextureCache>()->getFrameBufferSize();	3674	QSize size = DependencyManager::get<TextureCache>()->getFrameBufferSize();
3729	float ratio = QApplication::desktop()->windowHandle()->devicePixelRatio() * getRenderResolutionScale();	3675	float ratio = (float)QApplication::desktop()->windowHandle()->devicePixelRatio() * getRenderResolutionScale();
3730	int x = region.x() * ratio, y = region.y() * ratio, width = region.width() * ratio, height = region.height() * ratio;	3676	int x = region.x() * ratio, y = region.y() * ratio, width = region.width() * ratio, height = region.height() * ratio;
3731	glViewport(x, size.height() - y - height, width, height);	3677	glViewport(x, size.height() - y - height, width, height);
3732	glScissor(x, size.height() - y - height, width, height);	3678	glScissor(x, size.height() - y - height, width, height);
@@ -3741,10 +3687,6 @@ void Application::renderRearViewMirror(RenderArgs* renderArgs, const QRect& regi · 8 unmodified lines
3741	displaySide(renderArgs, _mirrorCamera, true, billboard);	3687	displaySide(renderArgs, _mirrorCamera, true, billboard);
3742	glPopMatrix();	3688	glPopMatrix();
3743		3689
3744	if (!billboard) {
3745	_rearMirrorTools->render(renderArgs, false, _glWidget->mapFromGlobal(QCursor::pos()));
3746	}
3747
3748	// reset Viewport and projection matrix	3690	// reset Viewport and projection matrix
3749	glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);	3691	glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
3750	glDisable(GL_SCISSOR_TEST);	3692	glDisable(GL_SCISSOR_TEST);
@@ -3884,7 +3826,7 @@ void Application::nodeKilled(SharedNodePointer node) { · 133 unmodified lines
3884	_entityServerJurisdictions.unlock();	3826	_entityServerJurisdictions.unlock();
3885		3827
3886	qCDebug(interfaceapp, "model server going away...... v[%f, %f, %f, %f]",	3828	qCDebug(interfaceapp, "model server going away...... v[%f, %f, %f, %f]",
3887	rootDetails.x, rootDetails.y, rootDetails.z, rootDetails.s);	3829	(double)rootDetails.x, (double)rootDetails.y, (double)rootDetails.z, (double)rootDetails.s);
3888		3830
3889	// Add the jurisditionDetails object to the list of "fade outs"	3831	// Add the jurisditionDetails object to the list of "fade outs"
3890	if (!Menu::getInstance()->isOptionChecked(MenuOption::DontFadeOnOctreeServerChanges)) {	3832	if (!Menu::getInstance()->isOptionChecked(MenuOption::DontFadeOnOctreeServerChanges)) {
@@ -3970,7 +3912,8 @@ int Application::parseOctreeStats(const QByteArray& packet, const SharedNodePoin · 79 unmodified lines
3970	jurisdiction->unlock();	3912	jurisdiction->unlock();
3971		3913
3972	qCDebug(interfaceapp, "stats from new %s server... [%f, %f, %f, %f]",	3914	qCDebug(interfaceapp, "stats from new %s server... [%f, %f, %f, %f]",
3973	qPrintable(serverType), rootDetails.x, rootDetails.y, rootDetails.z, rootDetails.s);	3915	qPrintable(serverType),
		3916	(double)rootDetails.x, (double)rootDetails.y, (double)rootDetails.z, (double)rootDetails.s);
3974		3917
3975	// Add the jurisditionDetails object to the list of "fade outs"	3918	// Add the jurisditionDetails object to the list of "fade outs"
3976	if (!Menu::getInstance()->isOptionChecked(MenuOption::DontFadeOnOctreeServerChanges)) {	3919	if (!Menu::getInstance()->isOptionChecked(MenuOption::DontFadeOnOctreeServerChanges)) {
@@ -4750,11 +4693,9 @@ void Application::postLambdaEvent(std::function<void()> f) { · 773 unmodified lines
4750	}	4693	}
4751		4694
4752	void Application::initPlugins() {	4695	void Application::initPlugins() {
4753	OculusManager::init();
4754	}	4696	}
4755		4697
4756	void Application::shutdownPlugins() {	4698	void Application::shutdownPlugins() {
4757	OculusManager::deinit();
4758	}	4699	}
4759		4700
4760	glm::vec3 Application::getHeadPosition() const {	4701	glm::vec3 Application::getHeadPosition() const {
@@ -4774,12 +4715,8 @@ QSize Application::getDeviceSize() const { · 13 unmodified lines
4774	return _glWidget->getDeviceSize();	4715	return _glWidget->getDeviceSize();
4775	}	4716	}
4776		4717
4777	int Application::getTrueMouseX() const {	4718	ivec2 Application::getTrueMouse() const {
4778	return _glWidget->mapFromGlobal(QCursor::pos()).x();	4719	return toGlm(_glWidget->mapFromGlobal(QCursor::pos()));
4779	}
4780
4781	int Application::getTrueMouseY() const {
4782	return _glWidget->mapFromGlobal(QCursor::pos()).y();
4783	}	4720	}
4784		4721
4785	bool Application::isThrottleRendering() const {	4722	bool Application::isThrottleRendering() const {
@@ -4809,3 +4746,25 @@ qreal Application::getDevicePixelRatio() { · 23 unmodified lines
4809	return _window ? _window->windowHandle()->devicePixelRatio() : 1.0;	4746	return _window ? _window->windowHandle()->devicePixelRatio() : 1.0;
4810	}	4747	}
4811		4748
		4749	mat4 Application::getEyeProjection(int eye) const {
		4750	if (isHMDMode()) {
		4751	return OculusManager::getEyeProjection(eye);
		4752	}
		4753
		4754	return _viewFrustum.getProjection();
		4755	}
		4756
		4757	mat4 Application::getEyePose(int eye) const {
		4758	if (isHMDMode()) {
		4759	return OculusManager::getEyePose(eye);
		4760	}
		4761
		4762	return mat4();
		4763	}
		4764
		4765	mat4 Application::getHeadPose() const {
		4766	if (isHMDMode()) {
		4767	return OculusManager::getHeadPose();
		4768	}
		4769	return mat4();
		4770	}

interface/src/Application.h+37−28

@@ -62,12 +62,12 @@ · 61 unmodified lines
62	#include "ui/ModelsBrowser.h"	62	#include "ui/ModelsBrowser.h"
63	#include "ui/NodeBounds.h"	63	#include "ui/NodeBounds.h"
64	#include "ui/OctreeStatsDialog.h"	64	#include "ui/OctreeStatsDialog.h"
65	#include "ui/RearMirrorTools.h"
66	#include "ui/SnapshotShareDialog.h"	65	#include "ui/SnapshotShareDialog.h"
67	#include "ui/LodToolsDialog.h"	66	#include "ui/LodToolsDialog.h"
68	#include "ui/LogDialog.h"	67	#include "ui/LogDialog.h"
69	#include "ui/overlays/Overlays.h"	68	#include "ui/overlays/Overlays.h"
70	#include "ui/ApplicationOverlay.h"	69	#include "ui/ApplicationOverlay.h"
		70	#include "ui/ApplicationCompositor.h"
71	#include "ui/RunningScriptsWidget.h"	71	#include "ui/RunningScriptsWidget.h"
72	#include "ui/ToolWindow.h"	72	#include "ui/ToolWindow.h"
73	#include "ui/UserInputMapper.h"	73	#include "ui/UserInputMapper.h"
@@ -221,15 +221,21 @@ public: · 147 unmodified lines
221	const glm::vec3& getMouseRayOrigin() const { return _mouseRayOrigin; }	221	const glm::vec3& getMouseRayOrigin() const { return _mouseRayOrigin; }
222	const glm::vec3& getMouseRayDirection() const { return _mouseRayDirection; }	222	const glm::vec3& getMouseRayDirection() const { return _mouseRayDirection; }
223	bool mouseOnScreen() const;	223	bool mouseOnScreen() const;
224	int getMouseX() const;	224
225	int getMouseY() const;	225	ivec2 getMouse() const;
226	glm::ivec2 getTrueMousePosition() const;	226	ivec2 getTrueMouse() const;
227	int getTrueMouseX() const;	227	ivec2 getMouseDragStarted() const;
228	int getTrueMouseY() const;	228	ivec2 getTrueMouseDragStarted() const;
229	int getMouseDragStartedX() const;	229
230	int getMouseDragStartedY() const;	230	// TODO get rid of these and use glm types directly
231	int getTrueMouseDragStartedX() const { return _mouseDragStartedX; }	231	int getMouseX() const { return getMouse().x; }
232	int getTrueMouseDragStartedY() const { return _mouseDragStartedY; }	232	int getMouseY() const { return getMouse().y; }
		233	int getTrueMouseX() const { return getTrueMouse().x; }
		234	int getTrueMouseY() const { return getTrueMouse().y; }
		235	int getMouseDragStartedX() const { return getMouseDragStarted().x; }
		236	int getMouseDragStartedY() const { return getMouseDragStarted().y; }
		237	int getTrueMouseDragStartedX() const { return getTrueMouseDragStarted().x; }
		238	int getTrueMouseDragStartedY() const { return getTrueMouseDragStarted().y; }
233	bool getLastMouseMoveWasSimulated() const { return _lastMouseMoveWasSimulated; }	239	bool getLastMouseMoveWasSimulated() const { return _lastMouseMoveWasSimulated; }
234		240
235	FaceTracker* getActiveFaceTracker();	241	FaceTracker* getActiveFaceTracker();
@@ -238,6 +244,8 @@ public: · 2 unmodified lines
238	QSystemTrayIcon* getTrayIcon() { return _trayIcon; }	244	QSystemTrayIcon* getTrayIcon() { return _trayIcon; }
239	ApplicationOverlay& getApplicationOverlay() { return _applicationOverlay; }	245	ApplicationOverlay& getApplicationOverlay() { return _applicationOverlay; }
240	const ApplicationOverlay& getApplicationOverlay() const { return _applicationOverlay; }	246	const ApplicationOverlay& getApplicationOverlay() const { return _applicationOverlay; }
		247	ApplicationCompositor& getApplicationCompositor() { return _compositor; }
		248	const ApplicationCompositor& getApplicationCompositor() const { return _compositor; }
241	Overlays& getOverlays() { return _overlays; }	249	Overlays& getOverlays() { return _overlays; }
242		250
243	float getFps() const { return _fps; }	251	float getFps() const { return _fps; }
@@ -330,6 +338,9 @@ public: · 86 unmodified lines
330	bool isHMDMode() const;	338	bool isHMDMode() const;
331	glm::quat getHeadOrientation() const;	339	glm::quat getHeadOrientation() const;
332	glm::vec3 getHeadPosition() const;	340	glm::vec3 getHeadPosition() const;
		341	glm::mat4 getHeadPose() const;
		342	glm::mat4 getEyePose(int eye) const;
		343	glm::mat4 getEyeProjection(int eye) const;
333		344
334	QRect getDesirableApplicationGeometry();	345	QRect getDesirableApplicationGeometry();
335	RunningScriptsWidget* getRunningScriptsWidget() { return _runningScriptsWidget; }	346	RunningScriptsWidget* getRunningScriptsWidget() { return _runningScriptsWidget; }
@@ -451,6 +462,8 @@ private slots: · 115 unmodified lines
451	void setFullscreen(bool fullscreen);	462	void setFullscreen(bool fullscreen);
452	void setEnable3DTVMode(bool enable3DTVMode);	463	void setEnable3DTVMode(bool enable3DTVMode);
453	void setEnableVRMode(bool enableVRMode);	464	void setEnableVRMode(bool enableVRMode);
		465
		466	void rotationModeChanged();
454		467
455	glm::vec2 getScaledScreenPoint(glm::vec2 projectedPoint);	468	glm::vec2 getScaledScreenPoint(glm::vec2 projectedPoint);
456		469
@@ -548,21 +561,17 @@ private: · 91 unmodified lines
548		561
549	OctreeQuery _octreeQuery; // NodeData derived class for querying octee cells from octree servers	562	OctreeQuery _octreeQuery; // NodeData derived class for querying octee cells from octree servers
550		563
551	KeyboardMouseDevice _keyboardMouseDevice; // Default input device, the good old keyboard mouse and maybe touchpad	564	KeyboardMouseDevice _keyboardMouseDevice; // Default input device, the good old keyboard mouse and maybe touchpad
552		565	UserInputMapper _userInputMapper; // User input mapper allowing to mapp different real devices to the action channels that the application has to offer
553	UserInputMapper _userInputMapper; // User input mapper allowing to mapp different real devices to the action channels that the application has to offer	566	MyAvatar* _myAvatar; // TODO: move this and relevant code to AvatarManager (or MyAvatar as the case may be)
554		567	Camera _myCamera; // My view onto the world
555	MyAvatar* _myAvatar; // TODO: move this and relevant code to AvatarManager (or MyAvatar as the case may be)
556
557	Camera _myCamera; // My view onto the world
558	Camera _mirrorCamera; // Cammera for mirror view	568	Camera _mirrorCamera; // Cammera for mirror view
559	QRect _mirrorViewRect;	569	QRect _mirrorViewRect;
560	RearMirrorTools* _rearMirrorTools;
561		570
562	Setting::Handle<bool> _firstRun;	571	Setting::Handle<bool> _firstRun;
563	Setting::Handle<QString> _previousScriptLocation;	572	Setting::Handle<QString> _previousScriptLocation;
564	Setting::Handle<QString> _scriptsLocationHandle;	573	Setting::Handle<QString> _scriptsLocationHandle;
565	Setting::Handle<float> _fieldOfView;	574	Setting::Handle<float> _fieldOfView;
566		575
567	Transform _viewTransform;	576	Transform _viewTransform;
568	glm::mat4 _untranslatedViewMatrix;	577	glm::mat4 _untranslatedViewMatrix;
@@ -580,18 +589,17 @@ private: · 11 unmodified lines
580	Environment _environment;	589	Environment _environment;
581		590
582	bool _cursorVisible;	591	bool _cursorVisible;
583	int _mouseDragStartedX;	592	ivec2 _mouseDragStarted;
584	int _mouseDragStartedY;	593
585	quint64 _lastMouseMove;	594	quint64 _lastMouseMove;
586	bool _lastMouseMoveWasSimulated;	595	bool _lastMouseMoveWasSimulated;
587		596
588	glm::vec3 _mouseRayOrigin;	597	glm::vec3 _mouseRayOrigin;
589	glm::vec3 _mouseRayDirection;	598	glm::vec3 _mouseRayDirection;
590		599
591	float _touchAvgX;	600	vec2 _touchAvg;
592	float _touchAvgY;	601	vec2 _touchDragStartedAvg;
593	float _touchDragStartedAvgX;	602
594	float _touchDragStartedAvgY;
595	bool _isTouchPressed; // true if multitouch has been pressed (clear when finished)	603	bool _isTouchPressed; // true if multitouch has been pressed (clear when finished)
596		604
597	bool _mousePressed; // true if mouse has been pressed (clear when finished)	605	bool _mousePressed; // true if mouse has been pressed (clear when finished)
@@ -669,6 +677,7 @@ private: · 71 unmodified lines
669		677
670	Overlays _overlays;	678	Overlays _overlays;
671	ApplicationOverlay _applicationOverlay;	679	ApplicationOverlay _applicationOverlay;
		680	ApplicationCompositor _compositor;
672	};	681	};
673		682
674	#endif // hifi_Application_h	683	#endif // hifi_Application_h

interface/src/Camera.cpp+0−16

@@ -49,8 +49,6 @@ Camera::Camera() : · 48 unmodified lines
49	_mode(CAMERA_MODE_THIRD_PERSON),	49	_mode(CAMERA_MODE_THIRD_PERSON),
50	_position(0.0f, 0.0f, 0.0f),	50	_position(0.0f, 0.0f, 0.0f),
51	_projection(glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), 16.0f/9.0f, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP)),	51	_projection(glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), 16.0f/9.0f, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP)),
52	_hmdPosition(),
53	_hmdRotation(),
54	_isKeepLookingAt(false),	52	_isKeepLookingAt(false),
55	_lookingAt(0.0f, 0.0f, 0.0f)	53	_lookingAt(0.0f, 0.0f, 0.0f)
56	{	54	{
@@ -74,20 +72,6 @@ void Camera::setRotation(const glm::quat& rotation) { · 17 unmodified lines
74	}	72	}
75	}	73	}
76		74
77	void Camera::setHmdPosition(const glm::vec3& hmdPosition) {
78	_hmdPosition = hmdPosition;
79	if (_isKeepLookingAt) {
80	lookAt(_lookingAt);
81	}
82	}
83
84	void Camera::setHmdRotation(const glm::quat& hmdRotation) {
85	_hmdRotation = hmdRotation;
86	if (_isKeepLookingAt) {
87	lookAt(_lookingAt);
88	}
89	}
90
91	void Camera::setMode(CameraMode mode) {	75	void Camera::setMode(CameraMode mode) {
92	_mode = mode;	76	_mode = mode;
93	emit modeUpdated(modeToString(mode));	77	emit modeUpdated(modeToString(mode));

interface/src/Camera.h+4−10

@@ -45,26 +45,22 @@ public: · 44 unmodified lines
45		45
46	void setRotation(const glm::quat& rotation);	46	void setRotation(const glm::quat& rotation);
47	void setProjection(const glm::mat4 & projection);	47	void setProjection(const glm::mat4 & projection);
48	void setHmdPosition(const glm::vec3& hmdPosition);
49	void setHmdRotation(const glm::quat& hmdRotation);
50	void setMode(CameraMode m);	48	void setMode(CameraMode m);
51		49
52	glm::quat getRotation() const { return _rotation * _hmdRotation; }	50	glm::quat getRotation() const { return _rotation; }
53	const glm::mat4& getProjection() const { return _projection; }	51	const glm::mat4& getProjection() const { return _projection; }
54	const glm::vec3& getHmdPosition() const { return _hmdPosition; }
55	const glm::quat& getHmdRotation() const { return _hmdRotation; }
56	CameraMode getMode() const { return _mode; }	52	CameraMode getMode() const { return _mode; }
57		53
58	public slots:	54	public slots:
59	QString getModeString() const;	55	QString getModeString() const;
60	void setModeString(const QString& mode);	56	void setModeString(const QString& mode);
61		57
62	glm::vec3 getPosition() const { return _position + _hmdPosition; }	58	glm::vec3 getPosition() const { return _position; }
63	void setPosition(const glm::vec3& position);	59	void setPosition(const glm::vec3& position);
64		60
65	void setOrientation(const glm::quat& orientation) { setRotation(orientation); }
66	glm::quat getOrientation() const { return getRotation(); }	61	glm::quat getOrientation() const { return getRotation(); }
67		62	void setOrientation(const glm::quat& orientation) { setRotation(orientation); }
		63
68	PickRay computePickRay(float x, float y);	64	PickRay computePickRay(float x, float y);
69		65
70	// These only work on independent cameras	66	// These only work on independent cameras
@@ -86,8 +82,6 @@ private: · 15 unmodified lines
86	glm::vec3 _position;	82	glm::vec3 _position;
87	glm::quat _rotation;	83	glm::quat _rotation;
88	glm::mat4 _projection;	84	glm::mat4 _projection;
89	glm::vec3 _hmdPosition;
90	glm::quat _hmdRotation;
91	bool _isKeepLookingAt;	85	bool _isKeepLookingAt;
92	glm::vec3 _lookingAt;	86	glm::vec3 _lookingAt;
93	};	87	};

interface/src/GLCanvas.cpp+2−2

@@ -39,11 +39,11 @@ bool GLCanvas::isThrottleRendering() const { · 38 unmodified lines
39	}	39	}
40		40
41	int GLCanvas::getDeviceWidth() const {	41	int GLCanvas::getDeviceWidth() const {
42	return width() * (windowHandle() ? windowHandle()->devicePixelRatio() : 1.0f);	42	return width() * (windowHandle() ? (float)windowHandle()->devicePixelRatio() : 1.0f);
43	}	43	}
44		44
45	int GLCanvas::getDeviceHeight() const {	45	int GLCanvas::getDeviceHeight() const {
46	return height() * (windowHandle() ? windowHandle()->devicePixelRatio() : 1.0f);	46	return height() * (windowHandle() ? (float)windowHandle()->devicePixelRatio() : 1.0f);
47	}	47	}
48		48
49	void GLCanvas::initializeGL() {	49	void GLCanvas::initializeGL() {

interface/src/InterfaceActionFactory.cpp+3−3

@@ -12,7 +12,7 @@ · 11 unmodified lines
12		12
13		13
14	#include <avatar/AvatarActionHold.h>	14	#include <avatar/AvatarActionHold.h>
15	#include <ObjectActionPullToPoint.h>	15	#include <ObjectActionOffset.h>
16	#include <ObjectActionSpring.h>	16	#include <ObjectActionSpring.h>
17		17
18	#include "InterfaceActionFactory.h"	18	#include "InterfaceActionFactory.h"
@@ -27,8 +27,8 @@ EntityActionPointer InterfaceActionFactory::factory(EntitySimulation* simulation · 8 unmodified lines
27	switch (type) {	27	switch (type) {
28	case ACTION_TYPE_NONE:	28	case ACTION_TYPE_NONE:
29	return nullptr;	29	return nullptr;
30	case ACTION_TYPE_PULL_TO_POINT:	30	case ACTION_TYPE_OFFSET:
31	action = (EntityActionPointer) new ObjectActionPullToPoint(id, ownerEntity);	31	action = (EntityActionPointer) new ObjectActionOffset(id, ownerEntity);
32	break;	32	break;
33	case ACTION_TYPE_SPRING:	33	case ACTION_TYPE_SPRING:
34	action = (EntityActionPointer) new ObjectActionSpring(id, ownerEntity);	34	action = (EntityActionPointer) new ObjectActionSpring(id, ownerEntity);

interface/src/LODManager.cpp+3−3

@@ -205,11 +205,11 @@ QString LODManager::getLODFeedbackText() { · 204 unmodified lines
205	int relativeToTwentyTwenty = 20 / relativeToDefault;	205	int relativeToTwentyTwenty = 20 / relativeToDefault;
206		206
207	QString result;	207	QString result;
208	if (relativeToDefault > 1.01) {	208	if (relativeToDefault > 1.01f) {
209	result = QString("20:%1 or %2 times further than average vision%3").arg(relativeToTwentyTwenty).arg(relativeToDefault,0,'f',2).arg(granularityFeedback);	209	result = QString("20:%1 or %2 times further than average vision%3").arg(relativeToTwentyTwenty).arg(relativeToDefault,0,'f',2).arg(granularityFeedback);
210	} else if (relativeToDefault > 0.99) {	210	} else if (relativeToDefault > 0.99f) {
211	result = QString("20:20 or the default distance for average vision%1").arg(granularityFeedback);	211	result = QString("20:20 or the default distance for average vision%1").arg(granularityFeedback);
212	} else if (relativeToDefault > 0.01) {	212	} else if (relativeToDefault > 0.01f) {
213	result = QString("20:%1 or %2 of default distance for average vision%3").arg(relativeToTwentyTwenty).arg(relativeToDefault,0,'f',3).arg(granularityFeedback);	213	result = QString("20:%1 or %2 of default distance for average vision%3").arg(relativeToTwentyTwenty).arg(relativeToDefault,0,'f',3).arg(granularityFeedback);
214	} else {	214	} else {
215	result = QString("%2 of default distance for average vision%3").arg(relativeToDefault,0,'f',3).arg(granularityFeedback);	215	result = QString("%2 of default distance for average vision%3").arg(relativeToDefault,0,'f',3).arg(granularityFeedback);

interface/src/Menu.cpp+6−0

     addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::Mirror,
         0, //QML Qt::SHIFT | Qt::Key_H,
         true);
+    addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::FullscreenMirror,
+        0, // QML Qt::Key_H,
+        false, qApp, SLOT(cameraMenuChanged()));
+    addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::CenterPlayerInView,
+                                           0, false, qApp, SLOT(rotationModeChanged()));
     addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::HMDTools,
 #ifdef Q_OS_MAC

interface/src/Menu.h+1−0

@@ -201,6 +201,7 @@ namespace MenuOption { · 200 unmodified lines
201	const QString FrameTimer = "Show Timer";	201	const QString FrameTimer = "Show Timer";
202	const QString Fullscreen = "Fullscreen";	202	const QString Fullscreen = "Fullscreen";
203	const QString FullscreenMirror = "Fullscreen Mirror";	203	const QString FullscreenMirror = "Fullscreen Mirror";
		204	const QString CenterPlayerInView = "Center Player In View";
204	const QString GlowWhenSpeaking = "Glow When Speaking";	205	const QString GlowWhenSpeaking = "Glow When Speaking";
205	const QString NamesAboveHeads = "Names Above Heads";	206	const QString NamesAboveHeads = "Names Above Heads";
206	const QString HMDTools = "HMD Tools";	207	const QString HMDTools = "HMD Tools";

interface/src/ModelPropertiesDialog.cpp+26−26

interface/src/Stars.cpp+8−10

@@ -16,13 +16,13 @@ · 15 unmodified lines
16	#include "InterfaceConfig.h"	16	#include "InterfaceConfig.h"
17	#include "starfield/Controller.h"	17	#include "starfield/Controller.h"
18		18
19	Stars::Stars() :	19	Stars::Stars() :
20	_controller(0l), _starsLoaded(false) {	20	_controller(0l), _starsLoaded(false) {
21	_controller = new starfield::Controller;	21	_controller = new starfield::Controller;
22	}	22	}
23		23
24	Stars::~Stars() {	24	Stars::~Stars() {
25	delete _controller;	25	delete _controller;
26	}	26	}
27		27
28	bool Stars::generate(unsigned numStars, unsigned seed) {	28	bool Stars::generate(unsigned numStars, unsigned seed) {
@@ -30,22 +30,20 @@ bool Stars::generate(unsigned numStars, unsigned seed) { · 1 unmodified line
30	return _starsLoaded;	30	return _starsLoaded;
31	}	31	}
32		32
33	bool Stars::setResolution(unsigned k) {	33	bool Stars::setResolution(unsigned k) {
34	return _controller->setResolution(k);	34	return _controller->setResolution(k);
35	}	35	}
36		36
37	void Stars::render(float fovY, float aspect, float nearZ, float alpha) {	37	void Stars::render(float fovY, float aspect, float nearZ, float alpha) {
38	// determine length of screen diagonal from quadrant height and aspect ratio	38	// determine length of screen diagonal from quadrant height and aspect ratio
39	float quadrantHeight = nearZ * tan(RADIANS_PER_DEGREE * fovY * 0.5f);	39	float quadrantHeight = nearZ * tanf(RADIANS_PER_DEGREE * fovY * 0.5f);
40	float halfDiagonal = sqrt(quadrantHeight * quadrantHeight * (1.0f + aspect * aspect));	40	float halfDiagonal = sqrt(quadrantHeight * quadrantHeight * (1.0f + aspect * aspect));
41		41
42	// determine fov angle in respect to the diagonal	42	// determine fov angle in respect to the diagonal
43	float fovDiagonal = atan(halfDiagonal / nearZ) * 2.0f;	43	float fovDiagonal = atanf(halfDiagonal / nearZ) * 2.0f;
44		44
45	// pull the modelview matrix off the GL stack	45	// pull the modelview matrix off the GL stack
46	glm::mat4 view; glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(view));	46	glm::mat4 view; glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(view));
47		47
48	_controller->render(fovDiagonal, aspect, glm::affineInverse(view), alpha);	48	_controller->render(fovDiagonal, aspect, glm::affineInverse(view), alpha);
49	}	49	}
50
51

interface/src/UIUtil.cpp+1−1

@@ -70,6 +70,6 @@ void UIUtil::internalScaleWidgetFontSizes(QWidget* widget, float scale) { · 69 unmodified lines
70	}	70	}
71		71
72	QFont font = widget->font();	72	QFont font = widget->font();
73	font.setPointSizeF(font.pointSizeF() * scale);	73	font.setPointSizeF(font.pointSizeF() * (double)scale);
74	widget->setFont(font);	74	widget->setFont(font);
75	}	75	}

interface/src/Util.cpp+25−22

     static const glm::vec3 green(0.0f, 1.0f, 0.0f);
     static const glm::vec3 blue(0.0f, 0.0f, 1.0f);
     static const glm::vec3 grey(0.5f, 0.5f, 0.5f);
     auto transform = Transform{};
     batch.setModelTransform(transform);
     geometryCache->renderLine(batch, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(TREE_SCALE, 0.0f, 0.0f), red);
     geometryCache->renderLine(batch, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, TREE_SCALE), blue);
     geometryCache->renderLine(batch, glm::vec3(0.0f, 0.0f, TREE_SCALE), glm::vec3(TREE_SCALE, 0.0f, TREE_SCALE), grey);
     geometryCache->renderLine(batch, glm::vec3(TREE_SCALE, 0.0f, TREE_SCALE), glm::vec3(TREE_SCALE, 0.0f, 0.0f), grey);
     //  Draw meter markers along the 3 axis to help with measuring things
     const float MARKER_DISTANCE = 1.0f;
     const float MARKER_RADIUS = 0.05f;
     geometryCache->renderSphere(batch, MARKER_RADIUS, 10, 10, red);
     transform.setTranslation(glm::vec3(MARKER_DISTANCE, 0.0f, 0.0f));
     batch.setModelTransform(transform);
     geometryCache->renderSphere(batch, MARKER_RADIUS, 10, 10, red);
 }
 static TextRenderer* textRenderer(int mono) {
     static TextRenderer* monoRenderer = TextRenderer::getInstance(MONO_FONT_FAMILY);
     static TextRenderer* proportionalRenderer = TextRenderer::getInstance(SANS_FONT_FAMILY,
         -1, -1, false, TextRenderer::SHADOW_EFFECT);
     static TextRenderer* inconsolataRenderer = TextRenderer::getInstance(INCONSOLATA_FONT_FAMILY, -1, INCONSOLATA_FONT_WEIGHT,
         false);
     switch (mono) {
         case 1:
     QElapsedTimer startTime;
     startTime.start();
     float elapsedUsecs;
     float NSEC_TO_USEC = 1.0f / 1000.0f;
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "QElapsedTimer::nsecElapsed() usecs: %f", elapsedUsecs);
+    qCDebug(interfaceapp, "QElapsedTimer::nsecElapsed() usecs: %f", (double)elapsedUsecs);
     // Test sleep functions for accuracy
     startTime.start();
     QThread::msleep(1);
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "QThread::msleep(1) ms: %f", elapsedUsecs / 1000.0f);
+    qCDebug(interfaceapp, "QThread::msleep(1) ms: %f", (double)(elapsedUsecs / 1000.0f));
     startTime.start();
     QThread::sleep(1);
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "QThread::sleep(1) ms: %f", elapsedUsecs / 1000.0f);
+    qCDebug(interfaceapp, "QThread::sleep(1) ms: %f", (double)(elapsedUsecs / 1000.0f));
     startTime.start();
     usleep(1);
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "usleep(1) ms: %f", elapsedUsecs / 1000.0f);
+    qCDebug(interfaceapp, "usleep(1) ms: %f", (double)(elapsedUsecs / 1000.0f));
     startTime.start();
     usleep(10);
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "usleep(10) ms: %f", elapsedUsecs / 1000.0f);
+    qCDebug(interfaceapp, "usleep(10) ms: %f", (double)(elapsedUsecs / 1000.0f));
     startTime.start();
     usleep(100);
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "usleep(100) ms: %f", elapsedUsecs / 1000.0f);
+    qCDebug(interfaceapp, "usleep(100) ms: %f", (double)(elapsedUsecs / 1000.0f));
     startTime.start();
     usleep(1000);
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "usleep(1000) ms: %f", elapsedUsecs / 1000.0f);
+    qCDebug(interfaceapp, "usleep(1000) ms: %f", (double)(elapsedUsecs / 1000.0f));
     startTime.start();
     usleep(15000);
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "usleep(15000) ms: %f", elapsedUsecs / 1000.0f);
+    qCDebug(interfaceapp, "usleep(15000) ms: %f", (double)(elapsedUsecs / 1000.0f));
     // Random number generation
     startTime.start();
         iResults[i] = rand();
     }
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "rand() stored in array usecs: %f, first result:%d", elapsedUsecs / (float) numTests, iResults[0]);
+    qCDebug(interfaceapp, "rand() stored in array usecs: %f, first result:%d",
+            (double)(elapsedUsecs / numTests), iResults[0]);
     // Random number generation using randFloat()
     startTime.start();
         fResults[i] = randFloat();
     }
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "randFloat() stored in array usecs: %f, first result: %f", elapsedUsecs / (float) numTests, fResults[0]);
+    qCDebug(interfaceapp, "randFloat() stored in array usecs: %f, first result: %f",
+            (double)(elapsedUsecs / numTests), (double)(fResults[0]));
     free(iResults);
     free(fResults);
         fTest = powf(fTest, 0.5f);
     }
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "powf(f, 0.5) usecs: %f", elapsedUsecs / (float) numTests);
+    qCDebug(interfaceapp, "powf(f, 0.5) usecs: %f", (double)(elapsedUsecs / (float) numTests));
     //  Vector Math
     float distance;
     }
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
     qCDebug(interfaceapp, "vector math usecs: %f [%f usecs total for %d tests], last result:%f",
-           elapsedUsecs / (float) numTests, elapsedUsecs, numTests, distance);
+            (double)(elapsedUsecs / (float) numTests), (double)elapsedUsecs, numTests, (double)distance);
     //  Vec3 test
     glm::vec3 vecA(randVector()), vecB(randVector());
     float result;
     startTime.start();
     for (int i = 0; i < numTests; i++) {
         glm::vec3 temp = vecA-vecB;
         result = glm::dot(temp,temp);
     }
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
-    qCDebug(interfaceapp, "vec3 assign and dot() usecs: %f, last result:%f", elapsedUsecs / (float) numTests, result);
+    qCDebug(interfaceapp, "vec3 assign and dot() usecs: %f, last result:%f",
+            (double)(elapsedUsecs / numTests), (double)result);
 }
 bool rayIntersectsSphere(const glm::vec3& rayStarting, const glm::vec3& rayNormalizedDirection,

interface/src/audio/AudioIOStatsRenderer.cpp+69−55

     if (!_isEnabled) {
         return;
     }
     const int linesWhenCentered = _shouldShowInjectedStreams ? 34 : 27;
     const int CENTERED_BACKGROUND_HEIGHT = STATS_HEIGHT_PER_LINE * linesWhenCentered;
     int lines = _shouldShowInjectedStreams ? _stats->getMixerInjectedStreamStatsMap().size() * 7 + 27 : 27;
     int statsHeight = STATS_HEIGHT_PER_LINE * lines;
     static const glm::vec4 backgroundColor = { 0.2f, 0.2f, 0.2f, 0.6f };
     int x = std::max((width - (int)STATS_WIDTH) / 2, 0);
     int y = std::max((height - CENTERED_BACKGROUND_HEIGHT) / 2, 0);
     int w = STATS_WIDTH;
     int h = statsHeight;
     DependencyManager::get<GeometryCache>()->renderQuad(x, y, w, h, backgroundColor);
     int horizontalOffset = x + 5;
     int verticalOffset = y;
     float scale = 0.10f;
     float rotation = 0.0f;
     int font = 2;
     char latencyStatString[512];
     float audioInputBufferLatency = 0.0f, inputRingBufferLatency = 0.0f, networkRoundtripLatency = 0.0f, mixerRingBufferLatency = 0.0f, outputRingBufferLatency = 0.0f, audioOutputBufferLatency = 0.0f;
     AudioStreamStats downstreamAudioStreamStats = _stats->getMixerDownstreamStats();
     SharedNodePointer audioMixerNodePointer = DependencyManager::get<NodeList>()->soloNodeOfType(NodeType::AudioMixer);
     if (!audioMixerNodePointer.isNull()) {
         audioOutputBufferLatency = _stats->getAudioOutputMsecsUnplayedStats().getWindowAverage();
     }
     float totalLatency = audioInputBufferLatency + inputRingBufferLatency + networkRoundtripLatency + mixerRingBufferLatency + outputRingBufferLatency + audioOutputBufferLatency;
-    sprintf(latencyStatString, "     Audio input buffer: %7.2fms    - avg msecs of samples read to the input ring buffer in last 10s", audioInputBufferLatency);
+    sprintf(latencyStatString,
+            "     Audio input buffer: %7.2fms    - avg msecs of samples read to the input ring buffer in last 10s",
+            (double)audioInputBufferLatency);
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, latencyStatString, color);
-    sprintf(latencyStatString, "      Input ring buffer: %7.2fms    - avg msecs of samples in input ring buffer in last 10s", inputRingBufferLatency);
+    sprintf(latencyStatString,
+            "      Input ring buffer: %7.2fms    - avg msecs of samples in input ring buffer in last 10s",
+            (double)inputRingBufferLatency);
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, latencyStatString, color);
-    sprintf(latencyStatString, "       Network to mixer: %7.2fms    - half of last ping value calculated by the node list", networkRoundtripLatency / 2.0f);
+    sprintf(latencyStatString,
+            "       Network to mixer: %7.2fms    - half of last ping value calculated by the node list",
+            (double)(networkRoundtripLatency / 2.0f));
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, latencyStatString, color);
-    sprintf(latencyStatString, " AudioMixer ring buffer: %7.2fms    - avg msecs of samples in audio mixer's ring buffer in last 10s", mixerRingBufferLatency);
+    sprintf(latencyStatString,
+            " AudioMixer ring buffer: %7.2fms    - avg msecs of samples in audio mixer's ring buffer in last 10s",
+            (double)mixerRingBufferLatency);
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, latencyStatString, color);
-    sprintf(latencyStatString, "      Network to client: %7.2fms    - half of last ping value calculated by the node list", networkRoundtripLatency / 2.0f);
+    sprintf(latencyStatString,
+            "      Network to client: %7.2fms    - half of last ping value calculated by the node list",
+            (double)(networkRoundtripLatency / 2.0f));
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, latencyStatString, color);
-    sprintf(latencyStatString, "     Output ring buffer: %7.2fms    - avg msecs of samples in output ring buffer in last 10s", outputRingBufferLatency);
+    sprintf(latencyStatString,
+            "     Output ring buffer: %7.2fms    - avg msecs of samples in output ring buffer in last 10s",
+            (double)outputRingBufferLatency);
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, latencyStatString, color);
-    sprintf(latencyStatString, "    Audio output buffer: %7.2fms    - avg msecs of samples in audio output buffer in last 10s", audioOutputBufferLatency);
+    sprintf(latencyStatString,
+            "    Audio output buffer: %7.2fms    - avg msecs of samples in audio output buffer in last 10s",
+            (double)audioOutputBufferLatency);
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, latencyStatString, color);
-    sprintf(latencyStatString, "                  TOTAL: %7.2fms\n", totalLatency);
+    sprintf(latencyStatString, "                  TOTAL: %7.2fms\n", (double)totalLatency);
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, latencyStatString, color);
     verticalOffset += STATS_HEIGHT_PER_LINE;    // blank line
     char clientUpstreamMicLabelString[] = "Upstream Mic Audio Packets Sent Gaps (by client):";
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, clientUpstreamMicLabelString, color);
     const MovingMinMaxAvg<quint64>& packetSentTimeGaps = _stats->getPacketSentTimeGaps();
     char stringBuffer[512];
     sprintf(stringBuffer, "  Inter-packet timegaps (overall) | min: %9s, max: %9s, avg: %9s",
             formatUsecTime(packetSentTimeGaps.getMin()).toLatin1().data(),
             formatUsecTime(packetSentTimeGaps.getAverage()).toLatin1().data());
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, stringBuffer, color);
     sprintf(stringBuffer, " Inter-packet timegaps (last 30s) | min: %9s, max: %9s, avg: %9s",
             formatUsecTime(packetSentTimeGaps.getWindowMin()).toLatin1().data(),
             formatUsecTime(packetSentTimeGaps.getWindowMax()).toLatin1().data(),
             formatUsecTime(packetSentTimeGaps.getWindowAverage()).toLatin1().data());
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, stringBuffer, color);
     verticalOffset += STATS_HEIGHT_PER_LINE;    // blank line
     char upstreamMicLabelString[] = "Upstream mic audio stats (received and reported by audio-mixer):";
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, upstreamMicLabelString, color);
     renderAudioStreamStats(&_stats->getMixerAvatarStreamStats(), horizontalOffset, verticalOffset,
                            scale, rotation, font, color);
     verticalOffset += STATS_HEIGHT_PER_LINE;    // blank line
     char downstreamLabelString[] = "Downstream mixed audio stats:";
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, downstreamLabelString, color);
     AudioStreamStats downstreamStats = _stats->getMixerDownstreamStats();
     renderAudioStreamStats(&downstreamStats, horizontalOffset, verticalOffset,
                            scale, rotation, font, color, true);
     if (_shouldShowInjectedStreams) {
         foreach(const AudioStreamStats& injectedStreamAudioStats, _stats->getMixerInjectedStreamStatsMap()) {
             verticalOffset += STATS_HEIGHT_PER_LINE;    // blank line
             char upstreamInjectedLabelString[512];
             sprintf(upstreamInjectedLabelString, "Upstream injected audio stats:      stream ID: %s",
                     injectedStreamAudioStats._streamIdentifier.toString().toLatin1().data());
             verticalOffset += STATS_HEIGHT_PER_LINE;
             drawText(horizontalOffset, verticalOffset, scale, rotation, font, upstreamInjectedLabelString, color);
             renderAudioStreamStats(&injectedStreamAudioStats, horizontalOffset, verticalOffset, scale, rotation, font, color);
         }
     }
 void AudioIOStatsRenderer::renderAudioStreamStats(const AudioStreamStats* streamStats, int horizontalOffset, int& verticalOffset,
                                                 float scale, float rotation, int font, const float* color, bool isDownstreamStats) {
     char stringBuffer[512];
     sprintf(stringBuffer, "                      Packet loss | overall: %5.2f%% (%d lost), last_30s: %5.2f%% (%d lost)",
-            streamStats->_packetStreamStats.getLostRate() * 100.0f,
+            (double)(streamStats->_packetStreamStats.getLostRate() * 100.0f),
             streamStats->_packetStreamStats._lost,
-            streamStats->_packetStreamWindowStats.getLostRate() * 100.0f,
+            (double)(streamStats->_packetStreamWindowStats.getLostRate() * 100.0f),
             streamStats->_packetStreamWindowStats._lost);
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, stringBuffer, color);
     if (isDownstreamStats) {
         sprintf(stringBuffer, "                Ringbuffer frames | desired: %u, avg_available(10s): %u+%d, available: %u+%d",
                 streamStats->_desiredJitterBufferFrames,
                 streamStats->_framesAvailableAverage,
-                (int)(_stats->getAudioInputMsecsReadStats().getWindowAverage() / AudioConstants::NETWORK_FRAME_MSECS),
+                (int)((float)_stats->getAudioInputMsecsReadStats().getWindowAverage() / AudioConstants::NETWORK_FRAME_MSECS),
                 streamStats->_framesAvailable,
                 (int)(_stats->getAudioOutputMsecsUnplayedStats().getCurrentIntervalLastSample()
                       / AudioConstants::NETWORK_FRAME_MSECS));
                 streamStats->_framesAvailableAverage,
                 streamStats->_framesAvailable);
     }
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, stringBuffer, color);
     sprintf(stringBuffer, "                 Ringbuffer stats | starves: %u, prev_starve_lasted: %u, frames_dropped: %u, overflows: %u",
             streamStats->_starveCount,
             streamStats->_consecutiveNotMixedCount,
             streamStats->_overflowCount);
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, stringBuffer, color);
     sprintf(stringBuffer, "  Inter-packet timegaps (overall) | min: %9s, max: %9s, avg: %9s",
             formatUsecTime(streamStats->_timeGapMin).toLatin1().data(),
             formatUsecTime(streamStats->_timeGapMax).toLatin1().data(),
             formatUsecTime(streamStats->_timeGapAverage).toLatin1().data());
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, stringBuffer, color);
     sprintf(stringBuffer, " Inter-packet timegaps (last 30s) | min: %9s, max: %9s, avg: %9s",
             formatUsecTime(streamStats->_timeGapWindowMin).toLatin1().data(),
             formatUsecTime(streamStats->_timeGapWindowMax).toLatin1().data(),
             formatUsecTime(streamStats->_timeGapWindowAverage).toLatin1().data());
     verticalOffset += STATS_HEIGHT_PER_LINE;
     drawText(horizontalOffset, verticalOffset, scale, rotation, font, stringBuffer, color);
 }

interface/src/audio/AudioToolBox.cpp+0−114

@@ -1,114 +0,0 @@
1	//
2	// AudioToolBox.cpp
3	// interface/src/audio
4	//
5	// Created by Stephen Birarda on 2014-12-16.
6	// Copyright 2014 High Fidelity, Inc.
7	//
8	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//
11
12	#include "InterfaceConfig.h"
13
14	#include <AudioClient.h>
15	#include <GLCanvas.h>
16	#include <PathUtils.h>
17	#include <GeometryCache.h>
18	#include <gpu/GLBackend.h>
19
20	#include "Application.h"
21	#include "AudioToolBox.h"
22
23	// Mute icon configration
24	const int MUTE_ICON_SIZE = 24;
25
26	AudioToolBox::AudioToolBox() :
27	_iconPulseTimeReference(usecTimestampNow())
28	{
29	}
30
31	bool AudioToolBox::mousePressEvent(int x, int y) {
32	if (_iconBounds.contains(x, y)) {
33	DependencyManager::get<AudioClient>()->toggleMute();
34	return true;
35	}
36	return false;
37	}
38
39	void AudioToolBox::render(int x, int y, int padding, bool boxed) {
40	glEnable(GL_TEXTURE_2D);
41
42	if (!_micTexture) {
43	_micTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/mic.svg");
44	}
45	if (!_muteTexture) {
46	_muteTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/mic-mute.svg");
47	}
48	if (_boxTexture) {
49	_boxTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/audio-box.svg");
50	}
51
52	auto audioIO = DependencyManager::get<AudioClient>();
53
54	if (boxed) {
55	bool isClipping = ((audioIO->getTimeSinceLastClip() > 0.0f) && (audioIO->getTimeSinceLastClip() < 1.0f));
56	const int BOX_LEFT_PADDING = 5;
57	const int BOX_TOP_PADDING = 10;
58	const int BOX_WIDTH = 266;
59	const int BOX_HEIGHT = 44;
60
61	QRect boxBounds = QRect(x - BOX_LEFT_PADDING, y - BOX_TOP_PADDING, BOX_WIDTH, BOX_HEIGHT);
62	glm::vec4 quadColor;
63
64	if (isClipping) {
65	quadColor = glm::vec4(1.0f, 0.0f, 0.0f, 1.0f);
66	} else {
67	quadColor = glm::vec4(0.41f, 0.41f, 0.41f, 1.0f);
68	}
69	glm::vec2 topLeft(boxBounds.left(), boxBounds.top());
70	glm::vec2 bottomRight(boxBounds.right(), boxBounds.bottom());
71	static const glm::vec2 texCoordTopLeft(1,1);
72	static const glm::vec2 texCoordBottomRight(0, 0);
73	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_boxTexture));
74	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, quadColor);
75	}
76
77	float iconColor = 1.0f;
78
79	_iconBounds = QRect(x + padding, y, MUTE_ICON_SIZE, MUTE_ICON_SIZE);
80	if (!audioIO->isMuted()) {
81	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_micTexture));
82	iconColor = 1.0f;
83	} else {
84	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_muteTexture));
85
86	// Make muted icon pulsate
87	static const float PULSE_MIN = 0.4f;
88	static const float PULSE_MAX = 1.0f;
89	static const float PULSE_FREQUENCY = 1.0f; // in Hz
90	qint64 now = usecTimestampNow();
91	if (now - _iconPulseTimeReference > (qint64)USECS_PER_SECOND) {
92	// Prevents t from getting too big, which would diminish glm::cos precision
93	_iconPulseTimeReference = now - ((now - _iconPulseTimeReference) % USECS_PER_SECOND);
94	}
95	float t = (float)(now - _iconPulseTimeReference) / (float)USECS_PER_SECOND;
96	float pulseFactor = (glm::cos(t * PULSE_FREQUENCY * 2.0f * PI) + 1.0f) / 2.0f;
97	iconColor = PULSE_MIN + (PULSE_MAX - PULSE_MIN) * pulseFactor;
98	}
99
100	glm::vec4 quadColor(iconColor, iconColor, iconColor, 1.0f);
101
102	glm::vec2 topLeft(_iconBounds.left(), _iconBounds.top());
103	glm::vec2 bottomRight(_iconBounds.right(), _iconBounds.bottom());
104	glm::vec2 texCoordTopLeft(1,1);
105	glm::vec2 texCoordBottomRight(0,0);
106
107	if (_boxQuadID == GeometryCache::UNKNOWN_ID) {
108	_boxQuadID = DependencyManager::get<GeometryCache>()->allocateID();
109	}
110
111	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, quadColor, _boxQuadID);
112	glBindTexture(GL_TEXTURE_2D, 0);
113	glDisable(GL_TEXTURE_2D);
114	}

interface/src/audio/AudioToolBox.h+0−36

@@ -1,36 +0,0 @@
1	//
2	// AudioToolBox.h
3	// interface/src/audio
4	//
5	// Created by Stephen Birarda on 2014-12-16.
6	// Copyright 2014 High Fidelity, Inc.
7	//
8	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//
11
12	#ifndef hifi_AudioToolBox_h
13	#define hifi_AudioToolBox_h
14
15	#include <DependencyManager.h>
16	#include <GeometryCache.h>
17	#include <QOpenGLTexture>
18
19	class AudioToolBox : public Dependency {
20	SINGLETON_DEPENDENCY
21	public:
22	void render(int x, int y, int padding, bool boxed);
23
24	bool mousePressEvent(int x, int y);
25	protected:
26	AudioToolBox();
27	private:
28	gpu::TexturePointer _micTexture;
29	gpu::TexturePointer _muteTexture;
30	gpu::TexturePointer _boxTexture;
31	int _boxQuadID = GeometryCache::UNKNOWN_ID;
32	QRect _iconBounds;
33	qint64 _iconPulseTimeReference = 0;
34	};
35
36	#endif // hifi_AudioToolBox_h

interface/src/avatar/Avatar.cpp+110−121

@@ -57,7 +57,7 @@ const float CHAT_MESSAGE_SCALE = 0.0015f; · 56 unmodified lines
57	const float CHAT_MESSAGE_HEIGHT = 0.1f;	57	const float CHAT_MESSAGE_HEIGHT = 0.1f;
58	const float DISPLAYNAME_FADE_TIME = 0.5f;	58	const float DISPLAYNAME_FADE_TIME = 0.5f;
59	const float DISPLAYNAME_FADE_FACTOR = pow(0.01f, 1.0f / DISPLAYNAME_FADE_TIME);	59	const float DISPLAYNAME_FADE_FACTOR = pow(0.01f, 1.0f / DISPLAYNAME_FADE_TIME);
60	const float DISPLAYNAME_ALPHA = 0.95f;	60	const float DISPLAYNAME_ALPHA = 1.0f;
61	const float DISPLAYNAME_BACKGROUND_ALPHA = 0.4f;	61	const float DISPLAYNAME_BACKGROUND_ALPHA = 0.4f;
62		62
63	namespace render {	63	namespace render {
@@ -107,6 +107,7 @@ Avatar::Avatar() : · 43 unmodified lines
107	}	107	}
108		108
109	Avatar::~Avatar() {	109	Avatar::~Avatar() {
		110	assert(_motionState == nullptr);
110	for(auto attachment : _unusedAttachments) {	111	for(auto attachment : _unusedAttachments) {
111	delete attachment;	112	delete attachment;
112	}	113	}
@@ -280,9 +281,9 @@ enum TextRendererType { · 167 unmodified lines
280	};	281	};
281		282
282	static TextRenderer3D* textRenderer(TextRendererType type) {	283	static TextRenderer3D* textRenderer(TextRendererType type) {
283	static TextRenderer3D* chatRenderer = TextRenderer3D::getInstance(SANS_FONT_FAMILY, 24, -1,	284	static TextRenderer3D* chatRenderer = TextRenderer3D::getInstance(SANS_FONT_FAMILY, -1,
284	false, TextRenderer3D::SHADOW_EFFECT);	285	false, TextRenderer3D::SHADOW_EFFECT);
285	static TextRenderer3D* displayNameRenderer = TextRenderer3D::getInstance(SANS_FONT_FAMILY, 12);	286	static TextRenderer3D* displayNameRenderer = TextRenderer3D::getInstance(SANS_FONT_FAMILY);
286		287
287	switch(type) {	288	switch(type) {
288	case CHAT:	289	case CHAT:
@@ -323,7 +324,7 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo · 34 unmodified lines
323	_referential->update();	324	_referential->update();
324	}	325	}
325		326
326	auto batch = renderArgs->_batch;	327	auto& batch = *renderArgs->_batch;
327		328
328	if (postLighting &&	329	if (postLighting &&
329	glm::distance(DependencyManager::get<AvatarManager>()->getMyAvatar()->getPosition(), _position) < 10.0f) {	330	glm::distance(DependencyManager::get<AvatarManager>()->getMyAvatar()->getPosition(), _position) < 10.0f) {
@@ -354,9 +355,9 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo · 24 unmodified lines
354	Transform pointerTransform;	355	Transform pointerTransform;
355	pointerTransform.setTranslation(position);	356	pointerTransform.setTranslation(position);
356	pointerTransform.setRotation(rotation);	357	pointerTransform.setRotation(rotation);
357	batch->setModelTransform(pointerTransform);	358	batch.setModelTransform(pointerTransform);
358	deferredLighting->bindSimpleProgram(*batch);	359	deferredLighting->bindSimpleProgram(batch);
359	geometryCache->renderLine(*batch, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, laserLength, 0.0f), laserColor);	360	geometryCache->renderLine(batch, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, laserLength, 0.0f), laserColor);
360	}	361	}
361	}	362	}
362		363
@@ -377,9 +378,9 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo · 14 unmodified lines
377	Transform pointerTransform;	378	Transform pointerTransform;
378	pointerTransform.setTranslation(position);	379	pointerTransform.setTranslation(position);
379	pointerTransform.setRotation(rotation);	380	pointerTransform.setRotation(rotation);
380	batch->setModelTransform(pointerTransform);	381	batch.setModelTransform(pointerTransform);
381	deferredLighting->bindSimpleProgram(*batch);	382	deferredLighting->bindSimpleProgram(batch);
382	geometryCache->renderLine(*batch, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, laserLength, 0.0f), laserColor);	383	geometryCache->renderLine(batch, glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, laserLength, 0.0f), laserColor);
383	}	384	}
384	}	385	}
385	}	386	}
@@ -464,8 +465,8 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo · 78 unmodified lines
464	}	465	}
465	Transform transform;	466	Transform transform;
466	transform.setTranslation(position);	467	transform.setTranslation(position);
467	batch->setModelTransform(transform);	468	batch.setModelTransform(transform);
468	DependencyManager::get<DeferredLightingEffect>()->renderSolidSphere(*batch, LOOK_AT_INDICATOR_RADIUS	469	DependencyManager::get<DeferredLightingEffect>()->renderSolidSphere(batch, LOOK_AT_INDICATOR_RADIUS
469	, 15, 15, LOOK_AT_INDICATOR_COLOR);	470	, 15, 15, LOOK_AT_INDICATOR_COLOR);
470	}	471	}
471	}	472	}
@@ -492,14 +493,14 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo · 20 unmodified lines
492	Transform transform;	493	Transform transform;
493	transform.setTranslation(_position);	494	transform.setTranslation(_position);
494	transform.setScale(height);	495	transform.setScale(height);
495	batch->setModelTransform(transform);	496	batch.setModelTransform(transform);
496		497
497	if (_voiceSphereID == GeometryCache::UNKNOWN_ID) {	498	if (_voiceSphereID == GeometryCache::UNKNOWN_ID) {
498	_voiceSphereID = DependencyManager::get<GeometryCache>()->allocateID();	499	_voiceSphereID = DependencyManager::get<GeometryCache>()->allocateID();
499	}	500	}
500		501
501	DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(*batch);	502	DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(batch);
502	DependencyManager::get<GeometryCache>()->renderSphere(*batch, sphereRadius, 15, 15,	503	DependencyManager::get<GeometryCache>()->renderSphere(batch, sphereRadius, 15, 15,
503	glm::vec4(SPHERE_COLOR[0], SPHERE_COLOR[1], SPHERE_COLOR[2], 1.0f - angle / MAX_SPHERE_ANGLE), true,	504	glm::vec4(SPHERE_COLOR[0], SPHERE_COLOR[1], SPHERE_COLOR[2], 1.0f - angle / MAX_SPHERE_ANGLE), true,
504	_voiceSphereID);	505	_voiceSphereID);
505	}	506	}
@@ -507,14 +508,12 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo · 1 unmodified line
507	}	508	}
508		509
509	const float DISPLAYNAME_DISTANCE = 20.0f;	510	const float DISPLAYNAME_DISTANCE = 20.0f;
510	setShowDisplayName(renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE && distanceToTarget < DISPLAYNAME_DISTANCE);	511	setShowDisplayName(distanceToTarget < DISPLAYNAME_DISTANCE);
511		512
512	if (renderArgs->_renderMode != RenderArgs::NORMAL_RENDER_MODE \|\| (isMyAvatar() &&	513	auto cameraMode = Application::getInstance()->getCamera()->getMode();
513	Application::getInstance()->getCamera()->getMode() == CAMERA_MODE_FIRST_PERSON)) {	514	if (!isMyAvatar() \|\| cameraMode != CAMERA_MODE_FIRST_PERSON) {
514	return;	515	renderDisplayName(batch, *renderArgs->_viewFrustum);
515	}	516	}
516
517	renderDisplayName(renderArgs);
518	}	517	}
519		518
520	glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {	519	glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {
@@ -654,8 +653,8 @@ float Avatar::getBillboardSize() const { · 133 unmodified lines
654	return _scale * BILLBOARD_DISTANCE * tanf(glm::radians(BILLBOARD_FIELD_OF_VIEW / 2.0f));	653	return _scale * BILLBOARD_DISTANCE * tanf(glm::radians(BILLBOARD_FIELD_OF_VIEW / 2.0f));
655	}	654	}
656		655
657	glm::vec3 Avatar::getDisplayNamePosition() {	656	glm::vec3 Avatar::getDisplayNamePosition() const {
658	glm::vec3 namePosition;	657	glm::vec3 namePosition(0.0f);
659	if (getSkeletonModel().getNeckPosition(namePosition)) {	658	if (getSkeletonModel().getNeckPosition(namePosition)) {
660	namePosition += getBodyUpDirection() * getHeadHeight() * 1.1f;	659	namePosition += getBodyUpDirection() * getHeadHeight() * 1.1f;
661	} else {	660	} else {
@@ -665,81 +664,73 @@ glm::vec3 Avatar::getDisplayNamePosition() { · 3 unmodified lines
665	return namePosition;	664	return namePosition;
666	}	665	}
667		666
668	float Avatar::calculateDisplayNameScaleFactor(const glm::vec3& textPosition, bool inHMD) {	667	Transform Avatar::calculateDisplayNameTransform(const ViewFrustum& frustum, float fontSize) const {
669		668	Transform result;
670	// We need to compute the scale factor such as the text remains with fixed size respect to window coordinates	669	// We assume textPosition is whithin the frustum
671	// We project a unit vector and check the difference in screen coordinates, to check which is the	670	glm::vec3 textPosition = getDisplayNamePosition();
672	// correction scale needed	671
673	// save the matrices for later scale correction factor	672	// Compute viewProjection matrix
674	// The up vector must be relative to the rotation current rotation matrix:	673	glm::mat4 projMat, viewMat;
675	// we set the identity	674	Transform view;
		675	frustum.evalProjectionMatrix(projMat);
		676	frustum.evalViewTransform(view);
		677	glm::mat4 viewProj = projMat * view.getInverseMatrix(viewMat);
		678
		679	// Used to determine correct scale
676	glm::vec3 testPoint0 = textPosition;	680	glm::vec3 testPoint0 = textPosition;
677	glm::vec3 testPoint1 = textPosition + (Application::getInstance()->getCamera()->getRotation() * IDENTITY_UP);	681	glm::vec3 testPoint1 = testPoint0 + glm::normalize(frustum.getUp());
678		682	// testPoints projections
679	double textWindowHeight;	683	glm::vec4 p0 = viewProj * glm::vec4(testPoint0, 1.0);
680		684	glm::vec4 p1 = viewProj * glm::vec4(testPoint1, 1.0);
		685
		686	// TODO REMOVE vvv
681	GLint viewportMatrix[4];	687	GLint viewportMatrix[4];
682	glGetIntegerv(GL_VIEWPORT, viewportMatrix);	688	glGetIntegerv(GL_VIEWPORT, viewportMatrix);
683	glm::dmat4 modelViewMatrix;	689	glm::dmat4 modelViewMatrix;
684	float windowSizeX = viewportMatrix[2] - viewportMatrix[0];
685	float windowSizeY = viewportMatrix[3] - viewportMatrix[1];	690	float windowSizeY = viewportMatrix[3] - viewportMatrix[1];
		691	// TODO REMOVE ^^^
		692
		693	const float DESIRED_HIGHT_ON_SCREEN = 20; // In pixels (this is double on retinas)
		694
		695	// Projected point are between -1.0f and 1.0f, hence 0.5f * windowSizeY
		696	double pixelHeight = 0.5f * windowSizeY * glm::abs((p1.y / p1.w) - (p0.y / p0.w)); //
		697	// Handles pixel density (especially for macs retina displays)
		698	double devicePixelRatio = qApp->getDevicePixelRatio() * qApp->getRenderResolutionScale(); // pixels / unit
		699
		700	// Compute correct scale to apply
		701	float scale = DESIRED_HIGHT_ON_SCREEN / (fontSize * pixelHeight) * devicePixelRatio;
		702
		703	// Compute pixel alignment offset
		704	float clipToPix = 0.5f * windowSizeY / p1.w; // Got from clip to pixel coordinates
		705	glm::vec4 screenPos = clipToPix * p1; // in pixels coords
		706	glm::vec4 screenOffset = (glm::round(screenPos) - screenPos) / clipToPix; // in clip coords
		707	glm::vec3 worldOffset = glm::vec3(screenOffset.x, screenOffset.y, 0.0f) / (float)pixelHeight;
		708
		709	// Compute orientation
		710	glm::vec3 eulerAngles = ::safeEulerAngles(frustum.getOrientation());
		711	eulerAngles.z = 0.0f; // Cancel roll
		712	glm::quat orientation(eulerAngles); // back to quaternions
		713
		714	// Set transform (The order IS important)
		715	result.setTranslation(textPosition);
		716	result.setRotation(orientation); // Always face the screen
		717	result.postTranslate(worldOffset); // Pixel alignment
		718	result.setScale(scale);
		719	return result;
686		720
687	glm::dmat4 projectionMatrix;
688	Application::getInstance()->getModelViewMatrix(&modelViewMatrix);
689	Application::getInstance()->getProjectionMatrix(&projectionMatrix);
690
691
692	glm::dvec4 p0 = modelViewMatrix * glm::dvec4(testPoint0, 1.0);
693	p0 = projectionMatrix * p0;
694	glm::dvec2 result0 = glm::vec2(windowSizeX * (p0.x / p0.w + 1.0f) * 0.5f, windowSizeY * (p0.y / p0.w + 1.0f) * 0.5f);
695
696	glm::dvec4 p1 = modelViewMatrix * glm::dvec4(testPoint1, 1.0);
697	p1 = projectionMatrix * p1;
698	glm::vec2 result1 = glm::vec2(windowSizeX * (p1.x / p1.w + 1.0f) * 0.5f, windowSizeY * (p1.y / p1.w + 1.0f) * 0.5f);
699	textWindowHeight = abs(result1.y - result0.y);
700
701	// need to scale to compensate for the font resolution due to the device
702	float scaleFactor = QApplication::desktop()->windowHandle()->devicePixelRatio() *
703	((textWindowHeight > EPSILON) ? 1.0f / textWindowHeight : 1.0f);
704	if (inHMD) {
705	const float HMDMODE_NAME_SCALE = 0.65f;
706	scaleFactor *= HMDMODE_NAME_SCALE;
707	} else {
708	scaleFactor *= Application::getInstance()->getRenderResolutionScale();
709	}
710	return scaleFactor;
711	}	721	}
712		722
713	void Avatar::renderDisplayName(RenderArgs* renderArgs) {	723	void Avatar::renderDisplayName(gpu::Batch& batch, const ViewFrustum& frustum) const {
714	auto batch = renderArgs->_batch;
715
716	bool shouldShowReceiveStats = DependencyManager::get<AvatarManager>()->shouldShowReceiveStats() && !isMyAvatar();	724	bool shouldShowReceiveStats = DependencyManager::get<AvatarManager>()->shouldShowReceiveStats() && !isMyAvatar();
717		725
		726	// If we have nothing to draw, or it's tottaly transparent, return
718	if ((_displayName.isEmpty() && !shouldShowReceiveStats) \|\| _displayNameAlpha == 0.0f) {	727	if ((_displayName.isEmpty() && !shouldShowReceiveStats) \|\| _displayNameAlpha == 0.0f) {
719	return;	728	return;
720	}	729	}
721		730	auto renderer = textRenderer(DISPLAYNAME);
722	// which viewing mode?
723	bool inHMD = Application::getInstance()->isHMDMode();
724
725	glm::vec3 textPosition = getDisplayNamePosition();
726
727	// we need "always facing camera": we must remove the camera rotation from the stac
728	glm::quat rotation = Application::getInstance()->getCamera()->getRotation();
729
730	// TODO: Fix scaling - at some point this or the text rendering changed in scale.
731	float scaleFactor = calculateDisplayNameScaleFactor(textPosition, inHMD);
732	scaleFactor /= 3.5f;
733
734	Transform textTransform;
735	textTransform.setTranslation(textPosition);
736	textTransform.setRotation(rotation);
737	textTransform.setScale(scaleFactor);
738		731
739	// optionally render timing stats for this avatar with the display name	732	// optionally render timing stats for this avatar with the display name
740	QString renderedDisplayName = _displayName;	733	QString renderedDisplayName = _displayName;
741	QRect nameDynamicRect = _displayNameBoundingRect;
742
743	if (shouldShowReceiveStats) {	734	if (shouldShowReceiveStats) {
744	float kilobitsPerSecond = getAverageBytesReceivedPerSecond() / (float) BYTES_PER_KILOBIT;	735	float kilobitsPerSecond = getAverageBytesReceivedPerSecond() / (float) BYTES_PER_KILOBIT;
745		736
@@ -747,42 +738,43 @@ void Avatar::renderDisplayName(RenderArgs* renderArgs) { · 1 unmodified line
747	if (!renderedDisplayName.isEmpty()) {	738	if (!renderedDisplayName.isEmpty()) {
748	statsFormat.prepend(" - ");	739	statsFormat.prepend(" - ");
749	}	740	}
750		741	renderedDisplayName += statsFormat.arg(QString::number(kilobitsPerSecond, 'f', 2)).arg(getReceiveRate());
751	QString statsText = statsFormat.arg(QString::number(kilobitsPerSecond, 'f', 2)).arg(getReceiveRate());
752	renderedDisplayName += statsText;
753
754	glm::vec2 extent = textRenderer(DISPLAYNAME)->computeExtent(renderedDisplayName);
755	nameDynamicRect = QRect(0, 0, (int)extent.x, (int)extent.y);
756	}	742	}
757
758	int text_x = -nameDynamicRect.width() / 2;
759	int text_y = -nameDynamicRect.height() / 2;
760
761	// draw a gray background
762	int left = text_x;
763	int right = left + nameDynamicRect.width();
764	int bottom = text_y;
765	int top = bottom + nameDynamicRect.height();
766	const int border = 8;
767	bottom -= border;
768	left -= border;
769	top += border;
770	right += border;
771		743
		744	// Compute display name extent/position offset
		745	glm::vec2 extent = renderer->computeExtent(renderedDisplayName);
		746	QRect nameDynamicRect = QRect(0, 0, (int)extent.x, (int)extent.y);
		747	const int text_x = -nameDynamicRect.width() / 2;
		748	const int text_y = -nameDynamicRect.height() / 2;
		749
		750	// Compute background position/size
		751	static const float SLIGHTLY_BEHIND = -0.05f;
		752	const int border = 0.1f * nameDynamicRect.height();
		753	const int left = text_x - border;
		754	const int bottom = text_y - border;
		755	const int width = nameDynamicRect.width() + 2.0f * border;
		756	const int height = nameDynamicRect.height() + 2.0f * border;
		757	const int bevelDistance = 0.1f * height;
		758
		759	// Display name and background colors
772	glm::vec4 textColor(0.93f, 0.93f, 0.93f, _displayNameAlpha);	760	glm::vec4 textColor(0.93f, 0.93f, 0.93f, _displayNameAlpha);
773	glm::vec4 backgroundColor(0.2f, 0.2f, 0.2f,	761	glm::vec4 backgroundColor(0.2f, 0.2f, 0.2f,
774	_displayNameAlpha * DISPLAYNAME_BACKGROUND_ALPHA / DISPLAYNAME_ALPHA);	762	(_displayNameAlpha / DISPLAYNAME_ALPHA) * DISPLAYNAME_BACKGROUND_ALPHA);
		763
		764	// Compute display name transform
		765	auto textTransform = calculateDisplayNameTransform(frustum, renderer->getFontSize());
775		766
		767	// Render background slightly behind to avoid z-fighting
776	auto backgroundTransform = textTransform;	768	auto backgroundTransform = textTransform;
777	backgroundTransform.postTranslate(glm::vec3(0.0f, 0.0f, -0.001f));	769	backgroundTransform.postTranslate(glm::vec3(0.0f, 0.0f, SLIGHTLY_BEHIND));
778	batch->setModelTransform(backgroundTransform);	770	batch.setModelTransform(backgroundTransform);
779	DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(*batch);	771	DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(batch);
780	DependencyManager::get<GeometryCache>()->renderBevelCornersRect(*batch, left, bottom, right - left, top - bottom, 3,	772	DependencyManager::get<GeometryCache>()->renderBevelCornersRect(batch, left, bottom, width, height,
781	backgroundColor);	773	bevelDistance, backgroundColor);
		774	// Render actual name
782	QByteArray nameUTF8 = renderedDisplayName.toLocal8Bit();	775	QByteArray nameUTF8 = renderedDisplayName.toLocal8Bit();
783		776	batch.setModelTransform(textTransform);
784	batch->setModelTransform(textTransform);	777	renderer->draw(batch, text_x, -text_y, nameUTF8.data(), textColor);
785	textRenderer(DISPLAYNAME)->draw(*batch, text_x, -text_y, nameUTF8.data(), textColor);
786	}	778	}
787		779
788	bool Avatar::findRayIntersection(RayIntersectionInfo& intersection) const {	780	bool Avatar::findRayIntersection(RayIntersectionInfo& intersection) const {
@@ -987,13 +979,6 @@ void Avatar::setAttachmentData(const QVector<AttachmentData>& attachmentData) { · 198 unmodified lines
987	}	979	}
988	}	980	}
989		981
990	void Avatar::setDisplayName(const QString& displayName) {
991	AvatarData::setDisplayName(displayName);
992	// FIXME is this a sufficient replacement for tightBoundingRect?
993	glm::vec2 extent = textRenderer(DISPLAYNAME)->computeExtent(displayName);
994	_displayNameBoundingRect = QRect(0, 0, (int)extent.x, (int)extent.y);
995	}
996
997	void Avatar::setBillboard(const QByteArray& billboard) {	982	void Avatar::setBillboard(const QByteArray& billboard) {
998	AvatarData::setBillboard(billboard);	983	AvatarData::setBillboard(billboard);
999		984
@@ -1092,7 +1077,12 @@ float Avatar::getSkeletonHeight() const { · 92 unmodified lines
1092	float Avatar::getHeadHeight() const {	1077	float Avatar::getHeadHeight() const {
1093	Extents extents = getHead()->getFaceModel().getMeshExtents();	1078	Extents extents = getHead()->getFaceModel().getMeshExtents();
1094	if (!extents.isEmpty() && extents.isValid()) {	1079	if (!extents.isEmpty() && extents.isValid()) {
1095	return extents.maximum.y - extents.minimum.y;	1080
		1081	// HACK: We have a really odd case when fading out for some models where this value explodes
		1082	float result = extents.maximum.y - extents.minimum.y;
		1083	if (result >= 0.0f && result < 100.0f * _scale ) {
		1084	return result;
		1085	}
1096	}	1086	}
1097		1087
1098	extents = _skeletonModel.getMeshExtents();	1088	extents = _skeletonModel.getMeshExtents();
@@ -1116,7 +1106,7 @@ void Avatar::setShowDisplayName(bool showDisplayName) { · 17 unmodified lines
1116	}	1106	}
1117		1107
1118	// For myAvatar, the alpha update is not done (called in simulate for other avatars)	1108	// For myAvatar, the alpha update is not done (called in simulate for other avatars)
1119	if (DependencyManager::get<AvatarManager>()->getMyAvatar() == this) {	1109	if (isMyAvatar()) {
1120	if (showDisplayName) {	1110	if (showDisplayName) {
1121	_displayNameAlpha = DISPLAYNAME_ALPHA;	1111	_displayNameAlpha = DISPLAYNAME_ALPHA;
1122	} else {	1112	} else {
@@ -1129,7 +1119,6 @@ void Avatar::setShowDisplayName(bool showDisplayName) { · 6 unmodified lines
1129	} else {	1119	} else {
1130	_displayNameTargetAlpha = 0.0f;	1120	_displayNameTargetAlpha = 0.0f;
1131	}	1121	}
1132
1133	}	1122	}
1134		1123
1135	// virtual	1124	// virtual

interface/src/avatar/Avatar.h+5−5

     //getters
     bool isInitialized() const { return _initialized; }
     SkeletonModel& getSkeletonModel() { return _skeletonModel; }
+    const SkeletonModel& getSkeletonModel() const { return _skeletonModel; }
     const QVector<Model*>& getAttachmentModels() const { return _attachmentModels; }
     glm::vec3 getChestPosition() const;
     float getScale() const { return _scale; }
     /// \return whether or not the plane penetrated
     bool findPlaneCollisions(const glm::vec4& plane, CollisionList& collisions);
-    virtual bool isMyAvatar() { return false; }
+    virtual bool isMyAvatar() const { return false; }
     virtual QVector<glm::quat> getJointRotations() const;
     virtual glm::quat getJointRotation(int index) const;
     virtual void setFaceModelURL(const QUrl& faceModelURL);
     virtual void setSkeletonModelURL(const QUrl& skeletonModelURL);
     virtual void setAttachmentData(const QVector<AttachmentData>& attachmentData);
-    virtual void setDisplayName(const QString& displayName);
     virtual void setBillboard(const QByteArray& billboard);
     void setShowDisplayName(bool showDisplayName);
     float getSkeletonHeight() const;
     float getHeadHeight() const;
     float getPelvisFloatingHeight() const;
-    glm::vec3 getDisplayNamePosition();
+    glm::vec3 getDisplayNamePosition() const;
-    float calculateDisplayNameScaleFactor(const glm::vec3& textPosition, bool inHMD);
+    Transform calculateDisplayNameTransform(const ViewFrustum& frustum, float fontSize) const;
-    void renderDisplayName(RenderArgs* renderArgs);
+    void renderDisplayName(gpu::Batch& batch, const ViewFrustum& frustum) const;
     virtual void renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel = 0.0f);
     virtual bool shouldRenderHead(const RenderArgs* renderArgs, const glm::vec3& cameraPosition) const;
     virtual void fixupModelsInScene();

interface/src/avatar/AvatarActionHold.cpp+10−1

 void AvatarActionHold::updateActionWorker(float deltaTimeStep) {
     auto myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
+    if (!tryLockForRead()) {
+        // don't risk hanging the thread running the physics simulation
+        return;
+    }
     glm::vec3 palmPosition;
     if (_hand == "right") {
         palmPosition = myAvatar->getRightPalmPosition();
     auto offset = rotation * _relativePosition;
     auto position = palmPosition + offset;
     rotation *= _relativeRotation;
+    unlock();
-    lockForWrite();
+    if (!tryLockForWrite()) {
+        return;
+    }
     _positionalTarget = position;
     _rotationalTarget = rotation;
     unlock();

interface/src/avatar/AvatarManager.cpp+17−5

 #include <QScriptEngine>
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdouble-promotion"
+#endif
 #include <glm/gtx/string_cast.hpp>
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 #include <GlowEffect.h>
 #include <PerfStat.h>
 #include <RegisteredMetaTypes.h>
             // DO NOT update or fade out uninitialized Avatars
             ++avatarIterator;
         } else if (avatar->shouldDie()) {
+            removeAvatarMotionState(avatar);
             _avatarFades.push_back(avatarIterator.value());
             avatarIterator = _avatarHash.erase(avatarIterator);
         } else {
 }
 // protected
-void AvatarManager::removeAvatarMotionState(Avatar* avatar) {
+void AvatarManager::removeAvatarMotionState(AvatarSharedPointer avatar) {
-    AvatarMotionState* motionState= avatar->_motionState;
+    auto rawPointer = std::static_pointer_cast<Avatar>(avatar);
+    AvatarMotionState* motionState= rawPointer->_motionState;
     if (motionState) {
         // clean up physics stuff
         motionState->clearObjectBackPointer();
-        avatar->_motionState = nullptr;
+        rawPointer->_motionState = nullptr;
         _avatarMotionStates.remove(motionState);
         _motionStatesToAdd.remove(motionState);
         _motionStatesToDelete.push_back(motionState);
     if (avatarIterator != _avatarHash.end()) {
         std::shared_ptr<Avatar> avatar = std::dynamic_pointer_cast<Avatar>(avatarIterator.value());
         if (avatar != _myAvatar && avatar->isInitialized()) {
-            removeAvatarMotionState(avatar.get());
+            removeAvatarMotionState(avatar);
             _avatarFades.push_back(avatarIterator.value());
             _avatarHash.erase(avatarIterator);
         }
             // don't remove myAvatar or uninitialized avatars from the list
             ++avatarIterator;
         } else {
-            removeAvatarMotionState(avatar.get());
+            removeAvatarMotionState(avatar);
             _avatarFades.push_back(avatarIterator.value());
             avatarIterator = _avatarHash.erase(avatarIterator);
         }

interface/src/avatar/AvatarManager.h+1−1

@@ -73,7 +73,7 @@ private: · 72 unmodified lines
73	// virtual overrides	73	// virtual overrides
74	virtual AvatarSharedPointer newSharedAvatar();	74	virtual AvatarSharedPointer newSharedAvatar();
75	virtual AvatarSharedPointer addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer);	75	virtual AvatarSharedPointer addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer);
76	void removeAvatarMotionState(Avatar* avatar);	76	void removeAvatarMotionState(AvatarSharedPointer avatar);
77	virtual void removeAvatar(const QUuid& sessionUUID);	77	virtual void removeAvatar(const QUuid& sessionUUID);
78		78
79	QVector<AvatarSharedPointer> _avatarFades;	79	QVector<AvatarSharedPointer> _avatarFades;

interface/src/avatar/Head.cpp+13−6

@@ -77,7 +77,7 @@ void Head::simulate(float deltaTime, bool isMine, bool billboard) { · 76 unmodified lines
77	const float AUDIO_LONG_TERM_AVERAGING_SECS = 30.0f;	77	const float AUDIO_LONG_TERM_AVERAGING_SECS = 30.0f;
78	_averageLoudness = glm::mix(_averageLoudness, _audioLoudness, glm::min(deltaTime / AUDIO_AVERAGING_SECS, 1.0f));	78	_averageLoudness = glm::mix(_averageLoudness, _audioLoudness, glm::min(deltaTime / AUDIO_AVERAGING_SECS, 1.0f));
79		79
80	if (_longTermAverageLoudness == -1.0) {	80	if (_longTermAverageLoudness == -1.0f) {
81	_longTermAverageLoudness = _averageLoudness;	81	_longTermAverageLoudness = _averageLoudness;
82	} else {	82	} else {
83	_longTermAverageLoudness = glm::mix(_longTermAverageLoudness, _averageLoudness, glm::min(deltaTime / AUDIO_LONG_TERM_AVERAGING_SECS, 1.0f));	83	_longTermAverageLoudness = glm::mix(_longTermAverageLoudness, _averageLoudness, glm::min(deltaTime / AUDIO_LONG_TERM_AVERAGING_SECS, 1.0f));
@@ -124,18 +124,25 @@ void Head::simulate(float deltaTime, bool isMine, bool billboard) { · 40 unmodified lines
124		124
125	if (!(_isFaceTrackerConnected \|\| billboard)) {	125	if (!(_isFaceTrackerConnected \|\| billboard)) {
126	// Update eye saccades	126	// Update eye saccades
127	const float AVERAGE_MICROSACCADE_INTERVAL = 0.50f;	127	const float AVERAGE_MICROSACCADE_INTERVAL = 1.0f;
128	const float AVERAGE_SACCADE_INTERVAL = 4.0f;	128	const float AVERAGE_SACCADE_INTERVAL = 6.0f;
129	const float MICROSACCADE_MAGNITUDE = 0.002f;	129	const float MICROSACCADE_MAGNITUDE = 0.002f;
130	const float SACCADE_MAGNITUDE = 0.04f;	130	const float SACCADE_MAGNITUDE = 0.04f;
131		131	const float MAXIMUM_SACCADE_SPEED = 0.8f;
		132
132	if (randFloat() < deltaTime / AVERAGE_MICROSACCADE_INTERVAL) {	133	if (randFloat() < deltaTime / AVERAGE_MICROSACCADE_INTERVAL) {
133	_saccadeTarget = MICROSACCADE_MAGNITUDE * randVector();	134	_saccadeTarget = MICROSACCADE_MAGNITUDE * randVector();
134	} else if (randFloat() < deltaTime / AVERAGE_SACCADE_INTERVAL) {	135	} else if (randFloat() < deltaTime / AVERAGE_SACCADE_INTERVAL) {
135	_saccadeTarget = SACCADE_MAGNITUDE * randVector();	136	_saccadeTarget = SACCADE_MAGNITUDE * randVector();
136	}	137	}
137	_saccade += (_saccadeTarget - _saccade) * 0.50f;	138
138		139	glm::vec3 saccadeDelta = (_saccadeTarget - _saccade) * 0.5f;
		140	float speed = glm::length(saccadeDelta) / deltaTime;
		141	if (speed > MAXIMUM_SACCADE_SPEED) {
		142	saccadeDelta = saccadeDelta * MAXIMUM_SACCADE_SPEED / speed;
		143	}
		144	_saccade += saccadeDelta;
		145
139	// Detect transition from talking to not; force blink after that and a delay	146	// Detect transition from talking to not; force blink after that and a delay
140	bool forceBlink = false;	147	bool forceBlink = false;
141	const float TALKING_LOUDNESS = 100.0f;	148	const float TALKING_LOUDNESS = 100.0f;

interface/src/avatar/MyAvatar.cpp+81−81

 const float MAX_BOOST_SPEED = 0.5f * MAX_WALKING_SPEED; // keyboard motor gets additive boost below this speed
 const float MIN_AVATAR_SPEED = 0.05f; // speed is set to zero below this
 // TODO: normalize avatar speed for standard avatar size, then scale all motion logic
 // to properly follow avatar size.
 float MAX_AVATAR_SPEED = 300.0f;
 float MAX_KEYBOARD_MOTOR_SPEED = MAX_AVATAR_SPEED;
 float DEFAULT_KEYBOARD_MOTOR_TIMESCALE = 0.25f;
 float MIN_SCRIPTED_MOTOR_TIMESCALE = 0.005f;
 float DEFAULT_SCRIPTED_MOTOR_TIMESCALE = 1.0e6f;
     if (_referential) {
         _referential->update();
     }
     Head* head = getHead();
     head->relaxLean(deltaTime);
     updateFromTrackers(deltaTime);
 void MyAvatar::simulate(float deltaTime) {
     PerformanceTimer perfTimer("simulate");
     // Play back recording
     if (_player && _player->isPlaying()) {
         _player->play();
     }
     if (_scale != _targetScale) {
         float scale = (1.0f - SMOOTHING_RATIO) * _scale + SMOOTHING_RATIO * _targetScale;
         setScale(scale);
         updateOrientation(deltaTime);
         updatePosition(deltaTime);
     }
     {
         PerformanceTimer perfTimer("hand");
         // update avatar skeleton and simulate hand and head
         head->setScale(_scale);
         head->simulate(deltaTime, true);
     }
     // Record avatars movements.
     if (_recorder && _recorder->isRecording()) {
         _recorder->record();
     }
     // consider updating our billboard
     maybeUpdateBillboard();
 }
 //  Update avatar head rotation with sensor data
 void MyAvatar::updateFromTrackers(float deltaTime) {
     glm::vec3 estimatedPosition, estimatedRotation;
     bool inHmd = qApp->isHMDMode();
     if (isPlaying() && inHmd) {
         return;
     }
     if (inHmd) {
         estimatedPosition = qApp->getHeadPosition();
         estimatedPosition.x *= -1.0f;
         _trackedHeadPosition = estimatedPosition;
         const float OCULUS_LEAN_SCALE = 0.05f;
         estimatedPosition /= OCULUS_LEAN_SCALE;
     } else {
             estimatedRotation = glm::degrees(safeEulerAngles(tracker->getHeadRotation()));
         }
     }
     //  Rotate the body if the head is turned beyond the screen
     if (Menu::getInstance()->isOptionChecked(MenuOption::TurnWithHead)) {
         const float TRACKER_YAW_TURN_SENSITIVITY = 0.5f;
     glm::vec3 headPosition(getHead()->getEyePosition());
     float torsoToHead = glm::length(headPosition - torsoPosition);
     glm::vec3 position;
-    qCDebug(interfaceapp, "head-above-torso %.2f, scale = %0.2f", torsoToHead, getScale());
+    qCDebug(interfaceapp, "head-above-torso %.2f, scale = %0.2f", (double)torsoToHead, (double)getScale());
     //  Torso Sphere
     position = torsoPosition;
     auto audioClient = DependencyManager::get<AudioClient>();
     connect(audioClient.data(), &AudioClient::inputReceived, _recorder.data(),
             &Recorder::recordAudio, Qt::BlockingQueuedConnection);
     _recorder->startRecording();
 }
         // stop grabbing audio from the AudioClient
         auto audioClient = DependencyManager::get<AudioClient>();
         disconnect(audioClient.data(), 0, _recorder.data(), 0);
         _recorder->stopRecording();
     }
 }
     if (!_player) {
         _player = PlayerPointer(new Player(this));
     }
     _player->loadRecording(_recorder->getRecording());
 }
     AnimationDetails result;
     if (QThread::currentThread() != thread()) {
         QMetaObject::invokeMethod(this, "getAnimationDetailsByRole", Qt::BlockingQueuedConnection,
             Q_RETURN_ARG(AnimationDetails, result),
             Q_ARG(const QString&, role));
         return result;
     }
     AnimationDetails result;
     if (QThread::currentThread() != thread()) {
         QMetaObject::invokeMethod(this, "getAnimationDetails", Qt::BlockingQueuedConnection,
             Q_RETURN_ARG(AnimationDetails, result),
             Q_ARG(const QString&, url));
         return result;
     }
         settings.setValue("scale", attachment.scale);
     }
     settings.endArray();
     settings.beginWriteArray("animationHandles");
     for (int i = 0; i < _animationHandles.size(); i++) {
         settings.setArrayIndex(i);
         settings.setValue("maskedJoints", pointer->getMaskedJoints());
     }
     settings.endArray();
     settings.setValue("displayName", _displayName);
     settings.endGroup();
     _targetScale = loadSetting(settings, "scale", 1.0f);
     setScale(_scale);
     // The old preferences only stored the face and skeleton URLs, we didn't track if the user wanted to use 1 or 2 urls
     // for their avatar, So we need to attempt to detect this old case and set our new preferences accordingly. If
     // the head URL is empty, then we will assume they are using a full url...
     bool isOldSettings = !(settings.contains("useFullAvatar") || settings.contains("fullAvatarURL"));
     _headModelName = settings.value("headModelName", DEFAULT_HEAD_MODEL_NAME).toString();
     _bodyModelName = settings.value("bodyModelName", DEFAULT_BODY_MODEL_NAME).toString();
     _fullAvatarModelName = settings.value("fullAvatarModelName", DEFAULT_FULL_AVATAR_MODEL_NAME).toString();
     if (isOldSettings) {
         bool assumeFullAvatar = _headURLFromPreferences.isEmpty();
         _useFullAvatar = assumeFullAvatar;
                 QVariantHash bodyFST = FSTReader::downloadMapping(_skeletonURLFromPreferences.toString());
                 _bodyModelName = bodyFST["name"].toString();
             }
             if (_headURLFromPreferences == DEFAULT_HEAD_MODEL_URL) {
                 _headModelName = DEFAULT_HEAD_MODEL_NAME;
             } else {
                 QVariantHash headFST = FSTReader::downloadMapping(_headURLFromPreferences.toString());
                 _headModelName = headFST["name"].toString();
             }
             _fullAvatarModelName = "Default";
         }
     }
     } else {
         useHeadAndBodyURLs(_headURLFromPreferences, _skeletonURLFromPreferences, _headModelName, _bodyModelName);
     }
     QVector<AttachmentData> attachmentData;
     int attachmentCount = settings.beginReadArray("attachmentData");
     for (int i = 0; i < attachmentCount; i++) {
     }
     settings.endArray();
     setAttachmentData(attachmentData);
     int animationCount = settings.beginReadArray("animationHandles");
     while (_animationHandles.size() > animationCount) {
         _animationHandles.takeLast()->stop();
         handle->setStartAutomatically(settings.value("startAutomatically", true).toBool());
     }
     settings.endArray();
     setDisplayName(settings.value("displayName").toString());
     settings.endGroup();
     settings.beginGroup(_skeletonModel.getURL().toString());
     settings.beginGroup(attachment.modelURL.toString());
     settings.setValue("jointName", attachment.jointName);
     settings.beginGroup(attachment.jointName);
     settings.setValue("translation_x", attachment.translation.x);
     settings.setValue("translation_y", attachment.translation.y);
     settings.setValue("rotation_y", eulers.y);
     settings.setValue("rotation_z", eulers.z);
     settings.setValue("scale", attachment.scale);
     settings.endGroup();
     settings.endGroup();
     settings.endGroup();
     settings.beginGroup("savedAttachmentData");
     settings.beginGroup(_skeletonModel.getURL().toString());
     settings.beginGroup(modelURL.toString());
     AttachmentData attachment;
     attachment.modelURL = modelURL;
     if (jointName.isEmpty()) {
     } else {
         attachment = AttachmentData();
     }
     settings.endGroup();
     settings.endGroup();
     settings.endGroup();
     settings.endGroup();
     return attachment;
 }
 int MyAvatar::parseDataAtOffset(const QByteArray& packet, int offset) {
     qCDebug(interfaceapp) << "Error: ignoring update packet for MyAvatar"
         << " packetLength = " << packet.size()
         << "  offset = " << offset;
     // this packet is just bad, so we pretend that we unpacked it ALL
     return packet.size() - offset;
     //
     _lookAtTargetAvatar.reset();
     _targetAvatarPosition = glm::vec3(0.0f);
     glm::vec3 lookForward = getHead()->getFinalOrientationInWorldFrame() * IDENTITY_FRONT;
     glm::vec3 cameraPosition = Application::getInstance()->getCamera()->getPosition();
     float smallestAngleTo = glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES) / 2.0f;
     const float KEEP_LOOKING_AT_CURRENT_ANGLE_FACTOR = 1.3f;
     const float GREATEST_LOOKING_AT_DISTANCE = 10.0f;
     int howManyLookingAtMe = 0;
     foreach (const AvatarSharedPointer& avatarPointer, DependencyManager::get<AvatarManager>()->getAvatarHash()) {
         Avatar* avatar = static_cast<Avatar*>(avatarPointer.get());
     }
     _useFullAvatar = true;
     if (_fullAvatarURLFromPreferences != fullAvatarURL) {
         _fullAvatarURLFromPreferences = fullAvatarURL;
         if (modelName.isEmpty()) {
             QVariantHash fullAvatarFST = FSTReader::downloadMapping(_fullAvatarURLFromPreferences.toString());
             _fullAvatarModelName = fullAvatarFST["name"].toString();
         } else {
             _fullAvatarModelName = modelName;
         }
     }
         if (headName.isEmpty()) {
             QVariantHash headFST = FSTReader::downloadMapping(_headURLFromPreferences.toString());
             _headModelName = headFST["name"].toString();
         } else {
             _headModelName = headName;
         }
     }
         if (bodyName.isEmpty()) {
             QVariantHash bodyFST = FSTReader::downloadMapping(_skeletonURLFromPreferences.toString());
             _bodyModelName = bodyFST["name"].toString();
         } else {
             _bodyModelName = bodyName;
         }
     }
 glm::vec3 MyAvatar::getSkeletonPosition() const {
     CameraMode mode = Application::getInstance()->getCamera()->getMode();
     if (mode == CAMERA_MODE_THIRD_PERSON || mode == CAMERA_MODE_INDEPENDENT) {
         // The avatar is rotated PI about the yAxis, so we have to correct for it
         // to get the skeleton offset contribution in the world-frame.
         const glm::quat FLIP = glm::angleAxis(PI, glm::vec3(0.0f, 1.0f, 0.0f));
         glm::vec3 skeletonOffset = _skeletonOffset;
 }
 void MyAvatar::setScriptedMotorTimescale(float timescale) {
     // we clamp the timescale on the large side (instead of just the low side) to prevent
     // obnoxiously large values from introducing NaN into avatar's velocity
     _scriptedMotorTimescale = glm::clamp(timescale, MIN_SCRIPTED_MOTOR_TIMESCALE,
             DEFAULT_SCRIPTED_MOTOR_TIMESCALE);
 }
     clearJointAnimationPriorities();
     _scriptedMotorVelocity = glm::vec3(0.0f);
     _scriptedMotorTimescale = DEFAULT_SCRIPTED_MOTOR_TIMESCALE;
 }
 void MyAvatar::attach(const QString& modelURL, const QString& jointName, const glm::vec3& translation,
         const glm::quat& rotation, float scale, bool allowDuplicates, bool useSaved) {
     if (QThread::currentThread() != thread()) {
         Avatar::attach(modelURL, jointName, translation, rotation, scale, allowDuplicates, useSaved);
         return;
     }
     if (useSaved) {
         AttachmentData attachment = loadAttachmentData(modelURL, jointName);
         if (attachment.isValid()) {
 bool MyAvatar::shouldRenderHead(const RenderArgs* renderArgs, const glm::vec3& cameraPosition) const {
     const Head* head = getHead();
     return (renderArgs->_renderMode != RenderArgs::NORMAL_RENDER_MODE) || (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON) ||
         (glm::length(cameraPosition - head->getEyePosition()) > RENDER_HEAD_CUTOFF_DISTANCE * _scale);
 }
         //Invert yaw and roll when in mirror mode
         if (Application::getInstance()->getCamera()->getMode() == CAMERA_MODE_MIRROR) {
-            YAW(euler) *= -1.0;
+            YAW(euler) *= -1.0f;
-            ROLL(euler) *= -1.0;
+            ROLL(euler) *= -1.0f;
         }
         Head* head = getHead();
         head->setBaseYaw(YAW(euler));
         head->setBasePitch(PITCH(euler));
         return localVelocity;
     }
     // compute motor efficiency
     // The timescale of the motor is the approximate time it takes for the motor to
     // accomplish its intended localVelocity.  A short timescale makes the motor strong,
     // and a long timescale makes it weak.  The value of timescale to use depends
     // on what the motor is doing:
     //
     // (1) braking --> short timescale (aggressive motor assertion)
     float MIN_KEYBOARD_BRAKE_SPEED = 0.3f;
     float timescale = MAX_KEYBOARD_MOTOR_TIMESCALE;
     bool isThrust = (glm::length2(_thrust) > EPSILON);
     if (_isPushing || isThrust ||
             (_scriptedMotorTimescale < MAX_KEYBOARD_MOTOR_TIMESCALE &&
             _motionBehaviors | AVATAR_MOTION_SCRIPTED_MOTOR_ENABLED)) {
         // we don't want to brake if something is pushing the avatar around
         timescale = _keyboardMotorTimescale;
     float motorEfficiency = glm::clamp(deltaTime / timescale, 0.0f, 1.0f);
     glm::vec3 newLocalVelocity = localVelocity;
     float keyboardInput = fabsf(_driveKeys[FWD] - _driveKeys[BACK]) +
         (fabsf(_driveKeys[RIGHT] - _driveKeys[LEFT])) +
         fabsf(_driveKeys[UP] - _driveKeys[DOWN]);
     if (keyboardInput) {
         // Compute keyboard input
         glm::vec3 front = (_driveKeys[FWD] - _driveKeys[BACK]) * IDENTITY_FRONT;
         glm::vec3 right = (_driveKeys[RIGHT] - _driveKeys[LEFT]) * IDENTITY_RIGHT;
         glm::vec3 up = (_driveKeys[UP] - _driveKeys[DOWN]) * IDENTITY_UP;
         glm::vec3 direction = front + right + up;
         float directionLength = glm::length(direction);
         // Compute motor magnitude
         if (directionLength > EPSILON) {
             direction /= directionLength;
                 motorEfficiency = glm::clamp(deltaTime / WALK_ACCELERATION_TIMESCALE, 0.0f, 1.0f);
             }
             _isPushing = true;
         }
         newLocalVelocity = localVelocity + motorEfficiency * (_keyboardMotorVelocity - localVelocity);
     } else {
         _keyboardMotorVelocity = glm::vec3(0.0f);
         _targetVelocity *= MAX_AVATAR_SPEED / speed;
         speed = MAX_AVATAR_SPEED;
     }
     if (speed > MIN_AVATAR_SPEED && !_characterController.isEnabled()) {
         // update position ourselves
         applyPositionDelta(deltaTime * _targetVelocity);
         measureMotionDerivatives(deltaTime);
     } // else physics will move avatar later
     // update _moving flag based on speed
     const float MOVING_SPEED_THRESHOLD = 0.01f;
     _moving = speed > MOVING_SPEED_THRESHOLD;
     float xzDistance = sqrt(positionBA.x * positionBA.x + positionBA.z * positionBA.z);
     if (xzDistance < (radiusA + radiusB)) {
         float yDistance = fabs(positionBA.y);
-        float halfHeights = 0.5 * (heightA + heightB);
+        float halfHeights = 0.5f * (heightA + heightB);
         if (yDistance < halfHeights) {
             // cylinders collide
             if (xzDistance > 0.0f) {
     }
     gpu::Context context(new gpu::GLBackend());
     RenderArgs renderArgs(&context);
-    QImage image = Application::getInstance()->renderAvatarBillboard(&renderArgs);
+    QImage image = qApp->renderAvatarBillboard(&renderArgs);
     _billboard.clear();
     QBuffer buffer(&_billboard);
     buffer.open(QIODevice::WriteOnly);
     image.save(&buffer, "PNG");
     _billboardValid = true;
     sendBillboardPacket();
 }
 void MyAvatar::increaseSize() {
     if ((1.0f + SCALING_RATIO) * _targetScale < MAX_AVATAR_SCALE) {
         _targetScale *= (1.0f + SCALING_RATIO);
-        qCDebug(interfaceapp, "Changed scale to %f", _targetScale);
+        qCDebug(interfaceapp, "Changed scale to %f", (double)_targetScale);
     }
 }
 void MyAvatar::decreaseSize() {
     if (MIN_AVATAR_SCALE < (1.0f - SCALING_RATIO) * _targetScale) {
         _targetScale *= (1.0f - SCALING_RATIO);
-        qCDebug(interfaceapp, "Changed scale to %f", _targetScale);
+        qCDebug(interfaceapp, "Changed scale to %f", (double)_targetScale);
     }
 }
 void MyAvatar::resetSize() {
     _targetScale = 1.0f;
-    qCDebug(interfaceapp, "Reseted scale to %f", _targetScale);
+    qCDebug(interfaceapp, "Reseted scale to %f", (double)_targetScale);
 }
 void MyAvatar::goToLocation(const glm::vec3& newPosition,
                             bool hasOrientation, const glm::quat& newOrientation,
                             bool shouldFaceLocation) {
     qCDebug(interfaceapp).nospace() << "MyAvatar goToLocation - moving to " << newPosition.x << ", "
         << newPosition.y << ", " << newPosition.z;
     glm::vec3 shiftedPosition = newPosition;
     if (hasOrientation) {
         qCDebug(interfaceapp).nospace() << "MyAvatar goToLocation - new orientation is "
             << newOrientation.x << ", " << newOrientation.y << ", " << newOrientation.z << ", " << newOrientation.w;
         // orient the user to face the target
         glm::quat quatOrientation = newOrientation;
         if (shouldFaceLocation) {
             quatOrientation = newOrientation * glm::angleAxis(PI, glm::vec3(0.0f, 1.0f, 0.0f));
             // move the user a couple units away
             const float DISTANCE_TO_USER = 2.0f;
             shiftedPosition = newPosition - quatOrientation * IDENTITY_FRONT * DISTANCE_TO_USER;
         }
         setOrientation(quatOrientation);
     }
 //Gets the tip position for the laser pointer
 glm::vec3 MyAvatar::getLaserPointerTipPosition(const PalmData* palm) {
-    const ApplicationOverlay& applicationOverlay = Application::getInstance()->getApplicationOverlay();
     glm::vec3 direction = glm::normalize(palm->getTipPosition() - palm->getPosition());
     glm::vec3 position = palm->getPosition();
     glm::vec3 result;
-    if (applicationOverlay.calculateRayUICollisionPoint(position, direction, result)) {
+    const auto& compositor = qApp->getApplicationCompositor();
+    if (compositor.calculateRayUICollisionPoint(position, direction, result)) {
         return result;
     }
     }
 }
 void MyAvatar::relayDriveKeysToCharacterController() {
     if (_driveKeys[UP] > 0.0f) {
         _characterController.jump();
     }
 }

interface/src/avatar/MyAvatar.h+1−1

@@ -90,7 +90,7 @@ public: · 89 unmodified lines
90		90
91	void relayDriveKeysToCharacterController();	91	void relayDriveKeysToCharacterController();
92		92
93	bool isMyAvatar() { return true; }	93	bool isMyAvatar() const { return true; }
94		94
95	bool isLookingAtLeftEye();	95	bool isLookingAtLeftEye();
96		96

interface/src/devices/CameraToolBox.cpp+0−121

@@ -1,121 +0,0 @@
1	//
2	// CameraToolBox.cpp
3	// interface/src/devices
4	//
5	// Created by David Rowe on 30 Apr 2015.
6	// Copyright 2015 High Fidelity, Inc.
7	//
8	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//
11
12	#include "InterfaceConfig.h"
13
14	#include <GLCanvas.h>
15	#include <PathUtils.h>
16
17	#include "gpu/GLBackend.h"
18	#include "Application.h"
19	#include "CameraToolBox.h"
20	#include "FaceTracker.h"
21
22
23	CameraToolBox::CameraToolBox() :
24	_iconPulseTimeReference(usecTimestampNow()),
25	_doubleClickTimer(NULL)
26	{
27	}
28
29	CameraToolBox::~CameraToolBox() {
30	if (_doubleClickTimer) {
31	_doubleClickTimer->stop();
32	delete _doubleClickTimer;
33	}
34	}
35
36	bool CameraToolBox::mousePressEvent(int x, int y) {
37	if (_iconBounds.contains(x, y)) {
38	if (!_doubleClickTimer) {
39	// Toggle mute after waiting to check that it's not a double-click.
40	const int DOUBLE_CLICK_WAIT = 200; // ms
41	_doubleClickTimer = new QTimer(this);
42	connect(_doubleClickTimer, SIGNAL(timeout()), this, SLOT(toggleMute()));
43	_doubleClickTimer->setSingleShot(true);
44	_doubleClickTimer->setInterval(DOUBLE_CLICK_WAIT);
45	_doubleClickTimer->start();
46	}
47	return true;
48	}
49	return false;
50	}
51
52	bool CameraToolBox::mouseDoublePressEvent(int x, int y) {
53	if (_iconBounds.contains(x, y)) {
54	if (_doubleClickTimer) {
55	_doubleClickTimer->stop();
56	delete _doubleClickTimer;
57	_doubleClickTimer = NULL;
58	}
59	Application::getInstance()->resetSensors();
60	return true;
61	}
62	return false;
63	}
64
65	void CameraToolBox::toggleMute() {
66	delete _doubleClickTimer;
67	_doubleClickTimer = NULL;
68
69	FaceTracker* faceTracker = Application::getInstance()->getSelectedFaceTracker();
70	if (faceTracker) {
71	faceTracker->toggleMute();
72	}
73	}
74
75	void CameraToolBox::render(int x, int y, bool boxed) {
76	glEnable(GL_TEXTURE_2D);
77
78	if (!_enabledTexture) {
79	_enabledTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/face.svg");
80	}
81	if (!_mutedTexture) {
82	_mutedTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/face-mute.svg");
83	}
84
85	const int MUTE_ICON_SIZE = 24;
86	_iconBounds = QRect(x, y, MUTE_ICON_SIZE, MUTE_ICON_SIZE);
87	float iconColor = 1.0f;
88	if (!Menu::getInstance()->isOptionChecked(MenuOption::MuteFaceTracking)) {
89	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_enabledTexture));
90	} else {
91	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_mutedTexture));
92
93	// Make muted icon pulsate
94	static const float PULSE_MIN = 0.4f;
95	static const float PULSE_MAX = 1.0f;
96	static const float PULSE_FREQUENCY = 1.0f; // in Hz
97	qint64 now = usecTimestampNow();
98	if (now - _iconPulseTimeReference > (qint64)USECS_PER_SECOND) {
99	// Prevents t from getting too big, which would diminish glm::cos precision
100	_iconPulseTimeReference = now - ((now - _iconPulseTimeReference) % USECS_PER_SECOND);
101	}
102	float t = (float)(now - _iconPulseTimeReference) / (float)USECS_PER_SECOND;
103	float pulseFactor = (glm::cos(t * PULSE_FREQUENCY * 2.0f * PI) + 1.0f) / 2.0f;
104	iconColor = PULSE_MIN + (PULSE_MAX - PULSE_MIN) * pulseFactor;
105	}
106
107	glm::vec4 quadColor(iconColor, iconColor, iconColor, 1.0f);
108
109	glm::vec2 topLeft(_iconBounds.left(), _iconBounds.top());
110	glm::vec2 bottomRight(_iconBounds.right(), _iconBounds.bottom());
111	glm::vec2 texCoordTopLeft(1,1);
112	glm::vec2 texCoordBottomRight(0,0);
113
114	if (_boxQuadID == GeometryCache::UNKNOWN_ID) {
115	_boxQuadID = DependencyManager::get<GeometryCache>()->allocateID();
116	}
117
118	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, quadColor, _boxQuadID);
119
120	glDisable(GL_TEXTURE_2D);
121	}

interface/src/devices/CameraToolBox.h+0−45

@@ -1,45 +0,0 @@
1	//
2	// CameraToolBox.h
3	// interface/src/devices
4	//
5	// Created by David Rowe on 30 Apr 2015.
6	// Copyright 2015 High Fidelity, Inc.
7	//
8	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//
11
12	#ifndef hifi_CameraToolBox_h
13	#define hifi_CameraToolBox_h
14
15	#include <QObject>
16
17	#include <DependencyManager.h>
18	#include <GeometryCache.h>
19
20	class CameraToolBox : public QObject, public Dependency {
21	Q_OBJECT
22	SINGLETON_DEPENDENCY
23
24	public:
25	void render(int x, int y, bool boxed);
26	bool mousePressEvent(int x, int y);
27	bool mouseDoublePressEvent(int x, int y);
28
29	protected:
30	CameraToolBox();
31	~CameraToolBox();
32
33	private slots:
34	void toggleMute();
35
36	private:
37	gpu::TexturePointer _enabledTexture;
38	gpu::TexturePointer _mutedTexture;
39	int _boxQuadID = GeometryCache::UNKNOWN_ID;
40	QRect _iconBounds;
41	qint64 _iconPulseTimeReference = 0;
42	QTimer* _doubleClickTimer;
43	};
44
45	#endif // hifi_CameraToolBox_h

interface/src/devices/DdeFaceTracker.cpp+6−5

         float browUp = _coefficients[_browUpCenterIndex];
         if (isFiltering) {
             const float BROW_VELOCITY_FILTER_STRENGTH = 0.5f;
-            float velocity = fabs(browUp - _lastBrowUp) / _averageMessageTime;
+            float velocity = fabsf(browUp - _lastBrowUp) / _averageMessageTime;
             float velocityFilter = glm::clamp(velocity * BROW_VELOCITY_FILTER_STRENGTH, 0.0f, 1.0f);
             _filteredBrowUp = velocityFilter * browUp + (1.0f - velocityFilter) * _filteredBrowUp;
             _lastBrowUp = browUp;
         // Velocity filter EyeBlink values
         const float DDE_EYEBLINK_SCALE = 3.0f;
-        float eyeBlinks[] = { DDE_EYEBLINK_SCALE * _coefficients[_leftBlinkIndex], DDE_EYEBLINK_SCALE * _coefficients[_rightBlinkIndex] };
+        float eyeBlinks[] = { DDE_EYEBLINK_SCALE * _coefficients[_leftBlinkIndex],
+                              DDE_EYEBLINK_SCALE * _coefficients[_rightBlinkIndex] };
         if (isFiltering) {
             const float BLINK_VELOCITY_FILTER_STRENGTH = 0.3f;
             for (int i = 0; i < 2; i++) {
-                float velocity = fabs(eyeBlinks[i] - _lastEyeBlinks[i]) / _averageMessageTime;
+                float velocity = fabsf(eyeBlinks[i] - _lastEyeBlinks[i]) / _averageMessageTime;
                 float velocityFilter = glm::clamp(velocity * BLINK_VELOCITY_FILTER_STRENGTH, 0.0f, 1.0f);
                 _filteredEyeBlinks[i] = velocityFilter * eyeBlinks[i] + (1.0f - velocityFilter) * _filteredEyeBlinks[i];
                 _lastEyeBlinks[i] = eyeBlinks[i];
                 if (_eyeStates[i] == EYE_CLOSING) {
                     // Close eyelid until it's fully closed
                     float closingValue = _lastEyeCoefficients[i] + EYELID_MOVEMENT_RATE * _averageMessageTime;
-                    if (closingValue >= 1.0) {
+                    if (closingValue >= 1.0f) {
                         _eyeStates[i] = EYE_CLOSED;
-                        eyeCoefficients[i] = 1.0;
+                        eyeCoefficients[i] = 1.0f;
                     } else {
                         eyeCoefficients[i] = closingValue;
                     }

interface/src/devices/OculusManager.cpp+469−436

@@ -11,13 +11,13 @@ · 10 unmodified lines
11	//	11	//
12		12
13	#include "InterfaceConfig.h"	13	#include "InterfaceConfig.h"
14
15	#include "OculusManager.h"	14	#include "OculusManager.h"
16	#include "ui/overlays/Text3DOverlay.h"	15	#include "ui/overlays/Text3DOverlay.h"
17		16
		17	#include <CursorManager.h>
18	#include <QDesktopWidget>	18	#include <QDesktopWidget>
19	#include <QGuiApplication>	19	#include <QGuiApplication>
20	#include <QScreen>	20	#include <QScreen>
21	#include <QOpenGLTimerQuery>	21	#include <QOpenGLTimerQuery>
22		22
23	#include <glm/glm.hpp>	23	#include <glm/glm.hpp>
@@ -25,6 +25,9 @@ · 1 unmodified line
25	#include <avatar/AvatarManager.h>	25	#include <avatar/AvatarManager.h>
26	#include <avatar/MyAvatar.h>	26	#include <avatar/MyAvatar.h>
27	#include <GlowEffect.h>	27	#include <GlowEffect.h>
		28	#include <GlWindow.h>
		29	#include <gpu/GLBackend.h>
		30	#include <OglplusHelpers.h>
28	#include <PathUtils.h>	31	#include <PathUtils.h>
29	#include <SharedUtil.h>	32	#include <SharedUtil.h>
30	#include <UserActivityLogger.h>	33	#include <UserActivityLogger.h>
@@ -34,8 +37,6 @@ · 3 unmodified lines
34	#include "InterfaceLogging.h"	37	#include "InterfaceLogging.h"
35	#include "Application.h"	38	#include "Application.h"
36		39
37	#include <gpu/GLBackend.h>
38
39	template <typename Function>	40	template <typename Function>
40	void for_each_eye(Function function) {	41	void for_each_eye(Function function) {
41	for (ovrEyeType eye = ovrEyeType::ovrEye_Left;	42	for (ovrEyeType eye = ovrEyeType::ovrEye_Left;
@@ -52,202 +53,413 @@ void for_each_eye(const ovrHmd & hmd, Function function) { · 10 unmodified lines
52	function(eye);	53	function(eye);
53	}	54	}
54	}	55	}
		56	enum CalibrationState {
		57	UNCALIBRATED,
		58	WAITING_FOR_DELTA,
		59	WAITING_FOR_ZERO,
		60	WAITING_FOR_ZERO_HELD,
		61	CALIBRATED
		62	};
		63
		64	inline glm::mat4 toGlm(const ovrMatrix4f & om) {
		65	return glm::transpose(glm::make_mat4(&om.M[0][0]));
		66	}
55		67
56	#ifdef OVR_CLIENT_DISTORTION	68	inline glm::mat4 toGlm(const ovrFovPort & fovport, float nearPlane = 0.01f, float farPlane = 10000.0f) {
57	ProgramObject OculusManager::_program;	69	return toGlm(ovrMatrix4f_Projection(fovport, nearPlane, farPlane, true));
58	int OculusManager::_textureLocation;	70	}
59	int OculusManager::_eyeToSourceUVScaleLocation;
60	int OculusManager::_eyeToSourceUVOffsetLocation;
61	int OculusManager::_eyeRotationStartLocation;
62	int OculusManager::_eyeRotationEndLocation;
63	int OculusManager::_positionAttributeLocation;
64	int OculusManager::_colorAttributeLocation;
65	int OculusManager::_texCoord0AttributeLocation;
66	int OculusManager::_texCoord1AttributeLocation;
67	int OculusManager::_texCoord2AttributeLocation;
68	ovrVector2f OculusManager::_UVScaleOffset[ovrEye_Count][2];
69	GLuint OculusManager::_vertices[ovrEye_Count] = { 0, 0 };
70	GLuint OculusManager::_indices[ovrEye_Count] = { 0, 0 };
71	GLsizei OculusManager::_meshSize[ovrEye_Count] = { 0, 0 };
72	ovrFrameTiming OculusManager::_hmdFrameTiming;
73	bool OculusManager::_programInitialized = false;
74	#endif
75		71
76	ovrTexture OculusManager::_eyeTextures[ovrEye_Count];	72	inline glm::vec3 toGlm(const ovrVector3f & ov) {
77	bool OculusManager::_isConnected = false;	73	return glm::make_vec3(&ov.x);
78	ovrHmd OculusManager::_ovrHmd;	74	}
79	ovrFovPort OculusManager::_eyeFov[ovrEye_Count];
80	ovrVector3f OculusManager::_eyeOffset[ovrEye_Count];
81	ovrEyeRenderDesc OculusManager::_eyeRenderDesc[ovrEye_Count];
82	ovrSizei OculusManager::_renderTargetSize;
83	glm::mat4 OculusManager::_eyeProjection[ovrEye_Count];
84	unsigned int OculusManager::_frameIndex = 0;
85	bool OculusManager::_frameTimingActive = false;
86	Camera* OculusManager::_camera = NULL;
87	ovrEyeType OculusManager::_activeEye = ovrEye_Count;
88	bool OculusManager::_hswDismissed = false;
89
90	float OculusManager::CALIBRATION_DELTA_MINIMUM_LENGTH = 0.02f;
91	float OculusManager::CALIBRATION_DELTA_MINIMUM_ANGLE = 5.0f * RADIANS_PER_DEGREE;
92	float OculusManager::CALIBRATION_ZERO_MAXIMUM_LENGTH = 0.01f;
93	float OculusManager::CALIBRATION_ZERO_MAXIMUM_ANGLE = 2.0f * RADIANS_PER_DEGREE;
94	quint64 OculusManager::CALIBRATION_ZERO_HOLD_TIME = 3000000; // usec
95	float OculusManager::CALIBRATION_MESSAGE_DISTANCE = 2.5f;
96	OculusManager::CalibrationState OculusManager::_calibrationState;
97	glm::vec3 OculusManager::_calibrationPosition;
98	glm::quat OculusManager::_calibrationOrientation;
99	quint64 OculusManager::_calibrationStartTime;
100	int OculusManager::_calibrationMessage = 0;
101	glm::vec3 OculusManager::_eyePositions[ovrEye_Count];
102	// TODO expose this as a developer toggle
103	bool OculusManager::_eyePerFrameMode = false;
104	ovrEyeType OculusManager::_lastEyeRendered = ovrEye_Count;
105	ovrSizei OculusManager::_recommendedTexSize = { 0, 0 };
106	float OculusManager::_offscreenRenderScale = 1.0;
107		75
		76	inline glm::vec2 toGlm(const ovrVector2f & ov) {
		77	return glm::make_vec2(&ov.x);
		78	}
108		79
109	void OculusManager::initSdk() {	80	inline glm::ivec2 toGlm(const ovrVector2i & ov) {
110	ovr_Initialize();	81	return glm::ivec2(ov.x, ov.y);
111	_ovrHmd = ovrHmd_Create(0);
112	if (!_ovrHmd) {
113	_ovrHmd = ovrHmd_CreateDebug(ovrHmd_DK2);
114	}
115	}	82	}
116		83
117	void OculusManager::shutdownSdk() {	84	inline glm::uvec2 toGlm(const ovrSizei & ov) {
118	if (_ovrHmd) {	85	return glm::uvec2(ov.w, ov.h);
119	ovrHmd_Destroy(_ovrHmd);
120	_ovrHmd = nullptr;
121	ovr_Shutdown();
122	}
123	}	86	}
124		87
125	void OculusManager::init() {	88	inline glm::quat toGlm(const ovrQuatf & oq) {
126	#ifdef OVR_DIRECT_MODE	89	return glm::make_quat(&oq.x);
127	initSdk();
128	#endif
129	}	90	}
130		91
131	void OculusManager::deinit() {	92	inline glm::mat4 toGlm(const ovrPosef & op) {
132	#ifdef OVR_DIRECT_MODE	93	glm::mat4 orientation = glm::mat4_cast(toGlm(op.Orientation));
133	shutdownSdk();	94	glm::mat4 translation = glm::translate(glm::mat4(), toGlm(op.Position));
134	#endif	95	return translation * orientation;
135	}	96	}
136		97
137	void OculusManager::connect() {	98	inline ovrMatrix4f ovrFromGlm(const glm::mat4 & m) {
138	#ifndef OVR_DIRECT_MODE	99	ovrMatrix4f result;
139	initSdk();	100	glm::mat4 transposed(glm::transpose(m));
140	#endif	101	memcpy(result.M, &(transposed[0][0]), sizeof(float) * 16);
141	_calibrationState = UNCALIBRATED;	102	return result;
142	qCDebug(interfaceapp) << "Oculus SDK" << OVR_VERSION_STRING;	103	}
143	if (_ovrHmd) {	104
144	if (!_isConnected) {	105	inline ovrVector3f ovrFromGlm(const glm::vec3 & v) {
145	UserActivityLogger::getInstance().connectedDevice("hmd", "oculus");	106	return{ v.x, v.y, v.z };
		107	}
		108
		109	inline ovrVector2f ovrFromGlm(const glm::vec2 & v) {
		110	return{ v.x, v.y };
		111	}
		112
		113	inline ovrSizei ovrFromGlm(const glm::uvec2 & v) {
		114	return{ (int)v.x, (int)v.y };
		115	}
		116
		117	inline ovrQuatf ovrFromGlm(const glm::quat & q) {
		118	return{ q.x, q.y, q.z, q.w };
		119	}
		120
		121
		122
		123	#ifdef Q_OS_WIN
		124
		125	// A base class for FBO wrappers that need to use the Oculus C
		126	// API to manage textures via ovrHmd_CreateSwapTextureSetGL,
		127	// ovrHmd_CreateMirrorTextureGL, etc
		128	template <typename C>
		129	struct RiftFramebufferWrapper : public FramebufferWrapper<C, char> {
		130	ovrHmd hmd;
		131	RiftFramebufferWrapper(const ovrHmd & hmd) : hmd(hmd) {
		132	color = 0;
		133	depth = 0;
		134	};
		135
		136	void Resize(const uvec2 & size) {
		137	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, oglplus::GetName(fbo));
		138	glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
		139	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
		140	this->size = size;
		141	initColor();
		142	initDone();
		143	}
		144
		145	protected:
		146	virtual void initDepth() override final {
		147	}
		148	};
		149
		150	// A wrapper for constructing and using a swap texture set,
		151	// where each frame you draw to a texture via the FBO,
		152	// then submit it and increment to the next texture.
		153	// The Oculus SDK manages the creation and destruction of
		154	// the textures
		155	struct SwapFramebufferWrapper : public RiftFramebufferWrapper<ovrSwapTextureSet*> {
		156	SwapFramebufferWrapper(const ovrHmd & hmd)
		157	: RiftFramebufferWrapper(hmd) {
		158	}
		159
		160	~SwapFramebufferWrapper() {
		161	if (color) {
		162	ovrHmd_DestroySwapTextureSet(hmd, color);
		163	color = nullptr;
146	}	164	}
147	_isConnected = true;	165	}
148		166
149	for_each_eye([&](ovrEyeType eye) {	167	void Increment() {
150	_eyeFov[eye] = _ovrHmd->DefaultEyeFov[eye];	168	++color->CurrentIndex;
151	});	169	color->CurrentIndex %= color->TextureCount;
152		170	}
153	ovrGLConfig cfg;	171
154	memset(&cfg, 0, sizeof(cfg));	172	protected:
155	cfg.OGL.Header.API = ovrRenderAPI_OpenGL;	173	virtual void initColor() override {
156	cfg.OGL.Header.BackBufferSize = _ovrHmd->Resolution;	174	if (color) {
157	cfg.OGL.Header.Multisample = 1;	175	ovrHmd_DestroySwapTextureSet(hmd, color);
158		176	color = nullptr;
159	int distortionCaps = 0	177	}
160	\| ovrDistortionCap_Vignette	178
161	\| ovrDistortionCap_Overdrive	179	ovrResult result = ovrHmd_CreateSwapTextureSetGL(hmd, GL_RGBA, size.x, size.y, &color);
162	\| ovrDistortionCap_TimeWarp;	180	Q_ASSERT(OVR_SUCCESS(result));
163		181
164	int configResult = ovrHmd_ConfigureRendering(_ovrHmd, &cfg.Config,	182	for (int i = 0; i < color->TextureCount; ++i) {
165	distortionCaps, _eyeFov, _eyeRenderDesc);	183	ovrGLTexture& ovrTex = (ovrGLTexture&)color->Textures[i];
166	assert(configResult);	184	glBindTexture(GL_TEXTURE_2D, ovrTex.OGL.TexId);
167		185	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
168		186	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
169	_recommendedTexSize = ovrHmd_GetFovTextureSize(_ovrHmd, ovrEye_Left, _eyeFov[ovrEye_Left], 1.0f);	187	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
170	_renderTargetSize = { _recommendedTexSize.w * 2, _recommendedTexSize.h };	188	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
171	for_each_eye([&](ovrEyeType eye) {	189	}
172	//Get texture size	190	glBindTexture(GL_TEXTURE_2D, 0);
173	_eyeTextures[eye].Header.API = ovrRenderAPI_OpenGL;	191	}
174	_eyeTextures[eye].Header.TextureSize = _renderTargetSize;	192
175	_eyeTextures[eye].Header.RenderViewport.Pos = { 0, 0 };	193	virtual void initDone() override {
176	});	194	}
177	_eyeTextures[ovrEye_Right].Header.RenderViewport.Pos.x = _recommendedTexSize.w;	195
178		196	virtual void onBind(oglplus::Framebuffer::Target target) override {
179	ovrHmd_SetEnabledCaps(_ovrHmd, ovrHmdCap_LowPersistence \| ovrHmdCap_DynamicPrediction);	197	ovrGLTexture& tex = (ovrGLTexture&)(color->Textures[color->CurrentIndex]);
180		198	glFramebufferTexture2D(toEnum(target), GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex.OGL.TexId, 0);
181	ovrHmd_ConfigureTracking(_ovrHmd, ovrTrackingCap_Orientation \| ovrTrackingCap_Position \|	199	}
182	ovrTrackingCap_MagYawCorrection,	200
183	ovrTrackingCap_Orientation);	201	virtual void onUnbind(oglplus::Framebuffer::Target target) override {
184		202	glFramebufferTexture2D(toEnum(target), GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
185	if (!_camera) {	203	}
186	_camera = new Camera;	204	};
187	configureCamera(*_camera); // no need to use screen dimensions; they're ignored	205
		206
		207	// We use a FBO to wrap the mirror texture because it makes it easier to
		208	// render to the screen via glBlitFramebuffer
		209	struct MirrorFramebufferWrapper : public RiftFramebufferWrapper<ovrGLTexture*> {
		210	MirrorFramebufferWrapper(const ovrHmd & hmd)
		211	: RiftFramebufferWrapper(hmd) {
		212	}
		213
		214	virtual ~MirrorFramebufferWrapper() {
		215	if (color) {
		216	ovrHmd_DestroyMirrorTexture(hmd, (ovrTexture*)color);
		217	color = nullptr;
188	}	218	}
189	#ifdef OVR_CLIENT_DISTORTION	219	}
190	if (!_programInitialized) {	220
191	// Shader program	221	private:
192	_programInitialized = true;	222	void initColor() override {
193	_program.addShaderFromSourceFile(QGLShader::Vertex, PathUtils::resourcesPath() + "shaders/oculus.vert");	223	if (color) {
194	_program.addShaderFromSourceFile(QGLShader::Fragment, PathUtils::resourcesPath() + "shaders/oculus.frag");	224	ovrHmd_DestroyMirrorTexture(hmd, (ovrTexture*)color);
195	_program.link();	225	color = nullptr;
196
197	// Uniforms
198	_textureLocation = _program.uniformLocation("texture");
199	_eyeToSourceUVScaleLocation = _program.uniformLocation("EyeToSourceUVScale");
200	_eyeToSourceUVOffsetLocation = _program.uniformLocation("EyeToSourceUVOffset");
201	_eyeRotationStartLocation = _program.uniformLocation("EyeRotationStart");
202	_eyeRotationEndLocation = _program.uniformLocation("EyeRotationEnd");
203
204	// Attributes
205	_positionAttributeLocation = _program.attributeLocation("position");
206	_colorAttributeLocation = _program.attributeLocation("color");
207	_texCoord0AttributeLocation = _program.attributeLocation("texCoord0");
208	_texCoord1AttributeLocation = _program.attributeLocation("texCoord1");
209	_texCoord2AttributeLocation = _program.attributeLocation("texCoord2");
210	}	226	}
		227	ovrResult result = ovrHmd_CreateMirrorTextureGL(hmd, GL_RGBA, size.x, size.y, (ovrTexture**)&color);
		228	Q_ASSERT(OVR_SUCCESS(result));
		229	}
		230
		231	void initDone() override {
		232	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, oglplus::GetName(fbo));
		233	glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color->OGL.TexId, 0);
		234	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
		235	}
		236	};
		237
		238	static SwapFramebufferWrapper* _swapFbo{ nullptr };
		239	static MirrorFramebufferWrapper* _mirrorFbo{ nullptr };
		240	static ovrLayerEyeFov _sceneLayer;
		241
		242	#else
		243
		244	static ovrTexture _eyeTextures[ovrEye_Count];
		245	static GlWindow* _outputWindow{ nullptr };
211		246
212	//Generate the distortion VBOs
213	generateDistortionMesh();
214	#endif	247	#endif
215	} else {	248
		249	static bool _isConnected = false;
		250	static ovrHmd _ovrHmd;
		251	static ovrFovPort _eyeFov[ovrEye_Count];
		252	static ovrVector3f _eyeOffset[ovrEye_Count];
		253	static ovrEyeRenderDesc _eyeRenderDesc[ovrEye_Count];
		254	static ovrSizei _renderTargetSize;
		255	static glm::mat4 _eyeProjection[ovrEye_Count];
		256	static unsigned int _frameIndex = 0;
		257	static bool _frameTimingActive = false;
		258	static Camera* _camera = NULL;
		259	static ovrEyeType _activeEye = ovrEye_Count;
		260	static bool _hswDismissed = false;
		261
		262	static const float CALIBRATION_DELTA_MINIMUM_LENGTH = 0.02f;
		263	static const float CALIBRATION_DELTA_MINIMUM_ANGLE = 5.0f * RADIANS_PER_DEGREE;
		264	static const float CALIBRATION_ZERO_MAXIMUM_LENGTH = 0.01f;
		265	static const float CALIBRATION_ZERO_MAXIMUM_ANGLE = 2.0f * RADIANS_PER_DEGREE;
		266	static const quint64 CALIBRATION_ZERO_HOLD_TIME = 3000000; // usec
		267	static const float CALIBRATION_MESSAGE_DISTANCE = 2.5f;
		268	static CalibrationState _calibrationState;
		269	static glm::vec3 _calibrationPosition;
		270	static glm::quat _calibrationOrientation;
		271	static quint64 _calibrationStartTime;
		272	static int _calibrationMessage = 0;
		273	static glm::vec3 _eyePositions[ovrEye_Count];
		274	// TODO expose this as a developer toggle
		275	static bool _eyePerFrameMode = false;
		276	static ovrEyeType _lastEyeRendered = ovrEye_Count;
		277	static ovrSizei _recommendedTexSize = { 0, 0 };
		278	static float _offscreenRenderScale = 1.0;
		279	static glm::mat4 _combinedProjection;
		280	static ovrPosef _eyeRenderPoses[ovrEye_Count];
		281	static ovrRecti _eyeViewports[ovrEye_Count];
		282	static ovrVector3f _eyeOffsets[ovrEye_Count];
		283
		284	glm::vec3 OculusManager::getLeftEyePosition() { return _eyePositions[ovrEye_Left]; }
		285	glm::vec3 OculusManager::getRightEyePosition() { return _eyePositions[ovrEye_Right]; }
		286
		287	void OculusManager::connect(QOpenGLContext* shareContext) {
		288	qCDebug(interfaceapp) << "Oculus SDK" << OVR_VERSION_STRING;
		289
		290	ovrInitParams initParams; memset(&initParams, 0, sizeof(initParams));
		291
		292	#ifdef DEBUG
		293	initParams.Flags \|= ovrInit_Debug;
		294	#endif
		295
		296	ovr_Initialize(&initParams);
		297
		298	#ifdef Q_OS_WIN
		299
		300	ovrResult res = ovrHmd_Create(0, &_ovrHmd);
		301	#ifdef DEBUG
		302	if (!OVR_SUCCESS(res)) {
		303	res = ovrHmd_CreateDebug(ovrHmd_DK2, &_ovrHmd);
		304	Q_ASSERT(OVR_SUCCESS(res));
		305	}
		306	#endif
		307
		308	#else
		309
		310	_ovrHmd = ovrHmd_Create(0);
		311	#ifdef DEBUG
		312	if (!_ovrHmd) {
		313	_ovrHmd = ovrHmd_CreateDebug(ovrHmd_DK2);
		314	}
		315	#endif
		316
		317	#endif
		318
		319	if (!_ovrHmd) {
216	_isConnected = false;	320	_isConnected = false;
217		321
218	// we're definitely not in "VR mode" so tell the menu that	322	// we're definitely not in "VR mode" so tell the menu that
219	Menu::getInstance()->getActionForOption(MenuOption::EnableVRMode)->setChecked(false);	323	Menu::getInstance()->getActionForOption(MenuOption::EnableVRMode)->setChecked(false);
		324	ovr_Shutdown();
		325	return;
		326	}
		327
		328	_calibrationState = UNCALIBRATED;
		329	if (!_isConnected) {
		330	UserActivityLogger::getInstance().connectedDevice("hmd", "oculus");
		331	}
		332	_isConnected = true;
		333
		334	for_each_eye([&](ovrEyeType eye) {
		335	_eyeFov[eye] = _ovrHmd->DefaultEyeFov[eye];
		336	_eyeProjection[eye] = toGlm(ovrMatrix4f_Projection(_eyeFov[eye],
		337	DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP, ovrProjection_RightHanded));
		338	ovrEyeRenderDesc erd = ovrHmd_GetRenderDesc(_ovrHmd, eye, _eyeFov[eye]);
		339	_eyeOffsets[eye] = erd.HmdToEyeViewOffset;
		340	});
		341	ovrFovPort combinedFov = _ovrHmd->MaxEyeFov[0];
		342	combinedFov.RightTan = _ovrHmd->MaxEyeFov[1].RightTan;
		343	_combinedProjection = toGlm(ovrMatrix4f_Projection(combinedFov,
		344	DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP, ovrProjection_RightHanded));
		345
		346	_recommendedTexSize = ovrHmd_GetFovTextureSize(_ovrHmd, ovrEye_Left, _eyeFov[ovrEye_Left], 1.0f);
		347	_renderTargetSize = { _recommendedTexSize.w * 2, _recommendedTexSize.h };
		348
		349	#ifdef Q_OS_WIN
		350
		351	_mirrorFbo = new MirrorFramebufferWrapper(_ovrHmd);
		352	_swapFbo = new SwapFramebufferWrapper(_ovrHmd);
		353	_swapFbo->Init(toGlm(_renderTargetSize));
		354	_sceneLayer.ColorTexture[0] = _swapFbo->color;
		355	_sceneLayer.ColorTexture[1] = nullptr;
		356	_sceneLayer.Viewport[0].Pos = { 0, 0 };
		357	_sceneLayer.Viewport[0].Size = _recommendedTexSize;
		358	_sceneLayer.Viewport[1].Pos = { _recommendedTexSize.w, 0 };
		359	_sceneLayer.Viewport[1].Size = _recommendedTexSize;
		360	_sceneLayer.Header.Type = ovrLayerType_EyeFov;
		361	_sceneLayer.Header.Flags = ovrLayerFlag_TextureOriginAtBottomLeft;
		362	for_each_eye([&](ovrEyeType eye) {
		363	_eyeViewports[eye] = _sceneLayer.Viewport[eye];
		364	_sceneLayer.Fov[eye] = _eyeFov[eye];
		365	});
		366
		367
		368
		369	#else
		370	_outputWindow = new GlWindow(shareContext);
		371	_outputWindow->show();
		372	// _outputWindow->setFlags(Qt::FramelessWindowHint );
		373	// _outputWindow->resize(_ovrHmd->Resolution.w, _ovrHmd->Resolution.h);
		374	// _outputWindow->setPosition(_ovrHmd->WindowsPos.x, _ovrHmd->WindowsPos.y);
		375	ivec2 desiredPosition = toGlm(_ovrHmd->WindowsPos);
		376	foreach(QScreen* screen, qGuiApp->screens()) {
		377	ivec2 screenPosition = toGlm(screen->geometry().topLeft());
		378	if (screenPosition == desiredPosition) {
		379	_outputWindow->setScreen(screen);
		380	break;
		381	}
		382	}
		383	_outputWindow->showFullScreen();
		384	_outputWindow->makeCurrent();
		385
		386	ovrGLConfig cfg;
		387	memset(&cfg, 0, sizeof(cfg));
		388	cfg.OGL.Header.API = ovrRenderAPI_OpenGL;
		389	cfg.OGL.Header.BackBufferSize = _ovrHmd->Resolution;
		390	cfg.OGL.Header.Multisample = 0;
		391
		392	int distortionCaps = 0
		393	\| ovrDistortionCap_Vignette
		394	\| ovrDistortionCap_Overdrive
		395	\| ovrDistortionCap_TimeWarp;
		396
		397	int configResult = ovrHmd_ConfigureRendering(_ovrHmd, &cfg.Config,
		398	distortionCaps, _eyeFov, _eyeRenderDesc);
		399	assert(configResult);
		400	_outputWindow->doneCurrent();
		401
		402	for_each_eye([&](ovrEyeType eye) {
		403	//Get texture size
		404	_eyeTextures[eye].Header.API = ovrRenderAPI_OpenGL;
		405	_eyeTextures[eye].Header.TextureSize = _renderTargetSize;
		406	_eyeTextures[eye].Header.RenderViewport.Pos = { 0, 0 };
		407	_eyeTextures[eye].Header.RenderViewport.Size = _renderTargetSize;
		408	_eyeTextures[eye].Header.RenderViewport.Size.w /= 2;
		409	});
		410	_eyeTextures[ovrEye_Right].Header.RenderViewport.Pos.x = _recommendedTexSize.w;
		411	for_each_eye([&](ovrEyeType eye) {
		412	_eyeViewports[eye] = _eyeTextures[eye].Header.RenderViewport;
		413	});
		414	#endif
		415
		416	ovrHmd_SetEnabledCaps(_ovrHmd,
		417	ovrHmdCap_LowPersistence \| ovrHmdCap_DynamicPrediction);
		418
		419	ovrHmd_ConfigureTracking(_ovrHmd,
		420	ovrTrackingCap_Orientation \| ovrTrackingCap_Position \| ovrTrackingCap_MagYawCorrection,
		421	ovrTrackingCap_Orientation);
		422
		423	if (!_camera) {
		424	_camera = new Camera;
		425	configureCamera(*_camera); // no need to use screen dimensions; they're ignored
220	}	426	}
221	}	427	}
222		428
223	//Disconnects and deallocates the OR	429	//Disconnects and deallocates the OR
224	void OculusManager::disconnect() {	430	void OculusManager::disconnect() {
225	if (_isConnected) {	431	if (_isConnected) {
		432
		433	#ifdef Q_OS_WIN
		434	if (_swapFbo) {
		435	delete _swapFbo;
		436	_swapFbo = nullptr;
		437	}
		438
		439	if (_mirrorFbo) {
		440	delete _mirrorFbo;
		441	_mirrorFbo = nullptr;
		442	}
		443	#else
		444	_outputWindow->showNormal();
		445	_outputWindow->deleteLater();
		446	_outputWindow = nullptr;
		447	#endif
		448
		449	if (_ovrHmd) {
		450	ovrHmd_Destroy(_ovrHmd);
		451	_ovrHmd = nullptr;
		452	}
		453	ovr_Shutdown();
		454
226	_isConnected = false;	455	_isConnected = false;
227	// Prepare to potentially have to dismiss the HSW again	456	// Prepare to potentially have to dismiss the HSW again
228	// if the user re-enables VR	457	// if the user re-enables VR
229	_hswDismissed = false;	458	_hswDismissed = false;
230	#ifndef OVR_DIRECT_MODE
231	shutdownSdk();
232	#endif
233
234	#ifdef OVR_CLIENT_DISTORTION
235	//Free the distortion mesh data
236	for (int i = 0; i < ovrEye_Count; i++) {
237	if (_vertices[i] != 0) {
238	glDeleteBuffers(1, &(_vertices[i]));
239	_vertices[i] = 0;
240	}
241	if (_indices[i] != 0) {
242	glDeleteBuffers(1, &(_indices[i]));
243	_indices[i] = 0;
244	}
245	}
246	#endif
247	}	459	}
248	}	460	}
249		461
250	void OculusManager::positionCalibrationBillboard(Text3DOverlay* billboard) {	462	void positionCalibrationBillboard(Text3DOverlay* billboard) {
251	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();	463	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
252	glm::quat headOrientation = myAvatar->getHeadOrientation();	464	glm::quat headOrientation = myAvatar->getHeadOrientation();
253	headOrientation.x = 0;	465	headOrientation.x = 0;
@@ -258,7 +470,7 @@ void OculusManager::positionCalibrationBillboard(Text3DOverlay* billboard) { · 4 unmodified lines
258	billboard->setRotation(headOrientation);	470	billboard->setRotation(headOrientation);
259	}	471	}
260		472
261	void OculusManager::calibrate(glm::vec3 position, glm::quat orientation) {	473	void calibrate(const glm::vec3& position, const glm::quat& orientation) {
262	static QString instructionMessage = "Hold still to calibrate";	474	static QString instructionMessage = "Hold still to calibrate";
263	static QString progressMessage;	475	static QString progressMessage;
264	static Text3DOverlay* billboard;	476	static Text3DOverlay* billboard;
@@ -346,7 +558,7 @@ void OculusManager::calibrate(glm::vec3 position, glm::quat orientation) { · 81 unmodified lines
346	break;	558	break;
347	default:	559	default:
348	break;	560	break;
349		561
350	}	562	}
351	}	563	}
352		564
@@ -363,64 +575,9 @@ void OculusManager::abandonCalibration() { · 10 unmodified lines
363	}	575	}
364	}	576	}
365		577
366	#ifdef OVR_CLIENT_DISTORTION
367	void OculusManager::generateDistortionMesh() {
368
369	//Check if we already have the distortion mesh
370	if (_vertices[0] != 0) {
371	printf("WARNING: Tried to generate Oculus distortion mesh twice without freeing the VBOs.");
372	return;
373	}
374
375	for (int eyeNum = 0; eyeNum < ovrEye_Count; eyeNum++) {
376	// Allocate and generate distortion mesh vertices
377	ovrDistortionMesh meshData;
378	ovrHmd_CreateDistortionMesh(_ovrHmd, _eyeRenderDesc[eyeNum].Eye, _eyeRenderDesc[eyeNum].Fov, _ovrHmd->DistortionCaps, &meshData);
379
380	// Parse the vertex data and create a render ready vertex buffer
381	DistortionVertex* pVBVerts = new DistortionVertex[meshData.VertexCount];
382	_meshSize[eyeNum] = meshData.IndexCount;
383
384	// Convert the oculus vertex data to the DistortionVertex format.
385	DistortionVertex* v = pVBVerts;
386	ovrDistortionVertex* ov = meshData.pVertexData;
387	for (unsigned int vertNum = 0; vertNum < meshData.VertexCount; vertNum++) {
388	v->pos.x = ov->ScreenPosNDC.x;
389	v->pos.y = ov->ScreenPosNDC.y;
390	v->texR.x = ov->TanEyeAnglesR.x;
391	v->texR.y = ov->TanEyeAnglesR.y;
392	v->texG.x = ov->TanEyeAnglesG.x;
393	v->texG.y = ov->TanEyeAnglesG.y;
394	v->texB.x = ov->TanEyeAnglesB.x;
395	v->texB.y = ov->TanEyeAnglesB.y;
396	v->color.r = v->color.g = v->color.b = (GLubyte)(ov->VignetteFactor * 255.99f);
397	v->color.a = (GLubyte)(ov->TimeWarpFactor * 255.99f);
398	v++;
399	ov++;
400	}
401
402	//vertices
403	glGenBuffers(1, &(_vertices[eyeNum]));
404	glBindBuffer(GL_ARRAY_BUFFER, _vertices[eyeNum]);
405	glBufferData(GL_ARRAY_BUFFER, sizeof(DistortionVertex) * meshData.VertexCount, pVBVerts, GL_STATIC_DRAW);
406	glBindBuffer(GL_ARRAY_BUFFER, 0);
407
408	//indices
409	glGenBuffers(1, &(_indices[eyeNum]));
410	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indices[eyeNum]);
411	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short) * meshData.IndexCount, meshData.pIndexData, GL_STATIC_DRAW);
412	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
413
414	//Now that we have the VBOs we can get rid of the mesh data
415	delete [] pVBVerts;
416	ovrHmd_DestroyDistortionMesh(&meshData);
417	}
418
419	}
420	#endif
421		578
422	bool OculusManager::isConnected() {	579	bool OculusManager::isConnected() {
423	return _isConnected && Menu::getInstance()->isOptionChecked(MenuOption::EnableVRMode);	580	return _isConnected;
424	}	581	}
425		582
426	//Begins the frame timing for oculus prediction purposes	583	//Begins the frame timing for oculus prediction purposes
@@ -428,10 +585,6 @@ void OculusManager::beginFrameTiming() { · 1 unmodified line
428	if (_frameTimingActive) {	585	if (_frameTimingActive) {
429	printf("WARNING: Called OculusManager::beginFrameTiming() twice in a row, need to call OculusManager::endFrameTiming().");	586	printf("WARNING: Called OculusManager::beginFrameTiming() twice in a row, need to call OculusManager::endFrameTiming().");
430	}	587	}
431
432	#ifdef OVR_CLIENT_DISTORTION
433	_hmdFrameTiming = ovrHmd_BeginFrameTiming(_ovrHmd, _frameIndex);
434	#endif
435	_frameTimingActive = true;	588	_frameTimingActive = true;
436	}	589	}
437		590
@@ -441,27 +594,18 @@ bool OculusManager::allowSwap() { · 3 unmodified lines
441		594
442	//Ends frame timing	595	//Ends frame timing
443	void OculusManager::endFrameTiming() {	596	void OculusManager::endFrameTiming() {
444	#ifdef OVR_CLIENT_DISTORTION
445	ovrHmd_EndFrameTiming(_ovrHmd);
446	#endif
447	_frameIndex++;	597	_frameIndex++;
448	_frameTimingActive = false;	598	_frameTimingActive = false;
449	}	599	}
450		600
451	//Sets the camera FoV and aspect ratio	601	//Sets the camera FoV and aspect ratio
452	void OculusManager::configureCamera(Camera& camera) {	602	void OculusManager::configureCamera(Camera& camera) {
453	ovrFovPort fov;
454	if (_activeEye == ovrEye_Count) {	603	if (_activeEye == ovrEye_Count) {
455	// When not rendering, provide a FOV encompasing both eyes	604	// When not rendering, provide a FOV encompasing both eyes
456	fov = _eyeFov[0];	605	camera.setProjection(_combinedProjection);
457	fov.RightTan = _eyeFov[1].RightTan;	606	return;
458	} else {	607	}
459	// When rendering, provide the exact FOV	608	camera.setProjection(_eyeProjection[_activeEye]);
460	fov = _eyeFov[_activeEye];
461	}
462	// Convert the FOV to the correct projection matrix
463	glm::mat4 projection = toGlm(ovrMatrix4f_Projection(fov, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP, ovrProjection_RightHanded));
464	camera.setProjection(projection);
465	}	609	}
466		610
467	//Displays everything for the oculus, frame timing must be active	611	//Displays everything for the oculus, frame timing must be active
@@ -473,40 +617,9 @@ void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const · 5 unmodified lines
473	assert(oldFrameIndex == -1 \|\| (unsigned int)oldFrameIndex == _frameIndex - 1);	617	assert(oldFrameIndex == -1 \|\| (unsigned int)oldFrameIndex == _frameIndex - 1);
474	oldFrameIndex = _frameIndex;	618	oldFrameIndex = _frameIndex;
475	#endif	619	#endif
476
477	// Every so often do some additional timing calculations and debug output
478	bool debugFrame = 0 == _frameIndex % 400;
479		620
480	#if 0	621	#ifndef Q_OS_WIN
481	// Try to measure the amount of time taken to do the distortion	622
482	// (does not seem to work on OSX with SDK based distortion)
483	// FIXME can't use a static object here, because it will cause a crash when the
484	// query attempts deconstruct after the GL context is gone.
485	static bool timerActive = false;
486	static QOpenGLTimerQuery timerQuery;
487	if (!timerQuery.isCreated()) {
488	timerQuery.create();
489	}
490
491	if (timerActive && timerQuery.isResultAvailable()) {
492	auto result = timerQuery.waitForResult();
493	if (result) { qCDebug(interfaceapp) << "Distortion took " << result << "ns"; };
494	timerActive = false;
495	}
496	#endif
497
498	#ifdef OVR_DIRECT_MODE
499	static bool attached = false;
500	if (!attached) {
501	attached = true;
502	void * nativeWindowHandle = (void*)(size_t)glCanvas->effectiveWinId();
503	if (nullptr != nativeWindowHandle) {
504	ovrHmd_AttachToWindow(_ovrHmd, nativeWindowHandle, nullptr, nullptr);
505	}
506	}
507	#endif
508
509	#ifndef OVR_CLIENT_DISTORTION
510	// FIXME: we need a better way of responding to the HSW. In particular	623	// FIXME: we need a better way of responding to the HSW. In particular
511	// we need to ensure that it's only displayed once per session, rather than	624	// we need to ensure that it's only displayed once per session, rather than
512	// every time the user toggles VR mode, and we need to hook it up to actual	625	// every time the user toggles VR mode, and we need to hook it up to actual
@@ -522,7 +635,7 @@ void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const · 9 unmodified lines
522	}	635	}
523	}	636	}
524	#endif	637	#endif
525		638
526		639
527	//beginFrameTiming must be called before display	640	//beginFrameTiming must be called before display
528	if (!_frameTimingActive) {	641	if (!_frameTimingActive) {
@@ -545,14 +658,14 @@ void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const · 16 unmodified lines
545		658
546	glMatrixMode(GL_MODELVIEW);	659	glMatrixMode(GL_MODELVIEW);
547	glPushMatrix();	660	glPushMatrix();
548		661
549	glm::quat orientation;	662	glm::quat orientation;
550	glm::vec3 trackerPosition;	663	glm::vec3 trackerPosition;
551	auto deviceSize = qApp->getDeviceSize();	664	auto deviceSize = qApp->getDeviceSize();
552		665
553	ovrTrackingState ts = ovrHmd_GetTrackingState(_ovrHmd, ovr_GetTimeInSeconds());	666	ovrTrackingState ts = ovrHmd_GetTrackingState(_ovrHmd, ovr_GetTimeInSeconds());
554	ovrVector3f ovrHeadPosition = ts.HeadPose.ThePose.Position;	667	ovrVector3f ovrHeadPosition = ts.HeadPose.ThePose.Position;
555		668
556	trackerPosition = glm::vec3(ovrHeadPosition.x, ovrHeadPosition.y, ovrHeadPosition.z);	669	trackerPosition = glm::vec3(ovrHeadPosition.x, ovrHeadPosition.y, ovrHeadPosition.z);
557		670
558	if (_calibrationState != CALIBRATED) {	671	if (_calibrationState != CALIBRATED) {
@@ -562,11 +675,11 @@ void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const · 3 unmodified lines
562	}	675	}
563		676
564	trackerPosition = bodyOrientation * trackerPosition;	677	trackerPosition = bodyOrientation * trackerPosition;
565	static ovrVector3f eyeOffsets[2] = { { 0, 0, 0 }, { 0, 0, 0 } };
566	ovrPosef eyePoses[ovrEye_Count];	678	ovrPosef eyePoses[ovrEye_Count];
567	ovrHmd_GetEyePoses(_ovrHmd, _frameIndex, eyeOffsets, eyePoses, nullptr);	679	ovrHmd_GetEyePoses(_ovrHmd, _frameIndex, _eyeOffsets, eyePoses, nullptr);
		680	#ifndef Q_OS_WIN
568	ovrHmd_BeginFrame(_ovrHmd, _frameIndex);	681	ovrHmd_BeginFrame(_ovrHmd, _frameIndex);
569	static ovrPosef eyeRenderPose[ovrEye_Count];	682	#endif
570	//Render each eye into an fbo	683	//Render each eye into an fbo
571	for_each_eye(_ovrHmd, [&](ovrEyeType eye){	684	for_each_eye(_ovrHmd, [&](ovrEyeType eye){
572	// If we're in eye-per-frame mode, only render one eye	685	// If we're in eye-per-frame mode, only render one eye
@@ -576,29 +689,17 @@ void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const · 3 unmodified lines
576	return;	689	return;
577	}	690	}
578	_lastEyeRendered = _activeEye = eye;	691	_lastEyeRendered = _activeEye = eye;
579	eyeRenderPose[eye] = eyePoses[eye];	692	_eyeRenderPoses[eye] = eyePoses[eye];
580	// Set the camera rotation for this eye	693	// Set the camera rotation for this eye
581	orientation.x = eyeRenderPose[eye].Orientation.x;
582	orientation.y = eyeRenderPose[eye].Orientation.y;
583	orientation.z = eyeRenderPose[eye].Orientation.z;
584	orientation.w = eyeRenderPose[eye].Orientation.w;
585
586	// Update the application camera with the latest HMD position
587	whichCamera.setHmdPosition(trackerPosition);
588	whichCamera.setHmdRotation(orientation);
589
590		694
		695	vec3 eyePosition = toGlm(_eyeRenderPoses[eye].Position);
		696	eyePosition = whichCamera.getRotation() * eyePosition;
		697	quat eyeRotation = toGlm(_eyeRenderPoses[eye].Orientation);
		698
591	// Update our camera to what the application camera is doing	699	// Update our camera to what the application camera is doing
592	_camera->setRotation(whichCamera.getRotation());	700	_camera->setRotation(whichCamera.getRotation() * eyeRotation);
593	_camera->setPosition(whichCamera.getPosition());	701	_camera->setPosition(whichCamera.getPosition() + eyePosition);
594	configureCamera(*_camera);	702	configureCamera(*_camera);
595
596	// Store the latest left and right eye render locations for things that need to know
597	glm::vec3 thisEyePosition = position + trackerPosition +
598	(bodyOrientation * glm::quat(orientation.x, orientation.y, orientation.z, orientation.w) *
599	glm::vec3(_eyeRenderDesc[eye].HmdToEyeViewOffset.x, _eyeRenderDesc[eye].HmdToEyeViewOffset.y, _eyeRenderDesc[eye].HmdToEyeViewOffset.z));
600
601	_eyePositions[eye] = thisEyePosition;
602	_camera->update(1.0f / Application::getInstance()->getFps());	703	_camera->update(1.0f / Application::getInstance()->getFps());
603		704
604	glMatrixMode(GL_PROJECTION);	705	glMatrixMode(GL_PROJECTION);
@@ -607,15 +708,14 @@ void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const · 2 unmodified lines
607	glMatrixMode(GL_MODELVIEW);	708	glMatrixMode(GL_MODELVIEW);
608	glLoadIdentity();	709	glLoadIdentity();
609		710
610	ovrRecti & vp = _eyeTextures[eye].Header.RenderViewport;	711	ovrRecti & vp = _eyeViewports[eye];
611	vp.Size.h = _recommendedTexSize.h * _offscreenRenderScale;	712	vp.Size.h = _recommendedTexSize.h * _offscreenRenderScale;
612	vp.Size.w = _recommendedTexSize.w * _offscreenRenderScale;	713	vp.Size.w = _recommendedTexSize.w * _offscreenRenderScale;
613
614	glViewport(vp.Pos.x, vp.Pos.y, vp.Size.w, vp.Size.h);	714	glViewport(vp.Pos.x, vp.Pos.y, vp.Size.w, vp.Size.h);
615		715
616	renderArgs->_renderSide = RenderArgs::MONO;	716	renderArgs->_renderSide = RenderArgs::MONO;
617	qApp->displaySide(renderArgs, *_camera, false);	717	qApp->displaySide(renderArgs, *_camera);
618	qApp->getApplicationOverlay().displayOverlayTextureHmd(*_camera);	718	qApp->getApplicationCompositor().displayOverlayTextureHmd(renderArgs, eye);
619	});	719	});
620	_activeEye = ovrEye_Count;	720	_activeEye = ovrEye_Count;
621		721
@@ -628,7 +728,7 @@ void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const · 6 unmodified lines
628	glViewport(0, 0, _renderTargetSize.w, _renderTargetSize.h);	728	glViewport(0, 0, _renderTargetSize.w, _renderTargetSize.h);
629	finalFbo = DependencyManager::get<GlowEffect>()->render(renderArgs);	729	finalFbo = DependencyManager::get<GlowEffect>()->render(renderArgs);
630	} else {	730	} else {
631	finalFbo = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();	731	finalFbo = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();
632	glBindFramebuffer(GL_FRAMEBUFFER, 0);	732	glBindFramebuffer(GL_FRAMEBUFFER, 0);
633	}	733	}
634		734
@@ -638,141 +738,73 @@ void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const · 3 unmodified lines
638	// restore our normal viewport	738	// restore our normal viewport
639	glViewport(0, 0, deviceSize.width(), deviceSize.height());	739	glViewport(0, 0, deviceSize.width(), deviceSize.height());
640		740
641	#if 0	741	#ifdef Q_OS_WIN
642	if (debugFrame && !timerActive) {	742	auto srcFboSize = finalFbo->getSize();
643	timerQuery.begin();
644	}
645	#endif
646		743
647	#ifdef OVR_CLIENT_DISTORTION
648
649	//Wait till time-warp to reduce latency
650	ovr_WaitTillTime(_hmdFrameTiming.TimewarpPointSeconds);
651		744
652	#ifdef DEBUG_RENDER_WITHOUT_DISTORTION	745	// Blit to the oculus provided texture
653	auto fboSize = finalFbo->getSize();
654	glBindFramebuffer(GL_READ_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(finalFbo));	746	glBindFramebuffer(GL_READ_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(finalFbo));
		747	_swapFbo->Bound(oglplus::Framebuffer::Target::Draw, [&] {
		748	glBlitFramebuffer(
		749	0, 0, srcFboSize.x, srcFboSize.y,
		750	0, 0, _swapFbo->size.x, _swapFbo->size.y,
		751	GL_COLOR_BUFFER_BIT, GL_NEAREST);
		752	});
		753
		754	// Blit to the onscreen window
		755	auto destWindowSize = qApp->getDeviceSize();
655	glBlitFramebuffer(	756	glBlitFramebuffer(
656	0, 0, fboSize.x, fboSize.y,	757	0, 0, srcFboSize.x, srcFboSize.y,
657	0, 0, deviceSize.width(), deviceSize.height(),	758	0, 0, destWindowSize.width(), destWindowSize.height(),
658	GL_COLOR_BUFFER_BIT, GL_NEAREST);	759	GL_COLOR_BUFFER_BIT, GL_NEAREST);
		760	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
		761
		762	// Submit the frame to the Oculus SDK for timewarp and distortion
		763	for_each_eye([&](ovrEyeType eye) {
		764	_sceneLayer.RenderPose[eye] = _eyeRenderPoses[eye];
		765	});
		766	auto header = &_sceneLayer.Header;
		767	ovrResult res = ovrHmd_SubmitFrame(_ovrHmd, _frameIndex, nullptr, &header, 1);
		768	Q_ASSERT(OVR_SUCCESS(res));
		769	_swapFbo->Increment();
659	#else	770	#else
660	//Clear the color buffer to ensure that there isnt any residual color	771	GLsync syncObject = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
661	//Left over from when OR was not connected.	772	glFlush();
662	glClear(GL_COLOR_BUFFER_BIT);
663	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(finalFbo->getRenderBuffer(0)));
664	//Renders the distorted mesh onto the screen
665	renderDistortionMesh(eyeRenderPose);
666	glBindTexture(GL_TEXTURE_2D, 0);
667	#endif
668	glCanvas->swapBuffers();
669		773
670	#else
671		774
		775	_outputWindow->makeCurrent();
		776	// force the compositing context to wait for the texture
		777	// rendering to complete before it starts the distortion rendering,
		778	// but without triggering a CPU/GPU synchronization
		779	glWaitSync(syncObject, 0, GL_TIMEOUT_IGNORED);
		780	glDeleteSync(syncObject);
		781
		782	GLuint textureId = gpu::GLBackend::getTextureID(finalFbo->getRenderBuffer(0));
672	for_each_eye([&](ovrEyeType eye) {	783	for_each_eye([&](ovrEyeType eye) {
673	ovrGLTexture & glEyeTexture = reinterpret_cast<ovrGLTexture&>(_eyeTextures[eye]);	784	ovrGLTexture & glEyeTexture = reinterpret_cast<ovrGLTexture&>(_eyeTextures[eye]);
674	glEyeTexture.OGL.TexId = finalFbo->texture();	785	glEyeTexture.OGL.TexId = textureId;
675
676	});
677		786
678	ovrHmd_EndFrame(_ovrHmd, eyeRenderPose, _eyeTextures);	787	});
679		788
		789	// restore our normal viewport
		790	ovrHmd_EndFrame(_ovrHmd, _eyeRenderPoses, _eyeTextures);
		791	glCanvas->makeCurrent();
680	#endif	792	#endif
681		793
682	#if 0
683	if (debugFrame && !timerActive) {
684	timerQuery.end();
685	timerActive = true;
686	}
687	#endif
688		794
689	// No DK2, no message.	795	// in order to account account for changes in the pick ray caused by head movement
		796	// we need to force a mouse move event on every frame (perhaps we could change this
		797	// to based on the head moving a minimum distance from the last position in which we
		798	// sent?)
690	{	799	{
691	float latencies[5] = {};	800	QMouseEvent mouseEvent(QEvent::MouseMove, glCanvas->mapFromGlobal(QCursor::pos()),
692	if (debugFrame && ovrHmd_GetFloatArray(_ovrHmd, "DK2Latency", latencies, 5) == 5)	801	Qt::NoButton, Qt::NoButton, 0);
693	{	802	qApp->mouseMoveEvent(&mouseEvent, 0);
694	bool nonZero = false;
695	for (int i = 0; i < 5; ++i)
696	{
697	nonZero \|= (latencies[i] != 0.f);
698	}
699
700	if (nonZero)
701	{
702	qCDebug(interfaceapp) << QString().sprintf("M2P Latency: Ren: %4.2fms TWrp: %4.2fms PostPresent: %4.2fms Err: %4.2fms %4.2fms",
703	latencies[0], latencies[1], latencies[2], latencies[3], latencies[4]);
704	}
705	}
706	}	803	}
707
708	}
709
710	#ifdef OVR_CLIENT_DISTORTION
711	void OculusManager::renderDistortionMesh(ovrPosef eyeRenderPose[ovrEye_Count]) {
712		804
713	glLoadIdentity();
714	auto deviceSize = qApp->getDeviceSize();
715	glOrtho(0, deviceSize.width(), 0, deviceSize.height(), -1.0, 1.0);
716
717	glDisable(GL_DEPTH_TEST);
718
719	glDisable(GL_BLEND);
720	_program.bind();
721	_program.setUniformValue(_textureLocation, 0);
722
723	_program.enableAttributeArray(_positionAttributeLocation);
724	_program.enableAttributeArray(_colorAttributeLocation);
725	_program.enableAttributeArray(_texCoord0AttributeLocation);
726	_program.enableAttributeArray(_texCoord1AttributeLocation);
727	_program.enableAttributeArray(_texCoord2AttributeLocation);
728
729	//Render the distortion meshes for each eye
730	for (int eyeNum = 0; eyeNum < ovrEye_Count; eyeNum++) {
731
732	ovrHmd_GetRenderScaleAndOffset(_eyeRenderDesc[eyeNum].Fov, _renderTargetSize, _eyeTextures[eyeNum].Header.RenderViewport,
733	_UVScaleOffset[eyeNum]);
734
735	GLfloat uvScale[2] = { _UVScaleOffset[eyeNum][0].x, _UVScaleOffset[eyeNum][0].y };
736	_program.setUniformValueArray(_eyeToSourceUVScaleLocation, uvScale, 1, 2);
737	GLfloat uvOffset[2] = { _UVScaleOffset[eyeNum][1].x, 1.0f - _UVScaleOffset[eyeNum][1].y };
738	_program.setUniformValueArray(_eyeToSourceUVOffsetLocation, uvOffset, 1, 2);
739
740	ovrMatrix4f timeWarpMatrices[2];
741	glm::mat4 transposeMatrices[2];
742	//Grabs the timewarp matrices to be used in the shader
743	ovrHmd_GetEyeTimewarpMatrices(_ovrHmd, (ovrEyeType)eyeNum, eyeRenderPose[eyeNum], timeWarpMatrices);
744	//Have to transpose the matrices before using them
745	transposeMatrices[0] = glm::transpose(toGlm(timeWarpMatrices[0]));
746	transposeMatrices[1] = glm::transpose(toGlm(timeWarpMatrices[1]));
747		805
748	glUniformMatrix4fv(_eyeRotationStartLocation, 1, GL_FALSE, (GLfloat *)&transposeMatrices[0][0][0]);
749	glUniformMatrix4fv(_eyeRotationEndLocation, 1, GL_FALSE, (GLfloat *)&transposeMatrices[1][0][0]);
750		806
751	glBindBuffer(GL_ARRAY_BUFFER, _vertices[eyeNum]);
752
753	//Set vertex attribute pointers
754	glVertexAttribPointer(_positionAttributeLocation, 2, GL_FLOAT, GL_FALSE, sizeof(DistortionVertex), (void *)0);
755	glVertexAttribPointer(_texCoord0AttributeLocation, 2, GL_FLOAT, GL_FALSE, sizeof(DistortionVertex), (void *)8);
756	glVertexAttribPointer(_texCoord1AttributeLocation, 2, GL_FLOAT, GL_FALSE, sizeof(DistortionVertex), (void *)16);
757	glVertexAttribPointer(_texCoord2AttributeLocation, 2, GL_FLOAT, GL_FALSE, sizeof(DistortionVertex), (void *)24);
758	glVertexAttribPointer(_colorAttributeLocation, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(DistortionVertex), (void *)32);
759
760	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indices[eyeNum]);
761	glDrawElements(GL_TRIANGLES, _meshSize[eyeNum], GL_UNSIGNED_SHORT, 0);
762	}
763
764	_program.disableAttributeArray(_positionAttributeLocation);
765	_program.disableAttributeArray(_colorAttributeLocation);
766	_program.disableAttributeArray(_texCoord0AttributeLocation);
767	_program.disableAttributeArray(_texCoord1AttributeLocation);
768	_program.disableAttributeArray(_texCoord2AttributeLocation);
769
770	glEnable(GL_BLEND);
771	glEnable(GL_DEPTH_TEST);
772	_program.release();
773	glBindBuffer(GL_ARRAY_BUFFER, 0);
774	}	807	}
775	#endif
776		808
777	//Tries to reconnect to the sensors	809	//Tries to reconnect to the sensors
778	void OculusManager::reset() {	810	void OculusManager::reset() {
@@ -781,21 +813,6 @@ void OculusManager::reset() { · 2 unmodified lines
781	}	813	}
782	}	814	}
783		815
784	//Gets the current predicted angles from the oculus sensors
785	void OculusManager::getEulerAngles(float& yaw, float& pitch, float& roll) {
786	ovrTrackingState ts = ovrHmd_GetTrackingState(_ovrHmd, ovr_GetTimeInSeconds());
787	if (ts.StatusFlags & (ovrStatus_OrientationTracked \| ovrStatus_PositionTracked)) {
788	glm::vec3 euler = glm::eulerAngles(toGlm(ts.HeadPose.ThePose.Orientation));
789	yaw = euler.y;
790	pitch = euler.x;
791	roll = euler.z;
792	} else {
793	yaw = 0.0f;
794	pitch = 0.0f;
795	roll = 0.0f;
796	}
797	}
798
799	glm::vec3 OculusManager::getRelativePosition() {	816	glm::vec3 OculusManager::getRelativePosition() {
800	ovrTrackingState trackingState = ovrHmd_GetTrackingState(_ovrHmd, ovr_GetTimeInSeconds());	817	ovrTrackingState trackingState = ovrHmd_GetTrackingState(_ovrHmd, ovr_GetTimeInSeconds());
801	return toGlm(trackingState.HeadPose.ThePose.Position);	818	return toGlm(trackingState.HeadPose.ThePose.Position);
@@ -826,6 +843,9 @@ void OculusManager::overrideOffAxisFrustum(float& left, float& right, float& bot · 24 unmodified lines
826	}	843	}
827		844
828	int OculusManager::getHMDScreen() {	845	int OculusManager::getHMDScreen() {
		846	#ifdef Q_OS_WIN
		847	return -1;
		848	#else
829	int hmdScreenIndex = -1; // unknown	849	int hmdScreenIndex = -1; // unknown
830	// TODO: it might be smarter to handle multiple HMDs connected in this case. but for now,	850	// TODO: it might be smarter to handle multiple HMDs connected in this case. but for now,
831	// we will simply assume the initialization code that set up _ovrHmd picked the best hmd	851	// we will simply assume the initialization code that set up _ovrHmd picked the best hmd
@@ -844,7 +864,7 @@ int OculusManager::getHMDScreen() { · 12 unmodified lines
844	const int SIMILAR_NAMES = 10;	864	const int SIMILAR_NAMES = 10;
845	const int EXACT_LOCATION_MATCH = 50;	865	const int EXACT_LOCATION_MATCH = 50;
846	const int EXACT_RESOLUTION_MATCH = 25;	866	const int EXACT_RESOLUTION_MATCH = 25;
847		867
848	int bestMatchScore = 0;	868	int bestMatchScore = 0;
849		869
850	// look at the display list and see if we can find the best match	870	// look at the display list and see if we can find the best match
@@ -853,7 +873,7 @@ int OculusManager::getHMDScreen() { · 2 unmodified lines
853	foreach (QScreen* screen, QGuiApplication::screens()) {	873	foreach (QScreen* screen, QGuiApplication::screens()) {
854	QString screenName = screen->name();	874	QString screenName = screen->name();
855	QRect screenRect = desktop->screenGeometry(screenNumber);	875	QRect screenRect = desktop->screenGeometry(screenNumber);
856		876
857	int screenScore = 0;	877	int screenScore = 0;
858	if (screenName == productNameFromOVR) {	878	if (screenName == productNameFromOVR) {
859	screenScore += EXACT_NAME_MATCH;	879	screenScore += EXACT_NAME_MATCH;
@@ -876,5 +896,18 @@ int OculusManager::getHMDScreen() { · 16 unmodified lines
876	}	896	}
877	}	897	}
878	return hmdScreenIndex;	898	return hmdScreenIndex;
		899	#endif
		900	}
		901
		902	mat4 OculusManager::getEyeProjection(int eye) {
		903	return _eyeProjection[eye];
879	}	904	}
880		905
		906	mat4 OculusManager::getEyePose(int eye) {
		907	return toGlm(_eyeRenderPoses[eye]);
		908	}
		909
		910	mat4 OculusManager::getHeadPose() {
		911	ovrTrackingState ts = ovrHmd_GetTrackingState(_ovrHmd, ovr_GetTimeInSeconds());
		912	return toGlm(ts.HeadPose.ThePose);
		913	}

interface/src/devices/OculusManager.h+7−170

@@ -13,8 +13,6 @@ · 12 unmodified lines
13	#ifndef hifi_OculusManager_h	13	#ifndef hifi_OculusManager_h
14	#define hifi_OculusManager_h	14	#define hifi_OculusManager_h
15		15
16	#include <OVR_CAPI.h>
17
18	#include <ProgramObject.h>	16	#include <ProgramObject.h>
19	#include <glm/glm.hpp>	17	#include <glm/glm.hpp>
20	#include <glm/gtc/matrix_transform.hpp>	18	#include <glm/gtc/matrix_transform.hpp>
@@ -22,39 +20,13 @@ · 1 unmodified line
22		20
23	#include "RenderArgs.h"	21	#include "RenderArgs.h"
24		22
		23	class QOpenGLContext;
25	class Camera;	24	class Camera;
26	class PalmData;
27	class Text3DOverlay;
28
29	// Uncomment this to enable client side distortion. NOT recommended since
30	// the Oculus SDK will ideally provide the best practices for distortion in
31	// in terms of performance and quality, and by using it we will get updated
32	// best practices for free with new runtime releases.
33	#define OVR_CLIENT_DISTORTION 1
34
35
36	// Direct HMD mode is currently only supported on windows and some linux systems will
37	// misbehave if we try to enable the Oculus SDK at all, so isolate support for Direct
38	// mode only to windows for now
39	#ifdef Q_OS_WIN
40	// On Win32 platforms, enabling Direct HMD requires that the SDK be
41	// initialized before the GL context is set up, but this breaks v-sync
42	// for any application that has a Direct mode enable Rift connected
43	// but is not rendering to it. For the time being I'm setting this as
44	// a macro enabled mechanism which changes where the SDK is initialized.
45	// To enable Direct HMD mode, you can un-comment this, but with the
46	// caveat that it will break v-sync in NON-VR mode if you have an Oculus
47	// Rift connect and in Direct mode
48	#define OVR_DIRECT_MODE 1
49	#endif
50
51		25
52	/// Handles interaction with the Oculus Rift.	26	/// Handles interaction with the Oculus Rift.
53	class OculusManager {	27	class OculusManager {
54	public:	28	public:
55	static void init();	29	static void connect(QOpenGLContext* shareContext);
56	static void deinit();
57	static void connect();
58	static void disconnect();	30	static void disconnect();
59	static bool isConnected();	31	static bool isConnected();
60	static void recalibrate();	32	static void recalibrate();
@@ -66,10 +38,6 @@ public: · 5 unmodified lines
66	static void display(QGLWidget * glCanvas, RenderArgs* renderArgs, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera);	38	static void display(QGLWidget * glCanvas, RenderArgs* renderArgs, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera);
67	static void reset();	39	static void reset();
68		40
69	/// param \yaw[out] yaw in radians
70	/// param \pitch[out] pitch in radians
71	/// param \roll[out] roll in radians
72	static void getEulerAngles(float& yaw, float& pitch, float& roll);
73	static glm::vec3 getRelativePosition();	41	static glm::vec3 getRelativePosition();
74	static glm::quat getOrientation();	42	static glm::quat getOrientation();
75	static QSize getRenderTargetSize();	43	static QSize getRenderTargetSize();
@@ -77,145 +45,14 @@ public: · 1 unmodified line
77	static void overrideOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& nearVal,	45	static void overrideOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& nearVal,
78	float& farVal, glm::vec4& nearClipPlane, glm::vec4& farClipPlane);	46	float& farVal, glm::vec4& nearClipPlane, glm::vec4& farClipPlane);
79		47
80	static glm::vec3 getLeftEyePosition() { return _eyePositions[ovrEye_Left]; }	48	static glm::vec3 getLeftEyePosition();
81	static glm::vec3 getRightEyePosition() { return _eyePositions[ovrEye_Right]; }	49	static glm::vec3 getRightEyePosition();
82		50
83	static int getHMDScreen();	51	static int getHMDScreen();
84
85	private:
86	static void initSdk();
87	static void shutdownSdk();
88	#ifdef OVR_CLIENT_DISTORTION
89	static void generateDistortionMesh();
90	static void renderDistortionMesh(ovrPosef eyeRenderPose[ovrEye_Count]);
91	struct DistortionVertex {
92	glm::vec2 pos;
93	glm::vec2 texR;
94	glm::vec2 texG;
95	glm::vec2 texB;
96	struct {
97	GLubyte r;
98	GLubyte g;
99	GLubyte b;
100	GLubyte a;
101	} color;
102	};
103		52
104	static ProgramObject _program;	53	static glm::mat4 getEyeProjection(int eye);
105	//Uniforms	54	static glm::mat4 getEyePose(int eye);
106	static int _textureLocation;	55	static glm::mat4 getHeadPose();
107	static int _eyeToSourceUVScaleLocation;
108	static int _eyeToSourceUVOffsetLocation;
109	static int _eyeRotationStartLocation;
110	static int _eyeRotationEndLocation;
111	//Attributes
112	static int _positionAttributeLocation;
113	static int _colorAttributeLocation;
114	static int _texCoord0AttributeLocation;
115	static int _texCoord1AttributeLocation;
116	static int _texCoord2AttributeLocation;
117	static ovrVector2f _UVScaleOffset[ovrEye_Count][2];
118	static GLuint _vertices[ovrEye_Count];
119	static GLuint _indices[ovrEye_Count];
120	static GLsizei _meshSize[ovrEye_Count];
121	static ovrFrameTiming _hmdFrameTiming;
122	static bool _programInitialized;
123	#endif
124
125	static ovrTexture _eyeTextures[ovrEye_Count];
126	static bool _isConnected;
127	static glm::vec3 _eyePositions[ovrEye_Count];
128	static ovrHmd _ovrHmd;
129	static ovrFovPort _eyeFov[ovrEye_Count];
130	static ovrVector3f _eyeOffset[ovrEye_Count];
131	static glm::mat4 _eyeProjection[ovrEye_Count];
132	static ovrEyeRenderDesc _eyeRenderDesc[ovrEye_Count];
133	static ovrSizei _renderTargetSize;
134	static unsigned int _frameIndex;
135	static bool _frameTimingActive;
136	static Camera* _camera;
137	static ovrEyeType _activeEye;
138	static bool _hswDismissed;
139
140	static void calibrate(const glm::vec3 position, const glm::quat orientation);
141	enum CalibrationState {
142	UNCALIBRATED,
143	WAITING_FOR_DELTA,
144	WAITING_FOR_ZERO,
145	WAITING_FOR_ZERO_HELD,
146	CALIBRATED
147	};
148	static void positionCalibrationBillboard(Text3DOverlay* message);
149	static float CALIBRATION_DELTA_MINIMUM_LENGTH;
150	static float CALIBRATION_DELTA_MINIMUM_ANGLE;
151	static float CALIBRATION_ZERO_MAXIMUM_LENGTH;
152	static float CALIBRATION_ZERO_MAXIMUM_ANGLE;
153	static quint64 CALIBRATION_ZERO_HOLD_TIME;
154	static float CALIBRATION_MESSAGE_DISTANCE;
155	static CalibrationState _calibrationState;
156	static glm::vec3 _calibrationPosition;
157	static glm::quat _calibrationOrientation;
158	static quint64 _calibrationStartTime;
159	static int _calibrationMessage;
160	// TODO drop this variable and use the existing 'Developer \| Render \| Scale Resolution' value
161	static ovrSizei _recommendedTexSize;
162	static float _offscreenRenderScale;
163	static bool _eyePerFrameMode;
164	static ovrEyeType _lastEyeRendered;
165	};	56	};
166		57
167
168	inline glm::mat4 toGlm(const ovrMatrix4f & om) {
169	return glm::transpose(glm::make_mat4(&om.M[0][0]));
170	}
171
172	inline glm::mat4 toGlm(const ovrFovPort & fovport, float nearPlane = 0.01f, float farPlane = 10000.0f) {
173	return toGlm(ovrMatrix4f_Projection(fovport, nearPlane, farPlane, true));
174	}
175
176	inline glm::vec3 toGlm(const ovrVector3f & ov) {
177	return glm::make_vec3(&ov.x);
178	}
179
180	inline glm::vec2 toGlm(const ovrVector2f & ov) {
181	return glm::make_vec2(&ov.x);
182	}
183
184	inline glm::uvec2 toGlm(const ovrSizei & ov) {
185	return glm::uvec2(ov.w, ov.h);
186	}
187
188	inline glm::quat toGlm(const ovrQuatf & oq) {
189	return glm::make_quat(&oq.x);
190	}
191
192	inline glm::mat4 toGlm(const ovrPosef & op) {
193	glm::mat4 orientation = glm::mat4_cast(toGlm(op.Orientation));
194	glm::mat4 translation = glm::translate(glm::mat4(), toGlm(op.Position));
195	return translation * orientation;
196	}
197
198	inline ovrMatrix4f ovrFromGlm(const glm::mat4 & m) {
199	ovrMatrix4f result;
200	glm::mat4 transposed(glm::transpose(m));
201	memcpy(result.M, &(transposed[0][0]), sizeof(float) * 16);
202	return result;
203	}
204
205	inline ovrVector3f ovrFromGlm(const glm::vec3 & v) {
206	return{ v.x, v.y, v.z };
207	}
208
209	inline ovrVector2f ovrFromGlm(const glm::vec2 & v) {
210	return{ v.x, v.y };
211	}
212
213	inline ovrSizei ovrFromGlm(const glm::uvec2 & v) {
214	return{ (int)v.x, (int)v.y };
215	}
216
217	inline ovrQuatf ovrFromGlm(const glm::quat & q) {
218	return{ q.x, q.y, q.z, q.w };
219	}
220
221	#endif // hifi_OculusManager_h	58	#endif // hifi_OculusManager_h

interface/src/devices/SDL2Manager.cpp+2−0

 }
 void SDL2Manager::focusOutEvent() {
+#ifdef HAVE_SDL2
     for (auto joystick : _openJoysticks) {
         joystick->focusOutEvent();
     }
+#endif
 }
 void SDL2Manager::update() {

interface/src/devices/SixenseManager.cpp+58−50

 const float NECK_Y = 0.3f;  // meters
 const float NECK_Z = 0.3f;  // meters
+const float CONTROLLER_THRESHOLD = 0.35f;
 #ifdef __APPLE__
 typedef int (*SixenseBaseFunction)();
 typedef int (*SixenseTakeIntFunction)(int);
 SixenseManager::~SixenseManager() {
 #ifdef HAVE_SIXENSE_
     if (_isInitialized) {
 #ifdef __APPLE__
         SixenseBaseFunction sixenseExit = (SixenseBaseFunction) _sixenseLibrary->resolve("sixenseExit");
 #endif
         sixenseExit();
     }
 #ifdef __APPLE__
     delete _sixenseLibrary;
 #endif
 #endif
 }
 void SixenseManager::initialize() {
 #ifdef HAVE_SIXENSE
     if (!_isInitialized) {
         _lowVelocityFilter = false;
         _controllersAtBase = true;
         // By default we assume the _neckBase (in orb frame) is as high above the orb
         // as the "torso" is below it.
         _neckBase = glm::vec3(NECK_X, -NECK_Y, NECK_Z);
 #ifdef __APPLE__
         if (!_sixenseLibrary) {
 #ifdef SIXENSE_LIB_FILENAME
             _sixenseLibrary = new QLibrary(SIXENSE_LIB_FILENAME);
 #else
             const QString SIXENSE_LIBRARY_NAME = "libsixense_x64";
             QString frameworkSixenseLibrary = QCoreApplication::applicationDirPath() + "/../Frameworks/"
                 + SIXENSE_LIBRARY_NAME;
             _sixenseLibrary = new QLibrary(frameworkSixenseLibrary);
 #endif
         }
         if (_sixenseLibrary->load()){
             qCDebug(interfaceapp) << "Loaded sixense library for hydra support -" << _sixenseLibrary->fileName();
         } else {
                 << "Continuing without hydra support.";
             return;
         }
         SixenseBaseFunction sixenseInit = (SixenseBaseFunction) _sixenseLibrary->resolve("sixenseInit");
 #endif
         sixenseInit();
         _isInitialized = true;
     }
 #endif
 }
 #ifdef __APPLE__
         SixenseTakeIntFunction sixenseSetFilterEnabled = (SixenseTakeIntFunction) _sixenseLibrary->resolve("sixenseSetFilterEnabled");
 #endif
         if (filter) {
             sixenseSetFilterEnabled(1);
         } else {
         SixenseBaseFunction sixenseGetNumActiveControllers =
         (SixenseBaseFunction) _sixenseLibrary->resolve("sixenseGetNumActiveControllers");
 #endif
         if (sixenseGetNumActiveControllers() == 0) {
             _hydrasConnected = false;
             if (_deviceID != 0) {
             }
             return;
         }
         PerformanceTimer perfTimer("sixense");
         if (!_hydrasConnected) {
             _hydrasConnected = true;
             getInstance().assignDefaultInputMapping(*Application::getUserInputMapper());
             UserActivityLogger::getInstance().connectedDevice("spatial_controller", "hydra");
         }
 #ifdef __APPLE__
         SixenseBaseFunction sixenseGetMaxControllers =
         (SixenseBaseFunction) _sixenseLibrary->resolve("sixenseGetMaxControllers");
 #endif
         int maxControllers = sixenseGetMaxControllers();
         // we only support two controllers
         sixenseControllerData controllers[2];
 #ifdef __APPLE__
         SixenseTakeIntFunction sixenseIsControllerEnabled =
         (SixenseTakeIntFunction) _sixenseLibrary->resolve("sixenseIsControllerEnabled");
         SixenseTakeIntAndSixenseControllerData sixenseGetNewestData =
         (SixenseTakeIntAndSixenseControllerData) _sixenseLibrary->resolve("sixenseGetNewestData");
 #endif
             sixenseControllerData* data = controllers + numActiveControllers;
             ++numActiveControllers;
             sixenseGetNewestData(i, data);
             //  Set palm position and normal based on Hydra position/orientation
             // Either find a palm matching the sixense controller, or make a new one
             PalmData* palm;
             bool foundHand = false;
                 _prevPalms[numActiveControllers - 1] = palm;
                 qCDebug(interfaceapp, "Found new Sixense controller, ID %i", data->controller_index);
             }
             // Disable the hands (and return to default pose) if both controllers are at base station
             if (foundHand) {
                 palm->setActive(!_controllersAtBase);
             } else {
                 palm->setActive(false); // if this isn't a Sixsense ID palm, always make it inactive
             }
             //  Read controller buttons and joystick into the hand
             palm->setControllerButtons(data->buttons);
             palm->setTrigger(data->trigger);
             palm->setJoystick(data->joystick_x, data->joystick_y);
             handleButtonEvent(data->buttons, numActiveControllers - 1);
             handleAxisEvent(data->joystick_x, data->joystick_y, data->trigger, numActiveControllers - 1);
             // Emulate the mouse so we can use scripts
             if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseMouseInput) && !_controllersAtBase) {
                 emulateMouse(palm, numActiveControllers - 1);
             }
             // NOTE: Sixense API returns pos data in millimeters but we IMMEDIATELY convert to meters.
             glm::vec3 position(data->pos[0], data->pos[1], data->pos[2]);
             position *= METERS_PER_MILLIMETER;
             // Check to see if this hand/controller is on the base
             const float CONTROLLER_AT_BASE_DISTANCE = 0.075f;
             if (glm::length(position) < CONTROLLER_AT_BASE_DISTANCE) {
                 numControllersAtBase++;
             }
             // Transform the measured position into body frame.
             glm::vec3 neck = _neckBase;
             // Zeroing y component of the "neck" effectively raises the measured position a little bit.
             neck.y = 0.0f;
             position = _orbRotation * (position - neck);
             //  Rotation of Palm
             glm::quat rotation(data->rot_quat[3], -data->rot_quat[0], data->rot_quat[1], -data->rot_quat[2]);
             rotation = glm::angleAxis(PI, glm::vec3(0.0f, 1.0f, 0.0f)) * _orbRotation * rotation;
             //  Compute current velocity from position change
             glm::vec3 rawVelocity;
             if (deltaTime > 0.0f) {
                 rawVelocity = glm::vec3(0.0f);
             }
             palm->setRawVelocity(rawVelocity);   //  meters/sec
             // adjustment for hydra controllers fit into hands
             float sign = (i == 0) ? -1.0f : 1.0f;
             rotation *= glm::angleAxis(sign * PI/4.0f, glm::vec3(0.0f, 0.0f, 1.0f));
             //  Angular Velocity of Palm
             glm::quat deltaRotation = rotation * glm::inverse(palm->getRawRotation());
             glm::vec3 angularVelocity(0.0f);
             } else {
                 palm->setRawAngularVelocity(glm::vec3(0.0f));
             }
             if (_lowVelocityFilter) {
                 //  Use a velocity sensitive filter to damp small motions and preserve large ones with
                 //  no latency.
                 palm->setRawPosition(position);
                 palm->setRawRotation(rotation);
             }
             // Store the one fingertip in the palm structure so we can track velocity
             const float FINGER_LENGTH = 0.3f;   //  meters
             const glm::vec3 FINGER_VECTOR(0.0f, 0.0f, FINGER_LENGTH);
             }
             palm->setTipPosition(newTipPosition);
         }
         if (numActiveControllers == 2) {
             updateCalibration(controllers);
         }
         _controllersAtBase = (numControllersAtBase == 2);
     }
+    for (auto axisState : _axisStateMap) {
+        if (fabsf(axisState.second) < CONTROLLER_THRESHOLD) {
+            _axisStateMap[axisState.first] = 0.0f;
+        }
+    }
 #endif  // HAVE_SIXENSE
 }
 //Constants for getCursorPixelRangeMultiplier()
 const float MIN_PIXEL_RANGE_MULT = 0.4f;
 const float MAX_PIXEL_RANGE_MULT = 2.0f;
-const float RANGE_MULT = (MAX_PIXEL_RANGE_MULT - MIN_PIXEL_RANGE_MULT) * 0.01;
+const float RANGE_MULT = (MAX_PIXEL_RANGE_MULT - MIN_PIXEL_RANGE_MULT) * 0.01f;
 //Returns a multiplier to be applied to the cursor range for the controllers
 float SixenseManager::getCursorPixelRangeMult() const {
             _calibrationState = CALIBRATION_STATE_X;
         }
         return;
     }
     quint64 now = usecTimestampNow() + LOCK_DURATION;
     // these are weighted running averages
     if (_calibrationState == CALIBRATION_STATE_X) {
         // compute new sliding average
         float distance = glm::distance(_averageLeft, _averageRight);
-        if (fabs(distance - _lastDistance) > MAXIMUM_NOISE_LEVEL) {
+        if (fabsf(distance - _lastDistance) > MAXIMUM_NOISE_LEVEL) {
             // distance is increasing so acquire the data and push the expiry out
             _reachLeft = _averageLeft;
             _reachRight = _averageRight;
         glm::vec3 torso = 0.5f * (_reachLeft + _reachRight);
         glm::vec3 averagePosition = 0.5f * (_averageLeft + _averageRight);
         float distance = (averagePosition - torso).y;
-        if (fabs(distance) > fabs(_lastDistance) + MAXIMUM_NOISE_LEVEL) {
+        if (fabsf(distance) > fabsf(_lastDistance) + MAXIMUM_NOISE_LEVEL) {
             // distance is increasing so acquire the data and push the expiry out
             _reachUp = averagePosition;
             _lastDistance = distance;
             _lastDistance = distance;
             _lockExpiry = now + LOCK_DURATION;
         } else if (now > _lockExpiry) {
-            if (fabs(_lastDistance) > 0.05f * MINIMUM_ARM_REACH) {
+            if (fabsf(_lastDistance) > 0.05f * MINIMUM_ARM_REACH) {
                 // lock has expired so clamp the data and move on
                 _calibrationState = CALIBRATION_STATE_COMPLETE;
                 qCDebug(interfaceapp, "success: sixense calibration: forward");
                 // TODO: it is theoretically possible to detect that the controllers have been
                 // accidentally switched (left hand is holding right controller) and to swap the order.
             }
         }
 void SixenseManager::emulateMouse(PalmData* palm, int index) {
     MyAvatar* avatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
     QPoint pos;
     Qt::MouseButton bumperButton;
     Qt::MouseButton triggerButton;
         triggerButton = Qt::LeftButton;
     }
     if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseLasers)
         || Menu::getInstance()->isOptionChecked(MenuOption::EnableVRMode)) {
-        pos = qApp->getApplicationOverlay().getPalmClickLocation(palm);
+        pos = qApp->getApplicationCompositor().getPalmClickLocation(palm);
     } else {
         // Get directon relative to avatar orientation
         glm::vec3 direction = glm::inverse(avatar->getOrientation()) * palm->getFingerDirection();
         // Get the angles, scaled between (-0.5,0.5)
         float xAngle = (atan2(direction.z, direction.x) + M_PI_2);
-        float yAngle = 0.5f - ((atan2(direction.z, direction.y) + M_PI_2));
+        float yAngle = 0.5f - ((atan2f(direction.z, direction.y) + (float)M_PI_2));
         auto canvasSize = qApp->getCanvasSize();
         // Get the pixel range over which the xAngle and yAngle are scaled
         float cursorRange = canvasSize.x * getCursorPixelRangeMult();
             if (!_bumperPressed[(int)(!index)]) {
                 qApp->mouseMoveEvent(&mouseEvent, deviceID);
             }
         }
     }
     _oldX[index] = pos.x();
     _oldY[index] = pos.y();
     //We need separate coordinates for clicks, since we need to check if
     //a magnification window was clicked on
     if (palm->getControllerButtons() & BUTTON_FWD) {
         if (!_bumperPressed[index]) {
             _bumperPressed[index] = true;
             QMouseEvent mouseEvent(QEvent::MouseButtonPress, pos, bumperButton, bumperButton, 0);
             qApp->mousePressEvent(&mouseEvent, deviceID);

interface/src/devices/TV3DManager.cpp+9−9

 #include "InterfaceConfig.h"
 #include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp>
 #include <GlowEffect.h>
 #include "gpu/GLBackend.h"
         _activeEye = &eye;
         glViewport(portalX, portalY, portalW, portalH);
         glScissor(portalX, portalY, portalW, portalH);
+        glm::mat4 projection = glm::frustum<float>(eye.left, eye.right, eye.bottom, eye.top, nearZ, farZ);
+        float fov = atan(1.0f / projection[1][1]);
+        projection = glm::translate(projection, vec3(eye.modelTranslation, 0, 0));
+        eyeCamera.setProjection(projection);
         glMatrixMode(GL_PROJECTION);
         glLoadIdentity(); // reset projection matrix
-        glFrustum(eye.left, eye.right, eye.bottom, eye.top, nearZ, farZ); // set left view frustum
+        glLoadMatrixf(glm::value_ptr(projection));
-        GLfloat p[4][4];
-        // Really?
-        glGetFloatv(GL_PROJECTION_MATRIX, &(p[0][0]));
-        float cotangent = p[1][1];
-        GLfloat fov = atan(1.0f / cotangent);
-        glTranslatef(eye.modelTranslation, 0.0, 0.0); // translate to cancel parallax
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
         renderArgs->_renderSide = RenderArgs::MONO;
         qApp->displaySide(renderArgs, eyeCamera, false);
-        qApp->getApplicationOverlay().displayOverlayTextureStereo(whichCamera, _aspect, fov);
+        qApp->getApplicationCompositor().displayOverlayTexture(renderArgs);
         _activeEye = NULL;
     }, [&]{
         // render right side view

interface/src/main.cpp+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	#ifdef Q_OS_WIN	23	#ifdef Q_OS_WIN
24	static BOOL CALLBACK enumWindowsCallback(HWND hWnd, LPARAM lParam) {	24	static BOOL CALLBACK enumWindowsCallback(HWND hWnd, LPARAM lParam) {
25	const UINT TIMEOUT = 200; // ms	25	const UINT TIMEOUT = 200; // ms
26	DWORD response;	26	DWORD_PTR response;
27	LRESULT result = SendMessageTimeout(hWnd, UWM_IDENTIFY_INSTANCES, 0, 0, SMTO_BLOCK \| SMTO_ABORTIFHUNG, TIMEOUT, &response);	27	LRESULT result = SendMessageTimeout(hWnd, UWM_IDENTIFY_INSTANCES, 0, 0, SMTO_BLOCK \| SMTO_ABORTIFHUNG, TIMEOUT, &response);
28	if (result == 0) { // Timeout; continue search.	28	if (result == 0) { // Timeout; continue search.
29	return TRUE;	29	return TRUE;

interface/src/scripting/ControllerScriptingInterface.cpp+1−1

@@ -463,7 +463,7 @@ void ControllerScriptingInterface::resetDevice(unsigned int device) { · 462 unmodified lines
463	}	463	}
464		464
465	int ControllerScriptingInterface::findDevice(QString name) {	465	int ControllerScriptingInterface::findDevice(QString name) {
466	Application::getUserInputMapper()->findDevice(name);	466	return Application::getUserInputMapper()->findDevice(name);
467	}	467	}
468		468
469	InputController::InputController(int deviceTrackerId, int subTrackerId, QObject* parent) :	469	InputController::InputController(int deviceTrackerId, int subTrackerId, QObject* parent) :

interface/src/scripting/ControllerScriptingInterface.h+1−0

@@ -65,6 +65,7 @@ public: · 64 unmodified lines
65		65
66	void emitMouseMoveEvent(QMouseEvent* event, unsigned int deviceID = 0) { emit mouseMoveEvent(MouseEvent(*event, deviceID)); }	66	void emitMouseMoveEvent(QMouseEvent* event, unsigned int deviceID = 0) { emit mouseMoveEvent(MouseEvent(*event, deviceID)); }
67	void emitMousePressEvent(QMouseEvent* event, unsigned int deviceID = 0) { emit mousePressEvent(MouseEvent(*event, deviceID)); }	67	void emitMousePressEvent(QMouseEvent* event, unsigned int deviceID = 0) { emit mousePressEvent(MouseEvent(*event, deviceID)); }
		68	void emitMouseDoublePressEvent(QMouseEvent* event, unsigned int deviceID = 0) { emit mouseDoublePressEvent(MouseEvent(*event, deviceID)); }
68	void emitMouseReleaseEvent(QMouseEvent* event, unsigned int deviceID = 0) { emit mouseReleaseEvent(MouseEvent(*event, deviceID)); }	69	void emitMouseReleaseEvent(QMouseEvent* event, unsigned int deviceID = 0) { emit mouseReleaseEvent(MouseEvent(*event, deviceID)); }
69		70
70	void emitTouchBeginEvent(const TouchEvent& event) { emit touchBeginEvent(event); }	71	void emitTouchBeginEvent(const TouchEvent& event) { emit touchBeginEvent(event); }

interface/src/scripting/HMDScriptingInterface.cpp+3−3

@@ -25,9 +25,9 @@ bool HMDScriptingInterface::getHUDLookAtPosition3D(glm::vec3& result) const { · 24 unmodified lines
25		25
26	glm::vec3 direction = orientation * glm::vec3(0.0f, 0.0f, -1.0f);	26	glm::vec3 direction = orientation * glm::vec3(0.0f, 0.0f, -1.0f);
27		27
28	ApplicationOverlay& applicationOverlay = Application::getInstance()->getApplicationOverlay();	28	const auto& compositor = Application::getInstance()->getApplicationCompositor();
29		29
30	return applicationOverlay.calculateRayUICollisionPoint(position, direction, result);	30	return compositor.calculateRayUICollisionPoint(position, direction, result);
31	}	31	}
32		32
33	QScriptValue HMDScriptingInterface::getHUDLookAtPosition2D(QScriptContext* context, QScriptEngine* engine) {	33	QScriptValue HMDScriptingInterface::getHUDLookAtPosition2D(QScriptContext* context, QScriptEngine* engine) {
@@ -40,7 +40,7 @@ QScriptValue HMDScriptingInterface::getHUDLookAtPosition2D(QScriptContext* conte · 6 unmodified lines
40	glm::vec3 direction = glm::inverse(myAvatar->getOrientation()) * (hudIntersection - sphereCenter);	40	glm::vec3 direction = glm::inverse(myAvatar->getOrientation()) * (hudIntersection - sphereCenter);
41	glm::quat rotation = ::rotationBetween(glm::vec3(0.0f, 0.0f, -1.0f), direction);	41	glm::quat rotation = ::rotationBetween(glm::vec3(0.0f, 0.0f, -1.0f), direction);
42	glm::vec3 eulers = ::safeEulerAngles(rotation);	42	glm::vec3 eulers = ::safeEulerAngles(rotation);
43	return qScriptValueFromValue<glm::vec2>(engine, Application::getInstance()->getApplicationOverlay()	43	return qScriptValueFromValue<glm::vec2>(engine, Application::getInstance()->getApplicationCompositor()
44	.sphericalToOverlay(glm::vec2(eulers.y, -eulers.x)));	44	.sphericalToOverlay(glm::vec2(eulers.y, -eulers.x)));
45	}	45	}
46	return QScriptValue::NullValue;	46	return QScriptValue::NullValue;

interface/src/scripting/HMDScriptingInterface.h+2−2

@@ -27,11 +27,11 @@ public: · 26 unmodified lines
27	static QScriptValue getHUDLookAtPosition3D(QScriptContext* context, QScriptEngine* engine);	27	static QScriptValue getHUDLookAtPosition3D(QScriptContext* context, QScriptEngine* engine);
28		28
29	public slots:	29	public slots:
30	void toggleMagnifier() { Application::getInstance()->getApplicationOverlay().toggleMagnifier(); };	30	void toggleMagnifier() { Application::getInstance()->getApplicationCompositor().toggleMagnifier(); };
31		31
32	private:	32	private:
33	HMDScriptingInterface() {};	33	HMDScriptingInterface() {};
34	bool getMagnifier() const { return Application::getInstance()->getApplicationOverlay().hasMagnifier(); };	34	bool getMagnifier() const { return Application::getInstance()->getApplicationCompositor().hasMagnifier(); };
35	bool isHMDMode() const { return Application::getInstance()->isHMDMode(); }	35	bool isHMDMode() const { return Application::getInstance()->isHMDMode(); }
36		36
37	bool getHUDLookAtPosition3D(glm::vec3& result) const;	37	bool getHUDLookAtPosition3D(glm::vec3& result) const;

interface/src/starfield/renderer/Renderer.cpp+9−0

 //
 #include "starfield/renderer/Renderer.h"
+#include "Application.h"
 using namespace starfield;
     matrix[3][1] = 0.0f;
     matrix[3][2] = 0.0f;
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadMatrixf(glm::value_ptr(qApp->getDisplayViewFrustum()->getProjection()));
+    glMatrixMode(GL_MODELVIEW);
     // extract local z vector
     vec3 ahead = vec3(matrix[2]);
     floodFill(cursor, TileSelection(*this, _tileArray, _tileArray + _tiling.getTileCount(), (TileSelection::Cursor*) _batchCountArray));
     this->glBatch(glm::value_ptr(matrix), prepareBatch((unsigned*) _batchOffs, _outIndexPos), alpha);
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
 }
 // renderer construction

interface/src/ui/AddressBarDialog.cpp+24−0

@@ -22,6 +22,20 @@ AddressBarDialog::AddressBarDialog(QQuickItem* parent) : OffscreenQmlDialog(pare · 21 unmodified lines
22	connect(addressManager.data(), &AddressManager::lookupResultIsOffline, this, &AddressBarDialog::displayAddressOfflineMessage);	22	connect(addressManager.data(), &AddressManager::lookupResultIsOffline, this, &AddressBarDialog::displayAddressOfflineMessage);
23	connect(addressManager.data(), &AddressManager::lookupResultIsNotFound, this, &AddressBarDialog::displayAddressNotFoundMessage);	23	connect(addressManager.data(), &AddressManager::lookupResultIsNotFound, this, &AddressBarDialog::displayAddressNotFoundMessage);
24	connect(addressManager.data(), &AddressManager::lookupResultsFinished, this, &AddressBarDialog::hide);	24	connect(addressManager.data(), &AddressManager::lookupResultsFinished, this, &AddressBarDialog::hide);
		25	connect(addressManager.data(), &AddressManager::goBackPossible, this, [this] (bool isPossible) {
		26	if (isPossible != _backEnabled) {
		27	_backEnabled = isPossible;
		28	emit backEnabledChanged();
		29	}
		30	});
		31	connect(addressManager.data(), &AddressManager::goForwardPossible, this, [this] (bool isPossible) {
		32	if (isPossible != _forwardEnabled) {
		33	_forwardEnabled = isPossible;
		34	emit forwardEnabledChanged();
		35	}
		36	});
		37	_backEnabled = !(DependencyManager::get<AddressManager>()->getBackStack().isEmpty());
		38	_forwardEnabled = !(DependencyManager::get<AddressManager>()->getForwardStack().isEmpty());
25	}	39	}
26		40
27	void AddressBarDialog::hide() {	41	void AddressBarDialog::hide() {
@@ -35,6 +49,16 @@ void AddressBarDialog::loadAddress(const QString& address) { · 7 unmodified lines
35	}	49	}
36	}	50	}
37		51
		52	void AddressBarDialog::loadBack() {
		53	qDebug() << "Called LoadBack";
		54	DependencyManager::get<AddressManager>()->goBack();
		55	}
		56
		57	void AddressBarDialog::loadForward() {
		58	qDebug() << "Called LoadForward";
		59	DependencyManager::get<AddressManager>()->goForward();
		60	}
		61
38	void AddressBarDialog::displayAddressOfflineMessage() {	62	void AddressBarDialog::displayAddressOfflineMessage() {
39	OffscreenUi::error("That user or place is currently offline");	63	OffscreenUi::error("That user or place is currently offline");
40	}	64	}

interface/src/ui/AddressBarDialog.h+13−0

 {
     Q_OBJECT
     HIFI_QML_DECL
+    Q_PROPERTY(bool backEnabled READ backEnabled NOTIFY backEnabledChanged)
+    Q_PROPERTY(bool forwardEnabled READ forwardEnabled NOTIFY forwardEnabledChanged)
 public:
     AddressBarDialog(QQuickItem* parent = nullptr);
+    bool backEnabled() { return _backEnabled; }
+    bool forwardEnabled() { return _forwardEnabled; }
+signals:
+    void backEnabledChanged();
+    void forwardEnabledChanged();
 protected:
     void displayAddressOfflineMessage();
     void hide();
     Q_INVOKABLE void loadAddress(const QString& address);
+    Q_INVOKABLE void loadBack();
+    Q_INVOKABLE void loadForward();
+    bool _backEnabled;
+    bool _forwardEnabled;
 };
 #endif

interface/src/ui/ApplicationCompositor.cpp+761−0

@@ -0,0 +1,761 @@
	1	//
	2	// ApplicationCompositor.cpp
	3	// interface/src/ui/overlays
	4	//
	5	// Created by Benjamin Arnold on 5/27/14.
	6	// Copyright 2014 High Fidelity, Inc.
	7	//
	8	// Distributed under the Apache License, Version 2.0.
	9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	10	//
	11
	12	#include "InterfaceConfig.h"
	13
	14	#include "ApplicationCompositor.h"
	15
	16	#include <glm/gtc/type_ptr.hpp>
	17
	18	#include <avatar/AvatarManager.h>
	19	#include <gpu/GLBackend.h>
	20	#include <CursorManager.h>
	21	#include <Tooltip.h>
	22
	23	#include "Application.h"
	24
	25
	26	// Used to animate the magnification windows
	27	static const float MAG_SPEED = 0.08f;
	28
	29	static const quint64 MSECS_TO_USECS = 1000ULL;
	30	static const quint64 TOOLTIP_DELAY = 500 * MSECS_TO_USECS;
	31
	32	static const float WHITE_TEXT[] = { 0.93f, 0.93f, 0.93f };
	33	static const float RETICLE_COLOR[] = { 0.0f, 198.0f / 255.0f, 244.0f / 255.0f };
	34	static const float reticleSize = TWO_PI / 100.0f;
	35
	36	static const float CONNECTION_STATUS_BORDER_COLOR[] = { 1.0f, 0.0f, 0.0f };
	37	static const float CONNECTION_STATUS_BORDER_LINE_WIDTH = 4.0f;
	38
	39	static const float CURSOR_PIXEL_SIZE = 32.0f;
	40	static const float MOUSE_PITCH_RANGE = 1.0f * PI;
	41	static const float MOUSE_YAW_RANGE = 0.5f * TWO_PI;
	42	static const glm::vec2 MOUSE_RANGE(MOUSE_YAW_RANGE, MOUSE_PITCH_RANGE);
	43
	44	static gpu::BufferPointer _hemiVertices;
	45	static gpu::BufferPointer _hemiIndices;
	46	static int _hemiIndexCount{ 0 };
	47	EntityItemID ApplicationCompositor::_noItemId;
	48	static QString _tooltipId;
	49
	50	// Return a point's cartesian coordinates on a sphere from pitch and yaw
	51	glm::vec3 getPoint(float yaw, float pitch) {
	52	return glm::vec3(glm::cos(-pitch) * (-glm::sin(yaw)),
	53	glm::sin(-pitch),
	54	glm::cos(-pitch) * (-glm::cos(yaw)));
	55	}
	56
	57	//Checks if the given ray intersects the sphere at the origin. result will store a multiplier that should
	58	//be multiplied by dir and added to origin to get the location of the collision
	59	bool raySphereIntersect(const glm::vec3 &dir, const glm::vec3 &origin, float r, float* result)
	60	{
	61	//Source: http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
	62
	63	//Compute A, B and C coefficients
	64	float a = glm::dot(dir, dir);
	65	float b = 2 * glm::dot(dir, origin);
	66	float c = glm::dot(origin, origin) - (r * r);
	67
	68	//Find discriminant
	69	float disc = b * b - 4 * a * c;
	70
	71	// if discriminant is negative there are no real roots, so return
	72	// false as ray misses sphere
	73	if (disc < 0) {
	74	return false;
	75	}
	76
	77	// compute q as described above
	78	float distSqrt = sqrtf(disc);
	79	float q;
	80	if (b < 0) {
	81	q = (-b - distSqrt) / 2.0f;
	82	} else {
	83	q = (-b + distSqrt) / 2.0f;
	84	}
	85
	86	// compute t0 and t1
	87	float t0 = q / a;
	88	float t1 = c / q;
	89
	90	// make sure t0 is smaller than t1
	91	if (t0 > t1) {
	92	// if t0 is bigger than t1 swap them around
	93	float temp = t0;
	94	t0 = t1;
	95	t1 = temp;
	96	}
	97
	98	// if t1 is less than zero, the object is in the ray's negative direction
	99	// and consequently the ray misses the sphere
	100	if (t1 < 0) {
	101	return false;
	102	}
	103
	104	// if t0 is less than zero, the intersection point is at t1
	105	if (t0 < 0) {
	106	*result = t1;
	107	return true;
	108	} else { // else the intersection point is at t0
	109	*result = t0;
	110	return true;
	111	}
	112	}
	113
	114	ApplicationCompositor::ApplicationCompositor() {
	115	memset(_reticleActive, 0, sizeof(_reticleActive));
	116	memset(_magActive, 0, sizeof(_reticleActive));
	117	memset(_magSizeMult, 0, sizeof(_magSizeMult));
	118
	119	auto geometryCache = DependencyManager::get<GeometryCache>();
	120
	121	_reticleQuad = geometryCache->allocateID();
	122	_magnifierQuad = geometryCache->allocateID();
	123	_magnifierBorder = geometryCache->allocateID();
	124
	125	auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();
	126	connect(entityScriptingInterface.data(), &EntityScriptingInterface::hoverEnterEntity, [=](const EntityItemID& entityItemID, const MouseEvent& event) {
	127	if (_hoverItemId != entityItemID) {
	128	_hoverItemId = entityItemID;
	129	_hoverItemEnterUsecs = usecTimestampNow();
	130	auto properties = entityScriptingInterface->getEntityProperties(_hoverItemId);
	131	_hoverItemHref = properties.getHref();
	132	auto cursor = Cursor::Manager::instance().getCursor();
	133	if (!_hoverItemHref.isEmpty()) {
	134	cursor->setIcon(Cursor::Icon::LINK);
	135	} else {
	136	cursor->setIcon(Cursor::Icon::DEFAULT);
	137	}
	138	}
	139	});
	140
	141	connect(entityScriptingInterface.data(), &EntityScriptingInterface::hoverLeaveEntity, [=](const EntityItemID& entityItemID, const MouseEvent& event) {
	142	if (_hoverItemId == entityItemID) {
	143	_hoverItemId = _noItemId;
	144	_hoverItemHref.clear();
	145	auto cursor = Cursor::Manager::instance().getCursor();
	146	cursor->setIcon(Cursor::Icon::DEFAULT);
	147	if (!_tooltipId.isEmpty()) {
	148	qDebug() << "Closing tooltip " << _tooltipId;
	149	Tooltip::closeTip(_tooltipId);
	150	_tooltipId.clear();
	151	}
	152	}
	153	});
	154	}
	155
	156	ApplicationCompositor::~ApplicationCompositor() {
	157	}
	158
	159
	160	void ApplicationCompositor::bindCursorTexture(gpu::Batch& batch, uint8_t cursorIndex) {
	161	auto& cursorManager = Cursor::Manager::instance();
	162	auto cursor = cursorManager.getCursor(cursorIndex);
	163	auto iconId = cursor->getIcon();
	164	if (!_cursors.count(iconId)) {
	165	auto iconPath = cursorManager.getIconImage(cursor->getIcon());
	166	_cursors[iconId] = DependencyManager::get<TextureCache>()->
	167	getImageTexture(iconPath);
	168	}
	169	batch.setUniformTexture(0, _cursors[iconId]);
	170	}
	171
	172	// Draws the FBO texture for the screen
	173	void ApplicationCompositor::displayOverlayTexture(RenderArgs* renderArgs) {
	174	if (_alpha == 0.0f) {
	175	return;
	176	}
	177
	178	GLuint texture = qApp->getApplicationOverlay().getOverlayTexture();
	179	if (!texture) {
	180	return;
	181	}
	182
	183	updateTooltips();
	184
	185	vec2 canvasSize = qApp->getCanvasSize();
	186
	187	//Handle fading and deactivation/activation of UI
	188	gpu::Batch batch;
	189
	190	renderArgs->_context->syncCache();
	191	auto geometryCache = DependencyManager::get<GeometryCache>();
	192
	193	geometryCache->useSimpleDrawPipeline(batch);
	194	batch.setModelTransform(Transform());
	195	batch.setViewTransform(Transform());
	196	batch.setProjectionTransform(mat4());
	197	batch._glBindTexture(GL_TEXTURE_2D, texture);
	198	batch._glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	199	batch._glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	200	geometryCache->renderUnitQuad(batch, vec4(vec3(1), _alpha));
	201
	202	// Doesn't actually render
	203	renderPointers(batch);
	204
	205	//draw the mouse pointer
	206	// Get the mouse coordinates and convert to NDC [-1, 1]
	207	vec2 mousePosition = toNormalizedDeviceScale(vec2(qApp->getMouse()), canvasSize);
	208	// Invert the Y axis
	209	mousePosition.y *= -1.0f;
	210
	211	Transform model;
	212	model.setTranslation(vec3(mousePosition, 0));
	213	vec2 mouseSize = CURSOR_PIXEL_SIZE / canvasSize;
	214	model.setScale(vec3(mouseSize, 1.0f));
	215	batch.setModelTransform(model);
	216	bindCursorTexture(batch);
	217	vec4 reticleColor = { RETICLE_COLOR[0], RETICLE_COLOR[1], RETICLE_COLOR[2], 1.0f };
	218	geometryCache->renderUnitQuad(batch, vec4(1));
	219	renderArgs->_context->render(batch);
	220	}
	221
	222
	223	vec2 getPolarCoordinates(const PalmData& palm) {
	224	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
	225	auto avatarOrientation = myAvatar->getOrientation();
	226	auto eyePos = myAvatar->getDefaultEyePosition();
	227	glm::vec3 tip = myAvatar->getLaserPointerTipPosition(&palm);
	228	// Direction of the tip relative to the eye
	229	glm::vec3 tipDirection = tip - eyePos;
	230	// orient into avatar space
	231	tipDirection = glm::inverse(avatarOrientation) * tipDirection;
	232	// Normalize for trig functions
	233	tipDirection = glm::normalize(tipDirection);
	234	// Convert to polar coordinates
	235	glm::vec2 polar(glm::atan(tipDirection.x, -tipDirection.z), glm::asin(tipDirection.y));
	236	return polar;
	237	}
	238
	239	// Draws the FBO texture for Oculus rift.
	240	void ApplicationCompositor::displayOverlayTextureHmd(RenderArgs* renderArgs, int eye) {
	241	if (_alpha == 0.0f) {
	242	return;
	243	}
	244
	245	GLuint texture = qApp->getApplicationOverlay().getOverlayTexture();
	246	if (!texture) {
	247	return;
	248	}
	249
	250	updateTooltips();
	251
	252	vec2 canvasSize = qApp->getCanvasSize();
	253	_textureAspectRatio = aspect(canvasSize);
	254
	255	renderArgs->_context->syncCache();
	256	auto geometryCache = DependencyManager::get<GeometryCache>();
	257
	258	gpu::Batch batch;
	259	geometryCache->useSimpleDrawPipeline(batch);
	260	batch._glDisable(GL_DEPTH_TEST);
	261	batch._glDisable(GL_CULL_FACE);
	262	batch._glBindTexture(GL_TEXTURE_2D, texture);
	263	batch._glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	264	batch._glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	265	batch.setViewTransform(Transform());
	266	batch.setProjectionTransform(qApp->getEyeProjection(eye));
	267
	268	mat4 eyePose = qApp->getEyePose(eye);
	269	glm::mat4 overlayXfm = glm::inverse(eyePose);
	270
	271	#ifdef DEBUG_OVERLAY
	272	{
	273	batch.setModelTransform(glm::translate(mat4(), vec3(0, 0, -2)));
	274	geometryCache->renderUnitQuad(batch, glm::vec4(1));
	275	}
	276	#else
	277	{
	278	batch.setModelTransform(overlayXfm);
	279	drawSphereSection(batch);
	280	}
	281	#endif
	282
	283	// Doesn't actually render
	284	renderPointers(batch);
	285	vec3 reticleScale = vec3(Cursor::Manager::instance().getScale() * reticleSize);
	286
	287	bindCursorTexture(batch);
	288
	289	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
	290	//Controller Pointers
	291	for (int i = 0; i < (int)myAvatar->getHand()->getNumPalms(); i++) {
	292	PalmData& palm = myAvatar->getHand()->getPalms()[i];
	293	if (palm.isActive()) {
	294	glm::vec2 polar = getPolarCoordinates(palm);
	295	// Convert to quaternion
	296	mat4 pointerXfm = glm::mat4_cast(quat(vec3(polar.y, -polar.x, 0.0f))) * glm::translate(mat4(), vec3(0, 0, -1));
	297	mat4 reticleXfm = overlayXfm * pointerXfm;
	298	reticleXfm = glm::scale(reticleXfm, reticleScale);
	299	batch.setModelTransform(reticleXfm);
	300	// Render reticle at location
	301	geometryCache->renderUnitQuad(batch, glm::vec4(1), _reticleQuad);
	302	}
	303	}
	304
	305	//Mouse Pointer
	306	if (_reticleActive[MOUSE]) {
	307	glm::vec2 projection = screenToSpherical(glm::vec2(_reticlePosition[MOUSE].x(),
	308	_reticlePosition[MOUSE].y()));
	309	mat4 pointerXfm = glm::mat4_cast(quat(vec3(-projection.y, projection.x, 0.0f))) * glm::translate(mat4(), vec3(0, 0, -1));
	310	mat4 reticleXfm = overlayXfm * pointerXfm;
	311	reticleXfm = glm::scale(reticleXfm, reticleScale);
	312	batch.setModelTransform(reticleXfm);
	313	geometryCache->renderUnitQuad(batch, glm::vec4(1), _reticleQuad);
	314	}
	315
	316	renderArgs->_context->render(batch);
	317	}
	318
	319
	320	void ApplicationCompositor::computeHmdPickRay(glm::vec2 cursorPos, glm::vec3& origin, glm::vec3& direction) const {
	321	cursorPos *= qApp->getCanvasSize();
	322	const glm::vec2 projection = screenToSpherical(cursorPos);
	323	// The overlay space orientation of the mouse coordinates
	324	const glm::quat orientation(glm::vec3(-projection.y, projection.x, 0.0f));
	325	// FIXME We now have the direction of the ray FROM THE DEFAULT HEAD POSE.
	326	// Now we need to account for the actual camera position relative to the overlay
	327	glm::vec3 overlaySpaceDirection = glm::normalize(orientation * IDENTITY_FRONT);
	328
	329
	330	// We need the RAW camera orientation and position, because this is what the overlay is
	331	// rendered relative to
	332	const glm::vec3 overlayPosition = qApp->getCamera()->getPosition();
	333	const glm::quat overlayOrientation = qApp->getCamera()->getRotation();
	334
	335	// Intersection UI overlay space
	336	glm::vec3 worldSpaceDirection = overlayOrientation * overlaySpaceDirection;
	337	glm::vec3 worldSpaceIntersection = (glm::normalize(worldSpaceDirection) * _oculusUIRadius) + overlayPosition;
	338	glm::vec3 worldSpaceHeadPosition = (overlayOrientation * glm::vec3(qApp->getHeadPose()[3])) + overlayPosition;
	339
	340	// Intersection in world space
	341	origin = worldSpaceHeadPosition;
	342	direction = glm::normalize(worldSpaceIntersection - worldSpaceHeadPosition);
	343	}
	344
	345	//Caculate the click location using one of the sixense controllers. Scale is not applied
	346	QPoint ApplicationCompositor::getPalmClickLocation(const PalmData *palm) const {
	347	QPoint rv;
	348	auto canvasSize = qApp->getCanvasSize();
	349	if (qApp->isHMDMode()) {
	350	glm::vec2 polar = getPolarCoordinates(*palm);
	351	glm::vec2 point = sphericalToScreen(-polar);
	352	rv.rx() = point.x;
	353	rv.ry() = point.y;
	354	} else {
	355	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
	356	glm::dmat4 projection;
	357	qApp->getProjectionMatrix(&projection);
	358	glm::quat invOrientation = glm::inverse(myAvatar->getOrientation());
	359	glm::vec3 eyePos = myAvatar->getDefaultEyePosition();
	360	glm::vec3 tip = myAvatar->getLaserPointerTipPosition(palm);
	361	glm::vec3 tipPos = invOrientation * (tip - eyePos);
	362
	363	glm::vec4 clipSpacePos = glm::vec4(projection * glm::dvec4(tipPos, 1.0));
	364	glm::vec3 ndcSpacePos;
	365	if (clipSpacePos.w != 0) {
	366	ndcSpacePos = glm::vec3(clipSpacePos) / clipSpacePos.w;
	367	}
	368
	369	rv.setX(((ndcSpacePos.x + 1.0) / 2.0) * canvasSize.x);
	370	rv.setY((1.0 - ((ndcSpacePos.y + 1.0) / 2.0)) * canvasSize.y);
	371	}
	372	return rv;
	373	}
	374
	375	//Finds the collision point of a world space ray
	376	bool ApplicationCompositor::calculateRayUICollisionPoint(const glm::vec3& position, const glm::vec3& direction, glm::vec3& result) const {
	377	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
	378
	379	glm::quat inverseOrientation = glm::inverse(myAvatar->getOrientation());
	380
	381	glm::vec3 relativePosition = inverseOrientation * (position - myAvatar->getDefaultEyePosition());
	382	glm::vec3 relativeDirection = glm::normalize(inverseOrientation * direction);
	383
	384	float t;
	385	if (raySphereIntersect(relativeDirection, relativePosition, _oculusUIRadius * myAvatar->getScale(), &t)){
	386	result = position + direction * t;
	387	return true;
	388	}
	389
	390	return false;
	391	}
	392
	393	//Renders optional pointers
	394	void ApplicationCompositor::renderPointers(gpu::Batch& batch) {
	395	if (qApp->isHMDMode() && !qApp->getLastMouseMoveWasSimulated() && !qApp->isMouseHidden()) {
	396	//If we are in oculus, render reticle later
	397	QPoint position = QPoint(qApp->getTrueMouseX(), qApp->getTrueMouseY());
	398	_reticlePosition[MOUSE] = position;
	399	_reticleActive[MOUSE] = true;
	400	_magActive[MOUSE] = _magnifier;
	401	_reticleActive[LEFT_CONTROLLER] = false;
	402	_reticleActive[RIGHT_CONTROLLER] = false;
	403	} else if (qApp->getLastMouseMoveWasSimulated() && Menu::getInstance()->isOptionChecked(MenuOption::SixenseMouseInput)) {
	404	//only render controller pointer if we aren't already rendering a mouse pointer
	405	_reticleActive[MOUSE] = false;
	406	_magActive[MOUSE] = false;
	407	renderControllerPointers(batch);
	408	}
	409	}
	410
	411
	412	void ApplicationCompositor::renderControllerPointers(gpu::Batch& batch) {
	413	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
	414
	415	//Static variables used for storing controller state
	416	static quint64 pressedTime[NUMBER_OF_RETICLES] = { 0ULL, 0ULL, 0ULL };
	417	static bool isPressed[NUMBER_OF_RETICLES] = { false, false, false };
	418	static bool stateWhenPressed[NUMBER_OF_RETICLES] = { false, false, false };
	419
	420	const HandData* handData = DependencyManager::get<AvatarManager>()->getMyAvatar()->getHandData();
	421
	422	for (unsigned int palmIndex = 2; palmIndex < 4; palmIndex++) {
	423	const int index = palmIndex - 1;
	424
	425	const PalmData* palmData = NULL;
	426
	427	if (palmIndex >= handData->getPalms().size()) {
	428	return;
	429	}
	430
	431	if (handData->getPalms()[palmIndex].isActive()) {
	432	palmData = &handData->getPalms()[palmIndex];
	433	} else {
	434	continue;
	435	}
	436
	437	int controllerButtons = palmData->getControllerButtons();
	438
	439	//Check for if we should toggle or drag the magnification window
	440	if (controllerButtons & BUTTON_3) {
	441	if (isPressed[index] == false) {
	442	//We are now dragging the window
	443	isPressed[index] = true;
	444	//set the pressed time in us
	445	pressedTime[index] = usecTimestampNow();
	446	stateWhenPressed[index] = _magActive[index];
	447	}
	448	} else if (isPressed[index]) {
	449	isPressed[index] = false;
	450	//If the button was only pressed for < 250 ms
	451	//then disable it.
	452
	453	const int MAX_BUTTON_PRESS_TIME = 250 * MSECS_TO_USECS;
	454	if (usecTimestampNow() < pressedTime[index] + MAX_BUTTON_PRESS_TIME) {
	455	_magActive[index] = !stateWhenPressed[index];
	456	}
	457	}
	458
	459	//if we have the oculus, we should make the cursor smaller since it will be
	460	//magnified
	461	if (qApp->isHMDMode()) {
	462
	463	QPoint point = getPalmClickLocation(palmData);
	464
	465	_reticlePosition[index] = point;
	466
	467	//When button 2 is pressed we drag the mag window
	468	if (isPressed[index]) {
	469	_magActive[index] = true;
	470	}
	471
	472	// If oculus is enabled, we draw the crosshairs later
	473	continue;
	474	}
	475
	476	auto canvasSize = qApp->getCanvasSize();
	477	int mouseX, mouseY;
	478	if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseLasers)) {
	479	QPoint res = getPalmClickLocation(palmData);
	480	mouseX = res.x();
	481	mouseY = res.y();
	482	} else {
	483	// Get directon relative to avatar orientation
	484	glm::vec3 direction = glm::inverse(myAvatar->getOrientation()) * palmData->getFingerDirection();
	485
	486	// Get the angles, scaled between (-0.5,0.5)
	487	float xAngle = (atan2(direction.z, direction.x) + M_PI_2);
	488	float yAngle = 0.5f - ((atan2(direction.z, direction.y) + M_PI_2));
	489
	490	// Get the pixel range over which the xAngle and yAngle are scaled
	491	float cursorRange = canvasSize.x * SixenseManager::getInstance().getCursorPixelRangeMult();
	492
	493	mouseX = (canvasSize.x / 2.0f + cursorRange * xAngle);
	494	mouseY = (canvasSize.y / 2.0f + cursorRange * yAngle);
	495	}
	496
	497	//If the cursor is out of the screen then don't render it
	498	if (mouseX < 0 \|\| mouseX >= (int)canvasSize.x \|\| mouseY < 0 \|\| mouseY >= (int)canvasSize.y) {
	499	_reticleActive[index] = false;
	500	continue;
	501	}
	502	_reticleActive[index] = true;
	503
	504
	505	const float reticleSize = 40.0f;
	506
	507	mouseX -= reticleSize / 2.0f;
	508	mouseY += reticleSize / 2.0f;
	509
	510
	511	glm::vec2 topLeft(mouseX, mouseY);
	512	glm::vec2 bottomRight(mouseX + reticleSize, mouseY - reticleSize);
	513	glm::vec2 texCoordTopLeft(0.0f, 0.0f);
	514	glm::vec2 texCoordBottomRight(1.0f, 1.0f);
	515
	516	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
	517	glm::vec4(RETICLE_COLOR[0], RETICLE_COLOR[1], RETICLE_COLOR[2], 1.0f));
	518
	519	}
	520	}
	521
	522	//Renders a small magnification of the currently bound texture at the coordinates
	523	void ApplicationCompositor::renderMagnifier(gpu::Batch& batch, const glm::vec2& magPos, float sizeMult, bool showBorder) {
	524	if (!_magnifier) {
	525	return;
	526	}
	527	auto canvasSize = qApp->getCanvasSize();
	528
	529	const int widgetWidth = canvasSize.x;
	530	const int widgetHeight = canvasSize.y;
	531
	532	const float halfWidth = (MAGNIFY_WIDTH / _textureAspectRatio) * sizeMult / 2.0f;
	533	const float halfHeight = MAGNIFY_HEIGHT * sizeMult / 2.0f;
	534	// Magnification Texture Coordinates
	535	const float magnifyULeft = (magPos.x - halfWidth) / (float)widgetWidth;
	536	const float magnifyURight = (magPos.x + halfWidth) / (float)widgetWidth;
	537	const float magnifyVTop = 1.0f - (magPos.y - halfHeight) / (float)widgetHeight;
	538	const float magnifyVBottom = 1.0f - (magPos.y + halfHeight) / (float)widgetHeight;
	539
	540	const float newHalfWidth = halfWidth * MAGNIFY_MULT;
	541	const float newHalfHeight = halfHeight * MAGNIFY_MULT;
	542	//Get yaw / pitch value for the corners
	543	const glm::vec2 topLeftYawPitch = overlayToSpherical(glm::vec2(magPos.x - newHalfWidth,
	544	magPos.y - newHalfHeight));
	545	const glm::vec2 bottomRightYawPitch = overlayToSpherical(glm::vec2(magPos.x + newHalfWidth,
	546	magPos.y + newHalfHeight));
	547
	548	const glm::vec3 bottomLeft = getPoint(topLeftYawPitch.x, bottomRightYawPitch.y);
	549	const glm::vec3 bottomRight = getPoint(bottomRightYawPitch.x, bottomRightYawPitch.y);
	550	const glm::vec3 topLeft = getPoint(topLeftYawPitch.x, topLeftYawPitch.y);
	551	const glm::vec3 topRight = getPoint(bottomRightYawPitch.x, topLeftYawPitch.y);
	552
	553	auto geometryCache = DependencyManager::get<GeometryCache>();
	554
	555	if (bottomLeft != _previousMagnifierBottomLeft \|\| bottomRight != _previousMagnifierBottomRight
	556	\|\| topLeft != _previousMagnifierTopLeft \|\| topRight != _previousMagnifierTopRight) {
	557	QVector<glm::vec3> border;
	558	border << topLeft;
	559	border << bottomLeft;
	560	border << bottomRight;
	561	border << topRight;
	562	border << topLeft;
	563	geometryCache->updateVertices(_magnifierBorder, border, glm::vec4(1.0f, 0.0f, 0.0f, _alpha));
	564
	565	_previousMagnifierBottomLeft = bottomLeft;
	566	_previousMagnifierBottomRight = bottomRight;
	567	_previousMagnifierTopLeft = topLeft;
	568	_previousMagnifierTopRight = topRight;
	569	}
	570
	571	glPushMatrix(); {
	572	if (showBorder) {
	573	glDisable(GL_TEXTURE_2D);
	574	glLineWidth(1.0f);
	575	//Outer Line
	576	geometryCache->renderVertices(gpu::LINE_STRIP, _magnifierBorder);
	577	glEnable(GL_TEXTURE_2D);
	578	}
	579	glm::vec4 magnifierColor = { 1.0f, 1.0f, 1.0f, _alpha };
	580
	581	DependencyManager::get<GeometryCache>()->renderQuad(bottomLeft, bottomRight, topRight, topLeft,
	582	glm::vec2(magnifyULeft, magnifyVBottom),
	583	glm::vec2(magnifyURight, magnifyVBottom),
	584	glm::vec2(magnifyURight, magnifyVTop),
	585	glm::vec2(magnifyULeft, magnifyVTop),
	586	magnifierColor, _magnifierQuad);
	587
	588	} glPopMatrix();
	589	}
	590
	591	void ApplicationCompositor::buildHemiVertices(
	592	const float fov, const float aspectRatio, const int slices, const int stacks) {
	593	static float textureFOV = 0.0f, textureAspectRatio = 1.0f;
	594	if (textureFOV == fov && textureAspectRatio == aspectRatio) {
	595	return;
	596	}
	597
	598	textureFOV = fov;
	599	textureAspectRatio = aspectRatio;
	600
	601	auto geometryCache = DependencyManager::get<GeometryCache>();
	602
	603	_hemiVertices = gpu::BufferPointer(new gpu::Buffer());
	604	_hemiIndices = gpu::BufferPointer(new gpu::Buffer());
	605
	606
	607	if (fov >= PI) {
	608	qDebug() << "TexturedHemisphere::buildVBO(): FOV greater or equal than Pi will create issues";
	609	}
	610
	611	//UV mapping source: http://www.mvps.org/directx/articles/spheremap.htm
	612
	613	vec3 pos;
	614	vec2 uv;
	615	// Compute vertices positions and texture UV coordinate
	616	// Create and write to buffer
	617	for (int i = 0; i < stacks; i++) {
	618	uv.y = (float)i / (float)(stacks - 1); // First stack is 0.0f, last stack is 1.0f
	619	// abs(theta) <= fov / 2.0f
	620	float pitch = -fov * (uv.y - 0.5f);
	621	for (int j = 0; j < slices; j++) {
	622	uv.x = (float)j / (float)(slices - 1); // First slice is 0.0f, last slice is 1.0f
	623	// abs(phi) <= fov * aspectRatio / 2.0f
	624	float yaw = -fov * aspectRatio * (uv.x - 0.5f);
	625	pos = getPoint(yaw, pitch);
	626	static const vec4 color(1);
	627	_hemiVertices->append(sizeof(pos), (gpu::Byte*)&pos);
	628	_hemiVertices->append(sizeof(vec2), (gpu::Byte*)&uv);
	629	_hemiVertices->append(sizeof(vec4), (gpu::Byte*)&color);
	630	}
	631	}
	632
	633	// Compute number of indices needed
	634	static const int VERTEX_PER_TRANGLE = 3;
	635	static const int TRIANGLE_PER_RECTANGLE = 2;
	636	int numberOfRectangles = (slices - 1) * (stacks - 1);
	637	_hemiIndexCount = numberOfRectangles * TRIANGLE_PER_RECTANGLE * VERTEX_PER_TRANGLE;
	638
	639	// Compute indices order
	640	std::vector<GLushort> indices;
	641	for (int i = 0; i < stacks - 1; i++) {
	642	for (int j = 0; j < slices - 1; j++) {
	643	GLushort bottomLeftIndex = i * slices + j;
	644	GLushort bottomRightIndex = bottomLeftIndex + 1;
	645	GLushort topLeftIndex = bottomLeftIndex + slices;
	646	GLushort topRightIndex = topLeftIndex + 1;
	647	// FIXME make a z-order curve for better vertex cache locality
	648	indices.push_back(topLeftIndex);
	649	indices.push_back(bottomLeftIndex);
	650	indices.push_back(topRightIndex);
	651
	652	indices.push_back(topRightIndex);
	653	indices.push_back(bottomLeftIndex);
	654	indices.push_back(bottomRightIndex);
	655	}
	656	}
	657	_hemiIndices->append(sizeof(GLushort) * indices.size(), (gpu::Byte*)&indices[0]);
	658	}
	659
	660
	661	void ApplicationCompositor::drawSphereSection(gpu::Batch& batch) {
	662	buildHemiVertices(_textureFov, _textureAspectRatio, 80, 80);
	663	static const int VERTEX_DATA_SLOT = 0;
	664	static const int TEXTURE_DATA_SLOT = 1;
	665	static const int COLOR_DATA_SLOT = 2;
	666	gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); // 1 for everyone
	667	streamFormat->setAttribute(gpu::Stream::POSITION, VERTEX_DATA_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
	668	streamFormat->setAttribute(gpu::Stream::TEXCOORD, TEXTURE_DATA_SLOT, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::UV));
	669	streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_DATA_SLOT, gpu::Element(gpu::VEC4, gpu::FLOAT, gpu::RGBA));
	670	batch.setInputFormat(streamFormat);
	671
	672	static const int VERTEX_STRIDE = sizeof(vec3) + sizeof(vec2) + sizeof(vec4);
	673	gpu::BufferView posView(_hemiVertices, 0, _hemiVertices->getSize(), VERTEX_STRIDE, streamFormat->getAttributes().at(gpu::Stream::POSITION)._element);
	674	gpu::BufferView uvView(_hemiVertices, sizeof(vec3), _hemiVertices->getSize(), VERTEX_STRIDE, streamFormat->getAttributes().at(gpu::Stream::TEXCOORD)._element);
	675	gpu::BufferView colView(_hemiVertices, sizeof(vec3) + sizeof(vec2), _hemiVertices->getSize(), VERTEX_STRIDE, streamFormat->getAttributes().at(gpu::Stream::COLOR)._element);
	676	batch.setInputBuffer(VERTEX_DATA_SLOT, posView);
	677	batch.setInputBuffer(TEXTURE_DATA_SLOT, uvView);
	678	batch.setInputBuffer(COLOR_DATA_SLOT, colView);
	679	batch.setIndexBuffer(gpu::UINT16, _hemiIndices, 0);
	680	batch.drawIndexed(gpu::TRIANGLES, _hemiIndexCount);
	681	}
	682
	683	glm::vec2 ApplicationCompositor::directionToSpherical(const glm::vec3& direction) {
	684	glm::vec2 result;
	685	// Compute yaw
	686	glm::vec3 normalProjection = glm::normalize(glm::vec3(direction.x, 0.0f, direction.z));
	687	result.x = glm::acos(glm::dot(IDENTITY_FRONT, normalProjection));
	688	if (glm::dot(IDENTITY_RIGHT, normalProjection) > 0.0f) {
	689	result.x = -glm::abs(result.x);
	690	} else {
	691	result.x = glm::abs(result.x);
	692	}
	693	// Compute pitch
	694	result.y = angleBetween(IDENTITY_UP, direction) - PI_OVER_TWO;
	695
	696	return result;
	697	}
	698
	699	glm::vec3 ApplicationCompositor::sphericalToDirection(const glm::vec2& sphericalPos) {
	700	glm::quat rotation(glm::vec3(sphericalPos.y, sphericalPos.x, 0.0f));
	701	return rotation * IDENTITY_FRONT;
	702	}
	703
	704	glm::vec2 ApplicationCompositor::screenToSpherical(const glm::vec2& screenPos) {
	705	auto screenSize = qApp->getCanvasSize();
	706	glm::vec2 result;
	707	result.x = -(screenPos.x / screenSize.x - 0.5f);
	708	result.y = (screenPos.y / screenSize.y - 0.5f);
	709	result.x *= MOUSE_YAW_RANGE;
	710	result.y *= MOUSE_PITCH_RANGE;
	711
	712	return result;
	713	}
	714
	715	glm::vec2 ApplicationCompositor::sphericalToScreen(const glm::vec2& sphericalPos) {
	716	glm::vec2 result = sphericalPos;
	717	result.x *= -1.0;
	718	result /= MOUSE_RANGE;
	719	result += 0.5f;
	720	result *= qApp->getCanvasSize();
	721	return result;
	722	}
	723
	724	glm::vec2 ApplicationCompositor::sphericalToOverlay(const glm::vec2& sphericalPos) const {
	725	glm::vec2 result = sphericalPos;
	726	result.x *= -1.0;
	727	result /= _textureFov;
	728	result.x /= _textureAspectRatio;
	729	result += 0.5f;
	730	result *= qApp->getCanvasSize();
	731	return result;
	732	}
	733
	734	glm::vec2 ApplicationCompositor::overlayToSpherical(const glm::vec2& overlayPos) const {
	735	glm::vec2 result = overlayPos;
	736	result /= qApp->getCanvasSize();
	737	result -= 0.5f;
	738	result *= _textureFov;
	739	result.x *= _textureAspectRatio;
	740	result.x *= -1.0f;
	741	return result;
	742	}
	743
	744	glm::vec2 ApplicationCompositor::screenToOverlay(const glm::vec2& screenPos) const {
	745	return sphericalToOverlay(screenToSpherical(screenPos));
	746	}
	747
	748	glm::vec2 ApplicationCompositor::overlayToScreen(const glm::vec2& overlayPos) const {
	749	return sphericalToScreen(overlayToSpherical(overlayPos));
	750	}
	751
	752	void ApplicationCompositor::updateTooltips() {
	753	if (_hoverItemId != _noItemId) {
	754	quint64 hoverDuration = usecTimestampNow() - _hoverItemEnterUsecs;
	755	if (_hoverItemEnterUsecs != UINT64_MAX && !_hoverItemHref.isEmpty() && hoverDuration > TOOLTIP_DELAY) {
	756	// TODO Enable and position the tooltip
	757	_hoverItemEnterUsecs = UINT64_MAX;
	758	_tooltipId = Tooltip::showTip("URL: " + _hoverItemHref);
	759	}
	760	}
	761	}

interface/src/ui/ApplicationCompositor.h+120−0

@@ -0,0 +1,120 @@
	1	//
	2	// Created by Bradley Austin Davis Arnold on 2015/06/13
	3	// Copyright 2015 High Fidelity, Inc.
	4	//
	5	// Distributed under the Apache License, Version 2.0.
	6	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	7	//
	8
	9	#ifndef hifi_ApplicationCompositor_h
	10	#define hifi_ApplicationCompositor_h
	11
	12	#include <QObject>
	13	#include <cstdint>
	14
	15	#include <EntityItemID.h>
	16	#include <GeometryCache.h>
	17	#include <GLMHelpers.h>
	18	#include <gpu/Batch.h>
	19	#include <gpu/Texture.h>
	20
	21	class Camera;
	22	class PalmData;
	23	class RenderArgs;
	24
	25	const float MAGNIFY_WIDTH = 220.0f;
	26	const float MAGNIFY_HEIGHT = 100.0f;
	27	const float MAGNIFY_MULT = 2.0f;
	28
	29	const float DEFAULT_HMD_UI_ANGULAR_SIZE = 72.0f;
	30
	31	// Handles the drawing of the overlays to the screen
	32	// TODO, move divide up the rendering, displaying and input handling
	33	// facilities of this class
	34	class ApplicationCompositor : public QObject {
	35	Q_OBJECT
	36	public:
	37	ApplicationCompositor();
	38	~ApplicationCompositor();
	39
	40	void displayOverlayTexture(RenderArgs* renderArgs);
	41	void displayOverlayTextureHmd(RenderArgs* renderArgs, int eye);
	42
	43	QPoint getPalmClickLocation(const PalmData *palm) const;
	44	bool calculateRayUICollisionPoint(const glm::vec3& position, const glm::vec3& direction, glm::vec3& result) const;
	45
	46	bool hasMagnifier() const { return _magnifier; }
	47	void toggleMagnifier() { _magnifier = !_magnifier; }
	48
	49	float getHmdUIAngularSize() const { return _hmdUIAngularSize; }
	50	void setHmdUIAngularSize(float hmdUIAngularSize) { _hmdUIAngularSize = hmdUIAngularSize; }
	51
	52	// Converter from one frame of reference to another.
	53	// Frame of reference:
	54	// Direction: Ray that represents the spherical values
	55	// Screen: Position on the screen (x,y)
	56	// Spherical: Pitch and yaw that gives the position on the sphere we project on (yaw,pitch)
	57	// Overlay: Position on the overlay (x,y)
	58	// (x,y) in Overlay are similar than (x,y) in Screen except they can be outside of the bound of te screen.
	59	// This allows for picking outside of the screen projection in 3D.
	60	glm::vec2 sphericalToOverlay(const glm::vec2 & sphericalPos) const;
	61	glm::vec2 overlayToSpherical(const glm::vec2 & overlayPos) const;
	62	glm::vec2 screenToOverlay(const glm::vec2 & screenPos) const;
	63	glm::vec2 overlayToScreen(const glm::vec2 & overlayPos) const;
	64	void computeHmdPickRay(glm::vec2 cursorPos, glm::vec3& origin, glm::vec3& direction) const;
	65	GLuint getOverlayTexture() const;
	66
	67	static glm::vec2 directionToSpherical(const glm::vec3 & direction);
	68	static glm::vec3 sphericalToDirection(const glm::vec2 & sphericalPos);
	69	static glm::vec2 screenToSpherical(const glm::vec2 & screenPos);
	70	static glm::vec2 sphericalToScreen(const glm::vec2 & sphericalPos);
	71
	72	private:
	73	void displayOverlayTextureStereo(RenderArgs* renderArgs, float aspectRatio, float fov);
	74	void bindCursorTexture(gpu::Batch& batch, uint8_t cursorId = 0);
	75	void buildHemiVertices(const float fov, const float aspectRatio, const int slices, const int stacks);
	76	void drawSphereSection(gpu::Batch& batch);
	77	void updateTooltips();
	78
	79	void renderPointers(gpu::Batch& batch);
	80	void renderMagnifier(gpu::Batch& batch, const glm::vec2& magPos, float sizeMult, bool showBorder);
	81	void renderControllerPointers(gpu::Batch& batch);
	82	void renderPointersOculus(gpu::Batch& batch);
	83
	84	// Support for hovering and tooltips
	85	static EntityItemID _noItemId;
	86	EntityItemID _hoverItemId{ _noItemId };
	87	QString _hoverItemHref;
	88	quint64 _hoverItemEnterUsecs{ 0 };
	89
	90	float _hmdUIAngularSize = DEFAULT_HMD_UI_ANGULAR_SIZE;
	91	float _textureFov{ glm::radians(DEFAULT_HMD_UI_ANGULAR_SIZE) };
	92	float _textureAspectRatio{ 1.0f };
	93	int _hemiVerticesID{ GeometryCache::UNKNOWN_ID };
	94
	95	enum Reticles { MOUSE, LEFT_CONTROLLER, RIGHT_CONTROLLER, NUMBER_OF_RETICLES };
	96	bool _reticleActive[NUMBER_OF_RETICLES];
	97	QPoint _reticlePosition[NUMBER_OF_RETICLES];
	98	bool _magActive[NUMBER_OF_RETICLES];
	99	float _magSizeMult[NUMBER_OF_RETICLES];
	100	bool _magnifier{ true };
	101
	102	float _alpha{ 1.0f };
	103	float _oculusUIRadius{ 1.0f };
	104
	105	QMap<uint16_t, gpu::TexturePointer> _cursors;
	106
	107	int _reticleQuad;
	108	int _magnifierQuad;
	109	int _magnifierBorder;
	110
	111	int _previousBorderWidth{ -1 };
	112	int _previousBorderHeight{ -1 };
	113
	114	glm::vec3 _previousMagnifierBottomLeft;
	115	glm::vec3 _previousMagnifierBottomRight;
	116	glm::vec3 _previousMagnifierTopLeft;
	117	glm::vec3 _previousMagnifierTopRight;
	118	};
	119
	120	#endif // hifi_ApplicationCompositor_h

interface/src/ui/ApplicationOverlay.cpp+116−1172

@@ -14,166 +14,58 @@ · 13 unmodified lines
14	#include <QOpenGLFramebufferObject>	14	#include <QOpenGLFramebufferObject>
15	#include <QOpenGLTexture>	15	#include <QOpenGLTexture>
16		16
		17	#include <glm/gtc/type_ptr.hpp>
		18
17	#include <avatar/AvatarManager.h>	19	#include <avatar/AvatarManager.h>
		20	#include <DeferredLightingEffect.h>
18	#include <GLMHelpers.h>	21	#include <GLMHelpers.h>
19	#include <PathUtils.h>
20	#include <gpu/GLBackend.h>	22	#include <gpu/GLBackend.h>
		23	#include <gpu/GLBackendShared.h>
21	#include <GLMHelpers.h>	24	#include <GLMHelpers.h>
22	#include <PerfStat.h>
23	#include <OffscreenUi.h>	25	#include <OffscreenUi.h>
		26	#include <CursorManager.h>
		27	#include <PerfStat.h>
24		28
25	#include "AudioClient.h"	29	#include "AudioClient.h"
26	#include "audio/AudioIOStatsRenderer.h"	30	#include "audio/AudioIOStatsRenderer.h"
27	#include "audio/AudioScope.h"	31	#include "audio/AudioScope.h"
28	#include "audio/AudioToolBox.h"
29	#include "Application.h"	32	#include "Application.h"
30	#include "ApplicationOverlay.h"	33	#include "ApplicationOverlay.h"
31	#include "devices/CameraToolBox.h"
32		34
33	#include "Util.h"	35	#include "Util.h"
34	#include "ui/Stats.h"	36	#include "ui/Stats.h"
35		37	#include "ui/AvatarInputs.h"
36	// Used to animate the magnification windows
37	const float MAG_SPEED = 0.08f;
38
39	const quint64 MSECS_TO_USECS = 1000ULL;
40		38
41	const float WHITE_TEXT[] = { 0.93f, 0.93f, 0.93f };	39	const float WHITE_TEXT[] = { 0.93f, 0.93f, 0.93f };
42	const float RETICLE_COLOR[] = { 0.0f, 198.0f / 255.0f, 244.0f / 255.0f };	40	const int AUDIO_METER_GAP = 5;
43	const float reticleSize = TWO_PI / 100.0f;	41	const int MUTE_ICON_PADDING = 10;
44		42	const vec4 CONNECTION_STATUS_BORDER_COLOR{ 1.0f, 0.0f, 0.0f, 0.8f };
45
46	const float CONNECTION_STATUS_BORDER_COLOR[] = { 1.0f, 0.0f, 0.0f };
47	const float CONNECTION_STATUS_BORDER_LINE_WIDTH = 4.0f;	43	const float CONNECTION_STATUS_BORDER_LINE_WIDTH = 4.0f;
		44	static const float ORTHO_NEAR_CLIP = -10000;
		45	static const float ORTHO_FAR_CLIP = 10000;
48		46
49	static const float MOUSE_PITCH_RANGE = 1.0f * PI;	47	// TODO move somewhere useful
50	static const float MOUSE_YAW_RANGE = 0.5f * TWO_PI;	48	static void fboViewport(QOpenGLFramebufferObject* fbo) {
51	static const glm::vec2 MOUSE_RANGE(MOUSE_YAW_RANGE, MOUSE_PITCH_RANGE);	49	auto size = fbo->size();
52		50	glViewport(0, 0, size.width(), size.height());
53	// Return a point's cartesian coordinates on a sphere from pitch and yaw
54	glm::vec3 getPoint(float yaw, float pitch) {
55	return glm::vec3(glm::cos(-pitch) * (-glm::sin(yaw)),
56	glm::sin(-pitch),
57	glm::cos(-pitch) * (-glm::cos(yaw)));
58	}	51	}
59		52
60	//Checks if the given ray intersects the sphere at the origin. result will store a multiplier that should	53	ApplicationOverlay::ApplicationOverlay()
61	//be multiplied by dir and added to origin to get the location of the collision
62	bool raySphereIntersect(const glm::vec3 &dir, const glm::vec3 &origin, float r, float* result)
63	{	54	{
64	//Source: http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
65
66	//Compute A, B and C coefficients
67	float a = glm::dot(dir, dir);
68	float b = 2 * glm::dot(dir, origin);
69	float c = glm::dot(origin, origin) - (r * r);
70
71	//Find discriminant
72	float disc = b * b - 4 * a * c;
73
74	// if discriminant is negative there are no real roots, so return
75	// false as ray misses sphere
76	if (disc < 0) {
77	return false;
78	}
79
80	// compute q as described above
81	float distSqrt = sqrtf(disc);
82	float q;
83	if (b < 0) {
84	q = (-b - distSqrt) / 2.0;
85	} else {
86	q = (-b + distSqrt) / 2.0;
87	}
88
89	// compute t0 and t1
90	float t0 = q / a;
91	float t1 = c / q;
92
93	// make sure t0 is smaller than t1
94	if (t0 > t1) {
95	// if t0 is bigger than t1 swap them around
96	float temp = t0;
97	t0 = t1;
98	t1 = temp;
99	}
100
101	// if t1 is less than zero, the object is in the ray's negative direction
102	// and consequently the ray misses the sphere
103	if (t1 < 0) {
104	return false;
105	}
106
107	// if t0 is less than zero, the intersection point is at t1
108	if (t0 < 0) {
109	*result = t1;
110	return true;
111	} else { // else the intersection point is at t0
112	*result = t0;
113	return true;
114	}
115	}
116
117	void ApplicationOverlay::renderReticle(glm::quat orientation, float alpha) {
118	glPushMatrix(); {
119	glm::vec3 axis = glm::axis(orientation);
120	glRotatef(glm::degrees(glm::angle(orientation)), axis.x, axis.y, axis.z);
121	glm::vec3 topLeft = getPoint(reticleSize / 2.0f, -reticleSize / 2.0f);
122	glm::vec3 topRight = getPoint(-reticleSize / 2.0f, -reticleSize / 2.0f);
123	glm::vec3 bottomLeft = getPoint(reticleSize / 2.0f, reticleSize / 2.0f);
124	glm::vec3 bottomRight = getPoint(-reticleSize / 2.0f, reticleSize / 2.0f);
125
126	// TODO: this version of renderQuad() needs to take a color
127	glm::vec4 reticleColor = { RETICLE_COLOR[0], RETICLE_COLOR[1], RETICLE_COLOR[2], alpha };
128
129
130
131	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomLeft, bottomRight, topRight,
132	glm::vec2(0.0f, 0.0f), glm::vec2(1.0f, 0.0f),
133	glm::vec2(1.0f, 1.0f), glm::vec2(0.0f, 1.0f),
134	reticleColor, _reticleQuad);
135	} glPopMatrix();
136	}
137
138	ApplicationOverlay::ApplicationOverlay() :
139	_textureFov(glm::radians(DEFAULT_HMD_UI_ANGULAR_SIZE)),
140	_textureAspectRatio(1.0f),
141	_lastMouseMove(0),
142	_magnifier(true),
143	_alpha(1.0f),
144	_oculusUIRadius(1.0f),
145	_trailingAudioLoudness(0.0f),
146	_previousBorderWidth(-1),
147	_previousBorderHeight(-1),
148	_previousMagnifierBottomLeft(),
149	_previousMagnifierBottomRight(),
150	_previousMagnifierTopLeft(),
151	_previousMagnifierTopRight()
152	{
153	memset(_reticleActive, 0, sizeof(_reticleActive));
154	memset(_magActive, 0, sizeof(_reticleActive));
155	memset(_magSizeMult, 0, sizeof(_magSizeMult));
156
157	auto geometryCache = DependencyManager::get<GeometryCache>();	55	auto geometryCache = DependencyManager::get<GeometryCache>();
158
159	_reticleQuad = geometryCache->allocateID();
160	_magnifierQuad = geometryCache->allocateID();
161	_audioRedQuad = geometryCache->allocateID();
162	_audioGreenQuad = geometryCache->allocateID();
163	_audioBlueQuad = geometryCache->allocateID();
164	_domainStatusBorder = geometryCache->allocateID();	56	_domainStatusBorder = geometryCache->allocateID();
165	_magnifierBorder = geometryCache->allocateID();	57	_magnifierBorder = geometryCache->allocateID();
166		58
167	// Once we move UI rendering and screen rendering to different	59	// Once we move UI rendering and screen rendering to different
168	// threads, we need to use a sync object to deteremine when	60	// threads, we need to use a sync object to deteremine when
169	// the current UI texture is no longer being read from, and only	61	// the current UI texture is no longer being read from, and only
170	// then release it back to the UI for re-use	62	// then release it back to the UI for re-use
171	auto offscreenUi = DependencyManager::get<OffscreenUi>();	63	auto offscreenUi = DependencyManager::get<OffscreenUi>();
172	connect(offscreenUi.data(), &OffscreenUi::textureUpdated, this, [&](GLuint textureId) {	64	connect(offscreenUi.data(), &OffscreenUi::textureUpdated, this, [&](GLuint textureId) {
173	auto offscreenUi = DependencyManager::get<OffscreenUi>();	65	auto offscreenUi = DependencyManager::get<OffscreenUi>();
174	offscreenUi->lockTexture(textureId);	66	offscreenUi->lockTexture(textureId);
175	assert(!glGetError());	67	assert(!glGetError());
176	std::swap(_newUiTexture, textureId);	68	std::swap(_uiTexture, textureId);
177	if (textureId) {	69	if (textureId) {
178	offscreenUi->releaseTexture(textureId);	70	offscreenUi->releaseTexture(textureId);
179	}	71	}
@@ -185,846 +77,81 @@ ApplicationOverlay::~ApplicationOverlay() { · 5 unmodified lines
185		77
186	// Renders the overlays either to a texture or to the screen	78	// Renders the overlays either to a texture or to the screen
187	void ApplicationOverlay::renderOverlay(RenderArgs* renderArgs) {	79	void ApplicationOverlay::renderOverlay(RenderArgs* renderArgs) {
		80	CHECK_GL_ERROR();
188	PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "ApplicationOverlay::displayOverlay()");	81	PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "ApplicationOverlay::displayOverlay()");
189	Overlays& overlays = qApp->getOverlays();
190
191	_textureFov = glm::radians(_hmdUIAngularSize);
192	glm::vec2 size = qApp->getCanvasSize();
193	_textureAspectRatio = aspect(size);
194		82
195	//Handle fading and deactivation/activation of UI	83	// TODO move to Application::idle()?
196		84	Stats::getInstance()->updateStats();
197	// Render 2D overlay	85	AvatarInputs::getInstance()->update();
198	glMatrixMode(GL_PROJECTION);
199	glDisable(GL_DEPTH_TEST);
200	glDisable(GL_LIGHTING);
201	glEnable(GL_BLEND);
202	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
203	_overlays.buildFramebufferObject();
204	_overlays.bind();
205	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
206	glViewport(0, 0, size.x, size.y);
207		86
208	glPushMatrix(); {	87	buildFramebufferObject();
209	const float NEAR_CLIP = -10000;
210	const float FAR_CLIP = 10000;
211	glLoadIdentity();
212	glOrtho(0, size.x, size.y, 0, NEAR_CLIP, FAR_CLIP);
213		88
214	glMatrixMode(GL_MODELVIEW);	89	// Execute the batch into our framebuffer
215		90	_overlayFramebuffer->bind();
216	renderAudioMeter();	91	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
217	renderCameraToggle();	92	fboViewport(_overlayFramebuffer);
218
219	renderStatsAndLogs();
220
221	// give external parties a change to hook in
222	emit qApp->renderingOverlay();
223
224	overlays.renderHUD(renderArgs);
225
226	renderPointers();
227
228	renderDomainConnectionStatusBorder();
229
230	glMatrixMode(GL_PROJECTION);
231	} glPopMatrix();
232
233	glMatrixMode(GL_MODELVIEW);
234	glEnable(GL_DEPTH_TEST);
235	glEnable(GL_LIGHTING);
236	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
237
238	_overlays.release();
239	}
240		93
241	// A quick and dirty solution for compositing the old overlay	94	// Now render the overlay components together into a single texture
242	// texture with the new one	95	renderOverlays(renderArgs);
243	template <typename F>	96	renderStatsAndLogs(renderArgs);
244	void with_each_texture(GLuint firstPassTexture, GLuint secondPassTexture, F f) {	97	renderDomainConnectionStatusBorder(renderArgs);
245	glEnable(GL_TEXTURE_2D);	98	renderQmlUi(renderArgs);
246	glActiveTexture(GL_TEXTURE0);	99	_overlayFramebuffer->release();
247	if (firstPassTexture) {	100	CHECK_GL_ERROR();
248	glBindTexture(GL_TEXTURE_2D, firstPassTexture);
249	f();
250	}
251	if (secondPassTexture) {
252	glBindTexture(GL_TEXTURE_2D, secondPassTexture);
253	f();
254	}
255	glBindTexture(GL_TEXTURE_2D, 0);
256	glDisable(GL_TEXTURE_2D);
257	}	101	}
258		102
259	// Draws the FBO texture for the screen	103	void ApplicationOverlay::renderQmlUi(RenderArgs* renderArgs) {
260	void ApplicationOverlay::displayOverlayTexture() {	104	if (_uiTexture) {
261	if (_alpha == 0.0f) {	105	gpu::Batch batch;
262	return;	106	auto geometryCache = DependencyManager::get<GeometryCache>();
		107	geometryCache->useSimpleDrawPipeline(batch);
		108	batch.setProjectionTransform(mat4());
		109	batch.setModelTransform(mat4());
		110	batch._glBindTexture(GL_TEXTURE_2D, _uiTexture);
		111	geometryCache->renderUnitQuad(batch, glm::vec4(1));
		112	renderArgs->_context->syncCache();
		113	renderArgs->_context->render(batch);
263	}	114	}
264	glMatrixMode(GL_PROJECTION);
265	glPushMatrix(); {
266	glLoadIdentity();
267	glDisable(GL_DEPTH_TEST);
268	glDisable(GL_LIGHTING);
269	glEnable(GL_BLEND);
270	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
271	glViewport(0, 0, qApp->getDeviceSize().width(), qApp->getDeviceSize().height());
272
273	static const glm::vec2 topLeft(-1, 1);
274	static const glm::vec2 bottomRight(1, -1);
275	static const glm::vec2 texCoordTopLeft(0.0f, 1.0f);
276	static const glm::vec2 texCoordBottomRight(1.0f, 0.0f);
277	with_each_texture(_overlays.getTexture(), _newUiTexture, [&] {
278	DependencyManager::get<GeometryCache>()->renderQuad(
279	topLeft, bottomRight,
280	texCoordTopLeft, texCoordBottomRight,
281	glm::vec4(1.0f, 1.0f, 1.0f, _alpha));
282	});
283
284	if (!_crosshairTexture) {
285	_crosshairTexture = DependencyManager::get<TextureCache>()->
286	getImageTexture(PathUtils::resourcesPath() + "images/sixense-reticle.png");
287	}
288
289	//draw the mouse pointer
290	glm::vec2 canvasSize = qApp->getCanvasSize();
291	glm::vec2 mouseSize = 32.0f / canvasSize;
292	auto mouseTopLeft = topLeft * mouseSize;
293	auto mouseBottomRight = bottomRight * mouseSize;
294	vec2 mousePosition = vec2(qApp->getMouseX(), qApp->getMouseY());
295	mousePosition /= canvasSize;
296	mousePosition *= 2.0f;
297	mousePosition -= 1.0f;
298	mousePosition.y *= -1.0f;
299
300	glEnable(GL_TEXTURE_2D);
301	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
302	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_crosshairTexture));
303	glm::vec4 reticleColor = { RETICLE_COLOR[0], RETICLE_COLOR[1], RETICLE_COLOR[2], 1.0f };
304	DependencyManager::get<GeometryCache>()->renderQuad(
305	mouseTopLeft + mousePosition, mouseBottomRight + mousePosition,
306	texCoordTopLeft, texCoordBottomRight,
307	reticleColor);
308	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
309	glDisable(GL_TEXTURE_2D);
310	} glPopMatrix();
311	}	115	}
312		116
313	// Draws the FBO texture for Oculus rift.	117	void ApplicationOverlay::renderOverlays(RenderArgs* renderArgs) {
314	void ApplicationOverlay::displayOverlayTextureHmd(Camera& whichCamera) {	118	glm::vec2 size = qApp->getCanvasSize();
315	if (_alpha == 0.0f) {
316	return;
317	}
318
319	glEnable(GL_BLEND);
320	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
321	glEnable(GL_DEPTH_TEST);
322	glDepthMask(GL_TRUE);
323	glDisable(GL_LIGHTING);
324	glEnable(GL_ALPHA_TEST);
325	glAlphaFunc(GL_GREATER, 0.01f);
326
327		119
328	//Update and draw the magnifiers	120	mat4 legacyProjection = glm::ortho<float>(0, size.x, size.y, 0, ORTHO_NEAR_CLIP, ORTHO_FAR_CLIP);
329	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();	121	glMatrixMode(GL_PROJECTION);
330	const glm::quat& orientation = myAvatar->getOrientation();	122	glPushMatrix();
331	// Always display the HMD overlay relative to the camera position but	123	glLoadMatrixf(glm::value_ptr(legacyProjection));
332	// remove the HMD pose offset. This results in an overlay that sticks with you
333	// even in third person mode, but isn't drawn at a fixed distance.
334	glm::vec3 position = whichCamera.getPosition();
335	position -= qApp->getCamera()->getHmdPosition();
336	const float scale = myAvatar->getScale() * _oculusUIRadius;
337
338	// glm::vec3 eyeOffset = setEyeOffsetPosition;
339	glMatrixMode(GL_MODELVIEW);	124	glMatrixMode(GL_MODELVIEW);
340	glPushMatrix(); {
341	glTranslatef(position.x, position.y, position.z);
342	glm::mat4 rotation = glm::toMat4(orientation);
343	glMultMatrixf(&rotation[0][0]);
344	glScalef(scale, scale, scale);
345	for (int i = 0; i < NUMBER_OF_RETICLES; i++) {
346
347	if (_magActive[i]) {
348	_magSizeMult[i] += MAG_SPEED;
349	if (_magSizeMult[i] > 1.0f) {
350	_magSizeMult[i] = 1.0f;
351	}
352	} else {
353	_magSizeMult[i] -= MAG_SPEED;
354	if (_magSizeMult[i] < 0.0f) {
355	_magSizeMult[i] = 0.0f;
356	}
357	}
358
359	if (_magSizeMult[i] > 0.0f) {
360	//Render magnifier, but dont show border for mouse magnifier
361	glm::vec2 projection = screenToOverlay(glm::vec2(_reticlePosition[MOUSE].x(),
362	_reticlePosition[MOUSE].y()));
363	with_each_texture(_overlays.getTexture(), 0, [&] {
364	renderMagnifier(projection, _magSizeMult[i], i != MOUSE);
365	});
366	}
367	}
368
369	glDepthMask(GL_FALSE);
370	glDisable(GL_ALPHA_TEST);
371
372	static float textureFOV = 0.0f, textureAspectRatio = 1.0f;
373	if (textureFOV != _textureFov \|\|
374	textureAspectRatio != _textureAspectRatio) {
375	textureFOV = _textureFov;
376	textureAspectRatio = _textureAspectRatio;
377
378	_overlays.buildVBO(_textureFov, _textureAspectRatio, 80, 80);
379	}
380		125
381	with_each_texture(_overlays.getTexture(), _newUiTexture, [&] {
382	_overlays.render();
383	});
384
385	if (!Application::getInstance()->isMouseHidden()) {
386	renderPointersOculus();
387	}
388	glDepthMask(GL_TRUE);
389	glDisable(GL_TEXTURE_2D);
390
391	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
392	glEnable(GL_LIGHTING);
393	} glPopMatrix();
394	}
395
396	// Draws the FBO texture for 3DTV.
397	void ApplicationOverlay::displayOverlayTextureStereo(Camera& whichCamera, float aspectRatio, float fov) {
398	if (_alpha == 0.0f) {
399	return;
400	}
401
402	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
403	const glm::vec3& viewMatrixTranslation = qApp->getViewMatrixTranslation();
404
405	glEnable(GL_BLEND);
406	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
407	glEnable(GL_DEPTH_TEST);
408	glDisable(GL_LIGHTING);
409
410	glMatrixMode(GL_MODELVIEW);
411
412	glPushMatrix();
413	glLoadIdentity();
414	// Transform to world space
415	glm::quat rotation = whichCamera.getRotation();
416	glm::vec3 axis2 = glm::axis(rotation);
417	glRotatef(-glm::degrees(glm::angle(rotation)), axis2.x, axis2.y, axis2.z);
418	glTranslatef(viewMatrixTranslation.x, viewMatrixTranslation.y, viewMatrixTranslation.z);
419
420	// Translate to the front of the camera
421	glm::vec3 pos = whichCamera.getPosition();
422	glm::quat rot = myAvatar->getOrientation();
423	glm::vec3 axis = glm::axis(rot);
424
425	glTranslatef(pos.x, pos.y, pos.z);
426	glRotatef(glm::degrees(glm::angle(rot)), axis.x, axis.y, axis.z);
427
428	glm::vec4 overlayColor = {1.0f, 1.0f, 1.0f, _alpha};
429
430	//Render
431	const GLfloat distance = 1.0f;
432
433	const GLfloat halfQuadHeight = distance * tan(fov);
434	const GLfloat halfQuadWidth = halfQuadHeight * aspectRatio;
435	const GLfloat quadWidth = halfQuadWidth * 2.0f;
436	const GLfloat quadHeight = halfQuadHeight * 2.0f;
437
438	GLfloat x = -halfQuadWidth;
439	GLfloat y = -halfQuadHeight;
440	glDisable(GL_DEPTH_TEST);	126	glDisable(GL_DEPTH_TEST);
441		127	glDisable(GL_LIGHTING);
442	with_each_texture(_overlays.getTexture(), _newUiTexture, [&] {
443	DependencyManager::get<GeometryCache>()->renderQuad(glm::vec3(x, y + quadHeight, -distance),
444	glm::vec3(x + quadWidth, y + quadHeight, -distance),
445	glm::vec3(x + quadWidth, y, -distance),
446	glm::vec3(x, y, -distance),
447	glm::vec2(0.0f, 1.0f), glm::vec2(1.0f, 1.0f),
448	glm::vec2(1.0f, 0.0f), glm::vec2(0.0f, 0.0f),
449	overlayColor);
450	});
451
452	if (!_crosshairTexture) {
453	_crosshairTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() +
454	"images/sixense-reticle.png");
455	}
456
457	//draw the mouse pointer
458	glEnable(GL_BLEND);	128	glEnable(GL_BLEND);
459	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	129	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
460	glEnable(GL_TEXTURE_2D);
461	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_crosshairTexture));
462	glm::vec2 canvasSize = qApp->getCanvasSize();
463	const float reticleSize = 40.0f / canvasSize.x * quadWidth;
464	x -= reticleSize / 2.0f;
465	y += reticleSize / 2.0f;
466	const float mouseX = (qApp->getMouseX() / (float)canvasSize.x) * quadWidth;
467	const float mouseY = (1.0 - (qApp->getMouseY() / (float)canvasSize.y)) * quadHeight;
468
469	glm::vec4 reticleColor = { RETICLE_COLOR[0], RETICLE_COLOR[1], RETICLE_COLOR[2], 1.0f };
470		130
471	DependencyManager::get<GeometryCache>()->renderQuad(glm::vec3(x + mouseX, y + mouseY, -distance),	131	// give external parties a change to hook in
472	glm::vec3(x + mouseX + reticleSize, y + mouseY, -distance),	132	emit qApp->renderingOverlay();
473	glm::vec3(x + mouseX + reticleSize, y + mouseY - reticleSize, -distance),	133	qApp->getOverlays().renderHUD(renderArgs);
474	glm::vec3(x + mouseX, y + mouseY - reticleSize, -distance),
475	glm::vec2(0.0f, 0.0f), glm::vec2(1.0f, 0.0f),
476	glm::vec2(1.0f, 1.0f), glm::vec2(0.0f, 1.0f),
477	reticleColor, _reticleQuad);
478		134
479	glEnable(GL_DEPTH_TEST);	135	glMatrixMode(GL_PROJECTION);
480
481	glPopMatrix();	136	glPopMatrix();
482
483	glDepthMask(GL_TRUE);
484	glBindTexture(GL_TEXTURE_2D, 0);
485	glDisable(GL_TEXTURE_2D);
486
487	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
488	glEnable(GL_LIGHTING);
489	}
490
491	void ApplicationOverlay::computeHmdPickRay(glm::vec2 cursorPos, glm::vec3& origin, glm::vec3& direction) const {
492	cursorPos *= qApp->getCanvasSize();
493	const glm::vec2 projection = screenToSpherical(cursorPos);
494	// The overlay space orientation of the mouse coordinates
495	const glm::quat orientation(glm::vec3(-projection.y, projection.x, 0.0f));
496	// FIXME We now have the direction of the ray FROM THE DEFAULT HEAD POSE.
497	// Now we need to account for the actual camera position relative to the overlay
498	glm::vec3 overlaySpaceDirection = glm::normalize(orientation * IDENTITY_FRONT);
499
500
501	const glm::vec3& hmdPosition = qApp->getCamera()->getHmdPosition();
502	const glm::quat& hmdOrientation = qApp->getCamera()->getHmdRotation();
503
504	// We need the RAW camera orientation and position, because this is what the overlay is
505	// rendered relative to
506	const glm::vec3 overlayPosition = qApp->getCamera()->getPosition() - hmdPosition;
507	const glm::quat overlayOrientation = qApp->getCamera()->getRotation() * glm::inverse(hmdOrientation);
508
509	// Intersection UI overlay space
510	glm::vec3 worldSpaceDirection = overlayOrientation * overlaySpaceDirection;
511	glm::vec3 intersectionWithUi = glm::normalize(worldSpaceDirection) * _oculusUIRadius;
512	intersectionWithUi += overlayPosition;
513
514	// Intersection in world space
515	origin = overlayPosition + hmdPosition;
516	direction = glm::normalize(intersectionWithUi - origin);
517	}
518
519	glm::vec2 getPolarCoordinates(const PalmData& palm) {
520	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
521	auto avatarOrientation = myAvatar->getOrientation();
522	auto eyePos = myAvatar->getDefaultEyePosition();
523	glm::vec3 tip = myAvatar->getLaserPointerTipPosition(&palm);
524	// Direction of the tip relative to the eye
525	glm::vec3 tipDirection = tip - eyePos;
526	// orient into avatar space
527	tipDirection = glm::inverse(avatarOrientation) * tipDirection;
528	// Normalize for trig functions
529	tipDirection = glm::normalize(tipDirection);
530	// Convert to polar coordinates
531	glm::vec2 polar(glm::atan(tipDirection.x, -tipDirection.z), glm::asin(tipDirection.y));
532	return polar;
533	}
534
535	//Caculate the click location using one of the sixense controllers. Scale is not applied
536	QPoint ApplicationOverlay::getPalmClickLocation(const PalmData *palm) const {
537	QPoint rv;
538	auto canvasSize = qApp->getCanvasSize();
539	if (qApp->isHMDMode()) {
540	glm::vec2 polar = getPolarCoordinates(*palm);
541	glm::vec2 point = sphericalToScreen(-polar);
542	rv.rx() = point.x;
543	rv.ry() = point.y;
544	} else {
545	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
546	glm::dmat4 projection;
547	qApp->getProjectionMatrix(&projection);
548	glm::quat invOrientation = glm::inverse(myAvatar->getOrientation());
549	glm::vec3 eyePos = myAvatar->getDefaultEyePosition();
550	glm::vec3 tip = myAvatar->getLaserPointerTipPosition(palm);
551	glm::vec3 tipPos = invOrientation * (tip - eyePos);
552
553	glm::vec4 clipSpacePos = glm::vec4(projection * glm::dvec4(tipPos, 1.0));
554	glm::vec3 ndcSpacePos;
555	if (clipSpacePos.w != 0) {
556	ndcSpacePos = glm::vec3(clipSpacePos) / clipSpacePos.w;
557	}
558
559	rv.setX(((ndcSpacePos.x + 1.0) / 2.0) * canvasSize.x);
560	rv.setY((1.0 - ((ndcSpacePos.y + 1.0) / 2.0)) * canvasSize.y);
561	}
562	return rv;
563	}
564
565	//Finds the collision point of a world space ray
566	bool ApplicationOverlay::calculateRayUICollisionPoint(const glm::vec3& position, const glm::vec3& direction, glm::vec3& result) const {
567	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
568
569	glm::quat inverseOrientation = glm::inverse(myAvatar->getOrientation());
570
571	glm::vec3 relativePosition = inverseOrientation * (position - myAvatar->getDefaultEyePosition());
572	glm::vec3 relativeDirection = glm::normalize(inverseOrientation * direction);
573
574	float t;
575	if (raySphereIntersect(relativeDirection, relativePosition, _oculusUIRadius * myAvatar->getScale(), &t)){
576	result = position + direction * t;
577	return true;
578	}
579
580	return false;
581	}
582
583	//Renders optional pointers
584	void ApplicationOverlay::renderPointers() {
585	//lazily load crosshair texture
586	if (_crosshairTexture == 0) {
587	_crosshairTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/sixense-reticle.png");
588	}
589	glEnable(GL_TEXTURE_2D);
590	glEnable(GL_BLEND);
591	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
592
593	//glActiveTexture(GL_TEXTURE0);
594	//bindCursorTexture();
595
596	if (qApp->isHMDMode() && !qApp->getLastMouseMoveWasSimulated() && !qApp->isMouseHidden()) {
597	//If we are in oculus, render reticle later
598	if (_lastMouseMove == 0) {
599	_lastMouseMove = usecTimestampNow();
600	}
601	QPoint position = QPoint(qApp->getTrueMouseX(), qApp->getTrueMouseY());
602
603	static const int MAX_IDLE_TIME = 3;
604	if (_reticlePosition[MOUSE] != position) {
605	_lastMouseMove = usecTimestampNow();
606	} else if (usecTimestampNow() - _lastMouseMove > MAX_IDLE_TIME * USECS_PER_SECOND) {
607	//float pitch = 0.0f, yaw = 0.0f, roll = 0.0f; // radians
608	//OculusManager::getEulerAngles(yaw, pitch, roll);
609	glm::quat orientation = qApp->getHeadOrientation(); // (glm::vec3(pitch, yaw, roll));
610	glm::vec3 result;
611
612	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
613	if (calculateRayUICollisionPoint(myAvatar->getEyePosition(),
614	myAvatar->getOrientation() * orientation * IDENTITY_FRONT,
615	result)) {
616	glm::vec3 lookAtDirection = glm::inverse(myAvatar->getOrientation()) * (result - myAvatar->getDefaultEyePosition());
617	glm::vec2 spericalPos = directionToSpherical(glm::normalize(lookAtDirection));
618	glm::vec2 screenPos = sphericalToScreen(spericalPos);
619	position = QPoint(screenPos.x, screenPos.y);
620	// FIXME
621	//glCanvas->cursor().setPos(glCanvas->mapToGlobal(position));
622	} else {
623	qDebug() << "No collision point";
624	}
625	}
626
627	_reticlePosition[MOUSE] = position;
628	_reticleActive[MOUSE] = true;
629	_magActive[MOUSE] = _magnifier;
630	_reticleActive[LEFT_CONTROLLER] = false;
631	_reticleActive[RIGHT_CONTROLLER] = false;
632	} else if (qApp->getLastMouseMoveWasSimulated() && Menu::getInstance()->isOptionChecked(MenuOption::SixenseMouseInput)) {
633	_lastMouseMove = 0;
634	//only render controller pointer if we aren't already rendering a mouse pointer
635	_reticleActive[MOUSE] = false;
636	_magActive[MOUSE] = false;
637	renderControllerPointers();
638	}
639	//glBindTexture(GL_TEXTURE_2D, 0);
640	//glDisable(GL_TEXTURE_2D);
641	}
642
643	void ApplicationOverlay::renderControllerPointers() {
644	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
645
646	//Static variables used for storing controller state
647	static quint64 pressedTime[NUMBER_OF_RETICLES] = { 0ULL, 0ULL, 0ULL };
648	static bool isPressed[NUMBER_OF_RETICLES] = { false, false, false };
649	static bool stateWhenPressed[NUMBER_OF_RETICLES] = { false, false, false };
650
651	const HandData* handData = DependencyManager::get<AvatarManager>()->getMyAvatar()->getHandData();
652
653	for (unsigned int palmIndex = 2; palmIndex < 4; palmIndex++) {
654	const int index = palmIndex - 1;
655
656	const PalmData* palmData = NULL;
657
658	if (palmIndex >= handData->getPalms().size()) {
659	return;
660	}
661
662	if (handData->getPalms()[palmIndex].isActive()) {
663	palmData = &handData->getPalms()[palmIndex];
664	} else {
665	continue;
666	}
667
668	int controllerButtons = palmData->getControllerButtons();
669
670	//Check for if we should toggle or drag the magnification window
671	if (controllerButtons & BUTTON_3) {
672	if (isPressed[index] == false) {
673	//We are now dragging the window
674	isPressed[index] = true;
675	//set the pressed time in us
676	pressedTime[index] = usecTimestampNow();
677	stateWhenPressed[index] = _magActive[index];
678	}
679	} else if (isPressed[index]) {
680	isPressed[index] = false;
681	//If the button was only pressed for < 250 ms
682	//then disable it.
683
684	const int MAX_BUTTON_PRESS_TIME = 250 * MSECS_TO_USECS;
685	if (usecTimestampNow() < pressedTime[index] + MAX_BUTTON_PRESS_TIME) {
686	_magActive[index] = !stateWhenPressed[index];
687	}
688	}
689
690	//if we have the oculus, we should make the cursor smaller since it will be
691	//magnified
692	if (qApp->isHMDMode()) {
693
694	QPoint point = getPalmClickLocation(palmData);
695
696	_reticlePosition[index] = point;
697
698	//When button 2 is pressed we drag the mag window
699	if (isPressed[index]) {
700	_magActive[index] = true;
701	}
702
703	// If oculus is enabled, we draw the crosshairs later
704	continue;
705	}
706
707	auto canvasSize = qApp->getCanvasSize();
708	int mouseX, mouseY;
709	if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseLasers)) {
710	QPoint res = getPalmClickLocation(palmData);
711	mouseX = res.x();
712	mouseY = res.y();
713	} else {
714	// Get directon relative to avatar orientation
715	glm::vec3 direction = glm::inverse(myAvatar->getOrientation()) * palmData->getFingerDirection();
716
717	// Get the angles, scaled between (-0.5,0.5)
718	float xAngle = (atan2(direction.z, direction.x) + M_PI_2);
719	float yAngle = 0.5f - ((atan2(direction.z, direction.y) + M_PI_2));
720
721	// Get the pixel range over which the xAngle and yAngle are scaled
722	float cursorRange = canvasSize.x * SixenseManager::getInstance().getCursorPixelRangeMult();
723
724	mouseX = (canvasSize.x / 2.0f + cursorRange * xAngle);
725	mouseY = (canvasSize.y / 2.0f + cursorRange * yAngle);
726	}
727
728	//If the cursor is out of the screen then don't render it
729	if (mouseX < 0 \|\| mouseX >= (int)canvasSize.x \|\| mouseY < 0 \|\| mouseY >= (int)canvasSize.y) {
730	_reticleActive[index] = false;
731	continue;
732	}
733	_reticleActive[index] = true;
734
735
736	const float reticleSize = 40.0f;
737
738	mouseX -= reticleSize / 2.0f;
739	mouseY += reticleSize / 2.0f;
740
741
742	glm::vec2 topLeft(mouseX, mouseY);
743	glm::vec2 bottomRight(mouseX + reticleSize, mouseY - reticleSize);
744	glm::vec2 texCoordTopLeft(0.0f, 0.0f);
745	glm::vec2 texCoordBottomRight(1.0f, 1.0f);
746
747	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
748	glm::vec4(RETICLE_COLOR[0], RETICLE_COLOR[1], RETICLE_COLOR[2], 1.0f));
749
750	}
751	}
752
753	void ApplicationOverlay::renderPointersOculus() {
754
755	glEnable(GL_BLEND);
756	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
757	glEnable(GL_TEXTURE_2D);
758
759	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(_crosshairTexture));
760	glDisable(GL_DEPTH_TEST);
761
762	glMatrixMode(GL_MODELVIEW);	137	glMatrixMode(GL_MODELVIEW);
763
764	//Controller Pointers
765	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
766	for (int i = 0; i < (int)myAvatar->getHand()->getNumPalms(); i++) {
767	PalmData& palm = myAvatar->getHand()->getPalms()[i];
768	if (palm.isActive()) {
769	glm::vec2 polar = getPolarCoordinates(palm);
770	// Convert to quaternion
771	glm::quat orientation = glm::quat(glm::vec3(polar.y, -polar.x, 0.0f));
772	// Render reticle at location
773	renderReticle(orientation, _alpha);
774	}
775	}
776
777	//Mouse Pointer
778	if (_reticleActive[MOUSE]) {
779	glm::vec2 projection = screenToSpherical(glm::vec2(_reticlePosition[MOUSE].x(),
780	_reticlePosition[MOUSE].y()));
781	glm::quat orientation(glm::vec3(-projection.y, projection.x, 0.0f));
782	renderReticle(orientation, _alpha);
783	}
784		138
785	glEnable(GL_DEPTH_TEST);	139	renderArgs->_context->syncCache();
786	glDisable(GL_TEXTURE_2D);	140	fboViewport(_overlayFramebuffer);
787	glDisable(GL_BLEND);
788	}	141	}
789		142
790	//Renders a small magnification of the currently bound texture at the coordinates	143	void ApplicationOverlay::renderRearViewToFbo(RenderArgs* renderArgs) {
791	void ApplicationOverlay::renderMagnifier(glm::vec2 magPos, float sizeMult, bool showBorder) {
792	if (!_magnifier) {
793	return;
794	}
795	auto canvasSize = qApp->getCanvasSize();
796
797	const int widgetWidth = canvasSize.x;
798	const int widgetHeight = canvasSize.y;
799
800	const float halfWidth = (MAGNIFY_WIDTH / _textureAspectRatio) * sizeMult / 2.0f;
801	const float halfHeight = MAGNIFY_HEIGHT * sizeMult / 2.0f;
802	// Magnification Texture Coordinates
803	const float magnifyULeft = (magPos.x - halfWidth) / (float)widgetWidth;
804	const float magnifyURight = (magPos.x + halfWidth) / (float)widgetWidth;
805	const float magnifyVTop = 1.0f - (magPos.y - halfHeight) / (float)widgetHeight;
806	const float magnifyVBottom = 1.0f - (magPos.y + halfHeight) / (float)widgetHeight;
807
808	const float newHalfWidth = halfWidth * MAGNIFY_MULT;
809	const float newHalfHeight = halfHeight * MAGNIFY_MULT;
810	//Get yaw / pitch value for the corners
811	const glm::vec2 topLeftYawPitch = overlayToSpherical(glm::vec2(magPos.x - newHalfWidth,
812	magPos.y - newHalfHeight));
813	const glm::vec2 bottomRightYawPitch = overlayToSpherical(glm::vec2(magPos.x + newHalfWidth,
814	magPos.y + newHalfHeight));
815
816	const glm::vec3 bottomLeft = getPoint(topLeftYawPitch.x, bottomRightYawPitch.y);
817	const glm::vec3 bottomRight = getPoint(bottomRightYawPitch.x, bottomRightYawPitch.y);
818	const glm::vec3 topLeft = getPoint(topLeftYawPitch.x, topLeftYawPitch.y);
819	const glm::vec3 topRight = getPoint(bottomRightYawPitch.x, topLeftYawPitch.y);
820
821	auto geometryCache = DependencyManager::get<GeometryCache>();
822
823	if (bottomLeft != _previousMagnifierBottomLeft \|\| bottomRight != _previousMagnifierBottomRight
824	\|\| topLeft != _previousMagnifierTopLeft \|\| topRight != _previousMagnifierTopRight) {
825	QVector<glm::vec3> border;
826	border << topLeft;
827	border << bottomLeft;
828	border << bottomRight;
829	border << topRight;
830	border << topLeft;
831	geometryCache->updateVertices(_magnifierBorder, border, glm::vec4(1.0f, 0.0f, 0.0f, _alpha));
832
833	_previousMagnifierBottomLeft = bottomLeft;
834	_previousMagnifierBottomRight = bottomRight;
835	_previousMagnifierTopLeft = topLeft;
836	_previousMagnifierTopRight = topRight;
837	}
838
839	glPushMatrix(); {
840	if (showBorder) {
841	glDisable(GL_TEXTURE_2D);
842	glLineWidth(1.0f);
843	//Outer Line
844	geometryCache->renderVertices(gpu::LINE_STRIP, _magnifierBorder);
845	glEnable(GL_TEXTURE_2D);
846	}
847	glm::vec4 magnifierColor = { 1.0f, 1.0f, 1.0f, _alpha };
848
849	DependencyManager::get<GeometryCache>()->renderQuad(bottomLeft, bottomRight, topRight, topLeft,
850	glm::vec2(magnifyULeft, magnifyVBottom),
851	glm::vec2(magnifyURight, magnifyVBottom),
852	glm::vec2(magnifyURight, magnifyVTop),
853	glm::vec2(magnifyULeft, magnifyVTop),
854	magnifierColor, _magnifierQuad);
855
856	} glPopMatrix();
857	}	144	}
858		145
859	const int AUDIO_METER_GAP = 5;	146	void ApplicationOverlay::renderRearView(RenderArgs* renderArgs) {
860	const int MUTE_ICON_PADDING = 10;
861
862	void ApplicationOverlay::renderCameraToggle() {
863	if (Menu::getInstance()->isOptionChecked(MenuOption::NoFaceTracking)) {
864	return;
865	}
866
867	int audioMeterY;
868	bool smallMirrorVisible = Menu::getInstance()->isOptionChecked(MenuOption::Mirror) && !qApp->isHMDMode();
869	bool boxed = smallMirrorVisible &&
870	!Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror);
871	if (boxed) {
872	audioMeterY = MIRROR_VIEW_HEIGHT + AUDIO_METER_GAP + MUTE_ICON_PADDING;
873	} else {
874	audioMeterY = AUDIO_METER_GAP + MUTE_ICON_PADDING;
875	}
876
877	DependencyManager::get<CameraToolBox>()->render(MIRROR_VIEW_LEFT_PADDING + AUDIO_METER_GAP, audioMeterY, boxed);
878	}	147	}
879		148
880	void ApplicationOverlay::renderAudioMeter() {	149	void ApplicationOverlay::renderStatsAndLogs(RenderArgs* renderArgs) {
881	auto audio = DependencyManager::get<AudioClient>();
882
883	// Audio VU Meter and Mute Icon
884	const int MUTE_ICON_SIZE = 24;
885	const int AUDIO_METER_HEIGHT = 8;
886	const int INTER_ICON_GAP = 2;
887
888	int cameraSpace = 0;
889	int audioMeterWidth = MIRROR_VIEW_WIDTH - MUTE_ICON_SIZE - MUTE_ICON_PADDING;
890	int audioMeterScaleWidth = audioMeterWidth - 2;
891	int audioMeterX = MIRROR_VIEW_LEFT_PADDING + MUTE_ICON_SIZE + AUDIO_METER_GAP;
892	if (!Menu::getInstance()->isOptionChecked(MenuOption::NoFaceTracking)) {
893	cameraSpace = MUTE_ICON_SIZE + INTER_ICON_GAP;
894	audioMeterWidth -= cameraSpace;
895	audioMeterScaleWidth -= cameraSpace;
896	audioMeterX += cameraSpace;
897	}
898
899	int audioMeterY;
900	bool smallMirrorVisible = Menu::getInstance()->isOptionChecked(MenuOption::Mirror) && !qApp->isHMDMode();
901	bool boxed = smallMirrorVisible &&
902	!Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror);
903	if (boxed) {
904	audioMeterY = MIRROR_VIEW_HEIGHT + AUDIO_METER_GAP + MUTE_ICON_PADDING;
905	} else {
906	audioMeterY = AUDIO_METER_GAP + MUTE_ICON_PADDING;
907	}
908
909	const glm::vec4 AUDIO_METER_BLUE = { 0.0, 0.0, 1.0, 1.0 };
910	const glm::vec4 AUDIO_METER_GREEN = { 0.0, 1.0, 0.0, 1.0 };
911	const glm::vec4 AUDIO_METER_RED = { 1.0, 0.0, 0.0, 1.0 };
912	const float CLIPPING_INDICATOR_TIME = 1.0f;
913	const float AUDIO_METER_AVERAGING = 0.5;
914	const float LOG2 = log(2.0f);
915	const float METER_LOUDNESS_SCALE = 2.8f / 5.0f;
916	const float LOG2_LOUDNESS_FLOOR = 11.0f;
917	float audioGreenStart = 0.25f * audioMeterScaleWidth;
918	float audioRedStart = 0.8f * audioMeterScaleWidth;
919	float audioLevel = 0.0f;
920	float loudness = audio->getLastInputLoudness() + 1.0f;
921
922	_trailingAudioLoudness = AUDIO_METER_AVERAGING * _trailingAudioLoudness + (1.0f - AUDIO_METER_AVERAGING) * loudness;
923	float log2loudness = log(_trailingAudioLoudness) / LOG2;
924
925	if (log2loudness <= LOG2_LOUDNESS_FLOOR) {
926	audioLevel = (log2loudness / LOG2_LOUDNESS_FLOOR) * METER_LOUDNESS_SCALE * audioMeterScaleWidth;
927	} else {
928	audioLevel = (log2loudness - (LOG2_LOUDNESS_FLOOR - 1.0f)) * METER_LOUDNESS_SCALE * audioMeterScaleWidth;
929	}
930	if (audioLevel > audioMeterScaleWidth) {
931	audioLevel = audioMeterScaleWidth;
932	}
933	bool isClipping = ((audio->getTimeSinceLastClip() > 0.0f) && (audio->getTimeSinceLastClip() < CLIPPING_INDICATOR_TIME));
934
935	DependencyManager::get<AudioToolBox>()->render(MIRROR_VIEW_LEFT_PADDING + AUDIO_METER_GAP, audioMeterY, cameraSpace, boxed);
936
937	auto canvasSize = qApp->getCanvasSize();
938	DependencyManager::get<AudioScope>()->render(canvasSize.x, canvasSize.y);
939	DependencyManager::get<AudioIOStatsRenderer>()->render(WHITE_TEXT, canvasSize.x, canvasSize.y);
940
941	audioMeterY += AUDIO_METER_HEIGHT;
942
943	// Draw audio meter background Quad
944	DependencyManager::get<GeometryCache>()->renderQuad(audioMeterX, audioMeterY, audioMeterWidth, AUDIO_METER_HEIGHT,
945	glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
946
947	if (audioLevel > audioRedStart) {
948	glm::vec4 quadColor;
949	if (!isClipping) {
950	quadColor = AUDIO_METER_RED;
951	} else {
952	quadColor = glm::vec4(1, 1, 1, 1);
953	}
954	// Draw Red Quad
955	DependencyManager::get<GeometryCache>()->renderQuad(audioMeterX + audioRedStart,
956	audioMeterY,
957	audioLevel - audioRedStart,
958	AUDIO_METER_HEIGHT, quadColor,
959	_audioRedQuad);
960
961	audioLevel = audioRedStart;
962	}
963
964	if (audioLevel > audioGreenStart) {
965	glm::vec4 quadColor;
966	if (!isClipping) {
967	quadColor = AUDIO_METER_GREEN;
968	} else {
969	quadColor = glm::vec4(1, 1, 1, 1);
970	}
971	// Draw Green Quad
972	DependencyManager::get<GeometryCache>()->renderQuad(audioMeterX + audioGreenStart,
973	audioMeterY,
974	audioLevel - audioGreenStart,
975	AUDIO_METER_HEIGHT, quadColor,
976	_audioGreenQuad);
977
978	audioLevel = audioGreenStart;
979	}
980
981	if (audioLevel >= 0) {
982	glm::vec4 quadColor;
983	if (!isClipping) {
984	quadColor = AUDIO_METER_BLUE;
985	} else {
986	quadColor = glm::vec4(1, 1, 1, 1);
987	}
988	// Draw Blue (low level) quad
989	DependencyManager::get<GeometryCache>()->renderQuad(audioMeterX,
990	audioMeterY,
991	audioLevel, AUDIO_METER_HEIGHT, quadColor,
992	_audioBlueQuad);
993	}
994	}
995
996	void ApplicationOverlay::renderStatsAndLogs() {
997	Application* application = Application::getInstance();
998	QSharedPointer<BandwidthRecorder> bandwidthRecorder = DependencyManager::get<BandwidthRecorder>();
999
1000	const OctreePacketProcessor& octreePacketProcessor = application->getOctreePacketProcessor();
1001	NodeBounds& nodeBoundsDisplay = application->getNodeBoundsDisplay();
1002
1003	// Display stats and log text onscreen	150	// Display stats and log text onscreen
1004	glLineWidth(1.0f);
1005	glPointSize(1.0f);
1006		151
1007	// Determine whether to compute timing details	152	// Determine whether to compute timing details
1008	bool shouldDisplayTimingDetail = Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails) &&
1009	Menu::getInstance()->isOptionChecked(MenuOption::Stats) &&
1010	Stats::getInstance()->isExpanded();
1011	if (shouldDisplayTimingDetail != PerformanceTimer::isActive()) {
1012	PerformanceTimer::setActive(shouldDisplayTimingDetail);
1013	}
1014
1015	if (Menu::getInstance()->isOptionChecked(MenuOption::Stats)) {
1016	// let's set horizontal offset to give stats some margin to mirror
1017	int horizontalOffset = MIRROR_VIEW_WIDTH + MIRROR_VIEW_LEFT_PADDING * 2;
1018	int voxelPacketsToProcess = octreePacketProcessor.packetsToProcessCount();
1019	// Onscreen text about position, servers, etc
1020	Stats::getInstance()->display(WHITE_TEXT, horizontalOffset, application->getFps(),
1021	bandwidthRecorder->getCachedTotalAverageInputPacketsPerSecond(),
1022	bandwidthRecorder->getCachedTotalAverageOutputPacketsPerSecond(),
1023	bandwidthRecorder->getCachedTotalAverageInputKilobitsPerSecond(),
1024	bandwidthRecorder->getCachedTotalAverageOutputKilobitsPerSecond(),
1025	voxelPacketsToProcess);
1026	}
1027		153
		154	/*
1028	// Show on-screen msec timer	155	// Show on-screen msec timer
1029	if (Menu::getInstance()->isOptionChecked(MenuOption::FrameTimer)) {	156	if (Menu::getInstance()->isOptionChecked(MenuOption::FrameTimer)) {
1030	auto canvasSize = qApp->getCanvasSize();	157	auto canvasSize = qApp->getCanvasSize();
@@ -1036,159 +163,77 @@ void ApplicationOverlay::renderStatsAndLogs() { · 5 unmodified lines
1036	drawText(canvasSize.x - 100, canvasSize.y - timerBottom,	163	drawText(canvasSize.x - 100, canvasSize.y - timerBottom,
1037	0.30f, 0.0f, 0, frameTimer.toUtf8().constData(), WHITE_TEXT);	164	0.30f, 0.0f, 0, frameTimer.toUtf8().constData(), WHITE_TEXT);
1038	}	165	}
		166
		167	glPointSize(1.0f);
		168	glDisable(GL_DEPTH_TEST);
		169	glDisable(GL_LIGHTING);
		170	glEnable(GL_BLEND);
		171	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		172	NodeBounds& nodeBoundsDisplay = qApp->getNodeBoundsDisplay();
1039	nodeBoundsDisplay.drawOverlay();	173	nodeBoundsDisplay.drawOverlay();
		174	glEnable(GL_DEPTH_TEST);
		175	glEnable(GL_LIGHTING);
		176	glEnable(GL_BLEND);
		177	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
		178	fboViewport(_overlayFramebuffer);
		179	*/
1040	}	180	}
1041		181
1042	void ApplicationOverlay::renderDomainConnectionStatusBorder() {	182	void ApplicationOverlay::renderDomainConnectionStatusBorder(RenderArgs* renderArgs) {
		183	auto geometryCache = DependencyManager::get<GeometryCache>();
		184	static std::once_flag once;
		185	std::call_once(once, [&] {
		186	QVector<vec2> points;
		187	static const float B = 0.99f;
		188	points.push_back(vec2(-B));
		189	points.push_back(vec2(B, -B));
		190	points.push_back(vec2(B));
		191	points.push_back(vec2(-B, B));
		192	points.push_back(vec2(-B));
		193	geometryCache->updateVertices(_domainStatusBorder, points, CONNECTION_STATUS_BORDER_COLOR);
		194	});
1043	auto nodeList = DependencyManager::get<NodeList>();	195	auto nodeList = DependencyManager::get<NodeList>();
1044
1045	if (nodeList && !nodeList->getDomainHandler().isConnected()) {	196	if (nodeList && !nodeList->getDomainHandler().isConnected()) {
		197	gpu::Batch batch;
1046	auto geometryCache = DependencyManager::get<GeometryCache>();	198	auto geometryCache = DependencyManager::get<GeometryCache>();
1047	auto canvasSize = qApp->getCanvasSize();	199	geometryCache->useSimpleDrawPipeline(batch);
1048	if ((int)canvasSize.x != _previousBorderWidth \|\| (int)canvasSize.y != _previousBorderHeight) {	200	batch.setProjectionTransform(mat4());
1049	glm::vec4 color(CONNECTION_STATUS_BORDER_COLOR[0],	201	batch.setModelTransform(mat4());
1050	CONNECTION_STATUS_BORDER_COLOR[1],	202	batch.setUniformTexture(0, DependencyManager::get<TextureCache>()->getWhiteTexture());
1051	CONNECTION_STATUS_BORDER_COLOR[2], 1.0f);	203	batch._glLineWidth(CONNECTION_STATUS_BORDER_LINE_WIDTH);
1052
1053	QVector<glm::vec2> border;
1054	border << glm::vec2(0, 0);
1055	border << glm::vec2(0, canvasSize.y);
1056	border << glm::vec2(canvasSize.x, canvasSize.y);
1057	border << glm::vec2(canvasSize.x, 0);
1058	border << glm::vec2(0, 0);
1059	geometryCache->updateVertices(_domainStatusBorder, border, color);
1060	_previousBorderWidth = canvasSize.x;
1061	_previousBorderHeight = canvasSize.y;
1062	}
1063
1064	glLineWidth(CONNECTION_STATUS_BORDER_LINE_WIDTH);
1065
1066	geometryCache->renderVertices(gpu::LINE_STRIP, _domainStatusBorder);
1067	}
1068	}
1069		204
1070	ApplicationOverlay::TexturedHemisphere::TexturedHemisphere() :	205	// TODO animate the disconnect border for some excitement while not connected?
1071	_vertices(0),	206	//double usecs = usecTimestampNow();
1072	_indices(0),	207	//double secs = usecs / 1000000.0;
1073	_framebufferObject(NULL),	208	//float scaleAmount = 1.0f + (0.01f * sin(secs * 5.0f));
1074	_vbo(0, 0) {	209	//batch.setModelTransform(glm::scale(mat4(), vec3(scaleAmount)));
1075	}
1076
1077	ApplicationOverlay::TexturedHemisphere::~TexturedHemisphere() {
1078	cleanupVBO();
1079	if (_framebufferObject != NULL) {
1080	delete _framebufferObject;
1081	}
1082	}
1083
1084	void ApplicationOverlay::TexturedHemisphere::bind() {
1085	_framebufferObject->bind();
1086	}
1087
1088	void ApplicationOverlay::TexturedHemisphere::release() {
1089	_framebufferObject->release();
1090	}
1091		210
1092	void ApplicationOverlay::TexturedHemisphere::buildVBO(const float fov,	211	geometryCache->renderVertices(batch, gpu::LINE_STRIP, _domainStatusBorder);
1093	const float aspectRatio,	212	renderArgs->_context->syncCache();
1094	const int slices,	213	renderArgs->_context->render(batch);
1095	const int stacks) {
1096	if (fov >= PI) {
1097	qDebug() << "TexturedHemisphere::buildVBO(): FOV greater or equal than Pi will create issues";
1098	}
1099	// Cleanup old VBO if necessary
1100	cleanupVBO();
1101
1102	//UV mapping source: http://www.mvps.org/directx/articles/spheremap.htm
1103
1104	// Compute number of vertices needed
1105	_vertices = slices * stacks;
1106
1107	// Compute vertices positions and texture UV coordinate
1108	TextureVertex* vertexData = new TextureVertex[_vertices];
1109	TextureVertex* vertexPtr = &vertexData[0];
1110	for (int i = 0; i < stacks; i++) {
1111	float stacksRatio = (float)i / (float)(stacks - 1); // First stack is 0.0f, last stack is 1.0f
1112	// abs(theta) <= fov / 2.0f
1113	float pitch = -fov * (stacksRatio - 0.5f);
1114
1115	for (int j = 0; j < slices; j++) {
1116	float slicesRatio = (float)j / (float)(slices - 1); // First slice is 0.0f, last slice is 1.0f
1117	// abs(phi) <= fov * aspectRatio / 2.0f
1118	float yaw = -fov * aspectRatio * (slicesRatio - 0.5f);
1119
1120	vertexPtr->position = getPoint(yaw, pitch);
1121	vertexPtr->uv.x = slicesRatio;
1122	vertexPtr->uv.y = stacksRatio;
1123	vertexPtr++;
1124	}
1125	}
1126	// Create and write to buffer
1127	glGenBuffers(1, &_vbo.first);
1128	glBindBuffer(GL_ARRAY_BUFFER, _vbo.first);
1129	static const int BYTES_PER_VERTEX = sizeof(TextureVertex);
1130	glBufferData(GL_ARRAY_BUFFER, _vertices * BYTES_PER_VERTEX, vertexData, GL_STATIC_DRAW);
1131	delete[] vertexData;
1132
1133
1134	// Compute number of indices needed
1135	static const int VERTEX_PER_TRANGLE = 3;
1136	static const int TRIANGLE_PER_RECTANGLE = 2;
1137	int numberOfRectangles = (slices - 1) * (stacks - 1);
1138	_indices = numberOfRectangles * TRIANGLE_PER_RECTANGLE * VERTEX_PER_TRANGLE;
1139
1140	// Compute indices order
1141	GLushort* indexData = new GLushort[_indices];
1142	GLushort* indexPtr = indexData;
1143	for (int i = 0; i < stacks - 1; i++) {
1144	for (int j = 0; j < slices - 1; j++) {
1145	GLushort bottomLeftIndex = i * slices + j;
1146	GLushort bottomRightIndex = bottomLeftIndex + 1;
1147	GLushort topLeftIndex = bottomLeftIndex + slices;
1148	GLushort topRightIndex = topLeftIndex + 1;
1149
1150	*(indexPtr++) = topLeftIndex;
1151	*(indexPtr++) = bottomLeftIndex;
1152	*(indexPtr++) = topRightIndex;
1153
1154	*(indexPtr++) = topRightIndex;
1155	*(indexPtr++) = bottomLeftIndex;
1156	*(indexPtr++) = bottomRightIndex;
1157	}
1158	}	214	}
1159	// Create and write to buffer
1160	glGenBuffers(1, &_vbo.second);
1161	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbo.second);
1162	static const int BYTES_PER_INDEX = sizeof(GLushort);
1163	glBufferData(GL_ELEMENT_ARRAY_BUFFER, _indices * BYTES_PER_INDEX, indexData, GL_STATIC_DRAW);
1164	delete[] indexData;
1165	}	215	}
1166		216
1167	void ApplicationOverlay::TexturedHemisphere::cleanupVBO() {	217	GLuint ApplicationOverlay::getOverlayTexture() {
1168	if (_vbo.first != 0) {	218	if (!_overlayFramebuffer) {
1169	glDeleteBuffers(1, &_vbo.first);	219	return 0;
1170	_vbo.first = 0;
1171	}
1172	if (_vbo.second != 0) {
1173	glDeleteBuffers(1, &_vbo.second);
1174	_vbo.second = 0;
1175	}	220	}
		221	return _overlayFramebuffer->texture();
1176	}	222	}
1177		223
1178	void ApplicationOverlay::TexturedHemisphere::buildFramebufferObject() {	224	void ApplicationOverlay::buildFramebufferObject() {
1179	auto canvasSize = qApp->getCanvasSize();	225	QSize fboSize = qApp->getDeviceSize();
1180	QSize fboSize = QSize(canvasSize.x, canvasSize.y);	226	if (_overlayFramebuffer && fboSize == _overlayFramebuffer->size()) {
1181	if (_framebufferObject != NULL && fboSize == _framebufferObject->size()) {	227	// Already built
1182	// Already build
1183	return;	228	return;
1184	}	229	}
1185		230
1186	if (_framebufferObject != NULL) {	231	if (_overlayFramebuffer) {
1187	delete _framebufferObject;	232	delete _overlayFramebuffer;
1188	}	233	}
1189		234
1190	_framebufferObject = new QOpenGLFramebufferObject(fboSize, QOpenGLFramebufferObject::Depth);	235	_overlayFramebuffer = new QOpenGLFramebufferObject(fboSize, QOpenGLFramebufferObject::Depth);
1191	glBindTexture(GL_TEXTURE_2D, getTexture());	236	glBindTexture(GL_TEXTURE_2D, getOverlayTexture());
1192	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);	237	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1193	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	238	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1194	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);	239	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
@@ -1197,104 +242,3 @@ void ApplicationOverlay::TexturedHemisphere::buildFramebufferObject() { · 2 unmodified lines
1197	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);	242	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
1198	glBindTexture(GL_TEXTURE_2D, 0);	243	glBindTexture(GL_TEXTURE_2D, 0);
1199	}	244	}
1200
1201	//Renders a hemisphere with texture coordinates.
1202	void ApplicationOverlay::TexturedHemisphere::render() {
1203	if (_framebufferObject == NULL \|\| _vbo.first == 0 \|\| _vbo.second == 0) {
1204	qDebug() << "TexturedHemisphere::render(): Incorrect initialisation";
1205	return;
1206	}
1207
1208	glBindBuffer(GL_ARRAY_BUFFER, _vbo.first);
1209	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbo.second);
1210
1211	glEnableClientState(GL_VERTEX_ARRAY);
1212	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1213
1214	static const int STRIDE = sizeof(TextureVertex);
1215	static const void* VERTEX_POINTER = 0;
1216	static const void* TEX_COORD_POINTER = (void*)sizeof(glm::vec3);
1217	glVertexPointer(3, GL_FLOAT, STRIDE, VERTEX_POINTER);
1218	glTexCoordPointer(2, GL_FLOAT, STRIDE, TEX_COORD_POINTER);
1219
1220	glDrawRangeElements(GL_TRIANGLES, 0, _vertices - 1, _indices, GL_UNSIGNED_SHORT, 0);
1221
1222	glDisableClientState(GL_VERTEX_ARRAY);
1223	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1224
1225	glBindBuffer(GL_ARRAY_BUFFER, 0);
1226	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1227	}
1228
1229	GLuint ApplicationOverlay::TexturedHemisphere::getTexture() {
1230	return _framebufferObject->texture();
1231	}
1232
1233	glm::vec2 ApplicationOverlay::directionToSpherical(const glm::vec3& direction) {
1234	glm::vec2 result;
1235	// Compute yaw
1236	glm::vec3 normalProjection = glm::normalize(glm::vec3(direction.x, 0.0f, direction.z));
1237	result.x = glm::acos(glm::dot(IDENTITY_FRONT, normalProjection));
1238	if (glm::dot(IDENTITY_RIGHT, normalProjection) > 0.0f) {
1239	result.x = -glm::abs(result.x);
1240	} else {
1241	result.x = glm::abs(result.x);
1242	}
1243	// Compute pitch
1244	result.y = angleBetween(IDENTITY_UP, direction) - PI_OVER_TWO;
1245
1246	return result;
1247	}
1248
1249	glm::vec3 ApplicationOverlay::sphericalToDirection(const glm::vec2& sphericalPos) {
1250	glm::quat rotation(glm::vec3(sphericalPos.y, sphericalPos.x, 0.0f));
1251	return rotation * IDENTITY_FRONT;
1252	}
1253
1254	glm::vec2 ApplicationOverlay::screenToSpherical(const glm::vec2& screenPos) {
1255	auto screenSize = qApp->getCanvasSize();
1256	glm::vec2 result;
1257	result.x = -(screenPos.x / screenSize.x - 0.5f);
1258	result.y = (screenPos.y / screenSize.y - 0.5f);
1259	result.x *= MOUSE_YAW_RANGE;
1260	result.y *= MOUSE_PITCH_RANGE;
1261
1262	return result;
1263	}
1264
1265	glm::vec2 ApplicationOverlay::sphericalToScreen(const glm::vec2& sphericalPos) {
1266	glm::vec2 result = sphericalPos;
1267	result.x *= -1.0;
1268	result /= MOUSE_RANGE;
1269	result += 0.5f;
1270	result *= qApp->getCanvasSize();
1271	return result;
1272	}
1273
1274	glm::vec2 ApplicationOverlay::sphericalToOverlay(const glm::vec2& sphericalPos) const {
1275	glm::vec2 result = sphericalPos;
1276	result.x *= -1.0;
1277	result /= _textureFov;
1278	result.x /= _textureAspectRatio;
1279	result += 0.5f;
1280	result *= qApp->getCanvasSize();
1281	return result;
1282	}
1283
1284	glm::vec2 ApplicationOverlay::overlayToSpherical(const glm::vec2& overlayPos) const {
1285	glm::vec2 result = overlayPos;
1286	result /= qApp->getCanvasSize();
1287	result -= 0.5f;
1288	result *= _textureFov;
1289	result.x *= _textureAspectRatio;
1290	result.x *= -1.0f;
1291	return result;
1292	}
1293
1294	glm::vec2 ApplicationOverlay::screenToOverlay(const glm::vec2& screenPos) const {
1295	return sphericalToOverlay(screenToSpherical(screenPos));
1296	}
1297
1298	glm::vec2 ApplicationOverlay::overlayToScreen(const glm::vec2& overlayPos) const {
1299	return sphericalToScreen(overlayToSpherical(overlayPos));
1300	}

interface/src/ui/ApplicationOverlay.h+14−118

@@ -13,16 +13,8 @@ · 12 unmodified lines
13	#define hifi_ApplicationOverlay_h	13	#define hifi_ApplicationOverlay_h
14		14
15	#include <gpu/Texture.h>	15	#include <gpu/Texture.h>
16	class Camera;
17	class Overlays;
18	class QOpenGLFramebufferObject;	16	class QOpenGLFramebufferObject;
19		17
20	const float MAGNIFY_WIDTH = 220.0f;
21	const float MAGNIFY_HEIGHT = 100.0f;
22	const float MAGNIFY_MULT = 2.0f;
23
24	const float DEFAULT_HMD_UI_ANGULAR_SIZE = 72.0f;
25
26	// Handles the drawing of the overlays to the screen	18	// Handles the drawing of the overlays to the screen
27	// TODO, move divide up the rendering, displaying and input handling	19	// TODO, move divide up the rendering, displaying and input handling
28	// facilities of this class	20	// facilities of this class
@@ -33,122 +25,26 @@ public: · 4 unmodified lines
33	~ApplicationOverlay();	25	~ApplicationOverlay();
34		26
35	void renderOverlay(RenderArgs* renderArgs);	27	void renderOverlay(RenderArgs* renderArgs);
36	void displayOverlayTexture();	28	GLuint getOverlayTexture();
37	void displayOverlayTextureStereo(Camera& whichCamera, float aspectRatio, float fov);
38	void displayOverlayTextureHmd(Camera& whichCamera);
39
40	QPoint getPalmClickLocation(const PalmData *palm) const;
41	bool calculateRayUICollisionPoint(const glm::vec3& position, const glm::vec3& direction, glm::vec3& result) const;
42
43	bool hasMagnifier() const { return _magnifier; }
44	void toggleMagnifier() { _magnifier = !_magnifier; }
45		29
46	float getHmdUIAngularSize() const { return _hmdUIAngularSize; }
47	void setHmdUIAngularSize(float hmdUIAngularSize) { _hmdUIAngularSize = hmdUIAngularSize; }
48
49	// Converter from one frame of reference to another.
50	// Frame of reference:
51	// Direction: Ray that represents the spherical values
52	// Screen: Position on the screen (x,y)
53	// Spherical: Pitch and yaw that gives the position on the sphere we project on (yaw,pitch)
54	// Overlay: Position on the overlay (x,y)
55	// (x,y) in Overlay are similar than (x,y) in Screen except they can be outside of the bound of te screen.
56	// This allows for picking outside of the screen projection in 3D.
57	glm::vec2 sphericalToOverlay(const glm::vec2 & sphericalPos) const;
58	glm::vec2 overlayToSpherical(const glm::vec2 & overlayPos) const;
59	glm::vec2 screenToOverlay(const glm::vec2 & screenPos) const;
60	glm::vec2 overlayToScreen(const glm::vec2 & overlayPos) const;
61	void computeHmdPickRay(glm::vec2 cursorPos, glm::vec3& origin, glm::vec3& direction) const;
62
63	static glm::vec2 directionToSpherical(const glm::vec3 & direction);
64	static glm::vec3 sphericalToDirection(const glm::vec2 & sphericalPos);
65	static glm::vec2 screenToSpherical(const glm::vec2 & screenPos);
66	static glm::vec2 sphericalToScreen(const glm::vec2 & sphericalPos);
67
68	private:	30	private:
69	// Interleaved vertex data	31	void renderStatsAndLogs(RenderArgs* renderArgs);
70	struct TextureVertex {	32	void renderDomainConnectionStatusBorder(RenderArgs* renderArgs);
71	glm::vec3 position;	33	void renderRearViewToFbo(RenderArgs* renderArgs);
72	glm::vec2 uv;	34	void renderRearView(RenderArgs* renderArgs);
73	};	35	void renderQmlUi(RenderArgs* renderArgs);
74		36	void renderOverlays(RenderArgs* renderArgs);
75	typedef QPair<GLuint, GLuint> VerticesIndices;	37	void buildFramebufferObject();
76	class TexturedHemisphere {	38
77	public:	39	float _alpha{ 1.0f };
78	TexturedHemisphere();	40	float _trailingAudioLoudness{ 0.0f };
79	~TexturedHemisphere();	41	GLuint _uiTexture{ 0 };
80
81	void bind();
82	void release();
83	GLuint getTexture();
84
85	void buildFramebufferObject();
86	void buildVBO(const float fov, const float aspectRatio, const int slices, const int stacks);
87	void render();
88
89	private:
90	void cleanupVBO();
91
92	GLuint _vertices;
93	GLuint _indices;
94	QOpenGLFramebufferObject* _framebufferObject;
95	VerticesIndices _vbo;
96	};
97
98	float _hmdUIAngularSize = DEFAULT_HMD_UI_ANGULAR_SIZE;
99	void renderReticle(glm::quat orientation, float alpha);
100	void renderPointers();;
101	void renderMagnifier(glm::vec2 magPos, float sizeMult, bool showBorder);
102
103	void renderControllerPointers();
104	void renderPointersOculus();
105
106	void renderAudioMeter();
107	void renderCameraToggle();
108	void renderStatsAndLogs();
109	void renderDomainConnectionStatusBorder();
110	void bindCursorTexture(gpu::Batch& batch, uint8_t cursorId = 0);
111		42
112	TexturedHemisphere _overlays;
113
114	float _textureFov;
115	float _textureAspectRatio;
116
117	enum Reticles { MOUSE, LEFT_CONTROLLER, RIGHT_CONTROLLER, NUMBER_OF_RETICLES };
118	bool _reticleActive[NUMBER_OF_RETICLES];
119	QPoint _reticlePosition[NUMBER_OF_RETICLES];
120	bool _magActive[NUMBER_OF_RETICLES];
121	float _magSizeMult[NUMBER_OF_RETICLES];
122	quint64 _lastMouseMove;
123	bool _magnifier;
124
125	float _alpha = 1.0f;
126	float _oculusUIRadius;
127	float _trailingAudioLoudness;
128
129	gpu::TexturePointer _crosshairTexture;
130
131
132	QMap<uint16_t, gpu::TexturePointer> _cursors;
133
134	GLuint _newUiTexture{ 0 };
135
136	int _reticleQuad;
137	int _magnifierQuad;
138	int _audioRedQuad;
139	int _audioGreenQuad;
140	int _audioBlueQuad;
141	int _domainStatusBorder;	43	int _domainStatusBorder;
142	int _magnifierBorder;	44	int _magnifierBorder;
143		45
144	int _previousBorderWidth;	46	ivec2 _previousBorderSize{ -1 };
145	int _previousBorderHeight;	47	QOpenGLFramebufferObject* _overlayFramebuffer{ nullptr };
146
147	glm::vec3 _previousMagnifierBottomLeft;
148	glm::vec3 _previousMagnifierBottomRight;
149	glm::vec3 _previousMagnifierTopLeft;
150	glm::vec3 _previousMagnifierTopRight;
151
152	};	48	};
153		49
154	#endif // hifi_ApplicationOverlay_h	50	#endif // hifi_ApplicationOverlay_h

interface/src/ui/AvatarInputs.cpp+134−0

@@ -0,0 +1,134 @@
	1	//
	2	// Created by Bradley Austin Davis 2015/06/19
	3	// Copyright 2013 High Fidelity, Inc.
	4	//
	5	// Distributed under the Apache License, Version 2.0.
	6	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	7	//
	8
	9
	10	#include "Application.h"
	11	#include "AvatarInputs.h"
	12
	13	#include <SettingHandle.h>
	14
	15	#include "Menu.h"
	16	#include "devices/FaceTracker.h"
	17
	18	HIFI_QML_DEF(AvatarInputs)
	19
	20
	21	static AvatarInputs* INSTANCE{ nullptr };
	22	static const char SETTINGS_GROUP_NAME[] = "Rear View Tools";
	23	static const char ZOOM_LEVEL_SETTINGS[] = "ZoomLevel";
	24
	25	static Setting::Handle<int> rearViewZoomLevel(QStringList() << SETTINGS_GROUP_NAME << ZOOM_LEVEL_SETTINGS, 0);
	26
	27	AvatarInputs* AvatarInputs::getInstance() {
	28	if (!INSTANCE) {
	29	AvatarInputs::registerType();
	30	AvatarInputs::show();
	31	Q_ASSERT(INSTANCE);
	32	}
	33	return INSTANCE;
	34	}
	35
	36	AvatarInputs::AvatarInputs(QQuickItem* parent) : QQuickItem(parent) {
	37	INSTANCE = this;
	38	int zoomSetting = rearViewZoomLevel.get();
	39	_mirrorZoomed = zoomSetting == 0;
	40	}
	41
	42	#define AI_UPDATE(name, src) \
	43	{ \
	44	auto val = src; \
	45	if (_##name != val) { \
	46	_##name = val; \
	47	emit name##Changed(); \
	48	} \
	49	}
	50
	51	#define AI_UPDATE_FLOAT(name, src, epsilon) \
	52	{ \
	53	float val = src; \
	54	if (fabs(_##name - val) >= epsilon) { \
	55	_##name = val; \
	56	emit name##Changed(); \
	57	} \
	58	}
	59
	60	void AvatarInputs::update() {
	61	if (!Menu::getInstance()) {
	62	return;
	63	}
	64	AI_UPDATE(mirrorVisible, Menu::getInstance()->isOptionChecked(MenuOption::Mirror) && !qApp->isHMDMode()
	65	&& !Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror));
	66	AI_UPDATE(cameraEnabled, !Menu::getInstance()->isOptionChecked(MenuOption::NoFaceTracking));
	67	AI_UPDATE(cameraMuted, Menu::getInstance()->isOptionChecked(MenuOption::MuteFaceTracking));
	68
	69	auto audioIO = DependencyManager::get<AudioClient>();
	70	const float CLIPPING_INDICATOR_TIME = 1.0f;
	71	const float AUDIO_METER_AVERAGING = 0.5;
	72	const float LOG2 = log(2.0f);
	73	const float METER_LOUDNESS_SCALE = 2.8f / 5.0f;
	74	const float LOG2_LOUDNESS_FLOOR = 11.0f;
	75	float audioLevel = 0.0f;
	76	auto audio = DependencyManager::get<AudioClient>();
	77	float loudness = audio->getLastInputLoudness() + 1.0f;
	78
	79	_trailingAudioLoudness = AUDIO_METER_AVERAGING * _trailingAudioLoudness + (1.0f - AUDIO_METER_AVERAGING) * loudness;
	80
	81	float log2loudness = logf(_trailingAudioLoudness) / LOG2;
	82
	83	if (log2loudness <= LOG2_LOUDNESS_FLOOR) {
	84	audioLevel = (log2loudness / LOG2_LOUDNESS_FLOOR) * METER_LOUDNESS_SCALE;
	85	} else {
	86	audioLevel = (log2loudness - (LOG2_LOUDNESS_FLOOR - 1.0f)) * METER_LOUDNESS_SCALE;
	87	}
	88	if (audioLevel > 1.0) {
	89	audioLevel = 1.0;
	90	}
	91	AI_UPDATE_FLOAT(audioLevel, audioLevel, 0.01);
	92	AI_UPDATE(audioClipping, ((audioIO->getTimeSinceLastClip() > 0.0f) && (audioIO->getTimeSinceLastClip() < 1.0f)));
	93	AI_UPDATE(audioMuted, audioIO->isMuted());
	94
	95	//// Make muted icon pulsate
	96	//static const float PULSE_MIN = 0.4f;
	97	//static const float PULSE_MAX = 1.0f;
	98	//static const float PULSE_FREQUENCY = 1.0f; // in Hz
	99	//qint64 now = usecTimestampNow();
	100	//if (now - _iconPulseTimeReference > (qint64)USECS_PER_SECOND) {
	101	// // Prevents t from getting too big, which would diminish glm::cos precision
	102	// _iconPulseTimeReference = now - ((now - _iconPulseTimeReference) % USECS_PER_SECOND);
	103	//}
	104	//float t = (float)(now - _iconPulseTimeReference) / (float)USECS_PER_SECOND;
	105	//float pulseFactor = (glm::cos(t * PULSE_FREQUENCY * 2.0f * PI) + 1.0f) / 2.0f;
	106	//iconColor = PULSE_MIN + (PULSE_MAX - PULSE_MIN) * pulseFactor;
	107	}
	108
	109	void AvatarInputs::toggleCameraMute() {
	110	FaceTracker* faceTracker = Application::getInstance()->getSelectedFaceTracker();
	111	if (faceTracker) {
	112	faceTracker->toggleMute();
	113	}
	114	}
	115
	116	void AvatarInputs::toggleAudioMute() {
	117	DependencyManager::get<AudioClient>()->toggleMute();
	118	}
	119
	120	void AvatarInputs::resetSensors() {
	121	qApp->resetSensors();
	122	}
	123
	124	void AvatarInputs::toggleZoom() {
	125	_mirrorZoomed = !_mirrorZoomed;
	126	rearViewZoomLevel.set(_mirrorZoomed ? 0 : 1);
	127	emit mirrorZoomedChanged();
	128	}
	129
	130	void AvatarInputs::closeMirror() {
	131	if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
	132	Menu::getInstance()->triggerOption(MenuOption::Mirror);
	133	}
	134	}

interface/src/ui/AvatarInputs.h+59−0

@@ -0,0 +1,59 @@
	1	//
	2	// Created by Bradley Austin Davis 2015/06/19
	3	// Copyright 2013 High Fidelity, Inc.
	4	//
	5	// Distributed under the Apache License, Version 2.0.
	6	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	7	//
	8
	9	#ifndef hifi_AvatarInputs_h
	10	#define hifi_AvatarInputs_h
	11
	12	#include <QQuickItem>
	13	#include <OffscreenUi.h>
	14
	15	#define AI_PROPERTY(type, name, initialValue) \
	16	Q_PROPERTY(type name READ name NOTIFY name##Changed) \
	17	public: \
	18	type name() { return _##name; }; \
	19	private: \
	20	type _##name{ initialValue };
	21
	22	class AvatarInputs : public QQuickItem {
	23	Q_OBJECT
	24	HIFI_QML_DECL
	25
	26	AI_PROPERTY(bool, cameraEnabled, false)
	27	AI_PROPERTY(bool, cameraMuted, false)
	28	AI_PROPERTY(bool, audioMuted, false)
	29	AI_PROPERTY(bool, audioClipping, false)
	30	AI_PROPERTY(float, audioLevel, 0)
	31	AI_PROPERTY(bool, mirrorVisible, false)
	32	AI_PROPERTY(bool, mirrorZoomed, true)
	33
	34	public:
	35	static AvatarInputs* getInstance();
	36	AvatarInputs(QQuickItem* parent = nullptr);
	37	void update();
	38
	39	signals:
	40	void cameraEnabledChanged();
	41	void cameraMutedChanged();
	42	void audioMutedChanged();
	43	void audioClippingChanged();
	44	void audioLevelChanged();
	45	void mirrorVisibleChanged();
	46	void mirrorZoomedChanged();
	47
	48	protected:
	49	Q_INVOKABLE void resetSensors();
	50	Q_INVOKABLE void toggleCameraMute();
	51	Q_INVOKABLE void toggleAudioMute();
	52	Q_INVOKABLE void toggleZoom();
	53	Q_INVOKABLE void closeMirror();
	54
	55	private:
	56	float _trailingAudioLoudness{ 0 };
	57	};
	58
	59	#endif // hifi_AvatarInputs_h

interface/src/ui/FlowLayout.cpp+9−0

@@ -38,8 +38,17 @@ · 37 unmodified lines
38	**	38	**
39	****************************************************************************/	39	****************************************************************************/
40		40
		41	#ifdef __GNUC__
		42	#pragma GCC diagnostic push
		43	#pragma GCC diagnostic ignored "-Wdouble-promotion"
		44	#endif
		45
41	#include <QtWidgets>	46	#include <QtWidgets>
42		47
		48	#ifdef __GNUC__
		49	#pragma GCC diagnostic pop
		50	#endif
		51
43	#include "FlowLayout.h"	52	#include "FlowLayout.h"
44	//! [1]	53	//! [1]
45	FlowLayout::FlowLayout(QWidget *parent, int margin, int hSpacing, int vSpacing)	54	FlowLayout::FlowLayout(QWidget *parent, int margin, int hSpacing, int vSpacing)

interface/src/ui/HMDToolsDialog.cpp+4−59

@@ -56,8 +56,6 @@ HMDToolsDialog::HMDToolsDialog(QWidget* parent) : · 55 unmodified lines
56		56
57	this->QDialog::setLayout(form);	57	this->QDialog::setLayout(form);
58		58
59	_wasMoved = false;
60	_previousRect = Application::getInstance()->getWindow()->rect();
61	Application::getInstance()->getWindow()->activateWindow();	59	Application::getInstance()->getWindow()->activateWindow();
62		60
63	// watch for our application window moving screens. If it does we want to update our screen details	61	// watch for our application window moving screens. If it does we want to update our screen details
@@ -136,24 +134,6 @@ void HMDToolsDialog::enterHDMMode() { · 72 unmodified lines
136	if (!_inHDMMode) {	134	if (!_inHDMMode) {
137	_switchModeButton->setText("Leave HMD Mode");	135	_switchModeButton->setText("Leave HMD Mode");
138	_debugDetails->setText(getDebugDetails());	136	_debugDetails->setText(getDebugDetails());
139
140	_hmdScreenNumber = OculusManager::getHMDScreen();
141
142	if (_hmdScreenNumber >= 0) {
143	QWindow* mainWindow = Application::getInstance()->getWindow()->windowHandle();
144	_hmdScreen = QGuiApplication::screens()[_hmdScreenNumber];
145
146	_previousRect = Application::getInstance()->getWindow()->rect();
147	_previousRect = QRect(mainWindow->mapToGlobal(_previousRect.topLeft()),
148	mainWindow->mapToGlobal(_previousRect.bottomRight()));
149	_previousScreen = mainWindow->screen();
150	QRect rect = QApplication::desktop()->screenGeometry(_hmdScreenNumber);
151	mainWindow->setScreen(_hmdScreen);
152	mainWindow->setGeometry(rect);
153
154	_wasMoved = true;
155	}
156
157		137
158	// if we're on a single screen setup, then hide our tools window when entering HMD mode	138	// if we're on a single screen setup, then hide our tools window when entering HMD mode
159	if (QApplication::desktop()->screenCount() == 1) {	139	if (QApplication::desktop()->screenCount() == 1) {
@@ -161,58 +141,21 @@ void HMDToolsDialog::enterHDMMode() { · 1 unmodified line
161	}	141	}
162		142
163	Application::getInstance()->setEnableVRMode(true);	143	Application::getInstance()->setEnableVRMode(true);
164		144
165	const int SLIGHT_DELAY = 500;
166	// If we go to fullscreen immediately, it ends up on the primary monitor,
167	// even though we've already moved the window. By adding this delay, the
168	// fullscreen target screen ends up correct.
169	QTimer::singleShot(SLIGHT_DELAY, this, [&]{
170	Application::getInstance()->setFullscreen(true);
171	activateWindowAfterEnterMode();
172	});
173
174	_inHDMMode = true;	145	_inHDMMode = true;
175	}	146	}
176	}	147	}
177		148
178	void HMDToolsDialog::activateWindowAfterEnterMode() {
179	Application::getInstance()->getWindow()->activateWindow();
180
181	// center the cursor on the main application window
182	centerCursorOnWidget(Application::getInstance()->getWindow());
183	}
184
185	void HMDToolsDialog::leaveHDMMode() {	149	void HMDToolsDialog::leaveHDMMode() {
186	if (_inHDMMode) {	150	if (_inHDMMode) {
187	_switchModeButton->setText("Enter HMD Mode");	151	_switchModeButton->setText("Enter HMD Mode");
188	_debugDetails->setText(getDebugDetails());	152	_debugDetails->setText(getDebugDetails());
189
190	Application::getInstance()->setEnableVRMode(false);	153	Application::getInstance()->setEnableVRMode(false);
191	Application::getInstance()->setFullscreen(false);
192	Application::getInstance()->getWindow()->activateWindow();	154	Application::getInstance()->getWindow()->activateWindow();
193
194	if (_wasMoved) {
195	QWindow* mainWindow = Application::getInstance()->getWindow()->windowHandle();
196	mainWindow->setScreen(_previousScreen);
197	mainWindow->setGeometry(_previousRect);
198
199	const int SLIGHT_DELAY = 1500;
200	QTimer::singleShot(SLIGHT_DELAY, this, SLOT(moveWindowAfterLeaveMode()));
201	}
202	_wasMoved = false;
203	_inHDMMode = false;	155	_inHDMMode = false;
204	}	156	}
205	}	157	}
206		158
207	void HMDToolsDialog::moveWindowAfterLeaveMode() {
208	QWindow* mainWindow = Application::getInstance()->getWindow()->windowHandle();
209	mainWindow->setScreen(_previousScreen);
210	mainWindow->setGeometry(_previousRect);
211	Application::getInstance()->getWindow()->activateWindow();
212	Application::getInstance()->resetSensors();
213	}
214
215
216	void HMDToolsDialog::reject() {	159	void HMDToolsDialog::reject() {
217	// Just regularly close upon ESC	160	// Just regularly close upon ESC
218	close();	161	close();
@@ -244,13 +187,15 @@ void HMDToolsDialog::hideEvent(QHideEvent* event) { · 25 unmodified lines
244		187
245	void HMDToolsDialog::aboutToQuit() {	188	void HMDToolsDialog::aboutToQuit() {
246	if (_inHDMMode) {	189	if (_inHDMMode) {
		190	// FIXME this is ineffective because it doesn't trigger the menu to
		191	// save the fact that VR Mode is not checked.
247	leaveHDMMode();	192	leaveHDMMode();
248	}	193	}
249	}	194	}
250		195
251	void HMDToolsDialog::screenCountChanged(int newCount) {	196	void HMDToolsDialog::screenCountChanged(int newCount) {
252	if (!OculusManager::isConnected()) {	197	if (!OculusManager::isConnected()) {
253	OculusManager::connect();	198	//OculusManager::connect();
254	}	199	}
255	int hmdScreenNumber = OculusManager::getHMDScreen();	200	int hmdScreenNumber = OculusManager::getHMDScreen();
256		201

interface/src/ui/HMDToolsDialog.h+0−4

 public slots:
     void reject();
     void switchModeClicked(bool checked);
-    void activateWindowAfterEnterMode();
-    void moveWindowAfterLeaveMode();
     void applicationWindowScreenChanged(QScreen* screen);
     void aboutToQuit();
     void screenCountChanged(int newCount);
     void enterHDMMode();
     void leaveHDMMode();
-    bool _wasMoved;
-    QRect _previousRect;
     QScreen* _previousScreen;
     QScreen* _hmdScreen;
     int _hmdScreenNumber;

interface/src/ui/LogDialog.cpp+9−0

 #include "InterfaceConfig.h"
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdouble-promotion"
+#endif
 #include <QDesktopWidget>
 #include <QTextBlock>
 #include <QtGui>
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 #include <PathUtils.h>
 #include <SharedUtil.h>

interface/src/ui/PreferencesDialog.cpp+2−2

@@ -175,7 +175,7 @@ void PreferencesDialog::loadPreferences() { · 174 unmodified lines
175		175
176	ui.maxOctreePPSSpin->setValue(qApp->getMaxOctreePacketsPerSecond());	176	ui.maxOctreePPSSpin->setValue(qApp->getMaxOctreePacketsPerSecond());
177		177
178	ui.oculusUIAngularSizeSpin->setValue(qApp->getApplicationOverlay().getHmdUIAngularSize());	178	ui.oculusUIAngularSizeSpin->setValue(qApp->getApplicationCompositor().getHmdUIAngularSize());
179		179
180	SixenseManager& sixense = SixenseManager::getInstance();	180	SixenseManager& sixense = SixenseManager::getInstance();
181	ui.sixenseReticleMoveSpeedSpin->setValue(sixense.getReticleMoveSpeed());	181	ui.sixenseReticleMoveSpeedSpin->setValue(sixense.getReticleMoveSpeed());
@@ -239,7 +239,7 @@ void PreferencesDialog::savePreferences() { · 57 unmodified lines
239		239
240	qApp->setMaxOctreePacketsPerSecond(ui.maxOctreePPSSpin->value());	240	qApp->setMaxOctreePacketsPerSecond(ui.maxOctreePPSSpin->value());
241		241
242	qApp->getApplicationOverlay().setHmdUIAngularSize(ui.oculusUIAngularSizeSpin->value());	242	qApp->getApplicationCompositor().setHmdUIAngularSize(ui.oculusUIAngularSizeSpin->value());
243		243
244	SixenseManager& sixense = SixenseManager::getInstance();	244	SixenseManager& sixense = SixenseManager::getInstance();
245	sixense.setReticleMoveSpeed(ui.sixenseReticleMoveSpeedSpin->value());	245	sixense.setReticleMoveSpeed(ui.sixenseReticleMoveSpeedSpin->value());

interface/src/ui/RearMirrorTools.cpp+0−134

@@ -1,134 +0,0 @@
1	//
2	// RearMirrorTools.cpp
3	// interface/src/ui
4	//
5	// Created by Stojce Slavkovski on 10/23/2013.
6	// Copyright 2013 High Fidelity, Inc.
7	//
8	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//
11
12	#include "InterfaceConfig.h"
13
14	#include <QMouseEvent>
15
16	#include <PathUtils.h>
17	#include <SharedUtil.h>
18	#include <gpu/GLBackend.h>
19
20	#include "Application.h"
21	#include "RearMirrorTools.h"
22	#include "Util.h"
23
24	const int ICON_SIZE = 24;
25	const int ICON_PADDING = 5;
26
27	const char SETTINGS_GROUP_NAME[] = "Rear View Tools";
28	const char ZOOM_LEVEL_SETTINGS[] = "ZoomLevel";
29	Setting::Handle<int> RearMirrorTools::rearViewZoomLevel(QStringList() << SETTINGS_GROUP_NAME << ZOOM_LEVEL_SETTINGS,
30	ZoomLevel::HEAD);
31
32	RearMirrorTools::RearMirrorTools(QRect& bounds) :
33	_bounds(bounds),
34	_windowed(false),
35	_fullScreen(false)
36	{
37	_closeTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/close.svg");
38
39	_zoomHeadTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/plus.svg");
40	_zoomBodyTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/minus.svg");
41
42	_shrinkIconRect = QRect(ICON_PADDING, ICON_PADDING, ICON_SIZE, ICON_SIZE);
43	_closeIconRect = QRect(_bounds.left() + ICON_PADDING, _bounds.top() + ICON_PADDING, ICON_SIZE, ICON_SIZE);
44	_resetIconRect = QRect(_bounds.width() - ICON_SIZE - ICON_PADDING, _bounds.top() + ICON_PADDING, ICON_SIZE, ICON_SIZE);
45	_bodyZoomIconRect = QRect(_bounds.width() - ICON_SIZE - ICON_PADDING, _bounds.bottom() - ICON_PADDING - ICON_SIZE, ICON_SIZE, ICON_SIZE);
46	_headZoomIconRect = QRect(_bounds.left() + ICON_PADDING, _bounds.bottom() - ICON_PADDING - ICON_SIZE, ICON_SIZE, ICON_SIZE);
47	}
48
49	void RearMirrorTools::render(RenderArgs* renderArgs, bool fullScreen, const QPoint & mousePosition) {
50	if (fullScreen) {
51	_fullScreen = true;
52	displayIcon(QRect(QPoint(), qApp->getDeviceSize()), _shrinkIconRect, _closeTexture);
53	} else {
54	// render rear view tools if mouse is in the bounds
55	_windowed = _bounds.contains(mousePosition);
56	if (_windowed) {
57	displayIcon(_bounds, _closeIconRect, _closeTexture);
58
59	ZoomLevel zoomLevel = (ZoomLevel)rearViewZoomLevel.get();
60	displayIcon(_bounds, _headZoomIconRect, _zoomHeadTexture, zoomLevel == HEAD);
61	displayIcon(_bounds, _bodyZoomIconRect, _zoomBodyTexture, zoomLevel == BODY);
62	}
63	}
64	}
65
66	bool RearMirrorTools::mousePressEvent(int x, int y) {
67	if (_windowed) {
68	if (_closeIconRect.contains(x, y)) {
69	_windowed = false;
70	emit closeView();
71	return true;
72	}
73
74	if (_headZoomIconRect.contains(x, y)) {
75	rearViewZoomLevel.set(HEAD);
76	return true;
77	}
78
79	if (_bodyZoomIconRect.contains(x, y)) {
80	rearViewZoomLevel.set(BODY);
81	return true;
82	}
83
84	if (_bounds.contains(x, y)) {
85	_windowed = false;
86	emit restoreView();
87	return true;
88	}
89	}
90
91	if (_fullScreen) {
92	if (_shrinkIconRect.contains(x, y)) {
93	_fullScreen = false;
94	emit shrinkView();
95	return true;
96	}
97	}
98	return false;
99	}
100
101	void RearMirrorTools::displayIcon(QRect bounds, QRect iconBounds, const gpu::TexturePointer& texture, bool selected) {
102
103	glMatrixMode(GL_PROJECTION);
104	glPushMatrix();
105	glLoadIdentity();
106
107	glOrtho(bounds.left(), bounds.right(), bounds.bottom(), bounds.top(), -1.0, 1.0);
108	glDisable(GL_DEPTH_TEST);
109	glDisable(GL_LIGHTING);
110	glEnable(GL_TEXTURE_2D);
111
112	glm::vec4 quadColor;
113	if (selected) {
114	quadColor = glm::vec4(.5f, .5f, .5f, 1.0f);
115	} else {
116	quadColor = glm::vec4(1, 1, 1, 1);
117	}
118
119	glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(texture));
120
121	glm::vec2 topLeft(iconBounds.left(), iconBounds.top());
122	glm::vec2 bottomRight(iconBounds.right(), iconBounds.bottom());
123	static const glm::vec2 texCoordTopLeft(0.0f, 1.0f);
124	static const glm::vec2 texCoordBottomRight(1.0f, 0.0f);
125
126	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, quadColor);
127
128	glPopMatrix();
129
130	glMatrixMode(GL_MODELVIEW);
131
132	glBindTexture(GL_TEXTURE_2D, 0);
133	glDisable(GL_TEXTURE_2D);
134	}

interface/src/ui/RearMirrorTools.h+0−56

@@ -1,56 +0,0 @@
1	//
2	// RearMirrorTools.h
3	// interface/src/ui
4	//
5	// Created by Stojce Slavkovski on 10/23/2013.
6	// Copyright 2013 High Fidelity, Inc.
7	//
8	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//
11
12	#ifndef hifi_RearMirrorTools_h
13	#define hifi_RearMirrorTools_h
14
15	#include <gpu/Texture.h>
16	#include <SettingHandle.h>
17
18	enum ZoomLevel {
19	HEAD = 0,
20	BODY = 1
21	};
22
23	class RearMirrorTools : public QObject {
24	Q_OBJECT
25	public:
26	RearMirrorTools(QRect& bounds);
27	void render(RenderArgs* renderArgs, bool fullScreen, const QPoint & mousePos);
28	bool mousePressEvent(int x, int y);
29
30	static Setting::Handle<int> rearViewZoomLevel;
31
32	signals:
33	void closeView();
34	void shrinkView();
35	void resetView();
36	void restoreView();
37
38	private:
39	QRect _bounds;
40	gpu::TexturePointer _closeTexture;
41	gpu::TexturePointer _zoomBodyTexture;
42	gpu::TexturePointer _zoomHeadTexture;
43
44	QRect _closeIconRect;
45	QRect _resetIconRect;
46	QRect _shrinkIconRect;
47	QRect _headZoomIconRect;
48	QRect _bodyZoomIconRect;
49
50	bool _windowed;
51	bool _fullScreen;
52
53	void displayIcon(QRect bounds, QRect iconBounds, const gpu::TexturePointer& texture, bool selected = false);
54	};
55
56	#endif // hifi_RearMirrorTools_h

interface/src/ui/Stats.cpp+221−466

@@ -1,17 +1,17 @@
1	//	1	//
2	// Stats.cpp	2	// Created by Bradley Austin Davis 2015/06/17
3	// interface/src/ui
4	//
5	// Created by Lucas Crisman on 22/03/14.
6	// Copyright 2013 High Fidelity, Inc.	3	// Copyright 2013 High Fidelity, Inc.
7	//	4	//
8	// Distributed under the Apache License, Version 2.0.	5	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html	6	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//	7	//
11		8
12	#include <sstream>	9	#include <gpu/GPUConfig.h>
13		10
14	#include <stdlib.h>	11	#include "Stats.h"
		12
		13	#include <sstream>
		14	#include <QFontDatabase>
15		15
16	#include <glm/glm.hpp>	16	#include <glm/glm.hpp>
17	#include <glm/gtx/component_wise.hpp>	17	#include <glm/gtx/component_wise.hpp>
@@ -25,147 +25,31 @@ · 7 unmodified lines
25	#include <LODManager.h>	25	#include <LODManager.h>
26	#include <PerfStat.h>	26	#include <PerfStat.h>
27		27
28	#include "Stats.h"
29	#include "BandwidthRecorder.h"	28	#include "BandwidthRecorder.h"
30	#include "InterfaceConfig.h"	29	#include "InterfaceConfig.h"
31	#include "Menu.h"	30	#include "Menu.h"
32	#include "Util.h"	31	#include "Util.h"
33	#include "SequenceNumberStats.h"	32	#include "SequenceNumberStats.h"
34		33
35	using namespace std;	34	HIFI_QML_DEF(Stats)
36		35
37	const int STATS_PELS_PER_LINE = 16;	36	using namespace std;
38	const int STATS_PELS_INITIALOFFSET = 12;
39		37
40	const int STATS_GENERAL_MIN_WIDTH = 165;	38	static Stats* INSTANCE{ nullptr };
41	const int STATS_PING_MIN_WIDTH = 190;
42	const int STATS_GEO_MIN_WIDTH = 240;
43	const int STATS_OCTREE_MIN_WIDTH = 410;
44		39
45	Stats* Stats::getInstance() {	40	Stats* Stats::getInstance() {
46	static Stats stats;	41	if (!INSTANCE) {
47	return &stats;	42	Stats::registerType();
48	}	43	Stats::show();
49		44	Q_ASSERT(INSTANCE);
50	Stats::Stats():
51	_expanded(false),
52	_recentMaxPackets(0),
53	_resetRecentMaxPacketsSoon(true),
54	_generalStatsWidth(STATS_GENERAL_MIN_WIDTH),
55	_pingStatsWidth(STATS_PING_MIN_WIDTH),
56	_geoStatsWidth(STATS_GEO_MIN_WIDTH),
57	_octreeStatsWidth(STATS_OCTREE_MIN_WIDTH),
58	_lastHorizontalOffset(0)
59	{
60	auto canvasSize = Application::getInstance()->getCanvasSize();
61	resetWidth(canvasSize.x, 0);
62	}
63
64	void Stats::toggleExpanded() {
65	_expanded = !_expanded;
66	}
67
68	// called on mouse click release
69	// check for clicks over stats in order to expand or contract them
70	void Stats::checkClick(int mouseX, int mouseY, int mouseDragStartedX, int mouseDragStartedY, int horizontalOffset) {
71	auto canvasSize = Application::getInstance()->getCanvasSize();
72
73	if (0 != glm::compMax(glm::abs(glm::ivec2(mouseX - mouseDragStartedX, mouseY - mouseDragStartedY)))) {
74	// not worried about dragging on stats
75	return;
76	}
77
78	int statsHeight = 0,
79	statsWidth = 0,
80	statsX = 0,
81	statsY = 0,
82	lines = 0;
83
84	statsX = horizontalOffset;
85
86	// top-left stats click
87	lines = _expanded ? 5 : 3;
88	statsHeight = lines * STATS_PELS_PER_LINE + 10;
89	if (mouseX > statsX && mouseX < statsX + _generalStatsWidth && mouseY > statsY && mouseY < statsY + statsHeight) {
90	toggleExpanded();
91	return;
92	}
93	statsX += _generalStatsWidth;
94
95	// ping stats click
96	if (Menu::getInstance()->isOptionChecked(MenuOption::TestPing)) {
97	lines = _expanded ? 4 : 3;
98	statsHeight = lines * STATS_PELS_PER_LINE + 10;
99	if (mouseX > statsX && mouseX < statsX + _pingStatsWidth && mouseY > statsY && mouseY < statsY + statsHeight) {
100	toggleExpanded();
101	return;
102	}
103	statsX += _pingStatsWidth;
104	}
105
106	// geo stats panel click
107	lines = _expanded ? 4 : 3;
108	statsHeight = lines * STATS_PELS_PER_LINE + 10;
109	if (mouseX > statsX && mouseX < statsX + _geoStatsWidth && mouseY > statsY && mouseY < statsY + statsHeight) {
110	toggleExpanded();
111	return;
112	}
113	statsX += _geoStatsWidth;
114
115	// top-right stats click
116	lines = _expanded ? 11 : 3;
117	statsHeight = lines * STATS_PELS_PER_LINE + 10;
118	statsWidth = canvasSize.x - statsX;
119	if (mouseX > statsX && mouseX < statsX + statsWidth && mouseY > statsY && mouseY < statsY + statsHeight) {
120	toggleExpanded();
121	return;
122	}
123	}
124
125	void Stats::resetWidth(int width, int horizontalOffset) {
126	auto canvasSize = Application::getInstance()->getCanvasSize();
127	int extraSpace = canvasSize.x - horizontalOffset - 2
128	- STATS_GENERAL_MIN_WIDTH
129	- (Menu::getInstance()->isOptionChecked(MenuOption::TestPing) ? STATS_PING_MIN_WIDTH -1 : 0)
130	- STATS_GEO_MIN_WIDTH
131	- STATS_OCTREE_MIN_WIDTH;
132
133	int panels = 4;
134
135	_generalStatsWidth = STATS_GENERAL_MIN_WIDTH;
136	if (Menu::getInstance()->isOptionChecked(MenuOption::TestPing)) {
137	_pingStatsWidth = STATS_PING_MIN_WIDTH;
138	} else {
139	_pingStatsWidth = 0;
140	panels = 3;
141	}
142	_geoStatsWidth = STATS_GEO_MIN_WIDTH;
143	_octreeStatsWidth = STATS_OCTREE_MIN_WIDTH;
144
145	if (extraSpace > panels) {
146	_generalStatsWidth += (int) extraSpace / panels;
147	if (Menu::getInstance()->isOptionChecked(MenuOption::TestPing)) {
148	_pingStatsWidth += (int) extraSpace / panels;
149	}
150	_geoStatsWidth += (int) extraSpace / panels;
151	_octreeStatsWidth += canvasSize.x -
152	(_generalStatsWidth + _pingStatsWidth + _geoStatsWidth + 3);
153	}	45	}
		46	return INSTANCE;
154	}	47	}
155		48
156		49	Stats::Stats(QQuickItem* parent) : QQuickItem(parent) {
157	// translucent background box that makes stats more readable	50	INSTANCE = this;
158	void Stats::drawBackground(unsigned int rgba, int x, int y, int width, int height) {	51	const QFont font = QFontDatabase::systemFont(QFontDatabase::FixedFont);
159	glm::vec4 color(((rgba >> 24) & 0xff) / 255.0f,	52	_monospaceFont = font.family();
160	((rgba >> 16) & 0xff) / 255.0f,
161	((rgba >> 8) & 0xff) / 255.0f,
162	(rgba & 0xff) / 255.0f);
163
164	// FIX ME: is this correct? It seems to work to fix textures bleeding into us...
165	glBindTexture(GL_TEXTURE_2D, 0);
166	glDisable(GL_TEXTURE_2D);
167
168	DependencyManager::get<GeometryCache>()->renderQuad(x, y, width, height, color);
169	}	53	}
170		54
171	bool Stats::includeTimingRecord(const QString& name) {	55	bool Stats::includeTimingRecord(const QString& name) {
@@ -190,161 +74,70 @@ bool Stats::includeTimingRecord(const QString& name) { · 18 unmodified lines
190	return false;	74	return false;
191	}	75	}
192		76
193	// display expanded or contracted stats	77	#define STAT_UPDATE(name, src) \
194	void Stats::display(	78	{ \
195	const float* color,	79	auto val = src; \
196	int horizontalOffset,	80	if (_##name != val) { \
197	float fps,	81	_##name = val; \
198	int inPacketsPerSecond,	82	emit name##Changed(); \
199	int outPacketsPerSecond,	83	} \
200	int inKbitsPerSecond,
201	int outKbitsPerSecond,
202	int voxelPacketsToProcess)
203	{
204	auto canvasSize = Application::getInstance()->getCanvasSize();
205
206	unsigned int backgroundColor = 0x33333399;
207	int verticalOffset = 0, lines = 0;
208	float scale = 0.10f;
209	float rotation = 0.0f;
210	int font = 2;
211
212	QLocale locale(QLocale::English);
213	std::stringstream octreeStats;
214
215	QSharedPointer<BandwidthRecorder> bandwidthRecorder = DependencyManager::get<BandwidthRecorder>();
216
217	if (_lastHorizontalOffset != horizontalOffset) {
218	resetWidth(canvasSize.x, horizontalOffset);
219	_lastHorizontalOffset = horizontalOffset;
220	}	84	}
221		85
222	glPointSize(1.0f);	86	#define STAT_UPDATE_FLOAT(name, src, epsilon) \
223		87	{ \
224	// we need to take one avatar out so we don't include ourselves	88	float val = src; \
225	int totalAvatars = DependencyManager::get<AvatarManager>()->size() - 1;	89	if (fabs(_##name - val) >= epsilon) { \
226	int totalServers = DependencyManager::get<NodeList>()->size();	90	_##name = val; \
227		91	emit name##Changed(); \
228	lines = 5;	92	} \
229	int columnOneWidth = _generalStatsWidth;
230
231	bool performanceTimerIsActive = PerformanceTimer::isActive();
232	bool displayPerf = _expanded && Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails);
233	if (displayPerf && performanceTimerIsActive) {
234	PerformanceTimer::tallyAllTimerRecords(); // do this even if we're not displaying them, so they don't stack up
235
236	columnOneWidth = _generalStatsWidth + _pingStatsWidth + _geoStatsWidth; // 3 columns wide...
237	// we will also include room for 1 line per timing record and a header of 4 lines
238	lines += 4;
239
240	const QMap<QString, PerformanceTimerRecord>& allRecords = PerformanceTimer::getAllTimerRecords();
241	QMapIterator<QString, PerformanceTimerRecord> i(allRecords);
242	bool onlyDisplayTopTen = Menu::getInstance()->isOptionChecked(MenuOption::OnlyDisplayTopTen);
243	int statsLines = 0;
244	while (i.hasNext()) {
245	i.next();
246	if (includeTimingRecord(i.key())) {
247	lines++;
248	statsLines++;
249	if (onlyDisplayTopTen && statsLines == 10) {
250	break;
251	}
252	}
253	}
254	}	93	}
255
256	drawBackground(backgroundColor, horizontalOffset, 0, columnOneWidth, (lines + 1) * STATS_PELS_PER_LINE);
257	horizontalOffset += 5;
258
259	int columnOneHorizontalOffset = horizontalOffset;
260
261	QString serverNodes = QString("Servers: %1").arg(totalServers);
262	QString avatarNodes = QString("Avatars: %1").arg(totalAvatars);
263	QString framesPerSecond = QString("Framerate: %1 FPS").arg(fps, 3, 'f', 0);
264
265	verticalOffset = STATS_PELS_INITIALOFFSET; // first one is offset by less than a line
266	drawText(horizontalOffset, verticalOffset, scale, rotation, font, serverNodes.toUtf8().constData(), color);
267	verticalOffset += STATS_PELS_PER_LINE;
268	drawText(horizontalOffset, verticalOffset, scale, rotation, font, avatarNodes.toUtf8().constData(), color);
269	verticalOffset += STATS_PELS_PER_LINE;
270	drawText(horizontalOffset, verticalOffset, scale, rotation, font, framesPerSecond.toUtf8().constData(), color);
271
272	QString packetsPerSecondString = QString("Packets In/Out: %1/%2").arg(inPacketsPerSecond).arg(outPacketsPerSecond);
273	QString averageMegabitsPerSecond = QString("Mbps In/Out: %1/%2").
274	arg((float)inKbitsPerSecond * 1.0f / 1000.0f).
275	arg((float)outKbitsPerSecond * 1.0f / 1000.0f);
276
277	verticalOffset += STATS_PELS_PER_LINE;
278	drawText(horizontalOffset, verticalOffset, scale, rotation, font, packetsPerSecondString.toUtf8().constData(), color);
279	verticalOffset += STATS_PELS_PER_LINE;
280	drawText(horizontalOffset, verticalOffset, scale, rotation, font, averageMegabitsPerSecond.toUtf8().constData(), color);
281		94
282
283	// TODO: the display of these timing details should all be moved to JavaScript
284	if (displayPerf && performanceTimerIsActive) {
285	bool onlyDisplayTopTen = Menu::getInstance()->isOptionChecked(MenuOption::OnlyDisplayTopTen);
286	// Timing details...
287	verticalOffset += STATS_PELS_PER_LINE * 4; // skip 3 lines to be under the other columns
288	drawText(columnOneHorizontalOffset, verticalOffset, scale, rotation, font,
289	"-------------------------------------------------------- Function "
290	"------------------------------------------------------- --msecs- -calls--", color);
291
292	// First iterate all the records, and for the ones that should be included, insert them into
293	// a new Map sorted by average time...
294	QMap<float, QString> sortedRecords;
295	const QMap<QString, PerformanceTimerRecord>& allRecords = PerformanceTimer::getAllTimerRecords();
296	QMapIterator<QString, PerformanceTimerRecord> i(allRecords);
297		95
298	while (i.hasNext()) {	96	void Stats::updateStats() {
299	i.next();	97	if (!Menu::getInstance()->isOptionChecked(MenuOption::Stats)) {
300	if (includeTimingRecord(i.key())) {	98	if (isVisible()) {
301	float averageTime = (float)i.value().getMovingAverage() / (float)USECS_PER_MSEC;	99	setVisible(false);
302	sortedRecords.insertMulti(averageTime, i.key());
303	}
304	}	100	}
305		101	return;
306	int linesDisplayed = 0;	102	} else {
307	QMapIterator<float, QString> j(sortedRecords);	103	if (!isVisible()) {
308	j.toBack();	104	setVisible(true);
309	while (j.hasPrevious()) {
310	j.previous();
311	QChar noBreakingSpace = QChar::Nbsp;
312	QString functionName = j.value();
313	const PerformanceTimerRecord& record = allRecords.value(functionName);
314
315	QString perfLine = QString("%1: %2 [%3]").
316	arg(QString(qPrintable(functionName)), 120, noBreakingSpace).
317	arg((float)record.getMovingAverage() / (float)USECS_PER_MSEC, 8, 'f', 3, noBreakingSpace).
318	arg((int)record.getCount(), 6, 10, noBreakingSpace);
319
320	verticalOffset += STATS_PELS_PER_LINE;
321	drawText(columnOneHorizontalOffset, verticalOffset, scale, rotation, font, perfLine.toUtf8().constData(), color);
322	linesDisplayed++;
323	if (onlyDisplayTopTen && linesDisplayed == 10) {
324	break;
325	}
326	}	105	}
327	}	106	}
328		107
		108	bool shouldDisplayTimingDetail = Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails) &&
		109	Menu::getInstance()->isOptionChecked(MenuOption::Stats) && isExpanded();
		110	if (shouldDisplayTimingDetail != PerformanceTimer::isActive()) {
		111	PerformanceTimer::setActive(shouldDisplayTimingDetail);
		112	}
329		113
330	verticalOffset = STATS_PELS_INITIALOFFSET;
331	horizontalOffset = _lastHorizontalOffset + _generalStatsWidth + 1;
332		114
333	if (Menu::getInstance()->isOptionChecked(MenuOption::TestPing)) {	115	auto nodeList = DependencyManager::get<NodeList>();
334	int pingAudio = -1, pingAvatar = -1, pingVoxel = -1, pingOctreeMax = -1;	116	auto avatarManager = DependencyManager::get<AvatarManager>();
		117	// we need to take one avatar out so we don't include ourselves
		118	STAT_UPDATE(avatarCount, avatarManager->size() - 1);
		119	STAT_UPDATE(serverCount, nodeList->size());
		120	STAT_UPDATE(framerate, (int)qApp->getFps());
		121
		122	auto bandwidthRecorder = DependencyManager::get<BandwidthRecorder>();
		123	STAT_UPDATE(packetInCount, bandwidthRecorder->getCachedTotalAverageInputPacketsPerSecond());
		124	STAT_UPDATE(packetOutCount, bandwidthRecorder->getCachedTotalAverageOutputPacketsPerSecond());
		125	STAT_UPDATE_FLOAT(mbpsIn, (float)bandwidthRecorder->getCachedTotalAverageOutputKilobitsPerSecond() / 1000.0f, 0.01f);
		126	STAT_UPDATE_FLOAT(mbpsOut, (float)bandwidthRecorder->getCachedTotalAverageInputKilobitsPerSecond() / 1000.0f, 0.01f);
335		127
336	auto nodeList = DependencyManager::get<NodeList>();	128	// Second column: ping
		129	if (Menu::getInstance()->isOptionChecked(MenuOption::TestPing)) {
337	SharedNodePointer audioMixerNode = nodeList->soloNodeOfType(NodeType::AudioMixer);	130	SharedNodePointer audioMixerNode = nodeList->soloNodeOfType(NodeType::AudioMixer);
338	SharedNodePointer avatarMixerNode = nodeList->soloNodeOfType(NodeType::AvatarMixer);	131	SharedNodePointer avatarMixerNode = nodeList->soloNodeOfType(NodeType::AvatarMixer);
		132	STAT_UPDATE(audioPing, audioMixerNode ? audioMixerNode->getPingMs() : -1);
		133	STAT_UPDATE(avatarPing, avatarMixerNode ? avatarMixerNode->getPingMs() : -1);
339		134
340	pingAudio = audioMixerNode ? audioMixerNode->getPingMs() : -1;	135	//// Now handle voxel servers, since there could be more than one, we average their ping times
341	pingAvatar = avatarMixerNode ? avatarMixerNode->getPingMs() : -1;
342
343	// Now handle voxel servers, since there could be more than one, we average their ping times
344	unsigned long totalPingOctree = 0;	136	unsigned long totalPingOctree = 0;
345	int octreeServerCount = 0;	137	int octreeServerCount = 0;
346		138	int pingOctreeMax = 0;
347	nodeList->eachNode([&totalPingOctree, &pingOctreeMax, &octreeServerCount](const SharedNodePointer& node){	139	int pingVoxel;
		140	nodeList->eachNode([&](const SharedNodePointer& node) {
348	// TODO: this should also support entities	141	// TODO: this should also support entities
349	if (node->getType() == NodeType::EntityServer) {	142	if (node->getType() == NodeType::EntityServer) {
350	totalPingOctree += node->getPingMs();	143	totalPingOctree += node->getPingMs();
@@ -359,168 +152,85 @@ void Stats::display( · 8 unmodified lines
359	pingVoxel = totalPingOctree / octreeServerCount;	152	pingVoxel = totalPingOctree / octreeServerCount;
360	}	153	}
361		154
362	lines = _expanded ? 4 : 3;	155	//STAT_UPDATE(entitiesPing, pingVoxel);
363		156	//if (_expanded) {
364	// only draw our background if column one didn't draw a wide background	157	// QString voxelMaxPing;
365	if (columnOneWidth == _generalStatsWidth) {	158	// if (pingVoxel >= 0) { // Average is only meaningful if pingVoxel is valid.
366	drawBackground(backgroundColor, horizontalOffset, 0, _pingStatsWidth, (lines + 1) * STATS_PELS_PER_LINE);	159	// voxelMaxPing = QString("Voxel max ping: %1").arg(pingOctreeMax);
367	}	160	// } else {
368	horizontalOffset += 5;	161	// voxelMaxPing = QString("Voxel max ping: --");
369		162	// }
370		163	} else {
371	QString audioPing;	164	// -2 causes the QML to hide the ping column
372	if (pingAudio >= 0) {	165	STAT_UPDATE(audioPing, -2);
373	audioPing = QString("Audio ping: %1").arg(pingAudio);
374	} else {
375	audioPing = QString("Audio ping: --");
376	}
377
378	QString avatarPing;
379	if (pingAvatar >= 0) {
380	avatarPing = QString("Avatar ping: %1").arg(pingAvatar);
381	} else {
382	avatarPing = QString("Avatar ping: --");
383	}
384
385	QString voxelAvgPing;
386	if (pingVoxel >= 0) {
387	voxelAvgPing = QString("Entities avg ping: %1").arg(pingVoxel);
388	} else {
389	voxelAvgPing = QString("Entities avg ping: --");
390	}
391
392	drawText(horizontalOffset, verticalOffset, scale, rotation, font, audioPing.toUtf8().constData(), color);
393	verticalOffset += STATS_PELS_PER_LINE;
394	drawText(horizontalOffset, verticalOffset, scale, rotation, font, avatarPing.toUtf8().constData(), color);
395	verticalOffset += STATS_PELS_PER_LINE;
396	drawText(horizontalOffset, verticalOffset, scale, rotation, font, voxelAvgPing.toUtf8().constData(), color);
397
398	if (_expanded) {
399	QString voxelMaxPing;
400	if (pingVoxel >= 0) { // Average is only meaningful if pingVoxel is valid.
401	voxelMaxPing = QString("Voxel max ping: %1").arg(pingOctreeMax);
402	} else {
403	voxelMaxPing = QString("Voxel max ping: --");
404	}
405
406	verticalOffset += STATS_PELS_PER_LINE;
407	drawText(horizontalOffset, verticalOffset, scale, rotation, font, voxelMaxPing.toUtf8().constData(), color);
408	}
409
410	verticalOffset = STATS_PELS_INITIALOFFSET;
411	horizontalOffset = _lastHorizontalOffset + _generalStatsWidth + _pingStatsWidth + 2;
412	}	166	}
413		167
414	MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
415	glm::vec3 avatarPos = myAvatar->getPosition();
416
417	lines = _expanded ? 7 : 3;
418
419	if (columnOneWidth == _generalStatsWidth) {
420	drawBackground(backgroundColor, horizontalOffset, 0, _geoStatsWidth, (lines + 1) * STATS_PELS_PER_LINE);
421	}
422	horizontalOffset += 5;
423
424	QString avatarPosition = QString("Position: %1, %2, %3").
425	arg(avatarPos.x, -1, 'f', 1).
426	arg(avatarPos.y, -1, 'f', 1).
427	arg(avatarPos.z, -1, 'f', 1);
428	QString avatarVelocity = QString("Velocity: %1").arg(glm::length(myAvatar->getVelocity()), -1, 'f', 1);
429	QString avatarBodyYaw = QString("Yaw: %1").arg(myAvatar->getBodyYaw(), -1, 'f', 1);
430	QString avatarMixerStats;
431
432	drawText(horizontalOffset, verticalOffset, scale, rotation, font, avatarPosition.toUtf8().constData(), color);
433	verticalOffset += STATS_PELS_PER_LINE;
434	drawText(horizontalOffset, verticalOffset, scale, rotation, font, avatarVelocity.toUtf8().constData(), color);
435	verticalOffset += STATS_PELS_PER_LINE;
436	drawText(horizontalOffset, verticalOffset, scale, rotation, font, avatarBodyYaw.toUtf8().constData(), color);
437		168
		169	// Third column, avatar stats
		170	MyAvatar* myAvatar = avatarManager->getMyAvatar();
		171	glm::vec3 avatarPos = myAvatar->getPosition();
		172	STAT_UPDATE(position, QVector3D(avatarPos.x, avatarPos.y, avatarPos.z));
		173	STAT_UPDATE_FLOAT(velocity, glm::length(myAvatar->getVelocity()), 0.1f);
		174	STAT_UPDATE_FLOAT(yaw, myAvatar->getBodyYaw(), 0.1f);
438	if (_expanded) {	175	if (_expanded) {
439	SharedNodePointer avatarMixer = DependencyManager::get<NodeList>()->soloNodeOfType(NodeType::AvatarMixer);	176	SharedNodePointer avatarMixer = nodeList->soloNodeOfType(NodeType::AvatarMixer);
440	if (avatarMixer) {	177	if (avatarMixer) {
441	avatarMixerStats = QString("Avatar Mixer: %1 kbps, %2 pps").	178	STAT_UPDATE(avatarMixerKbps, roundf(
442	arg(roundf(bandwidthRecorder->getAverageInputKilobitsPerSecond(NodeType::AudioMixer) +	179	bandwidthRecorder->getAverageInputKilobitsPerSecond(NodeType::AvatarMixer) +
443	bandwidthRecorder->getAverageOutputKilobitsPerSecond(NodeType::AudioMixer))).	180	bandwidthRecorder->getAverageOutputKilobitsPerSecond(NodeType::AvatarMixer)));
444	arg(roundf(bandwidthRecorder->getAverageInputPacketsPerSecond(NodeType::AudioMixer) +	181	STAT_UPDATE(avatarMixerPps, roundf(
445	bandwidthRecorder->getAverageOutputPacketsPerSecond(NodeType::AudioMixer)));	182	bandwidthRecorder->getAverageInputPacketsPerSecond(NodeType::AvatarMixer) +
		183	bandwidthRecorder->getAverageOutputPacketsPerSecond(NodeType::AvatarMixer)));
446	} else {	184	} else {
447	avatarMixerStats = QString("No Avatar Mixer");	185	STAT_UPDATE(avatarMixerKbps, -1);
		186	STAT_UPDATE(avatarMixerPps, -1);
448	}	187	}
449		188	SharedNodePointer audioMixerNode = nodeList->soloNodeOfType(NodeType::AudioMixer);
450	verticalOffset += STATS_PELS_PER_LINE;	189	if (audioMixerNode) {
451	drawText(horizontalOffset, verticalOffset, scale, rotation, font, avatarMixerStats.toUtf8().constData(), color);	190	STAT_UPDATE(audioMixerKbps, roundf(
452		191	bandwidthRecorder->getAverageInputKilobitsPerSecond(NodeType::AudioMixer) +
453	stringstream downloads;	192	bandwidthRecorder->getAverageOutputKilobitsPerSecond(NodeType::AudioMixer)));
454	downloads << "Downloads: ";	193	STAT_UPDATE(audioMixerPps, roundf(
455	foreach (Resource* resource, ResourceCache::getLoadingRequests()) {	194	bandwidthRecorder->getAverageInputPacketsPerSecond(NodeType::AudioMixer) +
456	downloads << (int)(resource->getProgress() * 100.0f) << "% ";	195	bandwidthRecorder->getAverageOutputPacketsPerSecond(NodeType::AudioMixer)));
		196	} else {
		197	STAT_UPDATE(audioMixerKbps, -1);
		198	STAT_UPDATE(audioMixerPps, -1);
457	}	199	}
458	downloads << "(" << ResourceCache::getPendingRequestCount() << " pending)";
459
460	verticalOffset += STATS_PELS_PER_LINE;
461	drawText(horizontalOffset, verticalOffset, scale, rotation, font, downloads.str().c_str(), color);
462	}
463		200
464	verticalOffset = STATS_PELS_INITIALOFFSET;	201	STAT_UPDATE(downloads, ResourceCache::getLoadingRequests().size());
465	horizontalOffset = _lastHorizontalOffset + _generalStatsWidth + _pingStatsWidth + _geoStatsWidth + 3;	202	STAT_UPDATE(downloadsPending, ResourceCache::getPendingRequestCount());
466		203	// TODO fix to match original behavior
467	lines = _expanded ? 10 : 3;	204	//stringstream downloads;
468		205	//downloads << "Downloads: ";
469	drawBackground(backgroundColor, horizontalOffset, 0, canvasSize.x - horizontalOffset,	206	//foreach(Resource* resource, ) {
470	(lines + 1) * STATS_PELS_PER_LINE);	207	// downloads << (int)(resource->getProgress() * 100.0f) << "% ";
471	horizontalOffset += 5;	208	//}
472		209	//downloads << "(" << << " pending)";
473	// Model/Entity render details	210	} // expanded avatar column
474	octreeStats.str("");	211
475	octreeStats << "Triangles: " << _renderDetails._trianglesRendered	212	// Fourth column, octree stats
476	<< " / Quads:" << _renderDetails._quadsRendered
477	<< " / Material Switches:" << _renderDetails._materialSwitches;
478	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);
479
480	if (_expanded) {
481	octreeStats.str("");
482	octreeStats << " Mesh Parts Rendered Opaque: " << _renderDetails._opaque._rendered
483	<< " / Translucent:" << _renderDetails._translucent._rendered;
484	verticalOffset += STATS_PELS_PER_LINE;
485	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);
486
487	octreeStats.str("");
488	octreeStats << " Opaque considered: " << _renderDetails._opaque._considered
489	<< " / Out of view:" << _renderDetails._opaque._outOfView
490	<< " / Too small:" << _renderDetails._opaque._tooSmall;
491	verticalOffset += STATS_PELS_PER_LINE;
492	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);
493
494	octreeStats.str("");
495	octreeStats << " Translucent considered: " << _renderDetails._translucent._considered
496	<< " / Out of view:" << _renderDetails._translucent._outOfView
497	<< " / Too small:" << _renderDetails._translucent._tooSmall;
498	verticalOffset += STATS_PELS_PER_LINE;
499	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);
500	}
501
502	// iterate all the current voxel stats, and list their sending modes, and total voxel counts
503	std::stringstream sendingMode("");
504	sendingMode << "Octree Sending Mode: [";
505	int serverCount = 0;	213	int serverCount = 0;
506	int movingServerCount = 0;	214	int movingServerCount = 0;
507	unsigned long totalNodes = 0;	215	unsigned long totalNodes = 0;
508	unsigned long totalInternal = 0;	216	unsigned long totalInternal = 0;
509	unsigned long totalLeaves = 0;	217	unsigned long totalLeaves = 0;
		218	std::stringstream sendingModeStream("");
		219	sendingModeStream << "[";
510	NodeToOctreeSceneStats* octreeServerSceneStats = Application::getInstance()->getOcteeSceneStats();	220	NodeToOctreeSceneStats* octreeServerSceneStats = Application::getInstance()->getOcteeSceneStats();
511	for(NodeToOctreeSceneStatsIterator i = octreeServerSceneStats->begin(); i != octreeServerSceneStats->end(); i++) {	221	for (NodeToOctreeSceneStatsIterator i = octreeServerSceneStats->begin(); i != octreeServerSceneStats->end(); i++) {
512	//const QUuid& uuid = i->first;	222	//const QUuid& uuid = i->first;
513	OctreeSceneStats& stats = i->second;	223	OctreeSceneStats& stats = i->second;
514	serverCount++;	224	serverCount++;
515	if (_expanded) {	225	if (_expanded) {
516	if (serverCount > 1) {	226	if (serverCount > 1) {
517	sendingMode << ",";	227	sendingModeStream << ",";
518	}	228	}
519	if (stats.isMoving()) {	229	if (stats.isMoving()) {
520	sendingMode << "M";	230	sendingModeStream << "M";
521	movingServerCount++;	231	movingServerCount++;
522	} else {	232	} else {
523	sendingMode << "S";	233	sendingModeStream << "S";
524	}	234	}
525	}	235	}
526		236
@@ -528,32 +238,35 @@ void Stats::display( · 1 unmodified line
528	totalNodes += stats.getTotalElements();	238	totalNodes += stats.getTotalElements();
529	if (_expanded) {	239	if (_expanded) {
530	totalInternal += stats.getTotalInternal();	240	totalInternal += stats.getTotalInternal();
531	totalLeaves += stats.getTotalLeaves();	241	totalLeaves += stats.getTotalLeaves();
532	}	242	}
533	}	243	}
534	if (_expanded) {	244	if (_expanded) {
535	if (serverCount == 0) {	245	if (serverCount == 0) {
536	sendingMode << "---";	246	sendingModeStream << "---";
537	}	247	}
538	sendingMode << "] " << serverCount << " servers";	248	sendingModeStream << "] " << serverCount << " servers";
539	if (movingServerCount > 0) {	249	if (movingServerCount > 0) {
540	sendingMode << " <SCENE NOT STABLE>";	250	sendingModeStream << " <SCENE NOT STABLE>";
541	} else {	251	} else {
542	sendingMode << " <SCENE STABLE>";	252	sendingModeStream << " <SCENE STABLE>";
543	}	253	}
544	verticalOffset += STATS_PELS_PER_LINE;	254	QString sendingModeResult = sendingModeStream.str().c_str();
545	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)sendingMode.str().c_str(), color);	255	STAT_UPDATE(sendingMode, sendingModeResult);
546	}	256	}
547		257
548	// Incoming packets	258	// Incoming packets
		259	QLocale locale(QLocale::English);
		260	auto voxelPacketsToProcess = qApp->getOctreePacketProcessor().packetsToProcessCount();
549	if (_expanded) {	261	if (_expanded) {
550	octreeStats.str("");	262	std::stringstream octreeStats;
551	QString packetsString = locale.toString((int)voxelPacketsToProcess);	263	QString packetsString = locale.toString((int)voxelPacketsToProcess);
552	QString maxString = locale.toString((int)_recentMaxPackets);	264	QString maxString = locale.toString((int)_recentMaxPackets);
553	octreeStats << "Octree Packets to Process: " << qPrintable(packetsString)	265	octreeStats << "Octree Packets to Process: " << qPrintable(packetsString)
554	<< " [Recent Max: " << qPrintable(maxString) << "]";	266	<< " [Recent Max: " << qPrintable(maxString) << "]";
555	verticalOffset += STATS_PELS_PER_LINE;	267	QString str = octreeStats.str().c_str();
556	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);	268	STAT_UPDATE(packetStats, str);
		269	// drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);
557	}	270	}
558		271
559	if (_resetRecentMaxPacketsSoon && voxelPacketsToProcess > 0) {	272	if (_resetRecentMaxPacketsSoon && voxelPacketsToProcess > 0) {
@@ -562,60 +275,102 @@ void Stats::display( · 2 unmodified lines
562	}	275	}
563	if (voxelPacketsToProcess == 0) {	276	if (voxelPacketsToProcess == 0) {
564	_resetRecentMaxPacketsSoon = true;	277	_resetRecentMaxPacketsSoon = true;
565	} else {	278	} else if (voxelPacketsToProcess > _recentMaxPackets) {
566	if (voxelPacketsToProcess > _recentMaxPackets) {	279	_recentMaxPackets = voxelPacketsToProcess;
567	_recentMaxPackets = voxelPacketsToProcess;
568	}
569	}	280	}
570		281
571	QString serversTotalString = locale.toString((uint)totalNodes); // consider adding: .rightJustified(10, ' ');
572	unsigned long localTotal = OctreeElement::getNodeCount();
573	QString localTotalString = locale.toString((uint)localTotal); // consider adding: .rightJustified(10, ' ');
574
575	// Server Octree Elements	282	// Server Octree Elements
576	if (!_expanded) {	283	STAT_UPDATE(serverElements, totalNodes);
577	octreeStats.str("");	284	STAT_UPDATE(localElements, OctreeElement::getNodeCount());
578	octreeStats << "Octree Elements Server: " << qPrintable(serversTotalString)
579	<< " Local:" << qPrintable(localTotalString);
580	verticalOffset += STATS_PELS_PER_LINE;
581	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);
582	}
583		285
584	if (_expanded) {	286	if (_expanded) {
585	octreeStats.str("");	287	STAT_UPDATE(serverInternal, totalInternal);
586	octreeStats << "Octree Elements -";	288	STAT_UPDATE(serverLeaves, totalLeaves);
587	verticalOffset += STATS_PELS_PER_LINE;	289	// Local Voxels
588	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);	290	STAT_UPDATE(localInternal, OctreeElement::getInternalNodeCount());
		291	STAT_UPDATE(localLeaves, OctreeElement::getLeafNodeCount());
		292	// LOD Details
		293	STAT_UPDATE(lodStatus, "You can see " + DependencyManager::get<LODManager>()->getLODFeedbackText());
		294	}
589		295
590	QString serversInternalString = locale.toString((uint)totalInternal);	296	bool performanceTimerIsActive = PerformanceTimer::isActive();
591	QString serversLeavesString = locale.toString((uint)totalLeaves);	297	bool displayPerf = _expanded && Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails);
		298	if (displayPerf && performanceTimerIsActive) {
		299	if (!_timingExpanded) {
		300	_timingExpanded = true;
		301	emit timingExpandedChanged();
		302	}
		303	PerformanceTimer::tallyAllTimerRecords(); // do this even if we're not displaying them, so they don't stack up
592		304
593	octreeStats.str("");	305	// we will also include room for 1 line per timing record and a header of 4 lines
594	octreeStats << " Server: " << qPrintable(serversTotalString) <<	306	// Timing details...
595	" Internal: " << qPrintable(serversInternalString) <<
596	" Leaves: " << qPrintable(serversLeavesString);
597	verticalOffset += STATS_PELS_PER_LINE;
598	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);
599		307
600	// Local Voxels	308	// First iterate all the records, and for the ones that should be included, insert them into
601	unsigned long localInternal = OctreeElement::getInternalNodeCount();	309	// a new Map sorted by average time...
602	unsigned long localLeaves = OctreeElement::getLeafNodeCount();	310	bool onlyDisplayTopTen = Menu::getInstance()->isOptionChecked(MenuOption::OnlyDisplayTopTen);
603	QString localInternalString = locale.toString((uint)localInternal);	311	QMap<float, QString> sortedRecords;
604	QString localLeavesString = locale.toString((uint)localLeaves);	312	const QMap<QString, PerformanceTimerRecord>& allRecords = PerformanceTimer::getAllTimerRecords();
605		313	QMapIterator<QString, PerformanceTimerRecord> i(allRecords);
606	octreeStats.str("");	314
607	octreeStats << " Local: " << qPrintable(serversTotalString) <<	315	while (i.hasNext()) {
608	" Internal: " << qPrintable(localInternalString) <<	316	i.next();
609	" Leaves: " << qPrintable(localLeavesString) << "";	317	if (includeTimingRecord(i.key())) {
610	verticalOffset += STATS_PELS_PER_LINE;	318	float averageTime = (float)i.value().getMovingAverage() / (float)USECS_PER_MSEC;
611	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);	319	sortedRecords.insertMulti(averageTime, i.key());
		320	}
		321	}
		322
		323	int linesDisplayed = 0;
		324	QMapIterator<float, QString> j(sortedRecords);
		325	j.toBack();
		326	QString perfLines;
		327	while (j.hasPrevious()) {
		328	j.previous();
		329	static const QChar noBreakingSpace = QChar::Nbsp;
		330	QString functionName = j.value();
		331	const PerformanceTimerRecord& record = allRecords.value(functionName);
		332	perfLines += QString("%1: %2 [%3]\n").
		333	arg(QString(qPrintable(functionName)), 90, noBreakingSpace).
		334	arg((float)record.getMovingAverage() / (float)USECS_PER_MSEC, 8, 'f', 3, noBreakingSpace).
		335	arg((int)record.getCount(), 6, 10, noBreakingSpace);
		336	linesDisplayed++;
		337	if (onlyDisplayTopTen && linesDisplayed == 10) {
		338	break;
		339	}
		340	}
		341	_timingStats = perfLines;
		342	emit timingStatsChanged();
		343	} else if (_timingExpanded) {
		344	_timingExpanded = false;
		345	emit timingExpandedChanged();
612	}	346	}
		347	}
		348
		349	void Stats::setRenderDetails(const RenderDetails& details) {
		350	STAT_UPDATE(triangles, details._trianglesRendered);
		351	STAT_UPDATE(quads, details._quadsRendered);
		352	STAT_UPDATE(materialSwitches, details._materialSwitches);
		353	if (_expanded) {
		354	STAT_UPDATE(meshOpaque, details._opaque._rendered);
		355	STAT_UPDATE(meshTranslucent, details._opaque._rendered);
		356	STAT_UPDATE(opaqueConsidered, details._opaque._considered);
		357	STAT_UPDATE(opaqueOutOfView, details._opaque._outOfView);
		358	STAT_UPDATE(opaqueTooSmall, details._opaque._tooSmall);
		359	STAT_UPDATE(translucentConsidered, details._translucent._considered);
		360	STAT_UPDATE(translucentOutOfView, details._translucent._outOfView);
		361	STAT_UPDATE(translucentTooSmall, details._translucent._tooSmall);
		362	}
		363	}
		364
		365
		366	/*
		367	// display expanded or contracted stats
		368	void Stats::display(
		369	int voxelPacketsToProcess)
		370	{
		371	// iterate all the current voxel stats, and list their sending modes, and total voxel counts
613		372
614	// LOD Details
615	octreeStats.str("");
616	QString displayLODDetails = DependencyManager::get<LODManager>()->getLODFeedbackText();
617	octreeStats << "LOD: You can see " << qPrintable(displayLODDetails.trimmed());
618	verticalOffset += STATS_PELS_PER_LINE;
619	drawText(horizontalOffset, verticalOffset, scale, rotation, font, (char*)octreeStats.str().c_str(), color);
620	}	373	}
621		374
		375
		376	*/

interface/src/ui/Stats.h+121−32

@@ -1,8 +1,5 @@
1	//	1	//
2	// Stats.h	2	// Created by Bradley Austin Davis 2015/06/17
3	// interface/src/ui
4	//
5	// Created by Lucas Crisman on 22/03/14.
6	// Copyright 2013 High Fidelity, Inc.	3	// Copyright 2013 High Fidelity, Inc.
7	//	4	//
8	// Distributed under the Apache License, Version 2.0.	5	// Distributed under the Apache License, Version 2.0.
@@ -13,47 +10,139 @@ · 4 unmodified lines
13	#define hifi_Stats_h	10	#define hifi_Stats_h
14		11
15	#include <QObject>	12	#include <QObject>
		13	#include <QQuickItem>
		14	#include <QVector3D>
16		15
		16	#include <OffscreenUi.h>
17	#include <RenderArgs.h>	17	#include <RenderArgs.h>
18		18
19	class Stats: public QObject {	19	#define STATS_PROPERTY(type, name, initialValue) \
		20	Q_PROPERTY(type name READ name NOTIFY name##Changed) \
		21	public: \
		22	type name() { return _##name; }; \
		23	private: \
		24	type _##name{ initialValue };
		25
		26
		27	class Stats : public QQuickItem {
20	Q_OBJECT	28	Q_OBJECT
		29	HIFI_QML_DECL
		30	Q_PROPERTY(bool expanded READ isExpanded WRITE setExpanded NOTIFY expandedChanged)
		31	Q_PROPERTY(bool timingExpanded READ isTimingExpanded NOTIFY timingExpandedChanged)
		32	Q_PROPERTY(QString monospaceFont READ monospaceFont)
		33
		34	STATS_PROPERTY(int, serverCount, 0)
		35	STATS_PROPERTY(int, framerate, 0)
		36	STATS_PROPERTY(int, avatarCount, 0)
		37	STATS_PROPERTY(int, packetInCount, 0)
		38	STATS_PROPERTY(int, packetOutCount, 0)
		39	STATS_PROPERTY(float, mbpsIn, 0)
		40	STATS_PROPERTY(float, mbpsOut, 0)
		41	STATS_PROPERTY(int, audioPing, 0)
		42	STATS_PROPERTY(int, avatarPing, 0)
		43	STATS_PROPERTY(int, entitiesPing, 0)
		44	STATS_PROPERTY(QVector3D, position, QVector3D(0, 0, 0) )
		45	STATS_PROPERTY(float, velocity, 0)
		46	STATS_PROPERTY(float, yaw, 0)
		47	STATS_PROPERTY(int, avatarMixerKbps, 0)
		48	STATS_PROPERTY(int, avatarMixerPps, 0)
		49	STATS_PROPERTY(int, audioMixerKbps, 0)
		50	STATS_PROPERTY(int, audioMixerPps, 0)
		51	STATS_PROPERTY(int, downloads, 0)
		52	STATS_PROPERTY(int, downloadsPending, 0)
		53	STATS_PROPERTY(int, triangles, 0)
		54	STATS_PROPERTY(int, quads, 0)
		55	STATS_PROPERTY(int, materialSwitches, 0)
		56	STATS_PROPERTY(int, meshOpaque, 0)
		57	STATS_PROPERTY(int, meshTranslucent, 0)
		58	STATS_PROPERTY(int, opaqueConsidered, 0)
		59	STATS_PROPERTY(int, opaqueOutOfView, 0)
		60	STATS_PROPERTY(int, opaqueTooSmall, 0)
		61	STATS_PROPERTY(int, translucentConsidered, 0)
		62	STATS_PROPERTY(int, translucentOutOfView, 0)
		63	STATS_PROPERTY(int, translucentTooSmall, 0)
		64	STATS_PROPERTY(QString, sendingMode, QString())
		65	STATS_PROPERTY(QString, packetStats, QString())
		66	STATS_PROPERTY(QString, lodStatus, QString())
		67	STATS_PROPERTY(QString, timingStats, QString())
		68	STATS_PROPERTY(int, serverElements, 0)
		69	STATS_PROPERTY(int, serverInternal, 0)
		70	STATS_PROPERTY(int, serverLeaves, 0)
		71	STATS_PROPERTY(int, localElements, 0)
		72	STATS_PROPERTY(int, localInternal, 0)
		73	STATS_PROPERTY(int, localLeaves, 0)
21		74
22	public:	75	public:
23	static Stats* getInstance();	76	static Stats* getInstance();
24		77
25	Stats();	78	Stats(QQuickItem* parent = nullptr);
26
27	static void drawBackground(unsigned int rgba, int x, int y, int width, int height);
28
29	void toggleExpanded();
30	bool isExpanded() { return _expanded; }
31
32	void checkClick(int mouseX, int mouseY, int mouseDragStartedX, int mouseDragStartedY, int horizontalOffset);
33	void resetWidth(int width, int horizontalOffset);
34	void display(const float* color, int horizontalOffset, float fps, int inPacketsPerSecond, int outPacketsPerSecond,
35	int inKbitsPerSecond, int outKbitsPerSecond, int voxelPacketsToProcess);
36	bool includeTimingRecord(const QString& name);	79	bool includeTimingRecord(const QString& name);
37		80	void setRenderDetails(const RenderDetails& details);
38	void setRenderDetails(const RenderDetails& details) { _renderDetails = details; }	81	const QString& monospaceFont() {
39		82	return _monospaceFont;
40	private:	83	}
41	static Stats* _sharedInstance;	84	void updateStats();
42		85
43	bool _expanded;	86	bool isExpanded() { return _expanded; }
		87	bool isTimingExpanded() { return _timingExpanded; }
44		88
45	int _recentMaxPackets; // recent max incoming voxel packets to process	89	void setExpanded(bool expanded) {
46	bool _resetRecentMaxPacketsSoon;	90	if (_expanded != expanded) {
		91	_expanded = expanded;
		92	emit expandedChanged();
		93	}
		94	}
47		95
48	int _generalStatsWidth;	96	signals:
49	int _bandwidthStatsWidth;	97	void expandedChanged();
50	int _pingStatsWidth;	98	void timingExpandedChanged();
51	int _geoStatsWidth;	99	void serverCountChanged();
52	int _octreeStatsWidth;	100	void framerateChanged();
		101	void avatarCountChanged();
		102	void packetInCountChanged();
		103	void packetOutCountChanged();
		104	void mbpsInChanged();
		105	void mbpsOutChanged();
		106	void audioPingChanged();
		107	void avatarPingChanged();
		108	void entitiesPingChanged();
		109	void positionChanged();
		110	void velocityChanged();
		111	void yawChanged();
		112	void avatarMixerKbpsChanged();
		113	void avatarMixerPpsChanged();
		114	void audioMixerKbpsChanged();
		115	void audioMixerPpsChanged();
		116	void downloadsChanged();
		117	void downloadsPendingChanged();
		118	void trianglesChanged();
		119	void quadsChanged();
		120	void materialSwitchesChanged();
		121	void meshOpaqueChanged();
		122	void meshTranslucentChanged();
		123	void opaqueConsideredChanged();
		124	void opaqueOutOfViewChanged();
		125	void opaqueTooSmallChanged();
		126	void translucentConsideredChanged();
		127	void translucentOutOfViewChanged();
		128	void translucentTooSmallChanged();
		129	void sendingModeChanged();
		130	void packetStatsChanged();
		131	void lodStatusChanged();
		132	void serverElementsChanged();
		133	void serverInternalChanged();
		134	void serverLeavesChanged();
		135	void localElementsChanged();
		136	void localInternalChanged();
		137	void localLeavesChanged();
		138	void timingStatsChanged();
53		139
54	int _lastHorizontalOffset;	140	private:
55		141	int _recentMaxPackets{ 0 } ; // recent max incoming voxel packets to process
56	RenderDetails _renderDetails;	142	bool _resetRecentMaxPacketsSoon{ true };
		143	bool _expanded{ false };
		144	bool _timingExpanded{ false };
		145	QString _monospaceFont;
57	};	146	};
58		147
59	#endif // hifi_Stats_h	148	#endif // hifi_Stats_h

interface/src/ui/UserInputMapper.cpp+1−1

@@ -53,7 +53,7 @@ void UserInputMapper::resetDevice(uint16 deviceID) { · 52 unmodified lines
53		53
54	int UserInputMapper::findDevice(QString name) {	54	int UserInputMapper::findDevice(QString name) {
55	for (auto device : _registeredDevices) {	55	for (auto device : _registeredDevices) {
56	if (device.second->_name == name) {	56	if (device.second->_name.split(" (")[0] == name) {
57	return device.first;	57	return device.first;
58	}	58	}
59	}	59	}

interface/src/ui/overlays/Circle3DOverlay.cpp+161−181

@@ -11,6 +11,7 @@ · 10 unmodified lines
11	// include this before QGLWidget, which includes an earlier version of OpenGL	11	// include this before QGLWidget, which includes an earlier version of OpenGL
12	#include "InterfaceConfig.h"	12	#include "InterfaceConfig.h"
13		13
		14	#include <DeferredLightingEffect.h>
14	#include <GeometryCache.h>	15	#include <GeometryCache.h>
15	#include <GlowEffect.h>	16	#include <GlowEffect.h>
16	#include <SharedUtil.h>	17	#include <SharedUtil.h>
@@ -75,20 +76,20 @@ void Circle3DOverlay::render(RenderArgs* args) { · 58 unmodified lines
75		76
76	float alpha = getAlpha();	77	float alpha = getAlpha();
77		78
78	if (alpha == 0.0) {	79	if (alpha == 0.0f) {
79	return; // do nothing if our alpha is 0, we're not visible	80	return; // do nothing if our alpha is 0, we're not visible
80	}	81	}
81		82
82	// Create the circle in the coordinates origin	83	// Create the circle in the coordinates origin
83	float outerRadius = getOuterRadius();	84	float outerRadius = getOuterRadius();
84	float innerRadius = getInnerRadius(); // only used in solid case	85	float innerRadius = getInnerRadius(); // only used in solid case
85	float startAt = getStartAt();	86	float startAt = getStartAt();
86	float endAt = getEndAt();	87	float endAt = getEndAt();
87		88
88	bool geometryChanged = (startAt != _lastStartAt \|\| endAt != _lastEndAt \|\|	89	bool geometryChanged = (startAt != _lastStartAt \|\| endAt != _lastEndAt \|\|
89	innerRadius != _lastInnerRadius \|\| outerRadius != _lastOuterRadius);	90	innerRadius != _lastInnerRadius \|\| outerRadius != _lastOuterRadius);
90		91
91		92
92	const float FULL_CIRCLE = 360.0f;	93	const float FULL_CIRCLE = 360.0f;
93	const float SLICES = 180.0f; // The amount of segment to create the circle	94	const float SLICES = 180.0f; // The amount of segment to create the circle
94	const float SLICE_ANGLE = FULL_CIRCLE / SLICES;	95	const float SLICE_ANGLE = FULL_CIRCLE / SLICES;
@@ -101,195 +102,178 @@ void Circle3DOverlay::render(RenderArgs* args) { · 6 unmodified lines
101	bool colorChanged = colorX.red != _lastColor.red \|\| colorX.green != _lastColor.green \|\| colorX.blue != _lastColor.blue;	102	bool colorChanged = colorX.red != _lastColor.red \|\| colorX.green != _lastColor.green \|\| colorX.blue != _lastColor.blue;
102	_lastColor = colorX;	103	_lastColor = colorX;
103		104
104	glDisable(GL_LIGHTING);	105	auto geometryCache = DependencyManager::get<GeometryCache>();
105
106	glm::vec3 position = getPosition();
107	glm::vec3 center = getCenter();
108	glm::vec2 dimensions = getDimensions();
109	glm::quat rotation = getRotation();
110
111	float glowLevel = getGlowLevel();
112	Glower* glower = NULL;
113	if (glowLevel > 0.0f) {
114	glower = new Glower(glowLevel);
115	}
116
117	glPushMatrix();
118	glTranslatef(position.x, position.y, position.z);
119	glm::vec3 axis = glm::axis(rotation);
120	glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
121	glPushMatrix();
122	glm::vec3 positionToCenter = center - position;
123	glTranslatef(positionToCenter.x, positionToCenter.y, positionToCenter.z);
124	glScalef(dimensions.x / 2.0f, dimensions.y / 2.0f, 1.0f);
125		106
126	glLineWidth(_lineWidth);	107	Transform transform;
127		108	transform.setTranslation(getCenter());
128	auto geometryCache = DependencyManager::get<GeometryCache>();	109	transform.setRotation(getRotation());
		110	transform.setScale(glm::vec3(getDimensions(), 0.01f));
		111
		112
		113	auto& batch = *args->_batch;
		114	batch._glLineWidth(_lineWidth);
		115	batch.setModelTransform(transform);
		116	DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(batch, false, false);
		117
		118	// for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise
		119	// we just draw a line...
		120	if (getIsSolid()) {
		121	if (_quadVerticesID == GeometryCache::UNKNOWN_ID) {
		122	_quadVerticesID = geometryCache->allocateID();
		123	}
		124
		125	if (geometryChanged \|\| colorChanged) {
129		126
130	// for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise	127	QVector<glm::vec2> points;
131	// we just draw a line...	128
132	if (getIsSolid()) {	129	float angle = startAt;
133	if (_quadVerticesID == GeometryCache::UNKNOWN_ID) {	130	float angleInRadians = glm::radians(angle);
134	_quadVerticesID = geometryCache->allocateID();	131	glm::vec2 firstInnerPoint(cosf(angleInRadians) * innerRadius, sinf(angleInRadians) * innerRadius);
135	}	132	glm::vec2 firstOuterPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
		133
		134	points << firstInnerPoint << firstOuterPoint;
		135
		136	while (angle < endAt) {
		137	angleInRadians = glm::radians(angle);
		138	glm::vec2 thisInnerPoint(cosf(angleInRadians) * innerRadius, sinf(angleInRadians) * innerRadius);
		139	glm::vec2 thisOuterPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
136		140
137	if (geometryChanged \|\| colorChanged) {	141	points << thisOuterPoint << thisInnerPoint;
138
139	QVector<glm::vec2> points;
140
141	float angle = startAt;
142	float angleInRadians = glm::radians(angle);
143	glm::vec2 firstInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);
144	glm::vec2 firstOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
145
146	points << firstInnerPoint << firstOuterPoint;
147
148	while (angle < endAt) {
149	angleInRadians = glm::radians(angle);
150	glm::vec2 thisInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);
151	glm::vec2 thisOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
152
153	points << thisOuterPoint << thisInnerPoint;
154		142
155	angle += SLICE_ANGLE;	143	angle += SLICE_ANGLE;
156	}	144	}
157		145
158	// get the last slice portion....	146	// get the last slice portion....
159	angle = endAt;	147	angle = endAt;
160	angleInRadians = glm::radians(angle);	148	angleInRadians = glm::radians(angle);
161	glm::vec2 lastInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);	149	glm::vec2 lastInnerPoint(cosf(angleInRadians) * innerRadius, sinf(angleInRadians) * innerRadius);
162	glm::vec2 lastOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);	150	glm::vec2 lastOuterPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
163		151
164	points << lastOuterPoint << lastInnerPoint;	152	points << lastOuterPoint << lastInnerPoint;
165
166	geometryCache->updateVertices(_quadVerticesID, points, color);
167	}
168
169	geometryCache->renderVertices(gpu::QUAD_STRIP, _quadVerticesID);
170
171	} else {
172	if (_lineVerticesID == GeometryCache::UNKNOWN_ID) {
173	_lineVerticesID = geometryCache->allocateID();
174	}
175
176	if (geometryChanged \|\| colorChanged) {
177	QVector<glm::vec2> points;
178
179	float angle = startAt;
180	float angleInRadians = glm::radians(angle);
181	glm::vec2 firstPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
182	points << firstPoint;
183
184	while (angle < endAt) {
185	angle += SLICE_ANGLE;
186	angleInRadians = glm::radians(angle);
187	glm::vec2 thisPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
188	points << thisPoint;
189
190	if (getIsDashedLine()) {
191	angle += SLICE_ANGLE / 2.0f; // short gap
192	angleInRadians = glm::radians(angle);
193	glm::vec2 dashStartPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
194	points << dashStartPoint;
195	}
196	}
197		153
198	// get the last slice portion....	154	geometryCache->updateVertices(_quadVerticesID, points, color);
199	angle = endAt;	155	}
200	angleInRadians = glm::radians(angle);	156
201	glm::vec2 lastPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);	157	geometryCache->renderVertices(batch, gpu::QUAD_STRIP, _quadVerticesID);
202	points << lastPoint;	158
203		159	} else {
204	geometryCache->updateVertices(_lineVerticesID, points, color);	160	if (_lineVerticesID == GeometryCache::UNKNOWN_ID) {
205	}	161	_lineVerticesID = geometryCache->allocateID();
206		162	}
		163
		164	if (geometryChanged \|\| colorChanged) {
		165	QVector<glm::vec2> points;
		166
		167	float angle = startAt;
		168	float angleInRadians = glm::radians(angle);
		169	glm::vec2 firstPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
		170	points << firstPoint;
		171
		172	while (angle < endAt) {
		173	angle += SLICE_ANGLE;
		174	angleInRadians = glm::radians(angle);
		175	glm::vec2 thisPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
		176	points << thisPoint;
		177
207	if (getIsDashedLine()) {	178	if (getIsDashedLine()) {
208	geometryCache->renderVertices(gpu::LINES, _lineVerticesID);	179	angle += SLICE_ANGLE / 2.0f; // short gap
209	} else {	180	angleInRadians = glm::radians(angle);
210	geometryCache->renderVertices(gpu::LINE_STRIP, _lineVerticesID);	181	glm::vec2 dashStartPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
		182	points << dashStartPoint;
211	}	183	}
212	}	184	}
213		185
214	// draw our tick marks	186	// get the last slice portion....
215	// for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise	187	angle = endAt;
216	// we just draw a line...	188	angleInRadians = glm::radians(angle);
217	if (getHasTickMarks()) {	189	glm::vec2 lastPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
218		190	points << lastPoint;
219	if (_majorTicksVerticesID == GeometryCache::UNKNOWN_ID) {	191
220	_majorTicksVerticesID = geometryCache->allocateID();	192	geometryCache->updateVertices(_lineVerticesID, points, color);
221	}	193	}
222	if (_minorTicksVerticesID == GeometryCache::UNKNOWN_ID) {	194
223	_minorTicksVerticesID = geometryCache->allocateID();	195	if (getIsDashedLine()) {
224	}	196	geometryCache->renderVertices(batch, gpu::LINES, _lineVerticesID);
225		197	} else {
226	if (geometryChanged) {	198	geometryCache->renderVertices(batch, gpu::LINE_STRIP, _lineVerticesID);
227	QVector<glm::vec2> majorPoints;	199	}
228	QVector<glm::vec2> minorPoints;	200	}
229		201
230	// draw our major tick marks	202	// draw our tick marks
231	if (getMajorTickMarksAngle() > 0.0f && getMajorTickMarksLength() != 0.0f) {	203	// for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise
		204	// we just draw a line...
		205	if (getHasTickMarks()) {
		206
		207	if (_majorTicksVerticesID == GeometryCache::UNKNOWN_ID) {
		208	_majorTicksVerticesID = geometryCache->allocateID();
		209	}
		210	if (_minorTicksVerticesID == GeometryCache::UNKNOWN_ID) {
		211	_minorTicksVerticesID = geometryCache->allocateID();
		212	}
		213
		214	if (geometryChanged) {
		215	QVector<glm::vec2> majorPoints;
		216	QVector<glm::vec2> minorPoints;
		217
		218	// draw our major tick marks
		219	if (getMajorTickMarksAngle() > 0.0f && getMajorTickMarksLength() != 0.0f) {
232		220
233	float tickMarkAngle = getMajorTickMarksAngle();	221	float tickMarkAngle = getMajorTickMarksAngle();
234	float angle = startAt - fmod(startAt, tickMarkAngle) + tickMarkAngle;	222	float angle = startAt - fmodf(startAt, tickMarkAngle) + tickMarkAngle;
235	float angleInRadians = glm::radians(angle);	223	float angleInRadians = glm::radians(angle);
236	float tickMarkLength = getMajorTickMarksLength();	224	float tickMarkLength = getMajorTickMarksLength();
237	float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;	225	float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;
238	float endRadius = startRadius + tickMarkLength;	226	float endRadius = startRadius + tickMarkLength;
239
240	while (angle <= endAt) {
241	angleInRadians = glm::radians(angle);
242
243	glm::vec2 thisPointA(cos(angleInRadians) * startRadius, sin(angleInRadians) * startRadius);
244	glm::vec2 thisPointB(cos(angleInRadians) * endRadius, sin(angleInRadians) * endRadius);
245
246	majorPoints << thisPointA << thisPointB;
247		227
248	angle += tickMarkAngle;	228	while (angle <= endAt) {
249	}	229	angleInRadians = glm::radians(angle);
250	}	230
251		231	glm::vec2 thisPointA(cosf(angleInRadians) * startRadius, sinf(angleInRadians) * startRadius);
252	// draw our minor tick marks	232	glm::vec2 thisPointB(cosf(angleInRadians) * endRadius, sinf(angleInRadians) * endRadius);
253	if (getMinorTickMarksAngle() > 0.0f && getMinorTickMarksLength() != 0.0f) {	233
		234	majorPoints << thisPointA << thisPointB;
		235
		236	angle += tickMarkAngle;
		237	}
		238	}
		239
		240	// draw our minor tick marks
		241	if (getMinorTickMarksAngle() > 0.0f && getMinorTickMarksLength() != 0.0f) {
254		242
255	float tickMarkAngle = getMinorTickMarksAngle();	243	float tickMarkAngle = getMinorTickMarksAngle();
256	float angle = startAt - fmod(startAt, tickMarkAngle) + tickMarkAngle;	244	float angle = startAt - fmodf(startAt, tickMarkAngle) + tickMarkAngle;
257	float angleInRadians = glm::radians(angle);	245	float angleInRadians = glm::radians(angle);
258	float tickMarkLength = getMinorTickMarksLength();	246	float tickMarkLength = getMinorTickMarksLength();
259	float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;	247	float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;
260	float endRadius = startRadius + tickMarkLength;	248	float endRadius = startRadius + tickMarkLength;
261
262	while (angle <= endAt) {
263	angleInRadians = glm::radians(angle);
264
265	glm::vec2 thisPointA(cos(angleInRadians) * startRadius, sin(angleInRadians) * startRadius);
266	glm::vec2 thisPointB(cos(angleInRadians) * endRadius, sin(angleInRadians) * endRadius);
267
268	minorPoints << thisPointA << thisPointB;
269		249
270	angle += tickMarkAngle;	250	while (angle <= endAt) {
271	}	251	angleInRadians = glm::radians(angle);
272	}	252
273		253	glm::vec2 thisPointA(cosf(angleInRadians) * startRadius, sinf(angleInRadians) * startRadius);
274	xColor majorColorX = getMajorTickMarksColor();	254	glm::vec2 thisPointB(cosf(angleInRadians) * endRadius, sinf(angleInRadians) * endRadius);
275	glm::vec4 majorColor(majorColorX.red / MAX_COLOR, majorColorX.green / MAX_COLOR, majorColorX.blue / MAX_COLOR, alpha);	255
276		256	minorPoints << thisPointA << thisPointB;
277	geometryCache->updateVertices(_majorTicksVerticesID, majorPoints, majorColor);	257
278		258	angle += tickMarkAngle;
279	xColor minorColorX = getMinorTickMarksColor();
280	glm::vec4 minorColor(minorColorX.red / MAX_COLOR, minorColorX.green / MAX_COLOR, minorColorX.blue / MAX_COLOR, alpha);
281
282	geometryCache->updateVertices(_minorTicksVerticesID, minorPoints, minorColor);
283	}	259	}
284
285	geometryCache->renderVertices(gpu::LINES, _majorTicksVerticesID);
286
287	geometryCache->renderVertices(gpu::LINES, _minorTicksVerticesID);
288	}	260	}
289		261
290		262	xColor majorColorX = getMajorTickMarksColor();
291	glPopMatrix();	263	glm::vec4 majorColor(majorColorX.red / MAX_COLOR, majorColorX.green / MAX_COLOR, majorColorX.blue / MAX_COLOR, alpha);
292	glPopMatrix();	264
		265	geometryCache->updateVertices(_majorTicksVerticesID, majorPoints, majorColor);
		266
		267	xColor minorColorX = getMinorTickMarksColor();
		268	glm::vec4 minorColor(minorColorX.red / MAX_COLOR, minorColorX.green / MAX_COLOR, minorColorX.blue / MAX_COLOR, alpha);
		269
		270	geometryCache->updateVertices(_minorTicksVerticesID, minorPoints, minorColor);
		271	}
		272
		273	geometryCache->renderVertices(batch, gpu::LINES, _majorTicksVerticesID);
		274
		275	geometryCache->renderVertices(batch, gpu::LINES, _minorTicksVerticesID);
		276	}
293		277
294	if (geometryChanged) {	278	if (geometryChanged) {
295	_lastStartAt = startAt;	279	_lastStartAt = startAt;
@@ -297,15 +281,11 @@ void Circle3DOverlay::render(RenderArgs* args) { · 1 unmodified line
297	_lastInnerRadius = innerRadius;	281	_lastInnerRadius = innerRadius;
298	_lastOuterRadius = outerRadius;	282	_lastOuterRadius = outerRadius;
299	}	283	}
300
301	if (glower) {
302	delete glower;
303	}
304	}	284	}
305		285
306	void Circle3DOverlay::setProperties(const QScriptValue &properties) {	286	void Circle3DOverlay::setProperties(const QScriptValue &properties) {
307	Planar3DOverlay::setProperties(properties);	287	Planar3DOverlay::setProperties(properties);
308		288
309	QScriptValue startAt = properties.property("startAt");	289	QScriptValue startAt = properties.property("startAt");
310	if (startAt.isValid()) {	290	if (startAt.isValid()) {
311	setStartAt(startAt.toVariant().toFloat());	291	setStartAt(startAt.toVariant().toFloat());
@@ -415,7 +395,7 @@ QScriptValue Circle3DOverlay::getProperty(const QString& property) { · 103 unmodified lines
415	}	395	}
416		396
417		397
418	bool Circle3DOverlay::findRayIntersection(const glm::vec3& origin,	398	bool Circle3DOverlay::findRayIntersection(const glm::vec3& origin,
419	const glm::vec3& direction, float& distance, BoxFace& face) {	399	const glm::vec3& direction, float& distance, BoxFace& face) {
420		400
421	bool intersects = Planar3DOverlay::findRayIntersection(origin, direction, distance, face);	401	bool intersects = Planar3DOverlay::findRayIntersection(origin, direction, distance, face);

interface/src/ui/overlays/Line3DOverlay.cpp+10−0

@@ -32,6 +32,16 @@ Line3DOverlay::Line3DOverlay(const Line3DOverlay* line3DOverlay) : · 31 unmodified lines
32	Line3DOverlay::~Line3DOverlay() {	32	Line3DOverlay::~Line3DOverlay() {
33	}	33	}
34		34
		35	AABox Line3DOverlay::getBounds() const {
		36	auto start = _position + _start;
		37	auto end = _position + _end;
		38
		39	auto min = glm::min(start, end);
		40	auto max = glm::max(start, end);
		41
		42	return AABox(min, max - min);
		43	}
		44
35	void Line3DOverlay::render(RenderArgs* args) {	45	void Line3DOverlay::render(RenderArgs* args) {
36	if (!_visible) {	46	if (!_visible) {
37	return; // do nothing if we're not visible	47	return; // do nothing if we're not visible

interface/src/ui/overlays/Line3DOverlay.h+1−0

@@ -21,6 +21,7 @@ public: · 20 unmodified lines
21	Line3DOverlay(const Line3DOverlay* line3DOverlay);	21	Line3DOverlay(const Line3DOverlay* line3DOverlay);
22	~Line3DOverlay();	22	~Line3DOverlay();
23	virtual void render(RenderArgs* args);	23	virtual void render(RenderArgs* args);
		24	virtual AABox getBounds() const override;
24		25
25	// getters	26	// getters
26	const glm::vec3& getStart() const { return _start; }	27	const glm::vec3& getStart() const { return _start; }

interface/src/ui/overlays/Overlays.cpp+1−1

@@ -258,7 +258,7 @@ void Overlays::deleteOverlay(unsigned int id) { · 257 unmodified lines
258	unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {	258	unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
259	glm::vec2 pointCopy = point;	259	glm::vec2 pointCopy = point;
260	if (qApp->isHMDMode()) {	260	if (qApp->isHMDMode()) {
261	pointCopy = qApp->getApplicationOverlay().screenToOverlay(point);	261	pointCopy = qApp->getApplicationCompositor().screenToOverlay(point);
262	}	262	}
263		263
264	QReadLocker lock(&_lock);	264	QReadLocker lock(&_lock);

interface/src/ui/overlays/TextOverlay.cpp+1−0

@@ -80,6 +80,7 @@ void TextOverlay::render(RenderArgs* args) { · 79 unmodified lines
80		80
81	glm::vec2 topLeft(left, top);	81	glm::vec2 topLeft(left, top);
82	glm::vec2 bottomRight(right, bottom);	82	glm::vec2 bottomRight(right, bottom);
		83	glBindTexture(GL_TEXTURE_2D, 0);
83	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, quadColor);	84	DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, quadColor);
84		85
85	const int leftAdjust = -1; // required to make text render relative to left edge of bounds	86	const int leftAdjust = -1; // required to make text render relative to left edge of bounds

libraries/audio-client/src/AudioClient.cpp+24−1

 #include <QtMultimedia/QAudioInput>
 #include <QtMultimedia/QAudioOutput>
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdouble-promotion"
+#endif
 extern "C" {
     #include <gverb/gverb.h>
     #include <gverb/gverbdsp.h>
 }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 #include <soxr.h>
 #include <NodeList.h>
             delete[] inputAudioSamples;
+            //  Remove DC offset
+            if (!_isStereoInput && !_audioSourceInjectEnabled) {
+                _inputGate.removeDCOffset(networkAudioSamples, numNetworkSamples);
+            }
             // only impose the noise gate and perform tone injection if we are sending mono audio
             if (!_isStereoInput && !_audioSourceInjectEnabled && _isNoiseGateEnabled) {
                 _inputGate.gateSamples(networkAudioSamples, numNetworkSamples);
         localOutput->moveToThread(injector->getLocalBuffer()->thread());
         // have it be stopped when that local buffer is about to close
-        connect(injector->getLocalBuffer(), &AudioInjectorLocalBuffer::bufferEmpty, localOutput, &QAudioOutput::stop);
+        connect(localOutput, &QAudioOutput::stateChanged, this, &AudioClient::audioStateChanged);
+        connect(this, &AudioClient::audioFinished, localOutput, &QAudioOutput::stop);
+        connect(this, &AudioClient::audioFinished, injector, &AudioInjector::stop);
         connect(injector->getLocalBuffer(), &QIODevice::aboutToClose, localOutput, &QAudioOutput::stop);
         qCDebug(audioclient) << "Starting QAudioOutput for local injector" << localOutput;
     windowSecondsForDesiredReduction.set(_receivedAudioStream.getWindowSecondsForDesiredReduction());
     repetitionWithFade.set(_receivedAudioStream.getRepetitionWithFade());
 }
+void AudioClient::audioStateChanged(QAudio::State state) {
+    if (state == QAudio::IdleState) {
+        emit audioFinished();
+    }
+}

libraries/audio-client/src/AudioClient.h+6−1

     QString getDefaultDeviceName(QAudio::Mode mode);
     QVector<QString> getDeviceNames(QAudio::Mode mode);
-    float getInputVolume() const { return (_audioInput) ? _audioInput->volume() : 0.0f; }
+    float getInputVolume() const { return (_audioInput) ? (float)_audioInput->volume() : 0.0f; }
     void setInputVolume(float volume) { if (_audioInput) _audioInput->setVolume(volume); }
     void setReverb(bool reverb);
     void setReverbOptions(const AudioEffectOptions* options);
     void receivedFirstPacket();
     void disconnected();
+    void audioFinished();
 protected:
     AudioClient();
     ~AudioClient();
         deleteLater();
     }
+private slots:
+    void audioStateChanged(QAudio::State state);
 private:
     void outputFormatChanged();

libraries/audio-client/src/AudioNoiseGate.cpp+28−15

@@ -33,6 +33,32 @@ AudioNoiseGate::AudioNoiseGate() : · 32 unmodified lines
33		33
34	}	34	}
35		35
		36	void AudioNoiseGate::removeDCOffset(int16_t* samples, int numSamples) {
		37	//
		38	// DC Offset correction
		39	//
		40	// Measure the DC offset over a trailing number of frames, and remove it from the input signal.
		41	// This causes the noise background measurements and server muting to be more accurate. Many off-board
		42	// ADC's have a noticeable DC offset.
		43	//
		44	const float DC_OFFSET_AVERAGING = 0.99f;
		45	float measuredDcOffset = 0.0f;
		46	// Remove trailing DC offset from samples
		47	for (int i = 0; i < numSamples; i++) {
		48	measuredDcOffset += samples[i];
		49	samples[i] -= (int16_t) _dcOffset;
		50	}
		51	// Update measured DC offset
		52	measuredDcOffset /= numSamples;
		53	if (_dcOffset == 0.0f) {
		54	// On first frame, copy over measured offset
		55	_dcOffset = measuredDcOffset;
		56	} else {
		57	_dcOffset = DC_OFFSET_AVERAGING * _dcOffset + (1.0f - DC_OFFSET_AVERAGING) * measuredDcOffset;
		58	}
		59	}
		60
		61
36	void AudioNoiseGate::gateSamples(int16_t* samples, int numSamples) {	62	void AudioNoiseGate::gateSamples(int16_t* samples, int numSamples) {
37	//	63	//
38	// Impose Noise Gate	64	// Impose Noise Gate
@@ -61,17 +87,12 @@ void AudioNoiseGate::gateSamples(int16_t* samples, int numSamples) { · 22 unmodified lines
61	const int NOISE_GATE_WIDTH = 5;	87	const int NOISE_GATE_WIDTH = 5;
62	const int NOISE_GATE_CLOSE_FRAME_DELAY = 5;	88	const int NOISE_GATE_CLOSE_FRAME_DELAY = 5;
63	const int NOISE_GATE_FRAMES_TO_AVERAGE = 5;	89	const int NOISE_GATE_FRAMES_TO_AVERAGE = 5;
64	const float DC_OFFSET_AVERAGING = 0.99f;	90
65		91	// Check clipping, and check if should open noise gate
66	// Check clipping, adjust DC offset, and check if should open noise gate
67	float measuredDcOffset = 0.0f;
68	_didClipInLastFrame = false;	92	_didClipInLastFrame = false;
69		93
70	for (int i = 0; i < numSamples; i++) {	94	for (int i = 0; i < numSamples; i++) {
71	measuredDcOffset += samples[i];
72	samples[i] -= (int16_t) _dcOffset;
73	thisSample = std::abs(samples[i]);	95	thisSample = std::abs(samples[i]);
74
75	if (thisSample >= ((float) AudioConstants::MAX_SAMPLE_VALUE * CLIPPING_THRESHOLD)) {	96	if (thisSample >= ((float) AudioConstants::MAX_SAMPLE_VALUE * CLIPPING_THRESHOLD)) {
76	_didClipInLastFrame = true;	97	_didClipInLastFrame = true;
77	}	98	}
@@ -83,14 +104,6 @@ void AudioNoiseGate::gateSamples(int16_t* samples, int numSamples) { · 5 unmodified lines
83	}	104	}
84	}	105	}
85		106
86	measuredDcOffset /= numSamples;
87	if (_dcOffset == 0.0f) {
88	// On first frame, copy over measured offset
89	_dcOffset = measuredDcOffset;
90	} else {
91	_dcOffset = DC_OFFSET_AVERAGING * _dcOffset + (1.0f - DC_OFFSET_AVERAGING) * measuredDcOffset;
92	}
93
94	_lastLoudness = fabs(loudness / numSamples);	107	_lastLoudness = fabs(loudness / numSamples);
95		108
96	if (_quietestFrame > _lastLoudness) {	109	if (_quietestFrame > _lastLoudness) {

libraries/audio-client/src/AudioNoiseGate.h+1−0

@@ -21,6 +21,7 @@ public: · 20 unmodified lines
21	AudioNoiseGate();	21	AudioNoiseGate();
22		22
23	void gateSamples(int16_t* samples, int numSamples);	23	void gateSamples(int16_t* samples, int numSamples);
		24	void removeDCOffset(int16_t* samples, int numSamples);
24		25
25	bool clippedInLastFrame() const { return _didClipInLastFrame; }	26	bool clippedInLastFrame() const { return _didClipInLastFrame; }
26	float getMeasuredFloor() const { return _measuredFloor; }	27	float getMeasuredFloor() const { return _measuredFloor; }

libraries/audio/CMakeLists.txt+7−1

@@ -7,4 +7,10 @@ add_dependency_external_projects(glm) · 6 unmodified lines
7	find_package(GLM REQUIRED)	7	find_package(GLM REQUIRED)
8	target_include_directories(${TARGET_NAME} PUBLIC ${GLM_INCLUDE_DIRS})	8	target_include_directories(${TARGET_NAME} PUBLIC ${GLM_INCLUDE_DIRS})
9		9
10	link_hifi_libraries(networking shared)	10	# we use libsoxr for resampling
		11	add_dependency_external_projects(soxr)
		12	find_package(Soxr REQUIRED)
		13	target_link_libraries(${TARGET_NAME} ${SOXR_LIBRARIES})
		14	target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${SOXR_INCLUDE_DIRS})
		15
		16	link_hifi_libraries(networking shared)

libraries/audio/src/AudioInjector.cpp+65−4

@@ -16,10 +16,12 @@ · 15 unmodified lines
16	#include <PacketHeaders.h>	16	#include <PacketHeaders.h>
17	#include <SharedUtil.h>	17	#include <SharedUtil.h>
18	#include <UUID.h>	18	#include <UUID.h>
		19	#include <soxr.h>
19		20
20	#include "AbstractAudioInterface.h"	21	#include "AbstractAudioInterface.h"
21	#include "AudioRingBuffer.h"	22	#include "AudioRingBuffer.h"
22	#include "AudioLogging.h"	23	#include "AudioLogging.h"
		24	#include "SoundCache.h"
23		25
24	#include "AudioInjector.h"	26	#include "AudioInjector.h"
25		27
@@ -60,7 +62,6 @@ void AudioInjector::setIsFinished(bool isFinished) { · 34 unmodified lines
60		62
61	if (_shouldDeleteAfterFinish) {	63	if (_shouldDeleteAfterFinish) {
62	// we've been asked to delete after finishing, trigger a queued deleteLater here	64	// we've been asked to delete after finishing, trigger a queued deleteLater here
63	qCDebug(audio) << "AudioInjector triggering delete from setIsFinished";
64	QMetaObject::invokeMethod(this, "deleteLater", Qt::QueuedConnection);	65	QMetaObject::invokeMethod(this, "deleteLater", Qt::QueuedConnection);
65	}	66	}
66	}	67	}
@@ -122,9 +123,6 @@ void AudioInjector::injectLocally() { · 55 unmodified lines
122		123
123	success = _localAudioInterface->outputLocalInjector(_options.stereo, this);	124	success = _localAudioInterface->outputLocalInjector(_options.stereo, this);
124		125
125	// if we're not looping and the buffer tells us it is empty then emit finished
126	connect(_localBuffer, &AudioInjectorLocalBuffer::bufferEmpty, this, &AudioInjector::stop);
127
128	if (!success) {	126	if (!success) {
129	qCDebug(audio) << "AudioInjector::injectLocally could not output locally via _localAudioInterface";	127	qCDebug(audio) << "AudioInjector::injectLocally could not output locally via _localAudioInterface";
130	}	128	}
@@ -288,3 +286,66 @@ void AudioInjector::stopAndDeleteLater() { · 157 unmodified lines
288	stop();	286	stop();
289	QMetaObject::invokeMethod(this, "deleteLater", Qt::QueuedConnection);	287	QMetaObject::invokeMethod(this, "deleteLater", Qt::QueuedConnection);
290	}	288	}
		289
		290	AudioInjector* AudioInjector::playSound(const QString& soundUrl, const float volume, const float stretchFactor, const glm::vec3 position) {
		291	if (soundUrl.isEmpty()) {
		292	return NULL;
		293	}
		294	auto soundCache = DependencyManager::get<SoundCache>();
		295	if (soundCache.isNull()) {
		296	return NULL;
		297	}
		298	SharedSoundPointer sound = soundCache.data()->getSound(QUrl(soundUrl));
		299	if (sound.isNull() \|\| !sound->isReady()) {
		300	return NULL;
		301	}
		302
		303	AudioInjectorOptions options;
		304	options.stereo = sound->isStereo();
		305	options.position = position;
		306	options.volume = volume;
		307
		308	QByteArray samples = sound->getByteArray();
		309	if (stretchFactor == 1.0f) {
		310	return playSound(samples, options, NULL);
		311	}
		312
		313	soxr_io_spec_t spec = soxr_io_spec(SOXR_INT16_I, SOXR_INT16_I);
		314	soxr_quality_spec_t qualitySpec = soxr_quality_spec(SOXR_MQ, 0);
		315	const int channelCount = sound->isStereo() ? 2 : 1;
		316	const int standardRate = AudioConstants::SAMPLE_RATE;
		317	const int resampledRate = standardRate * stretchFactor;
		318	const int nInputSamples = samples.size() / sizeof(int16_t);
		319	const int nOutputSamples = nInputSamples * stretchFactor;
		320	QByteArray resampled(nOutputSamples * sizeof(int16_t), '\0');
		321	const int16_t* receivedSamples = reinterpret_cast<const int16_t*>(samples.data());
		322	soxr_error_t soxError = soxr_oneshot(standardRate, resampledRate, channelCount,
		323	receivedSamples, nInputSamples, NULL,
		324	reinterpret_cast<int16_t*>(resampled.data()), nOutputSamples, NULL,
		325	&spec, &qualitySpec, 0);
		326	if (soxError) {
		327	qCDebug(audio) << "Unable to resample" << soundUrl << "from" << nInputSamples << "@" << standardRate << "to" << nOutputSamples << "@" << resampledRate;
		328	resampled = samples;
		329	}
		330	return playSound(resampled, options, NULL);
		331	}
		332
		333	AudioInjector* AudioInjector::playSound(const QByteArray& buffer, const AudioInjectorOptions options, AbstractAudioInterface* localInterface) {
		334	QThread* injectorThread = new QThread();
		335	injectorThread->setObjectName("Audio Injector Thread");
		336
		337	AudioInjector* injector = new AudioInjector(buffer, options);
		338	injector->setLocalAudioInterface(localInterface);
		339
		340	injector->moveToThread(injectorThread);
		341
		342	// start injecting when the injector thread starts
		343	connect(injectorThread, &QThread::started, injector, &AudioInjector::injectAudio);
		344
		345	// connect the right slots and signals for AudioInjector and thread cleanup
		346	connect(injector, &AudioInjector::destroyed, injectorThread, &QThread::quit);
		347	connect(injectorThread, &QThread::finished, injectorThread, &QThread::deleteLater);
		348
		349	injectorThread->start();
		350	return injector;
		351	}

libraries/audio/src/AudioInjector.h+4−0

@@ -45,6 +45,10 @@ public: · 44 unmodified lines
45	bool isLocalOnly() const { return _options.localOnly; }	45	bool isLocalOnly() const { return _options.localOnly; }
46		46
47	void setLocalAudioInterface(AbstractAudioInterface* localAudioInterface) { _localAudioInterface = localAudioInterface; }	47	void setLocalAudioInterface(AbstractAudioInterface* localAudioInterface) { _localAudioInterface = localAudioInterface; }
		48
		49	static AudioInjector* playSound(const QByteArray& buffer, const AudioInjectorOptions options, AbstractAudioInterface* localInterface);
		50	static AudioInjector* playSound(const QString& soundUrl, const float volume, const float stretchFactor, const glm::vec3 position);
		51
48	public slots:	52	public slots:
49	void injectAudio();	53	void injectAudio();
50	void restart();	54	void restart();

libraries/audio/src/AudioInjectorLocalBuffer.cpp+1−4

             _currentOffset += bytesRead;
         }
-        if (!_shouldLoop && bytesRead == bytesToEnd) {
+        if (_shouldLoop && _currentOffset == _rawAudioArray.size()) {
-            // we hit the end of the buffer, emit a signal
-            emit bufferEmpty();
-        } else if (_shouldLoop && _currentOffset == _rawAudioArray.size()) {
             _currentOffset = 0;
         }

libraries/audio/src/AudioInjectorLocalBuffer.h+0−3

@@ -32,9 +32,6 @@ public: · 31 unmodified lines
32	void setCurrentOffset(int currentOffset) { _currentOffset = currentOffset; }	32	void setCurrentOffset(int currentOffset) { _currentOffset = currentOffset; }
33	void setVolume(float volume) { _volume = glm::clamp(volume, 0.0f, 1.0f); }	33	void setVolume(float volume) { _volume = glm::clamp(volume, 0.0f, 1.0f); }
34		34
35	signals:
36	void bufferEmpty();
37
38	private:	35	private:
39	qint64 recursiveReadFromFront(char* data, qint64 maxSize);	36	qint64 recursiveReadFromFront(char* data, qint64 maxSize);
40		37

libraries/audio/src/AudioRingBuffer.cpp+1−1

@@ -211,7 +211,7 @@ float AudioRingBuffer::getFrameLoudness(const int16_t* frameStart) const { · 210 unmodified lines
211	const int16_t* _bufferLastAt = _buffer + _bufferLength - 1;	211	const int16_t* _bufferLastAt = _buffer + _bufferLength - 1;
212		212
213	for (int i = 0; i < _numFrameSamples; ++i) {	213	for (int i = 0; i < _numFrameSamples; ++i) {
214	loudness += std::abs(*sampleAt);	214	loudness += (float) std::abs(*sampleAt);
215	sampleAt = sampleAt == _bufferLastAt ? _buffer : sampleAt + 1;	215	sampleAt = sampleAt == _bufferLastAt ? _buffer : sampleAt + 1;
216	}	216	}
217	loudness /= _numFrameSamples;	217	loudness /= _numFrameSamples;

libraries/avatars/src/AvatarData.cpp+2−3

     _headData(NULL),
     _handData(NULL),
     _faceModelURL("http://invalid.com"),
-    _displayNameBoundingRect(),
+    _displayNameTargetAlpha(1.0f),
-    _displayNameTargetAlpha(0.0f),
+    _displayNameAlpha(1.0f),
-    _displayNameAlpha(0.0f),
     _billboard(),
     _errorLogExpiry(0),
     _owningAvatarMixer(),

libraries/avatars/src/AvatarData.h+1−2

     AvatarData();
     virtual ~AvatarData();
-    virtual bool isMyAvatar() { return false; }
+    virtual bool isMyAvatar() const { return false; }
     const QUuid& getSessionUUID() const { return _sessionUUID; }
     QVector<AttachmentData> _attachmentData;
     QString _displayName;
-    QRect _displayNameBoundingRect;
     float _displayNameTargetAlpha;
     float _displayNameAlpha;

libraries/entities-renderer/CMakeLists.txt+0−6

@@ -17,10 +17,4 @@ find_package(PolyVox REQUIRED) · 16 unmodified lines
17	target_include_directories(${TARGET_NAME} SYSTEM PUBLIC ${POLYVOX_INCLUDE_DIRS})	17	target_include_directories(${TARGET_NAME} SYSTEM PUBLIC ${POLYVOX_INCLUDE_DIRS})
18	target_link_libraries(${TARGET_NAME} ${POLYVOX_LIBRARIES})	18	target_link_libraries(${TARGET_NAME} ${POLYVOX_LIBRARIES})
19		19
20	# for changing the pitch of collision sounds
21	add_dependency_external_projects(soxr)
22	find_package(Soxr REQUIRED)
23	target_link_libraries(${TARGET_NAME} ${SOXR_LIBRARIES})
24	target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${SOXR_INCLUDE_DIRS})
25
26	link_hifi_libraries(shared gpu script-engine render render-utils)	20	link_hifi_libraries(shared gpu script-engine render render-utils)

libraries/entities-renderer/src/EntityTreeRenderer.cpp+6−60

@@ -27,10 +27,6 @@ · 26 unmodified lines
27	#include <SceneScriptingInterface.h>	27	#include <SceneScriptingInterface.h>
28	#include <ScriptEngine.h>	28	#include <ScriptEngine.h>
29	#include <TextureCache.h>	29	#include <TextureCache.h>
30	#include <SoundCache.h>
31	#include <soxr.h>
32	#include <AudioConstants.h>
33
34		30
35	#include "EntityTreeRenderer.h"	31	#include "EntityTreeRenderer.h"
36		32
@@ -54,7 +50,6 @@ EntityTreeRenderer::EntityTreeRenderer(bool wantScripts, AbstractViewStateInterf · 17 unmodified lines
54	_wantScripts(wantScripts),	50	_wantScripts(wantScripts),
55	_entitiesScriptEngine(NULL),	51	_entitiesScriptEngine(NULL),
56	_sandboxScriptEngine(NULL),	52	_sandboxScriptEngine(NULL),
57	_localAudioInterface(NULL),
58	_lastMouseEventValid(false),	53	_lastMouseEventValid(false),
59	_viewState(viewState),	54	_viewState(viewState),
60	_scriptingServices(scriptingServices),	55	_scriptingServices(scriptingServices),
@@ -911,15 +906,13 @@ void EntityTreeRenderer::mouseMoveEvent(QMouseEvent* event, unsigned int deviceI · 850 unmodified lines
911	bool precisionPicking = false; // for mouse moves we do not do precision picking	906	bool precisionPicking = false; // for mouse moves we do not do precision picking
912	RayToEntityIntersectionResult rayPickResult = findRayIntersectionWorker(ray, Octree::TryLock, precisionPicking);	907	RayToEntityIntersectionResult rayPickResult = findRayIntersectionWorker(ray, Octree::TryLock, precisionPicking);
913	if (rayPickResult.intersects) {	908	if (rayPickResult.intersects) {
		909	//qCDebug(entitiesrenderer) << "mouseReleaseEvent over entity:" << rayPickResult.entityID;
914	QScriptValueList entityScriptArgs = createMouseEventArgs(rayPickResult.entityID, event, deviceID);	910	QScriptValueList entityScriptArgs = createMouseEventArgs(rayPickResult.entityID, event, deviceID);
915
916	// load the entity script if needed...	911	// load the entity script if needed...
917	QScriptValue entityScript = loadEntityScript(rayPickResult.entity);	912	QScriptValue entityScript = loadEntityScript(rayPickResult.entity);
918	if (entityScript.property("mouseMoveEvent").isValid()) {	913	if (entityScript.property("mouseMoveEvent").isValid()) {
919	entityScript.property("mouseMoveEvent").call(entityScript, entityScriptArgs);	914	entityScript.property("mouseMoveEvent").call(entityScript, entityScriptArgs);
920	}	915	}
921
922	//qCDebug(entitiesrenderer) << "mouseMoveEvent over entity:" << rayPickResult.entityID;
923	emit mouseMoveOnEntity(rayPickResult, event, deviceID);	916	emit mouseMoveOnEntity(rayPickResult, event, deviceID);
924	if (entityScript.property("mouseMoveOnEntity").isValid()) {	917	if (entityScript.property("mouseMoveOnEntity").isValid()) {
925	entityScript.property("mouseMoveOnEntity").call(entityScript, entityScriptArgs);	918	entityScript.property("mouseMoveOnEntity").call(entityScript, entityScriptArgs);
@@ -1056,7 +1049,6 @@ void EntityTreeRenderer::checkAndCallUnload(const EntityItemID& entityID) { · 130 unmodified lines
1056	}	1049	}
1057	}	1050	}
1058		1051
1059
1060	void EntityTreeRenderer::playEntityCollisionSound(const QUuid& myNodeID, EntityTree* entityTree, const EntityItemID& id, const Collision& collision) {	1052	void EntityTreeRenderer::playEntityCollisionSound(const QUuid& myNodeID, EntityTree* entityTree, const EntityItemID& id, const Collision& collision) {
1061	EntityItemPointer entity = entityTree->findEntityByEntityItemID(id);	1053	EntityItemPointer entity = entityTree->findEntityByEntityItemID(id);
1062	if (!entity) {	1054	if (!entity) {
@@ -1099,61 +1091,15 @@ void EntityTreeRenderer::playEntityCollisionSound(const QUuid& myNodeID, EntityT · 36 unmodified lines
1099	if (energyFactorOfFull < COLLISION_MINIMUM_VOLUME) {	1091	if (energyFactorOfFull < COLLISION_MINIMUM_VOLUME) {
1100	return;	1092	return;
1101	}	1093	}
1102		1094	// Quiet sound aren't really heard at all, so we can compress everything to the range [1-c, 1], if we play it all.
1103	auto soundCache = DependencyManager::get<SoundCache>();
1104	if (soundCache.isNull()) {
1105	return;
1106	}
1107	SharedSoundPointer sound = soundCache.data()->getSound(QUrl(collisionSoundURL));
1108	if (sound.isNull() \|\| !sound->isReady()) {
1109	return;
1110	}
1111
1112	// This is a hack. Quiet sound aren't really heard at all, so we compress everything to the range [1-c, 1], if we play it all.
1113	const float COLLISION_SOUND_COMPRESSION_RANGE = 1.0f; // This section could be removed when the value is 1, but let's see how it goes.	1095	const float COLLISION_SOUND_COMPRESSION_RANGE = 1.0f; // This section could be removed when the value is 1, but let's see how it goes.
1114	float volume = energyFactorOfFull;	1096	const float volume = (energyFactorOfFull * COLLISION_SOUND_COMPRESSION_RANGE) + (1.0f - COLLISION_SOUND_COMPRESSION_RANGE);
1115	volume = (volume * COLLISION_SOUND_COMPRESSION_RANGE) + (1.0f - COLLISION_SOUND_COMPRESSION_RANGE);	1097
1116
1117	// This is quite similar to AudioScriptingInterface::playSound() and should probably be refactored.
1118	AudioInjectorOptions options;
1119	options.stereo = sound->isStereo();
1120	options.position = position;
1121	options.volume = volume;
1122		1098
1123	// Shift the pitch down by ln(1 + (size / COLLISION_SIZE_FOR_STANDARD_PITCH)) / ln(2)	1099	// Shift the pitch down by ln(1 + (size / COLLISION_SIZE_FOR_STANDARD_PITCH)) / ln(2)
1124	const float COLLISION_SIZE_FOR_STANDARD_PITCH = 0.2f;	1100	const float COLLISION_SIZE_FOR_STANDARD_PITCH = 0.2f;
1125	QByteArray samples = sound->getByteArray();	1101	const float stretchFactor = log(1.0f + (entity->getMinimumAACube().getLargestDimension() / COLLISION_SIZE_FOR_STANDARD_PITCH)) / log(2);
1126	soxr_io_spec_t spec = soxr_io_spec(SOXR_INT16_I, SOXR_INT16_I);	1102	AudioInjector::playSound(collisionSoundURL, volume, stretchFactor, position);
1127	soxr_quality_spec_t qualitySpec = soxr_quality_spec(SOXR_MQ, 0);
1128	const int channelCount = sound->isStereo() ? 2 : 1;
1129	const float factor = log(1.0f + (entity->getMinimumAACube().getLargestDimension() / COLLISION_SIZE_FOR_STANDARD_PITCH)) / log(2);
1130	const int standardRate = AudioConstants::SAMPLE_RATE;
1131	const int resampledRate = standardRate * factor;
1132	const int nInputSamples = samples.size() / sizeof(int16_t);
1133	const int nOutputSamples = nInputSamples * factor;
1134	QByteArray resampled(nOutputSamples * sizeof(int16_t), '\0');
1135	const int16_t* receivedSamples = reinterpret_cast<const int16_t*>(samples.data());
1136	soxr_error_t soxError = soxr_oneshot(standardRate, resampledRate, channelCount,
1137	receivedSamples, nInputSamples, NULL,
1138	reinterpret_cast<int16_t*>(resampled.data()), nOutputSamples, NULL,
1139	&spec, &qualitySpec, 0);
1140	if (soxError) {
1141	qCDebug(entitiesrenderer) << "Unable to resample" << collisionSoundURL << "from" << nInputSamples << "@" << standardRate << "to" << nOutputSamples << "@" << resampledRate;
1142	resampled = samples;
1143	}
1144
1145	AudioInjector* injector = new AudioInjector(resampled, options);
1146	injector->setLocalAudioInterface(_localAudioInterface);
1147	injector->triggerDeleteAfterFinish();
1148	QThread* injectorThread = new QThread();
1149	injectorThread->setObjectName("Audio Injector Thread");
1150	injector->moveToThread(injectorThread);
1151	// start injecting when the injector thread starts
1152	connect(injectorThread, &QThread::started, injector, &AudioInjector::injectAudio);
1153	// connect the right slots and signals for AudioInjector and thread cleanup
1154	connect(injector, &AudioInjector::destroyed, injectorThread, &QThread::quit);
1155	connect(injectorThread, &QThread::finished, injectorThread, &QThread::deleteLater);
1156	injectorThread->start();
1157	}	1103	}
1158		1104
1159	void EntityTreeRenderer::entityCollisionWithEntity(const EntityItemID& idA, const EntityItemID& idB,	1105	void EntityTreeRenderer::entityCollisionWithEntity(const EntityItemID& idA, const EntityItemID& idB,

libraries/entities-renderer/src/EntityTreeRenderer.h+0−1

@@ -158,7 +158,6 @@ private: · 157 unmodified lines
158	QHash<EntityItemID, EntityScriptDetails> _entityScripts;	158	QHash<EntityItemID, EntityScriptDetails> _entityScripts;
159		159
160	void playEntityCollisionSound(const QUuid& myNodeID, EntityTree* entityTree, const EntityItemID& id, const Collision& collision);	160	void playEntityCollisionSound(const QUuid& myNodeID, EntityTree* entityTree, const EntityItemID& id, const Collision& collision);
161	AbstractAudioInterface* _localAudioInterface; // So we can render collision sounds
162		161
163	bool _lastMouseEventValid;	162	bool _lastMouseEventValid;
164	MouseEvent _lastMouseEvent;	163	MouseEvent _lastMouseEvent;

libraries/entities-renderer/src/RenderableLineEntityItem.cpp+3−3

@@ -43,9 +43,9 @@ void RenderableLineEntityItem::render(RenderArgs* args) { · 42 unmodified lines
43		43
44	Q_ASSERT(args->_batch);	44	Q_ASSERT(args->_batch);
45	gpu::Batch& batch = *args->_batch;	45	gpu::Batch& batch = *args->_batch;
46	// TODO: Figure out clean , efficient way to do relative line positioning. For now we'll just use absolute positioning.	46	Transform transform = Transform();
47	//batch.setModelTransform(getTransformToCenter());	47	transform.setTranslation(getPosition());
48	batch.setModelTransform(Transform());	48	batch.setModelTransform(transform);
49		49
50	batch._glLineWidth(getLineWidth());	50	batch._glLineWidth(getLineWidth());
51	if (getLinePoints().size() > 1) {	51	if (getLinePoints().size() > 1) {

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp+11−7

 #include <QByteArray>
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdouble-promotion"
+#endif
 #include <glm/gtx/quaternion.hpp>
 #include <glm/gtx/string_cast.hpp>
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 #include <gpu/GPUConfig.h>
 #include <DeferredLightingEffect.h>
     decompressVolumeData();
 }
-void RenderablePolyVoxEntityItem::setVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle) {
+void RenderablePolyVoxEntityItem::updateVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle) {
-    if (voxelSurfaceStyle == _voxelSurfaceStyle) {
-        return;
-    }
     // if we are switching to or from "edged" we need to force a resize of _volData.
     if (voxelSurfaceStyle == SURFACE_EDGED_CUBIC ||
         _voxelSurfaceStyle == SURFACE_EDGED_CUBIC) {
             delete _volData;
         }
         _volData = nullptr;
-        PolyVoxEntityItem::setVoxelSurfaceStyle(voxelSurfaceStyle);
+        _voxelSurfaceStyle = voxelSurfaceStyle;
         setVoxelVolumeSize(_voxelVolumeSize);
     } else {
-        PolyVoxEntityItem::setVoxelSurfaceStyle(voxelSurfaceStyle);
+        _voxelSurfaceStyle = voxelSurfaceStyle;
     }
     _needsModelReload = true;
 }

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h+6−4

     virtual uint8_t getVoxel(int x, int y, int z);
     virtual void setVoxel(int x, int y, int z, uint8_t toValue);
     void updateOnCount(int x, int y, int z, uint8_t new_value);
     void render(RenderArgs* args);
     virtual bool supportsDetailedRayIntersection() const { return true; }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face,
                          void** intersectedObject, bool precisionPicking) const;
-    virtual void setVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle);
     void getModel();
     virtual void setVoxelData(QByteArray voxelData);
     SIMPLE_RENDERABLE();
+protected:
+    virtual void updateVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle);
 private:
     // The PolyVoxEntityItem class has _voxelData which contains dimensions and compressed voxel data.  The dimensions
     // may not match _voxelVolumeSize.
     void compressVolumeData();
     void decompressVolumeData();
     PolyVox::SimpleVolume<uint8_t>* _volData = nullptr;
     model::Geometry _modelGeometry;
     bool _needsModelReload = true;

libraries/entities/src/DeleteEntityOperator.cpp+1−0

@@ -95,6 +95,7 @@ bool DeleteEntityOperator::preRecursion(OctreeElement* element) { · 94 unmodified lines
95	EntityItemPointer theEntity = details.entity;	95	EntityItemPointer theEntity = details.entity;
96	bool entityDeleted = entityTreeElement->removeEntityItem(theEntity); // remove it from the element	96	bool entityDeleted = entityTreeElement->removeEntityItem(theEntity); // remove it from the element
97	assert(entityDeleted);	97	assert(entityDeleted);
		98	(void)entityDeleted; // quite warning
98	_tree->setContainingElement(details.entity->getEntityItemID(), NULL); // update or id to element lookup	99	_tree->setContainingElement(details.entity->getEntityItemID(), NULL); // update or id to element lookup
99	_foundCount++;	100	_foundCount++;
100	}	101	}

libraries/entities/src/EntityActionInterface.cpp+4−4

@@ -19,8 +19,8 @@ EntityActionType EntityActionInterface::actionTypeFromString(QString actionTypeS · 18 unmodified lines
19	if (normalizedActionTypeString == "none") {	19	if (normalizedActionTypeString == "none") {
20	return ACTION_TYPE_NONE;	20	return ACTION_TYPE_NONE;
21	}	21	}
22	if (normalizedActionTypeString == "pulltopoint") {	22	if (normalizedActionTypeString == "offset") {
23	return ACTION_TYPE_PULL_TO_POINT;	23	return ACTION_TYPE_OFFSET;
24	}	24	}
25	if (normalizedActionTypeString == "spring") {	25	if (normalizedActionTypeString == "spring") {
26	return ACTION_TYPE_SPRING;	26	return ACTION_TYPE_SPRING;
@@ -37,8 +37,8 @@ QString EntityActionInterface::actionTypeToString(EntityActionType actionType) { · 10 unmodified lines
37	switch(actionType) {	37	switch(actionType) {
38	case ACTION_TYPE_NONE:	38	case ACTION_TYPE_NONE:
39	return "none";	39	return "none";
40	case ACTION_TYPE_PULL_TO_POINT:	40	case ACTION_TYPE_OFFSET:
41	return "pullToPoint";	41	return "offset";
42	case ACTION_TYPE_SPRING:	42	case ACTION_TYPE_SPRING:
43	return "spring";	43	return "spring";
44	case ACTION_TYPE_HOLD:	44	case ACTION_TYPE_HOLD:

libraries/entities/src/EntityActionInterface.h+1−1

@@ -21,7 +21,7 @@ class EntitySimulation; · 20 unmodified lines
21	enum EntityActionType {	21	enum EntityActionType {
22	// keep these synchronized with actionTypeFromString and actionTypeToString	22	// keep these synchronized with actionTypeFromString and actionTypeToString
23	ACTION_TYPE_NONE,	23	ACTION_TYPE_NONE,
24	ACTION_TYPE_PULL_TO_POINT,	24	ACTION_TYPE_OFFSET,
25	ACTION_TYPE_SPRING,	25	ACTION_TYPE_SPRING,
26	ACTION_TYPE_HOLD	26	ACTION_TYPE_HOLD
27	};	27	};

libraries/entities/src/EntityItem.cpp+2−2

@@ -639,8 +639,8 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef · 638 unmodified lines
639	void EntityItem::debugDump() const {	639	void EntityItem::debugDump() const {
640	auto position = getPosition();	640	auto position = getPosition();
641	qCDebug(entities) << "EntityItem id:" << getEntityItemID();	641	qCDebug(entities) << "EntityItem id:" << getEntityItemID();
642	qCDebug(entities, " edited ago:%f", getEditedAgo());	642	qCDebug(entities, " edited ago:%f", (double)getEditedAgo());
643	qCDebug(entities, " position:%f,%f,%f", position.x, position.y, position.z);	643	qCDebug(entities, " position:%f,%f,%f", (double)position.x, (double)position.y, (double)position.z);
644	qCDebug(entities) << " dimensions:" << getDimensions();	644	qCDebug(entities) << " dimensions:" << getDimensions();
645	}	645	}
646		646

libraries/entities/src/EntityItemID.h+1−1

@@ -14,7 +14,7 @@ · 13 unmodified lines
14		14
15	#include <stdint.h>	15	#include <stdint.h>
16		16
17		17	#include <QDebug>
18	#include <QObject>	18	#include <QObject>
19	#include <QHash>	19	#include <QHash>
20	#include <QScriptEngine>	20	#include <QScriptEngine>

libraries/entities/src/EntityItemProperties.h+2−0

@@ -197,6 +197,8 @@ public: · 196 unmodified lines
197	QString getSimulatorIDAsString() const { return _simulatorID.toString().mid(1,36).toUpper(); }	197	QString getSimulatorIDAsString() const { return _simulatorID.toString().mid(1,36).toUpper(); }
198		198
199	void setVoxelDataDirty() { _voxelDataChanged = true; }	199	void setVoxelDataDirty() { _voxelDataChanged = true; }
		200
		201	void setLinePointsDirty() {_linePointsChanged = true; }
200		202
201	void setCreated(QDateTime& v);	203	void setCreated(QDateTime& v);
202		204

libraries/entities/src/EntityScriptingInterface.cpp+52−0

@@ -442,6 +442,43 @@ bool EntityScriptingInterface::setVoxels(QUuid entityID, · 441 unmodified lines
442	return true;	442	return true;
443	}	443	}
444		444
		445	bool EntityScriptingInterface::setPoints(QUuid entityID, std::function<bool(LineEntityItem&)> actor) {
		446	if (!_entityTree) {
		447	return false;
		448	}
		449
		450	EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID));
		451	if (!entity) {
		452	qCDebug(entities) << "EntityScriptingInterface::setPoints no entity with ID" << entityID;
		453	}
		454
		455	EntityTypes::EntityType entityType = entity->getType();
		456
		457	if (entityType != EntityTypes::Line) {
		458	return false;
		459	}
		460
		461	auto now = usecTimestampNow();
		462
		463	LineEntityItem* lineEntity = static_cast<LineEntityItem*>(entity.get());
		464	_entityTree->lockForWrite();
		465	bool success = actor(*lineEntity);
		466	entity->setLastEdited(now);
		467	entity->setLastBroadcast(now);
		468	_entityTree->unlock();
		469
		470	_entityTree->lockForRead();
		471	EntityItemProperties properties = entity->getProperties();
		472	_entityTree->unlock();
		473
		474	properties.setLinePointsDirty();
		475	properties.setLastEdited(now);
		476
		477
		478	queueEntityMessage(PacketTypeEntityEdit, entityID, properties);
		479	return success;
		480	}
		481
445	bool EntityScriptingInterface::setVoxelSphere(QUuid entityID, const glm::vec3& center, float radius, int value) {	482	bool EntityScriptingInterface::setVoxelSphere(QUuid entityID, const glm::vec3& center, float radius, int value) {
446	return setVoxels(entityID, [center, radius, value](PolyVoxEntityItem& polyVoxEntity) {	483	return setVoxels(entityID, [center, radius, value](PolyVoxEntityItem& polyVoxEntity) {
447	polyVoxEntity.setSphere(center, radius, value);	484	polyVoxEntity.setSphere(center, radius, value);
@@ -460,6 +497,21 @@ bool EntityScriptingInterface::setAllVoxels(QUuid entityID, int value) { · 12 unmodified lines
460	});	497	});
461	}	498	}
462		499
		500	bool EntityScriptingInterface::setAllPoints(QUuid entityID, const QVector<glm::vec3>& points) {
		501	return setPoints(entityID, [points](LineEntityItem& lineEntity) -> bool
		502	{
		503	return lineEntity.setLinePoints(points);
		504	});
		505	}
		506
		507	bool EntityScriptingInterface::appendPoint(QUuid entityID, const glm::vec3& point) {
		508	return setPoints(entityID, [point](LineEntityItem& lineEntity) -> bool
		509	{
		510	return lineEntity.appendPoint(point);
		511	});
		512
		513	}
		514
463		515
464	bool EntityScriptingInterface::actionWorker(const QUuid& entityID,	516	bool EntityScriptingInterface::actionWorker(const QUuid& entityID,
465	std::function<bool(EntitySimulation*, EntityItemPointer)> actor) {	517	std::function<bool(EntitySimulation*, EntityItemPointer)> actor) {

libraries/entities/src/EntityScriptingInterface.h+5−0

 #include <OctreeScriptingInterface.h>
 #include <RegisteredMetaTypes.h>
 #include "PolyVoxEntityItem.h"
+#include "LineEntityItem.h"
 #include "EntityEditPacketSender.h"
     Q_INVOKABLE bool setVoxelSphere(QUuid entityID, const glm::vec3& center, float radius, int value);
     Q_INVOKABLE bool setVoxel(QUuid entityID, const glm::vec3& position, int value);
     Q_INVOKABLE bool setAllVoxels(QUuid entityID, int value);
+    Q_INVOKABLE bool setAllPoints(QUuid entityID, const QVector<glm::vec3>& points);
+    Q_INVOKABLE bool appendPoint(QUuid entityID, const glm::vec3& point);
     Q_INVOKABLE void dumpTree() const;
 private:
     bool actionWorker(const QUuid& entityID, std::function<bool(EntitySimulation*, EntityItemPointer)> actor);
     bool setVoxels(QUuid entityID, std::function<void(PolyVoxEntityItem&)> actor);
+    bool setPoints(QUuid entityID, std::function<bool(LineEntityItem&)> actor);
     void queueEntityMessage(PacketType packetType, EntityItemID entityID, const EntityItemProperties& properties);
     /// actually does the work of finding the ray intersection, can be called in locking mode or tryLock mode

libraries/entities/src/LineEntityItem.cpp+28−13

 const float LineEntityItem::DEFAULT_LINE_WIDTH = 2.0f;
+const int LineEntityItem::MAX_POINTS_PER_LINE = 70;
 EntityItemPointer LineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     return somethingChanged;
 }
-void LineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
+bool LineEntityItem::appendPoint(const glm::vec3& point) {
-    QVector<glm::vec3> sanitizedPoints;
+    if (_points.size() > MAX_POINTS_PER_LINE - 1) {
-    int invalidPoints = 0;
+        qDebug() << "MAX POINTS REACHED!";
+        return false;
+    }
+    glm::vec3 halfBox = getDimensions() * 0.5f;
+    if ( (point.x < - halfBox.x || point.x > halfBox.x) || (point.y < -halfBox.y || point.y > halfBox.y) || (point.z < - halfBox.z || point.z > halfBox.z) ) {
+        qDebug() << "Point is outside entity's bounding box";
+        return false;
+    }
+    _points << point;
+    _pointsChanged = true;
+    return true;
+}
+bool LineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
+    if (points.size() > MAX_POINTS_PER_LINE) {
+        return false;
+    }
     for (int i = 0; i < points.size(); i++) {
         glm::vec3 point = points.at(i);
-        // Make sure all of our points are valid numbers.
+        glm::vec3 pos = getPosition();
-        // Must be greater than 0 because vector component is set to 0 if it is invalid data. Also should never be greater than TREE_SCALE
+        glm::vec3 halfBox = getDimensions() * 0.5f;
-        if ( (point.x > 0 && point.x < TREE_SCALE) && (point.y > 0 && point.y < TREE_SCALE) && (point.z > 0 && point.z < TREE_SCALE) ) {
+        if ( (point.x < - halfBox.x || point.x > halfBox.x) || (point.y < -halfBox.y || point.y > halfBox.y) || (point.z < - halfBox.z || point.z > halfBox.z) ) {
-            sanitizedPoints << point;
+            qDebug() << "Point is outside entity's bounding box";
-        } else {
+            return false;
-            ++invalidPoints;
         }
     }
-    if (invalidPoints > 0) {
+    _points = points;
-        qDebug() << "Line with" << invalidPoints << "INVALID POINTS";
-    }
-    _points = sanitizedPoints;
     _pointsChanged = true;
+    return true;
 }
 int LineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,

libraries/entities/src/LineEntityItem.h+3−1

     void setLineWidth(float lineWidth){ _lineWidth = lineWidth; }
     float getLineWidth() const{ return _lineWidth; }
-    void setLinePoints(const QVector<glm::vec3>& points);
+    bool setLinePoints(const QVector<glm::vec3>& points);
+    bool appendPoint(const glm::vec3& point);
     const QVector<glm::vec3>& getLinePoints() const{ return _points; }
     virtual void debugDump() const;
     static const float DEFAULT_LINE_WIDTH;
+    static const int MAX_POINTS_PER_LINE;
  protected:
     rgbColor _color;

libraries/entities/src/PolyVoxEntityItem.cpp+7−0

@@ -168,3 +168,10 @@ void PolyVoxEntityItem::debugDump() const { · 167 unmodified lines
168	qCDebug(entities) << " dimensions:" << debugTreeVector(getDimensions());	168	qCDebug(entities) << " dimensions:" << debugTreeVector(getDimensions());
169	qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now);	169	qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now);
170	}	170	}
		171
		172	void PolyVoxEntityItem::setVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle) {
		173	if (voxelSurfaceStyle == _voxelSurfaceStyle) {
		174	return;
		175	}
		176	updateVoxelSurfaceStyle(voxelSurfaceStyle);
		177	}

libraries/entities/src/PolyVoxEntityItem.h+7−4

         SURFACE_EDGED_CUBIC
     };
-    virtual void setVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle) { _voxelSurfaceStyle = voxelSurfaceStyle; }
+    void setVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle);
-    virtual void setVoxelSurfaceStyle(uint16_t voxelSurfaceStyle) {
+    // this other version of setVoxelSurfaceStyle is needed for SET_ENTITY_PROPERTY_FROM_PROPERTIES
-        setVoxelSurfaceStyle((PolyVoxSurfaceStyle) voxelSurfaceStyle);
+    void setVoxelSurfaceStyle(uint16_t voxelSurfaceStyle) { setVoxelSurfaceStyle((PolyVoxSurfaceStyle) voxelSurfaceStyle); }
-    }
     virtual PolyVoxSurfaceStyle getVoxelSurfaceStyle() const { return _voxelSurfaceStyle; }
     static const glm::vec3 DEFAULT_VOXEL_VOLUME_SIZE;
     static QByteArray makeEmptyVoxelData(quint16 voxelXSize = 16, quint16 voxelYSize = 16, quint16 voxelZSize = 16);
  protected:
+    virtual void updateVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle) {
+        _voxelSurfaceStyle = voxelSurfaceStyle;
+    }
     glm::vec3 _voxelVolumeSize; // this is always 3 bytes
     QByteArray _voxelData;
     PolyVoxSurfaceStyle _voxelSurfaceStyle;

libraries/fbx/src/FBXReader.cpp+37−6

 QVector<glm::vec4> createVec4Vector(const QVector<double>& doubleVector) {
     QVector<glm::vec4> values;
-    for (const double* it = doubleVector.constData(), *end = it + (doubleVector.size() / 4 * 4); it != end; ) {
+    for (const double* it = doubleVector.constData(), *end = it + ((doubleVector.size() / 4) * 4); it != end; ) {
         float x = *it++;
         float y = *it++;
         float z = *it++;
     return values;
 }
+QVector<glm::vec4> createVec4VectorRGBA(const QVector<double>& doubleVector, glm::vec4& average) {
+    QVector<glm::vec4> values;
+    for (const double* it = doubleVector.constData(), *end = it + ((doubleVector.size() / 4) * 4); it != end; ) {
+        float x = *it++;
+        float y = *it++;
+        float z = *it++;
+        float w = *it++;
+        auto val = glm::vec4(x, y, z, w);
+        values.append(val);
+        average += val;
+    }
+    if (!values.isEmpty()) {
+        average *= (1.0f / float(values.size()));
+    }
+    return values;
+}
 QVector<glm::vec3> createVec3Vector(const QVector<double>& doubleVector) {
     QVector<glm::vec3> values;
-    for (const double* it = doubleVector.constData(), *end = it + (doubleVector.size() / 3 * 3); it != end; ) {
+    for (const double* it = doubleVector.constData(), *end = it + ((doubleVector.size() / 3) * 3); it != end; ) {
         float x = *it++;
         float y = *it++;
         float z = *it++;
 QVector<glm::vec2> createVec2Vector(const QVector<double>& doubleVector) {
     QVector<glm::vec2> values;
-    for (const double* it = doubleVector.constData(), *end = it + (doubleVector.size() / 2 * 2); it != end; ) {
+    for (const double* it = doubleVector.constData(), *end = it + ((doubleVector.size() / 2) * 2); it != end; ) {
         float s = *it++;
         float t = *it++;
         values.append(glm::vec2(s, -t));
     QVector<int> normalIndices;
     bool colorsByVertex;
+    glm::vec4 averageColor{1.0f, 1.0f, 1.0f, 1.0f};
     QVector<glm::vec4> colors;
     QVector<int> colorIndices;
             bool indexToDirect = false;
             foreach (const FBXNode& subdata, child.children) {
                 if (subdata.name == "Colors") {
-                    data.colors = createVec4Vector(getDoubleVector(subdata));
+                    data.colors = createVec4VectorRGBA(getDoubleVector(subdata), data.averageColor);
                 } else if (subdata.name == "ColorsIndex") {
                     data.colorIndices = getIntVector(subdata);
                 // hack to work around wacky Makehuman exports
                 data.colorsByVertex = true;
             }
+#if defined(FBXREADER_KILL_BLACK_COLOR_ATTRIBUTE)
+            // Potential feature where we decide to kill the color attribute is to dark?
+            // Tested with the model:
+            // https://hifi-public.s3.amazonaws.com/ryan/gardenLight2.fbx
+            // let's check if we did have true data ?
+            if (glm::all(glm::lessThanEqual(data.averageColor, glm::vec4(0.09f)))) {
+                data.colors.clear();
+                data.colorIndices.clear();
+                data.colorsByVertex = false;
+                qCDebug(modelformat) << "LayerElementColor has an average value of 0.0f... let's forget it.";
+            }
+#endif
         } else if (child.name == "LayerElementUV") {
             if (child.properties.at(0).toInt() == 0) {
                 if (property.name == "P") {
                     QString propname = property.properties.at(0).toString();
                     if (propname == "Intensity") {
-                        light.intensity = 0.01f * property.properties.at(valIndex).value<double>();
+                        light.intensity = 0.01f * property.properties.at(valIndex).value<float>();
                     } else if (propname == "Color") {
                         light.color = getVec3(property.properties, valIndex);
                     }

libraries/gpu/src/gpu/Batch.h+3−1

     typedef Stream::Slot Slot;
     Batch();
-    Batch(const Batch& batch);
+    explicit Batch(const Batch& batch);
     ~Batch();
     void clear();
     void _glDrawBuffers(GLsizei n, const GLenum* bufs);
     void _glUseProgram(GLuint program);
+    void _glUniform1i(GLint location, GLint v0);
     void _glUniform1f(GLint location, GLfloat v0);
     void _glUniform2f(GLint location, GLfloat v0, GLfloat v1);
     void _glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
         COMMAND_glDrawBuffers,
         COMMAND_glUseProgram,
+        COMMAND_glUniform1i,
         COMMAND_glUniform1f,
         COMMAND_glUniform2f,
         COMMAND_glUniform3f,

libraries/gpu/src/gpu/GLBackend.cpp+57−0

 #include "GLBackendShared.h"
 #include <glm/gtc/type_ptr.hpp>
+using namespace gpu;
 GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
 {
     (&::gpu::GLBackend::do_draw),
     (&::gpu::GLBackend::do_glDrawBuffers),
     (&::gpu::GLBackend::do_glUseProgram),
+    (&::gpu::GLBackend::do_glUniform1i),
     (&::gpu::GLBackend::do_glUniform1f),
     (&::gpu::GLBackend::do_glUniform2f),
     (&::gpu::GLBackend::do_glUniform3f),
     }
 }
+bool GLBackend::checkGLErrorDebug(const char* name) {
+#ifdef DEBUG
+    return checkGLError(name);
+#else
+    Q_UNUSED(name);
+    return false;
+#endif
+}
 void GLBackend::syncCache() {
     syncTransformStateCache();
     (void) CHECK_GL_ERROR();
 }
+void Batch::_glUniform1i(GLint location, GLint v0) {
+    if (location < 0) {
+        return;
+    }
+    ADD_COMMAND_GL(glUniform1i);
+    _params.push_back(v0);
+    _params.push_back(location);
+    DO_IT_NOW(_glUniform1i, 1);
+}
+void GLBackend::do_glUniform1i(Batch& batch, uint32 paramOffset) {
+    if (_pipeline._program == 0) {
+        // We should call updatePipeline() to bind the program but we are not doing that
+        // because these uniform setters are deprecated and we don;t want to create side effect
+        return;
+    }
+    updatePipeline();
+    glUniform1f(
+        batch._params[paramOffset + 1]._int,
+        batch._params[paramOffset + 0]._int);
+    (void) CHECK_GL_ERROR();
+}
 void Batch::_glUniform1f(GLint location, GLfloat v0) {
     if (location < 0) {
         return;
         // because these uniform setters are deprecated and we don;t want to create side effect
         return;
     }
+    updatePipeline();
     glUniform1f(
         batch._params[paramOffset + 1]._int,
         batch._params[paramOffset + 0]._float);
         // because these uniform setters are deprecated and we don;t want to create side effect
         return;
     }
+    updatePipeline();
     glUniform2f(
         batch._params[paramOffset + 2]._int,
         batch._params[paramOffset + 1]._float,
         // because these uniform setters are deprecated and we don;t want to create side effect
         return;
     }
+    updatePipeline();
     glUniform3f(
         batch._params[paramOffset + 3]._int,
         batch._params[paramOffset + 2]._float,
         // because these uniform setters are deprecated and we don;t want to create side effect
         return;
     }
+    updatePipeline();
     glUniform3fv(
         batch._params[paramOffset + 2]._int,
         batch._params[paramOffset + 1]._uint,
         // because these uniform setters are deprecated and we don;t want to create side effect
         return;
     }
+    updatePipeline();
     glUniform4fv(
         batch._params[paramOffset + 2]._int,
         batch._params[paramOffset + 1]._uint,
         // because these uniform setters are deprecated and we don;t want to create side effect
         return;
     }
+    updatePipeline();
     glUniformMatrix4fv(
         batch._params[paramOffset + 3]._int,
         batch._params[paramOffset + 2]._uint,
     glGetFloatv(target, glm::value_ptr(m));
 }
+void GLBackend::checkGLStackStable(std::function<void()> f) {
+#ifdef DEBUG
+    GLint mvDepth, prDepth;
+    glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &mvDepth);
+    glGetIntegerv(GL_PROJECTION_STACK_DEPTH, &prDepth);
+#endif
+    f();
+#ifdef DEBUG
+    GLint mvDepthFinal, prDepthFinal;
+    glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &mvDepthFinal);
+    glGetIntegerv(GL_PROJECTION_STACK_DEPTH, &prDepthFinal);
+    Q_ASSERT(mvDepth == mvDepthFinal);
+    Q_ASSERT(prDepth == prDepthFinal);
+#endif
+}

libraries/gpu/src/gpu/GLBackend.h+9−1

 #define hifi_gpu_GLBackend_h
 #include <assert.h>
+#include <functional>
+#include <bitset>
 #include "GPUConfig.h"
 #include "Context.h"
 #include "Batch.h"
-#include <bitset>
 namespace gpu {
     static bool checkGLError(const char* name = nullptr);
+    // Only checks in debug builds
+    static bool checkGLErrorDebug(const char* name = nullptr);
+    static void checkGLStackStable(std::function<void()> f);
     static bool makeProgram(Shader& shader, const Shader::BindingSet& bindings = Shader::BindingSet());
     void do_glDrawBuffers(Batch& batch, uint32 paramOffset);
     void do_glUseProgram(Batch& batch, uint32 paramOffset);
+    void do_glUniform1i(Batch& batch, uint32 paramOffset);
     void do_glUniform1f(Batch& batch, uint32 paramOffset);
     void do_glUniform2f(Batch& batch, uint32 paramOffset);
     void do_glUniform3f(Batch& batch, uint32 paramOffset);

libraries/gpu/src/gpu/GLBackendOutput.cpp+1−0

@@ -11,6 +11,7 @@ · 10 unmodified lines
11	#include "GPULogging.h"	11	#include "GPULogging.h"
12	#include "GLBackendShared.h"	12	#include "GLBackendShared.h"
13		13
		14	using namespace gpu;
14		15
15	GLBackend::GLFramebuffer::GLFramebuffer() {}	16	GLBackend::GLFramebuffer::GLFramebuffer() {}
16		17

libraries/gpu/src/gpu/GLBackendShared.h+9−9

 #include "Batch.h"
-using namespace gpu;
+static const GLenum _primitiveToGLmode[gpu::NUM_PRIMITIVES] = {
-static const GLenum _primitiveToGLmode[NUM_PRIMITIVES] = {
     GL_POINTS,
     GL_LINES,
     GL_LINE_STRIP,
     GL_QUAD_STRIP,
 };
-static const GLenum _elementTypeToGLType[NUM_TYPES]= {
+static const GLenum _elementTypeToGLType[gpu::NUM_TYPES] = {
     GL_FLOAT,
     GL_INT,
     GL_UNSIGNED_INT,
     GL_UNSIGNED_BYTE
 };
-#if _DEBUG
+// Stupid preprocessor trick to turn the line macro into a string
-#define CHECK_GL_ERROR() ::gpu::GLBackend::checkGLError(__FUNCTION__)
+#define CHECK_GL_ERROR_HELPER(x) #x
-#else
+// FIXME doesn't build on Linux or Mac.  Hmmmm
-#define CHECK_GL_ERROR() false
+// #define CHECK_GL_ERROR() gpu::GLBackend::checkGLErrorDebug(__FUNCTION__ ":" CHECK_GL_ERROR_HELPER(__LINE__))
-#endif
+#define CHECK_GL_ERROR() gpu::GLBackend::checkGLErrorDebug(__FUNCTION__)
+#define CHECK_GL_STACK_STABLE(f) gpu::GLBackend::checkGLStackStable(f)
 #endif

libraries/gpu/src/gpu/GLBackendTexture.cpp+3−2

 #include "GPULogging.h"
 #include "GLBackendShared.h"
+using namespace gpu;
 GLBackend::GLTexture::GLTexture() :
     _storageStamp(0),
                 if (bytes && texture.isAutogenerateMips()) {
                     glGenerateMipmap(GL_TEXTURE_2D);
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-                } else {
+                }/* else {
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-                }
+                }*/
                 object->_target = GL_TEXTURE_2D;

libraries/gpu/src/gpu/GLBackendTransform.cpp+13−16

 }
 void GLBackend::updateTransform() {
+    GLint originalMatrixMode;
+    glGetIntegerv(GL_MATRIX_MODE, &originalMatrixMode);
     // Check all the dirty flags and update the state accordingly
     if (_transform._invalidProj) {
         _transform._transformCamera._projection = _transform._projection;
         (void) CHECK_GL_ERROR();
     }
     if (_transform._invalidModel || _transform._invalidView) {
+        if (_transform._lastMode != GL_MODELVIEW) {
+            glMatrixMode(GL_MODELVIEW);
+            _transform._lastMode = GL_MODELVIEW;
+        }
         if (!_transform._model.isIdentity()) {
-            if (_transform._lastMode != GL_MODELVIEW) {
-                glMatrixMode(GL_MODELVIEW);
-                _transform._lastMode = GL_MODELVIEW;
-            }
             Transform::Mat4 modelView;
             if (!_transform._view.isIdentity()) {
                 Transform mvx;
                 _transform._model.getMatrix(modelView);
             }
             glLoadMatrixf(reinterpret_cast< const GLfloat* >(&modelView));
+        } else if (!_transform._view.isIdentity()) {
+            Transform::Mat4 modelView;
+            _transform._view.getInverseMatrix(modelView);
+            glLoadMatrixf(reinterpret_cast< const GLfloat* >(&modelView));
         } else {
-            if (!_transform._view.isIdentity()) {
+            glLoadIdentity();
-                if (_transform._lastMode != GL_MODELVIEW) {
-                    glMatrixMode(GL_MODELVIEW);
-                    _transform._lastMode = GL_MODELVIEW;
-                }
-                Transform::Mat4 modelView;
-                _transform._view.getInverseMatrix(modelView);
-                glLoadMatrixf(reinterpret_cast< const GLfloat* >(&modelView));
-            } else {
-                // TODO: eventually do something about the matrix when neither view nor model is specified?
-                // glLoadIdentity();
-            }
         }
         (void) CHECK_GL_ERROR();
     }
     // Flags are clean
     _transform._invalidView = _transform._invalidProj = _transform._invalidModel = false;
+    glMatrixMode(originalMatrixMode);
 }

libraries/gpu/src/gpu/Texture.cpp+10−10

@@ -581,20 +581,20 @@ void sphericalHarmonicsScale(float * result, int order, const float * input, flo · 580 unmodified lines
581	void sphericalHarmonicsEvaluateDirection(float * result, int order, const glm::vec3 & dir) {	581	void sphericalHarmonicsEvaluateDirection(float * result, int order, const glm::vec3 & dir) {
582	// calculate coefficients for first 3 bands of spherical harmonics	582	// calculate coefficients for first 3 bands of spherical harmonics
583	double P_0_0 = 0.282094791773878140;	583	double P_0_0 = 0.282094791773878140;
584	double P_1_0 = 0.488602511902919920 * dir.z;	584	double P_1_0 = 0.488602511902919920 * (double)dir.z;
585	double P_1_1 = -0.488602511902919920;	585	double P_1_1 = -0.488602511902919920;
586	double P_2_0 = 0.946174695757560080 * dir.z * dir.z - 0.315391565252520050;	586	double P_2_0 = 0.946174695757560080 * (double)dir.z * (double)dir.z - 0.315391565252520050;
587	double P_2_1 = -1.092548430592079200 * dir.z;	587	double P_2_1 = -1.092548430592079200 * (double)dir.z;
588	double P_2_2 = 0.546274215296039590;	588	double P_2_2 = 0.546274215296039590;
589	result[0] = P_0_0;	589	result[0] = P_0_0;
590	result[1] = P_1_1 * dir.y;	590	result[1] = P_1_1 * (double)dir.y;
591	result[2] = P_1_0;	591	result[2] = P_1_0;
592	result[3] = P_1_1 * dir.x;	592	result[3] = P_1_1 * (double)dir.x;
593	result[4] = P_2_2 * (dir.x * dir.y + dir.y * dir.x);	593	result[4] = P_2_2 * ((double)dir.x * (double)dir.y + (double)dir.y * (double)dir.x);
594	result[5] = P_2_1 * dir.y;	594	result[5] = P_2_1 * (double)dir.y;
595	result[6] = P_2_0;	595	result[6] = P_2_0;
596	result[7] = P_2_1 * dir.x;	596	result[7] = P_2_1 * (double)dir.x;
597	result[8] = P_2_2 * (dir.x * dir.x - dir.y * dir.y);	597	result[8] = P_2_2 * ((double)dir.x * (double)dir.x - (double)dir.y * (double)dir.y);
598	}	598	}
599		599
600	bool sphericalHarmonicsFromTexture(const gpu::Texture& cubeTexture, std::vector<glm::vec3> & output, const uint order) {	600	bool sphericalHarmonicsFromTexture(const gpu::Texture& cubeTexture, std::vector<glm::vec3> & output, const uint order) {
@@ -767,4 +767,4 @@ void SphericalHarmonics::evalFromTexture(const Texture& texture) { · 166 unmodified lines
767	L21 = coefs[7];	767	L21 = coefs[7];
768	L22 = coefs[8];	768	L22 = coefs[8];
769	}	769	}
770	}	770	}

libraries/model/src/model/Light.cpp+1−1

@@ -73,7 +73,7 @@ void Light::setMaximumRadius(float radius) { · 72 unmodified lines
73	radius = 1.0f;	73	radius = 1.0f;
74	}	74	}
75	float CutOffIntensityRatio = 0.05f;	75	float CutOffIntensityRatio = 0.05f;
76	float surfaceRadius = radius / (sqrt(1.0f / CutOffIntensityRatio) - 1.f);	76	float surfaceRadius = radius / (sqrtf(1.0f / CutOffIntensityRatio) - 1.0f);
77	editSchema()._attenuation = Vec4(surfaceRadius, 1.0f/surfaceRadius, CutOffIntensityRatio, radius);	77	editSchema()._attenuation = Vec4(surfaceRadius, 1.0f/surfaceRadius, CutOffIntensityRatio, radius);
78	}	78	}
79		79

libraries/model/src/model/Skybox.cpp+2−2

@@ -72,7 +72,7 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky · 71 unmodified lines
72		72
73	thePipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState));	73	thePipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState));
74		74
75	const float CLIP = 1.0;	75	const float CLIP = 1.0f;
76	const glm::vec2 vertices[4] = { {-CLIP, -CLIP}, {CLIP, -CLIP}, {-CLIP, CLIP}, {CLIP, CLIP}};	76	const glm::vec2 vertices[4] = { {-CLIP, -CLIP}, {CLIP, -CLIP}, {-CLIP, CLIP}, {CLIP, CLIP}};
77	theBuffer.reset(new gpu::Buffer(sizeof(vertices), (const gpu::Byte*) vertices));	77	theBuffer.reset(new gpu::Buffer(sizeof(vertices), (const gpu::Byte*) vertices));
78		78
@@ -110,7 +110,7 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky · 31 unmodified lines
110	} else {	110	} else {
111	// skybox has no cubemap, just clear the color buffer	111	// skybox has no cubemap, just clear the color buffer
112	auto color = skybox.getColor();	112	auto color = skybox.getColor();
113	batch.clearFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, glm::vec4(color, 0.0f), 0.f, 0);	113	batch.clearFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, glm::vec4(color, 0.0f), 0.0f, 0);
114	}	114	}
115	}	115	}
116		116

libraries/model/src/model/Stage.cpp+6−6

@@ -42,9 +42,9 @@ Mat4d EarthSunModel::evalWorldToGeoLocationMat(double longitude, double latitude · 41 unmodified lines
42		42
43	void EarthSunModel::updateWorldToSurface() const {	43	void EarthSunModel::updateWorldToSurface() const {
44	// Check if the final position is too close to the earth center ?	44	// Check if the final position is too close to the earth center ?
45	double absAltitude = _earthRadius + _altitude;	45	float absAltitude = _earthRadius + _altitude;
46	if ( absAltitude < 0.01) {	46	if ( absAltitude < 0.01f) {
47	absAltitude = 0.01;	47	absAltitude = 0.01f;
48	}	48	}
49		49
50	// Final world to local Frame	50	// Final world to local Frame
@@ -263,8 +263,8 @@ double evalSunDeclinaison(double dayNumber) { · 212 unmodified lines
263	void SunSkyStage::updateGraphicsObject() const {	263	void SunSkyStage::updateGraphicsObject() const {
264	// Always update the sunLongitude based on the current dayTime and the current origin	264	// Always update the sunLongitude based on the current dayTime and the current origin
265	// The day time is supposed to be local at the origin	265	// The day time is supposed to be local at the origin
266	double signedNormalizedDayTime = (_dayTime - NUM_HOURS_PER_HALF_DAY) / NUM_HOURS_PER_HALF_DAY;	266	float signedNormalizedDayTime = (_dayTime - NUM_HOURS_PER_HALF_DAY) / NUM_HOURS_PER_HALF_DAY;
267	double sunLongitude = _earthSunModel.getLongitude() + (MAX_LONGITUDE * signedNormalizedDayTime);	267	float sunLongitude = _earthSunModel.getLongitude() + (MAX_LONGITUDE * signedNormalizedDayTime);
268	_earthSunModel.setSunLongitude(sunLongitude);	268	_earthSunModel.setSunLongitude(sunLongitude);
269		269
270	// And update the sunLAtitude as the declinaison depending of the time of the year	270	// And update the sunLAtitude as the declinaison depending of the time of the year
@@ -302,4 +302,4 @@ void SunSkyStage::setBackgroundMode(BackgroundMode mode) { · 31 unmodified lines
302	void SunSkyStage::setSkybox(const SkyboxPointer& skybox) {	302	void SunSkyStage::setSkybox(const SkyboxPointer& skybox) {
303	_skybox = skybox;	303	_skybox = skybox;
304	invalidate();	304	invalidate();
305	}	305	}

libraries/model/src/model/Stage.h+1−1

@@ -72,7 +72,7 @@ public: · 71 unmodified lines
72		72
73	protected:	73	protected:
74	float _scale = 1000.0f; //Km	74	float _scale = 1000.0f; //Km
75	double _earthRadius = 6360.0;	75	float _earthRadius = 6360.0;
76		76
77	Quat _surfaceOrientation;	77	Quat _surfaceOrientation;
78		78

libraries/networking/src/AddressManager.cpp+4−0

                             handlePath(returnedPath, trigger);
                         }
                     } else {
+                        // we're going to hit the index path, set that as the _newHostLookupPath
+                        _newHostLookupPath = INDEX_PATH;
                         // we didn't override the path or get one back - ask the DS for the viewpoint of its index path
                         // which we will jump to if it exists
                         emit pathChangeRequired(INDEX_PATH);
         // We use _newHostLookupPath to determine if the client has already stored its last address
         // before moving to a new host thanks to the information in the same lookup URL.
         if (definitelyPathOnly || (!pathString.isEmpty() && pathString != _newHostLookupPath)) {
             addCurrentAddressToHistory(LookupTrigger::UserInput);
         }

libraries/networking/src/AddressManager.h+3−0

@@ -62,6 +62,9 @@ public: · 61 unmodified lines
62		62
63	void loadSettings(const QString& lookupString = QString());	63	void loadSettings(const QString& lookupString = QString());
64		64
		65	const QStack<QUrl>& getBackStack() const { return _backStack; }
		66	const QStack<QUrl>& getForwardStack() const { return _forwardStack; }
		67
65	public slots:	68	public slots:
66	void handleLookupString(const QString& lookupString);	69	void handleLookupString(const QString& lookupString);
67		70

libraries/networking/src/BandwidthRecorder.cpp+2−2

@@ -21,7 +21,7 @@ BandwidthRecorder::Channel::Channel() { · 20 unmodified lines
21	float BandwidthRecorder::Channel::getAverageInputPacketsPerSecond() {	21	float BandwidthRecorder::Channel::getAverageInputPacketsPerSecond() {
22	float delt = _input.getEventDeltaAverage();	22	float delt = _input.getEventDeltaAverage();
23	if (delt > 0.0f) {	23	if (delt > 0.0f) {
24	return (1.0 / delt);	24	return (1.0f / delt);
25	}	25	}
26	return 0.0f;	26	return 0.0f;
27	}	27	}
@@ -29,7 +29,7 @@ float BandwidthRecorder::Channel::getAverageInputPacketsPerSecond() { · 1 unmodified line
29	float BandwidthRecorder::Channel::getAverageOutputPacketsPerSecond() {	29	float BandwidthRecorder::Channel::getAverageOutputPacketsPerSecond() {
30	float delt = _input.getEventDeltaAverage();	30	float delt = _input.getEventDeltaAverage();
31	if (delt > 0.0f) {	31	if (delt > 0.0f) {
32	return (1.0 / _output.getEventDeltaAverage());	32	return (1.0f / _output.getEventDeltaAverage());
33	}	33	}
34	return 0.0f;	34	return 0.0f;
35	}	35	}

libraries/octree/src/CoverageMap.cpp+1−1

@@ -75,7 +75,7 @@ CoverageMap::~CoverageMap() { · 74 unmodified lines
75		75
76	void CoverageMap::printStats() {	76	void CoverageMap::printStats() {
77	qCDebug(octree, "CoverageMap::printStats()...");	77	qCDebug(octree, "CoverageMap::printStats()...");
78	qCDebug(octree, "MINIMUM_POLYGON_AREA_TO_STORE=%f",MINIMUM_POLYGON_AREA_TO_STORE);	78	qCDebug(octree, "MINIMUM_POLYGON_AREA_TO_STORE=%f", (double)MINIMUM_POLYGON_AREA_TO_STORE);
79	qCDebug(octree, "_mapCount=%d",_mapCount);	79	qCDebug(octree, "_mapCount=%d",_mapCount);
80	qCDebug(octree, "_checkMapRootCalls=%d",_checkMapRootCalls);	80	qCDebug(octree, "_checkMapRootCalls=%d",_checkMapRootCalls);
81	qCDebug(octree, "_notAllInView=%d",_notAllInView);	81	qCDebug(octree, "_notAllInView=%d",_notAllInView);

libraries/octree/src/CoverageMapV2.cpp+1−1

@@ -82,7 +82,7 @@ void CoverageMapV2::erase() { · 81 unmodified lines
82		82
83	if (_isRoot && wantDebugging) {	83	if (_isRoot && wantDebugging) {
84	qCDebug(octree, "CoverageMapV2 last to be deleted...");	84	qCDebug(octree, "CoverageMapV2 last to be deleted...");
85	qCDebug(octree, "MINIMUM_POLYGON_AREA_TO_STORE=%f",MINIMUM_POLYGON_AREA_TO_STORE);	85	qCDebug(octree, "MINIMUM_POLYGON_AREA_TO_STORE=%f", (double)MINIMUM_POLYGON_AREA_TO_STORE);
86	qCDebug(octree, "_mapCount=%d",_mapCount);	86	qCDebug(octree, "_mapCount=%d",_mapCount);
87	qCDebug(octree, "_checkMapRootCalls=%d",_checkMapRootCalls);	87	qCDebug(octree, "_checkMapRootCalls=%d",_checkMapRootCalls);
88	qCDebug(octree, "_notAllInView=%d",_notAllInView);	88	qCDebug(octree, "_notAllInView=%d",_notAllInView);

libraries/octree/src/OctreeElement.cpp+28−26

     // set up the _children union
     _childBitmask = 0;
     _childrenExternal = false;
 #ifdef BLENDED_UNION_CHILDREN
     _children.external = NULL;
     _singleChildrenCount++;
             delete childAt;
         }
     }
     if (_childrenExternal) {
         // if the children_t union represents _children.external we need to delete it here
         delete[] _children.external;
         memset(_children.external, 0, sizeof(OctreeElement*) * NUMBER_OF_CHILDREN);
         _children.external[firstIndex] = previousChild;
         _children.external[childIndex] = child;
         _childrenExternal = true;
         _externalChildrenMemoryUsage += NUMBER_OF_CHILDREN * sizeof(OctreeElement*);
         delete[] _children.external;
         _childrenExternal = false;
         _externalChildrenMemoryUsage -= NUMBER_OF_CHILDREN * sizeof(OctreeElement*);
         if (childIndex == firstIndex) {
             _children.single = previousSecondChild;
             setAtBit(childBits,i);
         }
     }
     QDebug elementDebug = qDebug().nospace();
     QString resultString;
     resultString.sprintf("%s - Voxel at corner=(%f,%f,%f) size=%f\n isLeaf=%s isDirty=%s shouldRender=%s\n children=", label,
-                         _cube.getCorner().x, _cube.getCorner().y, _cube.getCorner().z, _cube.getScale(),
+                         (double)_cube.getCorner().x, (double)_cube.getCorner().y, (double)_cube.getCorner().z,
+                         (double)_cube.getScale(),
                          debug::valueOf(isLeaf()), debug::valueOf(isDirty()), debug::valueOf(getShouldRender()));
     elementDebug << resultString;
 //    By doing this, we don't need to test each child voxel's position vs the LOD boundary
 bool OctreeElement::calculateShouldRender(const ViewFrustum* viewFrustum, float voxelScaleSize, int boundaryLevelAdjust) const {
     bool shouldRender = false;
     if (hasContent()) {
         float furthestDistance = furthestDistanceToCamera(*viewFrustum);
         float childBoundary = boundaryDistanceForRenderLevel(getLevel() + 1 + boundaryLevelAdjust, voxelScaleSize);
 }
 bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face,
                          void** intersectedObject, bool precisionPicking) {
     keepSearching = true; // assume that we will continue searching after this.
     // for any details inside the cube to be closer so we don't need to consider them.
     if (_cube.contains(origin) || distanceToElementCube < distance) {
         if (findDetailedRayIntersection(origin, direction, keepSearching, element, distanceToElementDetails,
                                             face, intersectedObject, precisionPicking, distanceToElementCube)) {
             if (distanceToElementDetails < distance) {
 }
 bool OctreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face,
                          void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
     // we did hit this element, so calculate appropriate distances
     if (hasContent()) {
         element = this;
         distance = distanceToElementCube;
     float halfOurScale = ourScale / 2.0f;
     if(s > ourScale) {
-        qCDebug(octree, "UNEXPECTED -- OctreeElement::getOrCreateChildElementAt() s=[%f] > ourScale=[%f] ", s, ourScale);
+        qCDebug(octree, "UNEXPECTED -- OctreeElement::getOrCreateChildElementAt() s=[%f] > ourScale=[%f] ",
+                (double)s, (double)ourScale);
     }
     if (s > halfOurScale) {
 OctreeElement* OctreeElement::getOrCreateChildElementContaining(const AACube& cube) {
     OctreeElement* child = NULL;
     int childIndex = getMyChildContaining(cube);
     // If getMyChildContaining() returns CHILD_UNKNOWN then it means that our level
     // is the correct level for this cube
     if (childIndex == CHILD_UNKNOWN) {
         return this;
     }
     // Now, check if we have a child at that location
     child = getChildAtIndex(childIndex);
     if (!child) {
         child = addChildAtIndex(childIndex);
     }
     // if we've made a really small child, then go ahead and use that one.
     if (child->getScale() <= SMALLEST_REASONABLE_OCTREE_ELEMENT_SCALE) {
         return child;
 OctreeElement* OctreeElement::getOrCreateChildElementContaining(const AABox& box) {
     OctreeElement* child = NULL;
     int childIndex = getMyChildContaining(box);
     // If getMyChildContaining() returns CHILD_UNKNOWN then it means that our level
     // is the correct level for this cube
     if (childIndex == CHILD_UNKNOWN) {
         return this;
     }
     // Now, check if we have a child at that location
     child = getChildAtIndex(childIndex);
     if (!child) {
         child = addChildAtIndex(childIndex);
     }
     // if we've made a really small child, then go ahead and use that one.
     if (child->getScale() <= SMALLEST_REASONABLE_OCTREE_ELEMENT_SCALE) {
         return child;
         if (childIndexCubeMinimum != childIndexCubeMaximum) {
             return CHILD_UNKNOWN;
         }
         return childIndexCubeMinimum; // either would do, they are the same
     }
     return CHILD_UNKNOWN; // since cube is not contained in our element, it can't be in one of our children
     // TODO: consider changing this to assert()
     if(boxLargestScale > ourScale) {
         qCDebug(octree, "UNEXPECTED -- OctreeElement::getMyChildContaining() "
-                    "boxLargestScale=[%f] > ourScale=[%f] ", boxLargestScale, ourScale);
+                "boxLargestScale=[%f] > ourScale=[%f] ", (double)boxLargestScale, (double)ourScale);
     }
     // Determine which of our children the minimum and maximum corners of the cube live in...
         int childIndexCubeMinimum = getMyChildContainingPoint(cubeCornerMinimum);
         int childIndexCubeMaximum = getMyChildContainingPoint(cubeCornerMaximum);
         // If the minimum and maximum corners of the cube are in two different children's cubes,
         // then we are the containing element
         if (childIndexCubeMinimum != childIndexCubeMaximum) {
             return CHILD_UNKNOWN;
 int OctreeElement::getMyChildContainingPoint(const glm::vec3& point) const {
     glm::vec3 ourCenter = _cube.calcCenter();
     int childIndex = CHILD_UNKNOWN;
     // since point is not contained in our element, it can't be in one of our children
     if (!_cube.contains(point)) {
         return CHILD_UNKNOWN;
     }
     // left half
     if (point.x > ourCenter.x) {
         if (point.y > ourCenter.y) {

libraries/octree/src/OctreePacketData.cpp+5−3

 bool OctreePacketData::appendValue(const QVector<glm::vec3>& value) {
     uint16_t qVecSize = value.size();
     bool success = appendValue(qVecSize);
-    success = append((const unsigned char*)value.constData(), qVecSize * sizeof(glm::vec3));
     if (success) {
-        _bytesOfValues += qVecSize * sizeof(glm::vec3);
+        success = append((const unsigned char*)value.constData(), qVecSize * sizeof(glm::vec3));
-        _totalBytesOfValues += qVecSize * sizeof(glm::vec3);
+        if (success) {
+            _bytesOfValues += qVecSize * sizeof(glm::vec3);
+            _totalBytesOfValues += qVecSize * sizeof(glm::vec3);
+        }
     }
     return success;
 }

libraries/octree/src/OctreePersistThread.cpp+13−0

@@ -350,6 +350,19 @@ void OctreePersistThread::rollOldBackupVersions(const BackupRule& rule) { · 349 unmodified lines
350	if (rule.extensionFormat.contains("%N")) {	350	if (rule.extensionFormat.contains("%N")) {
351	if (rule.maxBackupVersions > 0) {	351	if (rule.maxBackupVersions > 0) {
352	qCDebug(octree) << "Rolling old backup versions for rule" << rule.name << "...";	352	qCDebug(octree) << "Rolling old backup versions for rule" << rule.name << "...";
		353
		354	// Delete maximum rolling file because rename() fails on Windows if target exists
		355	QString backupMaxExtensionN = rule.extensionFormat;
		356	backupMaxExtensionN.replace(QString("%N"), QString::number(rule.maxBackupVersions));
		357	QString backupMaxFilenameN = _filename + backupMaxExtensionN;
		358	QFile backupMaxFileN(backupMaxFilenameN);
		359	if (backupMaxFileN.exists()) {
		360	int result = remove(qPrintable(backupMaxFilenameN));
		361	if (result != 0) {
		362	qCDebug(octree) << "ERROR deleting old backup file " << backupMaxFilenameN;
		363	}
		364	}
		365
353	for(int n = rule.maxBackupVersions - 1; n > 0; n--) {	366	for(int n = rule.maxBackupVersions - 1; n > 0; n--) {
354	QString backupExtensionN = rule.extensionFormat;	367	QString backupExtensionN = rule.extensionFormat;
355	QString backupExtensionNplusOne = rule.extensionFormat;	368	QString backupExtensionNplusOne = rule.extensionFormat;

libraries/octree/src/OctreeProjectedPolygon.cpp+104−103

 void BoundingBox::printDebugDetails(const char* label) const {
     qCDebug(octree, "%s _set=%s\n    corner=%f,%f size=%f,%f\n    bounds=[(%f,%f) to (%f,%f)]",
-           (label ? label : "BoundingBox"),
+            (label ? label : "BoundingBox"),
-           debug::valueOf(_set), corner.x, corner.y, size.x, size.y, corner.x, corner.y, corner.x+size.x, corner.y+size.y);
+            debug::valueOf(_set), (double)corner.x, (double)corner.y, (double)size.x, (double)size.y,
+            (double)corner.x, (double)corner.y, (double)(corner.x+size.x), (double)(corner.y+size.y));
 }
 OctreeProjectedPolygon::OctreeProjectedPolygon(const BoundingBox& box) :
     _vertexCount(4),
     _maxX(-FLT_MAX), _maxY(-FLT_MAX), _minX(FLT_MAX), _minY(FLT_MAX),
     _distance(0)
 {
 }
 void OctreeProjectedPolygon::setVertex(int vertex, const glm::vec2& point) {
     _vertices[vertex] = point;
     // keep track of our bounding box
     if (point.x > _maxX) {
         _maxX = point.x;
     if (point.y < _minY) {
         _minY = point.y;
     }
 }
 // can be optimized with new pointInside()
 bool OctreeProjectedPolygon::occludes(const OctreeProjectedPolygon& occludee, bool checkAllInView) const {
     OctreeProjectedPolygon::occludes_calls++;
     // if we are completely out of view, then we definitely don't occlude!
     // if the occludee is completely out of view, then we also don't occlude it
     //
         (occludee.getMinY() < getMinY())) {
         return false;
     }
     // we need to test for identity as well, because in the case of identity, none of the points
     // will be "inside" but we don't want to bail early on the first non-inside point
     bool potentialIdenity = false;
     for(int i = 0; i < occludee.getVertexCount(); i++) {
         bool vertexMatched = false;
         if (!pointInside(occludee.getVertex(i), &vertexMatched)) {
             // so the point we just tested isn't inside, but it might have matched a vertex
             // if it didn't match a vertext, then we bail because we can't be an identity
             // or if we're not expecting identity, then we also bail early, no matter what
             pointsInside++;
         }
     }
     // we're only here if all points are inside matched and/or we had a potentialIdentity we need to check
     if (pointsInside == occludee.getVertexCount()) {
         return true;
     if (potentialIdenity) {
         return matches(occludee);
     }
     return false; // if we got this far, then we're not occluded
 }
     int originIndex = 0;
     for(int i = 0; i < vertextCount; i++) {
         glm::vec2 testeeVertex = testee.getVertex(i);
         // if they match, we found our origin.
         if (testeeVertex == polygonVertex) {
             originIndex = i;
         glm::vec2 testeeVertex  = testee.getVertex((i + originIndex) % vertextCount);
         glm::vec2 polygonVertex = getVertex(i);
         if (testeeVertex != polygonVertex) {
             return false; // we don't match, therefore we're not the same
         }
     }
     return true; // all of our vertices match, therefore we're the same
 }
 bool OctreeProjectedPolygon::matches(const BoundingBox& box) const {
             return false;
         }
     }
     return true;
 }
 void OctreeProjectedPolygon::printDebugDetails() const {
     qCDebug(octree, "OctreeProjectedPolygon..."
-           "    minX=%f maxX=%f minY=%f maxY=%f", getMinX(), getMaxX(), getMinY(), getMaxY());
+            "    minX=%f maxX=%f minY=%f maxY=%f", (double)getMinX(), (double)getMaxX(), (double)getMinY(), (double)getMaxY());
-    qCDebug(octree, "    vertex count=%d distance=%f", getVertexCount(), getDistance());
+    qCDebug(octree, "    vertex count=%d distance=%f", getVertexCount(), (double)getDistance());
     for (int i = 0; i < getVertexCount(); i++) {
         glm::vec2 point = getVertex(i);
-        qCDebug(octree, "    vertex[%d] = %f, %f ", i, point.x, point.y);
+        qCDebug(octree, "    vertex[%d] = %f, %f ", i, (double)point.x, (double)point.y);
     }
 }
 // intersect on all axes.
 //
 // Note: this only works on convex polygons
 //
 //
 bool OctreeProjectedPolygon::intersectsOnAxes(const OctreeProjectedPolygon& testee) const {
         // points that are ON the edge, are considered to be "outside"
         for (int j = 0; j < testee.getVertexCount(); j++) {
             glm::vec2 testeeVertex = testee.getVertex(j);
             // in comparison below:
             //      >= will cause points on edge to be considered inside
             //      >  will cause points on edge to be considered outside
             float c2 = a * testeeVertex.x + b * testeeVertex.y;
             if (c2 >= c) {
                 goto CONTINUE_OUTER;
     // RIGHT/NEAR
     // LEFT/NEAR
     if (
         (getProjectionType() == that.getProjectionType()) &&
         (
              getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR) ||
              getProjectionType() == (PROJECTION_LEFT | PROJECTION_NEAR)
         )
        ) {
         if (getVertex(1) == that.getVertex(0) && getVertex(4) == that.getVertex(5)) {
             return true;
     // NEAR/BOTTOM
     if (
         (getProjectionType() == that.getProjectionType()) &&
         (
              getProjectionType() == (PROJECTION_NEAR | PROJECTION_BOTTOM)
         )
        ) {
         if (getVertex(0) == that.getVertex(5) && getVertex(3) == that.getVertex(4)) {
             return true;
     // NEAR/TOP
     if (
         (getProjectionType() == that.getProjectionType()) &&
         (
              getProjectionType() == (PROJECTION_NEAR | PROJECTION_TOP)
         )
        ) {
         if (getVertex(0) == that.getVertex(5) && getVertex(1) == that.getVertex(2)) {
             return true;
     // RIGHT/NEAR & NEAR/RIGHT/TOP
     // LEFT/NEAR  & NEAR/LEFT/TOP
     if (
             ((getProjectionType()     == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_TOP)) &&
             (that.getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR)))
             ||
             ((getProjectionType()     == (PROJECTION_LEFT  | PROJECTION_NEAR | PROJECTION_TOP)) &&
             (that.getProjectionType() == (PROJECTION_LEFT  | PROJECTION_NEAR)))
         )
     {
         if (getVertex(5) == that.getVertex(0) && getVertex(3) == that.getVertex(2)) {
     // RIGHT/NEAR & NEAR/RIGHT/TOP
     // LEFT/NEAR  & NEAR/LEFT/TOP
     if (
             ((that.getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_TOP)) &&
             (getProjectionType()       == (PROJECTION_RIGHT | PROJECTION_NEAR)))
             ||
             ((that.getProjectionType() == (PROJECTION_LEFT  | PROJECTION_NEAR | PROJECTION_TOP)) &&
             (getProjectionType()       == (PROJECTION_LEFT  | PROJECTION_NEAR)))
         )
     {
         if (getVertex(0) == that.getVertex(5) && getVertex(2) == that.getVertex(3)) {
     // RIGHT/NEAR & NEAR/RIGHT/BOTTOM
     // NEAR/LEFT & NEAR/LEFT/BOTTOM
     if (
             ((that.getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_BOTTOM)) &&
             (getProjectionType()       == (PROJECTION_RIGHT | PROJECTION_NEAR)))
             ||
             ((that.getProjectionType() == (PROJECTION_LEFT | PROJECTION_NEAR | PROJECTION_BOTTOM)) &&
             (getProjectionType()       == (PROJECTION_LEFT | PROJECTION_NEAR)))
         )
     {
         if (getVertex(5) == that.getVertex(0) && getVertex(3) == that.getVertex(2)) {
     // RIGHT/NEAR & NEAR/RIGHT/BOTTOM
     // NEAR/LEFT & NEAR/LEFT/BOTTOM
     if (
             ((getProjectionType()     == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_BOTTOM)) &&
             (that.getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR)))
             ||
             ((getProjectionType()     == (PROJECTION_LEFT | PROJECTION_NEAR | PROJECTION_BOTTOM)) &&
             (that.getProjectionType() == (PROJECTION_LEFT | PROJECTION_NEAR)))
         )
     {
         if (getVertex(0) == that.getVertex(5) && getVertex(2) == that.getVertex(3)) {
     // NEAR/TOP & NEAR
     if (
             (getProjectionType()      == (PROJECTION_NEAR                   )) &&
             (that.getProjectionType() == (PROJECTION_NEAR  | PROJECTION_TOP ))
         )
     {
         if (getVertex(0) == that.getVertex(5) && getVertex(1) == that.getVertex(2)) {
     // NEAR/TOP & NEAR
     if (
             (that.getProjectionType() == (PROJECTION_NEAR                   )) &&
             (getProjectionType()      == (PROJECTION_NEAR  | PROJECTION_TOP ))
         )
     {
         if (getVertex(5) == that.getVertex(0) && getVertex(2) == that.getVertex(1)) {
     // NEAR/BOTTOM & NEAR
     if (
             (getProjectionType()      == (PROJECTION_NEAR                      )) &&
             (that.getProjectionType() == (PROJECTION_NEAR  | PROJECTION_BOTTOM ))
         )
     {
         if (getVertex(2) == that.getVertex(3) && getVertex(3) == that.getVertex(0)) {
     // NEAR/BOTTOM & NEAR
     if (
             (that.getProjectionType() == (PROJECTION_NEAR                      )) &&
             (getProjectionType()      == (PROJECTION_NEAR  | PROJECTION_BOTTOM ))
         )
     {
         if (getVertex(3) == that.getVertex(2) && getVertex(0) == that.getVertex(3)) {
     // NEAR/RIGHT & NEAR
     if (
             (getProjectionType()      == (PROJECTION_NEAR                      )) &&
             (that.getProjectionType() == (PROJECTION_NEAR  | PROJECTION_RIGHT ))
         )
     {
         if (getVertex(0) == that.getVertex(1) && getVertex(3) == that.getVertex(4)) {
     // NEAR/RIGHT & NEAR
     if (
             (that.getProjectionType() == (PROJECTION_NEAR                      )) &&
             (getProjectionType()      == (PROJECTION_NEAR  | PROJECTION_RIGHT ))
         )
     {
         if (getVertex(1) == that.getVertex(0) && getVertex(4) == that.getVertex(3)) {
             return true;
         }
     }
     // NEAR/LEFT & NEAR
     if (
             (getProjectionType()      == (PROJECTION_NEAR                    )) &&
             (that.getProjectionType() == (PROJECTION_NEAR  | PROJECTION_LEFT ))
         )
     {
         if (getVertex(1) == that.getVertex(1) && getVertex(2) == that.getVertex(4)) {
     // NEAR/LEFT & NEAR
     if (
             (that.getProjectionType() == (PROJECTION_NEAR                    )) &&
             (getProjectionType()      == (PROJECTION_NEAR  | PROJECTION_LEFT ))
         )
     {
         if (getVertex(1) == that.getVertex(0) && getVertex(4) == that.getVertex(3)) {
             return true;
         }
     }
     // NEAR/RIGHT/BOTTOM & NEAR/BOTTOM
     if (
             return true;
         }
     }
     // NEAR/LEFT/BOTTOM & NEAR/BOTTOM
     if (
             ((getProjectionType()     == (PROJECTION_BOTTOM | PROJECTION_NEAR                     )) &&
         if (getVertex(2) == that.getVertex(0) && getVertex(4) == that.getVertex(4)) {
             return true;
         }
     }
     // NEAR/LEFT/BOTTOM & NEAR/BOTTOM
     if (
             ((that.getProjectionType() == (PROJECTION_BOTTOM | PROJECTION_NEAR                     )) &&
             (getProjectionType()       == (PROJECTION_BOTTOM | PROJECTION_NEAR  | PROJECTION_LEFT )))
         )
     {
         if (getVertex(0) == that.getVertex(2) && getVertex(4) == that.getVertex(4)) {
     // LEFT/NEAR/BOTTOM
     // LEFT/NEAR/TOP
     if (
             (getProjectionType() == that.getProjectionType()) &&
             (
                 getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_BOTTOM ) ||
                 getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_TOP    ) ||
     // RIGHT/NEAR
     // LEFT/NEAR
     if (
         (getProjectionType() == that.getProjectionType()) &&
         (
              getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR) ||
              getProjectionType() == (PROJECTION_LEFT  | PROJECTION_NEAR)
         )
        ) {
         if (getVertex(1) == that.getVertex(0) && getVertex(4) == that.getVertex(5)) {
             //setVertex(0, this.getVertex(0)); // no change
             return; // done
         }
     }
     // NEAR/BOTTOM
     if (
         (getProjectionType() == that.getProjectionType()) &&
         (
              getProjectionType() == (PROJECTION_NEAR | PROJECTION_BOTTOM)
         )
        ) {
         if (getVertex(0) == that.getVertex(5) && getVertex(3) == that.getVertex(4)) {
             setVertex(0, that.getVertex(0));
     // NEAR/TOP
     if (
         (getProjectionType() == that.getProjectionType()) &&
         (
              getProjectionType() == (PROJECTION_NEAR | PROJECTION_TOP)
         )
        ) {
         if (getVertex(0) == that.getVertex(5) && getVertex(1) == that.getVertex(2)) {
             setVertex(0, that.getVertex(0));
             return; // done
         }
     }
     // RIGHT/NEAR & NEAR/RIGHT/TOP
     // LEFT/NEAR  & NEAR/LEFT/TOP
     if (
             ((getProjectionType()     == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_TOP)) &&
             (that.getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR)))
             ||
             ((getProjectionType()     == (PROJECTION_LEFT  | PROJECTION_NEAR | PROJECTION_TOP)) &&
             (that.getProjectionType() == (PROJECTION_LEFT  | PROJECTION_NEAR)))
         )
     {
         if (getVertex(5) == that.getVertex(0) && getVertex(3) == that.getVertex(2)) {
     // RIGHT/NEAR & NEAR/RIGHT/TOP
     // LEFT/NEAR  & NEAR/LEFT/TOP
     if (
             ((that.getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_TOP)) &&
             (getProjectionType()       == (PROJECTION_RIGHT | PROJECTION_NEAR)))
             ||
             ((that.getProjectionType() == (PROJECTION_LEFT  | PROJECTION_NEAR | PROJECTION_TOP)) &&
             (getProjectionType()       == (PROJECTION_LEFT  | PROJECTION_NEAR)))
         )
     {
         if (getVertex(0) == that.getVertex(5) && getVertex(2) == that.getVertex(3)) {
     // RIGHT/NEAR & NEAR/RIGHT/BOTTOM
     // NEAR/LEFT & NEAR/LEFT/BOTTOM
     if (
             ((that.getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_BOTTOM)) &&
             (getProjectionType()       == (PROJECTION_RIGHT | PROJECTION_NEAR)))
             ||
             ((that.getProjectionType() == (PROJECTION_LEFT | PROJECTION_NEAR | PROJECTION_BOTTOM)) &&
             (getProjectionType()       == (PROJECTION_LEFT | PROJECTION_NEAR)))
         )
     {
         if (getVertex(5) == that.getVertex(0) && getVertex(3) == that.getVertex(2)) {
     // RIGHT/NEAR & NEAR/RIGHT/BOTTOM
     // NEAR/LEFT & NEAR/LEFT/BOTTOM
     if (
             ((getProjectionType()     == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_BOTTOM)) &&
             (that.getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR)))
             ||
             ((getProjectionType()     == (PROJECTION_LEFT | PROJECTION_NEAR | PROJECTION_BOTTOM)) &&
             (that.getProjectionType() == (PROJECTION_LEFT | PROJECTION_NEAR)))
         )
     {
         if (getVertex(0) == that.getVertex(5) && getVertex(2) == that.getVertex(3)) {
             //setVertex(3, this.getVertex(3)); // no change
             //setVertex(4, this.getVertex(4)); // no change
             //setVertex(5, this.getVertex(5)); // no change
             setProjectionType((PROJECTION_RIGHT | PROJECTION_NEAR));
             return; // done
         }
     }
     // NEAR/TOP & NEAR
     if (
             (getProjectionType()      == (PROJECTION_NEAR                   )) &&
             (that.getProjectionType() == (PROJECTION_NEAR  | PROJECTION_TOP ))
         )
     {
         if (getVertex(0) == that.getVertex(5) && getVertex(1) == that.getVertex(2)) {
     // NEAR/TOP & NEAR
     if (
             (that.getProjectionType() == (PROJECTION_NEAR                   )) &&
             (getProjectionType()      == (PROJECTION_NEAR  | PROJECTION_TOP ))
         )
     {
         if (getVertex(5) == that.getVertex(0) && getVertex(2) == that.getVertex(1)) {
             return; // done
         }
     }
     // NEAR/BOTTOM & NEAR
     if (
             (getProjectionType()      == (PROJECTION_NEAR                      )) &&
             (that.getProjectionType() == (PROJECTION_NEAR  | PROJECTION_BOTTOM ))
         )
     {
         if (getVertex(2) == that.getVertex(3) && getVertex(3) == that.getVertex(0)) {
     // NEAR/BOTTOM & NEAR
     if (
             (that.getProjectionType() == (PROJECTION_NEAR                      )) &&
             (getProjectionType()      == (PROJECTION_NEAR  | PROJECTION_BOTTOM ))
         )
     {
         if (getVertex(3) == that.getVertex(2) && getVertex(0) == that.getVertex(3)) {
     // NEAR/RIGHT & NEAR
     if (
             (getProjectionType()      == (PROJECTION_NEAR                      )) &&
             (that.getProjectionType() == (PROJECTION_NEAR  | PROJECTION_RIGHT ))
         )
     {
         if (getVertex(0) == that.getVertex(1) && getVertex(3) == that.getVertex(4)) {
     // NEAR/RIGHT & NEAR
     if (
             (that.getProjectionType() == (PROJECTION_NEAR                      )) &&
             (getProjectionType()      == (PROJECTION_NEAR  | PROJECTION_RIGHT ))
         )
     {
         if (getVertex(1) == that.getVertex(0) && getVertex(4) == that.getVertex(3)) {
     // NEAR/LEFT & NEAR
     if (
             (getProjectionType()      == (PROJECTION_NEAR                    )) &&
             (that.getProjectionType() == (PROJECTION_NEAR  | PROJECTION_LEFT ))
         )
     {
         if (getVertex(1) == that.getVertex(1) && getVertex(2) == that.getVertex(4)) {
     // NEAR/LEFT & NEAR
     if (
             (that.getProjectionType() == (PROJECTION_NEAR                    )) &&
             (getProjectionType()      == (PROJECTION_NEAR  | PROJECTION_LEFT ))
         )
     {
         if (getVertex(1) == that.getVertex(0) && getVertex(4) == that.getVertex(3)) {
     // NEAR/LEFT/BOTTOM & NEAR/BOTTOM
     if (
             ((that.getProjectionType() == (PROJECTION_BOTTOM | PROJECTION_NEAR                     )) &&
             (getProjectionType()       == (PROJECTION_BOTTOM | PROJECTION_NEAR  | PROJECTION_LEFT )))
         )
     {
         if (getVertex(0) == that.getVertex(2) && getVertex(4) == that.getVertex(4)) {
     // LEFT/NEAR/BOTTOM
     // LEFT/NEAR/TOP
     if (
             (getProjectionType() == that.getProjectionType()) &&
             (
                 getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_BOTTOM ) ||
                 getProjectionType() == (PROJECTION_RIGHT | PROJECTION_NEAR | PROJECTION_TOP    ) ||

libraries/octree/src/OctreeSceneStats.cpp+3−3

libraries/octree/src/Plane.cpp+2−1

@@ -66,5 +66,6 @@ float Plane::distance(const glm::vec3 &point) const { · 65 unmodified lines
66		66
67	void Plane::print() const {	67	void Plane::print() const {
68	qCDebug(octree, "Plane - point (x=%f y=%f z=%f) normal (x=%f y=%f z=%f) d=%f",	68	qCDebug(octree, "Plane - point (x=%f y=%f z=%f) normal (x=%f y=%f z=%f) d=%f",
69	_point.x, _point.y, _point.z, _normal.x, _normal.y, _normal.z, _dCoefficient);	69	(double)_point.x, (double)_point.y, (double)_point.z,
		70	(double)_normal.x, (double)_normal.y, (double)_normal.z, (double)_dCoefficient);
70	}	71	}

libraries/octree/src/ViewFrustum.cpp+57−55

@@ -65,9 +65,10 @@ void ViewFrustum::setProjection(const glm::mat4& projection) { · 64 unmodified lines
65	_farClip = -_corners[BOTTOM_LEFT_FAR].z;	65	_farClip = -_corners[BOTTOM_LEFT_FAR].z;
66	_aspectRatio = (_corners[TOP_RIGHT_NEAR].x - _corners[BOTTOM_LEFT_NEAR].x) /	66	_aspectRatio = (_corners[TOP_RIGHT_NEAR].x - _corners[BOTTOM_LEFT_NEAR].x) /
67	(_corners[TOP_RIGHT_NEAR].y - _corners[BOTTOM_LEFT_NEAR].y);	67	(_corners[TOP_RIGHT_NEAR].y - _corners[BOTTOM_LEFT_NEAR].y);
68	glm::vec3 right = glm::normalize(glm::vec3(_corners[TOP_RIGHT_NEAR]));	68
69	glm::vec3 left = glm::normalize(glm::vec3(_corners[TOP_LEFT_NEAR]));	69	glm::vec4 top = _inverseProjection * vec4(0, 1, -1, 1);
70	_fieldOfView = abs(glm::degrees(glm::angle(right, left)));	70	top /= top.w;
		71	_fieldOfView = abs(glm::degrees(2.0f * abs(glm::angle(vec3(0, 0, -1), glm::normalize(vec3(top))))));
71	}	72	}
72		73
73	// ViewFrustum::calculateViewFrustum()	74	// ViewFrustum::calculateViewFrustum()
@@ -387,36 +388,36 @@ bool ViewFrustum::matches(const ViewFrustum& compareTo, bool debug) const { · 313 unmodified lines
387	if (!result && debug) {	388	if (!result && debug) {
388	qCDebug(octree, "ViewFrustum::matches()... result=%s", debug::valueOf(result));	389	qCDebug(octree, "ViewFrustum::matches()... result=%s", debug::valueOf(result));
389	qCDebug(octree, "%s -- compareTo._position=%f,%f,%f _position=%f,%f,%f",	390	qCDebug(octree, "%s -- compareTo._position=%f,%f,%f _position=%f,%f,%f",
390	(testMatches(compareTo._position,_position) ? "MATCHES " : "NO MATCH"),	391	(testMatches(compareTo._position,_position) ? "MATCHES " : "NO MATCH"),
391	compareTo._position.x, compareTo._position.y, compareTo._position.z,	392	(double)compareTo._position.x, (double)compareTo._position.y, (double)compareTo._position.z,
392	_position.x, _position.y, _position.z );	393	(double)_position.x, (double)_position.y, (double)_position.z);
393	qCDebug(octree, "%s -- compareTo._direction=%f,%f,%f _direction=%f,%f,%f",	394	qCDebug(octree, "%s -- compareTo._direction=%f,%f,%f _direction=%f,%f,%f",
394	(testMatches(compareTo._direction, _direction) ? "MATCHES " : "NO MATCH"),	395	(testMatches(compareTo._direction, _direction) ? "MATCHES " : "NO MATCH"),
395	compareTo._direction.x, compareTo._direction.y, compareTo._direction.z,	396	(double)compareTo._direction.x, (double)compareTo._direction.y, (double)compareTo._direction.z,
396	_direction.x, _direction.y, _direction.z );	397	(double)_direction.x, (double)_direction.y, (double)_direction.z );
397	qCDebug(octree, "%s -- compareTo._up=%f,%f,%f _up=%f,%f,%f",	398	qCDebug(octree, "%s -- compareTo._up=%f,%f,%f _up=%f,%f,%f",
398	(testMatches(compareTo._up, _up) ? "MATCHES " : "NO MATCH"),	399	(testMatches(compareTo._up, _up) ? "MATCHES " : "NO MATCH"),
399	compareTo._up.x, compareTo._up.y, compareTo._up.z,	400	(double)compareTo._up.x, (double)compareTo._up.y, (double)compareTo._up.z,
400	_up.x, _up.y, _up.z );	401	(double)_up.x, (double)_up.y, (double)_up.z );
401	qCDebug(octree, "%s -- compareTo._right=%f,%f,%f _right=%f,%f,%f",	402	qCDebug(octree, "%s -- compareTo._right=%f,%f,%f _right=%f,%f,%f",
402	(testMatches(compareTo._right, _right) ? "MATCHES " : "NO MATCH"),	403	(testMatches(compareTo._right, _right) ? "MATCHES " : "NO MATCH"),
403	compareTo._right.x, compareTo._right.y, compareTo._right.z,	404	(double)compareTo._right.x, (double)compareTo._right.y, (double)compareTo._right.z,
404	_right.x, _right.y, _right.z );	405	(double)_right.x, (double)_right.y, (double)_right.z );
405	qCDebug(octree, "%s -- compareTo._fieldOfView=%f _fieldOfView=%f",	406	qCDebug(octree, "%s -- compareTo._fieldOfView=%f _fieldOfView=%f",
406	(testMatches(compareTo._fieldOfView, _fieldOfView) ? "MATCHES " : "NO MATCH"),	407	(testMatches(compareTo._fieldOfView, _fieldOfView) ? "MATCHES " : "NO MATCH"),
407	compareTo._fieldOfView, _fieldOfView);	408	(double)compareTo._fieldOfView, (double)_fieldOfView);
408	qCDebug(octree, "%s -- compareTo._aspectRatio=%f _aspectRatio=%f",	409	qCDebug(octree, "%s -- compareTo._aspectRatio=%f _aspectRatio=%f",
409	(testMatches(compareTo._aspectRatio, _aspectRatio) ? "MATCHES " : "NO MATCH"),	410	(testMatches(compareTo._aspectRatio, _aspectRatio) ? "MATCHES " : "NO MATCH"),
410	compareTo._aspectRatio, _aspectRatio);	411	(double)compareTo._aspectRatio, (double)_aspectRatio);
411	qCDebug(octree, "%s -- compareTo._nearClip=%f _nearClip=%f",	412	qCDebug(octree, "%s -- compareTo._nearClip=%f _nearClip=%f",
412	(testMatches(compareTo._nearClip, _nearClip) ? "MATCHES " : "NO MATCH"),	413	(testMatches(compareTo._nearClip, _nearClip) ? "MATCHES " : "NO MATCH"),
413	compareTo._nearClip, _nearClip);	414	(double)compareTo._nearClip, (double)_nearClip);
414	qCDebug(octree, "%s -- compareTo._farClip=%f _farClip=%f",	415	qCDebug(octree, "%s -- compareTo._farClip=%f _farClip=%f",
415	(testMatches(compareTo._farClip, _farClip) ? "MATCHES " : "NO MATCH"),	416	(testMatches(compareTo._farClip, _farClip) ? "MATCHES " : "NO MATCH"),
416	compareTo._farClip, _farClip);	417	(double)compareTo._farClip, (double)_farClip);
417	qCDebug(octree, "%s -- compareTo._focalLength=%f _focalLength=%f",	418	qCDebug(octree, "%s -- compareTo._focalLength=%f _focalLength=%f",
418	(testMatches(compareTo._focalLength, _focalLength) ? "MATCHES " : "NO MATCH"),	419	(testMatches(compareTo._focalLength, _focalLength) ? "MATCHES " : "NO MATCH"),
419	compareTo._focalLength, _focalLength);	420	(double)compareTo._focalLength, (double)_focalLength);
420	}	421	}
421	return result;	422	return result;
422	}	423	}
@@ -448,33 +449,34 @@ bool ViewFrustum::isVerySimilar(const ViewFrustum& compareTo, bool debug) const · 25 unmodified lines
448	if (!result && debug) {	449	if (!result && debug) {
449	qCDebug(octree, "ViewFrustum::isVerySimilar()... result=%s\n", debug::valueOf(result));	450	qCDebug(octree, "ViewFrustum::isVerySimilar()... result=%s\n", debug::valueOf(result));
450	qCDebug(octree, "%s -- compareTo._position=%f,%f,%f _position=%f,%f,%f",	451	qCDebug(octree, "%s -- compareTo._position=%f,%f,%f _position=%f,%f,%f",
451	(testMatches(compareTo._position,_position, POSITION_SIMILAR_ENOUGH) ? "IS SIMILAR ENOUGH " : "IS NOT SIMILAR ENOUGH"),	452	(testMatches(compareTo._position,_position, POSITION_SIMILAR_ENOUGH) ?
452	compareTo._position.x, compareTo._position.y, compareTo._position.z,	453	"IS SIMILAR ENOUGH " : "IS NOT SIMILAR ENOUGH"),
453	_position.x, _position.y, _position.z );	454	(double)compareTo._position.x, (double)compareTo._position.y, (double)compareTo._position.z,
		455	(double)_position.x, (double)_position.y, (double)_position.z );
454		456
455	qCDebug(octree, "%s -- positionDistance=%f",	457	qCDebug(octree, "%s -- positionDistance=%f",
456	(testMatches(0,positionDistance, POSITION_SIMILAR_ENOUGH) ? "IS SIMILAR ENOUGH " : "IS NOT SIMILAR ENOUGH"),	458	(testMatches(0,positionDistance, POSITION_SIMILAR_ENOUGH) ? "IS SIMILAR ENOUGH " : "IS NOT SIMILAR ENOUGH"),
457	positionDistance);	459	(double)positionDistance);
458		460
459	qCDebug(octree, "%s -- angleOrientation=%f",	461	qCDebug(octree, "%s -- angleOrientation=%f",
460	(testMatches(0, angleOrientation, ORIENTATION_SIMILAR_ENOUGH) ? "IS SIMILAR ENOUGH " : "IS NOT SIMILAR ENOUGH"),	462	(testMatches(0, angleOrientation, ORIENTATION_SIMILAR_ENOUGH) ? "IS SIMILAR ENOUGH " : "IS NOT SIMILAR ENOUGH"),
461	angleOrientation);	463	(double)angleOrientation);
462		464
463	qCDebug(octree, "%s -- compareTo._fieldOfView=%f _fieldOfView=%f",	465	qCDebug(octree, "%s -- compareTo._fieldOfView=%f _fieldOfView=%f",
464	(testMatches(compareTo._fieldOfView, _fieldOfView) ? "MATCHES " : "NO MATCH"),	466	(testMatches(compareTo._fieldOfView, _fieldOfView) ? "MATCHES " : "NO MATCH"),
465	compareTo._fieldOfView, _fieldOfView);	467	(double)compareTo._fieldOfView, (double)_fieldOfView);
466	qCDebug(octree, "%s -- compareTo._aspectRatio=%f _aspectRatio=%f",	468	qCDebug(octree, "%s -- compareTo._aspectRatio=%f _aspectRatio=%f",
467	(testMatches(compareTo._aspectRatio, _aspectRatio) ? "MATCHES " : "NO MATCH"),	469	(testMatches(compareTo._aspectRatio, _aspectRatio) ? "MATCHES " : "NO MATCH"),
468	compareTo._aspectRatio, _aspectRatio);	470	(double)compareTo._aspectRatio, (double)_aspectRatio);
469	qCDebug(octree, "%s -- compareTo._nearClip=%f _nearClip=%f",	471	qCDebug(octree, "%s -- compareTo._nearClip=%f _nearClip=%f",
470	(testMatches(compareTo._nearClip, _nearClip) ? "MATCHES " : "NO MATCH"),	472	(testMatches(compareTo._nearClip, _nearClip) ? "MATCHES " : "NO MATCH"),
471	compareTo._nearClip, _nearClip);	473	(double)compareTo._nearClip, (double)_nearClip);
472	qCDebug(octree, "%s -- compareTo._farClip=%f _farClip=%f",	474	qCDebug(octree, "%s -- compareTo._farClip=%f _farClip=%f",
473	(testMatches(compareTo._farClip, _farClip) ? "MATCHES " : "NO MATCH"),	475	(testMatches(compareTo._farClip, _farClip) ? "MATCHES " : "NO MATCH"),
474	compareTo._farClip, _farClip);	476	(double)compareTo._farClip, (double)_farClip);
475	qCDebug(octree, "%s -- compareTo._focalLength=%f _focalLength=%f",	477	qCDebug(octree, "%s -- compareTo._focalLength=%f _focalLength=%f",
476	(testMatches(compareTo._focalLength, _focalLength) ? "MATCHES " : "NO MATCH"),	478	(testMatches(compareTo._focalLength, _focalLength) ? "MATCHES " : "NO MATCH"),
477	compareTo._focalLength, _focalLength);	479	(double)compareTo._focalLength, (double)_focalLength);
478	}	480	}
479	return result;	481	return result;
480	}	482	}
@@ -531,23 +533,23 @@ void ViewFrustum::computeOffAxisFrustum(float& left, float& right, float& bottom · 50 unmodified lines
531		533
532	void ViewFrustum::printDebugDetails() const {	534	void ViewFrustum::printDebugDetails() const {
533	qCDebug(octree, "ViewFrustum::printDebugDetails()...");	535	qCDebug(octree, "ViewFrustum::printDebugDetails()...");
534	qCDebug(octree, "_position=%f,%f,%f", _position.x, _position.y, _position.z );	536	qCDebug(octree, "_position=%f,%f,%f", (double)_position.x, (double)_position.y, (double)_position.z );
535	qCDebug(octree, "_direction=%f,%f,%f", _direction.x, _direction.y, _direction.z );	537	qCDebug(octree, "_direction=%f,%f,%f", (double)_direction.x, (double)_direction.y, (double)_direction.z );
536	qCDebug(octree, "_up=%f,%f,%f", _up.x, _up.y, _up.z );	538	qCDebug(octree, "_up=%f,%f,%f", (double)_up.x, (double)_up.y, (double)_up.z );
537	qCDebug(octree, "_right=%f,%f,%f", _right.x, _right.y, _right.z );	539	qCDebug(octree, "_right=%f,%f,%f", (double)_right.x, (double)_right.y, (double)_right.z );
538	qCDebug(octree, "_fieldOfView=%f", _fieldOfView);	540	qCDebug(octree, "_fieldOfView=%f", (double)_fieldOfView);
539	qCDebug(octree, "_aspectRatio=%f", _aspectRatio);	541	qCDebug(octree, "_aspectRatio=%f", (double)_aspectRatio);
540	qCDebug(octree, "_keyHoleRadius=%f", _keyholeRadius);	542	qCDebug(octree, "_keyHoleRadius=%f", (double)_keyholeRadius);
541	qCDebug(octree, "_nearClip=%f", _nearClip);	543	qCDebug(octree, "_nearClip=%f", (double)_nearClip);
542	qCDebug(octree, "_farClip=%f", _farClip);	544	qCDebug(octree, "_farClip=%f", (double)_farClip);
543	qCDebug(octree, "_focalLength=%f", _focalLength);	545	qCDebug(octree, "_focalLength=%f", (double)_focalLength);
544	}	546	}
545		547
546	glm::vec2 ViewFrustum::projectPoint(glm::vec3 point, bool& pointInView) const {	548	glm::vec2 ViewFrustum::projectPoint(glm::vec3 point, bool& pointInView) const {
547		549
548	glm::vec4 pointVec4 = glm::vec4(point,1);	550	glm::vec4 pointVec4 = glm::vec4(point, 1.0f);
549	glm::vec4 projectedPointVec4 = _ourModelViewProjectionMatrix * pointVec4;	551	glm::vec4 projectedPointVec4 = _ourModelViewProjectionMatrix * pointVec4;
550	pointInView = (projectedPointVec4.w > 0); // math! If the w result is negative then the point is behind the viewer	552	pointInView = (projectedPointVec4.w > 0.0f); // math! If the w result is negative then the point is behind the viewer
551		553
552	// what happens with w is 0???	554	// what happens with w is 0???
553	float x = projectedPointVec4.x / projectedPointVec4.w;	555	float x = projectedPointVec4.x / projectedPointVec4.w;

libraries/physics/src/EntityMotionState.cpp+2−2

@@ -245,7 +245,7 @@ bool EntityMotionState::remoteSimulationOutOfSync(uint32_t simulationStep) { · 244 unmodified lines
245		245
246	float dx2 = glm::distance2(position, _serverPosition);	246	float dx2 = glm::distance2(position, _serverPosition);
247		247
248	const float MAX_POSITION_ERROR_SQUARED = 0.001f; // 0.001 m^2 ~~> 0.03 m	248	const float MAX_POSITION_ERROR_SQUARED = 0.000004f; // Sqrt() - corresponds to 2 millimeters
249	if (dx2 > MAX_POSITION_ERROR_SQUARED) {	249	if (dx2 > MAX_POSITION_ERROR_SQUARED) {
250		250
251	#ifdef WANT_DEBUG	251	#ifdef WANT_DEBUG
@@ -270,7 +270,7 @@ bool EntityMotionState::remoteSimulationOutOfSync(uint32_t simulationStep) { · 18 unmodified lines
270	_serverRotation = glm::normalize(computeBulletRotationStep(_serverAngularVelocity, PHYSICS_ENGINE_FIXED_SUBSTEP) * _serverRotation);	270	_serverRotation = glm::normalize(computeBulletRotationStep(_serverAngularVelocity, PHYSICS_ENGINE_FIXED_SUBSTEP) * _serverRotation);
271	}	271	}
272	}	272	}
273	const float MIN_ROTATION_DOT = 0.99f; // 0.99 dot threshold coresponds to about 16 degrees of slop	273	const float MIN_ROTATION_DOT = 0.99999f; // This corresponds to about 0.5 degrees of rotation
274	glm::quat actualRotation = bulletToGLM(worldTrans.getRotation());	274	glm::quat actualRotation = bulletToGLM(worldTrans.getRotation());
275		275
276	#ifdef WANT_DEBUG	276	#ifdef WANT_DEBUG

libraries/physics/src/MeshMassProperties.cpp+4−0

     }
     // create some variables to hold temporary results
+    #ifndef NDEBUG
     uint32_t numPoints = points.size();
+    #endif
     const btVector3 p0(0.0f, 0.0f, 0.0f);
     btMatrix3x3 tetraInertia;
     btMatrix3x3 doubleDebugInertia;
     uint32_t numTriangles = triangleIndices.size() / 3;
     for (uint32_t i = 0; i < numTriangles; ++i) {
         uint32_t t = 3 * i;
+        #ifndef NDEBUG
         assert(triangleIndices[t] < numPoints);
         assert(triangleIndices[t + 1] < numPoints);
         assert(triangleIndices[t + 2] < numPoints);
+        #endif
         // extract raw vertices
         tetraPoints[0] = p0;

libraries/physics/src/ObjectAction.cpp+1−1

@@ -28,7 +28,7 @@ void ObjectAction::updateAction(btCollisionWorld* collisionWorld, btScalar delta · 27 unmodified lines
28	return;	28	return;
29	}	29	}
30	if (!_ownerEntity) {	30	if (!_ownerEntity) {
31	qDebug() << "ObjectActionPullToPoint::updateAction no owner entity";	31	qDebug() << "ObjectAction::updateAction no owner entity";
32	return;	32	return;
33	}	33	}
34	updateActionWorker(deltaTimeStep);	34	updateActionWorker(deltaTimeStep);

libraries/physics/src/ObjectAction.h+1−0

@@ -59,6 +59,7 @@ protected: · 58 unmodified lines
59		59
60	bool tryLockForRead() { return _lock.tryLockForRead(); }	60	bool tryLockForRead() { return _lock.tryLockForRead(); }
61	void lockForWrite() { _lock.lockForWrite(); }	61	void lockForWrite() { _lock.lockForWrite(); }
		62	bool tryLockForWrite() { return _lock.tryLockForWrite(); }
62	void unlock() { _lock.unlock(); }	63	void unlock() { _lock.unlock(); }
63		64
64	bool _active;	65	bool _active;

libraries/physics/src/ObjectActionOffset.cpp+109−0

@@ -0,0 +1,109 @@
	1	//
	2	// ObjectActionOffset.cpp
	3	// libraries/physics/src
	4	//
	5	// Created by Seth Alves 2015-6-17
	6	// Copyright 2015 High Fidelity, Inc.
	7	//
	8	// Distributed under the Apache License, Version 2.0.
	9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	10	//
	11
	12	#include "ObjectActionOffset.h"
	13
	14	ObjectActionOffset::ObjectActionOffset(QUuid id, EntityItemPointer ownerEntity) :
	15	ObjectAction(id, ownerEntity) {
	16	#if WANT_DEBUG
	17	qDebug() << "ObjectActionOffset::ObjectActionOffset";
	18	#endif
	19	}
	20
	21	ObjectActionOffset::~ObjectActionOffset() {
	22	#if WANT_DEBUG
	23	qDebug() << "ObjectActionOffset::~ObjectActionOffset";
	24	#endif
	25	}
	26
	27	void ObjectActionOffset::updateActionWorker(btScalar deltaTimeStep) {
	28	if (!tryLockForRead()) {
	29	// don't risk hanging the thread running the physics simulation
	30	return;
	31	}
	32
	33	void* physicsInfo = _ownerEntity->getPhysicsInfo();
	34	if (!physicsInfo) {
	35	unlock();
	36	return;
	37	}
	38	ObjectMotionState* motionState = static_cast<ObjectMotionState*>(physicsInfo);
	39	btRigidBody* rigidBody = motionState->getRigidBody();
	40	if (!rigidBody) {
	41	unlock();
	42	qDebug() << "ObjectActionOffset::updateActionWorker no rigidBody";
	43	return;
	44	}
	45
	46	if (_positionalTargetSet) {
	47	glm::vec3 offset = _pointToOffsetFrom - bulletToGLM(rigidBody->getCenterOfMassPosition());
	48	float offsetLength = glm::length(offset);
	49	float offsetError = _linearDistance - offsetLength;
	50
	51	// if (glm::abs(offsetError) > IGNORE_POSITION_DELTA) {
	52	if (glm::abs(offsetError) > 0.0f) {
	53	float offsetErrorAbs = glm::abs(offsetError);
	54	float offsetErrorDirection = - offsetError / offsetErrorAbs;
	55	glm::vec3 previousVelocity = bulletToGLM(rigidBody->getLinearVelocity());
	56
	57	glm::vec3 velocityAdjustment = glm::normalize(offset) * offsetErrorDirection * offsetErrorAbs / _linearTimeScale;
	58	rigidBody->setLinearVelocity(glmToBullet(previousVelocity + velocityAdjustment));
	59	// rigidBody->setLinearVelocity(glmToBullet(velocityAdjustment));
	60	rigidBody->activate();
	61	}
	62	}
	63
	64	unlock();
	65	}
	66
	67
	68	bool ObjectActionOffset::updateArguments(QVariantMap arguments) {
	69	bool pOk0 = true;
	70	glm::vec3 pointToOffsetFrom =
	71	EntityActionInterface::extractVec3Argument("offset action", arguments, "pointToOffsetFrom", pOk0, true);
	72
	73	bool pOk1 = true;
	74	float linearTimeScale =
	75	EntityActionInterface::extractFloatArgument("offset action", arguments, "linearTimeScale", pOk1, false);
	76
	77	bool pOk2 = true;
	78	float linearDistance =
	79	EntityActionInterface::extractFloatArgument("offset action", arguments, "linearDistance", pOk2, false);
	80
	81	if (!pOk0) {
	82	return false;
	83	}
	84	if (pOk1 && linearTimeScale <= 0.0f) {
	85	qDebug() << "offset action -- linearTimeScale must be greater than zero.";
	86	return false;
	87	}
	88
	89	lockForWrite();
	90
	91	_pointToOffsetFrom = pointToOffsetFrom;
	92	_positionalTargetSet = true;
	93
	94	if (pOk1) {
	95	_linearTimeScale = linearTimeScale;
	96	} else {
	97	_linearTimeScale = 0.1f;
	98	}
	99
	100	if (pOk2) {
	101	_linearDistance = linearDistance;
	102	} else {
	103	_linearDistance = 1.0f;
	104	}
	105
	106	_active = true;
	107	unlock();
	108	return true;
	109	}

libraries/physics/src/ObjectActionOffset.h+35−0

@@ -0,0 +1,35 @@
	1	//
	2	// ObjectActionOffset.h
	3	// libraries/physics/src
	4	//
	5	// Created by Seth Alves 2015-6-17
	6	// Copyright 2015 High Fidelity, Inc.
	7	//
	8	// Distributed under the Apache License, Version 2.0.
	9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	10	//
	11
	12	#ifndef hifi_ObjectActionOffset_h
	13	#define hifi_ObjectActionOffset_h
	14
	15	#include <QUuid>
	16
	17	#include <EntityItem.h>
	18	#include "ObjectAction.h"
	19
	20	class ObjectActionOffset : public ObjectAction {
	21	public:
	22	ObjectActionOffset(QUuid id, EntityItemPointer ownerEntity);
	23	virtual ~ObjectActionOffset();
	24
	25	virtual bool updateArguments(QVariantMap arguments);
	26	virtual void updateActionWorker(float deltaTimeStep);
	27
	28	private:
	29	glm::vec3 _pointToOffsetFrom;
	30	float _linearDistance;
	31	float _linearTimeScale;
	32	bool _positionalTargetSet;
	33	};
	34
	35	#endif // hifi_ObjectActionOffset_h

libraries/physics/src/ObjectActionPullToPoint.cpp+0−72

@@ -1,72 +0,0 @@
1	//
2	// ObjectActionPullToPoint.cpp
3	// libraries/physics/src
4	//
5	// Created by Seth Alves 2015-6-2
6	// Copyright 2015 High Fidelity, Inc.
7	//
8	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//
11
12	#include "ObjectActionPullToPoint.h"
13
14	ObjectActionPullToPoint::ObjectActionPullToPoint(QUuid id, EntityItemPointer ownerEntity) :
15	ObjectAction(id, ownerEntity) {
16	#if WANT_DEBUG
17	qDebug() << "ObjectActionPullToPoint::ObjectActionPullToPoint";
18	#endif
19	}
20
21	ObjectActionPullToPoint::~ObjectActionPullToPoint() {
22	#if WANT_DEBUG
23	qDebug() << "ObjectActionPullToPoint::~ObjectActionPullToPoint";
24	#endif
25	}
26
27	void ObjectActionPullToPoint::updateActionWorker(btScalar deltaTimeStep) {
28	if (!tryLockForRead()) {
29	// don't risk hanging the thread running the physics simulation
30	return;
31	}
32
33	void* physicsInfo = _ownerEntity->getPhysicsInfo();
34	if (!physicsInfo) {
35	unlock();
36	return;
37	}
38	ObjectMotionState* motionState = static_cast<ObjectMotionState*>(physicsInfo);
39	btRigidBody* rigidBody = motionState->getRigidBody();
40	if (!rigidBody) {
41	unlock();
42	return;
43	}
44
45	glm::vec3 offset = _target - bulletToGLM(rigidBody->getCenterOfMassPosition());
46	float offsetLength = glm::length(offset);
47	if (offsetLength > IGNORE_POSITION_DELTA) {
48	glm::vec3 newVelocity = glm::normalize(offset) * _speed;
49	rigidBody->setLinearVelocity(glmToBullet(newVelocity));
50	rigidBody->activate();
51	} else {
52	rigidBody->setLinearVelocity(glmToBullet(glm::vec3()));
53	}
54
55	unlock();
56	}
57
58
59	bool ObjectActionPullToPoint::updateArguments(QVariantMap arguments) {
60	bool ok = true;
61	glm::vec3 target = EntityActionInterface::extractVec3Argument("pull-to-point action", arguments, "target", ok);
62	float speed = EntityActionInterface::extractFloatArgument("pull-to-point action", arguments, "speed", ok);
63	if (ok) {
64	lockForWrite();
65	_target = target;
66	_speed = speed;
67	_active = true;
68	unlock();
69	return true;
70	}
71	return false;
72	}

libraries/physics/src/ObjectActionPullToPoint.h+0−34

@@ -1,34 +0,0 @@
1	//
2	// ObjectActionPullToPoint.h
3	// libraries/physics/src
4	//
5	// Created by Seth Alves 2015-6-3
6	// Copyright 2015 High Fidelity, Inc.
7	//
8	// Distributed under the Apache License, Version 2.0.
9	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10	//
11
12	#ifndef hifi_ObjectActionPullToPoint_h
13	#define hifi_ObjectActionPullToPoint_h
14
15	#include <QUuid>
16
17	#include <EntityItem.h>
18	#include "ObjectAction.h"
19
20	class ObjectActionPullToPoint : public ObjectAction {
21	public:
22	ObjectActionPullToPoint(QUuid id, EntityItemPointer ownerEntity);
23	virtual ~ObjectActionPullToPoint();
24
25	virtual bool updateArguments(QVariantMap arguments);
26	virtual void updateActionWorker(float deltaTimeStep);
27
28	private:
29
30	glm::vec3 _target;
31	float _speed;
32	};
33
34	#endif // hifi_ObjectActionPullToPoint_h

libraries/render-utils/CMakeLists.txt+37−27

@@ -1,27 +1,37 @@
1	set(TARGET_NAME render-utils)	1	set(TARGET_NAME render-utils)
2		2
3	AUTOSCRIBE_SHADER_LIB(gpu model render)	3	AUTOSCRIBE_SHADER_LIB(gpu model render)
4		4
5	# pull in the resources.qrc file	5	# pull in the resources.qrc file
6	qt5_add_resources(QT_RESOURCES_FILE "${CMAKE_CURRENT_SOURCE_DIR}/res/fonts/fonts.qrc")	6	qt5_add_resources(QT_RESOURCES_FILE "${CMAKE_CURRENT_SOURCE_DIR}/res/fonts/fonts.qrc")
7		7
8	# use setup_hifi_library macro to setup our project and link appropriate Qt modules	8	# use setup_hifi_library macro to setup our project and link appropriate Qt modules
9	setup_hifi_library(Widgets OpenGL Network Qml Quick Script)	9	setup_hifi_library(Widgets OpenGL Network Qml Quick Script)
10		10
11	add_dependency_external_projects(glm)	11	setup_hifi_opengl()
12	find_package(GLM REQUIRED)	12
13	target_include_directories(${TARGET_NAME} PUBLIC ${GLM_INCLUDE_DIRS})	13	add_dependency_external_projects(glm)
14		14	find_package(GLM REQUIRED)
15	if (WIN32)	15	target_include_directories(${TARGET_NAME} PUBLIC ${GLM_INCLUDE_DIRS})
16	if (USE_NSIGHT)	16
17	# try to find the Nsight package and add it to the build if we find it	17	if (WIN32)
18	find_package(NSIGHT)	18	if (USE_NSIGHT)
19	if (NSIGHT_FOUND)	19	# try to find the Nsight package and add it to the build if we find it
20	include_directories(${NSIGHT_INCLUDE_DIRS})	20	find_package(NSIGHT)
21	add_definitions(-DNSIGHT_FOUND)	21	if (NSIGHT_FOUND)
22	target_link_libraries(${TARGET_NAME} "${NSIGHT_LIBRARIES}")	22	include_directories(${NSIGHT_INCLUDE_DIRS})
23	endif ()	23	add_definitions(-DNSIGHT_FOUND)
24	endif()	24	target_link_libraries(${TARGET_NAME} "${NSIGHT_LIBRARIES}")
25	endif (WIN32)	25	endif ()
26		26	endif()
27	link_hifi_libraries(animation fbx shared gpu model render)	27
		28	add_dependency_external_projects(boostconfig)
		29	find_package(BoostConfig REQUIRED)
		30	target_include_directories(${TARGET_NAME} PUBLIC ${BOOSTCONFIG_INCLUDE_DIRS})
		31
		32	add_dependency_external_projects(oglplus)
		33	find_package(OGLPLUS REQUIRED)
		34	target_include_directories(${TARGET_NAME} PUBLIC ${OGLPLUS_INCLUDE_DIRS})
		35	endif (WIN32)
		36
		37	link_hifi_libraries(animation fbx shared gpu model render)

libraries/render-utils/src/DeferredLightingEffect.cpp+25−6

     gpu::Shader::BindingSet slotBindings;
     gpu::Shader::makeProgram(*program, slotBindings);
     gpu::Shader::makeProgram(*programTextured, slotBindings);
     gpu::StatePointer state = gpu::StatePointer(new gpu::State());
     state->setCullMode(gpu::State::CULL_BACK);
     state->setDepthTest(true, true, gpu::LESS_EQUAL);
     state->setBlendFunction(false,
                             gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
                             gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
+    gpu::StatePointer stateCullNone = gpu::StatePointer(new gpu::State());
+    stateCullNone->setCullMode(gpu::State::CULL_NONE);
+    stateCullNone->setDepthTest(true, true, gpu::LESS_EQUAL);
+    stateCullNone->setBlendFunction(false,
+                            gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
+                            gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
     _simpleProgram = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
+    _simpleProgramCullNone = gpu::PipelinePointer(gpu::Pipeline::create(program, stateCullNone));
     _simpleProgramTextured = gpu::PipelinePointer(gpu::Pipeline::create(programTextured, state));
+    _simpleProgramTexturedCullNone = gpu::PipelinePointer(gpu::Pipeline::create(programTextured, stateCullNone));
     _viewState = viewState;
     loadLightProgram(directional_light_frag, false, _directionalLight, _directionalLightLocations);
     lp->setAmbientSpherePreset(gpu::SphericalHarmonics::Preset(_ambientLightMode % gpu::SphericalHarmonics::NUM_PRESET));
 }
-void DeferredLightingEffect::bindSimpleProgram(gpu::Batch& batch, bool textured) {
+void DeferredLightingEffect::bindSimpleProgram(gpu::Batch& batch, bool textured, bool culled) {
   // DependencyManager::get<TextureCache>()->setPrimaryDrawBuffers(batch, true, true, true);
     if (textured) {
-        batch.setPipeline(_simpleProgramTextured);
+        if (culled) {
+            batch.setPipeline(_simpleProgramTextured);
+        } else {
+            batch.setPipeline(_simpleProgramTexturedCullNone);
+        }
     } else {
-        batch.setPipeline(_simpleProgram);
+        if (culled) {
+            batch.setPipeline(_simpleProgram);
+        } else {
+            batch.setPipeline(_simpleProgramCullNone);
+        }
     }
 }
     }
 }
-void DeferredLightingEffect::prepare() {
+void DeferredLightingEffect::prepare(RenderArgs* args) {
     // clear the normal and specular buffers
     auto textureCache = DependencyManager::get<TextureCache>();
     textureCache->setPrimaryDrawBuffers(false, true, false);
     textureCache->setPrimaryDrawBuffers(true, false, false);
 }
-void DeferredLightingEffect::render() {
+void DeferredLightingEffect::render(RenderArgs* args) {
     // perform deferred lighting, rendering to free fbo
     glDisable(GL_BLEND);
     glDisable(GL_LIGHTING);

libraries/render-utils/src/DeferredLightingEffect.h+5−3

     void init(AbstractViewStateInterface* viewState);
     /// Sets up the state necessary to render static untextured geometry with the simple program.
-    void bindSimpleProgram(gpu::Batch& batch, bool textured = false);
+    void bindSimpleProgram(gpu::Batch& batch, bool textured = false, bool culled = true);
     /// Tears down the state necessary to render static untextured geometry with the simple program.
     void releaseSimpleProgram(gpu::Batch& batch);
     void addSpotLight(const glm::vec3& position, float radius, const glm::vec3& color = glm::vec3(1.0f, 1.0f, 1.0f),
         float intensity = 0.5f, const glm::quat& orientation = glm::quat(), float exponent = 0.0f, float cutoff = PI);
-    void prepare();
+    void prepare(RenderArgs* args);
-    void render();
+    void render(RenderArgs* args);
     void copyBack(RenderArgs* args);
     void setupTransparent(RenderArgs* args, int lightBufferUnit);
     static void loadLightProgram(const char* fragSource, bool limited, ProgramObject& program, LightLocations& locations);
     gpu::PipelinePointer _simpleProgram;
+    gpu::PipelinePointer _simpleProgramCullNone;
     gpu::PipelinePointer _simpleProgramTextured;
+    gpu::PipelinePointer _simpleProgramTexturedCullNone;
     ProgramObject _directionalSkyboxLight;
     LightLocations _directionalSkyboxLightLocations;

libraries/render-utils/src/GeometryCache.cpp+82−39

@@ -28,6 +28,9 @@ · 27 unmodified lines
28	#include "RenderUtilsLogging.h"	28	#include "RenderUtilsLogging.h"
29	#include "GeometryCache.h"	29	#include "GeometryCache.h"
30		30
		31	#include "standardTransformPNTC_vert.h"
		32	#include "standardDrawTexture_frag.h"
		33
31	//#define WANT_DEBUG	34	//#define WANT_DEBUG
32		35
33	const int GeometryCache::UNKNOWN_ID = -1;	36	const int GeometryCache::UNKNOWN_ID = -1;
@@ -1025,13 +1028,13 @@ void GeometryCache::renderBevelCornersRect(gpu::Batch& batch, int x, int y, int · 991 unmodified lines
1025	#endif // def WANT_DEBUG	1028	#endif // def WANT_DEBUG
1026	}	1029	}
1027		1030
1028	const int FLOATS_PER_VERTEX = 2; // vertices
1029	const int vertices = 8;
1030
1031	if (!details.isCreated) {	1031	if (!details.isCreated) {
1032		1032	static const int FLOATS_PER_VERTEX = 2; // vertices
		1033	static const int NUM_VERTICES = 8;
		1034	static const int NUM_FLOATS = NUM_VERTICES * FLOATS_PER_VERTEX;
		1035
1033	details.isCreated = true;	1036	details.isCreated = true;
1034	details.vertices = vertices;	1037	details.vertices = NUM_VERTICES;
1035	details.vertexSize = FLOATS_PER_VERTEX;	1038	details.vertexSize = FLOATS_PER_VERTEX;
1036		1039
1037	gpu::BufferPointer verticesBuffer(new gpu::Buffer());	1040	gpu::BufferPointer verticesBuffer(new gpu::Buffer());
@@ -1044,62 +1047,65 @@ void GeometryCache::renderBevelCornersRect(gpu::Batch& batch, int x, int y, int · 6 unmodified lines
1044	details.streamFormat = streamFormat;	1047	details.streamFormat = streamFormat;
1045	details.stream = stream;	1048	details.stream = stream;
1046		1049
1047	details.streamFormat->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ), 0);	1050	details.streamFormat->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ));
1048	details.streamFormat->setAttribute(gpu::Stream::COLOR, 1, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));	1051	details.streamFormat->setAttribute(gpu::Stream::COLOR, 1, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
1049		1052
1050	details.stream->addBuffer(details.verticesBuffer, 0, details.streamFormat->getChannels().at(0)._stride);	1053	details.stream->addBuffer(details.verticesBuffer, 0, details.streamFormat->getChannels().at(0)._stride);
1051	details.stream->addBuffer(details.colorBuffer, 0, details.streamFormat->getChannels().at(1)._stride);	1054	details.stream->addBuffer(details.colorBuffer, 0, details.streamFormat->getChannels().at(1)._stride);
1052		1055
1053		1056
1054	int vertexPoints = vertices * FLOATS_PER_VERTEX;	1057	GLfloat vertexBuffer[NUM_FLOATS]; // only vertices, no normals because we're a 2D quad
1055	GLfloat* vertexBuffer = new GLfloat[vertexPoints]; // only vertices, no normals because we're a 2D quad
1056	GLfloat* vertex = vertexBuffer;
1057	int vertexPoint = 0;	1058	int vertexPoint = 0;
1058		1059
1059	// left side	1060	// Triangle strip points
1060	vertex[vertexPoint++] = x;	1061	// 3 ------ 5
1061	vertex[vertexPoint++] = y + bevelDistance;	1062	// / \
		1063	// 1 7
		1064	// \| \|
		1065	// 2 8
		1066	// \ /
		1067	// 4 ------ 6
1062		1068
1063	vertex[vertexPoint++] = x;	1069	// 1
1064	vertex[vertexPoint++] = y + height - bevelDistance;	1070	vertexBuffer[vertexPoint++] = x;
1065		1071	vertexBuffer[vertexPoint++] = y + height - bevelDistance;
1066	// top side	1072	// 2
1067	vertex[vertexPoint++] = x + bevelDistance;	1073	vertexBuffer[vertexPoint++] = x;
1068	vertex[vertexPoint++] = y + height;	1074	vertexBuffer[vertexPoint++] = y + bevelDistance;
		1075	// 3
		1076	vertexBuffer[vertexPoint++] = x + bevelDistance;
		1077	vertexBuffer[vertexPoint++] = y + height;
		1078	// 4
		1079	vertexBuffer[vertexPoint++] = x + bevelDistance;
		1080	vertexBuffer[vertexPoint++] = y;
		1081	// 5
		1082	vertexBuffer[vertexPoint++] = x + width - bevelDistance;
		1083	vertexBuffer[vertexPoint++] = y + height;
		1084	// 6
		1085	vertexBuffer[vertexPoint++] = x + width - bevelDistance;
		1086	vertexBuffer[vertexPoint++] = y;
		1087	// 7
		1088	vertexBuffer[vertexPoint++] = x + width;
		1089	vertexBuffer[vertexPoint++] = y + height - bevelDistance;
		1090	// 8
		1091	vertexBuffer[vertexPoint++] = x + width;
		1092	vertexBuffer[vertexPoint++] = y + bevelDistance;
1069		1093
1070	vertex[vertexPoint++] = x + width - bevelDistance;
1071	vertex[vertexPoint++] = y + height;
1072
1073	// right
1074	vertex[vertexPoint++] = x + width;
1075	vertex[vertexPoint++] = y + height - bevelDistance;
1076	vertex[vertexPoint++] = x + width;
1077	vertex[vertexPoint++] = y + bevelDistance;
1078
1079	// bottom
1080	vertex[vertexPoint++] = x + width - bevelDistance;
1081	vertex[vertexPoint++] = y;
1082	vertex[vertexPoint++] = x +bevelDistance;
1083	vertex[vertexPoint++] = y;
1084
1085	const int NUM_COLOR_SCALARS_PER_QUAD = 8;
1086	int compactColor = ((int(color.x * 255.0f) & 0xFF)) \|	1094	int compactColor = ((int(color.x * 255.0f) & 0xFF)) \|
1087	((int(color.y * 255.0f) & 0xFF) << 8) \|	1095	((int(color.y * 255.0f) & 0xFF) << 8) \|
1088	((int(color.z * 255.0f) & 0xFF) << 16) \|	1096	((int(color.z * 255.0f) & 0xFF) << 16) \|
1089	((int(color.w * 255.0f) & 0xFF) << 24);	1097	((int(color.w * 255.0f) & 0xFF) << 24);
1090	int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor,	1098	int colors[NUM_VERTICES] = { compactColor, compactColor, compactColor, compactColor,
1091	compactColor, compactColor, compactColor, compactColor };	1099	compactColor, compactColor, compactColor, compactColor };
1092		1100
1093		1101
1094	details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);	1102	details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
1095	details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);	1103	details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
1096
1097	delete[] vertexBuffer;
1098	}	1104	}
1099		1105
1100	batch.setInputFormat(details.streamFormat);	1106	batch.setInputFormat(details.streamFormat);
1101	batch.setInputStream(0, *details.stream);	1107	batch.setInputStream(0, *details.stream);
1102	batch.draw(gpu::QUADS, 4, 0);	1108	batch.draw(gpu::TRIANGLE_STRIP, details.vertices, 0);
1103	}	1109	}
1104		1110
1105	void GeometryCache::renderQuad(const glm::vec2& minCorner, const glm::vec2& maxCorner, const glm::vec4& color, int id) {	1111	void GeometryCache::renderQuad(const glm::vec2& minCorner, const glm::vec2& maxCorner, const glm::vec4& color, int id) {
@@ -1179,6 +1185,26 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec2& minCorner, co · 73 unmodified lines
1179	batch.draw(gpu::QUADS, 4, 0);	1185	batch.draw(gpu::QUADS, 4, 0);
1180	}	1186	}
1181		1187
		1188	void GeometryCache::renderUnitCube(gpu::Batch& batch) {
		1189	static const glm::vec4 color(1);
		1190	renderSolidCube(batch, 1, color);
		1191	}
		1192
		1193	void GeometryCache::renderUnitQuad(const glm::vec4& color, int id) {
		1194	gpu::Batch batch;
		1195	renderUnitQuad(batch, color, id);
		1196	gpu::GLBackend::renderBatch(batch);
		1197	}
		1198
		1199	void GeometryCache::renderUnitQuad(gpu::Batch& batch, const glm::vec4& color, int id) {
		1200	static const glm::vec2 topLeft(-1, 1);
		1201	static const glm::vec2 bottomRight(1, -1);
		1202	static const glm::vec2 texCoordTopLeft(0.0f, 1.0f);
		1203	static const glm::vec2 texCoordBottomRight(1.0f, 0.0f);
		1204	renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color, id);
		1205	}
		1206
		1207
1182	void GeometryCache::renderQuad(const glm::vec2& minCorner, const glm::vec2& maxCorner,	1208	void GeometryCache::renderQuad(const glm::vec2& minCorner, const glm::vec2& maxCorner,
1183	const glm::vec2& texCoordMinCorner, const glm::vec2& texCoordMaxCorner,	1209	const glm::vec2& texCoordMinCorner, const glm::vec2& texCoordMaxCorner,
1184	const glm::vec4& color, int id) {	1210	const glm::vec4& color, int id) {
@@ -1802,6 +1828,23 @@ QSharedPointer<Resource> GeometryCache::createResource(const QUrl& url, const QS · 617 unmodified lines
1802	return geometry.staticCast<Resource>();	1828	return geometry.staticCast<Resource>();
1803	}	1829	}
1804		1830
		1831	void GeometryCache::useSimpleDrawPipeline(gpu::Batch& batch) {
		1832	if (!_standardDrawPipeline) {
		1833	auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(standardTransformPNTC_vert)));
		1834	auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(standardDrawTexture_frag)));
		1835	auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
		1836	gpu::Shader::makeProgram((*program));
		1837
		1838	auto state = gpu::StatePointer(new gpu::State());
		1839
		1840	// enable decal blend
		1841	state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA);
		1842
		1843	_standardDrawPipeline.reset(gpu::Pipeline::create(program, state));
		1844	}
		1845	batch.setPipeline(_standardDrawPipeline);
		1846	}
		1847
1805	const float NetworkGeometry::NO_HYSTERESIS = -1.0f;	1848	const float NetworkGeometry::NO_HYSTERESIS = -1.0f;
1806		1849
1807	NetworkGeometry::NetworkGeometry(const QUrl& url, const QSharedPointer<NetworkGeometry>& fallback, bool delayLoad,	1850	NetworkGeometry::NetworkGeometry(const QUrl& url, const QSharedPointer<NetworkGeometry>& fallback, bool delayLoad,

libraries/render-utils/src/GeometryCache.h+9−1

     void renderBevelCornersRect(int x, int y, int width, int height, int bevelDistance, const glm::vec4& color, int id = UNKNOWN_ID);
     void renderBevelCornersRect(gpu::Batch& batch, int x, int y, int width, int height, int bevelDistance, const glm::vec4& color, int id = UNKNOWN_ID);
+    void renderUnitCube(gpu::Batch& batch);
+    void renderUnitQuad(const glm::vec4& color = glm::vec4(1), int id = UNKNOWN_ID);
+    void renderUnitQuad(gpu::Batch& batch, const glm::vec4& color = glm::vec4(1), int id = UNKNOWN_ID);
     void renderQuad(int x, int y, int width, int height, const glm::vec4& color, int id = UNKNOWN_ID)
             { renderQuad(glm::vec2(x,y), glm::vec2(x + width, y + height), color, id); }
     void renderQuad(gpu::Batch& batch, int x, int y, int width, int height, const glm::vec4& color, int id = UNKNOWN_ID)
     /// \param delayLoad if true, don't load the geometry immediately; wait until load is first requested
     QSharedPointer<NetworkGeometry> getGeometry(const QUrl& url, const QUrl& fallback = QUrl(), bool delayLoad = false);
+    /// Set a batch to the simple pipeline, returning the previous pipeline
+    void useSimpleDrawPipeline(gpu::Batch& batch);
 protected:
     virtual QSharedPointer<Resource> createResource(const QUrl& url,
         int vertexSize;
     };
+    gpu::PipelinePointer _standardDrawPipeline;
     QHash<float, gpu::BufferPointer> _cubeVerticies;
     QHash<Vec2Pair, gpu::BufferPointer> _cubeColors;
     gpu::BufferPointer _wireCubeIndexBuffer;
     QHash<float, gpu::BufferPointer> _solidCubeVertices;
     QHash<Vec2Pair, gpu::BufferPointer> _solidCubeColors;
     gpu::BufferPointer _solidCubeIndexBuffer;
     class BatchItemDetails {
     public:
         static int population;

libraries/render-utils/src/Model.cpp+10−5

     // we can use the AABox's ray intersection by mapping our origin and direction into the model frame
     // and testing intersection there.
     if (modelFrameBox.findRayIntersection(modelFrameOrigin, modelFrameDirection, distance, face)) {
-        if (!_calculatedMeshBoxesValid) {
-            recalculateMeshBoxes(pickAgainstTriangles);
-        }
         float bestDistance = std::numeric_limits<float>::max();
         float distanceToSubMesh;
         // If we hit the models box, then consider the submeshes...
         _mutex.lock();
+        if (!_calculatedMeshBoxesValid) {
+            recalculateMeshBoxes(pickAgainstTriangles);
+        }
         foreach(const AABox& subMeshBox, _calculatedMeshBoxes) {
             if (subMeshBox.findRayIntersection(origin, direction, distanceToSubMesh, subMeshFace)) {
 }
 void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool translucent) {
+    PerformanceTimer perfTimer("Model::renderPart");
     if (!_readyWhenAdded) {
         return; // bail asap
     }
     // We need to make sure we have valid offsets calculated before we can render
     if (!_calculatedMeshPartOffsetValid) {
+        _mutex.lock();
         recalculateMeshPartOffsets();
+        _mutex.unlock();
     }
     auto textureCache = DependencyManager::get<TextureCache>();
         }
     }
+    _mutex.lock();
     qint64 offset = _calculatedMeshPartOffset[QPair<int,int>(meshIndex, partIndex)];
+    _mutex.unlock();
     if (part.quadIndices.size() > 0) {
         batch.drawIndexed(gpu::QUADS, part.quadIndices.size(), offset);

libraries/render-utils/src/OffscreenQmlSurface.cpp+6−2

 #include <QOpenGLDebugLogger>
 #include <QGLWidget>
 #include <QtQml>
+#include <PerfStat.h>
 #include "AbstractViewStateInterface.h"
 Q_DECLARE_LOGGING_CATEGORY(offscreenFocus)
     // Qt bug in 5.4 forces this check of pixel ratio,
     // even though we're rendering offscreen.
     qreal pixelRatio = 1.0;
+    _qmlEngine->rootContext()->setContextProperty("surfaceSize", newSize);
     if (_renderControl && _renderControl->_renderWindow) {
         pixelRatio = _renderControl->_renderWindow->devicePixelRatio();
     } else {
         _quickWindow->contentItem()->setSize(newSize);
     }
     // Update our members
     if (_rootItem) {
         _rootItem->setSize(newSize);
 void OffscreenQmlSurface::updateQuick() {
+    PerformanceTimer perfTimer("qmlUpdate");
     if (_paused) {
         return;
     }
 QQuickWindow* OffscreenQmlSurface::getWindow() {
     return _quickWindow;
 }

libraries/render-utils/src/OglplusHelpers.cpp+325−0

@@ -0,0 +1,325 @@
	1	#ifdef Q_OS_WIN
	2
	3	//
	4	// Created by Bradley Austin Davis on 2015/05/29
	5	// Copyright 2015 High Fidelity, Inc.
	6	//
	7	// Distributed under the Apache License, Version 2.0.
	8	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	9	//
	10	#include "OglplusHelpers.h"
	11
	12	using namespace oglplus;
	13	using namespace oglplus::shapes;
	14
	15	static const char * SIMPLE_TEXTURED_VS = R"VS(#version 410 core
	16	#pragma line __LINE__
	17
	18	uniform mat4 Projection = mat4(1);
	19	uniform mat4 ModelView = mat4(1);
	20
	21	layout(location = 0) in vec3 Position;
	22	layout(location = 1) in vec2 TexCoord;
	23
	24	out vec2 vTexCoord;
	25
	26	void main() {
	27	gl_Position = Projection * ModelView * vec4(Position, 1);
	28	vTexCoord = TexCoord;
	29	}
	30
	31	)VS";
	32
	33	static const char * SIMPLE_TEXTURED_FS = R"FS(#version 410 core
	34	#pragma line __LINE__
	35
	36	uniform sampler2D sampler;
	37	uniform float Alpha = 1.0;
	38
	39	in vec2 vTexCoord;
	40	out vec4 vFragColor;
	41
	42	void main() {
	43	vec4 c = texture(sampler, vTexCoord);
	44	c.a = min(Alpha, c.a);
	45	vFragColor = c;
	46	}
	47
	48	)FS";
	49
	50
	51	ProgramPtr loadDefaultShader() {
	52	ProgramPtr result;
	53	compileProgram(result, SIMPLE_TEXTURED_VS, SIMPLE_TEXTURED_FS);
	54	return result;
	55	}
	56
	57	void compileProgram(ProgramPtr & result, const std::string& vs, const std::string& fs) {
	58	using namespace oglplus;
	59	try {
	60	result = ProgramPtr(new Program());
	61	// attach the shaders to the program
	62	result->AttachShader(
	63	VertexShader()
	64	.Source(GLSLSource(vs))
	65	.Compile()
	66	);
	67	result->AttachShader(
	68	FragmentShader()
	69	.Source(GLSLSource(fs))
	70	.Compile()
	71	);
	72	result->Link();
	73	} catch (ProgramBuildError & err) {
	74	Q_UNUSED(err);
	75	Q_ASSERT_X(false, "compileProgram", "Failed to build shader program");
	76	qFatal((const char*)err.Message);
	77	result.reset();
	78	}
	79	}
	80
	81
	82	ShapeWrapperPtr loadPlane(ProgramPtr program, float aspect) {
	83	using namespace oglplus;
	84	Vec3f a(1, 0, 0);
	85	Vec3f b(0, 1, 0);
	86	if (aspect > 1) {
	87	b[1] /= aspect;
	88	} else {
	89	a[0] *= aspect;
	90	}
	91	return ShapeWrapperPtr(
	92	new shapes::ShapeWrapper({ "Position", "TexCoord" }, shapes::Plane(a, b), *program)
	93	);
	94	}
	95
	96	// Return a point's cartesian coordinates on a sphere from pitch and yaw
	97	static glm::vec3 getPoint(float yaw, float pitch) {
	98	return glm::vec3(glm::cos(-pitch) * (-glm::sin(yaw)),
	99	glm::sin(-pitch),
	100	glm::cos(-pitch) * (-glm::cos(yaw)));
	101	}
	102
	103
	104	class SphereSection : public DrawingInstructionWriter, public DrawMode {
	105	public:
	106	using IndexArray = std::vector<GLuint>;
	107	using PosArray = std::vector<float>;
	108	using TexArray = std::vector<float>;
	109	/// The type of the index container returned by Indices()
	110	// vertex positions
	111	PosArray _pos_data;
	112	// vertex tex coords
	113	TexArray _tex_data;
	114	IndexArray _idx_data;
	115	unsigned int _prim_count{ 0 };
	116
	117	public:
	118	SphereSection(
	119	const float fov,
	120	const float aspectRatio,
	121	const int slices_,
	122	const int stacks_) {
	123	//UV mapping source: http://www.mvps.org/directx/articles/spheremap.htm
	124	if (fov >= PI) {
	125	qDebug() << "TexturedHemisphere::buildVBO(): FOV greater or equal than Pi will create issues";
	126	}
	127
	128	int gridSize = std::max(slices_, stacks_);
	129	int gridSizeLog2 = 1;
	130	while (1 << gridSizeLog2 < gridSize) {
	131	++gridSizeLog2;
	132	}
	133	gridSize = (1 << gridSizeLog2) + 1;
	134	// Compute number of vertices needed
	135	int vertices = gridSize * gridSize;
	136	_pos_data.resize(vertices * 3);
	137	_tex_data.resize(vertices * 2);
	138
	139	// Compute vertices positions and texture UV coordinate
	140	for (int y = 0; y <= gridSize; ++y) {
	141	for (int x = 0; x <= gridSize; ++x) {
	142
	143	}
	144	}
	145	for (int i = 0; i < gridSize; i++) {
	146	float stacksRatio = (float)i / (float)(gridSize - 1); // First stack is 0.0f, last stack is 1.0f
	147	// abs(theta) <= fov / 2.0f
	148	float pitch = -fov * (stacksRatio - 0.5f);
	149	for (int j = 0; j < gridSize; j++) {
	150	float slicesRatio = (float)j / (float)(gridSize - 1); // First slice is 0.0f, last slice is 1.0f
	151	// abs(phi) <= fov * aspectRatio / 2.0f
	152	float yaw = -fov * aspectRatio * (slicesRatio - 0.5f);
	153	int vertex = i * gridSize + j;
	154	int posOffset = vertex * 3;
	155	int texOffset = vertex * 2;
	156	vec3 pos = getPoint(yaw, pitch);
	157	_pos_data[posOffset] = pos.x;
	158	_pos_data[posOffset + 1] = pos.y;
	159	_pos_data[posOffset + 2] = pos.z;
	160	_tex_data[texOffset] = slicesRatio;
	161	_tex_data[texOffset + 1] = stacksRatio;
	162	}
	163	} // done with vertices
	164
	165	int rowLen = gridSize;
	166
	167	// gridsize now refers to the triangles, not the vertices, so reduce by one
	168	// or die by fencepost error http://en.wikipedia.org/wiki/Off-by-one_error
	169	--gridSize;
	170	int quads = gridSize * gridSize;
	171	for (int t = 0; t < quads; ++t) {
	172	int x =
	173	((t & 0x0001) >> 0) \|
	174	((t & 0x0004) >> 1) \|
	175	((t & 0x0010) >> 2) \|
	176	((t & 0x0040) >> 3) \|
	177	((t & 0x0100) >> 4) \|
	178	((t & 0x0400) >> 5) \|
	179	((t & 0x1000) >> 6) \|
	180	((t & 0x4000) >> 7);
	181	int y =
	182	((t & 0x0002) >> 1) \|
	183	((t & 0x0008) >> 2) \|
	184	((t & 0x0020) >> 3) \|
	185	((t & 0x0080) >> 4) \|
	186	((t & 0x0200) >> 5) \|
	187	((t & 0x0800) >> 6) \|
	188	((t & 0x2000) >> 7) \|
	189	((t & 0x8000) >> 8);
	190	int i = x * (rowLen) + y;
	191
	192	_idx_data.push_back(i);
	193	_idx_data.push_back(i + 1);
	194	_idx_data.push_back(i + rowLen + 1);
	195
	196	_idx_data.push_back(i + rowLen + 1);
	197	_idx_data.push_back(i + rowLen);
	198	_idx_data.push_back(i);
	199	}
	200	_prim_count = quads * 2;
	201	}
	202
	203	/// Returns the winding direction of faces
	204	FaceOrientation FaceWinding(void) const {
	205	return FaceOrientation::CCW;
	206	}
	207
	208	typedef GLuint(SphereSection::*VertexAttribFunc)(std::vector<GLfloat>&) const;
	209
	210	/// Makes the vertex positions and returns the number of values per vertex
	211	template <typename T>
	212	GLuint Positions(std::vector<T>& dest) const {
	213	dest.clear();
	214	dest.insert(dest.begin(), _pos_data.begin(), _pos_data.end());
	215	return 3;
	216	}
	217
	218	/// Makes the vertex normals and returns the number of values per vertex
	219	template <typename T>
	220	GLuint Normals(std::vector<T>& dest) const {
	221	dest.clear();
	222	return 3;
	223	}
	224
	225	/// Makes the vertex tangents and returns the number of values per vertex
	226	template <typename T>
	227	GLuint Tangents(std::vector<T>& dest) const {
	228	dest.clear();
	229	return 3;
	230	}
	231
	232	/// Makes the vertex bi-tangents and returns the number of values per vertex
	233	template <typename T>
	234	GLuint Bitangents(std::vector<T>& dest) const {
	235	dest.clear();
	236	return 3;
	237	}
	238
	239	/// Makes the texture coordinates returns the number of values per vertex
	240	template <typename T>
	241	GLuint TexCoordinates(std::vector<T>& dest) const {
	242	dest.clear();
	243	dest.insert(dest.begin(), _tex_data.begin(), _tex_data.end());
	244	return 2;
	245	}
	246
	247	typedef VertexAttribsInfo<
	248	SphereSection,
	249	std::tuple<
	250	VertexPositionsTag,
	251	VertexNormalsTag,
	252	VertexTangentsTag,
	253	VertexBitangentsTag,
	254	VertexTexCoordinatesTag
	255	>
	256	> VertexAttribs;
	257
	258	Spheref MakeBoundingSphere(void) const {
	259	GLfloat min_x = _pos_data[3], max_x = _pos_data[3];
	260	GLfloat min_y = _pos_data[4], max_y = _pos_data[4];
	261	GLfloat min_z = _pos_data[5], max_z = _pos_data[5];
	262	for (std::size_t v = 0, vn = _pos_data.size() / 3; v != vn; ++v) {
	263	GLfloat x = _pos_data[v * 3 + 0];
	264	GLfloat y = _pos_data[v * 3 + 1];
	265	GLfloat z = _pos_data[v * 3 + 2];
	266
	267	if (min_x > x) min_x = x;
	268	if (min_y > y) min_y = y;
	269	if (min_z > z) min_z = z;
	270	if (max_x < x) max_x = x;
	271	if (max_y < y) max_y = y;
	272	if (max_z < z) max_z = z;
	273	}
	274
	275	Vec3f c(
	276	(min_x + max_x) * 0.5f,
	277	(min_y + max_y) * 0.5f,
	278	(min_z + max_z) * 0.5f
	279	);
	280
	281	return Spheref(
	282	c.x(), c.y(), c.z(),
	283	Distance(c, Vec3f(min_x, min_y, min_z))
	284	);
	285	}
	286
	287	/// Queries the bounding sphere coordinates and dimensions
	288	template <typename T>
	289	void BoundingSphere(oglplus::Sphere<T>& bounding_sphere) const {
	290	bounding_sphere = oglplus::Sphere<T>(MakeBoundingSphere());
	291	}
	292
	293
	294	/// Returns element indices that are used with the drawing instructions
	295	const IndexArray & Indices(Default = Default()) const {
	296	return _idx_data;
	297	}
	298
	299	/// Returns the instructions for rendering of faces
	300	DrawingInstructions Instructions(PrimitiveType primitive) const {
	301	DrawingInstructions instr = this->MakeInstructions();
	302	DrawOperation operation;
	303	operation.method = DrawOperation::Method::DrawElements;
	304	operation.mode = primitive;
	305	operation.first = 0;
	306	operation.count = _prim_count * 3;
	307	operation.restart_index = DrawOperation::NoRestartIndex();
	308	operation.phase = 0;
	309	this->AddInstruction(instr, operation);
	310	return std::move(instr);
	311	}
	312
	313	/// Returns the instructions for rendering of faces
	314	DrawingInstructions Instructions(Default = Default()) const {
	315	return Instructions(PrimitiveType::Triangles);
	316	}
	317	};
	318
	319	ShapeWrapperPtr loadSphereSection(ProgramPtr program, float fov, float aspect, int slices, int stacks) {
	320	using namespace oglplus;
	321	return ShapeWrapperPtr(
	322	new shapes::ShapeWrapper({ "Position", "TexCoord" }, SphereSection(fov, aspect, slices, stacks), *program)
	323	);
	324	}
	325	#endif

libraries/render-utils/src/OglplusHelpers.h+173−0

@@ -0,0 +1,173 @@
	1	//
	2	// Created by Bradley Austin Davis on 2015/05/26
	3	// Copyright 2015 High Fidelity, Inc.
	4	//
	5	// Distributed under the Apache License, Version 2.0.
	6	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	7	//
	8	#pragma once
	9
	10	// FIXME support oglplus on all platforms
	11	// For now it's a convenient helper for Windows
	12
	13	#include <QtGlobal>
	14
	15	#ifdef Q_OS_WIN
	16	#include "GLMHelpers.h"
	17
	18	#define OGLPLUS_USE_GLCOREARB_H 0
	19
	20	#if defined(__APPLE__)
	21
	22	#define OGLPLUS_USE_GL3_H 1
	23
	24	#elif defined(WIN32)
	25
	26	#define OGLPLUS_USE_GLEW 1
	27	#pragma warning(disable : 4068)
	28
	29	#elif defined(ANDROID)
	30
	31	#else
	32
	33	#define OGLPLUS_USE_GLCOREARB_H 1
	34
	35	#endif
	36
	37
	38
	39	#define OGLPLUS_USE_BOOST_CONFIG 1
	40	#define OGLPLUS_NO_SITE_CONFIG 1
	41	#define OGLPLUS_LOW_PROFILE 1
	42	#include <oglplus/gl.hpp>
	43
	44	#include <oglplus/all.hpp>
	45	#include <oglplus/interop/glm.hpp>
	46	#include <oglplus/bound/texture.hpp>
	47	#include <oglplus/bound/framebuffer.hpp>
	48	#include <oglplus/bound/renderbuffer.hpp>
	49	#include <oglplus/shapes/wrapper.hpp>
	50	#include <oglplus/shapes/plane.hpp>
	51
	52	#include "NumericalConstants.h"
	53
	54	using FramebufferPtr = std::shared_ptr<oglplus::Framebuffer>;
	55	using ShapeWrapperPtr = std::shared_ptr<oglplus::shapes::ShapeWrapper>;
	56	using BufferPtr = std::shared_ptr<oglplus::Buffer>;
	57	using VertexArrayPtr = std::shared_ptr<oglplus::VertexArray>;
	58	using ProgramPtr = std::shared_ptr<oglplus::Program>;
	59	using Mat4Uniform = oglplus::Uniform<mat4>;
	60
	61	ProgramPtr loadDefaultShader();
	62	void compileProgram(ProgramPtr & result, const std::string& vs, const std::string& fs);
	63	ShapeWrapperPtr loadPlane(ProgramPtr program, float aspect = 1.0f);
	64	ShapeWrapperPtr loadSphereSection(ProgramPtr program, float fov = PI / 3.0f * 2.0f, float aspect = 16.0f / 9.0f, int slices = 32, int stacks = 32);
	65
	66
	67	// A basic wrapper for constructing a framebuffer with a renderbuffer
	68	// for the depth attachment and an undefined type for the color attachement
	69	// This allows us to reuse the basic framebuffer code for both the Mirror
	70	// FBO as well as the Oculus swap textures we will use to render the scene
	71	// Though we don't really need depth at all for the mirror FBO, or even an
	72	// FBO, but using one means I can just use a glBlitFramebuffer to get it onto
	73	// the screen.
	74	template <
	75	typename C,
	76	typename D
	77	>
	78	struct FramebufferWrapper {
	79	uvec2 size;
	80	oglplus::Framebuffer fbo;
	81	C color;
	82	D depth;
	83
	84	FramebufferWrapper() {}
	85
	86	virtual ~FramebufferWrapper() {
	87	}
	88
	89	virtual void Init(const uvec2 & size) {
	90	this->size = size;
	91	initColor();
	92	initDepth();
	93	initDone();
	94	}
	95
	96	template <typename F>
	97	void Bound(F f) {
	98	Bound(oglplus::Framebuffer::Target::Draw, f);
	99	}
	100
	101	template <typename F>
	102	void Bound(oglplus::Framebuffer::Target target , F f) {
	103	fbo.Bind(target);
	104	onBind(target);
	105	f();
	106	onUnbind(target);
	107	oglplus::DefaultFramebuffer().Bind(target);
	108	}
	109
	110	void Viewport() {
	111	oglplus::Context::Viewport(size.x, size.y);
	112	}
	113
	114	protected:
	115	virtual void onBind(oglplus::Framebuffer::Target target) {}
	116	virtual void onUnbind(oglplus::Framebuffer::Target target) {}
	117
	118	static GLenum toEnum(oglplus::Framebuffer::Target target) {
	119	switch (target) {
	120	case oglplus::Framebuffer::Target::Draw:
	121	return GL_DRAW_FRAMEBUFFER;
	122	case oglplus::Framebuffer::Target::Read:
	123	return GL_READ_FRAMEBUFFER;
	124	default:
	125	Q_ASSERT(false);
	126	return GL_FRAMEBUFFER;
	127	}
	128	}
	129
	130	virtual void initDepth() {}
	131
	132	virtual void initColor() {}
	133
	134	virtual void initDone() = 0;
	135	};
	136
	137	struct BasicFramebufferWrapper : public FramebufferWrapper <oglplus::Texture, oglplus::Renderbuffer> {
	138	protected:
	139	virtual void initDepth() override {
	140	using namespace oglplus;
	141	Context::Bound(Renderbuffer::Target::Renderbuffer, depth)
	142	.Storage(
	143	PixelDataInternalFormat::DepthComponent,
	144	size.x, size.y);
	145	}
	146
	147	virtual void initColor() override {
	148	using namespace oglplus;
	149	Context::Bound(oglplus::Texture::Target::_2D, color)
	150	.MinFilter(TextureMinFilter::Linear)
	151	.MagFilter(TextureMagFilter::Linear)
	152	.WrapS(TextureWrap::ClampToEdge)
	153	.WrapT(TextureWrap::ClampToEdge)
	154	.Image2D(
	155	0, PixelDataInternalFormat::RGBA8,
	156	size.x, size.y,
	157	0, PixelDataFormat::RGB, PixelDataType::UnsignedByte, nullptr
	158	);
	159	}
	160
	161	virtual void initDone() override {
	162	using namespace oglplus;
	163	static const Framebuffer::Target target = Framebuffer::Target::Draw;
	164	Bound(target, [&] {
	165	fbo.AttachTexture(target, FramebufferAttachment::Color, color, 0);
	166	fbo.AttachRenderbuffer(target, FramebufferAttachment::Depth, depth);
	167	fbo.Complete(target);
	168	});
	169	}
	170	};
	171
	172	using BasicFramebufferWrapperPtr = std::shared_ptr<BasicFramebufferWrapper>;
	173	#endif

libraries/render-utils/src/ProgramObject.h+12−3

 #ifndef hifi_ProgramObject_h
 #define hifi_ProgramObject_h
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdouble-promotion"
+#endif
 #include <QGLShaderProgram>
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 #include <glm/glm.hpp>
 class ProgramObject : public QGLShaderProgram {
 public:
     ProgramObject(QObject* parent = 0);
     void setUniform(int location, const glm::vec2& value);
     void setUniform(const char* name, const glm::vec2& value);
     void setUniform(int location, const glm::vec3& value);
     void setUniform(const char* name, const glm::vec3& value);
     void setUniform(int location, const glm::vec4& value);
     void setUniform(const char* name, const glm::vec4& value);
     void setUniformArray(const char* name, const glm::vec3* values, int count);
 };
 #endif // hifi_ProgramObject_h

libraries/render-utils/src/RenderDeferredTask.cpp+114−176

@@ -19,42 +19,54 @@ · 18 unmodified lines
19		19
20	#include <PerfStat.h>	20	#include <PerfStat.h>
21		21
22	#include "overlay3D_vert.h"	22	#include "overlay3D_vert.h"
23	#include "overlay3D_frag.h"	23	#include "overlay3D_frag.h"
24		24
25	using namespace render;	25	using namespace render;
26		26
27	template <> void render::jobRun(const PrepareDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {	27	void PrepareDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
28	PerformanceTimer perfTimer("PrepareDeferred");	28	DependencyManager::get<DeferredLightingEffect>()->prepare(renderContext->args);
29	DependencyManager::get<DeferredLightingEffect>()->prepare();
30	}	29	}
31		30
32	template <> void render::jobRun(const RenderDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {	31	void RenderDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
33	PerformanceTimer perfTimer("RenderDeferred");	32	DependencyManager::get<DeferredLightingEffect>()->render(renderContext->args);
34	DependencyManager::get<DeferredLightingEffect>()->render();
35	// renderContext->args->_context->syncCache();
36	}	33	}
37		34
38	template <> void render::jobRun(const ResolveDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {	35	void ResolveDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
39	PerformanceTimer perfTimer("ResolveDeferred");	36	PerformanceTimer perfTimer("ResolveDeferred");
40	DependencyManager::get<DeferredLightingEffect>()->copyBack(renderContext->args);	37	DependencyManager::get<DeferredLightingEffect>()->copyBack(renderContext->args);
41	renderContext->args->_context->syncCache();
42
43	}	38	}
44		39
45
46
47	RenderDeferredTask::RenderDeferredTask() : Task() {	40	RenderDeferredTask::RenderDeferredTask() : Task() {
48	_jobs.push_back(Job(PrepareDeferred()));	41	_jobs.push_back(Job(new PrepareDeferred::JobModel("PrepareDeferred")));
49	_jobs.push_back(Job(DrawBackground()));	42	_jobs.push_back(Job(new DrawBackground::JobModel("DrawBackground")));
50	_jobs.push_back(Job(DrawOpaqueDeferred()));	43	_jobs.push_back(Job(new FetchItems::JobModel("FetchOpaque",
51	_jobs.push_back(Job(DrawLight()));	44	FetchItems(
52	_jobs.push_back(Job(ResetGLState()));	45	[] (const RenderContextPointer& context, int count) {
53	_jobs.push_back(Job(RenderDeferred()));	46	context->_numFeedOpaqueItems = count;
54	_jobs.push_back(Job(ResolveDeferred()));	47	}
55	_jobs.push_back(Job(DrawTransparentDeferred()));	48	)
56	_jobs.push_back(Job(DrawOverlay3D()));	49	)));
57	_jobs.push_back(Job(ResetGLState()));	50	_jobs.push_back(Job(new CullItems::JobModel("CullOpaque", _jobs.back().getOutput())));
		51	_jobs.push_back(Job(new DepthSortItems::JobModel("DepthSortOpaque", _jobs.back().getOutput())));
		52	_jobs.push_back(Job(new DrawOpaqueDeferred::JobModel("DrawOpaqueDeferred", _jobs.back().getOutput())));
		53	_jobs.push_back(Job(new DrawLight::JobModel("DrawLight")));
		54	_jobs.push_back(Job(new ResetGLState::JobModel()));
		55	_jobs.push_back(Job(new RenderDeferred::JobModel("RenderDeferred")));
		56	_jobs.push_back(Job(new ResolveDeferred::JobModel("ResolveDeferred")));
		57	_jobs.push_back(Job(new FetchItems::JobModel("FetchTransparent",
		58	FetchItems(
		59	ItemFilter::Builder::transparentShape().withoutLayered(),
		60	[] (const RenderContextPointer& context, int count) {
		61	context->_numFeedTransparentItems = count;
		62	}
		63	)
		64	)));
		65	_jobs.push_back(Job(new CullItems::JobModel("CullTransparent", _jobs.back().getOutput())));
		66	_jobs.push_back(Job(new DepthSortItems::JobModel("DepthSortTransparent", _jobs.back().getOutput(), DepthSortItems(false))));
		67	_jobs.push_back(Job(new DrawTransparentDeferred::JobModel("TransparentDeferred", _jobs.back().getOutput())));
		68	_jobs.push_back(Job(new DrawOverlay3D::JobModel("DrawOverlay3D")));
		69	_jobs.push_back(Job(new ResetGLState::JobModel()));
58	}	70	}
59		71
60	RenderDeferredTask::~RenderDeferredTask() {	72	RenderDeferredTask::~RenderDeferredTask() {
@@ -80,181 +92,104 @@ void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const Rend · 19 unmodified lines
80	}	92	}
81	};	93	};
82		94
83		95	void DrawOpaqueDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems) {
84
85	template <> void render::jobRun(const DrawOpaqueDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
86	PerformanceTimer perfTimer("DrawOpaqueDeferred");
87	assert(renderContext->args);	96	assert(renderContext->args);
88	assert(renderContext->args->_viewFrustum);	97	assert(renderContext->args->_viewFrustum);
89		98
90	// render opaques	99	RenderArgs* args = renderContext->args;
91	auto& scene = sceneContext->_scene;	100	gpu::Batch batch;
92	auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape().withoutLayered());	101	args->_batch = &batch;
93	auto& renderDetails = renderContext->args->_details;
94
95	ItemIDsBounds inItems;
96	inItems.reserve(items.size());
97	for (auto id : items) {
98	inItems.emplace_back(ItemIDAndBounds(id));
99	}
100	ItemIDsBounds& renderedItems = inItems;
101
102	renderContext->_numFeedOpaqueItems = renderedItems.size();
103
104	ItemIDsBounds culledItems;
105	culledItems.reserve(inItems.size());
106	if (renderContext->_cullOpaque) {
107	renderDetails.pointTo(RenderDetails::OPAQUE_ITEM);
108	cullItems(sceneContext, renderContext, renderedItems, culledItems);
109	renderDetails.pointTo(RenderDetails::OTHER_ITEM);
110	renderedItems = culledItems;
111	}
112
113	renderContext->_numDrawnOpaqueItems = renderedItems.size();
114		102
		103	renderContext->_numDrawnOpaqueItems = inItems.size();
115		104
116	ItemIDsBounds sortedItems;	105	glm::mat4 projMat;
117	sortedItems.reserve(culledItems.size());	106	Transform viewMat;
118	if (renderContext->_sortOpaque) {	107	args->_viewFrustum->evalProjectionMatrix(projMat);
119	depthSortItems(sceneContext, renderContext, true, renderedItems, sortedItems); // Sort Front to back opaque items!	108	args->_viewFrustum->evalViewTransform(viewMat);
120	renderedItems = sortedItems;	109	if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
		110	viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
121	}	111	}
		112	batch.setProjectionTransform(projMat);
		113	batch.setViewTransform(viewMat);
122		114
123	// ItemIDsBounds sortedItems;	115	{
124	/* ItemMaterialBucketMap stateSortedItems;	116	GLenum buffers[3];
125	stateSortedItems.allocateStandardMaterialBuckets();	117	int bufferCount = 0;
126	if (true) {	118	buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
127	for (auto& itemIDAndBound : renderedItems) {	119	buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
128	stateSortedItems.insert(itemIDAndBound.id, scene->getItem(itemIDAndBound.id).getMaterialKey());	120	buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
129	}	121	batch._glDrawBuffers(bufferCount, buffers);
		122	const float OPAQUE_ALPHA_THRESHOLD = 0.5f;
		123	args->_alphaThreshold = OPAQUE_ALPHA_THRESHOLD;
130	}	124	}
131	*/
132
133	if (renderContext->_renderOpaque) {
134	RenderArgs* args = renderContext->args;
135	gpu::Batch batch;
136	args->_batch = &batch;
137
138	glm::mat4 projMat;
139	Transform viewMat;
140	args->_viewFrustum->evalProjectionMatrix(projMat);
141	args->_viewFrustum->evalViewTransform(viewMat);
142	if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
143	viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
144	}
145	batch.setProjectionTransform(projMat);
146	batch.setViewTransform(viewMat);
147
148	{
149	GLenum buffers[3];
150	int bufferCount = 0;
151	buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
152	buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
153	buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
154	batch._glDrawBuffers(bufferCount, buffers);
155	}
156		125
157	renderItems(sceneContext, renderContext, renderedItems, renderContext->_maxDrawnOpaqueItems);	126	renderItems(sceneContext, renderContext, inItems, renderContext->_maxDrawnOpaqueItems);
158		127
159	args->_context->render((*args->_batch));	128	// Before rendering the batch make sure we re in sync with gl state
160	args->_batch = nullptr;	129	args->_context->syncCache();
161	}	130	renderContext->args->_context->syncCache();
		131	args->_context->render((*args->_batch));
		132	args->_batch = nullptr;
162	}	133	}
163		134
164		135	void DrawTransparentDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems) {
165	template <> void render::jobRun(const DrawTransparentDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
166	PerformanceTimer perfTimer("DrawTransparentDeferred");
167	assert(renderContext->args);	136	assert(renderContext->args);
168	assert(renderContext->args->_viewFrustum);	137	assert(renderContext->args->_viewFrustum);
169
170	// render transparents
171	auto& scene = sceneContext->_scene;
172	auto& items = scene->getMasterBucket().at(ItemFilter::Builder::transparentShape().withoutLayered());
173	auto& renderDetails = renderContext->args->_details;	138	auto& renderDetails = renderContext->args->_details;
174
175	ItemIDsBounds inItems;
176	inItems.reserve(items.size());
177	for (auto id : items) {
178	inItems.push_back(id);
179	}
180	ItemIDsBounds& renderedItems = inItems;
181		139
182	renderContext->_numFeedTransparentItems = renderedItems.size();	140	RenderArgs* args = renderContext->args;
		141	gpu::Batch batch;
		142	args->_batch = &batch;
		143
		144	renderContext->_numDrawnTransparentItems = inItems.size();
183		145
184	ItemIDsBounds culledItems;	146	glm::mat4 projMat;
185	if (renderContext->_cullTransparent) {	147	Transform viewMat;
186	renderDetails.pointTo(RenderDetails::TRANSLUCENT_ITEM);	148	args->_viewFrustum->evalProjectionMatrix(projMat);
187	cullItems(sceneContext, renderContext, inItems, culledItems);	149	args->_viewFrustum->evalViewTransform(viewMat);
188	renderDetails.pointTo(RenderDetails::OTHER_ITEM);	150	if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
189	renderedItems = culledItems;	151	viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
190	}	152	}
		153	batch.setProjectionTransform(projMat);
		154	batch.setViewTransform(viewMat);
		155	const float TRANSPARENT_ALPHA_THRESHOLD = 0.0f;
191		156
192	renderContext->_numDrawnTransparentItems = renderedItems.size();	157	{
193		158	GLenum buffers[3];
194	ItemIDsBounds sortedItems;	159	int bufferCount = 0;
195	if (renderContext->_sortTransparent) {	160	buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
196	depthSortItems(sceneContext, renderContext, false, renderedItems, sortedItems); // Sort Back to front transparent items!	161	batch._glDrawBuffers(bufferCount, buffers);
197	renderedItems = sortedItems;	162	args->_alphaThreshold = TRANSPARENT_ALPHA_THRESHOLD;
198	}	163	}
		164
		165
		166	renderItems(sceneContext, renderContext, inItems, renderContext->_maxDrawnTransparentItems);
		167
		168	// Before rendering the batch make sure we re in sync with gl state
		169	args->_context->syncCache();
		170	args->_context->render((*args->_batch));
		171	args->_batch = nullptr;
		172
		173	// reset blend function to standard...
		174	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
		175	}
199		176
200	if (renderContext->_renderTransparent) {	177	const gpu::PipelinePointer& DrawOverlay3D::getOpaquePipeline() const {
201	RenderArgs* args = renderContext->args;	178	if (!_opaquePipeline) {
202	gpu::Batch batch;	179	auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(overlay3D_vert)));
203	args->_batch = &batch;	180	auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(overlay3D_frag)));
204
205		181
		182	auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
206		183
		184	auto state = gpu::StatePointer(new gpu::State());
		185	state->setDepthTest(true, true, gpu::LESS_EQUAL);
207		186
208	glm::mat4 projMat;	187	_opaquePipeline.reset(gpu::Pipeline::create(program, state));
209	Transform viewMat;
210	args->_viewFrustum->evalProjectionMatrix(projMat);
211	args->_viewFrustum->evalViewTransform(viewMat);
212	if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
213	viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
214	}
215	batch.setProjectionTransform(projMat);
216	batch.setViewTransform(viewMat);
217
218	const float TRANSPARENT_ALPHA_THRESHOLD = 0.0f;
219
220	{
221	GLenum buffers[3];
222	int bufferCount = 0;
223	buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
224	batch._glDrawBuffers(bufferCount, buffers);
225	args->_alphaThreshold = TRANSPARENT_ALPHA_THRESHOLD;
226	}
227
228
229	renderItems(sceneContext, renderContext, renderedItems, renderContext->_maxDrawnTransparentItems);
230
231	// Before rendering the batch make sure we re in sync with gl state
232	args->_context->syncCache();
233	args->_context->render((*args->_batch));
234	args->_batch = nullptr;
235
236	// reset blend function to standard...
237	// glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
238	}	188	}
		189	return _opaquePipeline;
239	}	190	}
240		191
241	const gpu::PipelinePointer& DrawOverlay3D::getOpaquePipeline() const {	192	void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
242	if (!_opaquePipeline) {
243	auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(overlay3D_vert)));
244	auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(overlay3D_frag)));
245
246	auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
247
248	auto state = gpu::StatePointer(new gpu::State());
249	state->setDepthTest(true, true, gpu::LESS_EQUAL);
250
251	_opaquePipeline.reset(gpu::Pipeline::create(program, state));
252	}
253	return _opaquePipeline;
254	}
255
256	template <> void render::jobRun(const DrawOverlay3D& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
257	PerformanceTimer perfTimer("DrawOverlay3D");
258	assert(renderContext->args);	193	assert(renderContext->args);
259	assert(renderContext->args->_viewFrustum);	194	assert(renderContext->args->_viewFrustum);
260		195
@@ -271,13 +206,14 @@ template <> void render::jobRun(const DrawOverlay3D& job, const SceneContextPoin · 10 unmodified lines
271	inItems.emplace_back(id);	206	inItems.emplace_back(id);
272	}	207	}
273	}	208	}
274		209	renderContext->_numFeedOverlay3DItems = inItems.size();
		210	renderContext->_numDrawnOverlay3DItems = inItems.size();
		211
275	RenderArgs* args = renderContext->args;	212	RenderArgs* args = renderContext->args;
276	gpu::Batch batch;	213	gpu::Batch batch;
277	args->_batch = &batch;	214	args->_batch = &batch;
278	args->_whiteTexture = DependencyManager::get<TextureCache>()->getWhiteTexture();	215	args->_whiteTexture = DependencyManager::get<TextureCache>()->getWhiteTexture();
279		216
280
281	glm::mat4 projMat;	217	glm::mat4 projMat;
282	Transform viewMat;	218	Transform viewMat;
283	args->_viewFrustum->evalProjectionMatrix(projMat);	219	args->_viewFrustum->evalProjectionMatrix(projMat);
@@ -287,12 +223,13 @@ template <> void render::jobRun(const DrawOverlay3D& job, const SceneContextPoin · 3 unmodified lines
287	}	223	}
288	batch.setProjectionTransform(projMat);	224	batch.setProjectionTransform(projMat);
289	batch.setViewTransform(viewMat);	225	batch.setViewTransform(viewMat);
290	batch.setPipeline(job.getOpaquePipeline());	226
		227	batch.setPipeline(getOpaquePipeline());
291	batch.setUniformTexture(0, args->_whiteTexture);	228	batch.setUniformTexture(0, args->_whiteTexture);
292		229
293	if (!inItems.empty()) {	230	if (!inItems.empty()) {
294	batch.clearFramebuffer(gpu::Framebuffer::BUFFER_DEPTH, glm::vec4(), 1.f, 0);	231	batch.clearFramebuffer(gpu::Framebuffer::BUFFER_DEPTH, glm::vec4(), 1.f, 0);
295	renderItems(sceneContext, renderContext, inItems);	232	renderItems(sceneContext, renderContext, inItems, renderContext->_maxDrawnOverlay3DItems);
296	}	233	}
297		234
298	// Before rendering the batch make sure we re in sync with gl state	235	// Before rendering the batch make sure we re in sync with gl state
@@ -301,3 +238,4 @@ template <> void render::jobRun(const DrawOverlay3D& job, const SceneContextPoin · 2 unmodified lines
301	args->_batch = nullptr;	238	args->_batch = nullptr;
302	args->_whiteTexture.reset();	239	args->_whiteTexture.reset();
303	}	240	}
		241

libraries/render-utils/src/RenderDeferredTask.h+25−24

@@ -18,48 +18,49 @@ · 17 unmodified lines
18		18
19	class PrepareDeferred {	19	class PrepareDeferred {
20	public:	20	public:
		21	void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
		22
		23	typedef render::Job::Model<PrepareDeferred> JobModel;
21	};	24	};
22	namespace render {	25
23	template <> void jobRun(const PrepareDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
24	}
25		26
26	class RenderDeferred {	27	class RenderDeferred {
27	public:	28	public:
		29	void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
		30
		31	typedef render::Job::Model<RenderDeferred> JobModel;
28	};	32	};
29	namespace render {
30	template <> void jobRun(const RenderDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
31	}
32		33
33	class ResolveDeferred {	34	class ResolveDeferred {
34	public:	35	public:
35	};	36	void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
36	namespace render {
37	template <> void jobRun(const ResolveDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
38	}
39		37
		38	typedef render::Job::Model<ResolveDeferred> JobModel;
		39	};
40		40
41	class DrawOpaqueDeferred {	41	class DrawOpaqueDeferred {
42	public:	42	public:
		43	void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const render::ItemIDsBounds& inItems);
		44
		45	typedef render::Job::ModelI<DrawOpaqueDeferred, render::ItemIDsBounds> JobModel;
43	};	46	};
44	namespace render {
45	template <> void jobRun(const DrawOpaqueDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
46	}
47		47
48	class DrawTransparentDeferred {	48	class DrawTransparentDeferred {
49	public:	49	public:
		50	void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const render::ItemIDsBounds& inItems);
		51
		52	typedef render::Job::ModelI<DrawTransparentDeferred, render::ItemIDsBounds> JobModel;
50	};	53	};
51	namespace render {	54
52	template <> void jobRun(const DrawTransparentDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);	55	class DrawOverlay3D {
53	}	56	mutable gpu::PipelinePointer _opaquePipeline; //lazy evaluation hence mutable
54		57	public:
55	class DrawOverlay3D {	58	const gpu::PipelinePointer& getOpaquePipeline() const;
56	mutable gpu::PipelinePointer _opaquePipeline; //lazy evaluation hence mutable	59
57	public:	60	void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
58	const gpu::PipelinePointer& getOpaquePipeline() const;	61
		62	typedef render::Job::Model<DrawOverlay3D> JobModel;
59	};	63	};
60	namespace render {
61	template <> void jobRun(const DrawOverlay3D& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
62	}
63		64
64	class RenderDeferredTask : public render::Task {	65	class RenderDeferredTask : public render::Task {
65	public:	66	public:

libraries/render-utils/src/TextRenderer.cpp+9−0

 #include <QBuffer>
 #include <QFile>
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdouble-promotion"
+#endif
 // FIXME, decouple from the GL headers
 #include <QOpenGLShaderProgram>
 #include <QOpenGLTexture>
 #include <QOpenGLVertexArrayObject>
 #include <QOpenGLBuffer>
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>

libraries/render-utils/src/TextRenderer3D.cpp+14−28

 #include "GeometryCache.h"
 #include "DeferredLightingEffect.h"
-// FIXME support the shadow effect, or remove it from the API
-// FIXME figure out how to improve the anti-aliasing on the
-// interior of the outline fonts
-const float DEFAULT_POINT_SIZE = 12;
 // Helper functions for reading binary data from an IO device
 template<class T>
 void readStream(QIODevice& in, T& t) {
     // Render string to batch
     void drawString(gpu::Batch& batch, float x, float y, const QString& str,
-            const glm::vec4& color, TextRenderer3D::EffectType effectType,
+            const glm::vec4* color, TextRenderer3D::EffectType effectType,
             const glm::vec2& bound);
 private:
     }
 }
-void Font3D::drawString(gpu::Batch& batch, float x, float y, const QString& str, const glm::vec4& color,
+void Font3D::drawString(gpu::Batch& batch, float x, float y, const QString& str, const glm::vec4* color,
                       TextRenderer3D::EffectType effectType, const glm::vec2& bounds) {
     if (str == "") {
         return;
     setupGPU();
     batch.setPipeline(_pipeline);
     batch.setUniformTexture(_fontLoc, _texture);
-    batch._glUniform1f(_outlineLoc, (effectType == TextRenderer3D::OUTLINE_EFFECT) ? 1.0f : 0.0f);
+    batch._glUniform1i(_outlineLoc, (effectType == TextRenderer3D::OUTLINE_EFFECT));
-    batch._glUniform4fv(_colorLoc, 1, (const GLfloat*)&color);
+    batch._glUniform4fv(_colorLoc, 1, (const GLfloat*)color);
     batch.setInputFormat(_format);
     batch.setInputBuffer(0, _verticesBuffer, 0, _format->getChannels().at(0)._stride);
     batch.draw(gpu::QUADS, _numVertices, 0);
 }
-TextRenderer3D* TextRenderer3D::getInstance(const char* family, float pointSize,
+TextRenderer3D* TextRenderer3D::getInstance(const char* family,
-        int weight, bool italic, EffectType effect, int effectThickness,
+        int weight, bool italic, EffectType effect, int effectThickness) {
-        const QColor& color) {
+    return new TextRenderer3D(family, weight, italic, effect, effectThickness);
-    if (pointSize < 0) {
-        pointSize = DEFAULT_POINT_SIZE;
-    }
-    return new TextRenderer3D(family, pointSize, weight, italic, effect,
-            effectThickness, color);
 }
-TextRenderer3D::TextRenderer3D(const char* family, float pointSize, int weight, bool italic,
+TextRenderer3D::TextRenderer3D(const char* family, int weight, bool italic,
-                           EffectType effect, int effectThickness, const QColor& color) :
+                           EffectType effect, int effectThickness) :
     _effectType(effect),
     _effectThickness(effectThickness),
-    _pointSize(pointSize),
-    _color(toGlm(color)),
     _font(loadFont3D(family)) {
     if (!_font) {
         qWarning() << "Unable to load font with family " << family;
         _font = loadFont3D("Courier");
     }
     if (1 != _effectThickness) {
-        qWarning() << "Effect thickness not current supported";
+        qWarning() << "Effect thickness not currently supported";
     }
     if (NO_EFFECT != _effectType && OUTLINE_EFFECT != _effectType) {
-        qWarning() << "Effect thickness not current supported";
+        qWarning() << "Effect type not currently supported";
     }
 }
                          const glm::vec2& bounds) {
     // The font does all the OpenGL work
     if (_font) {
-        glm::vec4 actualColor(color);
+        // Cache color so that the pointer stays valid.
-        if (actualColor.r < 0) {
+        _color = color;
-            actualColor = _color;
+        _font->drawString(batch, x, y, str, &_color, _effectType, bounds);
-        }
-        _font->drawString(batch, x, y, str, actualColor, _effectType, bounds);
     }
 }

libraries/render-utils/src/TextRenderer3D.h+9−12

 class Font3D;
 // TextRenderer3D is actually a fairly thin wrapper around a Font class
 // defined in the cpp file.
 class TextRenderer3D {
 public:
     enum EffectType { NO_EFFECT, SHADOW_EFFECT, OUTLINE_EFFECT };
-    static TextRenderer3D* getInstance(const char* family, float pointSize = -1, int weight = -1, bool italic = false,
+    static TextRenderer3D* getInstance(const char* family, int weight = -1, bool italic = false,
-        EffectType effect = NO_EFFECT, int effectThickness = 1, const QColor& color = QColor(255, 255, 255));
+                                       EffectType effect = NO_EFFECT, int effectThickness = 1);
     ~TextRenderer3D();
     glm::vec2 computeExtent(const QString& str) const;
-    float getFontSize() const;
+    float getFontSize() const; // Pixel size
-    void draw(gpu::Batch& batch, float x, float y, const QString& str, const glm::vec4& color = glm::vec4(-1.0f),
+    void draw(gpu::Batch& batch, float x, float y, const QString& str, const glm::vec4& color = glm::vec4(1.0f),
-               const glm::vec2& bounds = glm::vec2(-1.0f));
+              const glm::vec2& bounds = glm::vec2(-1.0f));
 private:
-    TextRenderer3D(const char* family, float pointSize = -1, int weight = -1, bool italic = false,
+    TextRenderer3D(const char* family, int weight = -1, bool italic = false,
-        EffectType effect = NO_EFFECT, int effectThickness = 1, const QColor& color = QColor(255, 255, 255));
+                   EffectType effect = NO_EFFECT, int effectThickness = 1);
     // the type of effect to apply
     const EffectType _effectType;
     // the thickness of the effect
     const int _effectThickness;
-    const float _pointSize;
     // text color
-    const glm::vec4 _color;
+    glm::vec4 _color;
     Font3D* _font;
 };

libraries/render-utils/src/sdf_text3D.slf+11−6

 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 uniform sampler2D Font;
-uniform float Outline;
+uniform bool Outline;
 uniform vec4 Color;
-const float gamma = 2.6;
+// the interpolated normal
-const float smoothing = 100.0;
+varying vec4 interpolatedNormal;
+const float gamma = 2.2;
+const float smoothing = 64.0;
 const float interiorCutoff = 0.8;
 const float outlineExpansion = 0.2;
 void main() {
     // retrieve signed distance
     float sdf = texture2D(Font, gl_TexCoord[0].xy).g;
-    if (Outline == 1.0f) {
+    if (Outline) {
         if (sdf > interiorCutoff) {
             sdf = 1.0 - sdf;
         } else {
     }
     // perform adaptive anti-aliasing of the edges
     // The larger we're rendering, the less anti-aliasing we need
-    float s = smoothing * length(fwidth(gl_TexCoord[0]));
+    float s = smoothing * length(fwidth(gl_TexCoord[0].xy));
     float w = clamp( s, 0.0, 0.5);
     float a = smoothstep(0.5 - w, 0.5 + w, sdf);
     }
     // final color
-    gl_FragColor = vec4(Color.rgb, a);
+    gl_FragData[0] = vec4(Color.rgb, Color.a * a);
+    gl_FragData[1] = vec4(interpolatedNormal.xyz, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 1.0);
+    gl_FragData[2] = vec4(0.0);
 }

libraries/render-utils/src/sdf_text3D.slv+6−0

 <$declareStandardTransform()$>
+// the interpolated normal
+varying vec4 interpolatedNormal;
 void main() {
     gl_TexCoord[0] = gl_MultiTexCoord0;
     TransformCamera cam = getTransformCamera();
     TransformObject obj = getTransformObject();
     <$transformModelToClipPos(cam, obj, gl_Vertex, gl_Position)$>
+    <$transformModelToEyeDir(cam, obj, gl_Normal, interpolatedNormal.xyz)$>
+    interpolatedNormal = vec4(normalize(interpolatedNormal.xyz), 0.0);
 }

libraries/render-utils/src/standardDrawTexture.slf+24−0

@@ -0,0 +1,24 @@
	1	<@include gpu/Config.slh@>
	2	<$VERSION_HEADER$>
	3	// Generated on <$_SCRIBE_DATE$>
	4	// standardDrawTexture.frag
	5	// fragment shader
	6	//
	7	// Created by Sam Gateau on 6/10/15.
	8	// Copyright 2015 High Fidelity, Inc.
	9	//
	10	// Distributed under the Apache License, Version 2.0.
	11	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	12	//
	13
	14	// the texture
	15	uniform sampler2D colorMap;
	16
	17	varying vec2 varTexcoord;
	18	varying vec4 varColor;
	19
	20
	21	void main(void) {
	22	vec4 color = texture2D(colorMap, varTexcoord);
	23	gl_FragColor = color * varColor;
	24	}

libraries/render-utils/src/standardTransformPNTC.slv+35−0

@@ -0,0 +1,35 @@
	1	<@include gpu/Config.slh@>
	2	<$VERSION_HEADER$>
	3	// Generated on <$_SCRIBE_DATE$>
	4	//
	5	// standardTransformPNTC.slv
	6	// vertex shader
	7	//
	8	// Created by Sam Gateau on 6/10/2015.
	9	// Copyright 2015 High Fidelity, Inc.
	10	//
	11	// Distributed under the Apache License, Version 2.0.
	12	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	13	//
	14
	15	<@include gpu/Transform.slh@>
	16
	17	<$declareStandardTransform()$>
	18
	19	varying vec3 varPosition;
	20	varying vec3 varNormal;
	21	varying vec2 varTexcoord;
	22	varying vec4 varColor;
	23
	24	void main(void) {
	25	varTexcoord = gl_MultiTexCoord0.xy;
	26	varColor = gl_Color;
	27
	28	// standard transform
	29	TransformCamera cam = getTransformCamera();
	30	TransformObject obj = getTransformObject();
	31	<$transformModelToClipPos(cam, obj, gl_Vertex, gl_Position)$>
	32	<$transformModelToEyeDir(cam, obj, gl_Normal, varNormal)$>
	33	varNormal = normalize(varNormal);
	34	varPosition = gl_Vertex.xyz;
	35	}

libraries/render-utils/src/stars.slf+76−0

@@ -0,0 +1,76 @@
	1	<@include gpu/Config.slh@>
	2	<$VERSION_HEADER$>
	3	// Generated on <$_SCRIBE_DATE$>
	4	// stars.frag
	5	// fragment shader
	6	//
	7	// Created by Bradley Austin Davis on 2015/06/19
	8
	9	varying vec2 varTexcoord;
	10	varying vec3 varNomral;
	11	varying vec3 varPosition;
	12
	13
	14	const int star_iterations = 14;
	15	const float time_scale = 0.2;
	16	const vec3 col_star = vec3( 1.0, 0.7, 0.5 );
	17
	18	float hash( float n ) { return fract(sin(n)*123.456789); }
	19
	20	vec2 rotate( in vec2 uv, float a)
	21	{
	22	float c = cos( a );
	23	float s = sin( a );
	24	return vec2( c * uv.x - s * uv.y, s * uv.x + c * uv.y );
	25	}
	26
	27	float noise( in vec3 p )
	28	{
	29	vec3 fl = floor( p );
	30	vec3 fr = fract( p );
	31	fr = fr * fr * ( 3.0 - 2.0 * fr );
	32
	33	float n = fl.x + fl.y * 157.0 + 113.0 * fl.z;
	34	return mix( mix( mix( hash( n + 0.0), hash( n + 1.0 ), fr.x ),
	35	mix( hash( n + 157.0), hash( n + 158.0 ), fr.x ), fr.y ),
	36	mix( mix( hash( n + 113.0), hash( n + 114.0 ), fr.x ),
	37	mix( hash( n + 270.0), hash( n + 271.0 ), fr.x ), fr.y ), fr.z );
	38	}
	39
	40	float fbm( in vec2 p, float t )
	41	{
	42	float f;
	43	f = 0.5000 * noise( vec3( p, t ) ); p *= 2.1;
	44	f += 0.2500 * noise( vec3( p, t ) ); p *= 2.2;
	45	f += 0.1250 * noise( vec3( p, t ) ); p *= 2.3;
	46	f += 0.0625 * noise( vec3( p, t ) );
	47	return f;
	48	}
	49
	50	vec3 doBackgroundStars( in vec3 dir )
	51	{
	52	vec3 n = abs( dir );
	53	vec2 uv = ( n.x > n.y && n.x > n.z ) ? dir.yz / dir.x:
	54	( n.y > n.x && n.y > n.z ) ? dir.zx / dir.y:
	55	dir.xy / dir.z;
	56
	57	float f = 0.0;
	58
	59	for( int i = 0 ; i < star_iterations; ++i )
	60	{
	61	uv = rotate( 1.07 * uv + vec2( 0.7 ), 0.5 );
	62
	63	float t = 10. * uv.x * uv.y;
	64	vec2 u = cos( 100. * uv ) * fbm( 10. * uv, 0.0 );
	65	f += smoothstep( 0.5, 0.55, u.x * u.y ) * ( 0.25 * sin( t ) + 0.75 );
	66	}
	67
	68	return f * col_star;
	69	}
	70
	71	void main(void) {
	72	vec3 c = doBackgroundStars( normalize(varPosition) );
	73	c = pow( c, vec3( 0.4545 ) );
	74	gl_FragColor = vec4( c, 1.0 );
	75	}
	76

libraries/render/src/render/DrawTask.cpp+54−229

@@ -25,11 +25,6 @@ · 24 unmodified lines
25	using namespace render;	25	using namespace render;
26		26
27	DrawSceneTask::DrawSceneTask() : Task() {	27	DrawSceneTask::DrawSceneTask() : Task() {
28
29	_jobs.push_back(Job(DrawOpaque()));
30	_jobs.push_back(Job(DrawLight()));
31	_jobs.push_back(Job(DrawTransparent()));
32	_jobs.push_back(Job(ResetGLState()));
33	}	28	}
34		29
35	DrawSceneTask::~DrawSceneTask() {	30	DrawSceneTask::~DrawSceneTask() {
@@ -56,8 +51,11 @@ void DrawSceneTask::run(const SceneContextPointer& sceneContext, const RenderCon · 20 unmodified lines
56	Job::~Job() {	51	Job::~Job() {
57	}	52	}
58		53
		54
		55
		56
		57
59	void render::cullItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems) {	58	void render::cullItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems) {
60	PerformanceTimer perfTimer("cullItems");
61	assert(renderContext->args);	59	assert(renderContext->args);
62	assert(renderContext->args->_viewFrustum);	60	assert(renderContext->args->_viewFrustum);
63		61
@@ -68,17 +66,9 @@ void render::cullItems(const SceneContextPointer& sceneContext, const RenderCont · 4 unmodified lines
68	renderDetails->_considered += inItems.size();	66	renderDetails->_considered += inItems.size();
69		67
70	// Culling / LOD	68	// Culling / LOD
71	for (auto itemDetails : inItems) {	69	for (auto item : inItems) {
72	auto item = scene->getItem(itemDetails.id);	70	if (item.bounds.isNull()) {
73	AABox bound;	71	outItems.emplace_back(item); // One more Item to render
74	{
75	PerformanceTimer perfTimer("getBound");
76
77	bound = item.getBound();
78	}
79
80	if (bound.isNull()) {
81	outItems.emplace_back(ItemIDAndBounds(itemDetails.id)); // One more Item to render
82	continue;	72	continue;
83	}	73	}
84		74
@@ -87,16 +77,16 @@ void render::cullItems(const SceneContextPointer& sceneContext, const RenderCont · 2 unmodified lines
87	bool outOfView;	77	bool outOfView;
88	{	78	{
89	PerformanceTimer perfTimer("boxInFrustum");	79	PerformanceTimer perfTimer("boxInFrustum");
90	outOfView = args->_viewFrustum->boxInFrustum(bound) == ViewFrustum::OUTSIDE;	80	outOfView = args->_viewFrustum->boxInFrustum(item.bounds) == ViewFrustum::OUTSIDE;
91	}	81	}
92	if (!outOfView) {	82	if (!outOfView) {
93	bool bigEnoughToRender;	83	bool bigEnoughToRender;
94	{	84	{
95	PerformanceTimer perfTimer("shouldRender");	85	PerformanceTimer perfTimer("shouldRender");
96	bigEnoughToRender = (args->_shouldRender) ? args->_shouldRender(args, bound) : true;	86	bigEnoughToRender = (args->_shouldRender) ? args->_shouldRender(args, item.bounds) : true;
97	}	87	}
98	if (bigEnoughToRender) {	88	if (bigEnoughToRender) {
99	outItems.emplace_back(ItemIDAndBounds(itemDetails.id, bound)); // One more Item to render	89	outItems.emplace_back(item); // One more Item to render
100	} else {	90	} else {
101	renderDetails->_tooSmall++;	91	renderDetails->_tooSmall++;
102	}	92	}
@@ -107,6 +97,32 @@ void render::cullItems(const SceneContextPointer& sceneContext, const RenderCont · 4 unmodified lines
107	renderDetails->_rendered += outItems.size();	97	renderDetails->_rendered += outItems.size();
108	}	98	}
109		99
		100
		101	void FetchItems::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, ItemIDsBounds& outItems) {
		102	auto& scene = sceneContext->_scene;
		103	auto& items = scene->getMasterBucket().at(_filter);
		104	auto& renderDetails = renderContext->args->_details;
		105
		106	outItems.clear();
		107	outItems.reserve(items.size());
		108	for (auto id : items) {
		109	auto& item = scene->getItem(id);
		110	outItems.emplace_back(ItemIDAndBounds(id, item.getBound()));
		111	}
		112
		113	if (_probeNumItems) {
		114	_probeNumItems(renderContext, outItems.size());
		115	}
		116	}
		117
		118	void CullItems::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems) {
		119
		120	outItems.clear();
		121	outItems.reserve(inItems.size());
		122	cullItems(sceneContext, renderContext, inItems, outItems);
		123	}
		124
		125
110	struct ItemBound {	126	struct ItemBound {
111	float _centerDepth = 0.0f;	127	float _centerDepth = 0.0f;
112	float _nearDepth = 0.0f;	128	float _nearDepth = 0.0f;
@@ -130,7 +146,6 @@ struct BackToFrontSort { · 17 unmodified lines
130	};	146	};
131		147
132	void render::depthSortItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, bool frontToBack, const ItemIDsBounds& inItems, ItemIDsBounds& outItems) {	148	void render::depthSortItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, bool frontToBack, const ItemIDsBounds& inItems, ItemIDsBounds& outItems) {
133	PerformanceTimer perfTimer("depthSortItems");
134	assert(renderContext->args);	149	assert(renderContext->args);
135	assert(renderContext->args->_viewFrustum);	150	assert(renderContext->args->_viewFrustum);
136		151
@@ -139,9 +154,10 @@ void render::depthSortItems(const SceneContextPointer& sceneContext, const Rende · 2 unmodified lines
139		154
140		155
141	// Allocate and simply copy	156	// Allocate and simply copy
		157	outItems.clear();
142	outItems.reserve(inItems.size());	158	outItems.reserve(inItems.size());
143		159
144		160
145	// Make a local dataset of the center distance and closest point distance	161	// Make a local dataset of the center distance and closest point distance
146	std::vector<ItemBound> itemBounds;	162	std::vector<ItemBound> itemBounds;
147	itemBounds.reserve(outItems.size());	163	itemBounds.reserve(outItems.size());
@@ -169,8 +185,14 @@ void render::depthSortItems(const SceneContextPointer& sceneContext, const Rende · 21 unmodified lines
169	}	185	}
170	}	186	}
171		187
		188
		189	void DepthSortItems::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems) {
		190	outItems.clear();
		191	outItems.reserve(inItems.size());
		192	depthSortItems(sceneContext, renderContext, _frontToBack, inItems, outItems);
		193	}
		194
172	void render::renderItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, int maxDrawnItems) {	195	void render::renderItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, int maxDrawnItems) {
173	PerformanceTimer perfTimer("renderItems");
174	auto& scene = sceneContext->_scene;	196	auto& scene = sceneContext->_scene;
175	RenderArgs* args = renderContext->args;	197	RenderArgs* args = renderContext->args;
176	// render	198	// render
@@ -183,6 +205,10 @@ void render::renderItems(const SceneContextPointer& sceneContext, const RenderCo · 6 unmodified lines
183	int numItems = 0;	205	int numItems = 0;
184	for (auto itemDetails : inItems) {	206	for (auto itemDetails : inItems) {
185	auto item = scene->getItem(itemDetails.id);	207	auto item = scene->getItem(itemDetails.id);
		208	if (numItems + 1 >= maxDrawnItems) {
		209	item.render(args);
		210	return;
		211	}
186	item.render(args);	212	item.render(args);
187	numItems++;	213	numItems++;
188	if (numItems >= maxDrawnItems) {	214	if (numItems >= maxDrawnItems) {
@@ -224,8 +250,7 @@ void addClearStateCommands(gpu::Batch& batch) { · 35 unmodified lines
224	// Back to no program	250	// Back to no program
225	batch._glUseProgram(0);	251	batch._glUseProgram(0);
226	}	252	}
227		253	void ResetGLState::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
228	template <> void render::jobRun(const ResetGLState& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
229		254
230	gpu::Batch theBatch;	255	gpu::Batch theBatch;
231	addClearStateCommands(theBatch);	256	addClearStateCommands(theBatch);
@@ -233,160 +258,7 @@ template <> void render::jobRun(const ResetGLState& job, const SceneContextPoint · 1 unmodified line
233	renderContext->args->_context->render(theBatch);	258	renderContext->args->_context->render(theBatch);
234	}	259	}
235		260
236	template <> void render::jobRun(const DrawOpaque& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {	261	void DrawLight::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
237	PerformanceTimer perfTimer("DrawOpaque");
238	assert(renderContext->args);
239	assert(renderContext->args->_viewFrustum);
240
241	// render opaques
242	auto& scene = sceneContext->_scene;
243	auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape());
244	auto& renderDetails = renderContext->args->_details;
245
246	ItemIDsBounds inItems;
247	inItems.reserve(items.size());
248	for (auto id : items) {
249	inItems.emplace_back(ItemIDAndBounds(id));
250	}
251	ItemIDsBounds& renderedItems = inItems;
252
253	renderContext->_numFeedOpaqueItems = renderedItems.size();
254
255	ItemIDsBounds culledItems;
256	culledItems.reserve(inItems.size());
257	if (renderContext->_cullOpaque) {
258	renderDetails.pointTo(RenderDetails::OPAQUE_ITEM);
259	cullItems(sceneContext, renderContext, renderedItems, culledItems);
260	renderDetails.pointTo(RenderDetails::OTHER_ITEM);
261	renderedItems = culledItems;
262	}
263
264	renderContext->_numDrawnOpaqueItems = renderedItems.size();
265
266	ItemIDsBounds sortedItems;
267	sortedItems.reserve(culledItems.size());
268	if (renderContext->_sortOpaque) {
269	depthSortItems(sceneContext, renderContext, true, renderedItems, sortedItems); // Sort Front to back opaque items!
270	renderedItems = sortedItems;
271	}
272
273	if (renderContext->_renderOpaque) {
274	RenderArgs* args = renderContext->args;
275	gpu::Batch batch;
276	args->_batch = &batch;
277
278	glm::mat4 projMat;
279	Transform viewMat;
280	args->_viewFrustum->evalProjectionMatrix(projMat);
281	args->_viewFrustum->evalViewTransform(viewMat);
282	if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
283	viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
284	}
285	batch.setProjectionTransform(projMat);
286	batch.setViewTransform(viewMat);
287
288	{
289	GLenum buffers[3];
290	int bufferCount = 0;
291	buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
292	buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
293	buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
294	batch._glDrawBuffers(bufferCount, buffers);
295	}
296
297	renderItems(sceneContext, renderContext, renderedItems, renderContext->_maxDrawnOpaqueItems);
298
299	args->_context->render((*args->_batch));
300	args->_batch = nullptr;
301	}
302	}
303
304
305	template <> void render::jobRun(const DrawTransparent& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
306	PerformanceTimer perfTimer("DrawTransparent");
307	assert(renderContext->args);
308	assert(renderContext->args->_viewFrustum);
309
310	// render transparents
311	auto& scene = sceneContext->_scene;
312	auto& items = scene->getMasterBucket().at(ItemFilter::Builder::transparentShape());
313	auto& renderDetails = renderContext->args->_details;
314
315	ItemIDsBounds inItems;
316	inItems.reserve(items.size());
317	for (auto id : items) {
318	inItems.emplace_back(id);
319	}
320	ItemIDsBounds& renderedItems = inItems;
321
322	renderContext->_numFeedTransparentItems = renderedItems.size();
323
324	ItemIDsBounds culledItems;
325	culledItems.reserve(inItems.size());
326	if (renderContext->_cullTransparent) {
327	renderDetails.pointTo(RenderDetails::TRANSLUCENT_ITEM);
328	cullItems(sceneContext, renderContext, inItems, culledItems);
329	renderDetails.pointTo(RenderDetails::OTHER_ITEM);
330	renderedItems = culledItems;
331	}
332
333	renderContext->_numDrawnTransparentItems = renderedItems.size();
334
335	ItemIDsBounds sortedItems;
336	sortedItems.reserve(culledItems.size());
337	if (renderContext->_sortTransparent) {
338	depthSortItems(sceneContext, renderContext, false, renderedItems, sortedItems); // Sort Back to front transparent items!
339	renderedItems = sortedItems;
340	}
341
342	if (renderContext->_renderTransparent) {
343	RenderArgs* args = renderContext->args;
344	gpu::Batch batch;
345	args->_batch = &batch;
346
347	glm::mat4 projMat;
348	Transform viewMat;
349	args->_viewFrustum->evalProjectionMatrix(projMat);
350	args->_viewFrustum->evalViewTransform(viewMat);
351	if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
352	viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
353	}
354	batch.setProjectionTransform(projMat);
355	batch.setViewTransform(viewMat);
356
357	const float MOSTLY_OPAQUE_THRESHOLD = 0.75f;
358	const float TRANSPARENT_ALPHA_THRESHOLD = 0.0f;
359
360	// render translucent meshes afterwards
361	{
362	GLenum buffers[2];
363	int bufferCount = 0;
364	buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
365	buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
366	batch._glDrawBuffers(bufferCount, buffers);
367	args->_alphaThreshold = MOSTLY_OPAQUE_THRESHOLD;
368	}
369
370	renderItems(sceneContext, renderContext, renderedItems, renderContext->_maxDrawnTransparentItems);
371
372	{
373	GLenum buffers[3];
374	int bufferCount = 0;
375	buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
376	batch._glDrawBuffers(bufferCount, buffers);
377	args->_alphaThreshold = TRANSPARENT_ALPHA_THRESHOLD;
378	}
379
380
381	renderItems(sceneContext, renderContext, renderedItems, renderContext->_maxDrawnTransparentItems);
382
383	args->_context->render((*args->_batch));
384	args->_batch = nullptr;
385	}
386	}
387
388	template <> void render::jobRun(const DrawLight& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
389	PerformanceTimer perfTimer("DrawLight");
390	assert(renderContext->args);	262	assert(renderContext->args);
391	assert(renderContext->args->_viewFrustum);	263	assert(renderContext->args->_viewFrustum);
392		264
@@ -398,7 +270,8 @@ template <> void render::jobRun(const DrawLight& job, const SceneContextPointer& · 5 unmodified lines
398	ItemIDsBounds inItems;	270	ItemIDsBounds inItems;
399	inItems.reserve(items.size());	271	inItems.reserve(items.size());
400	for (auto id : items) {	272	for (auto id : items) {
401	inItems.emplace_back(id);	273	auto item = scene->getItem(id);
		274	inItems.emplace_back(ItemIDAndBounds(id, item.getBound()));
402	}	275	}
403		276
404	ItemIDsBounds culledItems;	277	ItemIDsBounds culledItems;
@@ -413,8 +286,7 @@ template <> void render::jobRun(const DrawLight& job, const SceneContextPointer& · 8 unmodified lines
413	args->_batch = nullptr;	286	args->_batch = nullptr;
414	}	287	}
415		288
416	template <> void render::jobRun(const DrawBackground& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {	289	void DrawBackground::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
417	PerformanceTimer perfTimer("DrawBackground");
418	assert(renderContext->args);	290	assert(renderContext->args);
419	assert(renderContext->args->_viewFrustum);	291	assert(renderContext->args->_viewFrustum);
420		292
@@ -450,53 +322,6 @@ template <> void render::jobRun(const DrawBackground& job, const SceneContextPoi · 29 unmodified lines
450	args->_context->syncCache();	322	args->_context->syncCache();
451	}	323	}
452		324
453	template <> void render::jobRun(const DrawPostLayered& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
454	PerformanceTimer perfTimer("DrawPostLayered");
455	assert(renderContext->args);
456	assert(renderContext->args->_viewFrustum);
457
458	// render backgrounds
459	auto& scene = sceneContext->_scene;
460	auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape().withLayered());
461
462
463	ItemIDsBounds inItems;
464	inItems.reserve(items.size());
465	for (auto id : items) {
466	auto& item = scene->getItem(id);
467	if (item.getKey().isVisible() && (item.getLayer() > 0)) {
468	inItems.emplace_back(id);
469	}
470	}
471	if (inItems.empty()) {
472	return;
473	}
474
475	RenderArgs* args = renderContext->args;
476	gpu::Batch batch;
477	args->_batch = &batch;
478
479	glm::mat4 projMat;
480	Transform viewMat;
481	args->_viewFrustum->evalProjectionMatrix(projMat);
482	args->_viewFrustum->evalViewTransform(viewMat);
483	if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
484	viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
485	}
486	batch.setProjectionTransform(projMat);
487	batch.setViewTransform(viewMat);
488
489	batch.clearFramebuffer(gpu::Framebuffer::BUFFER_DEPTH, glm::vec4(), 1.f, 0);
490
491	renderItems(sceneContext, renderContext, inItems);
492	args->_context->render((*args->_batch));
493	args->_batch = nullptr;
494
495	// Force the context sync
496	args->_context->syncCache();
497	}
498
499
500	void ItemMaterialBucketMap::insert(const ItemID& id, const model::MaterialKey& key) {	325	void ItemMaterialBucketMap::insert(const ItemID& id, const model::MaterialKey& key) {
501	// Insert the itemID in every bucket where it filters true	326	// Insert the itemID in every bucket where it filters true
502	for (auto& bucket : (*this)) {	327	for (auto& bucket : (*this)) {

libraries/render/src/render/DrawTask.h+172−24

@@ -13,42 +13,173 @@ · 12 unmodified lines
13	#define hifi_render_Task_h	13	#define hifi_render_Task_h
14		14
15	#include "Engine.h"	15	#include "Engine.h"
		16	#include "gpu/Batch.h"
		17	#include <PerfStat.h>
		18
16		19
17	namespace render {	20	namespace render {
18		21
19	template <class T> void jobRun(const T& jobModel, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { }	22	template <class T> void jobRun(T& jobModel, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
		23	jobModel.run(sceneContext, renderContext);
		24	}
		25	template <class T, class I> void jobRunI(T& jobModel, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const I& input) {
		26	jobModel.run(sceneContext, renderContext, input);
		27	}
		28	template <class T, class O> void jobRunO(T& jobModel, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, O& output) {
		29	jobModel.run(sceneContext, renderContext, output);
		30	}
		31	template <class T, class I, class O> void jobRunIO(T& jobModel, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const I& input, O& output) {
		32	jobModel.run(sceneContext, renderContext, input, output);
		33	}
20		34
21	class Job {	35	class Job {
22	public:	36	public:
23		37
24	template <class T>	38	// Varying represent a varying piece of data
25	Job(T data) : _concept(new Model<T>(data)) {}	39	class Varying {
		40	public:
		41
		42	Varying(const Varying& var): _concept(var._concept) {}
		43
		44	Varying() {}
		45	template <class T>
		46	Varying(const T& data) : _concept(new Job::Varying::Model<T>(data)) {}
		47
		48	// Access the _data contained win the concept explicitely
		49	template <class T> T& edit() { return (static_cast<Model<T>*> (_concept.get())->_data); }
		50	template <class T> const T& get() const { return (static_cast<const Model<T>*> (_concept.get())->_data); }
		51
		52	protected:
		53	friend class Job;
		54
		55	std::vector<std::weak_ptr<Job>> _consumerJobs;
		56
		57	void addJobConsumer(const std::shared_ptr<Job>& job) {
		58	_consumerJobs.push_back(job);
		59	}
		60
		61	class Concept {
		62	public:
		63	virtual ~Concept() = default;
		64	};
		65	template <class T> class Model : public Concept {
		66	public:
		67	typedef T Data;
		68	Data _data;
		69	Model(const Model& source): _data(source.data) {}
		70	Model(const Data& data): _data(data) {}
		71	virtual ~Model() {}
		72	};
		73
		74	std::shared_ptr<Concept> _concept;
		75	};
		76
26	Job(const Job& other) : _concept(other._concept) {}	77	Job(const Job& other) : _concept(other._concept) {}
27	~Job();	78	~Job();
28		79
29	virtual void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {	80	const std::string& getName() const { return _concept->getName(); }
30	if (_concept) {	81	const Varying getInput() const { return _concept->getInput(); }
31	_concept->run(sceneContext, renderContext);	82	const Varying getOutput() const { return _concept->getOutput(); }
32	}	83
		84	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
		85	PerformanceTimer perfTimer(getName().c_str());
		86	PROFILE_RANGE(getName().c_str());
		87	_concept->run(sceneContext, renderContext);
33	}	88	}
34		89
35	protected:	90	protected:
		91	public:
		92
36	class Concept {	93	class Concept {
		94	std::string _name;
37	public:	95	public:
		96	Concept() : _name() {}
		97	Concept(const std::string& name) : _name(name) {}
38	virtual ~Concept() = default;	98	virtual ~Concept() = default;
		99
		100	void setName(const std::string& name) { _name = name; }
		101	const std::string& getName() const { return _name; }
		102
		103	virtual const Varying getInput() const { return Varying(); }
		104	virtual const Varying getOutput() const { return Varying(); }
39	virtual void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) = 0;	105	virtual void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) = 0;
40	};	106	};
41		107
		108	Job(Concept* concept) : _concept(concept) {}
		109
		110	public:
42	template <class T> class Model : public Concept {	111	template <class T> class Model : public Concept {
43	public:	112	public:
44	typedef T Data;	113	typedef T Data;
45		114
46	Data _data;	115	Data _data;
		116
		117	Model() {}
		118	Model(const std::string& name): Concept(name) {}
47	Model(Data data): _data(data) {}	119	Model(Data data): _data(data) {}
		120	Model(Data data, const std::string& name): Concept(name), _data(data) {}
48		121
49	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { jobRun(_data, sceneContext, renderContext); }	122	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { jobRun(_data, sceneContext, renderContext); }
50	};	123	};
51		124
		125	template <class T, class I> class ModelI : public Concept {
		126	public:
		127	typedef T Data;
		128	typedef I Input;
		129
		130	Data _data;
		131	Varying _input;
		132
		133	const Varying getInput() const { return _input; }
		134
		135	ModelI(const std::string& name, const Varying& input): Concept(name), _input(input) {}
		136	ModelI(const std::string& name, Data data): Concept(name), _data(data) {}
		137
		138	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { jobRunI(_data, sceneContext, renderContext, _input.get<I>()); }
		139	};
		140
		141	template <class T, class O> class ModelO : public Concept {
		142	public:
		143	typedef T Data;
		144	typedef O Output;
		145
		146	Data _data;
		147	Varying _output;
		148
		149	const Varying getOutput() const { return _output; }
		150
		151	ModelO(const std::string& name): Concept(name), _output(Output()) {
		152
		153	}
		154
		155	ModelO(const std::string& name, Data data): Concept(name), _data(data), _output(Output()) {}
		156
		157	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
		158	jobRunO(_data, sceneContext, renderContext, _output.edit<O>());
		159	}
		160	};
		161
		162	template <class T, class I, class O> class ModelIO : public Concept {
		163	public:
		164	typedef T Data;
		165	typedef I Input;
		166	typedef O Output;
		167
		168	Data _data;
		169	Varying _input;
		170	Varying _output;
		171
		172	const Varying getInput() const { return _input; }
		173	const Varying getOutput() const { return _output; }
		174
		175	ModelIO(const std::string& name, const Varying& input, Data data = Data()): Concept(name), _data(data), _input(input), _output(Output()) {}
		176	ModelIO(const std::string& name, Data data, Output output): Concept(name), _data(data), _output(output) {}
		177
		178	void setInput(const Varying& input) { _input = input; }
		179
		180	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { jobRunIO(_data, sceneContext, renderContext, _input.get<I>(), _output.edit<O>()); }
		181	};
		182
52	std::shared_ptr<Concept> _concept;	183	std::shared_ptr<Concept> _concept;
53	};	184	};
54		185
@@ -62,43 +193,59 @@ void depthSortItems(const SceneContextPointer& sceneContext, const RenderContext · 7 unmodified lines
62	void renderItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, int maxDrawnItems = -1);	193	void renderItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, int maxDrawnItems = -1);
63		194
64		195
		196	class FetchItems {
		197	public:
		198	typedef std::function<void (const RenderContextPointer& context, int count)> ProbeNumItems;
		199	FetchItems(const ProbeNumItems& probe): _probeNumItems(probe) {}
		200	FetchItems(const ItemFilter& filter, const ProbeNumItems& probe): _filter(filter), _probeNumItems(probe) {}
65		201
66	void materialSortItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems);	202	ItemFilter _filter = ItemFilter::Builder::opaqueShape().withoutLayered();
		203	ProbeNumItems _probeNumItems;
67		204
		205	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, ItemIDsBounds& outItems);
68		206
69	class DrawOpaque {	207	typedef Job::ModelO<FetchItems, ItemIDsBounds> JobModel;
70	public:
71	};	208	};
72	template <> void jobRun(const DrawOpaque& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
73		209
		210	class CullItems {
		211	public:
		212	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems);
74		213
75	class DrawTransparent {	214	typedef Job::ModelIO<CullItems, ItemIDsBounds, ItemIDsBounds> JobModel;
		215	};
		216
		217	class DepthSortItems {
76	public:	218	public:
		219	bool _frontToBack = true;
		220
		221	DepthSortItems(bool frontToBack = true) : _frontToBack(frontToBack) {}
		222
		223	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outITems);
		224
		225	typedef Job::ModelIO<DepthSortItems, ItemIDsBounds, ItemIDsBounds> JobModel;
77	};	226	};
78	template <> void jobRun(const DrawTransparent& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
79		227
80	class DrawLight {	228	class DrawLight {
81	public:	229	public:
		230	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
		231
		232	typedef Job::Model<DrawLight> JobModel;
82	};	233	};
83	template <> void jobRun(const DrawLight& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
84		234
85	class DrawBackground {	235	class DrawBackground {
86	public:	236	public:
87	};	237	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
88	template <> void jobRun(const DrawBackground& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
89
90		238
91	class DrawPostLayered {	239	typedef Job::Model<DrawBackground> JobModel;
92	public:
93	};	240	};
94	template <> void jobRun(const DrawPostLayered& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
95
96
97		241
98	class ResetGLState {	242	class ResetGLState {
99	public:	243	public:
		244	void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
		245
		246	typedef Job::Model<ResetGLState> JobModel;
100	};	247	};
101	template <> void jobRun(const ResetGLState& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);	248
102		249
103		250
104	class DrawSceneTask : public Task {	251	class DrawSceneTask : public Task {
@@ -126,6 +273,7 @@ public: · 21 unmodified lines
126	// standard builders allocating the main buckets	273	// standard builders allocating the main buckets
127	void allocateStandardMaterialBuckets();	274	void allocateStandardMaterialBuckets();
128	};	275	};
		276	void materialSortItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems);
129		277
130	}	278	}
131		279

libraries/render/src/render/Engine.h+4−0

     int _numDrawnTransparentItems = 0;
     int _maxDrawnTransparentItems = -1;
+    int _numFeedOverlay3DItems = 0;
+    int _numDrawnOverlay3DItems = 0;
+    int _maxDrawnOverlay3DItems = -1;
     RenderContext() {}
 };
 typedef std::shared_ptr<RenderContext> RenderContextPointer;

libraries/script-engine/src/AbstractControllerScriptingInterface.h+1−0

@@ -107,6 +107,7 @@ signals: · 106 unmodified lines
107		107
108	void mouseMoveEvent(const MouseEvent& event, unsigned int deviceID = 0);	108	void mouseMoveEvent(const MouseEvent& event, unsigned int deviceID = 0);
109	void mousePressEvent(const MouseEvent& event, unsigned int deviceID = 0);	109	void mousePressEvent(const MouseEvent& event, unsigned int deviceID = 0);
		110	void mouseDoublePressEvent(const MouseEvent& event, unsigned int deviceID = 0);
110	void mouseReleaseEvent(const MouseEvent& event, unsigned int deviceID = 0);	111	void mouseReleaseEvent(const MouseEvent& event, unsigned int deviceID = 0);
111		112
112	void touchBeginEvent(const TouchEvent& event);	113	void touchBeginEvent(const TouchEvent& event);

libraries/script-engine/src/AudioScriptingInterface.cpp+1−18

@@ -46,24 +46,7 @@ ScriptAudioInjector* AudioScriptingInterface::playSound(Sound* sound, const Audi · 45 unmodified lines
46	AudioInjectorOptions optionsCopy = injectorOptions;	46	AudioInjectorOptions optionsCopy = injectorOptions;
47	optionsCopy.stereo = sound->isStereo();	47	optionsCopy.stereo = sound->isStereo();
48		48
49	QThread* injectorThread = new QThread();	49	return new ScriptAudioInjector(AudioInjector::playSound(sound->getByteArray(), optionsCopy, _localAudioInterface));
50	injectorThread->setObjectName("Audio Injector Thread");
51
52	AudioInjector* injector = new AudioInjector(sound, optionsCopy);
53	injector->setLocalAudioInterface(_localAudioInterface);
54
55	injector->moveToThread(injectorThread);
56
57	// start injecting when the injector thread starts
58	connect(injectorThread, &QThread::started, injector, &AudioInjector::injectAudio);
59
60	// connect the right slots and signals for AudioInjector and thread cleanup
61	connect(injector, &AudioInjector::destroyed, injectorThread, &QThread::quit);
62	connect(injectorThread, &QThread::finished, injectorThread, &QThread::deleteLater);
63
64	injectorThread->start();
65
66	return new ScriptAudioInjector(injector);
67		50
68	} else {	51	} else {
69	qCDebug(scriptengine) << "AudioScriptingInterface::playSound called with null Sound object.";	52	qCDebug(scriptengine) << "AudioScriptingInterface::playSound called with null Sound object.";

libraries/script-engine/src/SceneScriptingInterface.cpp+2−0

@@ -159,4 +159,6 @@ void SceneScriptingInterface::clearEngineCounters() { · 158 unmodified lines
159	_numDrawnOpaqueItems = 0;	159	_numDrawnOpaqueItems = 0;
160	_numFeedTransparentItems = 0;	160	_numFeedTransparentItems = 0;
161	_numDrawnTransparentItems = 0;	161	_numDrawnTransparentItems = 0;
		162	_numFeedOverlay3DItems = 0;
		163	_numDrawnOverlay3DItems = 0;
162	}	164	}

libraries/script-engine/src/SceneScriptingInterface.h+9−1

@@ -90,17 +90,22 @@ public: · 89 unmodified lines
90	Q_INVOKABLE int getEngineNumDrawnOpaqueItems() { return _numDrawnOpaqueItems; }	90	Q_INVOKABLE int getEngineNumDrawnOpaqueItems() { return _numDrawnOpaqueItems; }
91	void setEngineDrawnTransparentItems(int count) { _numDrawnTransparentItems = count; }	91	void setEngineDrawnTransparentItems(int count) { _numDrawnTransparentItems = count; }
92	Q_INVOKABLE int getEngineNumDrawnTransparentItems() { return _numDrawnTransparentItems; }	92	Q_INVOKABLE int getEngineNumDrawnTransparentItems() { return _numDrawnTransparentItems; }
		93	void setEngineDrawnOverlay3DItems(int count) { _numDrawnOverlay3DItems = count; }
		94	Q_INVOKABLE int getEngineNumDrawnOverlay3DItems() { return _numDrawnOverlay3DItems; }
93		95
94	void setEngineFeedOpaqueItems(int count) { _numFeedOpaqueItems = count; }	96	void setEngineFeedOpaqueItems(int count) { _numFeedOpaqueItems = count; }
95	Q_INVOKABLE int getEngineNumFeedOpaqueItems() { return _numFeedOpaqueItems; }	97	Q_INVOKABLE int getEngineNumFeedOpaqueItems() { return _numFeedOpaqueItems; }
96	void setEngineFeedTransparentItems(int count) { _numFeedTransparentItems = count; }	98	void setEngineFeedTransparentItems(int count) { _numFeedTransparentItems = count; }
97	Q_INVOKABLE int getEngineNumFeedTransparentItems() { return _numFeedTransparentItems; }	99	Q_INVOKABLE int getEngineNumFeedTransparentItems() { return _numFeedTransparentItems; }
		100	void setEngineFeedOverlay3DItems(int count) { _numFeedOverlay3DItems = count; }
		101	Q_INVOKABLE int getEngineNumFeedOverlay3DItems() { return _numFeedOverlay3DItems; }
98		102
99	Q_INVOKABLE void setEngineMaxDrawnOpaqueItems(int count) { _maxDrawnOpaqueItems = count; }	103	Q_INVOKABLE void setEngineMaxDrawnOpaqueItems(int count) { _maxDrawnOpaqueItems = count; }
100	Q_INVOKABLE int getEngineMaxDrawnOpaqueItems() { return _maxDrawnOpaqueItems; }	104	Q_INVOKABLE int getEngineMaxDrawnOpaqueItems() { return _maxDrawnOpaqueItems; }
101	Q_INVOKABLE void setEngineMaxDrawnTransparentItems(int count) { _maxDrawnTransparentItems = count; }	105	Q_INVOKABLE void setEngineMaxDrawnTransparentItems(int count) { _maxDrawnTransparentItems = count; }
102	Q_INVOKABLE int getEngineMaxDrawnTransparentItems() { return _maxDrawnTransparentItems; }	106	Q_INVOKABLE int getEngineMaxDrawnTransparentItems() { return _maxDrawnTransparentItems; }
103		107	Q_INVOKABLE void setEngineMaxDrawnOverlay3DItems(int count) { _maxDrawnOverlay3DItems = count; }
		108	Q_INVOKABLE int getEngineMaxDrawnOverlay3DItems() { return _maxDrawnOverlay3DItems; }
104	signals:	109	signals:
105	void shouldRenderAvatarsChanged(bool shouldRenderAvatars);	110	void shouldRenderAvatarsChanged(bool shouldRenderAvatars);
106	void shouldRenderEntitiesChanged(bool shouldRenderEntities);	111	void shouldRenderEntitiesChanged(bool shouldRenderEntities);
@@ -124,9 +129,12 @@ protected: · 17 unmodified lines
124	int _numDrawnOpaqueItems = 0;	129	int _numDrawnOpaqueItems = 0;
125	int _numFeedTransparentItems = 0;	130	int _numFeedTransparentItems = 0;
126	int _numDrawnTransparentItems = 0;	131	int _numDrawnTransparentItems = 0;
		132	int _numFeedOverlay3DItems = 0;
		133	int _numDrawnOverlay3DItems = 0;
127		134
128	int _maxDrawnOpaqueItems = -1;	135	int _maxDrawnOpaqueItems = -1;
129	int _maxDrawnTransparentItems = -1;	136	int _maxDrawnTransparentItems = -1;
		137	int _maxDrawnOverlay3DItems = -1;
130		138
131	};	139	};
132		140

libraries/script-engine/src/ScriptEngine.cpp+4−1

@@ -317,7 +317,10 @@ void ScriptEngine::init() { · 316 unmodified lines
317	registerAnimationTypes(this);	317	registerAnimationTypes(this);
318	registerAvatarTypes(this);	318	registerAvatarTypes(this);
319	registerAudioMetaTypes(this);	319	registerAudioMetaTypes(this);
320	_controllerScriptingInterface->registerControllerTypes(this);	320
		321	if (_controllerScriptingInterface) {
		322	_controllerScriptingInterface->registerControllerTypes(this);
		323	}
321		324
322	qScriptRegisterMetaType(this, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly);	325	qScriptRegisterMetaType(this, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly);
323	qScriptRegisterMetaType(this, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue);	326	qScriptRegisterMetaType(this, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue);

libraries/script-engine/src/ScriptEngine.h+1−1

@@ -35,7 +35,7 @@ · 34 unmodified lines
35		35
36	const QString NO_SCRIPT("");	36	const QString NO_SCRIPT("");
37		37
38	const unsigned int SCRIPT_DATA_CALLBACK_USECS = floor(((1.0 / 60.0f) * 1000 * 1000) + 0.5);	38	const unsigned int SCRIPT_DATA_CALLBACK_USECS = floor(((1.0f / 60.0f) * 1000 * 1000) + 0.5f);
39		39
40	typedef QHash<QString, QScriptValueList> RegisteredEventHandlers;	40	typedef QHash<QString, QScriptValueList> RegisteredEventHandlers;
41		41

libraries/script-engine/src/TouchEvent.cpp+13−13

@@ -40,7 +40,7 @@ TouchEvent::TouchEvent() : · 39 unmodified lines
40	isRotating(false),	40	isRotating(false),
41	rotating("none")	41	rotating("none")
42	{	42	{
43		43
44	}	44	}
45		45
46	TouchEvent::TouchEvent(const QTouchEvent& event) :	46	TouchEvent::TouchEvent(const QTouchEvent& event) :
@@ -77,9 +77,9 @@ void TouchEvent::initWithQTouchEvent(const QTouchEvent& event) { · 30 unmodified lines
77	touchPoints = tPoints.count();	77	touchPoints = tPoints.count();
78	if (touchPoints > 1) {	78	if (touchPoints > 1) {
79	for (int i = 0; i < touchPoints; ++i) {	79	for (int i = 0; i < touchPoints; ++i) {
80	touchAvgX += tPoints[i].pos().x();	80	touchAvgX += (float)tPoints[i].pos().x();
81	touchAvgY += tPoints[i].pos().y();	81	touchAvgY += (float)tPoints[i].pos().y();
82		82
83	// add it to our points vector	83	// add it to our points vector
84	glm::vec2 thisPoint(tPoints[i].pos().x(), tPoints[i].pos().y());	84	glm::vec2 thisPoint(tPoints[i].pos().x(), tPoints[i].pos().y());
85	points << thisPoint;	85	points << thisPoint;
@@ -94,7 +94,7 @@ void TouchEvent::initWithQTouchEvent(const QTouchEvent& event) { · 8 unmodified lines
94	}	94	}
95	x = touchAvgX;	95	x = touchAvgX;
96	y = touchAvgY;	96	y = touchAvgY;
97		97
98	// after calculating the center point (average touch point), determine the maximum radius	98	// after calculating the center point (average touch point), determine the maximum radius
99	// also calculate the rotation angle for each point	99	// also calculate the rotation angle for each point
100	float maxRadius = 0.0f;	100	float maxRadius = 0.0f;
@@ -105,25 +105,25 @@ void TouchEvent::initWithQTouchEvent(const QTouchEvent& event) { · 4 unmodified lines
105	if (thisRadius > maxRadius) {	105	if (thisRadius > maxRadius) {
106	maxRadius = thisRadius;	106	maxRadius = thisRadius;
107	}	107	}
108		108
109	// calculate the angle for this point	109	// calculate the angle for this point
110	float thisAngle = angleBetweenPoints(center,touchPoint);	110	float thisAngle = angleBetweenPoints(center,touchPoint);
111	angles << thisAngle;	111	angles << thisAngle;
112	}	112	}
113	radius = maxRadius;	113	radius = maxRadius;
114		114
115	// after calculating the angles for each touch point, determine the average angle	115	// after calculating the angles for each touch point, determine the average angle
116	float totalAngle = 0.0f;	116	float totalAngle = 0.0f;
117	for (int i = 0; i < touchPoints; ++i) {	117	for (int i = 0; i < touchPoints; ++i) {
118	totalAngle += angles[i];	118	totalAngle += angles[i];
119	}	119	}
120	angle = totalAngle/(float)touchPoints;	120	angle = totalAngle/(float)touchPoints;
121		121
122	isPressed = event.touchPointStates().testFlag(Qt::TouchPointPressed);	122	isPressed = event.touchPointStates().testFlag(Qt::TouchPointPressed);
123	isMoved = event.touchPointStates().testFlag(Qt::TouchPointMoved);	123	isMoved = event.touchPointStates().testFlag(Qt::TouchPointMoved);
124	isStationary = event.touchPointStates().testFlag(Qt::TouchPointStationary);	124	isStationary = event.touchPointStates().testFlag(Qt::TouchPointStationary);
125	isReleased = event.touchPointStates().testFlag(Qt::TouchPointReleased);	125	isReleased = event.touchPointStates().testFlag(Qt::TouchPointReleased);
126		126
127	// keyboard modifiers	127	// keyboard modifiers
128	isShifted = event.modifiers().testFlag(Qt::ShiftModifier);	128	isShifted = event.modifiers().testFlag(Qt::ShiftModifier);
129	isMeta = event.modifiers().testFlag(Qt::MetaModifier);	129	isMeta = event.modifiers().testFlag(Qt::MetaModifier);
@@ -143,7 +143,7 @@ void TouchEvent::calculateMetaAttributes(const TouchEvent& other) { · 13 unmodified lines
143	isPinching = other.isPinching;	143	isPinching = other.isPinching;
144	isPinchOpening = other.isPinchOpening;	144	isPinchOpening = other.isPinchOpening;
145	}	145	}
146		146
147	// determine if the points are rotating...	147	// determine if the points are rotating...
148	// note: if the number of touch points change between events, then we don't consider ourselves to be rotating	148	// note: if the number of touch points change between events, then we don't consider ourselves to be rotating
149	if (touchPoints == other.touchPoints) {	149	if (touchPoints == other.touchPoints) {
@@ -178,7 +178,7 @@ QScriptValue TouchEvent::toScriptValue(QScriptEngine* engine, const TouchEvent& · 28 unmodified lines
178	obj.setProperty("isControl", event.isControl);	178	obj.setProperty("isControl", event.isControl);
179	obj.setProperty("isAlt", event.isAlt);	179	obj.setProperty("isAlt", event.isAlt);
180	obj.setProperty("touchPoints", event.touchPoints);	180	obj.setProperty("touchPoints", event.touchPoints);
181		181
182	QScriptValue pointsObj = engine->newArray();	182	QScriptValue pointsObj = engine->newArray();
183	int index = 0;	183	int index = 0;
184	foreach (glm::vec2 point, event.points) {	184	foreach (glm::vec2 point, event.points) {
@@ -190,7 +190,7 @@ QScriptValue TouchEvent::toScriptValue(QScriptEngine* engine, const TouchEvent& · 5 unmodified lines
190	obj.setProperty("radius", event.radius);	190	obj.setProperty("radius", event.radius);
191	obj.setProperty("isPinching", event.isPinching);	191	obj.setProperty("isPinching", event.isPinching);
192	obj.setProperty("isPinchOpening", event.isPinchOpening);	192	obj.setProperty("isPinchOpening", event.isPinchOpening);
193		193
194	obj.setProperty("angle", event.angle);	194	obj.setProperty("angle", event.angle);
195	obj.setProperty("deltaAngle", event.deltaAngle);	195	obj.setProperty("deltaAngle", event.deltaAngle);
196	QScriptValue anglesObj = engine->newArray();	196	QScriptValue anglesObj = engine->newArray();
@@ -200,7 +200,7 @@ QScriptValue TouchEvent::toScriptValue(QScriptEngine* engine, const TouchEvent& · 3 unmodified lines
200	index++;	200	index++;
201	}	201	}
202	obj.setProperty("angles", anglesObj);	202	obj.setProperty("angles", anglesObj);
203		203
204	obj.setProperty("isRotating", event.isRotating);	204	obj.setProperty("isRotating", event.isRotating);
205	obj.setProperty("rotating", event.rotating);	205	obj.setProperty("rotating", event.rotating);
206	return obj;	206	return obj;

libraries/shared/CMakeLists.txt+2−1

@@ -6,4 +6,5 @@ setup_hifi_library(Gui Network Script Widgets) · 5 unmodified lines
6		6
7	add_dependency_external_projects(glm)	7	add_dependency_external_projects(glm)
8	find_package(GLM REQUIRED)	8	find_package(GLM REQUIRED)
9	target_include_directories(${TARGET_NAME} PUBLIC ${GLM_INCLUDE_DIRS})	9	target_include_directories(${TARGET_NAME} PUBLIC ${GLM_INCLUDE_DIRS})
		10

libraries/shared/src/AABox.cpp+38−38

libraries/shared/src/AACube.cpp+35−35

libraries/shared/src/AngularConstraint.cpp+1−1

@@ -120,7 +120,7 @@ bool HingeConstraint::clamp(glm::quat& rotation) const { · 119 unmodified lines
120	forward /= length;	120	forward /= length;
121	float sign = (glm::dot(glm::cross(_forwardAxis, forward), _rotationAxis) > 0.0f ? 1.0f : -1.0f);	121	float sign = (glm::dot(glm::cross(_forwardAxis, forward), _rotationAxis) > 0.0f ? 1.0f : -1.0f);
122	//float angle = sign * acos(glm::dot(forward, _forwardAxis) / length);	122	//float angle = sign * acos(glm::dot(forward, _forwardAxis) / length);
123	float angle = sign * acos(glm::dot(forward, _forwardAxis));	123	float angle = sign * acosf(glm::dot(forward, _forwardAxis));
124	glm::quat newRotation = glm::angleAxis(clampAngle(angle, _minAngle, _maxAngle), _rotationAxis);	124	glm::quat newRotation = glm::angleAxis(clampAngle(angle, _minAngle, _maxAngle), _rotationAxis);
125	if (fabsf(1.0f - glm::dot(newRotation, rotation)) > EPSILON * EPSILON) {	125	if (fabsf(1.0f - glm::dot(newRotation, rotation)) > EPSILON * EPSILON) {
126	rotation = newRotation;	126	rotation = newRotation;

libraries/shared/src/GLMHelpers.cpp+1−1

@@ -238,7 +238,7 @@ glm::quat extractRotation(const glm::mat4& matrix, bool assumeOrthogonal) { · 237 unmodified lines
238	float sd10 = previous[0][1] * previous[2][2] - previous[2][1] * previous[0][2];	238	float sd10 = previous[0][1] * previous[2][2] - previous[2][1] * previous[0][2];
239	float sd20 = previous[0][1] * previous[1][2] - previous[1][1] * previous[0][2];	239	float sd20 = previous[0][1] * previous[1][2] - previous[1][1] * previous[0][2];
240	float det = previous[0][0] * sd00 + previous[2][0] * sd20 - previous[1][0] * sd10;	240	float det = previous[0][0] * sd00 + previous[2][0] * sd20 - previous[1][0] * sd10;
241	if (fabs(det) == 0.0f) {	241	if (fabsf(det) == 0.0f) {
242	// determinant is zero; matrix is not invertible	242	// determinant is zero; matrix is not invertible
243	break;	243	break;
244	}	244	}

libraries/shared/src/GLMHelpers.h+24−0

@@ -28,10 +28,19 @@ using glm::vec3; · 27 unmodified lines
28	using glm::vec4;	28	using glm::vec4;
29	using glm::quat;	29	using glm::quat;
30		30
		31	#ifdef __GNUC__
		32	#pragma GCC diagnostic push
		33	#pragma GCC diagnostic ignored "-Wdouble-promotion"
		34	#endif
		35
31	#include <QtCore/QByteArray>	36	#include <QtCore/QByteArray>
32	#include <QtGui/QMatrix4x4>	37	#include <QtGui/QMatrix4x4>
33	#include <QtGui/QColor>	38	#include <QtGui/QColor>
34		39
		40	#ifdef __GNUC__
		41	#pragma GCC diagnostic pop
		42	#endif
		43
35	#include "SharedUtil.h"	44	#include "SharedUtil.h"
36		45
37	// this is where the coordinate system is represented	46	// this is where the coordinate system is represented
@@ -122,6 +131,21 @@ float aspect(const T& t) { · 84 unmodified lines
122	return (float)t.x / (float)t.y;	131	return (float)t.x / (float)t.y;
123	}	132	}
124		133
		134	// Take values in an arbitrary range [0, size] and convert them to the range [0, 1]
		135	template <typename T>
		136	T toUnitScale(const T& value, const T& size) {
		137	return value / size;
		138	}
		139
		140	// Take values in an arbitrary range [0, size] and convert them to the range [0, 1]
		141	template <typename T>
		142	T toNormalizedDeviceScale(const T& value, const T& size) {
		143	vec2 result = toUnitScale(value, size);
		144	result *= 2.0f;
		145	result -= 1.0f;
		146	return result;
		147	}
		148
125	#define YAW(euler) euler.y	149	#define YAW(euler) euler.y
126	#define PITCH(euler) euler.x	150	#define PITCH(euler) euler.x
127	#define ROLL(euler) euler.z	151	#define ROLL(euler) euler.z

libraries/shared/src/MatrixStack.h+5−1

   template <typename Function>
   void withPush(Function f) {
+    #ifndef NDEBUG
     size_t startingDepth = size();
+    #endif
     push();
     f();
     pop();
-    assert(startingDepth = size());
+    #ifndef NDEBUG
+    assert(startingDepth == size());
+    #endif
   }
   template <typename Function>

libraries/shared/src/OctalCode.cpp+33−33

libraries/shared/src/PhysicsCollisionGroups.h+1−1

@@ -55,7 +55,7 @@ const int16_t COLLISION_GROUP_COLLISIONLESS = 1 << 15; · 54 unmodified lines
55	const int16_t COLLISION_MASK_DEFAULT = ~ COLLISION_GROUP_COLLISIONLESS;	55	const int16_t COLLISION_MASK_DEFAULT = ~ COLLISION_GROUP_COLLISIONLESS;
56		56
57	// STATIC also doesn't collide with other STATIC	57	// STATIC also doesn't collide with other STATIC
58	const int16_t COLLISION_MASK_STATIC = ~ (COLLISION_GROUP_COLLISIONLESS \| COLLISION_MASK_STATIC);	58	const int16_t COLLISION_MASK_STATIC = ~ (COLLISION_GROUP_COLLISIONLESS \| COLLISION_GROUP_STATIC);
59		59
60	const int16_t COLLISION_MASK_KINEMATIC = COLLISION_MASK_DEFAULT;	60	const int16_t COLLISION_MASK_KINEMATIC = COLLISION_MASK_DEFAULT;
61		61

libraries/shared/src/RegisteredMetaTypes.cpp+12−0

 static int vec4MetaTypeId = qRegisterMetaType<glm::vec4>();
 static int vec3MetaTypeId = qRegisterMetaType<glm::vec3>();
+static int qVectorVec3MetaTypeId = qRegisterMetaType<QVector<glm::vec3>>();
 static int vec2MetaTypeId = qRegisterMetaType<glm::vec2>();
 static int quatMetaTypeId = qRegisterMetaType<glm::quat>();
 static int xColorMetaTypeId = qRegisterMetaType<xColor>();
 void registerMetaTypes(QScriptEngine* engine) {
     qScriptRegisterMetaType(engine, vec4toScriptValue, vec4FromScriptValue);
     qScriptRegisterMetaType(engine, vec3toScriptValue, vec3FromScriptValue);
+    qScriptRegisterMetaType(engine, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue);
     qScriptRegisterMetaType(engine, vec2toScriptValue, vec2FromScriptValue);
     qScriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue);
     qScriptRegisterMetaType(engine, qRectToScriptValue, qRectFromScriptValue);
     return newVector;
 }
+void qVectorVec3FromScriptValue(const QScriptValue& array, QVector<glm::vec3>& vector ) {
+    int length = array.property("length").toInteger();
+    for (int i = 0; i < length; i++) {
+        glm::vec3 newVec3 = glm::vec3();
+        vec3FromScriptValue(array.property(i), newVec3);
+        vector << newVec3;
+    }
+}
 QScriptValue vec2toScriptValue(QScriptEngine* engine, const glm::vec2 &vec2) {
     QScriptValue obj = engine->newObject();
     obj.setProperty("x", vec2.x);

libraries/shared/src/RegisteredMetaTypes.h+1−0

@@ -57,6 +57,7 @@ QScriptValue qURLToScriptValue(QScriptEngine* engine, const QUrl& url); · 56 unmodified lines
57	void qURLFromScriptValue(const QScriptValue& object, QUrl& url);	57	void qURLFromScriptValue(const QScriptValue& object, QUrl& url);
58		58
59	QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<glm::vec3>& vector);	59	QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<glm::vec3>& vector);
		60	void qVectorVec3FromScriptValue(const QScriptValue& array, QVector<glm::vec3>& vector);
60	QVector<glm::vec3> qVectorVec3FromScriptValue( const QScriptValue& array);	61	QVector<glm::vec3> qVectorVec3FromScriptValue( const QScriptValue& array);
61		62
62	class PickRay {	63	class PickRay {

libraries/shared/src/ShapeCollider.cpp+1−1

@@ -881,7 +881,7 @@ bool capsuleVsAACube(const Shape* shapeA, const Shape* shapeB, CollisionList& co · 880 unmodified lines
881	faceNormal = glm::vec3(0.0f, 0.0f, signs.z);	881	faceNormal = glm::vec3(0.0f, 0.0f, signs.z);
882	}	882	}
883		883
884	if (fabs(glm::dot(faceNormal, capsuleAxis)) < EPSILON) {	884	if (fabsf(glm::dot(faceNormal, capsuleAxis)) < EPSILON) {
885	if (glm::dot(nearestApproach, faceNormal) > cubeB->getScale() + capsuleA->getRadius()) {	885	if (glm::dot(nearestApproach, faceNormal) > cubeB->getScale() + capsuleA->getRadius()) {
886	return false;	886	return false;
887	}	887	}

libraries/shared/src/Transform.h+2−2

@@ -29,7 +29,7 @@ inline bool isValidScale(glm::vec3 scale) { · 28 unmodified lines
29	}	29	}
30		30
31	inline bool isValidScale(float scale) {	31	inline bool isValidScale(float scale) {
32	bool result = scale != 0.0f;	32	bool result = scale != 0.0f && !glm::isnan(scale) && !glm::isinf(scale);
33	assert(result);	33	assert(result);
34	return result;	34	return result;
35	}	35	}
@@ -323,7 +323,7 @@ inline void Transform::setScale(const Vec3& scale) { · 287 unmodified lines
323	}	323	}
324		324
325	inline void Transform::postScale(float scale) {	325	inline void Transform::postScale(float scale) {
326	if (isValidScale(scale) \|\| scale == 1.0f) {	326	if (!isValidScale(scale) \|\| scale == 1.0f) {
327	return;	327	return;
328	}	328	}
329	if (isScaling()) {	329	if (isScaling()) {

libraries/shared/src/VariantMapToScriptValue.cpp+39−13

 #include "SharedLogging.h"
 #include "VariantMapToScriptValue.h"
-QScriptValue variantMapToScriptValue(QVariantMap& variantMap, QScriptEngine& scriptEngine) {
-    QScriptValue scriptValue = scriptEngine.newObject();
-    for (QVariantMap::const_iterator iter = variantMap.begin(); iter != variantMap.end(); ++iter) {
-        QString key = iter.key();
-        QVariant qValue = iter.value();
-        switch(qValue.type()) {
+QScriptValue variantToScriptValue(QVariant& qValue, QScriptEngine& scriptEngine) {
+    switch(qValue.type()) {
         case QVariant::Bool:
-            scriptValue.setProperty(key, qValue.toBool());
+            return qValue.toBool();
             break;
         case QVariant::Int:
-            scriptValue.setProperty(key, qValue.toInt());
+            return qValue.toInt();
             break;
         case QVariant::Double:
-            scriptValue.setProperty(key, qValue.toDouble());
+            return qValue.toDouble();
             break;
         case QVariant::String: {
-            scriptValue.setProperty(key, scriptEngine.newVariant(qValue));
+            return scriptEngine.newVariant(qValue);
             break;
         }
         case QVariant::Map: {
             QVariantMap childMap = qValue.toMap();
-            scriptValue.setProperty(key, variantMapToScriptValue(childMap, scriptEngine));
+            return variantMapToScriptValue(childMap, scriptEngine);
+            break;
+        }
+        case QVariant::List: {
+            QVariantList childList = qValue.toList();
+            return variantListToScriptValue(childList, scriptEngine);
             break;
         }
         default:
             qCDebug(shared) << "unhandled QScript type" << qValue.type();
-        }
+            break;
+    }
+    return QScriptValue();
+}
+QScriptValue variantMapToScriptValue(QVariantMap& variantMap, QScriptEngine& scriptEngine) {
+    QScriptValue scriptValue = scriptEngine.newObject();
+    for (QVariantMap::const_iterator iter = variantMap.begin(); iter != variantMap.end(); ++iter) {
+        QString key = iter.key();
+        QVariant qValue = iter.value();
+        scriptValue.setProperty(key, variantToScriptValue(qValue, scriptEngine));
+    }
+    return scriptValue;
+}
+QScriptValue variantListToScriptValue(QVariantList& variantList, QScriptEngine& scriptEngine) {
+    QScriptValue scriptValue = scriptEngine.newObject();
+    scriptValue.setProperty("length", variantList.size());
+    int i = 0;
+    foreach (QVariant v, variantList) {
+        scriptValue.setProperty(i++, variantToScriptValue(v, scriptEngine));
     }
     return scriptValue;

libraries/shared/src/VariantMapToScriptValue.h+2−0

@@ -13,4 +13,6 @@ · 12 unmodified lines
13	#include <QScriptValue>	13	#include <QScriptValue>
14	#include <QScriptEngine>	14	#include <QScriptEngine>
15		15
		16	QScriptValue variantToScriptValue(QVariant& qValue, QScriptEngine& scriptEngine);
16	QScriptValue variantMapToScriptValue(QVariantMap& variantMap, QScriptEngine& scriptEngine);	17	QScriptValue variantMapToScriptValue(QVariantMap& variantMap, QScriptEngine& scriptEngine);
		18	QScriptValue variantListToScriptValue(QVariantList& variantList, QScriptEngine& scriptEngine);

libraries/ui/src/Tooltip.cpp+51−0

@@ -0,0 +1,51 @@
	1	//
	2	// Tooltip.cpp
	3	//
	4	// Created by Bradley Austin Davis on 2015/04/14
	5	// Copyright 2015 High Fidelity, Inc.
	6	//
	7	// Distributed under the Apache License, Version 2.0.
	8	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	9	//
	10	#include "Tooltip.h"
	11	#include <QUuid>
	12
	13	HIFI_QML_DEF(Tooltip)
	14
	15	Tooltip::Tooltip(QQuickItem* parent) : QQuickItem(parent) {
	16	}
	17
	18	Tooltip::~Tooltip() {
	19	}
	20
	21	QString Tooltip::text() const {
	22	return _text;
	23	}
	24
	25	void Tooltip::setText(const QString& arg) {
	26	if (arg != _text) {
	27	_text = arg;
	28	emit textChanged();
	29	}
	30	}
	31
	32	void Tooltip::setVisible(bool visible) {
	33	QQuickItem::setVisible(visible);
	34	}
	35
	36	QString Tooltip::showTip(const QString& text) {
	37	const QString newTipId = QUuid().createUuid().toString();
	38	Tooltip::show([&](QQmlContext, QObject object) {
	39	object->setObjectName(newTipId);
	40	object->setProperty("text", text);
	41	});
	42	return newTipId;
	43	}
	44
	45	void Tooltip::closeTip(const QString& tipId) {
	46	auto rootItem = DependencyManager::get<OffscreenUi>()->getRootItem();
	47	QQuickItem* that = rootItem->findChild<QQuickItem*>(tipId);
	48	if (that) {
	49	that->deleteLater();
	50	}
	51	}

libraries/ui/src/Tooltip.h+45−0

@@ -0,0 +1,45 @@
	1	//
	2	// Tooltip.h
	3	//
	4	// Created by Bradley Austin Davis on 2015/04/14
	5	// Copyright 2015 High Fidelity, Inc.
	6	//
	7	// Distributed under the Apache License, Version 2.0.
	8	// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
	9	//
	10
	11	#pragma once
	12	#ifndef hifi_Tooltip_h
	13	#define hifi_Tooltip_h
	14
	15	#include "OffscreenQmlDialog.h"
	16
	17	class Tooltip : public QQuickItem
	18	{
	19	Q_OBJECT
	20	HIFI_QML_DECL
	21
	22	private:
	23	Q_PROPERTY(QString text READ text WRITE setText NOTIFY textChanged)
	24
	25	public:
	26	Tooltip(QQuickItem* parent = 0);
	27	virtual ~Tooltip();
	28
	29	QString text() const;
	30
	31	static QString showTip(const QString& text);
	32	static void closeTip(const QString& tipId);
	33
	34	public slots:
	35	virtual void setVisible(bool v);
	36	void setText(const QString& arg);
	37
	38	signals:
	39	void textChanged();
	40
	41	private:
	42	QString _text;
	43	};
	44
	45	#endif // hifi_Tooltip_h

libraries/ui/src/VrMenu.cpp+2−2

@@ -135,8 +135,8 @@ void VrMenu::setRootMenu(QObject* rootMenu) { · 134 unmodified lines
135		135
136	void VrMenu::addMenu(QMenu* menu) {	136	void VrMenu::addMenu(QMenu* menu) {
137	Q_ASSERT(!MenuUserData::forObject(menu));	137	Q_ASSERT(!MenuUserData::forObject(menu));
138	QObject * parent = menu->parent();	138	QObject* parent = menu->parent();
139	QObject * qmlParent;	139	QObject* qmlParent = nullptr;
140	if (dynamic_cast<QMenu*>(parent)) {	140	if (dynamic_cast<QMenu*>(parent)) {
141	MenuUserData* userData = MenuUserData::forObject(parent);	141	MenuUserData* userData = MenuUserData::forObject(parent);
142	qmlParent = findMenuObject(userData->uuid.toString());	142	qmlParent = findMenuObject(userData->uuid.toString());

tests/physics/src/ShapeColliderTests.cpp+257−257

299 more lines aren’t shown here.

tests/render-utils/src/main.cpp+9−0

This diff is large: its 23 lines aren’t shown here.

tests/shared/src/AngularConstraintTests.cpp+1−1

This diff is large: its 9 lines aren’t shown here.

tests/shared/src/MovingMinMaxAvgTests.cpp+9−8

This diff is large: its 67 lines aren’t shown here.

tools/vhacd-util/src/VHACDUtil.cpp+1−1

This diff is large: its 9 lines aren’t shown here.

tools/vhacd-util/src/VHACDUtilApp.cpp+1−0

This diff is large: its 8 lines aren’t shown here.

@@ -33,19 +33,19 @@ _basePath(basePath), · 32 unmodified lines
33	_geometry(geometry)	33	_geometry(geometry)
34	{	34	{
35	setWindowTitle("Set Model Properties");	35	setWindowTitle("Set Model Properties");
36		36
37	QFormLayout* form = new QFormLayout();	37	QFormLayout* form = new QFormLayout();
38	setLayout(form);	38	setLayout(form);
39		39
40	form->addRow("Name:", _name = new QLineEdit());	40	form->addRow("Name:", _name = new QLineEdit());
41		41
42	form->addRow("Texture Directory:", _textureDirectory = new QPushButton());	42	form->addRow("Texture Directory:", _textureDirectory = new QPushButton());
43	connect(_textureDirectory, SIGNAL(clicked(bool)), SLOT(chooseTextureDirectory()));	43	connect(_textureDirectory, SIGNAL(clicked(bool)), SLOT(chooseTextureDirectory()));
44		44
45	form->addRow("Scale:", _scale = new QDoubleSpinBox());	45	form->addRow("Scale:", _scale = new QDoubleSpinBox());
46	_scale->setMaximum(FLT_MAX);	46	_scale->setMaximum(FLT_MAX);
47	_scale->setSingleStep(0.01);	47	_scale->setSingleStep(0.01);
48		48
49	if (_modelType != FSTReader::ENTITY_MODEL) {	49	if (_modelType != FSTReader::ENTITY_MODEL) {
50	if (_modelType == FSTReader::ATTACHMENT_MODEL) {	50	if (_modelType == FSTReader::ATTACHMENT_MODEL) {
51	QHBoxLayout* translation = new QHBoxLayout();	51	QHBoxLayout* translation = new QHBoxLayout();
@@ -57,7 +57,7 @@ _geometry(geometry) · 5 unmodified lines
57	form->addRow("Pivot Joint:", _pivotJoint = createJointBox());	57	form->addRow("Pivot Joint:", _pivotJoint = createJointBox());
58	connect(_pivotAboutCenter, SIGNAL(toggled(bool)), SLOT(updatePivotJoint()));	58	connect(_pivotAboutCenter, SIGNAL(toggled(bool)), SLOT(updatePivotJoint()));
59	_pivotAboutCenter->setChecked(true);	59	_pivotAboutCenter->setChecked(true);
60		60
61	} else {	61	} else {
62	form->addRow("Left Eye Joint:", _leftEyeJoint = createJointBox());	62	form->addRow("Left Eye Joint:", _leftEyeJoint = createJointBox());
63	form->addRow("Right Eye Joint:", _rightEyeJoint = createJointBox());	63	form->addRow("Right Eye Joint:", _rightEyeJoint = createJointBox());
@@ -69,22 +69,22 @@ _geometry(geometry) · 5 unmodified lines
69	form->addRow("Head Joint:", _headJoint = createJointBox());	69	form->addRow("Head Joint:", _headJoint = createJointBox());
70	form->addRow("Left Hand Joint:", _leftHandJoint = createJointBox());	70	form->addRow("Left Hand Joint:", _leftHandJoint = createJointBox());
71	form->addRow("Right Hand Joint:", _rightHandJoint = createJointBox());	71	form->addRow("Right Hand Joint:", _rightHandJoint = createJointBox());
72		72
73	form->addRow("Free Joints:", _freeJoints = new QVBoxLayout());	73	form->addRow("Free Joints:", _freeJoints = new QVBoxLayout());
74	QPushButton* newFreeJoint = new QPushButton("New Free Joint");	74	QPushButton* newFreeJoint = new QPushButton("New Free Joint");
75	_freeJoints->addWidget(newFreeJoint);	75	_freeJoints->addWidget(newFreeJoint);
76	connect(newFreeJoint, SIGNAL(clicked(bool)), SLOT(createNewFreeJoint()));	76	connect(newFreeJoint, SIGNAL(clicked(bool)), SLOT(createNewFreeJoint()));
77	}	77	}
78	}	78	}
79		79
80	QDialogButtonBox* buttons = new QDialogButtonBox(QDialogButtonBox::Ok \|	80	QDialogButtonBox* buttons = new QDialogButtonBox(QDialogButtonBox::Ok \|
81	QDialogButtonBox::Cancel \| QDialogButtonBox::Reset);	81	QDialogButtonBox::Cancel \| QDialogButtonBox::Reset);
82	connect(buttons, SIGNAL(accepted()), SLOT(accept()));	82	connect(buttons, SIGNAL(accepted()), SLOT(accept()));
83	connect(buttons, SIGNAL(rejected()), SLOT(reject()));	83	connect(buttons, SIGNAL(rejected()), SLOT(reject()));
84	connect(buttons->button(QDialogButtonBox::Reset), SIGNAL(clicked(bool)), SLOT(reset()));	84	connect(buttons->button(QDialogButtonBox::Reset), SIGNAL(clicked(bool)), SLOT(reset()));
85		85
86	form->addRow(buttons);	86	form->addRow(buttons);
87		87
88	// reset to initialize the fields	88	// reset to initialize the fields
89	reset();	89	reset();
90	}	90	}
@@ -100,42 +100,42 @@ QVariantHash ModelPropertiesDialog::getMapping() const { · 9 unmodified lines
100	mapping.insert(NAME_FIELD, _name->text());	100	mapping.insert(NAME_FIELD, _name->text());
101	mapping.insert(TEXDIR_FIELD, _textureDirectory->text());	101	mapping.insert(TEXDIR_FIELD, _textureDirectory->text());
102	mapping.insert(SCALE_FIELD, QString::number(_scale->value()));	102	mapping.insert(SCALE_FIELD, QString::number(_scale->value()));
103		103
104	// update the joint indices	104	// update the joint indices
105	QVariantHash jointIndices;	105	QVariantHash jointIndices;
106	for (int i = 0; i < _geometry.joints.size(); i++) {	106	for (int i = 0; i < _geometry.joints.size(); i++) {
107	jointIndices.insert(_geometry.joints.at(i).name, QString::number(i));	107	jointIndices.insert(_geometry.joints.at(i).name, QString::number(i));
108	}	108	}
109	mapping.insert(JOINT_INDEX_FIELD, jointIndices);	109	mapping.insert(JOINT_INDEX_FIELD, jointIndices);
110		110
111	if (_modelType != FSTReader::ENTITY_MODEL) {	111	if (_modelType != FSTReader::ENTITY_MODEL) {
112	QVariantHash joints = mapping.value(JOINT_FIELD).toHash();	112	QVariantHash joints = mapping.value(JOINT_FIELD).toHash();
113	if (_modelType == FSTReader::ATTACHMENT_MODEL) {	113	if (_modelType == FSTReader::ATTACHMENT_MODEL) {
114	glm::vec3 pivot;	114	glm::vec3 pivot;
115	if (_pivotAboutCenter->isChecked()) {	115	if (_pivotAboutCenter->isChecked()) {
116	pivot = (_geometry.meshExtents.minimum + _geometry.meshExtents.maximum) * 0.5f;	116	pivot = (_geometry.meshExtents.minimum + _geometry.meshExtents.maximum) * 0.5f;
117		117
118	} else if (_pivotJoint->currentIndex() != 0) {	118	} else if (_pivotJoint->currentIndex() != 0) {
119	pivot = extractTranslation(_geometry.joints.at(_pivotJoint->currentIndex() - 1).transform);	119	pivot = extractTranslation(_geometry.joints.at(_pivotJoint->currentIndex() - 1).transform);
120	}	120	}
121	mapping.insert(TRANSLATION_X_FIELD, -pivot.x * _scale->value() + _translationX->value());	121	mapping.insert(TRANSLATION_X_FIELD, -pivot.x * (float)_scale->value() + (float)_translationX->value());
122	mapping.insert(TRANSLATION_Y_FIELD, -pivot.y * _scale->value() + _translationY->value());	122	mapping.insert(TRANSLATION_Y_FIELD, -pivot.y * (float)_scale->value() + (float)_translationY->value());
123	mapping.insert(TRANSLATION_Z_FIELD, -pivot.z * _scale->value() + _translationZ->value());	123	mapping.insert(TRANSLATION_Z_FIELD, -pivot.z * (float)_scale->value() + (float)_translationZ->value());
124		124
125	} else {	125	} else {
126	insertJointMapping(joints, "jointEyeLeft", _leftEyeJoint->currentText());	126	insertJointMapping(joints, "jointEyeLeft", _leftEyeJoint->currentText());
127	insertJointMapping(joints, "jointEyeRight", _rightEyeJoint->currentText());	127	insertJointMapping(joints, "jointEyeRight", _rightEyeJoint->currentText());
128	insertJointMapping(joints, "jointNeck", _neckJoint->currentText());	128	insertJointMapping(joints, "jointNeck", _neckJoint->currentText());
129	}	129	}
130		130
131		131
132	if (_modelType == FSTReader::BODY_ONLY_MODEL \|\| _modelType == FSTReader::HEAD_AND_BODY_MODEL) {	132	if (_modelType == FSTReader::BODY_ONLY_MODEL \|\| _modelType == FSTReader::HEAD_AND_BODY_MODEL) {
133	insertJointMapping(joints, "jointRoot", _rootJoint->currentText());	133	insertJointMapping(joints, "jointRoot", _rootJoint->currentText());
134	insertJointMapping(joints, "jointLean", _leanJoint->currentText());	134	insertJointMapping(joints, "jointLean", _leanJoint->currentText());
135	insertJointMapping(joints, "jointHead", _headJoint->currentText());	135	insertJointMapping(joints, "jointHead", _headJoint->currentText());
136	insertJointMapping(joints, "jointLeftHand", _leftHandJoint->currentText());	136	insertJointMapping(joints, "jointLeftHand", _leftHandJoint->currentText());
137	insertJointMapping(joints, "jointRightHand", _rightHandJoint->currentText());	137	insertJointMapping(joints, "jointRightHand", _rightHandJoint->currentText());
138		138
139	mapping.remove(FREE_JOINT_FIELD);	139	mapping.remove(FREE_JOINT_FIELD);
140	for (int i = 0; i < _freeJoints->count() - 1; i++) {	140	for (int i = 0; i < _freeJoints->count() - 1; i++) {
141	QComboBox* box = static_cast<QComboBox*>(_freeJoints->itemAt(i)->widget()->layout()->itemAt(0)->widget());	141	QComboBox* box = static_cast<QComboBox*>(_freeJoints->itemAt(i)->widget()->layout()->itemAt(0)->widget());
@@ -144,7 +144,7 @@ QVariantHash ModelPropertiesDialog::getMapping() const { · 2 unmodified lines
144	}	144	}
145	mapping.insert(JOINT_FIELD, joints);	145	mapping.insert(JOINT_FIELD, joints);
146	}	146	}
147		147
148	return mapping;	148	return mapping;
149	}	149	}
150		150
@@ -156,9 +156,9 @@ void ModelPropertiesDialog::reset() { · 5 unmodified lines
156	_name->setText(_originalMapping.value(NAME_FIELD).toString());	156	_name->setText(_originalMapping.value(NAME_FIELD).toString());
157	_textureDirectory->setText(_originalMapping.value(TEXDIR_FIELD).toString());	157	_textureDirectory->setText(_originalMapping.value(TEXDIR_FIELD).toString());
158	_scale->setValue(_originalMapping.value(SCALE_FIELD).toDouble());	158	_scale->setValue(_originalMapping.value(SCALE_FIELD).toDouble());
159		159
160	QVariantHash jointHash = _originalMapping.value(JOINT_FIELD).toHash();	160	QVariantHash jointHash = _originalMapping.value(JOINT_FIELD).toHash();
161		161
162	if (_modelType != FSTReader::ENTITY_MODEL) {	162	if (_modelType != FSTReader::ENTITY_MODEL) {
163	if (_modelType == FSTReader::ATTACHMENT_MODEL) {	163	if (_modelType == FSTReader::ATTACHMENT_MODEL) {
164	_translationX->setValue(_originalMapping.value(TRANSLATION_X_FIELD).toDouble());	164	_translationX->setValue(_originalMapping.value(TRANSLATION_X_FIELD).toDouble());
@@ -166,20 +166,20 @@ void ModelPropertiesDialog::reset() { · 1 unmodified line
166	_translationZ->setValue(_originalMapping.value(TRANSLATION_Z_FIELD).toDouble());	166	_translationZ->setValue(_originalMapping.value(TRANSLATION_Z_FIELD).toDouble());
167	_pivotAboutCenter->setChecked(true);	167	_pivotAboutCenter->setChecked(true);
168	_pivotJoint->setCurrentIndex(0);	168	_pivotJoint->setCurrentIndex(0);
169		169
170	} else {	170	} else {
171	setJointText(_leftEyeJoint, jointHash.value("jointEyeLeft").toString());	171	setJointText(_leftEyeJoint, jointHash.value("jointEyeLeft").toString());
172	setJointText(_rightEyeJoint, jointHash.value("jointEyeRight").toString());	172	setJointText(_rightEyeJoint, jointHash.value("jointEyeRight").toString());
173	setJointText(_neckJoint, jointHash.value("jointNeck").toString());	173	setJointText(_neckJoint, jointHash.value("jointNeck").toString());
174	}	174	}
175		175
176	if (_modelType == FSTReader::BODY_ONLY_MODEL \|\| _modelType == FSTReader::HEAD_AND_BODY_MODEL) {	176	if (_modelType == FSTReader::BODY_ONLY_MODEL \|\| _modelType == FSTReader::HEAD_AND_BODY_MODEL) {
177	setJointText(_rootJoint, jointHash.value("jointRoot").toString());	177	setJointText(_rootJoint, jointHash.value("jointRoot").toString());
178	setJointText(_leanJoint, jointHash.value("jointLean").toString());	178	setJointText(_leanJoint, jointHash.value("jointLean").toString());
179	setJointText(_headJoint, jointHash.value("jointHead").toString());	179	setJointText(_headJoint, jointHash.value("jointHead").toString());
180	setJointText(_leftHandJoint, jointHash.value("jointLeftHand").toString());	180	setJointText(_leftHandJoint, jointHash.value("jointLeftHand").toString());
181	setJointText(_rightHandJoint, jointHash.value("jointRightHand").toString());	181	setJointText(_rightHandJoint, jointHash.value("jointRightHand").toString());
182		182
183	while (_freeJoints->count() > 1) {	183	while (_freeJoints->count() > 1) {
184	delete _freeJoints->itemAt(0)->widget();	184	delete _freeJoints->itemAt(0)->widget();
185	}	185	}

@@ -707,8 +707,8 @@ const char* OctreeSceneStats::getItemValue(Item item) { · 706 unmodified lines
707	float elapsedAverage = _elapsedAverage.getAverage();	707	float elapsedAverage = _elapsedAverage.getAverage();
708	calcAverageFPS = (float)USECS_PER_SECOND / (float)elapsedAverage;	708	calcAverageFPS = (float)USECS_PER_SECOND / (float)elapsedAverage;
709		709
710	sprintf(_itemValueBuffer, "%llu usecs (%d fps) Average: %.0f usecs (%d fps)",	710	sprintf(_itemValueBuffer, "%llu usecs (%d fps) Average: %.0f usecs (%d fps)",
711	(long long unsigned int)_elapsed, calcFPS, elapsedAverage, calcAverageFPS);	711	(long long unsigned int)_elapsed, calcFPS, (double)elapsedAverage, calcAverageFPS);
712	break;	712	break;
713	}	713	}
714	case ITEM_ENCODE:	714	case ITEM_ENCODE:
@@ -733,7 +733,7 @@ const char* OctreeSceneStats::getItemValue(Item item) { · 18 unmodified lines
733	float calculatedBPV = total == 0 ? 0 : (_bytes * 8) / total;	733	float calculatedBPV = total == 0 ? 0 : (_bytes * 8) / total;
734	float averageBPV = _bitsPerOctreeAverage.getAverage();	734	float averageBPV = _bitsPerOctreeAverage.getAverage();
735	sprintf(_itemValueBuffer, "%lu (%.2f bits/octree Average: %.2f bits/octree) %lu internal %lu leaves",	735	sprintf(_itemValueBuffer, "%lu (%.2f bits/octree Average: %.2f bits/octree) %lu internal %lu leaves",
736	total, calculatedBPV, averageBPV,	736	total, (double)calculatedBPV, (double)averageBPV,
737	(long unsigned int)_existsInPacketBitsWritten,	737	(long unsigned int)_existsInPacketBitsWritten,
738	(long unsigned int)_colorSent);	738	(long unsigned int)_colorSent);
739	break;	739	break;

@@ -16,20 +16,20 @@ · 15 unmodified lines
16	#include "GeometryUtil.h"	16	#include "GeometryUtil.h"
17	#include "NumericalConstants.h"	17	#include "NumericalConstants.h"
18		18
19	AABox::AABox(const AACube& other) :	19	AABox::AABox(const AACube& other) :
20	_corner(other.getCorner()), _scale(other.getScale(), other.getScale(), other.getScale()) {	20	_corner(other.getCorner()), _scale(other.getScale(), other.getScale(), other.getScale()) {
21	}	21	}
22		22
23	AABox::AABox(const Extents& other) :	23	AABox::AABox(const Extents& other) :
24	_corner(other.minimum),	24	_corner(other.minimum),
25	_scale(other.maximum - other.minimum) {	25	_scale(other.maximum - other.minimum) {
26	}	26	}
27		27
28	AABox::AABox(const glm::vec3& corner, float size) :	28	AABox::AABox(const glm::vec3& corner, float size) :
29	_corner(corner), _scale(size, size, size) {	29	_corner(corner), _scale(size, size, size) {
30	};	30	};
31		31
32	AABox::AABox(const glm::vec3& corner, const glm::vec3& dimensions) :	32	AABox::AABox(const glm::vec3& corner, const glm::vec3& dimensions) :
33	_corner(corner), _scale(dimensions) {	33	_corner(corner), _scale(dimensions) {
34	};	34	};
35		35
@@ -39,7 +39,7 @@ AABox::AABox() : _corner(std::numeric_limits<float>::infinity()), _scale(0.0f) { · 3 unmodified lines
39	glm::vec3 AABox::calcCenter() const {	39	glm::vec3 AABox::calcCenter() const {
40	glm::vec3 center(_corner);	40	glm::vec3 center(_corner);
41	center += (_scale * 0.5f);	41	center += (_scale * 0.5f);
42	return center;	42	return center;
43	}	43	}
44		44
45	void AABox::scale(float scale) {	45	void AABox::scale(float scale) {
@@ -134,12 +134,12 @@ bool AABox::contains(const AABox& otherBox) const { · 88 unmodified lines
134		134
135	bool AABox::touches(const AABox& otherBox) const {	135	bool AABox::touches(const AABox& otherBox) const {
136	glm::vec3 relativeCenter = _corner - otherBox._corner + ((_scale - otherBox._scale) * 0.5f);	136	glm::vec3 relativeCenter = _corner - otherBox._corner + ((_scale - otherBox._scale) * 0.5f);
137		137
138	glm::vec3 totalHalfScale = (_scale + otherBox._scale) * 0.5f;	138	glm::vec3 totalHalfScale = (_scale + otherBox._scale) * 0.5f;
139		139
140	return fabs(relativeCenter.x) <= totalHalfScale.x &&	140	return fabsf(relativeCenter.x) <= totalHalfScale.x &&
141	fabs(relativeCenter.y) <= totalHalfScale.y &&	141	fabsf(relativeCenter.y) <= totalHalfScale.y &&
142	fabs(relativeCenter.z) <= totalHalfScale.z;	142	fabsf(relativeCenter.z) <= totalHalfScale.z;
143	}	143	}
144		144
145	bool AABox::contains(const AACube& otherCube) const {	145	bool AABox::contains(const AACube& otherCube) const {
@@ -154,12 +154,12 @@ bool AABox::contains(const AACube& otherCube) const { · 8 unmodified lines
154		154
155	bool AABox::touches(const AACube& otherCube) const {	155	bool AABox::touches(const AACube& otherCube) const {
156	glm::vec3 relativeCenter = _corner - otherCube.getCorner() + ((_scale - otherCube.getDimensions()) * 0.5f);	156	glm::vec3 relativeCenter = _corner - otherCube.getCorner() + ((_scale - otherCube.getDimensions()) * 0.5f);
157		157
158	glm::vec3 totalHalfScale = (_scale + otherCube.getDimensions()) * 0.5f;	158	glm::vec3 totalHalfScale = (_scale + otherCube.getDimensions()) * 0.5f;
159		159
160	return fabs(relativeCenter.x) <= totalHalfScale.x &&	160	return fabsf(relativeCenter.x) <= totalHalfScale.x &&
161	fabs(relativeCenter.y) <= totalHalfScale.y &&	161	fabsf(relativeCenter.y) <= totalHalfScale.y &&
162	fabs(relativeCenter.z) <= totalHalfScale.z;	162	fabsf(relativeCenter.z) <= totalHalfScale.z;
163	}	163	}
164		164
165	// determines whether a value is within the expanded extents	165	// determines whether a value is within the expanded extents
@@ -244,14 +244,14 @@ bool AABox::findRayIntersection(const glm::vec3& origin, const glm::vec3& direct · 78 unmodified lines
244	isWithin(origin.y + axisDistance*direction.y, _corner.y, _scale.y) &&	244	isWithin(origin.y + axisDistance*direction.y, _corner.y, _scale.y) &&
245	isWithin(origin.x + axisDistance*direction.x, _corner.x, _scale.x))) {	245	isWithin(origin.x + axisDistance*direction.x, _corner.x, _scale.x))) {
246	distance = axisDistance;	246	distance = axisDistance;
247	face = direction.z > 0 ? MAX_Z_FACE : MIN_Z_FACE;	247	face = direction.z > 0 ? MAX_Z_FACE : MIN_Z_FACE;
248	return true;	248	return true;
249	}	249	}
250	// This case is unexpected, but mimics the previous behavior for inside out intersections	250	// This case is unexpected, but mimics the previous behavior for inside out intersections
251	distance = 0;	251	distance = 0;
252	return true;	252	return true;
253	}	253	}
254		254
255	// check each axis	255	// check each axis
256	float axisDistance;	256	float axisDistance;
257	if ((findIntersection(origin.x, direction.x, _corner.x, _scale.x, axisDistance) && axisDistance >= 0 &&	257	if ((findIntersection(origin.x, direction.x, _corner.x, _scale.x, axisDistance) && axisDistance >= 0 &&
@@ -272,7 +272,7 @@ bool AABox::findRayIntersection(const glm::vec3& origin, const glm::vec3& direct · 14 unmodified lines
272	isWithin(origin.y + axisDistance*direction.y, _corner.y, _scale.y) &&	272	isWithin(origin.y + axisDistance*direction.y, _corner.y, _scale.y) &&
273	isWithin(origin.x + axisDistance*direction.x, _corner.x, _scale.x))) {	273	isWithin(origin.x + axisDistance*direction.x, _corner.x, _scale.x))) {
274	distance = axisDistance;	274	distance = axisDistance;
275	face = direction.z > 0 ? MIN_Z_FACE : MAX_Z_FACE;	275	face = direction.z > 0 ? MIN_Z_FACE : MAX_Z_FACE;
276	return true;	276	return true;
277	}	277	}
278	return false;	278	return false;
@@ -280,7 +280,7 @@ bool AABox::findRayIntersection(const glm::vec3& origin, const glm::vec3& direct · 1 unmodified line
280		280
281	bool AABox::findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration) const {	281	bool AABox::findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration) const {
282	glm::vec4 center4 = glm::vec4(center, 1.0f);	282	glm::vec4 center4 = glm::vec4(center, 1.0f);
283		283
284	float minPenetrationLength = FLT_MAX;	284	float minPenetrationLength = FLT_MAX;
285	for (int i = 0; i < FACE_COUNT; i++) {	285	for (int i = 0; i < FACE_COUNT; i++) {
286	glm::vec4 facePlane = getPlane((BoxFace)i);	286	glm::vec4 facePlane = getPlane((BoxFace)i);
@@ -297,7 +297,7 @@ bool AABox::findSpherePenetration(const glm::vec3& center, float radius, glm::ve · 10 unmodified lines
297	minPenetrationLength = vectorLength;	297	minPenetrationLength = vectorLength;
298	}	298	}
299	}	299	}
300		300
301	return true;	301	return true;
302	}	302	}
303		303
@@ -305,7 +305,7 @@ bool AABox::findCapsulePenetration(const glm::vec3& start, const glm::vec3& end, · 1 unmodified line
305	glm::vec4 start4 = glm::vec4(start, 1.0f);	305	glm::vec4 start4 = glm::vec4(start, 1.0f);
306	glm::vec4 end4 = glm::vec4(end, 1.0f);	306	glm::vec4 end4 = glm::vec4(end, 1.0f);
307	glm::vec4 startToEnd = glm::vec4(end - start, 0.0f);	307	glm::vec4 startToEnd = glm::vec4(end - start, 0.0f);
308		308
309	float minPenetrationLength = FLT_MAX;	309	float minPenetrationLength = FLT_MAX;
310	for (int i = 0; i < FACE_COUNT; i++) {	310	for (int i = 0; i < FACE_COUNT; i++) {
311	// find the vector from the segment to the closest point on the face (starting from deeper end)	311	// find the vector from the segment to the closest point on the face (starting from deeper end)
@@ -324,8 +324,8 @@ bool AABox::findCapsulePenetration(const glm::vec3& start, const glm::vec3& end, · 12 unmodified lines
324	vector * ((vectorLength + radius) / -vectorLength);	324	vector * ((vectorLength + radius) / -vectorLength);
325	minPenetrationLength = vectorLength;	325	minPenetrationLength = vectorLength;
326	}	326	}
327	}	327	}
328		328
329	return true;	329	return true;
330	}	330	}
331		331
@@ -334,23 +334,23 @@ glm::vec3 AABox::getClosestPointOnFace(const glm::vec3& point, BoxFace face) con · 2 unmodified lines
334	case MIN_X_FACE:	334	case MIN_X_FACE:
335	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),	335	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),
336	glm::vec3(_corner.x, _corner.y + _scale.y, _corner.z + _scale.z));	336	glm::vec3(_corner.x, _corner.y + _scale.y, _corner.z + _scale.z));
337		337
338	case MAX_X_FACE:	338	case MAX_X_FACE:
339	return glm::clamp(point, glm::vec3(_corner.x + _scale.x, _corner.y, _corner.z),	339	return glm::clamp(point, glm::vec3(_corner.x + _scale.x, _corner.y, _corner.z),
340	glm::vec3(_corner.x + _scale.x, _corner.y + _scale.y, _corner.z + _scale.z));	340	glm::vec3(_corner.x + _scale.x, _corner.y + _scale.y, _corner.z + _scale.z));
341		341
342	case MIN_Y_FACE:	342	case MIN_Y_FACE:
343	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),	343	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),
344	glm::vec3(_corner.x + _scale.x, _corner.y, _corner.z + _scale.z));	344	glm::vec3(_corner.x + _scale.x, _corner.y, _corner.z + _scale.z));
345		345
346	case MAX_Y_FACE:	346	case MAX_Y_FACE:
347	return glm::clamp(point, glm::vec3(_corner.x, _corner.y + _scale.y, _corner.z),	347	return glm::clamp(point, glm::vec3(_corner.x, _corner.y + _scale.y, _corner.z),
348	glm::vec3(_corner.x + _scale.x, _corner.y + _scale.y, _corner.z + _scale.z));	348	glm::vec3(_corner.x + _scale.x, _corner.y + _scale.y, _corner.z + _scale.z));
349		349
350	case MIN_Z_FACE:	350	case MIN_Z_FACE:
351	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),	351	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),
352	glm::vec3(_corner.x + _scale.z, _corner.y + _scale.y, _corner.z));	352	glm::vec3(_corner.x + _scale.z, _corner.y + _scale.y, _corner.z));
353		353
354	default: //quiet windows warnings	354	default: //quiet windows warnings
355	case MAX_Z_FACE:	355	case MAX_Z_FACE:
356	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z + _scale.z),	356	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z + _scale.z),
@@ -373,7 +373,7 @@ glm::vec3 AABox::getClosestPointOnFace(const glm::vec4& origin, const glm::vec4& · 16 unmodified lines
373	}	373	}
374	anyOutside = true;	374	anyOutside = true;
375	float divisor = glm::dot(direction, iPlane);	375	float divisor = glm::dot(direction, iPlane);
376	if (fabs(divisor) < EPSILON) {	376	if (fabsf(divisor) < EPSILON) {
377	continue; // segment is parallel to plane	377	continue; // segment is parallel to plane
378	}	378	}
379	// find intersection and see if it lies within face bounds	379	// find intersection and see if it lies within face bounds
@@ -389,29 +389,29 @@ glm::vec3 AABox::getClosestPointOnFace(const glm::vec4& origin, const glm::vec4& · 9 unmodified lines
389	}	389	}
390	}	390	}
391	return getClosestPointOnFace(glm::vec3(intersection), face);	391	return getClosestPointOnFace(glm::vec3(intersection), face);
392		392
393	outerContinue: ;	393	outerContinue: ;
394	}	394	}
395		395
396	// if we were outside any of the sides, we must check against the diagonals	396	// if we were outside any of the sides, we must check against the diagonals
397	if (anyOutside) {	397	if (anyOutside) {
398	int faceAxis = face / 2;	398	int faceAxis = face / 2;
399	int secondAxis = (faceAxis + 1) % 3;	399	int secondAxis = (faceAxis + 1) % 3;
400	int thirdAxis = (faceAxis + 2) % 3;	400	int thirdAxis = (faceAxis + 2) % 3;
401		401
402	glm::vec4 secondAxisMinPlane = getPlane((BoxFace)(secondAxis * 2));	402	glm::vec4 secondAxisMinPlane = getPlane((BoxFace)(secondAxis * 2));
403	glm::vec4 secondAxisMaxPlane = getPlane((BoxFace)(secondAxis * 2 + 1));	403	glm::vec4 secondAxisMaxPlane = getPlane((BoxFace)(secondAxis * 2 + 1));
404	glm::vec4 thirdAxisMaxPlane = getPlane((BoxFace)(thirdAxis * 2 + 1));	404	glm::vec4 thirdAxisMaxPlane = getPlane((BoxFace)(thirdAxis * 2 + 1));
405		405
406	glm::vec4 offset = glm::vec4(0.0f, 0.0f, 0.0f,	406	glm::vec4 offset = glm::vec4(0.0f, 0.0f, 0.0f,
407	glm::dot(glm::vec3(secondAxisMaxPlane + thirdAxisMaxPlane), _scale) * 0.5f);	407	glm::dot(glm::vec3(secondAxisMaxPlane + thirdAxisMaxPlane), _scale) * 0.5f);
408	glm::vec4 diagonals[] = { secondAxisMinPlane + thirdAxisMaxPlane + offset,	408	glm::vec4 diagonals[] = { secondAxisMinPlane + thirdAxisMaxPlane + offset,
409	secondAxisMaxPlane + thirdAxisMaxPlane + offset };	409	secondAxisMaxPlane + thirdAxisMaxPlane + offset };
410		410
411	float minDistance = FLT_MAX;	411	float minDistance = FLT_MAX;
412	for (size_t i = 0; i < sizeof(diagonals) / sizeof(diagonals[0]); i++) {	412	for (size_t i = 0; i < sizeof(diagonals) / sizeof(diagonals[0]); i++) {
413	float divisor = glm::dot(direction, diagonals[i]);	413	float divisor = glm::dot(direction, diagonals[i]);
414	if (fabs(divisor) < EPSILON) {	414	if (fabsf(divisor) < EPSILON) {
415	continue; // segment is parallel to diagonal plane	415	continue; // segment is parallel to diagonal plane
416	}	416	}
417	minDistance = glm::min(-glm::dot(origin, diagonals[i]) / divisor, minDistance);	417	minDistance = glm::min(-glm::dot(origin, diagonals[i]) / divisor, minDistance);
@@ -420,7 +420,7 @@ glm::vec3 AABox::getClosestPointOnFace(const glm::vec4& origin, const glm::vec4& · 2 unmodified lines
420	return getClosestPointOnFace(glm::vec3(origin + direction * minDistance), face);	420	return getClosestPointOnFace(glm::vec3(origin + direction * minDistance), face);
421	}	421	}
422	}	422	}
423		423
424	// last resort or all inside: clamp origin to face	424	// last resort or all inside: clamp origin to face
425	return getClosestPointOnFace(glm::vec3(origin), face);	425	return getClosestPointOnFace(glm::vec3(origin), face);
426	}	426	}
@@ -453,7 +453,7 @@ AABox AABox::clamp(const glm::vec3& min, const glm::vec3& max) const { · 26 unmodified lines
453	glm::vec3 clampedCorner = glm::clamp(_corner, min, max);	453	glm::vec3 clampedCorner = glm::clamp(_corner, min, max);
454	glm::vec3 clampedTopFarLeft = glm::clamp(calcTopFarLeft(), min, max);	454	glm::vec3 clampedTopFarLeft = glm::clamp(calcTopFarLeft(), min, max);
455	glm::vec3 clampedScale = clampedTopFarLeft - clampedCorner;	455	glm::vec3 clampedScale = clampedTopFarLeft - clampedCorner;
456		456
457	return AABox(clampedCorner, clampedScale);	457	return AABox(clampedCorner, clampedScale);
458	}	458	}
459		459
@@ -461,7 +461,7 @@ AABox AABox::clamp(float min, float max) const { · 1 unmodified line
461	glm::vec3 clampedCorner = glm::clamp(_corner, min, max);	461	glm::vec3 clampedCorner = glm::clamp(_corner, min, max);
462	glm::vec3 clampedTopFarLeft = glm::clamp(calcTopFarLeft(), min, max);	462	glm::vec3 clampedTopFarLeft = glm::clamp(calcTopFarLeft(), min, max);
463	glm::vec3 clampedScale = clampedTopFarLeft - clampedCorner;	463	glm::vec3 clampedScale = clampedTopFarLeft - clampedCorner;
464		464
465	return AABox(clampedCorner, clampedScale);	465	return AABox(clampedCorner, clampedScale);
466	}	466	}
467		467

@@ -21,14 +21,14 @@ AACube::AACube(const AABox& other) : · 20 unmodified lines
21	_corner(other.getCorner()), _scale(other.getLargestDimension()) {	21	_corner(other.getCorner()), _scale(other.getLargestDimension()) {
22	}	22	}
23		23
24	AACube::AACube(const Extents& other) :	24	AACube::AACube(const Extents& other) :
25	_corner(other.minimum)	25	_corner(other.minimum)
26	{	26	{
27	glm::vec3 dimensions = other.maximum - other.minimum;	27	glm::vec3 dimensions = other.maximum - other.minimum;
28	_scale = glm::max(dimensions.x, dimensions.y, dimensions.z);	28	_scale = glm::max(dimensions.x, dimensions.y, dimensions.z);
29	}	29	}
30		30
31	AACube::AACube(const glm::vec3& corner, float size) :	31	AACube::AACube(const glm::vec3& corner, float size) :
32	_corner(corner), _scale(size) {	32	_corner(corner), _scale(size) {
33	};	33	};
34		34
@@ -38,13 +38,13 @@ AACube::AACube() : _corner(0,0,0), _scale(0) { · 3 unmodified lines
38	glm::vec3 AACube::calcCenter() const {	38	glm::vec3 AACube::calcCenter() const {
39	glm::vec3 center(_corner);	39	glm::vec3 center(_corner);
40	center += (glm::vec3(_scale, _scale, _scale) * 0.5f);	40	center += (glm::vec3(_scale, _scale, _scale) * 0.5f);
41	return center;	41	return center;
42	}	42	}
43		43
44	glm::vec3 AACube::calcTopFarLeft() const {	44	glm::vec3 AACube::calcTopFarLeft() const {
45	glm::vec3 topFarLeft(_corner);	45	glm::vec3 topFarLeft(_corner);
46	topFarLeft += glm::vec3(_scale, _scale, _scale);	46	topFarLeft += glm::vec3(_scale, _scale, _scale);
47	return topFarLeft;	47	return topFarLeft;
48	};	48	};
49		49
50	void AACube::scale(float scale) {	50	void AACube::scale(float scale) {
@@ -135,9 +135,9 @@ bool AACube::contains(const AACube& otherCube) const { · 84 unmodified lines
135	bool AACube::touches(const AACube& otherCube) const {	135	bool AACube::touches(const AACube& otherCube) const {
136	glm::vec3 relativeCenter = _corner - otherCube._corner + (glm::vec3(_scale - otherCube._scale) * 0.5f);	136	glm::vec3 relativeCenter = _corner - otherCube._corner + (glm::vec3(_scale - otherCube._scale) * 0.5f);
137	float totalHalfScale = 0.5f * (_scale + otherCube._scale);	137	float totalHalfScale = 0.5f * (_scale + otherCube._scale);
138	return fabs(relativeCenter.x) <= totalHalfScale &&	138	return fabsf(relativeCenter.x) <= totalHalfScale &&
139	fabs(relativeCenter.y) <= totalHalfScale &&	139	fabsf(relativeCenter.y) <= totalHalfScale &&
140	fabs(relativeCenter.z) <= totalHalfScale;	140	fabsf(relativeCenter.z) <= totalHalfScale;
141	}	141	}
142		142
143	bool AACube::contains(const AABox& otherBox) const {	143	bool AACube::contains(const AABox& otherBox) const {
@@ -154,10 +154,10 @@ bool AACube::touches(const AABox& otherBox) const { · 10 unmodified lines
154	glm::vec3 myDimensions = glm::vec3(_scale);	154	glm::vec3 myDimensions = glm::vec3(_scale);
155	glm::vec3 relativeCenter = _corner - otherBox.getCorner() + ((myDimensions - otherBox.getScale()) * 0.5f);	155	glm::vec3 relativeCenter = _corner - otherBox.getCorner() + ((myDimensions - otherBox.getScale()) * 0.5f);
156	glm::vec3 totalHalfScale = (myDimensions + otherBox.getDimensions()) * 0.5f;	156	glm::vec3 totalHalfScale = (myDimensions + otherBox.getDimensions()) * 0.5f;
157		157
158	return fabs(relativeCenter.x) <= totalHalfScale.x &&	158	return fabsf(relativeCenter.x) <= totalHalfScale.x &&
159	fabs(relativeCenter.y) <= totalHalfScale.y &&	159	fabsf(relativeCenter.y) <= totalHalfScale.y &&
160	fabs(relativeCenter.z) <= totalHalfScale.z;	160	fabsf(relativeCenter.z) <= totalHalfScale.z;
161	}	161	}
162		162
163	// determines whether a value is within the expanded extents	163	// determines whether a value is within the expanded extents
@@ -222,7 +222,7 @@ bool AACube::expandedIntersectsSegment(const glm::vec3& start, const glm::vec3& · 58 unmodified lines
222	bool AACube::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const {	222	bool AACube::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const {
223	// handle the trivial case where the box contains the origin	223	// handle the trivial case where the box contains the origin
224	if (contains(origin)) {	224	if (contains(origin)) {
225		225
226	// We still want to calculate the distance from the origin to the inside out plane	226	// We still want to calculate the distance from the origin to the inside out plane
227	float axisDistance;	227	float axisDistance;
228	if ((findInsideOutIntersection(origin.x, direction.x, _corner.x, _scale, axisDistance) && axisDistance >= 0 &&	228	if ((findInsideOutIntersection(origin.x, direction.x, _corner.x, _scale, axisDistance) && axisDistance >= 0 &&
@@ -243,14 +243,14 @@ bool AACube::findRayIntersection(const glm::vec3& origin, const glm::vec3& direc · 14 unmodified lines
243	isWithin(origin.y + axisDistance*direction.y, _corner.y, _scale) &&	243	isWithin(origin.y + axisDistance*direction.y, _corner.y, _scale) &&
244	isWithin(origin.x + axisDistance*direction.x, _corner.x, _scale))) {	244	isWithin(origin.x + axisDistance*direction.x, _corner.x, _scale))) {
245	distance = axisDistance;	245	distance = axisDistance;
246	face = direction.z > 0 ? MAX_Z_FACE : MIN_Z_FACE;	246	face = direction.z > 0 ? MAX_Z_FACE : MIN_Z_FACE;
247	return true;	247	return true;
248	}	248	}
249	// This case is unexpected, but mimics the previous behavior for inside out intersections	249	// This case is unexpected, but mimics the previous behavior for inside out intersections
250	distance = 0;	250	distance = 0;
251	return true;	251	return true;
252	}	252	}
253		253
254	// check each axis	254	// check each axis
255	float axisDistance;	255	float axisDistance;
256	if ((findIntersection(origin.x, direction.x, _corner.x, _scale, axisDistance) && axisDistance >= 0 &&	256	if ((findIntersection(origin.x, direction.x, _corner.x, _scale, axisDistance) && axisDistance >= 0 &&
@@ -271,7 +271,7 @@ bool AACube::findRayIntersection(const glm::vec3& origin, const glm::vec3& direc · 14 unmodified lines
271	isWithin(origin.y + axisDistance*direction.y, _corner.y, _scale) &&	271	isWithin(origin.y + axisDistance*direction.y, _corner.y, _scale) &&
272	isWithin(origin.x + axisDistance*direction.x, _corner.x, _scale))) {	272	isWithin(origin.x + axisDistance*direction.x, _corner.x, _scale))) {
273	distance = axisDistance;	273	distance = axisDistance;
274	face = direction.z > 0 ? MIN_Z_FACE : MAX_Z_FACE;	274	face = direction.z > 0 ? MIN_Z_FACE : MAX_Z_FACE;
275	return true;	275	return true;
276	}	276	}
277	return false;	277	return false;
@@ -279,7 +279,7 @@ bool AACube::findRayIntersection(const glm::vec3& origin, const glm::vec3& direc · 1 unmodified line
279		279
280	bool AACube::findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration) const {	280	bool AACube::findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration) const {
281	glm::vec4 center4 = glm::vec4(center, 1.0f);	281	glm::vec4 center4 = glm::vec4(center, 1.0f);
282		282
283	float minPenetrationLength = FLT_MAX;	283	float minPenetrationLength = FLT_MAX;
284	for (int i = 0; i < FACE_COUNT; i++) {	284	for (int i = 0; i < FACE_COUNT; i++) {
285	glm::vec4 facePlane = getPlane((BoxFace)i);	285	glm::vec4 facePlane = getPlane((BoxFace)i);
@@ -296,7 +296,7 @@ bool AACube::findSpherePenetration(const glm::vec3& center, float radius, glm::v · 10 unmodified lines
296	minPenetrationLength = vectorLength;	296	minPenetrationLength = vectorLength;
297	}	297	}
298	}	298	}
299		299
300	return true;	300	return true;
301	}	301	}
302		302
@@ -304,7 +304,7 @@ bool AACube::findCapsulePenetration(const glm::vec3& start, const glm::vec3& end · 1 unmodified line
304	glm::vec4 start4 = glm::vec4(start, 1.0f);	304	glm::vec4 start4 = glm::vec4(start, 1.0f);
305	glm::vec4 end4 = glm::vec4(end, 1.0f);	305	glm::vec4 end4 = glm::vec4(end, 1.0f);
306	glm::vec4 startToEnd = glm::vec4(end - start, 0.0f);	306	glm::vec4 startToEnd = glm::vec4(end - start, 0.0f);
307		307
308	float minPenetrationLength = FLT_MAX;	308	float minPenetrationLength = FLT_MAX;
309	for (int i = 0; i < FACE_COUNT; i++) {	309	for (int i = 0; i < FACE_COUNT; i++) {
310	// find the vector from the segment to the closest point on the face (starting from deeper end)	310	// find the vector from the segment to the closest point on the face (starting from deeper end)
@@ -323,8 +323,8 @@ bool AACube::findCapsulePenetration(const glm::vec3& start, const glm::vec3& end · 12 unmodified lines
323	vector * ((vectorLength + radius) / -vectorLength);	323	vector * ((vectorLength + radius) / -vectorLength);
324	minPenetrationLength = vectorLength;	324	minPenetrationLength = vectorLength;
325	}	325	}
326	}	326	}
327		327
328	return true;	328	return true;
329	}	329	}
330		330
@@ -333,23 +333,23 @@ glm::vec3 AACube::getClosestPointOnFace(const glm::vec3& point, BoxFace face) co · 2 unmodified lines
333	case MIN_X_FACE:	333	case MIN_X_FACE:
334	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),	334	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),
335	glm::vec3(_corner.x, _corner.y + _scale, _corner.z + _scale));	335	glm::vec3(_corner.x, _corner.y + _scale, _corner.z + _scale));
336		336
337	case MAX_X_FACE:	337	case MAX_X_FACE:
338	return glm::clamp(point, glm::vec3(_corner.x + _scale, _corner.y, _corner.z),	338	return glm::clamp(point, glm::vec3(_corner.x + _scale, _corner.y, _corner.z),
339	glm::vec3(_corner.x + _scale, _corner.y + _scale, _corner.z + _scale));	339	glm::vec3(_corner.x + _scale, _corner.y + _scale, _corner.z + _scale));
340		340
341	case MIN_Y_FACE:	341	case MIN_Y_FACE:
342	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),	342	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),
343	glm::vec3(_corner.x + _scale, _corner.y, _corner.z + _scale));	343	glm::vec3(_corner.x + _scale, _corner.y, _corner.z + _scale));
344		344
345	case MAX_Y_FACE:	345	case MAX_Y_FACE:
346	return glm::clamp(point, glm::vec3(_corner.x, _corner.y + _scale, _corner.z),	346	return glm::clamp(point, glm::vec3(_corner.x, _corner.y + _scale, _corner.z),
347	glm::vec3(_corner.x + _scale, _corner.y + _scale, _corner.z + _scale));	347	glm::vec3(_corner.x + _scale, _corner.y + _scale, _corner.z + _scale));
348		348
349	case MIN_Z_FACE:	349	case MIN_Z_FACE:
350	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),	350	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z),
351	glm::vec3(_corner.x + _scale, _corner.y + _scale, _corner.z));	351	glm::vec3(_corner.x + _scale, _corner.y + _scale, _corner.z));
352		352
353	default: //quiet windows warnings	353	default: //quiet windows warnings
354	case MAX_Z_FACE:	354	case MAX_Z_FACE:
355	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z + _scale),	355	return glm::clamp(point, glm::vec3(_corner.x, _corner.y, _corner.z + _scale),
@@ -372,7 +372,7 @@ glm::vec3 AACube::getClosestPointOnFace(const glm::vec4& origin, const glm::vec4 · 16 unmodified lines
372	}	372	}
373	anyOutside = true;	373	anyOutside = true;
374	float divisor = glm::dot(direction, iPlane);	374	float divisor = glm::dot(direction, iPlane);
375	if (fabs(divisor) < EPSILON) {	375	if (fabsf(divisor) < EPSILON) {
376	continue; // segment is parallel to plane	376	continue; // segment is parallel to plane
377	}	377	}
378	// find intersection and see if it lies within face bounds	378	// find intersection and see if it lies within face bounds
@@ -388,29 +388,29 @@ glm::vec3 AACube::getClosestPointOnFace(const glm::vec4& origin, const glm::vec4 · 9 unmodified lines
388	}	388	}
389	}	389	}
390	return getClosestPointOnFace(glm::vec3(intersection), face);	390	return getClosestPointOnFace(glm::vec3(intersection), face);
391		391
392	outerContinue: ;	392	outerContinue: ;
393	}	393	}
394		394
395	// if we were outside any of the sides, we must check against the diagonals	395	// if we were outside any of the sides, we must check against the diagonals
396	if (anyOutside) {	396	if (anyOutside) {
397	int faceAxis = face / 2;	397	int faceAxis = face / 2;
398	int secondAxis = (faceAxis + 1) % 3;	398	int secondAxis = (faceAxis + 1) % 3;
399	int thirdAxis = (faceAxis + 2) % 3;	399	int thirdAxis = (faceAxis + 2) % 3;
400		400
401	glm::vec4 secondAxisMinPlane = getPlane((BoxFace)(secondAxis * 2));	401	glm::vec4 secondAxisMinPlane = getPlane((BoxFace)(secondAxis * 2));
402	glm::vec4 secondAxisMaxPlane = getPlane((BoxFace)(secondAxis * 2 + 1));	402	glm::vec4 secondAxisMaxPlane = getPlane((BoxFace)(secondAxis * 2 + 1));
403	glm::vec4 thirdAxisMaxPlane = getPlane((BoxFace)(thirdAxis * 2 + 1));	403	glm::vec4 thirdAxisMaxPlane = getPlane((BoxFace)(thirdAxis * 2 + 1));
404		404
405	glm::vec4 offset = glm::vec4(0.0f, 0.0f, 0.0f,	405	glm::vec4 offset = glm::vec4(0.0f, 0.0f, 0.0f,
406	glm::dot(glm::vec3(secondAxisMaxPlane + thirdAxisMaxPlane), glm::vec3(_scale, _scale, _scale)) * 0.5f);	406	glm::dot(glm::vec3(secondAxisMaxPlane + thirdAxisMaxPlane), glm::vec3(_scale, _scale, _scale)) * 0.5f);
407	glm::vec4 diagonals[] = { secondAxisMinPlane + thirdAxisMaxPlane + offset,	407	glm::vec4 diagonals[] = { secondAxisMinPlane + thirdAxisMaxPlane + offset,
408	secondAxisMaxPlane + thirdAxisMaxPlane + offset };	408	secondAxisMaxPlane + thirdAxisMaxPlane + offset };
409		409
410	float minDistance = FLT_MAX;	410	float minDistance = FLT_MAX;
411	for (size_t i = 0; i < sizeof(diagonals) / sizeof(diagonals[0]); i++) {	411	for (size_t i = 0; i < sizeof(diagonals) / sizeof(diagonals[0]); i++) {
412	float divisor = glm::dot(direction, diagonals[i]);	412	float divisor = glm::dot(direction, diagonals[i]);
413	if (fabs(divisor) < EPSILON) {	413	if (fabsf(divisor) < EPSILON) {
414	continue; // segment is parallel to diagonal plane	414	continue; // segment is parallel to diagonal plane
415	}	415	}
416	minDistance = glm::min(-glm::dot(origin, diagonals[i]) / divisor, minDistance);	416	minDistance = glm::min(-glm::dot(origin, diagonals[i]) / divisor, minDistance);
@@ -419,7 +419,7 @@ glm::vec3 AACube::getClosestPointOnFace(const glm::vec4& origin, const glm::vec4 · 2 unmodified lines
419	return getClosestPointOnFace(glm::vec3(origin + direction * minDistance), face);	419	return getClosestPointOnFace(glm::vec3(origin + direction * minDistance), face);
420	}	420	}
421	}	421	}
422		422
423	// last resort or all inside: clamp origin to face	423	// last resort or all inside: clamp origin to face
424	return getClosestPointOnFace(glm::vec3(origin), face);	424	return getClosestPointOnFace(glm::vec3(origin), face);
425	}	425	}

@@ -47,7 +47,7 @@ void printOctalCode(const unsigned char* octalCode) { · 46 unmodified lines
47		47
48	char sectionValue(const unsigned char* startByte, char startIndexInByte) {	48	char sectionValue(const unsigned char* startByte, char startIndexInByte) {
49	char rightShift = 8 - startIndexInByte - 3;	49	char rightShift = 8 - startIndexInByte - 3;
50		50
51	if (rightShift < 0) {	51	if (rightShift < 0) {
52	return ((startByte[0] << -rightShift) & 7) + (startByte[1] >> (8 + rightShift));	52	return ((startByte[0] << -rightShift) & 7) + (startByte[1] >> (8 + rightShift));
53	} else {	53	} else {
@@ -65,7 +65,7 @@ size_t bytesRequiredForCodeLength(unsigned char threeBitCodes) { · 11 unmodified lines
65		65
66	int branchIndexWithDescendant(const unsigned char* ancestorOctalCode, const unsigned char* descendantOctalCode) {	66	int branchIndexWithDescendant(const unsigned char* ancestorOctalCode, const unsigned char* descendantOctalCode) {
67	int parentSections = numberOfThreeBitSectionsInCode(ancestorOctalCode);	67	int parentSections = numberOfThreeBitSectionsInCode(ancestorOctalCode);
68		68
69	int branchStartBit = parentSections * 3;	69	int branchStartBit = parentSections * 3;
70	// Note: this does not appear to be "multi-byte length code" safe. When octal codes are larger than 255 bytes	70	// Note: this does not appear to be "multi-byte length code" safe. When octal codes are larger than 255 bytes
71	// long, the length code is stored in two bytes. The "1" below appears to assume that the length is always one	71	// long, the length code is stored in two bytes. The "1" below appears to assume that the length is always one
@@ -74,45 +74,45 @@ int branchIndexWithDescendant(const unsigned char* ancestorOctalCode, const unsi · 2 unmodified lines
74	}	74	}
75		75
76	unsigned char* childOctalCode(const unsigned char* parentOctalCode, char childNumber) {	76	unsigned char* childOctalCode(const unsigned char* parentOctalCode, char childNumber) {
77		77
78	// find the length (in number of three bit code sequences)	78	// find the length (in number of three bit code sequences)
79	// in the parent	79	// in the parent
80	int parentCodeSections = parentOctalCode	80	int parentCodeSections = parentOctalCode
81	? numberOfThreeBitSectionsInCode(parentOctalCode)	81	? numberOfThreeBitSectionsInCode(parentOctalCode)
82	: 0;	82	: 0;
83		83
84	// get the number of bytes used by the parent octal code	84	// get the number of bytes used by the parent octal code
85	size_t parentCodeBytes = bytesRequiredForCodeLength(parentCodeSections);	85	size_t parentCodeBytes = bytesRequiredForCodeLength(parentCodeSections);
86		86
87	// child code will have one more section than the parent	87	// child code will have one more section than the parent
88	size_t childCodeBytes = bytesRequiredForCodeLength(parentCodeSections + 1);	88	size_t childCodeBytes = bytesRequiredForCodeLength(parentCodeSections + 1);
89		89
90	// create a new buffer to hold the new octal code	90	// create a new buffer to hold the new octal code
91	unsigned char* newCode = new unsigned char[childCodeBytes];	91	unsigned char* newCode = new unsigned char[childCodeBytes];
92		92
93	// copy the parent code to the child	93	// copy the parent code to the child
94	if (parentOctalCode) {	94	if (parentOctalCode) {
95	memcpy(newCode, parentOctalCode, parentCodeBytes);	95	memcpy(newCode, parentOctalCode, parentCodeBytes);
96	}	96	}
97		97
98	// the child octal code has one more set of three bits	98	// the child octal code has one more set of three bits
99	*newCode = parentCodeSections + 1;	99	*newCode = parentCodeSections + 1;
100		100
101	if (childCodeBytes > parentCodeBytes) {	101	if (childCodeBytes > parentCodeBytes) {
102	// we have a new byte due to the addition of the child code	102	// we have a new byte due to the addition of the child code
103	// so set it to zero for correct results when shifting later	103	// so set it to zero for correct results when shifting later
104	newCode[childCodeBytes - 1] = 0;	104	newCode[childCodeBytes - 1] = 0;
105	}	105	}
106		106
107	// add the child code bits to newCode	107	// add the child code bits to newCode
108		108
109	// find the start bit index	109	// find the start bit index
110	int startBit = parentCodeSections * 3;	110	int startBit = parentCodeSections * 3;
111		111
112	// calculate the amount of left shift required	112	// calculate the amount of left shift required
113	// this will be -1 or -2 if there's wrap	113	// this will be -1 or -2 if there's wrap
114	char leftShift = 8 - (startBit % 8) - 3;	114	char leftShift = 8 - (startBit % 8) - 3;
115		115
116	if (leftShift < 0) {	116	if (leftShift < 0) {
117	// we have a wrap-around to accomodate	117	// we have a wrap-around to accomodate
118	// right shift for the end of first byte	118	// right shift for the end of first byte
@@ -123,7 +123,7 @@ unsigned char* childOctalCode(const unsigned char* parentOctalCode, char childNu · 4 unmodified lines
123	// no wraparound, left shift and add	123	// no wraparound, left shift and add
124	newCode[(startBit / 8) + 1] += (childNumber << leftShift);	124	newCode[(startBit / 8) + 1] += (childNumber << leftShift);
125	}	125	}
126		126
127	return newCode;	127	return newCode;
128	}	128	}
129		129
@@ -135,9 +135,9 @@ void voxelDetailsForCode(const unsigned char* octalCode, VoxelPositionSize& voxe · 5 unmodified lines
135	if (octalCode) {	135	if (octalCode) {
136	for (int i = 0; i < numberOfThreeBitSectionsInCode(octalCode); i++) {	136	for (int i = 0; i < numberOfThreeBitSectionsInCode(octalCode); i++) {
137	currentScale *= 0.5f;	137	currentScale *= 0.5f;
138	int sectionIndex = sectionValue(octalCode + 1 + (BITS_IN_OCTAL * i / BITS_IN_BYTE),	138	int sectionIndex = sectionValue(octalCode + 1 + (BITS_IN_OCTAL * i / BITS_IN_BYTE),
139	(BITS_IN_OCTAL * i) % BITS_IN_BYTE);	139	(BITS_IN_OCTAL * i) % BITS_IN_BYTE);
140		140
141	for (int j = 0; j < BITS_IN_OCTAL; j++) {	141	for (int j = 0; j < BITS_IN_OCTAL; j++) {
142	output[j] += currentScale * (float)oneAtBit(sectionIndex, (BITS_IN_BYTE - BITS_IN_OCTAL) + j);	142	output[j] += currentScale * (float)oneAtBit(sectionIndex, (BITS_IN_BYTE - BITS_IN_OCTAL) + j);
143	}	143	}
@@ -151,17 +151,17 @@ void voxelDetailsForCode(const unsigned char* octalCode, VoxelPositionSize& voxe · 7 unmodified lines
151		151
152	void copyFirstVertexForCode(const unsigned char* octalCode, float* output) {	152	void copyFirstVertexForCode(const unsigned char* octalCode, float* output) {
153	memset(output, 0, 3 * sizeof(float));	153	memset(output, 0, 3 * sizeof(float));
154		154
155	float currentScale = 0.5f;	155	float currentScale = 0.5f;
156		156
157	for (int i = 0; i < numberOfThreeBitSectionsInCode(octalCode); i++) {	157	for (int i = 0; i < numberOfThreeBitSectionsInCode(octalCode); i++) {
158	int sectionIndex = sectionValue(octalCode + 1 + (3 * i / 8), (3 * i) % 8);	158	int sectionIndex = sectionValue(octalCode + 1 + (3 * i / 8), (3 * i) % 8);
159		159
160	for (int j = 0; j < 3; j++) {	160	for (int j = 0; j < 3; j++) {
161	output[j] += currentScale * (int)oneAtBit(sectionIndex, 5 + j);	161	output[j] += currentScale * (int)oneAtBit(sectionIndex, 5 + j);
162	}	162	}
163		163
164	currentScale *= 0.5;	164	currentScale *= 0.5f;
165	}	165	}
166	}	166	}
167		167
@@ -171,7 +171,7 @@ OctalCodeComparison compareOctalCodes(const unsigned char* codeA, const unsigned · 3 unmodified lines
171	}	171	}
172		172
173	OctalCodeComparison result = LESS_THAN; // assume it's shallower	173	OctalCodeComparison result = LESS_THAN; // assume it's shallower
174		174
175	size_t numberOfBytes = std::min(bytesRequiredForCodeLength(codeA), bytesRequiredForCodeLength(codeB));	175	size_t numberOfBytes = std::min(bytesRequiredForCodeLength(codeA), bytesRequiredForCodeLength(codeB));
176	int compare = memcmp(codeA, codeB, numberOfBytes);	176	int compare = memcmp(codeA, codeB, numberOfBytes);
177		177
@@ -205,7 +205,7 @@ char getOctalCodeSectionValue(const unsigned char* octalCode, int section) { · 27 unmodified lines
205	int startAtByte = 1 + (BITS_IN_OCTAL * section / BITS_IN_BYTE);	205	int startAtByte = 1 + (BITS_IN_OCTAL * section / BITS_IN_BYTE);
206	char startIndexInByte = (BITS_IN_OCTAL * section) % BITS_IN_BYTE;	206	char startIndexInByte = (BITS_IN_OCTAL * section) % BITS_IN_BYTE;
207	const unsigned char* startByte = octalCode + startAtByte;	207	const unsigned char* startByte = octalCode + startAtByte;
208		208
209	return sectionValue(startByte, startIndexInByte);	209	return sectionValue(startByte, startIndexInByte);
210	}	210	}
211		211
@@ -227,7 +227,7 @@ void setOctalCodeSectionValue(unsigned char* octalCode, int section, char sectio · 15 unmodified lines
227	unsigned char oldValue = *byteAt & ~shiftedMask;	227	unsigned char oldValue = *byteAt & ~shiftedMask;
228	unsigned char newValue = oldValue \| shiftedValue;	228	unsigned char newValue = oldValue \| shiftedValue;
229	*byteAt = newValue;	229	*byteAt = newValue;
230		230
231	// If the requested section is partially in the byte, then we	231	// If the requested section is partially in the byte, then we
232	// need to also set the portion of the section value in the next byte	232	// need to also set the portion of the section value in the next byte
233	// there's only two cases where this happens, if the bit in byte is	233	// there's only two cases where this happens, if the bit in byte is
@@ -255,7 +255,7 @@ unsigned char* chopOctalCode(const unsigned char* originalOctalCode, int chopLev · 21 unmodified lines
255	int newLength = codeLength - chopLevels;	255	int newLength = codeLength - chopLevels;
256	newCode = new unsigned char[newLength+1];	256	newCode = new unsigned char[newLength+1];
257	*newCode = newLength; // set the length byte	257	*newCode = newLength; // set the length byte
258		258
259	for (int section = chopLevels; section < codeLength; section++) {	259	for (int section = chopLevels; section < codeLength; section++) {
260	char sectionValue = getOctalCodeSectionValue(originalOctalCode, section);	260	char sectionValue = getOctalCodeSectionValue(originalOctalCode, section);
261	setOctalCodeSectionValue(newCode, section - chopLevels, sectionValue);	261	setOctalCodeSectionValue(newCode, section - chopLevels, sectionValue);
@@ -264,9 +264,9 @@ unsigned char* chopOctalCode(const unsigned char* originalOctalCode, int chopLev · 2 unmodified lines
264	return newCode;	264	return newCode;
265	}	265	}
266		266
267	unsigned char* rebaseOctalCode(const unsigned char* originalOctalCode, const unsigned char* newParentOctalCode,	267	unsigned char* rebaseOctalCode(const unsigned char* originalOctalCode, const unsigned char* newParentOctalCode,
268	bool includeColorSpace) {	268	bool includeColorSpace) {
269		269
270	int oldCodeLength = numberOfThreeBitSectionsInCode(originalOctalCode);	270	int oldCodeLength = numberOfThreeBitSectionsInCode(originalOctalCode);
271	int newParentCodeLength = numberOfThreeBitSectionsInCode(newParentOctalCode);	271	int newParentCodeLength = numberOfThreeBitSectionsInCode(newParentOctalCode);
272	int newCodeLength = newParentCodeLength + oldCodeLength;	272	int newCodeLength = newParentCodeLength + oldCodeLength;
@@ -298,12 +298,12 @@ bool isAncestorOf(const unsigned char* possibleAncestor, const unsigned char* po · 25 unmodified lines
298	}	298	}
299		299
300	int descendentCodeLength = numberOfThreeBitSectionsInCode(possibleDescendent);	300	int descendentCodeLength = numberOfThreeBitSectionsInCode(possibleDescendent);
301		301
302	// if the caller also include a child, then our descendent length is actually one extra!	302	// if the caller also include a child, then our descendent length is actually one extra!
303	if (descendentsChild != CHECK_NODE_ONLY) {	303	if (descendentsChild != CHECK_NODE_ONLY) {
304	descendentCodeLength++;	304	descendentCodeLength++;
305	}	305	}
306		306
307	if (ancestorCodeLength > descendentCodeLength) {	307	if (ancestorCodeLength > descendentCodeLength) {
308	return false; // if the descendent is shorter, it can't be a descendent	308	return false; // if the descendent is shorter, it can't be a descendent
309	}	309	}
@@ -322,7 +322,7 @@ bool isAncestorOf(const unsigned char* possibleAncestor, const unsigned char* po · 12 unmodified lines
322	return false; // first non-match, means they don't match	322	return false; // first non-match, means they don't match
323	}	323	}
324	}	324	}
325		325
326	// they all match, so we are an ancestor	326	// they all match, so we are an ancestor
327	return true;	327	return true;
328	}	328	}
@@ -335,7 +335,7 @@ unsigned char* hexStringToOctalCode(const QString& input) { · 6 unmodified lines
335		335
336	// allocate byte array based on half of string length	336	// allocate byte array based on half of string length
337	unsigned char* bytes = new unsigned char[(input.length()) / HEX_BYTE_SIZE];	337	unsigned char* bytes = new unsigned char[(input.length()) / HEX_BYTE_SIZE];
338		338
339	// loop through the string - 2 bytes at a time converting	339	// loop through the string - 2 bytes at a time converting
340	// it to decimal equivalent and store in byte array	340	// it to decimal equivalent and store in byte array
341	bool ok = false;	341	bool ok = false;
@@ -348,7 +348,7 @@ unsigned char* hexStringToOctalCode(const QString& input) { · 6 unmodified lines
348	stringIndex += HEX_BYTE_SIZE;	348	stringIndex += HEX_BYTE_SIZE;
349	byteArrayIndex++;	349	byteArrayIndex++;
350	}	350	}
351		351
352	// something went wrong	352	// something went wrong
353	if (!ok) {	353	if (!ok) {
354	delete[] bytes;	354	delete[] bytes;

@@ -127,7 +127,7 @@ void OctreeServer::resetSendingStats() { · 126 unmodified lines
127	_noProcessWait = 0;	127	_noProcessWait = 0;
128	}	128	}
129		129
130	void OctreeServer::trackEncodeTime(float time) {	130	void OctreeServer::trackEncodeTime(float time) {
131	const float MAX_SHORT_TIME = 10.0f;	131	const float MAX_SHORT_TIME = 10.0f;
132	const float MAX_LONG_TIME = 100.0f;	132	const float MAX_LONG_TIME = 100.0f;
133		133
@@ -144,10 +144,10 @@ void OctreeServer::trackEncodeTime(float time) { · 10 unmodified lines
144	_extraLongEncode++;	144	_extraLongEncode++;
145	_averageExtraLongEncodeTime.updateAverage(time);	145	_averageExtraLongEncodeTime.updateAverage(time);
146	}	146	}
147	_averageEncodeTime.updateAverage(time);	147	_averageEncodeTime.updateAverage(time);
148	}	148	}
149		149
150	void OctreeServer::trackTreeWaitTime(float time) {	150	void OctreeServer::trackTreeWaitTime(float time) {
151	const float MAX_SHORT_TIME = 10.0f;	151	const float MAX_SHORT_TIME = 10.0f;
152	const float MAX_LONG_TIME = 100.0f;	152	const float MAX_LONG_TIME = 100.0f;
153	if (time == SKIP_TIME) {	153	if (time == SKIP_TIME) {
@@ -166,7 +166,7 @@ void OctreeServer::trackTreeWaitTime(float time) { · 12 unmodified lines
166	_averageTreeWaitTime.updateAverage(time);	166	_averageTreeWaitTime.updateAverage(time);
167	}	167	}
168		168
169	void OctreeServer::trackCompressAndWriteTime(float time) {	169	void OctreeServer::trackCompressAndWriteTime(float time) {
170	const float MAX_SHORT_TIME = 10.0f;	170	const float MAX_SHORT_TIME = 10.0f;
171	const float MAX_LONG_TIME = 100.0f;	171	const float MAX_LONG_TIME = 100.0f;
172	if (time == SKIP_TIME) {	172	if (time == SKIP_TIME) {
@@ -182,19 +182,19 @@ void OctreeServer::trackCompressAndWriteTime(float time) { · 9 unmodified lines
182	_extraLongCompress++;	182	_extraLongCompress++;
183	_averageExtraLongCompressTime.updateAverage(time);	183	_averageExtraLongCompressTime.updateAverage(time);
184	}	184	}
185	_averageCompressAndWriteTime.updateAverage(time);	185	_averageCompressAndWriteTime.updateAverage(time);
186	}	186	}
187		187
188	void OctreeServer::trackPacketSendingTime(float time) {	188	void OctreeServer::trackPacketSendingTime(float time) {
189	if (time == SKIP_TIME) {	189	if (time == SKIP_TIME) {
190	_noSend++;	190	_noSend++;
191	time = 0.0f;	191	time = 0.0f;
192	}	192	}
193	_averagePacketSendingTime.updateAverage(time);	193	_averagePacketSendingTime.updateAverage(time);