control (some) application parameters via cmdline

diff --git a/building b/building
index 41638628526aa965d2bce7fce02d5b3333f0b9c2..e10bb282a4edba8644d10e703c8e2b3712a95f8f 100644 (file)
--- a/building
+++ b/building
@@ -46,3 +46,19 @@ CPPFLAGS, CXXFLAGS, LDXXFLAGS:
 
 DEBUG_FLAGS, PROFILE_FLAGS, RELEASE_FLAGS:
        flags for building binaries in debug, profile, and release mode
+
+
+Running
+=======
+
+blank
+       normal execution
+
+blank <n>
+       terminate after <n> frames
+
+blank -t <t>
+       terminate after <t> milliseconds
+
+blank <n> -t <t>
+       terminate after n frames, assume <t> milliseconds pass each frame

diff --git a/src/app.cpp b/src/app.cpp
index d8f1e2147ba2589df979be0c7bbdd3402fc4eb57..7ddbbf189180d43dccd577a91e68a057ef1c8f0f 100644 (file)
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -40,6 +40,34 @@ Application::Application()
 }
 
 
+void Application::RunN(size_t n) {
+       Uint32 last = SDL_GetTicks();
+       for (size_t i = 0; i < n; ++i) {
+               Uint32 now = SDL_GetTicks();
+               int delta = now - last;
+               Loop(delta);
+               last = now;
+       }
+}
+
+void Application::RunT(size_t t) {
+       Uint32 last = SDL_GetTicks();
+       Uint32 finish = last + t;
+       while (last < finish) {
+               Uint32 now = SDL_GetTicks();
+               int delta = now - last;
+               Loop(delta);
+               last = now;
+       }
+}
+
+void Application::RunS(size_t n, size_t t) {
+       for (size_t i = 0; i < n; ++i) {
+               Loop(t);
+       }
+}
+
+
 void Application::Run() {
        running = true;
        Uint32 last = SDL_GetTicks();

diff --git a/src/app.hpp b/src/app.hpp
index 0b0e64e46681c26d167c5214e2d8193c256ca0eb..cb71411de60e312231f0ac847580f8baf914d579 100644 (file)
--- a/src/app.hpp
+++ b/src/app.hpp
@@ -23,9 +23,17 @@ public:
        Application(const Application &) = delete;
        Application &operator =(const Application &) = delete;
 
+       /// run until user quits
        void Run();
        void Loop(int dt);
 
+       /// run for n frames
+       void RunN(size_t n);
+       /// run for t milliseconds
+       void RunT(size_t t);
+       /// run for n frames, assuming t milliseconds for each
+       void RunS(size_t n, size_t t);
+
        void HandleEvents();
        void Update(int dt);
        void Render();

diff --git a/src/main.cpp b/src/main.cpp
index 06771fe8c4b76d1df04ee9292dd92088eb2428d0..f9bc154739fa57a0045f8e6bbd991782367cc9d7 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,12 +1,85 @@
 #include "app.hpp"
 
+#include <cctype>
+#include <cstdlib>
+#include <iostream>
+
 using namespace blank;
 
 
+namespace {
+
+enum Mode {
+       NORMAL,
+       FRAME_LIMIT,
+       TIME_LIMIT,
+       FIXED_FRAME_LIMIT,
+};
+
+}
+
+
 int main(int argc, char *argv[]) {
 
+       Mode mode = NORMAL;
+       size_t n = 0, t = 0;
+
+       bool error = false;
+       for (int i = 1; i < argc; ++i) {
+               if (argv[i] == nullptr || argv[i][0] == '\0') continue;
+               if (argv[i][0] == '-') {
+                       if (argv[i][1] == 't' && argv[i][2] == '\0') {
+                               ++i;
+                               if (i >= argc) {
+                                       std::cerr << "missing argument to -t" << std::endl;
+                                       error = true;
+                               } else {
+                                       t = std::strtoul(argv[i], nullptr, 10);
+                               }
+                       } else {
+                               std::cerr << "unable to interpret argument "
+                                       << i << " (" << argv[i] << ")" << std::endl;
+                               error = true;
+                       }
+               } else if (std::isdigit(*argv[i])) {
+                       n = std::strtoul(argv[i], nullptr, 10);
+               } else {
+                       std::cerr << "unable to interpret argument "
+                               << i << " (" << argv[i] << ")" << std::endl;
+                       error = true;
+               }
+       }
+
+       if (error) {
+               return 1;
+       }
+
+       if (n > 0) {
+               if (t > 0) {
+                       mode = FIXED_FRAME_LIMIT;
+               } else {
+                       mode = FRAME_LIMIT;
+               }
+       } else if (t > 0) {
+               mode = TIME_LIMIT;
+       }
+
        Application app;
-       app.Run();
+       switch (mode) {
+               default:
+               case NORMAL:
+                       app.Run();
+                       break;
+               case FRAME_LIMIT:
+                       app.RunN(n);
+                       break;
+               case TIME_LIMIT:
+                       app.RunT(t);
+                       break;
+               case FIXED_FRAME_LIMIT:
+                       app.RunS(n, t);
+                       break;
+       }
 
        return 0;