linker hell

.gitignore

@@ -5,4 +5,3 @@ 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 log)
+             program_options)
 
 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 Boost::log)
+target_link_libraries(${EXE_1_NAME} glfw Boost::program_options)
 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,5 +5,4 @@ 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

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

run.sh

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

src/graphics.cpp

@@ -1,251 +1,10 @@
-#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 "main.hpp"
+#include <GLFW/glfw3.h> // Include the library header file here
 
-#include <iostream>
+void init() {
-
+// Use GLFW functions here
-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);
-  }
 }
 
-/* class ShaderProgram Implementations */
+void draw() {
-string ShaderProgram::baseName() {
+// Use GLFW functions here
-  /*
-  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,25 +1,9 @@
 #ifndef GRAPHICS_HPP
 #define GRAPHICS_HPP
-#include <GLFW/glfw3.h>
 
-#include <iostream>
+#include <GLFW/glfw3.h> // Include the library header file here
-#include <string>
 
-class ShaderProgram {
+void init();
-public:
+void draw();
-  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,139 +1,7 @@
-#include <boost/log/trivial.hpp>
+#include "graphics.hpp"
-#include <cstddef>
-#include <cstdio>
-#include <cstdlib>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <string>
 
-#include "main.hpp"
+int main() {
-
+init();
-int main(int argc, char **argv) {
+draw();
-
+return 0;
-  /* 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

@@ -1,25 +0,0 @@
-#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