Add CLI for camera speed (zoom, rotations, and pan)

Author: Jerboa-app

include/commandLine.h

@@ -317,6 +317,10 @@ struct CommandLine
         extractArgument(globalAtomAlpha, arguments);
         extractArgument(globalBondAlpha, arguments);
         extractArgument(videoName, arguments);
+        extractArgument(cameraZoomSpeed, arguments);
+        extractArgument(cameraPanSpeed, arguments);
+        extractArgument(cameraInclineSpeed, arguments);
+        extractArgument(cameraRotateSpeed, arguments);
 
         #ifdef WITH_FFMPEG
         extractArgument(cq, arguments);
@@ -352,6 +356,10 @@ struct CommandLine
     Argument<vec<2>> resolution = {"resolution", "Window resolution in pixels.", "", {512, 512}};
     Argument<uint64_t> bondFocus = {"bondFocus", "Only draw bonds for this atom.", "", NULL_INDEX};
     Argument<uint64_t> focus = {"focus", "Centre on a particular atom.", "", NULL_INDEX};
+    Argument<float> cameraZoomSpeed = {"cameraZoomSpeed", "Speed of the camera's zoom.", "", 1.0};
+    Argument<float> cameraRotateSpeed = {"cameraRotateSpeed", "Speed of the camera's rotation", "", 1.0};
+    Argument<float> cameraInclineSpeed = {"cameraInclineSpeed", "Speed of the camera's inclination.", "", 1.0};
+    Argument<float> cameraPanSpeed = {"cameraPanSpeed", "Speed of the camera's pan.", "", 1.0};
 
     #ifdef WITH_FFMPEG
     Argument<std::string> codec = {"codec", "FFmpeg codec name.", "See ffmpeg -codecs", "libx264"};
@@ -625,6 +633,10 @@ struct CommandLine
           << "\n"
           << sidebyside(argumentHelp(videoName), argumentHelp(fieldOfView), 42)
           << "\n"
+          << sidebyside(argumentHelp(cameraRotateSpeed), argumentHelp(cameraInclineSpeed), 42)
+          << "\n"
+          << sidebyside(argumentHelp(cameraPanSpeed), argumentHelp(cameraZoomSpeed), 42)
+          << "\n"
           #ifdef WITH_FFMPEG
           << "\n FFMPEG recording options:\n\n"
           << "   See here for advice https://trac.ffmpeg.org/wiki/Encode/H.264\n\n"

include/main.h

@@ -137,40 +137,50 @@ Theme lightTheme()
  *
  * @param display display to obtain events from.
  * @param camera the camera to update.
+ * @param zoomSpeed multiplier for zoom.
+ * @param rotateSpeed multiplier for rotation.
+ * @param inclineSpeed multiplier for inclination.
  * @return true if the camera moved.
  * @return false if the camera did not move.
  */
