triangle

.gitignore

@@ -5,3 +5,4 @@ CMakeDoxygenDefaults.cmake
 Makefile
 cmake_install.cmake
 bin/loader/loader
+lib/glfw

CMakeLists.txt

@@ -30,7 +30,7 @@ source_group("sources" FILES ${PROJECT_SOURCES})
 source_group("vendors" FILES ${VENDORS_SOURCES})
 
 find_package(Boost 1.56 REQUIRED COMPONENTS
-             program_options)
+             program_options log)
 
 set(EXE_1_NAME loader)
 file(
@@ -41,7 +41,7 @@ set(CMAKE_BINARY_DIR "bin")
 
 add_executable(${EXE_1_NAME} ${EXE_1_SOURCES} ${PROJECT_HEADERS}
                              ${PROJECT_SHADERS} ${VENDORS_SOURCES})
-target_link_libraries(${EXE_1_NAME} glfw Boost::program_options)
+target_link_libraries(${EXE_1_NAME} glfw Boost::program_options Boost::log)
 target_include_directories(${EXE_1_NAME} PRIVATE include)
 set_target_properties(${EXE_1_NAME} PROPERTIES
                       RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${EXE_1_NAME})

build.sh

@@ -5,4 +5,5 @@ cmake $flags .
 cmake --build .
 echo -e "running the program, passing the given args"
 echo -e "========================================"
+# shellcheck disable=SC2046 # Intended splitting of OPTIONS
 ./run.sh $@

data/shader/frag/basic.glsl

@@ -0,0 +1,7 @@
+#version 330 core
+out vec4 FragColor;
+
+void main()
+{
+    FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
+}

run.sh

@@ -1,3 +1,4 @@
 #!/bin/bash
 set -e
+# shellcheck disable=SC2046 # Intended splitting of OPTIONS
 ./bin/loader/loader $@

src/graphics.cpp

@@ -1,10 +1,251 @@
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/case_conv.hpp>
+#include <boost/log/trivial.hpp>
+#include <exception>
+#include <glad/glad.c>
+// glad must be loaded before GLFW
 #include "graphics.hpp"
-#include <GLFW/glfw3.h> // Include the library header file here
+#include "main.hpp"
 
-void init() {
-// Use GLFW functions here
+#include <iostream>
+
+using namespace std;
+
+ShaderProgram::Base ShaderProgram::baseFromName(string name) {
+  string lname = name;
+  boost::algorithm::to_lower(lname); // yes, cpp needs a library to do this.
+                                     // luckily I'm already using boost so I
+                                     // don't need to worry too much about it.
+  // can't do a switch over strings in cpp.
+  if (lname == "empty") {
+    return Empty;
+  }
+  if (lname == "triangle") {
+    return Triangle;
+  } else {
+    BOOST_LOG_TRIVIAL(fatal) << "unknown base program \"" << name << "\"";
+    exit(EXIT_USAGE);
+  }
 }
 
-void draw() {
-// Use GLFW functions here
+/* class ShaderProgram Implementations */
+string ShaderProgram::baseName() {
+  /*
+  BOOST_LOG_TRIVIAL(debug) << "this->base: " << this->base
+                           << " Base::Empty: " << Base::Empty
+                           << " Base::Triangle: " << Base::Triangle;
+  */
+  switch (this->base) {
+  case ShaderProgram::Base::Empty:
+    return "Empty";
+  case ShaderProgram::Base::Triangle:
+    return "Triangle";
+  default:
+    // this should never occur, as the switch case should cover all variants.
+    throw std::runtime_error("Undefined base Program");
+  }
+}
+
+/**
+ * @param vertexSource C style string with NULL termination
+ * @param fragSource C style string with NULL termination
+ */
+ShaderProgram::ShaderProgram(Base base, string vertexSource,
+                             string fragSource) {
+  int success;
+  char infoLog[512];
+  const char *vertexSource_c = vertexSource.c_str();
+  const char *fragSource_c = fragSource.c_str();
+  this->base = base;
+  BOOST_LOG_TRIVIAL(info) << "With base program \"" << this->baseName() << "\"";
+  // NOTE: char arrays and char pointers are not actually the same.
+  // glShaderSource requires a char[] as it appears. We pass the
+  // variable by reference to avoid duplication in memory.
+  BOOST_LOG_TRIVIAL(trace) << "creating empty shaders";
+  this->vertex = glCreateShader(GL_VERTEX_SHADER);
+  this->frag = glCreateShader(GL_FRAGMENT_SHADER);
+
+  BOOST_LOG_TRIVIAL(trace) << "loading vertex shader";
+  glShaderSource(this->vertex, 1, &vertexSource_c, NULL);
+  BOOST_LOG_TRIVIAL(trace) << "compiling vertex shader";
+  glCompileShader(this->vertex);
+  // check if it worked
+  glGetShaderiv(this->vertex, GL_COMPILE_STATUS, &success);
+  if (!success) {
+    glGetShaderInfoLog(this->vertex, 512, NULL, infoLog);
+    BOOST_LOG_TRIVIAL(fatal) << "could not compile vertex shader:\n\n"
+                             << infoLog << std::endl;
+    exit(EXIT_SHADER);
+  }
+
+  BOOST_LOG_TRIVIAL(trace) << "loading fragments shader";
+  glShaderSource(this->frag, 1, &fragSource_c, NULL);
+  BOOST_LOG_TRIVIAL(trace) << "compiling fragments shader";
+  glCompileShader(this->frag);
+  // check if it worked
+  glGetShaderiv(this->frag, GL_COMPILE_STATUS, &success);
+  if (!success) {
+    glGetShaderInfoLog(this->frag, 512, NULL, infoLog);
+    BOOST_LOG_TRIVIAL(fatal) << "could not compile fragments shader:\n\n"
+                             << infoLog << std::endl;
+    exit(EXIT_SHADER);
+  }
+
+  // combine it all in a actual program
+  this->program = glCreateProgram();
+  glAttachShader(this->program, this->vertex);
+  glAttachShader(this->program, this->frag);
+  glLinkProgram(this->program);
+
+  glGetProgramiv(this->program, GL_LINK_STATUS, &success);
+  if (!success) {
+    glGetProgramInfoLog(this->program, 512, NULL, infoLog);
+    BOOST_LOG_TRIVIAL(fatal) << "could not link shader program:\n\n"
+                             << infoLog << std::endl;
+    exit(EXIT_SHADER);
+  }
+
+  // finalizing our setup
+  glDeleteShader(this->vertex);
+  glDeleteShader(this->frag);
+}
+
+/** defines the base program behavior.
+ *
+ * will be called in `mainWindow`.
+ */
+int ShaderProgram::run(GLFWwindow *window) {
+  if (this->base == Triangle) {
+    // set up vertex data (and buffer(s)) and configure vertex attributes
+    // ------------------------------------------------------------------
+    float vTriangle[] = {
+        -0.5f, -0.5f, 0.0f, // left
+        0.5f,  -0.5f, 0.0f, // right
+        0.0f,  0.5f,  0.0f  // top
+    };
+
+    unsigned int VBOTriangle, VAOTriangle;
+    glGenVertexArrays(1, &VAOTriangle);
+    glGenBuffers(1, &VBOTriangle);
+    // bind the Vertex Array Object first, then bind and set vertex buffer(s),
+    // and then configure vertex attributes(s).
+    glBindVertexArray(VAOTriangle);
+
+    glBindBuffer(GL_ARRAY_BUFFER, VBOTriangle);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vTriangle), vTriangle, GL_STATIC_DRAW);
+
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float),
+                          (void *)0);
+    glEnableVertexAttribArray(0);
+
+    // note that this is allowed, the call to glVertexAttribPointer registered
+    // VBO as the vertex attribute's bound vertex buffer object so afterwards we
+    // can safely unbind
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    // You can unbind the VAO afterwards so other VAO calls won't accidentally
+    // modify this VAO, but this rarely happens. Modifying other VAOs requires a
+    // call to glBindVertexArray anyways so we generally don't unbind VAOs (nor
+    // VBOs) when it's not directly necessary.
+    glBindVertexArray(0);
+
+    // uncomment this call to draw in wireframe polygons.
+    // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    while (!glfwWindowShouldClose(window)) {
+      // input
+      // -----
+      processInput(window);
+
+      // render
+      // ------
+      glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
+      glClear(GL_COLOR_BUFFER_BIT);
+
+      // draw our first triangle
+      glUseProgram(this->program);
+      glBindVertexArray(VAOTriangle); // seeing as we only have a single VAO there's no
+                              // need to bind it every time, but we'll do so to
+                              // keep things a bit more organized
+      glDrawArrays(GL_TRIANGLES, 0, 3);
+      // glBindVertexArray(0); // no need to unbind it every time
+
+      // glfw: swap buffers and poll IO events (keys pressed/released, mouse
+      // moved etc.)
+      // -------------------------------------------------------------------------------
+      glfwSwapBuffers(window);
+      glfwPollEvents();
+    }
+    // optional: de-allocate all resources once they've outlived their purpose:
+    // ------------------------------------------------------------------------
+    glDeleteVertexArrays(1, &VAOTriangle);
+    glDeleteBuffers(1, &VBOTriangle);
+    glDeleteProgram(this->program);
+
+    // glfw: terminate, clearing all previously allocated GLFW resources.
+    // ------------------------------------------------------------------
+    glfwTerminate();
+    return 0;
+  } else // Empty
+  {
+    // use the compiled shader
+    glUseProgram(this->program);
+    while (!glfwWindowShouldClose(window)) {
+      processInput(window);
+
+      glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
+      glClear(GL_COLOR_BUFFER_BIT);
+
+      glfwSwapBuffers(window);
+      glfwPollEvents();
+    }
+    return 0;
+  }
+}
+
+/* functions that run out graphics stuff */
+
+void framebuffer_size_callback(GLFWwindow *window, int width, int height) {
+  glViewport(0, 0, width, height);
+}
+
+GLFWwindow *initGl() {
+  /* graphics stuff */
+  glfwInit();
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+  // glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+
+  GLFWwindow *window = glfwCreateWindow(800, 600, "Shader Loader", NULL, NULL);
+  if (window == NULL) {
+    printf("Failed to create GLFW window\n");
+    glfwTerminate();
+    exit(EXIT_GL);
+  }
+  glfwMakeContextCurrent(window);
+
+  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
+    printf("Failed to initialize GLAD\n");
+    exit(EXIT_GL);
+  }
+
+  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+  return window;
+}
+
+int mainWindow(ShaderProgram *shaderProgram, GLFWwindow *window) {
+
+  int result = 0;
+
+  BOOST_LOG_TRIVIAL(trace) << "Base program";
+  result = shaderProgram->run(window);
+  BOOST_LOG_TRIVIAL(trace) << "Left base program";
+
+  glfwTerminate();
+  return result;
+}
+
+void processInput(GLFWwindow *window) {
+  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+    glfwSetWindowShouldClose(window, true);
 }

