diff --git a/applications/flyCam/cameraOn.wav b/applications/flyCam/cameraOn.wav
new file mode 100644
index 0000000..76dbb64
Binary files /dev/null and b/applications/flyCam/cameraOn.wav differ
diff --git a/applications/flyCam/flashOff.wav b/applications/flyCam/flashOff.wav
new file mode 100644
index 0000000..fef7668
Binary files /dev/null and b/applications/flyCam/flashOff.wav differ
diff --git a/applications/flyCam/flashOn.wav b/applications/flyCam/flashOn.wav
new file mode 100644
index 0000000..f7e95c9
Binary files /dev/null and b/applications/flyCam/flashOn.wav differ
diff --git a/applications/flyCam/flyCam-a.png b/applications/flyCam/flyCam-a.png
new file mode 100644
index 0000000..d5f905e
Binary files /dev/null and b/applications/flyCam/flyCam-a.png differ
diff --git a/applications/flyCam/flyCam-i.png b/applications/flyCam/flyCam-i.png
new file mode 100644
index 0000000..4b5acfd
Binary files /dev/null and b/applications/flyCam/flyCam-i.png differ
diff --git a/applications/flyCam/flyCamera.js b/applications/flyCam/flyCamera.js
new file mode 100644
index 0000000..a050e09
--- /dev/null
+++ b/applications/flyCam/flyCamera.js
@@ -0,0 +1,702 @@
+"use strict";
+/*jslint vars:true, plusplus:true, forin:true*/
+/*global Tablet, Script, */
+/* eslint indent: ["error", 4, { "outerIIFEBody": 0 }] */
+//
+// flyCamera.js
+//
+// Created by Alezia Kurdis, December 10th, 2023. (based on "Spectator Camera" by by Zach Fox on June 5th, 2017)
+// Copyright 2023, Overte e.V.
+//
+// Distributed under the Apache License, Version 2.0
+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+(function () { // BEGIN LOCAL_SCOPE
+
+ var ROOT = Script.resolvePath('').split("flyCamera.js")[0];
+
+ // FUNCTION VAR DECLARATIONS
+ var sendToQml, addOrRemoveButton, onTabletScreenChanged, fromQml,
+ onTabletButtonClicked, wireEventBridge, startup, shutdown, registerButtonMappings;
+
+ // Function Name: flyCameraOn()
+ //
+ // Description:
+ // -Call this function to set up the fly camera and spawn the camera entity.
+
+ var flyCameraConfig = Render.getConfig("SecondaryCamera");
+ var camera = false;
+ var cameraRotation;
+ var cameraPosition;
+
+ var cameraDistance = 3; //meters
+ var cameraHeight = 0; //meters
+ var cameraHorizontalAngle = 180; //degree
+ var cameraVerticalAngle = 0; //degree
+ var cameraTarget = "AVATAR"; //AVATAR | FORWARD | BACKWARD | OUTSIDE
+
+ var cameraViewWidth = 0.25;
+ var cameraViewAspect = 16/9;
+ var toneCurve = 1;
+ var cameraName = "Action Camera";
+
+ function flyCameraPositioningUpdate() {
+ if (camera) {
+ computeCamPosition();
+ Entities.editEntity(camera, {
+ "localRotation": cameraRotation,
+ "localPosition": cameraPosition
+ });
+ }
+ }
+
+ function computeCamPosition() {
+ var antiHorizontalAngle = cameraHorizontalAngle - 180;
+ if (antiHorizontalAngle < 0) {antiHorizontalAngle = antiHorizontalAngle + 360;}
+ switch(cameraTarget) {
+ case "AVATAR":
+ cameraRotation = Quat.fromVec3Degrees({ "x": -cameraVerticalAngle, "y": antiHorizontalAngle, "z": 0 });
+ break;
+ case "FORWARD":
+ cameraRotation = Quat.fromVec3Degrees({ "x": 0, "y": 0, "z": 0 });
+ break;
+ case "BACKWARD":
+ cameraRotation = Quat.fromVec3Degrees({ "x": 0, "y": 180, "z": 0 });
+ break;
+ case "OUTSIDE":
+ cameraRotation = Quat.fromVec3Degrees({ "x": cameraVerticalAngle, "y": cameraHorizontalAngle, "z": 0 });
+ break;
+ }
+ cameraPosition = Vec3.multiplyQbyV(Quat.fromVec3Degrees({ "x": cameraVerticalAngle, "y": cameraHorizontalAngle, "z": 0 }), { "x": 0, "y": cameraHeight, "z": -cameraDistance });
+ }
+
+ function flyCameraOn() {
+ cameraDistance = Settings.getValue('flyCamera/cameraDistance', 3); //meters
+ cameraHeight = Settings.getValue('flyCamera/cameraHeight', 0); //meters
+ cameraHorizontalAngle = Settings.getValue('flyCamera/cameraHorizontalAngle', 180); //degree
+ cameraVerticalAngle = Settings.getValue('flyCamera/cameraVerticalAngle', 0); //degree
+ cameraTarget = Settings.getValue('flyCamera/cameraTarget', "AVATAR"); //AVATAR | FORWARD | BACKWARD | OUTSIDE
+
+ Render.getConfig("SecondaryCameraJob.ToneMapping").curve = toneCurve;
+
+ // Sets the special texture size based on the window it is displayed in, which doesn't include the menu bar
+ flyCameraConfig.enableSecondaryCameraRenderConfigs(true);
+ flyCameraConfig.resetSizeSpectatorCamera(Window.innerWidth, Window.innerHeight);
+ computeCamPosition();
+ camera = Entities.addEntity({
+ "name": cameraName,
+ "dimensions": {
+ "x": 0.03,
+ "y": 0.03,
+ "z": 0.03
+ },
+ "color": {
+ "red": 0,
+ "green": 0,
+ "blue": 0
+ },
+ "canCastShadow": false,
+ "parentID": MyAvatar.SELF_ID,
+ "localRotation": cameraRotation,
+ "localPosition": cameraPosition,
+ "type": "Shape",
+ "shape": "Cube",
+ "grab": {
+ "grabbable": false
+ },
+ "isVisibleInSecondaryCamera": false,
+ "visible": false
+ }, "local");
+ flyCameraConfig.attachedEntityId = camera;
+ if (!HMD.active) {
+ setMonitorShowsCameraView(false);
+ } else {
+ setDisplay(monitorShowsCameraView);
+ }
+ // Change button to active when window is first opened OR if the camera is on, false otherwise.
+ if (button) {
+ button.editProperties({ isActive: onFlyCameraScreen || camera });
+ }
+ Audio.playSound(SOUND_CAMERA_ON, {
+ volume: 0.25,
+ position: cameraPosition,
+ localOnly: true
+ });
+
+ setSwitchViewControllerMappingStatus(true);
+ setTakeSnapshotControllerMappingStatus(true);
+ }
+
+ // Function Name: flyCameraOff()
+ //
+ // Description:
+ // -Call this function to shut down the fly camera and
+ // destroy the camera entity. "isChangingDomains" is true when this function is called
+ // from the "Window.domainChanged()" signal.
+ var WAIT_AFTER_DOMAIN_SWITCH_BEFORE_CAMERA_DELETE_MS = 1 * 1000;
+ function flyCameraOff(isChangingDomains) {
+ function deleteCamera() {
+ if (flash) {
+ Entities.deleteEntity(flash);
+ flash = false;
+ }
+ if (camera) {
+ Entities.deleteEntity(camera);
+ camera = false;
+ }
+ setSwitchViewControllerMappingStatus(false);
+ setTakeSnapshotControllerMappingStatus(false);
+
+ if (button) {
+ // Change button to active when window is first openend OR if the camera is on, false otherwise.
+ button.editProperties({ isActive: onFlyCameraScreen || camera });
+ }
+ }
+
+ flyCameraConfig.attachedEntityId = false;
+ flyCameraConfig.enableSecondaryCameraRenderConfigs(false);
+ if (camera) {
+ if (isChangingDomains) {
+ Script.setTimeout(function () {
+ deleteCamera();
+ flyCameraOn();
+ }, WAIT_AFTER_DOMAIN_SWITCH_BEFORE_CAMERA_DELETE_MS);
+ } else {
+ deleteCamera();
+ }
+ }
+ setDisplay(monitorShowsCameraView);
+ }
+
+ // Function Name: addOrRemoveButton()
+ //
+ // Description:
+ // -Used to add or remove the "FLY-CAM" app button from the HUD/tablet. Set the "isShuttingDown" argument
+ // to true if you're calling this function upon script shutdown. Set the "isHMDmode" to true if the user is
+ // in HMD; otherwise set to false.
+
+ var button = false;
+ var buttonName = "FLY-CAM";
+ function addOrRemoveButton(isShuttingDown) {
+ if (!tablet) {
+ print("Warning in addOrRemoveButton(): 'tablet' undefined!");
+ return;
+ }
+ if (!button) {
+ if (!isShuttingDown) {
+ button = tablet.addButton({
+ text: buttonName,
+ icon: ROOT + "flyCam-i.png",
+ activeIcon: ROOT + "flyCam-a.png"
+ });
+ button.clicked.connect(onTabletButtonClicked);
+ }
+ } else if (button) {
+ if (isShuttingDown) {
+ button.clicked.disconnect(onTabletButtonClicked);
+ tablet.removeButton(button);
+ button = false;
+ }
+ } else {
+ print("ERROR adding/removing FLY-CAM button!");
+ }
+ }
+
+ // Function Name: startup()
+ //
+ // Description:
+ // -startup() will be called when the script is loaded.
+
+ var tablet = null;
+ function startup() {
+ tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
+ addOrRemoveButton(false);
+ tablet.screenChanged.connect(onTabletScreenChanged);
+ Window.domainChanged.connect(onDomainChanged);
+ Controller.keyPressEvent.connect(keyPressEvent);
+ HMD.displayModeChanged.connect(onHMDChanged);
+ camera = false;
+ registerButtonMappings();
+ }
+
+ // Function Name: wireEventBridge()
+ //
+ // Description:
+ // -Used to connect/disconnect the script's response to the tablet's "fromQml" signal. Set the "on" argument to enable or
+ // disable to event bridge.
+
+ var hasEventBridge = false;
+ function wireEventBridge(on) {
+ if (!tablet) {
+ print("Warning in wireEventBridge(): 'tablet' undefined!");
+ return;
+ }
+ if (on) {
+ if (!hasEventBridge) {
+ tablet.fromQml.connect(fromQml);
+ hasEventBridge = true;
+ }
+ } else {
+ if (hasEventBridge) {
+ tablet.fromQml.disconnect(fromQml);
+ hasEventBridge = false;
+ }
+ }
+ }
+
+ // Function Name: setDisplay()
+ //
+ // Description:
+ // -There are two bool variables that determine what the "url" argument to "setDisplayTexture(url)" should be:
+ // Camera on/off switch, and the "Monitor Shows" on/off switch.
+ // This results in four possible cases for the argument. Those four cases are:
+ // 1. Camera is off; "Monitor Shows" is "HMD Preview": "url" is ""
+ // 2. Camera is off; "Monitor Shows" is "Camera View": "url" is ""
+ // 3. Camera is on; "Monitor Shows" is "HMD Preview": "url" is ""
+ // 4. Camera is on; "Monitor Shows" is "Camera View": "url" is "resource://spectatorCameraFrame"
+ function setDisplay(showCameraView) {
+ var url = (camera) ? (showCameraView ? "resource://spectatorCameraFrame" : "resource://hmdPreviewFrame") : "";
+
+ // FIXME: temporary hack to avoid setting the display texture to hmdPreviewFrame
+ // until it is the correct mono.
+ if (url === "resource://hmdPreviewFrame") {
+ Window.setDisplayTexture("");
+ } else {
+ Window.setDisplayTexture(url);
+ }
+ }
+ const MONITOR_SHOWS_CAMERA_VIEW_DEFAULT = false;
+ var monitorShowsCameraView = !!Settings.getValue('flyCamera/monitorShowsCameraView', MONITOR_SHOWS_CAMERA_VIEW_DEFAULT);
+ function setMonitorShowsCameraView(showCameraView) {
+ setDisplay(showCameraView);
+ monitorShowsCameraView = showCameraView;
+ Settings.setValue('flyCamera/monitorShowsCameraView', showCameraView);
+ }
+ function setMonitorShowsCameraViewAndSendToQml(showCameraView) {
+ setMonitorShowsCameraView(showCameraView);
+ sendToQml({ method: 'updateMonitorShowsSwitch', params: showCameraView });
+ }
+ function keyPressEvent(event) {
+ if ((event.text === "0") && !event.isAutoRepeat && !event.isShifted && !event.isMeta && event.isControl && !event.isAlt) {
+ setMonitorShowsCameraViewAndSendToQml(!monitorShowsCameraView);
+ }
+ }
+
+ function setSwitchViewControllerMappingStatus(status) {
+ if (!switchViewControllerMapping) {
+ return;
+ }
+ if (status) {
+ switchViewControllerMapping.enable();
+ } else {
+ switchViewControllerMapping.disable();
+ }
+ }
+
+ function setTakeSnapshotControllerMappingStatus(status) {
+ if (!takeSnapshotControllerMapping) {
+ return;
+ }
+ if (status) {
+ takeSnapshotControllerMapping.enable();
+ } else {
+ takeSnapshotControllerMapping.disable();
+ }
+ }
+
+ // Function Name: registerButtonMappings()
+ //
+ // Description:
+ // -Updates controller button mappings for fly Camera.
+
+ var switchViewControllerMapping;
+ var switchViewControllerMappingName = 'Hifi-flyCamera-Mapping-SwitchView';
+ function registerSwitchViewControllerMapping() {
+ switchViewControllerMapping = Controller.newMapping(switchViewControllerMappingName);
+ if (controllerType === "OculusTouch") {
+ switchViewControllerMapping.from(Controller.Standard.LS).to(function (value) {
+ if (value === 1.0) {
+ setMonitorShowsCameraViewAndSendToQml(!monitorShowsCameraView);
+ }
+ return;
+ });
+ } else if (controllerType === "Vive") {
+ switchViewControllerMapping.from(Controller.Standard.LeftPrimaryThumb).to(function (value) {
+ if (value === 1.0) {
+ setMonitorShowsCameraViewAndSendToQml(!monitorShowsCameraView);
+ }
+ return;
+ });
+ }
+ }
+ var takeSnapshotControllerMapping;
+ var takeSnapshotControllerMappingName = 'Hifi-flyCamera-Mapping-TakeSnapshot';
+
+ var flash = false;
+ function setFlashStatus(enabled) {
+ var cameraPosition = Entities.getEntityProperties(camera, ["positon"]).position;
+ if (enabled) {
+ if (camera) {
+ Audio.playSound(SOUND_FLASH_ON, {
+ position: cameraPosition,
+ localOnly: true,
+ volume: 0.8
+ });
+ flash = Entities.addEntity({
+ "collidesWith": "",
+ "collisionMask": 0,
+ "color": {
+ "blue": 173,
+ "green": 252,
+ "red": 255
+ },
+ "cutoff": 90,
+ "dimensions": {
+ "x": 4,
+ "y": 4,
+ "z": 4
+ },
+ "dynamic": false,
+ "falloffRadius": 0.20000000298023224,
+ "intensity": 37,
+ "isSpotlight": true,
+ "localRotation": { w: 1, x: 0, y: 0, z: 0 },
+ "localPosition": { x: 0, y: -0.005, z: -0.08 },
+ "name": "Camera Flash",
+ "type": "Light",
+ "parentID": camera,
+ }, true);
+ }
+ } else {
+ if (flash) {
+ Audio.playSound(SOUND_FLASH_OFF, {
+ position: cameraPosition,
+ localOnly: true,
+ volume: 0.8
+ });
+ Entities.deleteEntity(flash);
+ flash = false;
+ }
+ }
+ }
+
+ function onStillSnapshotTaken() {
+ Render.getConfig("SecondaryCameraJob.ToneMapping").curve = toneCurve;
+ sendToQml({
+ method: 'finishedProcessingStillSnapshot'
+ });
+ }
+ function maybeTakeSnapshot() {
+ if (camera) {
+ sendToQml({
+ method: 'startedProcessingStillSnapshot'
+ });
+
+ // Wait a moment before taking the snapshot for the tonemapping curve to update
+ Script.setTimeout(function () {
+ Audio.playSound(SOUND_SNAPSHOT, {
+ position: { x: MyAvatar.position.x, y: MyAvatar.position.y, z: MyAvatar.position.z },
+ localOnly: true,
+ volume: 1.0
+ });
+ Window.takeSecondaryCameraSnapshot();
+ }, 250);
+ } else {
+ sendToQml({
+ method: 'finishedProcessingStillSnapshot'
+ });
+ }
+ }
+ function on360SnapshotTaken() {
+ if (monitorShowsCameraView) {
+ setDisplay(true);
+ }
+ sendToQml({
+ method: 'finishedProcessing360Snapshot'
+ });
+ }
+ function maybeTake360Snapshot() {
+ if (camera) {
+ Audio.playSound(SOUND_SNAPSHOT, {
+ position: { x: MyAvatar.position.x, y: MyAvatar.position.y, z: MyAvatar.position.z },
+ localOnly: true,
+ volume: 1.0
+ });
+ if (HMD.active && monitorShowsCameraView) {
+ setDisplay(false);
+ }
+ Window.takeSecondaryCamera360Snapshot(Entities.getEntityProperties(camera, ["positon"]).position);
+ }
+ }
+ function registerTakeSnapshotControllerMapping() {
+ takeSnapshotControllerMapping = Controller.newMapping(takeSnapshotControllerMappingName);
+ if (controllerType === "OculusTouch") {
+ takeSnapshotControllerMapping.from(Controller.Standard.RS).to(function (value) {
+ if (value === 1.0) {
+ maybeTakeSnapshot();
+ }
+ return;
+ });
+ } else if (controllerType === "Vive") {
+ takeSnapshotControllerMapping.from(Controller.Standard.RightPrimaryThumb).to(function (value) {
+ if (value === 1.0) {
+ maybeTakeSnapshot();
+ }
+ return;
+ });
+ }
+ }
+ var controllerType = "Other";
+ function registerButtonMappings() {
+ var VRDevices = Controller.getDeviceNames().toString();
+ if (VRDevices) {
+ if (VRDevices.indexOf("Vive") !== -1) {
+ controllerType = "Vive";
+ } else if (VRDevices.indexOf("OculusTouch") !== -1) {
+ controllerType = "OculusTouch";
+ } else {
+ sendToQml({
+ method: 'updateControllerMappingCheckbox',
+ controller: controllerType
+ });
+ return; // Neither Vive nor Touch detected
+ }
+ }
+
+ if (!switchViewControllerMapping) {
+ registerSwitchViewControllerMapping();
+ }
+ setSwitchViewControllerMappingStatus(true);
+
+ if (!takeSnapshotControllerMapping) {
+ registerTakeSnapshotControllerMapping();
+ }
+ setTakeSnapshotControllerMappingStatus(true);
+
+ sendToQml({
+ method: 'updateControllerMappingCheckbox',
+ controller: controllerType
+ });
+ }
+
+ // Function Name: onTabletButtonClicked()
+ //
+ // Description:
+ // -Fired when the fly Camera app button is pressed.
+ //
+ // Relevant Variables:
+ // -FLY_CAMERA_QML_SOURCE: The path to the flyCamera QML
+ // -onFlyCameraScreen: true/false depending on whether we're looking at the fly camera app.
+ var FLY_CAMERA_QML_SOURCE = Script.resolvePath("flyCamera.qml");
+ var onFlyCameraScreen = false;
+ function onTabletButtonClicked() {
+ if (!tablet) {
+ print("Warning in onTabletButtonClicked(): 'tablet' undefined!");
+ return;
+ }
+ if (onFlyCameraScreen) {
+ // for toolbar-mode: go back to home screen, this will close the window.
+ tablet.gotoHomeScreen();
+ } else {
+ tablet.loadQMLSource(FLY_CAMERA_QML_SOURCE);
+ }
+ }
+
+ function updateFlyCameraQML() {
+ var messageToQML = {
+ "method": 'initializeUI',
+ "masterSwitchOn": !!camera,
+ "flashCheckboxChecked": !!flash,
+ "monitorShowsCamView": monitorShowsCameraView,
+ "cameraDistance": cameraDistance,
+ "cameraTarget": cameraTarget,
+ "cameraHorizontalAngle": cameraHorizontalAngle,
+ "cameraVerticalAngle": cameraVerticalAngle
+ };
+ sendToQml(messageToQML);
+ registerButtonMappings();
+ Menu.setIsOptionChecked("Disable Preview", false);
+ Menu.setIsOptionChecked("Mono Preview", true);
+ }
+
+ var signalsWired = false;
+ function wireSignals(shouldWire) {
+ if (signalsWired === shouldWire) {
+ return;
+ }
+
+ signalsWired = shouldWire;
+
+ if (shouldWire) {
+ Window.stillSnapshotTaken.connect(onStillSnapshotTaken);
+ Window.snapshot360Taken.connect(on360SnapshotTaken);
+ } else {
+ Window.stillSnapshotTaken.disconnect(onStillSnapshotTaken);
+ Window.snapshot360Taken.disconnect(on360SnapshotTaken);
+ }
+ }
+
+ // Function Name: onTabletScreenChanged()
+ //
+ // Description:
+ // -Called when the TabletScriptingInterface::screenChanged() signal is emitted. The "type" argument can be either the string
+ // value of "Home", "Web", "Menu", "QML", or "Closed". The "url" argument is only valid for Web and QML.
+ function onTabletScreenChanged(type, url) {
+ onFlyCameraScreen = (type === "QML" && url === FLY_CAMERA_QML_SOURCE);
+ wireEventBridge(onFlyCameraScreen);
+ // Change button to active when window is first openend OR if the camera is on, false otherwise.
+ if (button) {
+ button.editProperties({ isActive: onFlyCameraScreen || camera });
+ }
+
+ // In the case of a remote QML app, it takes a bit of time
+ // for the event bridge to actually connect, so we have to wait...
+ Script.setTimeout(function () {
+ if (onFlyCameraScreen) {
+ updateFlyCameraQML();
+ }
+ }, 700);
+
+ wireSignals(onFlyCameraScreen);
+ }
+
+ // Function Name: sendToQml()
+ //
+ // Description:
+ // -Use this function to send a message to the QML (i.e. to change appearances). The "message" argument is what is sent to
+ // flyCamera QML in the format "{method, params}", like json-rpc. See also fromQml().
+ function sendToQml(message) {
+ if (onFlyCameraScreen) {
+ tablet.sendToQml(message);
+ }
+ }
+
+ // Function Name: fromQml()
+ //
+ // Description:
+ // -Called when a message is received from flyCamera.qml. The "message" argument is what is sent from the flyCamera QML
+ // in the format "{method, params}", like json-rpc. See also sendToQml().
+ function fromQml(message) {
+ switch (message.method) {
+ case 'flyCameraOn':
+ flyCameraOn();
+ break;
+ case 'flyCameraOff':
+ flyCameraOff();
+ break;
+ case 'setMonitorShowsCameraView':
+ setMonitorShowsCameraView(message.params);
+ break;
+ case 'updateCameravFoV':
+ flyCameraConfig.vFoV = message.vFoV;
+ break;
+ case 'updateToneMap':
+ toneCurve = message.toneCurve;
+ Render.getConfig("SecondaryCameraJob.ToneMapping").curve = toneCurve;
+ break;
+ case 'setFlashStatus':
+ setFlashStatus(message.enabled);
+ break;
+ case 'updateCameraHorAngle':
+ cameraHorizontalAngle = message.horAngle;
+ Settings.setValue('flyCamera/cameraHorizontalAngle', cameraHorizontalAngle);
+ flyCameraPositioningUpdate();
+ break;
+ case 'updateCameraVertAngle':
+ cameraVerticalAngle = message.vertAngle;
+ Settings.setValue('flyCamera/cameraVerticalAngle', cameraVerticalAngle);
+ flyCameraPositioningUpdate();
+ break;
+ case 'updateCameraDist':
+ cameraDistance = Math.floor(message.distance*10)/10;
+ Settings.setValue('flyCamera/cameraDistance', cameraDistance);
+ flyCameraPositioningUpdate();
+ break;
+ case 'updateCameraTarget':
+ cameraTarget = message.target;
+ Settings.setValue('flyCamera/cameraTarget', cameraTarget);
+ flyCameraPositioningUpdate();
+ break;
+ case 'updateCameraHeight':
+ cameraHeight = Math.floor(message.height*100)/100;
+ Settings.setValue('flyCamera/cameraHeight', cameraHeight);
+ flyCameraPositioningUpdate();
+ break;
+ case 'takeSecondaryCameraSnapshot':
+ maybeTakeSnapshot();
+ break;
+ case 'takeSecondaryCamera360Snapshot':
+ maybeTake360Snapshot();
+ break;
+ case 'openSettings':
+ if ((HMD.active && Settings.getValue("hmdTabletBecomesToolbar", false))
+ || (!HMD.active && Settings.getValue("desktopTabletBecomesToolbar", true))) {
+ Desktop.show("hifi/dialogs/GeneralPreferencesDialog.qml", "GeneralPreferencesDialog");
+ } else {
+ tablet.pushOntoStack("hifi/tablet/TabletGeneralPreferences.qml");
+ }
+ break;
+ default:
+ print('Unrecognized message from flyCamera.qml:', JSON.stringify(message));
+ }
+ }
+
+ // Function Name: onHMDChanged()
+ //
+ // Description:
+ // -Called from C++ when HMD mode is changed. The argument "isHMDMode" is true if HMD is on; false otherwise.
+ function onHMDChanged(isHMDMode) {
+ registerButtonMappings();
+ if (!isHMDMode) {
+ setMonitorShowsCameraView(false);
+ } else {
+ setDisplay(monitorShowsCameraView);
+ }
+ }
+
+ // Function Name: shutdown()
+ //
+ // Description:
+ // -shutdown() will be called when the script ends (i.e. is stopped).
+ function shutdown() {
+ flyCameraOff();
+ Window.domainChanged.disconnect(onDomainChanged);
+ wireSignals(false);
+ if (tablet) {
+ tablet.screenChanged.disconnect(onTabletScreenChanged);
+ if (onFlyCameraScreen) {
+ tablet.gotoHomeScreen();
+ }
+ }
+ addOrRemoveButton(true);
+ HMD.displayModeChanged.disconnect(onHMDChanged);
+ Controller.keyPressEvent.disconnect(keyPressEvent);
+ if (switchViewControllerMapping) {
+ switchViewControllerMapping.disable();
+ }
+ if (takeSnapshotControllerMapping) {
+ takeSnapshotControllerMapping.disable();
+ }
+ Script.scriptEnding.disconnect(shutdown);
+ }
+
+ // Function Name: onDomainChanged()
+ //
+ // Description:
+ // -A small utility function used when the Window.domainChanged() signal is fired.
+ function onDomainChanged() {
+ flyCameraOff(true);
+ }
+
+
+
+ // These functions will be called when the script is loaded.
+ var SOUND_CAMERA_ON = SoundCache.getSound(Script.resolvePath("cameraOn.wav"));
+ var SOUND_SNAPSHOT = SoundCache.getSound(Script.resolvePath("snap.wav"));
+ var SOUND_FLASH_ON = SoundCache.getSound(Script.resolvePath("flashOn.wav"));
+ var SOUND_FLASH_OFF = SoundCache.getSound(Script.resolvePath("flashOff.wav"));
+ startup();
+ Script.scriptEnding.connect(shutdown);
+
+}());
diff --git a/applications/flyCam/flyCamera.qml b/applications/flyCam/flyCamera.qml
new file mode 100644
index 0000000..d7961cf
--- /dev/null
+++ b/applications/flyCam/flyCamera.qml
@@ -0,0 +1,1000 @@
+//
+// flyCamera.qml
+// qml/hifi
+//
+// Created by Alezia Kurdis, December 10th, 2023. (based on "Spectator Camera" by by Zach Fox on June 5th, 2017)
+// Copyright 2023, Overte e.V.
+//
+// Distributed under the Apache License, Version 2.0.
+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+//#####################################################################
+import Hifi 1.0 as Hifi
+import QtQuick 2.7
+import QtQuick.Controls 2.2
+import QtGraphicalEffects 1.0
+
+import stylesUit 1.0 as HifiStylesUit
+import controlsUit 1.0 as HifiControlsUit
+import controls 1.0 as HifiControls
+import "qrc:////qml//hifi" as Hifi
+
+Rectangle {
+ HifiStylesUit.HifiConstants { id: hifi; }
+
+ id: root;
+ property bool uiReady: false;
+ property bool processingStillSnapshot: false;
+ property bool processing360Snapshot: false;
+ // Style
+ color: "#404040";
+
+ // The letterbox used for popup messages
+ Hifi.LetterboxMessage {
+ id: letterboxMessage;
+ z: 998; // Force the popup on top of everything else
+ }
+ function letterbox(headerGlyph, headerText, message) {
+ letterboxMessage.headerGlyph = headerGlyph;
+ letterboxMessage.headerText = headerText;
+ letterboxMessage.text = message;
+ letterboxMessage.visible = true;
+ letterboxMessage.popupRadius = 0;
+ }
+
+ //
+ // TITLE BAR START
+ //
+ Rectangle {
+ id: titleBarContainer;
+ // Size
+ width: root.width;
+ height: 60;
+ // Anchors
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ color: "#121212";
+
+ // "Fly Camera" text
+ HifiStylesUit.RalewaySemiBold {
+ id: titleBarText;
+ text: "Action Camera";
+ // Anchors
+ anchors.left: parent.left;
+ anchors.leftMargin: 30;
+ width: paintedWidth;
+ height: parent.height;
+ size: 22;
+ // Style
+ color: hifi.colors.white;
+ // Alignment
+ horizontalAlignment: Text.AlignHLeft;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ Switch {
+ id: masterSwitch;
+ focusPolicy: Qt.ClickFocus;
+ width: 65;
+ height: 30;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.right: parent.right;
+ anchors.rightMargin: 30;
+ hoverEnabled: true;
+
+ onHoveredChanged: {
+ if (hovered) {
+ switchHandle.color = hifi.colors.blueHighlight;
+ } else {
+ switchHandle.color = hifi.colors.lightGray;
+ }
+ }
+
+ onClicked: {
+ if (!checked) {
+ flashCheckBox.checked = false;
+ }
+ sendToScript({method: (checked ? 'flyCameraOn' : 'flyCameraOff')});
+ sendToScript({method: 'updateCameravFoV', vFoV: fieldOfViewSlider.value});
+ }
+
+ background: Rectangle {
+ color: parent.checked ? "#1FC6A6" : hifi.colors.white;
+ implicitWidth: masterSwitch.width;
+ implicitHeight: masterSwitch.height;
+ radius: height/2;
+ }
+
+ indicator: Rectangle {
+ id: switchHandle;
+ implicitWidth: masterSwitch.height - 4;
+ implicitHeight: implicitWidth;
+ radius: implicitWidth/2;
+ border.color: "#E3E3E3";
+ color: "#404040";
+ x: Math.max(4, Math.min(parent.width - width - 4, parent.visualPosition * parent.width - (width / 2) - 4))
+ y: parent.height / 2 - height / 2;
+ Behavior on x {
+ enabled: !masterSwitch.down
+ SmoothedAnimation { velocity: 200 }
+ }
+
+ }
+ }
+ }
+ //
+ // TITLE BAR END
+ //
+
+ Rectangle {
+ z: 999;
+ id: processingSnapshot;
+ anchors.fill: parent;
+ visible: root.processing360Snapshot || !root.uiReady;
+ color: Qt.rgba(0.0, 0.0, 0.0, 0.85);
+
+ // This object is always used in a popup.
+ // This MouseArea is used to prevent a user from being
+ // able to click on a button/mouseArea underneath the popup/section.
+ MouseArea {
+ anchors.fill: parent;
+ hoverEnabled: true;
+ propagateComposedEvents: false;
+ }
+
+ AnimatedImage {
+ id: processingImage;
+ source: "processing.gif"
+ width: 74;
+ height: width;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.horizontalCenter: parent.horizontalCenter;
+ }
+
+ HifiStylesUit.RalewaySemiBold {
+ text: root.uiReady ? "Processing..." : "";
+ // Anchors
+ anchors.top: processingImage.bottom;
+ anchors.topMargin: 4;
+ anchors.horizontalCenter: parent.horizontalCenter;
+ width: paintedWidth;
+ // Text size
+ size: 26;
+ // Style
+ color: hifi.colors.white;
+ verticalAlignment: Text.AlignVCenter;
+ }
+ }
+
+ //
+ // CONTROLS START
+ //
+ Item {
+ id: flyCamControlsContainer;
+ // Anchors
+ anchors.top: titleBarContainer.bottom;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ anchors.bottom: parent.bottom;
+
+ // Instructions or Preview
+ Rectangle {
+ id: flyCameraImageContainer;
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ anchors.right: parent.right;
+ height: 250;
+ color: masterSwitch.checked ? "transparent" : "black";
+
+ AnimatedImage {
+ source: "static.gif"
+ visible: !masterSwitch.checked;
+ anchors.fill: parent;
+ opacity: 0.15;
+ }
+
+ // Instructions (visible when display texture isn't set)
+ HifiStylesUit.FiraSansRegular {
+ id: flyCameraInstructions;
+ text: "Turn on Fly Camera for a preview\nof " + (HMD.active ? "what your monitor shows." : "the camera's view.");
+ size: 16;
+ color: hifi.colors.white;
+ visible: !masterSwitch.checked;
+ anchors.fill: parent;
+ horizontalAlignment: Text.AlignHCenter;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiStylesUit.FiraSansRegular {
+ text: ":)";
+ size: 28;
+ color: hifi.colors.white;
+ visible: root.processing360Snapshot || root.processingStillSnapshot;
+ anchors.fill: parent;
+ horizontalAlignment: Text.AlignHCenter;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ // Fly Camera Preview
+ Hifi.ResourceImageItem {
+ id: flyCameraPreview;
+ visible: masterSwitch.checked && !root.processing360Snapshot && !root.processingStillSnapshot;
+ url: showCameraView.checked || !HMD.active ? "resource://spectatorCameraFrame" : "resource://hmdPreviewFrame";
+ ready: masterSwitch.checked;
+ mirrorVertically: true;
+ anchors.fill: parent;
+ onVisibleChanged: {
+ ready = masterSwitch.checked;
+ update();
+ }
+ }
+
+ Item {
+ visible: HMD.active;
+ anchors.top: parent.top;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: 40;
+
+ LinearGradient {
+ anchors.fill: parent;
+ start: Qt.point(0, 0);
+ end: Qt.point(0, height);
+ gradient: Gradient {
+ GradientStop { position: 0.0; color: hifi.colors.black }
+ GradientStop { position: 1.0; color: Qt.rgba(0, 0, 0, 0) }
+ }
+ }
+
+ HifiStylesUit.HiFiGlyphs {
+ id: monitorShowsSwitchLabelGlyph;
+ text: hifi.glyphs.screen;
+ size: 32;
+ color: hifi.colors.white;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.left: parent.left;
+ anchors.leftMargin: 16;
+ }
+ HifiStylesUit.RalewayLight {
+ id: monitorShowsSwitchLabel;
+ text: "Monitor View:";
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.left: monitorShowsSwitchLabelGlyph.right;
+ anchors.leftMargin: 8;
+ size: 20;
+ width: paintedWidth;
+ height: parent.height;
+ color: hifi.colors.white;
+ verticalAlignment: Text.AlignVCenter;
+ }
+ Item {
+ anchors.left: monitorShowsSwitchLabel.right;
+ anchors.leftMargin: 14;
+ anchors.right: parent.right;
+ anchors.rightMargin: 10;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+
+ HifiControlsUit.RadioButton {
+ id: showCameraView;
+ text: "Camera View";
+ width: 125;
+ anchors.left: parent.left;
+ anchors.leftMargin: 10;
+ anchors.verticalCenter: parent.verticalCenter;
+ colorScheme: hifi.colorSchemes.dark;
+ onClicked: {
+ if (showHmdPreview.checked) {
+ showHmdPreview.checked = false;
+ }
+ if (!showCameraView.checked && !showHmdPreview.checked) {
+ showCameraView.checked = true;
+ }
+ }
+ onCheckedChanged: {
+ if (checked) {
+ sendToScript({method: 'setMonitorShowsCameraView', params: true});
+ }
+ }
+ }
+
+ HifiControlsUit.RadioButton {
+ id: showHmdPreview;
+ text: "VR Preview";
+ anchors.left: showCameraView.right;
+ anchors.leftMargin: 10;
+ width: 125;
+ anchors.verticalCenter: parent.verticalCenter;
+ colorScheme: hifi.colorSchemes.dark;
+ onClicked: {
+ if (showCameraView.checked) {
+ showCameraView.checked = false;
+ }
+ if (!showCameraView.checked && !showHmdPreview.checked) {
+ showHmdPreview.checked = true;
+ }
+ }
+ onCheckedChanged: {
+ if (checked) {
+ sendToScript({method: 'setMonitorShowsCameraView', params: false});
+ }
+ }
+ }
+ }
+ }
+
+ HifiStylesUit.HiFiGlyphs {
+ id: flashGlyph;
+ visible: flashCheckBox.visible;
+ text: hifi.glyphs.lightning;
+ size: 26;
+ color: hifi.colors.white;
+ anchors.verticalCenter: flashCheckBox.verticalCenter;
+ anchors.right: flashCheckBox.left;
+ anchors.rightMargin: -2;
+ }
+ HifiControlsUit.CheckBox {
+ id: flashCheckBox;
+ visible: masterSwitch.checked;
+ color: hifi.colors.white;
+ colorScheme: hifi.colorSchemes.dark;
+ anchors.right: takeSnapshotButton.left;
+ anchors.rightMargin: -8;
+ anchors.verticalCenter: takeSnapshotButton.verticalCenter;
+ boxSize: 22;
+ onClicked: {
+ sendToScript({method: 'setFlashStatus', enabled: checked});
+ }
+ }
+ HifiControlsUit.Button {
+ id: takeSnapshotButton;
+ enabled: masterSwitch.checked;
+ text: "SNAP PICTURE";
+ colorScheme: hifi.colorSchemes.light;
+ color: hifi.buttons.white;
+ anchors.bottom: parent.bottom;
+ anchors.bottomMargin: 8;
+ anchors.right: take360SnapshotButton.left;
+ anchors.rightMargin: 12;
+ width: 100;
+ height: 22;
+ onClicked: {
+ root.processingStillSnapshot = true;
+ sendToScript({method: 'takeSecondaryCameraSnapshot'});
+ }
+ }
+ HifiControlsUit.Button {
+ id: take360SnapshotButton;
+ enabled: masterSwitch.checked;
+ text: "SNAP 360";
+ colorScheme: hifi.colorSchemes.light;
+ color: hifi.buttons.white;
+ anchors.bottom: parent.bottom;
+ anchors.bottomMargin: 8;
+ anchors.right: parent.right;
+ anchors.rightMargin: 26;
+ width: 100;
+ height: 22;
+ onClicked: {
+ root.processing360Snapshot = true;
+ sendToScript({method: 'takeSecondaryCamera360Snapshot'});
+ }
+ }
+ }
+
+ Item {
+ anchors.top: flyCameraImageContainer.bottom;
+ anchors.topMargin: 8;
+ anchors.left: parent.left;
+ anchors.leftMargin: 26;
+ anchors.right: parent.right;
+ anchors.rightMargin: 26;
+ anchors.bottom: parent.bottom;
+
+ Item {
+ id: fieldOfView;
+ visible: masterSwitch.checked;
+ anchors.top: parent.top;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: 30;
+
+ HifiStylesUit.RalewaySemiBold {
+ id: fieldOfViewLabel;
+ text: "Field of View (" + fieldOfViewSlider.value + "\u00B0): ";
+ size: 16;
+ color: hifi.colors.white;
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ width: 172;
+ horizontalAlignment: Text.AlignLeft;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiControlsUit.Slider {
+ id: fieldOfViewSlider;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.right: resetvFoV.left;
+ anchors.rightMargin: 8;
+ anchors.left: fieldOfViewLabel.right;
+ anchors.leftMargin: 8;
+ colorScheme: hifi.colorSchemes.dark;
+ from: 10.0;
+ to: 120.0;
+ value: 45.0;
+ stepSize: 1;
+
+ onValueChanged: {
+ sendToScript({method: 'updateCameravFoV', vFoV: value});
+ }
+ onPressedChanged: {
+ if (!pressed) {
+ sendToScript({method: 'updateCameravFoV', vFoV: value});
+ }
+ }
+ }
+
+ HifiControlsUit.GlyphButton {
+ id: resetvFoV;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.right: parent.right;
+ anchors.rightMargin: -8;
+ height: parent.height - 8;
+ width: height;
+ glyph: hifi.glyphs.reload;
+ onClicked: {
+ fieldOfViewSlider.value = 45.0;
+ }
+ }
+ }
+
+//------------------------------------------------------------------------------------------
+ Item {
+ id: toneMap;
+ visible: masterSwitch.checked;
+ anchors.top: fieldOfView.bottom;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: 30;
+
+ HifiStylesUit.RalewaySemiBold {
+ id: toneMapLabel;
+ text: "Tone mapping curve: " + toneMapSlider.value;
+ size: 16;
+ color: hifi.colors.white;
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ width: 172;
+ horizontalAlignment: Text.AlignLeft;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiControlsUit.Slider {
+ id: toneMapSlider;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.right: resetToneMap.left;
+ anchors.rightMargin: 8;
+ anchors.left: toneMapLabel.right;
+ anchors.leftMargin: 8;
+ colorScheme: hifi.colorSchemes.dark;
+ from: 0.0;
+ to: 3.0;
+ value: 1.0;
+ stepSize: 1;
+
+ onValueChanged: {
+ sendToScript({method: 'updateToneMap', toneCurve: value});
+ }
+ onPressedChanged: {
+ if (!pressed) {
+ sendToScript({method: 'updateToneMap', toneCurve: value});
+ }
+ }
+ }
+
+ HifiControlsUit.GlyphButton {
+ id: resetToneMap;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.right: parent.right;
+ anchors.rightMargin: -8;
+ height: parent.height - 8;
+ width: height;
+ glyph: hifi.glyphs.reload;
+ onClicked: {
+ toneMapSlider.value = 1.0;
+ }
+ }
+ }
+
+//====================================================== CAMERA POSITIONING ========
+
+ Item {
+ id: positioningContainer;
+ visible: masterSwitch.checked;
+ anchors.top: toneMap.bottom;
+ anchors.topMargin: 16;
+ anchors.left: parent.left;
+ anchors.leftMargin: 0;
+ anchors.right: parent.right;
+ anchors.rightMargin: 0;
+ anchors.bottom: parent.bottom;
+
+ Item {
+ id: relativeHorizontalAngle;
+ anchors.top: parent.top;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: 30;
+
+ HifiStylesUit.RalewaySemiBold {
+ id: relativeHorizontalAngleLabel;
+ text: "Horizontal Angle (" + relativeHorizontalAngleSlider.value + "\u00B0): ";
+ size: 16;
+ color: hifi.colors.white;
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ width: 172;
+ horizontalAlignment: Text.AlignLeft;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiControlsUit.Slider {
+ id: relativeHorizontalAngleSlider;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.right: resetHorAngle.left;
+ anchors.rightMargin: 8;
+ anchors.left: relativeHorizontalAngleLabel.right;
+ anchors.leftMargin: 8;
+ colorScheme: hifi.colorSchemes.dark;
+ from: 0.0;
+ to: 360.0;
+ value: 180.0;
+ stepSize: 1;
+
+ onValueChanged: {
+ sendToScript({method: 'updateCameraHorAngle', horAngle: value});
+ }
+ onPressedChanged: {
+ if (!pressed) {
+ sendToScript({method: 'updateCameraHorAngle', horAngle: value});
+ }
+ }
+ }
+
+ HifiControlsUit.GlyphButton {
+ id: resetHorAngle;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.right: parent.right;
+ anchors.rightMargin: -8;
+ height: parent.height - 8;
+ width: height;
+ glyph: hifi.glyphs.reload;
+ onClicked: {
+ relativeHorizontalAngleSlider.value = 180.0;
+ }
+ }
+ }
+
+ //-----------------
+
+ Item {
+ id: relativeVerticalAngle;
+ anchors.top: relativeHorizontalAngle.bottom;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: 30;
+
+ HifiStylesUit.RalewaySemiBold {
+ id: relativeVerticalAngleLabel;
+ text: "Vertical Angle (" + relativeVerticalAngleSlider.value + "\u00B0): ";
+ size: 16;
+ color: hifi.colors.white;
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ width: 172;
+ horizontalAlignment: Text.AlignLeft;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiControlsUit.Slider {
+ id: relativeVerticalAngleSlider;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.right: resetVertAngle.left;
+ anchors.rightMargin: 8;
+ anchors.left: relativeVerticalAngleLabel.right;
+ anchors.leftMargin: 8;
+ colorScheme: hifi.colorSchemes.dark;
+ from: -180.0;
+ to: 180.0;
+ value: 0.0;
+ stepSize: 1;
+
+ onValueChanged: {
+ sendToScript({method: 'updateCameraVertAngle', vertAngle: value});
+ }
+ onPressedChanged: {
+ if (!pressed) {
+ sendToScript({method: 'updateCameraVertAngle', vertAngle: value});
+ }
+ }
+ }
+
+ HifiControlsUit.GlyphButton {
+ id: resetVertAngle;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.right: parent.right;
+ anchors.rightMargin: -8;
+ height: parent.height - 8;
+ width: height;
+ glyph: hifi.glyphs.reload;
+ onClicked: {
+ relativeVerticalAngleSlider.value = 0.0;
+ }
+ }
+ }
+ //--------------------------------
+
+ Item {
+ id: camDistance;
+ anchors.top: relativeVerticalAngle.bottom;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: 30;
+
+ HifiStylesUit.RalewaySemiBold {
+ id: camDistanceLabel;
+ text: "Distance (" + camDistanceSlider.value.toFixed(1) + " m): ";
+ size: 16;
+ color: hifi.colors.white;
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ width: 172;
+ horizontalAlignment: Text.AlignLeft;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiControlsUit.Slider {
+ id: camDistanceSlider;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.right: resetCamDistance.left;
+ anchors.rightMargin: 8;
+ anchors.left: camDistanceLabel.right;
+ anchors.leftMargin: 8;
+ colorScheme: hifi.colorSchemes.dark;
+ from: 0.3;
+ to: 30.0;
+ value: 3.0;
+ stepSize: 0.1;
+
+ onValueChanged: {
+ sendToScript({method: 'updateCameraDist', distance: value});
+ }
+ onPressedChanged: {
+ if (!pressed) {
+ sendToScript({method: 'updateCameraDist', distance: value});
+ }
+ }
+ }
+
+ HifiControlsUit.GlyphButton {
+ id: resetCamDistance;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.right: parent.right;
+ anchors.rightMargin: -8;
+ height: parent.height - 8;
+ width: height;
+ glyph: hifi.glyphs.reload;
+ onClicked: {
+ camDistanceSlider.value = 3.0;
+ }
+ }
+ }
+
+ //--------------------------------
+
+ Item {
+ id: camHeight;
+ anchors.top: camDistance.bottom;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: 30;
+
+ HifiStylesUit.RalewaySemiBold {
+ id: camHeightLabel;
+ text: "Height (" + camHeightSlider.value.toFixed(2) + " m): ";
+ size: 16;
+ color: hifi.colors.white;
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ width: 172;
+ horizontalAlignment: Text.AlignLeft;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiControlsUit.Slider {
+ id: camHeightSlider;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.right: resetCamHeight.left;
+ anchors.rightMargin: 8;
+ anchors.left: camHeightLabel.right;
+ anchors.leftMargin: 8;
+ colorScheme: hifi.colorSchemes.dark;
+ from: -3.00;
+ to: 6.00;
+ value: 0.00;
+ stepSize: 0.01;
+
+ onValueChanged: {
+ sendToScript({method: 'updateCameraHeight', height: value});
+ }
+ onPressedChanged: {
+ if (!pressed) {
+ sendToScript({method: 'updateCameraHeight', height: value});
+ }
+ }
+ }
+
+ HifiControlsUit.GlyphButton {
+ id: resetCamHeight;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.right: parent.right;
+ anchors.rightMargin: -8;
+ height: parent.height - 8;
+ width: height;
+ glyph: hifi.glyphs.reload;
+ onClicked: {
+ camHeightSlider.value = 0.00;
+ }
+ }
+ }
+
+ //--------------------------------
+
+ Item {
+ id: camTarget;
+ anchors.top: camHeight.bottom;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: 30;
+
+ HifiStylesUit.RalewaySemiBold {
+ id: camTargetLabel;
+ text: "Target: ";
+ size: 16;
+ color: hifi.colors.white;
+ anchors.left: parent.left;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ width: 172;
+ horizontalAlignment: Text.AlignLeft;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiControlsUit.GlyphButton {
+ id: camTargetAntiSwapper;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.left: camTargetLabel.right;
+ anchors.leftMargin: 12;
+ height: parent.height - 8;
+ width: height;
+ glyph: hifi.glyphs.backward;
+ onClicked: {
+ switch (camTargetValue.text) {
+ case "AVATAR":
+ camTargetValue.text = "OUTSIDE";
+ break;
+ case "FORWARD":
+ camTargetValue.text = "AVATAR";
+ break;
+ case "BACKWARD":
+ camTargetValue.text = "FORWARD";
+ break;
+ case "OUTSIDE":
+ camTargetValue.text = "BACKWARD";
+ break;
+ }
+ sendToScript({method: 'updateCameraTarget', target: camTargetValue.text});
+ }
+ }
+
+
+ HifiStylesUit.RalewaySemiBold {
+ id: camTargetValue;
+ visible: true;
+ text: "";
+ size: 16;
+ color: hifi.colors.white;
+ anchors.top: parent.top;
+ anchors.bottom: parent.bottom;
+ anchors.right: camTargetSwapper.left;
+ anchors.rightMargin: 8;
+ anchors.left: camTargetAntiSwapper.right;
+ anchors.leftMargin: 12;
+ horizontalAlignment: Text.AlignCenter;
+ verticalAlignment: Text.AlignVCenter;
+ }
+
+ HifiControlsUit.GlyphButton {
+ id: camTargetSwapper;
+ anchors.verticalCenter: parent.verticalCenter;
+ anchors.right: parent.right;
+ anchors.rightMargin: -8;
+ height: parent.height - 8;
+ width: height;
+ glyph: hifi.glyphs.forward;
+ onClicked: {
+ switch (camTargetValue.text) {
+ case "AVATAR":
+ camTargetValue.text = "FORWARD";
+ break;
+ case "FORWARD":
+ camTargetValue.text = "BACKWARD";
+ break;
+ case "BACKWARD":
+ camTargetValue.text = "OUTSIDE";
+ break;
+ case "OUTSIDE":
+ camTargetValue.text = "AVATAR";
+ break;
+ }
+ sendToScript({method: 'updateCameraTarget', target: camTargetValue.text});
+ }
+ }
+ }
+ }
+//====================================================== END CAMERA POSITIONING ========
+
+ HifiStylesUit.RalewaySemiBold {
+ id: textShortcut;
+ visible: false;
+ anchors.top: parent.top;
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ height: paintedHeight;
+ text: "";
+ size: 16;
+ color: hifi.colors.white;
+ }
+
+
+ Item {
+ id: flyCamDescriptionContainer;
+ // Size
+ height: childrenRect.height;
+ // Anchors
+ anchors.left: parent.left;
+ anchors.right: parent.right;
+ anchors.bottom: parent.bottom;
+ anchors.bottomMargin: 20;
+
+ HifiControlsUit.Button {
+ id: flyCamSettingButton;
+ text: "Snapshot Settings";
+ colorScheme: hifi.colorSchemes.dark;
+ color: hifi.buttons.none;
+ anchors.top: parent.top;
+ anchors.topMargin: 10;
+ anchors.rightMargin: 10;
+ anchors.left: parent.left + 100;
+ anchors.right: flyCamLearnMoreText.left;
+ height: 20;
+ onClicked: {
+ sendToScript({method: 'openSettings'});
+ }
+ }
+
+ HifiControlsUit.Button {
+ id: flyCamInfoButton;
+ text: "More Info";
+ colorScheme: hifi.colorSchemes.dark;
+ color: hifi.buttons.none;
+ anchors.top: parent.top;
+ anchors.topMargin: 10;
+ anchors.leftMargin: 10;
+ anchors.left: flyCamSettingButton.right - 100;
+ anchors.right: parent.right;
+ height: 20;
+ MouseArea {
+ anchors.fill: parent;
+ hoverEnabled: enabled;
+ onClicked: {
+ letterbox(hifi.glyphs.question,
+ "Action Camera",
+ "By default, your monitor shows a preview of what you're seeing in VR. " +
+ "Using the Action Camera app, your monitor can display the view " +
+ "from a virtual camera - perfect for filming yourself in motion
Shortcuts:
" + textShortcut.text + "
" +
+ "Streaming and Recording
" +
+ "We recommend OBS for streaming and recording the contents of your monitor to services like " +
+ "Twitch, YouTube Live, and Facebook Live.
" +
+ "To get started using OBS, click this link now. The page will open in an external browser:
" +
+ 'OBS Official Overview Guide
' +
+ 'Snapshots taken using Action Camera will be saved in your Snapshots Directory - change via Settings -> General.');
+ }
+ onEntered: parent.color = hifi.colors.blueHighlight;
+ onExited: parent.color = hifi.colors.blueAccent;
+ }
+ }
+
+ }
+ }
+ }
+ //
+ // SPECTATOR CONTROLS END
+ //
+
+ //
+ // FUNCTION DEFINITIONS START
+ //
+ //
+ // Function Name: fromScript()
+ //
+ // Relevant Variables:
+ // None
+ //
+ // Arguments:
+ // message: The message sent from the flyCamera JavaScript.
+ // Messages are in format "{method, params}", like json-rpc.
+ //
+ // Description:
+ // Called when a message is received from flyCamera.js.
+ //
+
+ function fromScript(message) {
+ switch (message.method) {
+ case 'initializeUI':
+ masterSwitch.checked = message.masterSwitchOn;
+ flashCheckBox.checked = message.flashCheckboxChecked;
+ showCameraView.checked = message.monitorShowsCamView;
+ showHmdPreview.checked = !message.monitorShowsCamView;
+ relativeHorizontalAngleSlider.value = message.cameraHorizontalAngle;
+ relativeVerticalAngleSlider.value = message.cameraVerticalAngle;
+ camDistanceSlider.value = message.cameraDistance;
+ camTargetValue.text = message.cameraTarget;
+ root.uiReady = true;
+ break;
+ case 'updateMonitorShowsSwitch':
+ showCameraView.checked = message.params;
+ showHmdPreview.checked = !message.params;
+ break;
+ case 'updateControllerMappingCheckbox':
+ if (message.controller === "OculusTouch") {
+ textShortcut.text = "Left Thumbstick: Switch Monitor View
Right Thumbstick: Take Snapshot";
+ } else if (message.controller === "Vive") {
+ textShortcut.text = "Left Thumb Pad: Switch Monitor View
Right Thumb Pad: Take Snapshot";
+ } else {
+ textShortcut.text = "Pressing Ctrl+0 Switches Monitor View";
+ }
+ break;
+ case 'finishedProcessing360Snapshot':
+ root.processing360Snapshot = false;
+ break;
+ case 'startedProcessingStillSnapshot':
+ root.processingStillSnapshot = true;
+ break;
+ case 'finishedProcessingStillSnapshot':
+ root.processingStillSnapshot = false;
+ break;
+ default:
+ console.log('Unrecognized message from spectatorCamera.js:', JSON.stringify(message));
+ }
+ }
+ signal sendToScript(var message);
+
+ //
+ // FUNCTION DEFINITIONS END
+ //
+}
diff --git a/applications/flyCam/processing.gif b/applications/flyCam/processing.gif
new file mode 100644
index 0000000..0536bd1
Binary files /dev/null and b/applications/flyCam/processing.gif differ
diff --git a/applications/flyCam/snap.wav b/applications/flyCam/snap.wav
new file mode 100644
index 0000000..e5b86c0
Binary files /dev/null and b/applications/flyCam/snap.wav differ
diff --git a/applications/flyCam/static.gif b/applications/flyCam/static.gif
new file mode 100644
index 0000000..fbe46f4
Binary files /dev/null and b/applications/flyCam/static.gif differ
diff --git a/applications/metadata.js b/applications/metadata.js
index e8f6f7b..d8ddbfd 100644
--- a/applications/metadata.js
+++ b/applications/metadata.js
@@ -269,6 +269,15 @@ var metadata = { "applications":
"jsfile": "inventory-app/dist/inventory.js",
"icon": "inventory-app/dist/inventory-i.svg",
"caption": "INVENTORY"
- }
+ },
+ {
+ "isActive": true,
+ "directory": "flyCam",
+ "name": "Action Camera",
+ "description": "The Action Camera is attached to your avatar, allowing you to capture video while moving, walking, or flying. Fully adjustable around your avatar, this camera is invisible and ensures optimal capture. It also includes most of the features found in the Spectator Camera.",
+ "jsfile": "flyCam/flyCamera.js",
+ "icon": "flyCam/flyCam-i.png",
+ "caption": "FLY-CAM"
+ },
]
};
\ No newline at end of file