-bool cameraControls(jGL::DesktopDisplay & display, Camera & camera)
+bool cameraControls
+(
+    jGL::DesktopDisplay & display,
+    Camera & camera,
+    float zoomSpeed,
+    float rotateSpeed,
+    float inclineSpeed
+)
 {
     bool moved = false;
     if (display.keyHasAnyEvents(GLFW_KEY_W, {jGL::EventType::PRESS, jGL::EventType::HOLD}))
     {
-        camera.zoom(-dr);
+        camera.zoom(-dr*zoomSpeed);
         moved = true;
     }
     if (display.keyHasAnyEvents(GLFW_KEY_S, {jGL::EventType::PRESS, jGL::EventType::HOLD}))
     {
-        camera.zoom(dr);
+        camera.zoom(dr*zoomSpeed);
         moved = true;
     }
     if (display.keyHasAnyEvents(GLFW_KEY_Q, {jGL::EventType::PRESS, jGL::EventType::HOLD}))
     {
-        camera.incline(dtheta);
+        camera.incline(dtheta*inclineSpeed);
         moved = true;
     }
     if (display.keyHasAnyEvents(GLFW_KEY_E, {jGL::EventType::PRESS, jGL::EventType::HOLD}))
     {
-        camera.incline(-dtheta);
+        camera.incline(-dtheta*inclineSpeed);
         moved = true;
     }
     if (display.keyHasAnyEvents(GLFW_KEY_A, {jGL::EventType::PRESS, jGL::EventType::HOLD}))
     {
-        camera.rotate(-dphi);
+        camera.rotate(-dphi*rotateSpeed);
         moved = true;
     }
     if (display.keyHasAnyEvents(GLFW_KEY_D, {jGL::EventType::PRESS, jGL::EventType::HOLD}))
     {
-        camera.rotate(dphi);
+        camera.rotate(dphi*rotateSpeed);
         moved = true;
     }
     return moved;
@@ -182,6 +192,10 @@ bool cameraControls(jGL::DesktopDisplay & display, Camera & camera)
  * @param display the display to get events from.
  * @param atoms the Atoms to modify.
  * @param emphasisControls key bindings to emphasise elements.
+ * @param elementMap map elements to indices.
+ * @param alphaOverrides overriding alpha channels.
+ * @param deemphasisAlpha alpha for faded atoms.
+ * @param translateSpeed atom translation speed.
  *
  * @return true if the Atoms were modified.
  * @return false if the Atoms were not modified.
@@ -193,38 +207,39 @@ bool atomControls
     std::map<int, Element> & emphasisControls,
     std::multimap<Element, uint64_t> & elementMap,
     std::vector<float> & alphaOverrides,
-    float deemphasisAlpha
+    float deemphasisAlpha,
+    float translateSpeed
 )
 {
     bool elementsNeedUpdate = false;
     if (display.keyHasEvent(GLFW_KEY_LEFT, jGL::EventType::PRESS) || display.keyHasEvent(GLFW_KEY_LEFT, jGL::EventType::HOLD))
     {
-        translate(atoms, {-dr, 0.0, 0.0});
+        translate(atoms, {-dr*translateSpeed, 0.0, 0.0});
         elementsNeedUpdate = true;
     }
     if (display.keyHasEvent(GLFW_KEY_RIGHT, jGL::EventType::PRESS) || display.keyHasEvent(GLFW_KEY_RIGHT, jGL::EventType::HOLD))
     {
-        translate(atoms, {dr, 0.0, 0.0});
+        translate(atoms, {dr*translateSpeed, 0.0, 0.0});
         elementsNeedUpdate = true;
     }
     if (display.keyHasEvent(GLFW_KEY_PERIOD, jGL::EventType::PRESS) || display.keyHasEvent(GLFW_KEY_PERIOD, jGL::EventType::HOLD))
     {
-        translate(atoms, {0.0, -dr, 0.0});
+        translate(atoms, {0.0, -dr*translateSpeed, 0.0});
         elementsNeedUpdate = true;
     }
     if (display.keyHasEvent(GLFW_KEY_SLASH, jGL::EventType::PRESS) || display.keyHasEvent(GLFW_KEY_SLASH, jGL::EventType::HOLD))
     {
-        translate(atoms, {0.0, dr, 0.0});
+        translate(atoms, {0.0, dr*translateSpeed, 0.0});
         elementsNeedUpdate = true;
     }
     if (display.keyHasEvent(GLFW_KEY_DOWN, jGL::EventType::PRESS) || display.keyHasEvent(GLFW_KEY_DOWN, jGL::EventType::HOLD))
     {
-        translate(atoms, {0.0, 0.0, -dr});
+        translate(atoms, {0.0, 0.0, -dr*translateSpeed});
         elementsNeedUpdate = true;
     }
     if (display.keyHasEvent(GLFW_KEY_UP, jGL::EventType::PRESS) || display.keyHasEvent(GLFW_KEY_UP, jGL::EventType::HOLD))
     {
-        translate(atoms, {0.0, 0.0, dr});
+        translate(atoms, {0.0, 0.0, dr*translateSpeed});
         elementsNeedUpdate = true;
     }
 
@@ -287,7 +302,7 @@ void loadingScreenFrame
     jGLInstance->setClear(theme.background);
     jGLInstance->clear();
 
-    cameraControls(display, camera);
+    cameraControls(display, camera, 1.0f, 1.0f, 1.0f);
 
     loadingAtoms.updateCamera(camera);
     loadingAtoms.draw(true);

src/main.cpp

@@ -217,7 +217,14 @@ int main(int argv, char ** argc)
             options.hideInfoText.value = !options.hideInfoText.value;
         }
 
-        bool cameraMoved = cameraControls(display, camera);
+        bool cameraMoved = cameraControls
+        (
+            display,
+            camera,
+            options.cameraZoomSpeed.value,
+            options.cameraRotateSpeed.value,
+            options.cameraInclineSpeed.value
+        );
 
         elementsNeedUpdate = atomControls
         (
@@ -226,7 +233,8 @@ int main(int argv, char ** argc)
             visualisationState.emphasisControls,
             visualisationState.elementMap,
             visualisationState.atomEmphasisOverrides,
-            options.deemphasisAlpha.value
+            options.deemphasisAlpha.value,
+            options.cameraPanSpeed.value
         );
 
         if (display.keyHasAnyEvents(GLFW_KEY_SPACE, {jGL::EventType::PRESS, jGL::EventType::HOLD}))