SFTtech · sandsmark · Apr 19, 2015 · Apr 19, 2015 · Apr 19, 2015 · Apr 20, 2015
diff --git a/.mailmap b/.mailmap
@@ -13,3 +13,4 @@ Henry Snoek <?> <snoek09@users.noreply.github.com>
 coop shell (Michael Enßlin, Jonas Jelten, Andre Kupka) <coop@sft.mx>
 Franz-Niclas Muschter <fm@stusta.net> <franz-niclas.muschter@stusta.net>
 Niklas Fiekas <niklas.fiekas@backscattering.de> <niklas.fiekas@tu-clausthal.de>
+Wojciech Nawrocki <wjnawrocki@protonmail.com> <wjnawrocki+gh@protonmail.com>
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -54,6 +54,14 @@ if(NOT DEFINED WANT_INOTIFY)
 	set(WANT_INOTIFY if_available)
 endif()
 
+if(NOT DEFINED WANT_OPENGL)
+	set(WANT_OPENGL if_available)
+endif()
+
+if(NOT DEFINED WANT_VULKAN)
+	set(WANT_VULKAN if_available)
+endif()
+
 if(NOT DEFINED WANT_GPERFTOOLS_PROFILER)
 	set(WANT_GPERFTOOLS_PROFILER if_available)
 endif()

diff --git a/README.md b/README.md
@@ -29,7 +29,7 @@ Technology     | Component
 **Qt5**        | Graphical user interface
 **Cython**     | Glue code
 **CMake**      | Build system
-**OpenGL2.1**  | Rendering, shaders
+**OpenGL3.3**  | Rendering, shaders
 **SDL2**       | Cross-platform Audio/Input/Window handling
 **Opus**       | Audio codec
 **Humans**     | Mixing together all of the above

diff --git a/buildsystem/modules/FindInotify.cmake b/buildsystem/modules/FindInotify.cmake
@@ -1,4 +1,4 @@
-# Copyright 2014-2014 the openage authors. See copying.md for legal info.
+# Copyright 2014-2015 the openage authors. See copying.md for legal info.
 
 # This module defines
 #
@@ -8,6 +8,6 @@
 find_path(INOTIFY_INCLUDE_DIR sys/inotify.h HINTS /usr/include/${CMAKE_LIBRARY_ARCHITECTURE})
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(INOTIFY DEFAULT_MSG INOTIFY_INCLUDE_DIR)
+find_package_handle_standard_args(inotify DEFAULT_MSG INOTIFY_INCLUDE_DIR)
 
 mark_as_advanced(INOTIFY_INCLUDE_DIR)
diff --git a/buildsystem/modules/FindVulkan.cmake b/buildsystem/modules/FindVulkan.cmake
@@ -0,0 +1,50 @@
+# Copyright 2015-2015 the openage authors. See copying.md for legal info.
+#
+# (To distribute this file outside of openage, extend the above
+#  copyright line with an appropriate GPLv3 or later reference,
+#  as you probably don't have a our copying.md)
+
+
+#=================================================================
+# Locate Vulkan graphics library
+#
+# usage:
+#   find_package(Vulkan)
+#
+# This module sets the following variables:
+# VULKAN_FOUND            True, if the system has Vulkan.
+# VULKAN_INCLUDE_DIR      Path to the Vulkan include directory.
+# VULKAN_LIBRARIES        Paths to the Vulkan libraries.
+#=================================================================
+
+set(_Vulkan_REQUIRED_VARS "VULKAN_vk_LIBRARY" "VULKAN_INCLUDE_DIR")
+
+find_path(VULKAN_INCLUDE_DIR
+	VK/vk.h
+	/opt/graphics/Vulkan/include
+)
+
+find_library(VULKAN_vk_LIBRARY
+	NAMES VK Vulkan
+	PATHS
+	/opt/graphics/Vulkan/lib
+)
+
+if(VULKAN_vk_LIBRARY)
+	set(VULKAN_LIBRARIES ${VULKAN_vk_LIBRARY})
+endif()
+
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+	Vulkan
+	REQUIRED_VARS ${_Vulkan_REQUIRED_VARS}
+	FAIL_MESSAGE "Vulkan NOT found."
+)
+
+unset(_Vulkan_REQUIRED_VARS)
+
+mark_as_advanced(
+	VULKAN_INCLUDE_DIR
+	VULKAN_vk_LIBRARY
+)
diff --git a/configure b/configure
@@ -69,6 +69,8 @@ def getenv_bool(varname):
 OPTIONS = {
     "backtrace": "if_available",
     "inotify": "if_available",
+    "opengl": "if_available",
+    "vulkan": "if_available",
     "gperftools-tcmalloc": False,
     "gperftools-profiler": "if_available",
 }