src/graphics.hpp

@@ -1,9 +1,25 @@
 #ifndef GRAPHICS_HPP
 #define GRAPHICS_HPP
+#include <GLFW/glfw3.h>
 
-#include <GLFW/glfw3.h> // Include the library header file here
+#include <iostream>
+#include <string>
 
-void init();
-void draw();
+class ShaderProgram {
+public:
+  enum Base { Empty, Triangle };
+  std::string baseName();
+  static Base baseFromName(std::string name);
+  ShaderProgram(Base base, std::string vertexSource, std::string fragSource);
+  int run(GLFWwindow* window);
 
+protected:
+  unsigned int vertex;
+  unsigned int frag;
+  Base base;
+  unsigned int program;
+};
+int mainWindow(ShaderProgram* shaderProgramm, GLFWwindow* window);
+GLFWwindow* initGl();
+void processInput(GLFWwindow *window);
 #endif

src/main.cpp

@@ -1,7 +1,139 @@
-#include "graphics.hpp"
+#include <boost/log/trivial.hpp>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
 
-int main() {
-init();
-draw();
-return 0;
+#include "main.hpp"
+
+int main(int argc, char **argv) {
+
+  /* declarations */
+  int result = 0;
+
+  /* Parsing CLI Arguments */
+  po::options_description desc("Available options");
+  desc.add_options()("help,h", "show help")("verbose,v", "more verbose output")(
+      "vert", po::value<string>()->required(), "vertex shader file")(
+      "frag", po::value<string>()->required(), "fragment shader file")(
+      "base,b", po::value<string>()->required(), "base program");
+
+  /* unused for now */
+  po::positional_options_description pdesc;
+  // NOTE: if you want to add a positional argument,
+  // you need to create and option for it as it seems.
+  /* pdesc.add("vert", 1); */
+  /* pdesc.add("frag", 1); */
+
+  po::variables_map vm;
+  try {
+
+    po::store(po::command_line_parser(argc, argv)
+                  .options(desc)     // load options
+                  .positional(pdesc) // load positionals
+                  .run(),
+              vm);
+    po::notify(vm);
+    if (vm.count("help") || argc < 3) {
+      help(argv[0], desc);
+      return 1;
+    }
+  } catch (po::error &e) {
+    BOOST_LOG_TRIVIAL(fatal) << e.what() << endl << endl;
+    help(argv[0], desc);
+    return EXIT_USAGE;
+  }
+
+  // set boost log level to trace on verbose
+  // TODO: -v should decrease the default log level by 1 but be repeatable.
+  // (default should be info)
+  if (vm.count("verbose")) {
+    boost::log::core::get()->set_filter(boost::log::trivial::severity >=
+                                        boost::log::trivial::trace);
+    BOOST_LOG_TRIVIAL(trace)
+        << "verbose flag found, setting log level to trace";
+  }
+
+  /* init graphics stuff */
+  GLFWwindow *window = initGl();
+  if (result != 0) {
+    return EXIT_GL;
+  }
+
+  /* find the requested */
+  ShaderProgram::Base base =
+      ShaderProgram::baseFromName(vm["base"].as<string>());
+
+  /* setup the shader program */
+  BOOST_LOG_TRIVIAL(trace) << "Reading shader files";
+  ifstream fvert(vm["vert"].as<string>());
+  ifstream ffrag(vm["frag"].as<string>());
+  if (fvert.fail()) {
+    BOOST_LOG_TRIVIAL(fatal) << "failed to read vertex shader file";
+    exit(EXIT_IO);
+  }
+  if (ffrag.fail()) {
+    BOOST_LOG_TRIVIAL(fatal) << "failed to read fragments shader file";
+    exit(EXIT_IO);
+  }
+  string buf;
+  string vert;
+  string frag;
+  while(!fvert.eof()) {
+    getline(fvert, buf);
+    vert.append(buf + "\n");
+  }
+  while(!ffrag.eof()) {
+    getline(ffrag, buf);
+    frag.append(buf + "\n");
+  }
+  // get file sizes
+  BOOST_LOG_TRIVIAL(trace) << "Reading shader file sizes";
+  BOOST_LOG_TRIVIAL(debug) << "vert file:\n```glsl\n"
+                           << vert << "```\n"
+                           << vert.size() << "B";
+  BOOST_LOG_TRIVIAL(debug) << "frag file:\n```glsl\n"
+                           << frag << "```\n"
+                           << frag.size() << "B";
+  fvert.close();
+  ffrag.close();
+
+  BOOST_LOG_TRIVIAL(trace) << "Creating ShaderProgram";
+
+  // TODO: determinde ShaderProgram::Base with a CLI arg
+  ShaderProgram shaderProgram(base, vert, frag);
+
+  /* Run our main program */
+  BOOST_LOG_TRIVIAL(trace) << "Starting mainWindow";
+  result = mainWindow(&shaderProgram, window);
+  BOOST_LOG_TRIVIAL(trace) << "mainWindow stopped, goodbye";
+
+  return result;
+}
+
+void help(char *prog, po::options_description desc) {
+  cout << "Usage:" << endl
+       << prog
+       << " [-vh] [--vert] shaders/vertex.glsl [--frag] shaders/fragment.glsl"
+       << endl
+       << endl
+       << "return values:" << endl
+       << "0\tSuccess" << endl
+       << "1\tGeneric Failure" << endl
+       << "2\tBad arguments" << endl
+       << "3\tI/O Error" << endl
+       << "4\tOpenGL Error" << endl
+       << "5\tShader Source Error" << endl
+       << endl
+       << endl
+       << "base programs:" << endl
+       << "Empty\t\t-\tEmpty window with colored background" << endl
+       << "Triangle\t-\tA static Triangle" << endl
+       << endl
+       << endl
+       << desc << endl;
+  // NOTE: constants for the error codes are defined in main.hpp
 }

src/main.hpp

@@ -0,0 +1,25 @@
+#ifndef MAIN_HPP
+#define MAIN_HPP
+#include <boost/program_options.hpp>
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/positional_options.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <boost/log/core.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/log/expressions.hpp>
+
+#include "graphics.hpp"
+
+// EXIT_FAILURE and EXIT_SUCCESS are defined in cstdlib
+const int EXIT_USAGE = 2;
+const int EXIT_IO = 3;
+const int EXIT_GL = 4;
+const int EXIT_SHADER = 5;
+
+namespace po = boost::program_options;
+using namespace std;
+
+int main(int argc, char **argv);
+
+void help(char *prog, po::options_description desc);
+#endif