Commander now ezOptionParser. Fixed many warnings.

CMakeLists.txt

     set (WARNINGS "${WARNINGS} -Wno-padded -Wno-packed")
     set (WARNINGS "${WARNINGS} -Wno-global-constructors -Wno-exit-time-destructors")
     set (WARNINGS "${WARNINGS} -Wno-documentation-unknown-command -Wno-c++98-compat-pedantic")
-    set (WARNINGS "${WARNINGS} -Wno-date-time -Wno-unused-variable")
+    set (WARNINGS "${WARNINGS} -Wno-date-time -Wno-unused-variable -Wno-unused-parameter")
     set (WARNINGS "${WARNINGS} -Wno-shorten-64-to-32 -Wno-sign-compare -Wno-sign-conversion")
     set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -std=c++11")
     set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -g -O0")

ChangeLog.md

 
 ## OpenRaider (0.1.4) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20150813 ]
+    * Removed commander lib, added ezOptionParser
+    * Fixed many warnings
+
     [ 20150811 ]
     * Can click on RoomModels and RoomSprites
     * This will show their BoundingSpheres

README.md

 
 See the respective files in `cmake` for their licensing.
 
-The included [clibs/commander](https://github.com/clibs/commander) lib is Copyright (c) 2012 TJ Holowaychuk (tj@vision-media.ca) and licensed under the [MIT License](http://opensource.org/licenses/MIT).
+The included header [ezOptionParser](http://ezoptionparser.sourceforge.net) is licensed under the [MIT License](http://opensource.org/licenses/MIT).
 
 The included GUI lib, [imgui](https://github.com/ocornut/imgui/) is Copyright (c) 2014 Omar Cornut. See src/deps/imgui/LICENSE for more informations about the MIT license used. 
 
 Also included is the imgui addon [imguifilesystem by Flix01](https://gist.github.com/Flix01/f34b5efa91e50a241c1b).
-

include/Log.h

 
 class LogLevel {
   public:
-    LogLevel(int l) : level(l) { printBuffer << std::boolalpha; }
-    LogLevel(LogLevel&& l) : level(l.level) { }
+    explicit LogLevel(int l) : level(l) { printBuffer << std::boolalpha; }
+    LogLevel(LogLevel&& l) : level(l.level) { printBuffer << std::boolalpha; }
 
     LogLevel& operator<< (const glm::vec2& v) {
         return (*this) << v.x << " " << v.y;

include/SkeletalModel.h

 
 class BoneFrame {
   public:
-    BoneFrame(glm::vec3 p) : pos(p) { }
+    explicit BoneFrame(glm::vec3 p) : pos(p) { }
     ~BoneFrame();
 
     glm::vec3 getPosition() { return pos; }
 
 class AnimationFrame {
   public:
-    AnimationFrame(char r) : rate(r) { }
+    explicit AnimationFrame(char r) : rate(r) { }
     ~AnimationFrame();
 
     unsigned long size();
 
 class SkeletalModel {
   public:
-    SkeletalModel(int i) : id(i) { }
+    explicit SkeletalModel(int i) : id(i) { }
     ~SkeletalModel();
     void display(glm::mat4 MVP, int aframe, int bframe, ShaderTexture* shaderTexture = nullptr);
 

include/utils/Folder.h

 
 class File {
   public:
-    File(std::string file);
+    explicit File(std::string file);
 
     std::string& getName() { return name; }
     std::string& getPath() { return path; }

include/utils/binary.h

 
 class BinaryFile : public BinaryReader {
   public:
-    BinaryFile(std::string f = "");
+    explicit BinaryFile(std::string f = "");
     virtual ~BinaryFile();
 
     int open(std::string f = "");

src/Camera.cpp

 
     if (indexBuffer.size() == 0) {
         for (int i = 0; i < 6; i++) {
-            indexBuffer.push_back(4 * i);
-            indexBuffer.push_back((4 * i) + 1);
-            indexBuffer.push_back((4 * i) + 2);
-            indexBuffer.push_back((4 * i) + 3);
-            indexBuffer.push_back((4 * i) + 2);
-            indexBuffer.push_back(4 * i);
+            indexBuffer.push_back(static_cast<unsigned short>(4 * i));
+            indexBuffer.push_back(static_cast<unsigned short>((4 * i) + 1));
+            indexBuffer.push_back(static_cast<unsigned short>((4 * i) + 2));
+            indexBuffer.push_back(static_cast<unsigned short>((4 * i) + 3));
+            indexBuffer.push_back(static_cast<unsigned short>((4 * i) + 2));
+            indexBuffer.push_back(static_cast<unsigned short>(4 * i));
         }
     }
 }

src/Mesh.cpp

                 v = 2;
             else if (v == 2)
                 v = 0;
-            ind.push_back(vert.size());
+            ind.push_back(static_cast<unsigned short>(vert.size()));
             vert.push_back(verticesBuff.at(vertIndex + v));
             uvBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
             tex.push_back(texture);
                 v = 2;
             else if (v == 2)
                 v = 0;
-            indCol.push_back(vertCol.size());
+            indCol.push_back(static_cast<unsigned short>(vertCol.size()));
             vertCol.push_back(verticesColorBuff.at(vertIndex + v));
             glm::vec4 c = TextureManager::getPalette(colorsIndexBuff.at(i));
             cols.push_back(glm::vec3(c.x, c.y, c.z));
 
     glm::vec3 center = average / float(averageCount);
     float radius = 0.0f;
-    for (auto& vert : verticesBuff) {
-        float dist = glm::distance(center, vert);
+    for (auto& v : verticesBuff) {
+        float dist = glm::distance(center, v);
         if (dist > radius) radius = dist;
     }
-    for (auto& vert : verticesColorBuff) {
-        float dist = glm::distance(center, vert);
+    for (auto& v : verticesColorBuff) {
+        float dist = glm::distance(center, v);
         if (dist > radius) radius = dist;
     }
 

src/RoomMesh.cpp

                 v = 2;
             else if (v == 2)
                 v = 0;
-            ind.push_back(vert.size());
+            ind.push_back(static_cast<unsigned short>(vert.size()));
             vert.push_back(verticesBuff.at(vertIndex + v));
             uvsBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
             tex.push_back(texture);

src/SkeletalModel.cpp

 
 class MatrixStack {
   public:
-    MatrixStack(glm::mat4 start) : startVal(start) { stack.push_back(startVal); }
+    explicit MatrixStack(glm::mat4 start) : startVal(start) { stack.push_back(startVal); }
 
     void push() {
         //orAssertGreaterThan(stack.size(), 0);

src/SoundManager.cpp

 }
 
 void SoundManager::display() {
-    static bool offsets = false;
     if (ImGui::CollapsingHeader("Sound Sources")) {
         ImGui::Columns(5, "soundsources");
         ImGui::Text("No");
         ImGui::Text("Tools");
         ImGui::NextColumn();
         ImGui::Separator();
+
+        static bool offsets = false;
         if (!offsets) {
             ImGui::SetColumnOffset(1, 40.0f);
             ImGui::SetColumnOffset(2, 80.0f);
             ImGui::SetColumnOffset(4, 350.0f);
             offsets = true;
         }
+
         for (int i = 0; i < soundSources.size(); i++) {
             auto& ss = soundSources.at(i);
             ImGui::Text("%03d", i);
             ImGui::PopID();
             ImGui::NextColumn();
         }
+
         ImGui::Columns(1);
     }
 
-    static bool offsets2 = false;
     if (ImGui::CollapsingHeader("Sound Details")) {
         ImGui::Columns(4, "sounddetails");
         ImGui::Text("No");
         ImGui::Text("Tools");
         ImGui::NextColumn();
         ImGui::Separator();
+
+        static bool offsets2 = false;
         if (!offsets2) {
             ImGui::SetColumnOffset(1, 40.0f);
             ImGui::SetColumnOffset(2, 80.0f);
             ImGui::SetColumnOffset(3, 180.0f);
             offsets2 = true;
         }
+
         for (int i = 0; i < soundDetails.size(); i++) {
             auto& sd = soundDetails.at(i);
             ImGui::Text("%03d", i);
             ImGui::PopID();
             ImGui::NextColumn();
         }
+
         ImGui::Columns(1);
     }
 

src/Sprite.cpp

     width >>= 8;
     height >>= 8;
 
-    int width2 = (int)(width * scale);
-    int height2 = (int)(height * scale);
+    int width2 = static_cast<int>(width * scale);
+    int height2 = static_cast<int>(height * scale);
 
     uvBuff.emplace_back(float(x + texelOffset) / texelScale, float(y + height) / texelScale);
     uvBuff.emplace_back(float(x + texelOffset) / texelScale, float(y + texelOffset) / texelScale);

src/TextureManager.cpp

         unsigned int width = std::get<1>(tex);
         unsigned int height = std::get<2>(tex);
         unsigned char* image = new unsigned char[width * height * 4];
-        for (unsigned int i = 0; i < (width * height); i++) {
-            auto col = getPalette(img[i]);
-            image[i * 4] = col.x * 255;
-            image[(i * 4) + 1] = col.y * 255;
-            image[(i * 4) + 2] = col.z * 255;
-            image[(i * 4) + 3] = col.w * 255;
+        for (unsigned int j = 0; j < (width * height); j++) {
+            auto col = getPalette(img[j]);
+            image[j * 4] = static_cast<unsigned char>(col.x * 255);
+            image[(j * 4) + 1] = static_cast<unsigned char>(col.y * 255);
+            image[(j * 4) + 2] = static_cast<unsigned char>(col.z * 255);
+            image[(j * 4) + 3] = static_cast<unsigned char>(col.w * 255);
         }
         delete [] img;
         loadBufferSlot(image, width, height, ColorMode::RGBA, 32, TextureStorage::GAME, i, true);

src/UI.cpp

                 orAssert(bm != nullptr);
                 imguiShader.loadUniform(1, bm->getTextureID(), bm->getTextureStorage());
 
-                gl::glScissor(pcmd->ClipRect.x,
-                              Window::getSize().y - pcmd->ClipRect.w,
-                              pcmd->ClipRect.z - pcmd->ClipRect.x,
-                              pcmd->ClipRect.w - pcmd->ClipRect.y);
+                gl::glScissor(static_cast<gl::GLint>(pcmd->ClipRect.x),
+                              static_cast<gl::GLint>(Window::getSize().y - pcmd->ClipRect.w),
+                              static_cast<gl::GLsizei>(pcmd->ClipRect.z - pcmd->ClipRect.x),
+                              static_cast<gl::GLsizei>(pcmd->ClipRect.w - pcmd->ClipRect.y));
 
                 gl::glDrawElements(gl::GL_TRIANGLES, pcmd->ElemCount, gl::GL_UNSIGNED_SHORT, idx_buffer_offset);
             }

src/World.cpp

 
 void World::displayUI() {
     // Rooms
-    static bool offsets = false;
     if (ImGui::CollapsingHeader("Room Listing")) {
         ImGui::Columns(8, "rooms");
         ImGui::Text("No");
         ImGui::Text("Tools");
         ImGui::NextColumn();
         ImGui::Separator();
+
+        static bool offsets = false;
         if (!offsets) {
             ImGui::SetColumnOffset(1, 40.0f);
             ImGui::SetColumnOffset(2, 80.0f);
             ImGui::SetColumnOffset(7, 400.0f);
             offsets = true;
         }
+
         for (int i = 0; i < rooms.size(); i++) {
             ImGui::Text("%03d", i);
             ImGui::NextColumn();
             rooms.at(i)->displayUI();
         }
+
         ImGui::Columns(1);
     }
 
     // Entities
-    static bool offsets2 = false;
     if (ImGui::CollapsingHeader("Entity Listing")) {
         ImGui::Columns(4, "entities");
         ImGui::Text("No");
         ImGui::Text("Index");
         ImGui::NextColumn();
         ImGui::Separator();
+
+        static bool offsets2 = false;
         if (!offsets2) {
             ImGui::SetColumnOffset(1, 40.0f);
             ImGui::SetColumnOffset(2, 80.0f);
             ImGui::SetColumnOffset(3, 200.0f);
             offsets2 = true;
         }
+
         for (int i = 0; i < entities.size(); i++) {
             ImGui::Text("%03d", i);
             ImGui::NextColumn();
             entities.at(i)->displayUI();
         }
+
         ImGui::Columns(1);
     }
 
     // Static Meshes
-    static bool offsets3 = false;
     if (ImGui::CollapsingHeader("StaticMesh Listing")) {
         ImGui::Columns(3, "staticmeshes");
         ImGui::Text("No");
         ImGui::Text("Mesh");
         ImGui::NextColumn();
         ImGui::Separator();
+
+        static bool offsets3 = false;
         if (!offsets3) {
             ImGui::SetColumnOffset(1, 40.0f);
             ImGui::SetColumnOffset(2, 80.0f);
             offsets3 = true;
         }
+
         for (int i = 0; i < staticMeshes.size(); i++) {
             ImGui::Text("%03d", i);
             ImGui::NextColumn();
             staticMeshes.at(i)->displayUI();
         }
+
         ImGui::Columns(1);
     }
 }

src/deps/CMakeLists.txt

 # Source files
-set (DEPS_SRCS ${DEPS_SRCS} "commander/commander.c" "commander/commander.h")
+set (DEPS_SRCS ${DEPS_SRCS} "ezoptionparser/ezOptionParser.hpp")
 set (DEPS_SRCS ${DEPS_SRCS} "imgui/imgui.cpp" "imgui/imgui.h" "imgui/imconfig.h" "imgui/stb_textedit.h")
 set (DEPS_SRCS ${DEPS_SRCS} "stb/stb.cpp" "stb/stb_image.h" "stb/stb_image_write.h")
 

src/deps/commander/commander.c

-
-//
-// commander.c
-//
-// Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
-//
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include "commander.h"
-
-/*
- * Output error and exit.
- */
-
-static void
-error(char *msg) {
-  fprintf(stderr, "%s\n", msg);
-  exit(1);
-}
-
-/*
- * Output command version.
- */
-
-static void
-command_version(command_t *self) {
-  printf("%s\n", self->version);
-  command_free(self);
-  exit(0);
-}
-
-/*
- * Output command help.
- */
-
-void
-command_help(command_t *self) {
-  printf("\n");
-  printf("  Usage: %s %s\n", self->name, self->usage);
-  printf("\n");
-  printf("  Options:\n");
-  printf("\n");
-
-  int i;
-  for (i = 0; i < self->option_count; ++i) {
-    command_option_t *option = &self->options[i];
-    printf("    %s, %-25s %s\n"
-      , option->small
-      , option->large_with_arg
-      , option->description);
-  }
-
-  printf("\n");
-  command_free(self);
-  exit(0);
-}
-
-/*
- * Initialize with program `name` and `version`.
- */
-
-void
-command_init(command_t *self, const char *name, const char *version) {
-  self->arg = NULL;
-  self->name = name;
-  self->version = version;
-  self->option_count = self->argc = 0;
-  self->usage = "[options]";
-  self->nargv = NULL;
-  command_option(self, "-V", "--version", "output program version", command_version);
-  command_option(self, "-h", "--help", "output help information", command_help);
-}
-
-/*
- * Free up commander after use.
- */
-
-void
-command_free(command_t *self) {
-  int i;
-
-  for (i = 0; i < self->option_count; ++i) {
-    command_option_t *option = &self->options[i];
-    free(option->argname);
-    free(option->large);
-  }
-
-  if (self->nargv) {
-    for (i = 0; self->nargv[i]; ++i) {
-      free(self->nargv[i]);
-    }
-    free(self->nargv);
-  }
-}
-
-/*
- * Parse argname from `str`. For example
- * Take "--required <arg>" and populate `flag`
- * with "--required" and `arg` with "<arg>".
- */
-
-static void
-parse_argname(const char *str, char *flag, char *arg) {
-  int buffer = 0;
-  size_t flagpos = 0;
-  size_t argpos = 0;
-  size_t len = strlen(str);
-  size_t i;
-
-  for (i = 0; i < len; ++i) {
-    if (buffer || '[' == str[i] || '<' == str[i]) {
-      buffer = 1;
-      arg[argpos++] = str[i];
-    } else {
-      if (' ' == str[i]) continue;
-      flag[flagpos++] = str[i];
-    }
-  }
-
-  arg[argpos] = '\0';
-  flag[flagpos] = '\0';
-}
-
-/*
- * Normalize the argument vector by exploding
- * multiple options (if any). For example
- * "foo -abc --scm git" -> "foo -a -b -c --scm git"
- */
-
-static char **
-normalize_args(int *argc, char **argv) {
-  int size = 0;
-  int alloc = *argc + 1;
-  char **nargv = malloc(alloc * sizeof(char *));
-  int i;
-
-  for (i = 0; argv[i]; ++i) {
-    const char *arg = argv[i];
-    size_t len = strlen(arg);
-
-    // short flag
-    if (len > 2 && '-' == arg[0] && !strchr(arg + 1, '-')) {
-      alloc += len - 2;
-      nargv = realloc(nargv, alloc * sizeof(char *));
-      size_t j;
-      for (j = 1; j < len; ++j) {
-        nargv[size] = malloc(3);
-        sprintf(nargv[size], "-%c", arg[j]);
-        size++;
-      }
-      continue;
-    }
-
-    // regular arg
-    nargv[size] = malloc(len + 1);
-    strcpy(nargv[size], arg);
-    size++;
-  }
-
-  nargv[size] = NULL;
-  *argc = size;
-  return nargv;
-}
-
-/*
- * Define an option.
- */
-
-void
-command_option(command_t *self, const char *small, const char *large, const char *desc, command_callback_t cb) {
-  if (self->option_count == COMMANDER_MAX_OPTIONS) {
-    command_free(self);
-    error("Maximum option definitions exceeded");
-  }
-  int n = self->option_count++;
-  command_option_t *option = &self->options[n];
-  option->cb = cb;
-  option->small = small;
-  option->description = desc;
-  option->required_arg = option->optional_arg = 0;
-  option->large_with_arg = large;
-  option->argname = malloc(strlen(large) + 1);
-  assert(option->argname);
-  option->large = malloc(strlen(large) + 1);
-  assert(option->large);
-  parse_argname(large, option->large, option->argname);
-  if ('[' == option->argname[0]) option->optional_arg = 1;
-  if ('<' == option->argname[0]) option->required_arg = 1;
-}
-
-/*
- * Parse `argv` (internal).
- * Input arguments should be normalized first
- * see `normalize_args`.
- */
-
-static void
-command_parse_args(command_t *self, int argc, char **argv) {
-  int literal = 0;
-  int i, j;
-
-  for (i = 1; i < argc; ++i) {
-    const char *arg = argv[i];
-    for (j = 0; j < self->option_count; ++j) {
-      command_option_t *option = &self->options[j];
-
-      // match flag
-      if (!strcmp(arg, option->small) || !strcmp(arg, option->large)) {
-        self->arg = NULL;
-
-        // required
-        if (option->required_arg) {
-          arg = argv[++i];
-          if (!arg || '-' == arg[0]) {
-            fprintf(stderr, "%s %s argument required\n", option->large, option->argname);
-            command_free(self);
-            exit(1);
-          }
-          self->arg = arg;
-        }
-
-        // optional
-        if (option->optional_arg) {
-          if (argv[i + 1] && '-' != argv[i + 1][0]) {
-            self->arg = argv[++i];
-          }
-        }
-
-        // invoke callback
-        option->cb(self);
-        goto match;
-      }
-    }
-
-    // --
-    if ('-' == arg[0] && '-' == arg[1] && 0 == arg[2]) {
-      literal = 1;
-      goto match;
-    }
-
-    // unrecognized
-    if ('-' == arg[0] && !literal) {
-      fprintf(stderr, "unrecognized flag %s\n", arg);
-      command_free(self);
-      exit(1);
-    }
-
-    int n = self->argc++;
-    if (n == COMMANDER_MAX_ARGS) {
-      command_free(self);
-      error("Maximum number of arguments exceeded");
-    }
-    self->argv[n] = (char *) arg;
-    match:;
-  }
-}
-
-/*
- * Parse `argv` (public).
- */
-
-void
-command_parse(command_t *self, int argc, char **argv) {
-  self->nargv = normalize_args(&argc, argv);
-  command_parse_args(self, argc, self->nargv);
-  self->argv[self->argc] = NULL;
-}

src/deps/commander/commander.h

-
-//
-// commander.h
-//
-// Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
-//
-
-#ifndef COMMANDER_H
-#define COMMANDER_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Max options that can be defined.
- */
-
-#ifndef COMMANDER_MAX_OPTIONS
-#define COMMANDER_MAX_OPTIONS 32
-#endif
-
-/*
- * Max arguments that can be passed.
- */
-
-#ifndef COMMANDER_MAX_ARGS
-#define COMMANDER_MAX_ARGS 32
-#endif
-
-/*
- * Command struct.
- */
-
-struct command;
-
-/*
- * Option callback.
- */
-
-typedef void (* command_callback_t)(struct command *self);
-
-/*
- * Command option.
- */
-
-typedef struct {
-  int optional_arg;
-  int required_arg;
-  char *argname;
-  char *large;
-  const char *small;
-  const char *large_with_arg;
-  const char *description;
-  command_callback_t cb;
-} command_option_t;
-
-/*
- * Command.
- */
-
-typedef struct command {
-  void *data;
-  const char *usage;
-  const char *arg;
-  const char *name;
-  const char *version;
-  int option_count;
-  command_option_t options[COMMANDER_MAX_OPTIONS];
-  int argc;
-  char *argv[COMMANDER_MAX_ARGS];
-  char **nargv;
-} command_t;
-
-// prototypes
-
-void
-command_init(command_t *self, const char *name, const char *version);
-
-void
-command_free(command_t *self);
-
-void
-command_help(command_t *self);
-
-void
-command_option(command_t *self, const char *small, const char *large, const char *desc, command_callback_t cb);
-
-void
-command_parse(command_t *self, int argc, char **argv);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* COMMANDER_H */

src/deps/commander/package.json

-{
-  "name": "commander",
-  "version": "1.3.2",
-  "repo": "clibs/commander",
-  "description": "Command-line argument parser",
-  "keywords": ["cli", "command", "parser", "argv", "args", "options"],
-  "license": "MIT",
-  "src": ["src/commander.h", "src/commander.c"]
-}

src/deps/imguifilesystem/imguifilesystem.cpp

 #include <stdio.h>  // FILENAME_MAX
 #include <new>      // operator new
 
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
 
 namespace ImGuiFs {
 

src/loader/LoaderTR1.cpp

      */
     uint16_t numValues = frame.readU16();
 
+    orAssertEqual(numValues, numMeshes);
+
     for (int i = 0; i < numValues; i++) {
         int mesh = startingMesh + i;
         glm::vec3 offset(0.0f, 0.0f, 0.0f);

src/main.cpp

 #include "TextureManager.h"
 #include "UI.h"
 #include "World.h"
-#include "commander/commander.h"
 #include "commands/Command.h"
 #include "system/Shader.h"
 #include "system/Sound.h"
 #include "utils/time.h"
 
 #include <glbinding/Binding.h>
+#include <ezoptionparser/ezOptionParser.hpp>
 
 #ifdef DEBUG
 #include <glbinding/callbacks.h>
 }
 #endif
 
-int main(int argc, char* argv[]) {
-    command_t cmd;
-    command_init(&cmd, argv[0], VERSION);
-    command_option(&cmd, "-c", "--config <file>", "select config file to use",
-    [](command_t* self) {
-        configFileToUse = self->arg;
-    });
-    command_parse(&cmd, argc, argv);
-    command_free(&cmd);
+int main(int argc, const char* argv[]) {
+    ez::ezOptionParser opt;
+    opt.overview = "Open Tomb Raider Game Engine";
+    opt.syntax = "OpenRaider [OPTIONS]";
+    opt.example = "OpenRaider --config ~/.OpenRaider/OpenRaider.ini";
+    opt.footer = VERSION;
+
+    opt.add("", 0, 0, 0, "Display usage instructions.", "-h", "-help", "--help", "--usage");
+    opt.add("", 0, 1, 0, "Config file to use", "-c", "--conf", "--config");
+
+    opt.parse(argc, argv);
+
+    if (opt.isSet("-h")) {
+        std::string usage;
+        opt.getUsage(usage);
+        std::cout << usage << std::endl;
+        return -1;
+    }
+
+    std::vector<std::string> badOptions;
+    if (!opt.gotRequired(badOptions)) {
+        for (int i = 0; i < badOptions.size(); i++) {
+            std::cout << "ERROR: Missing required option " << badOptions[i] << "." << std::endl;
+        }
+        std::string usage;
+        opt.getUsage(usage);
+        std::cout << usage << std::endl;
+        return -2;
+    }
+
+    if (!opt.gotExpected(badOptions)) {
+        for (int i = 0; i < badOptions.size(); i++) {
+            std::cout << "ERROR: Got unexpected number of arguments for option " << badOptions[i] << "." <<
+                      std::endl;
+        }
+        std::string usage;
+        opt.getUsage(usage);
+        std::cout << usage << std::endl;
+        return -3;
+    }
+
+    if (opt.isSet("-c")) {
+        std::cout << "Test!" << std::endl;
+        opt.get("-c")->getString(configFileToUse);
+    }
 
     glbinding::Binding::initialize();
     Log::initialize();
     int error = Window::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Window (" << error << ")!" << std::endl;
-        return -1;
+        return -4;
     }
 
     error = Shader::initialize();
     if (error != 0) {
         std::cout << "Could not initialize OpenGL (" << error << ")!" << std::endl;
-        return -2;
+        return -5;
     }
 
     // Initialize Texture Manager
     error = TextureManager::initialize();
     if (error != 0) {
         std::cout << "Could not initialize TextureManager (" << error << ")!" << std::endl;
-        return -3;
+        return -6;
     }
 
     if (configFileToUse == "") {
                 if (p != "/")
                     p += "/";
                 p += "share/OpenRaider/";
-                Command::executeFile(p + DEFAULT_CONFIG_FILE);
+                if (Command::executeFile(p + DEFAULT_CONFIG_FILE) != 0) {
+                    std::cout << "Could not find any config files. Trying to continue..." << std::endl;
+                }
             }
         }
     } else {
-        Command::executeFile(configFileToUse);
+        if (Command::executeFile(configFileToUse) != 0) {
+            std::cout << "Could not find specified config file!" << std::endl;
+            return -7;
+        }
     }
 
     error = TextureManager::initializeSplash();
     if (error != 0) {
         std::cout << "Coult not load Splash Texture (" << error << ")!" << std::endl;
-        return -4;
+        return -8;
     }
 
     // Initialize Sound
     error = Sound::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Sound (" << error << ")!" << std::endl;
-        return -5;
+        return -9;
     }
 
     // Initialize Debug UI
     error = UI::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Debug UI (" << error << ")!" << std::endl;
-        return -6;
+        return -10;
     }
 
     // Initialize Menu
     error = Menu::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Menu (" << error << ")!" << std::endl;
-        return -7;
+        return -11;
     }
 
     Log::get(LOG_INFO) << "Starting " << VERSION << Log::endl;

src/system/WindowGLFW.cpp

 }
 
 void WindowGLFW::charCallback(GLFWwindow* w, unsigned int codepoint) {
-    static std::codecvt_utf8<char32_t> conv;
-    static mbstate_t state;
-    static const int bufferSize = 42;
-    static char buffer[bufferSize + 1];
-
     if (textinput) {
+        static std::codecvt_utf8<char32_t> conv;
+        static mbstate_t state;
+        static const int bufferSize = 42;
+        static char buffer[bufferSize + 1];
+
         char32_t inBuff[2] = { codepoint, '\0' };
         const char32_t* in = nullptr;
         char* ex = nullptr;

src/utils/binary.cpp

 uint16_t BinaryReader::readU16() {
     uint16_t a = readU8();
     uint16_t b = readU8();
-    return (a | (b << 8));
+    return static_cast<uint16_t>(a | (b << 8));
 }
 
 uint32_t BinaryReader::readU32() {

src/utils/pixel.cpp

         // arrr.rrgg gggb.bbbb shift to 5bit
         img[i * 4] = (image[(i * 2) + 1] & 0x80) ? 0xFF : 0; // A
         img[(i * 4) + 1] = (image[(i * 2) + 1] & 0x7C) >> 2; // R
-        img[(i * 4) + 2] = (image[(i * 2) + 1] & 0x03) << 3;
+        img[(i * 4) + 2] = static_cast<unsigned char>((image[(i * 2) + 1] & 0x03) << 3);
         img[(i * 4) + 2] |= (image[i * 2] & 0xE0) >> 5; // G
         img[(i * 4) + 3] = image[i * 2] & 0x1F; // B