@@ -81,7 +83,6 @@ def features(args, parser):
     the defaults below will be used.
     """
 
-
     def sanitize_option_name(option):
         """ Check if the given feature exists """
         if option not in OPTIONS:

diff --git a/doc/renderer/doc.md b/doc/renderer/doc.md
@@ -0,0 +1,143 @@
+# Openage graphics
+The graphics subsystem is implemented in two levels. The first level is an abstraction over graphics APIs (OpenGL, Vulkan) and provides generic shader execution methods. The second level uses the first to draw openage-specific graphics, i.e. the actual world, units, etc.
+
+### Namespaces:
+`openage::renderer` - the level 1 renderer
+`openage::renderer::opengl` - the OpenGL implementation
+`openage::renderer::vulkan` - the Vulkan implementation
+`openage::renderer::resources` - management of graphics assets
+
+__TODO name__
+`openage::graphics` - the level 2 system
+
+Every namespace is an actual directory and all its classes are contained there.
+
+## Level 1:
+### Overview
+First things first, we might want to support multiple APIs. For now just OpenGL, but maybe Vulkan or some others.  We want to abstract over these, but this can't unfortunately be done at the level of graphics primitives like textures, buffers, etc. Well, it can, but it introduces unnecessary complexity and possible overhead. That is because the next-gen (Vulkan, Metal, DX12) APIs are vastly different from the old ones - most importantly, they're bindless, so something like a Vulkan context (GL notion) doesn't even make sense. We therefore choose to abstract on the higher level of things-to-draw.
+
+It works similarly to the Unity engine. The user can submit resources to be uploaded to the GPU and receives a handle that identifies the uploaded resource. Resources can be added, updated and removed. Currently supported resource types: shader, texture.
+
+### Thread-safety
+This level might or might not be threadsafe depending on the concrete implementation. The OpenGL version is, in typical GL fashion, so not-threadsafe it's almost anti-threadsafe. All code must be executed sequentially on a dedicated window thread, the same one on which the window and renderer were initially created. The plan for the Vulkan version is to make it at least independent of thread-local storage and hopefully completely threadsafe.
+
+### Shaders
+
+<NOTE: this is an unorganized braindump, i'll rewrite it later>
+
+These are more involved than resources, since each shader also carries a set of uniforms.
+
+A shader program takes in uniform values and vertex inputs and produces a number of bitmaps written into its render targets. Every shader program is then a function of the form $S:P\times\prod\limits^{n_u} U_i\times\left(\prod\limits^{n_a}V_j\right)^n\rightarrow\prod\limits^{n_t}B_k$, where $P$ is the primitive type, $\{U_i\}$, $\{V_j\}$, $\{B_k\}$ are indexed families of uniform, vertex attribute and bitmap types, respectively and the shader takes in $n_u$ uniforms, $n$ vertices with $n_a$ attributes per vertex and outputs to $n_t$ render targets.
+
+All of these inputs are contained in the $Renderable$ type. There is a catch here, since shaders are stateful, arguments are preserved between calls.
+
+Keep in mind that the output bitmap is not necessarily what the final output in a render target will be, since multiple draw calls get combined into a single bitmap and the initial value of the target also has an effect.
+
+With this premise, we can create a renderer interface generic over low-level APIs and usage (although optimized for openage's purposes). The only renderables are sets of values to be passed to shader programs - they may or may not include geometry, textures, matrices, etc.
+
+Our $ShaderInput$ class conceptually has almost the same member types as the types in the domain of the corresponding shader program function, with some small differences. For example, OpenGL shaders have implicit vertex attributes like $gl\_VertexID$ which we do not valuate manually.
+
+For the most part, these types are not know statically, so $ShaderInput$ has to simulate them internally with dynamic dispatch while providing an external interface that acts as if its members are the same as the inputs to the shader.
+
+OTOH, when it is the case that they are know statically, we can generate the appropriate headers from the shader code for better performance (in the future).
+
+Figure out the interface for $ShaderInput$.
+
+Parametrize $ShaderInput$ over a $Shader$ type. Have one $DynamicShader$ for all shaders loaded at runtime and some $StaticShaderForSpecificThing$ classes for shaders known beforehand. Make $DynamicShader$ compile for all operations and $StaticShader$.. only have operations it supports implemented, making it check them at compile-time.
+
+```c++
+template<typename S>
+class ShaderInput {
+  template<unsigned int U, typename T>
+  void set_unif(T val) {
+    // always compiles for dynamic shader,
+    // only compiles for valid U and T for static shader
+    (instanceof S).set_unif<U, T>(val);
+  }
+};
+
+template<unsigned int N>
+void func() {
+    static_assert(N != N, "Invalid shader uniform name.");
+}
+
+template<>
+void func<COMPILE_TIME_CRC32_STR("val1")>() {
+    cout << "val1" << endl;
+    return;
+}
+
+template<>
+void func<COMPILE_TIME_CRC32_STR("val2")>() {
+    cout << "val2" << endl;
+    return;
+}
+```
+
+How to deal with drawing the scene?
+We want stateless drawing, but pure stateless incurs some overhead. We can probably do with some mix of sharing scene between renderer and user. Keep a Scene object containing renderables (just shader valuations) and pass it to the render method.
+What shoud Scene contain?
+```c++
+struct Scene {
+    std::vector<ObjectId>;
+    OR
+    std::vector<std::shared_ptr<Object>>;
+    SceneSettings...
+        alpha blending, ztest, all of that in Object
+        is there anything global?
+        From Unity3D:
+            far, near plane
+            default depth
+            projection type
+            occlusion culling method
+            HDR
+            AA styles
+            how to deal with unit picking? probably have to make it a separate render pass
+            that renders unit ids into a buffer. read it on CPU or GPU? GPU faster, but is it possible?
+            general render-pass related things; have objects for render passes?
+};
+```
+alternatively call render_pass(..) for each pass rather than call render(OBJ) once where OBJ contains info about render passes. might be nicer since render pass info can be recovered. problem - have to sync CPU/GPU to wait for command buffer execution finish
+QUESTION:
+    share ownership of scene data at all times or give views to the user that are only accessible when not rendering?
+
+### Usage
+Sample usage:
+
+```c++
+Window window("title");
+auto renderer = opengl::GlRenderer(window.get_context());
+
+resources::TextureData tex_data("/path.tex");
+std::unique_ptr<Texture> tex = renderer->add_texture(tex_data);
+
+resources::ShaderSource vsrc = resources::ShaderSource::read_from_file("/path.vert", resources::shader_t::glsl_vertex);
+resources::ShaderSource fsrc = resources::ShaderSource::read_from_file("/path.frag", resources::shader_t::glsl_fragment);
+
+std::unique_ptr<ShaderProgram> prog = renderer->add_shader( { vsrc, fsrc } );
+
+auto input = prog->new_uniform_input(
+  "color", { 0.0f, 1.0f, 0.0f },
+  "time", 0.0f,
+  "num", 1337
+);
+
+RenderPass pass {
+  { {
+    input,
+    new Geometry(geometry_t::quad),
+    true,
+    true,
+    true,
+    true,
+  } }, // list of renderables
+  renderer->get_framebuffer_target(),
+  1.0f,
+  8,
+};
+
+renderer->render(pass);
+```
+
+## Level 2:
+On top of that renderer, we build a level 2 graphics subsystem. It has an API that is actually specific to openage, and is threadsafe. The level-2 renderer calls the level 1 renderer and updates it to match the game state.
diff --git a/libopenage/CMakeLists.txt b/libopenage/CMakeLists.txt
@@ -37,8 +37,8 @@ add_subdirectory("gui")
 add_subdirectory("error")
 add_subdirectory("gamestate")
 add_subdirectory("input")
-add_subdirectory("log")
 add_subdirectory("job")
+add_subdirectory("log")
 add_subdirectory("pathfinding")
 add_subdirectory("pyinterface")
 add_subdirectory("renderer")
@@ -49,7 +49,6 @@ add_subdirectory("testing")
 add_subdirectory("unit")
 add_subdirectory("util")
 
-
 # run codegen, add files to executable
 codegen_run()
 add_sources(libopenage GENERATED ${CODEGEN_TARGET_TUS})
@@ -150,6 +149,35 @@ else()
 	have_config_option(inotify INOTIFY false)
 endif()
 
+# opengl support
+if(WANT_OPENGL)
+	find_package(OpenGL)
+endif()
+
+# vulkan support
+if(WANT_VULKAN)
+	find_package(Vulkan)
+endif()
+
+if(WANT_OPENGL AND OPENGL_FOUND)
+	have_config_option(opengl OPENGL true)
+	include_directories(${OPENGL_INCLUDE_DIR})
+else()
+	have_config_option(opengl OPENGL false)
+endif()
+
+if(WANT_VULKAN AND VULKAN_FOUND)
+	have_config_option(vulkan VULKAN true)
+	include_directories(${VULKAN_INCLUDE_DIR})
+else()
+	have_config_option(vulkan VULKAN false)
+endif()
+
+if(NOT (OPENGL_FOUND OR VULKAN_FOUND))
+	message(FATAL_ERROR "One of OpenGL or Vulkan is required!")
+endif()
+
+
 get_config_option_string()
 
 configure_file(config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/config.h)

diff --git a/libopenage/config.h.in b/libopenage/config.h.in
@@ -8,6 +8,8 @@
 
 #define WITH_BACKTRACE ${WITH_BACKTRACE}
 #define WITH_INOTIFY ${WITH_INOTIFY}
+#define WITH_OPENGL ${WITH_OPENGL}
+#define WITH_VULKAN ${WITH_VULKAN}
 #define WITH_GPERFTOOLS_PROFILER ${WITH_GPERFTOOLS_PROFILER}
 #define WITH_GPERFTOOLS_TCMALLOC ${WITH_GPERFTOOLS_TCMALLOC}
 

diff --git a/libopenage/renderer/CMakeLists.txt b/libopenage/renderer/CMakeLists.txt
@@ -1,6 +1,19 @@
 add_sources(libopenage
-	color.cpp
-	text.cpp
+  color.cpp
+  geometry.cpp
+  renderer.h
+  shader_program.h
+  tests.cpp
+  text.cpp
+  texture.cpp
+  window.cpp
 )
 
-add_subdirectory(font)
+pxdgen(
+	tests.h
+)
+
+add_subdirectory(font/)
+add_subdirectory(opengl/)
+add_subdirectory(resources/)
+#add_subdirectory(shaders/)
diff --git a/libopenage/renderer/color.cpp b/libopenage/renderer/color.cpp
@@ -10,11 +10,10 @@ Color::Color()
 	r{0},
 	g{0},
 	b{0},
-	a{255} {
-	// Empty
-}
+	a{255} {}
 
-Color::Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+Color::Color(color_channel_t r, color_channel_t g,
+             color_channel_t b, color_channel_t a)
 	:
 	r{r},
 	g{g},

diff --git a/libopenage/renderer/color.h b/libopenage/renderer/color.h
@@ -8,20 +8,20 @@ namespace openage {
 namespace renderer {
 
 class Color {
+	using color_channel_t = uint8_t;
+
 public:
 	Color();
-
-	Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
+	Color(color_channel_t r, color_channel_t g, color_channel_t b, color_channel_t a);
 
 	bool operator==(const Color &other) const;
 
-	bool operator!=(const Color &other) const;
-
-	uint8_t r;
-	uint8_t g;
-	uint8_t b;
-	uint8_t a;
+	bool operator !=(const Color &other) const;
 
+	color_channel_t r;
+	color_channel_t g;
+	color_channel_t b;
+	color_channel_t a;
 };
 
 }} // openage::renderer