Implementing editor window

resources/shaders/3d_project.vert

@@ -0,0 +1,11 @@
+#version 460 core
+
+layout(location = 0) in vec3 i_vertex_position;
+
+uniform mat4 u_model_matrix;
+uniform mat4 u_vp_matrix;
+
+void main()
+{
+    gl_Position = u_vp_matrix * u_model_matrix * vec4(i_vertex_position, 1.0);
+}

resources/shaders/grid.frag

@@ -0,0 +1,27 @@
+#version 460 core
+
+in vec2 fragment_position;
+flat in int line_segment_index;
+
+uniform float u_grid_size;
+uniform int u_grid_count;
+
+out vec4 o_color;
+
+vec3 lighten(vec3 color, float percent) { return color * percent; }
+
+float is_nth(int i, int n) { return (1 - sign(i % n - .5)) / 2.0; }
+
+void main()
+{
+    vec3 color = vec3(0.4);
+    const float max_distance = (u_grid_count / 4) * u_grid_size;
+
+    float nth = is_nth(abs(line_segment_index), 10);
+    color = lighten(color, 1.0 + nth * .5);
+
+    float falloff = 1 - distance(fragment_position, vec2(0)) / max_distance;
+    falloff = clamp(falloff, 0, 1);
+
+    o_color = vec4(color, falloff);
+}

resources/shaders/grid.vert

@@ -0,0 +1,55 @@
+#version 460 core
+
+layout(location = 0) in vec2 i_vertex_position;
+
+uniform vec3 u_grid_origin;
+uniform mat4 u_model_matrix;
+uniform mat4 u_vp_matrix;
+uniform float u_grid_size;
+uniform int u_grid_count;
+
+out vec2 fragment_position;
+flat out int line_segment_index;
+
+void main()
+{
+    const int grid_count_half = u_grid_count / 2;
+    const int grid_count_quarter = u_grid_count / 4;
+
+    /*
+       Determine, whether the x and y coordinates should be swapped.
+       Basically, the upper half number of instances will be used as y axis
+       grid.
+    */
+    int switch_factor = gl_InstanceID / grid_count_half;
+
+    /*
+       Calculates the the index of the line in the axis range. Counts from 0.
+    */
+    int index_per_axis = gl_InstanceID % grid_count_half;
+
+    /*
+       Calculate the displacement across the axis.
+    */
+    int symmetric_index = index_per_axis - grid_count_quarter;
+    float position_per_axis = symmetric_index * u_grid_size;
+
+    vec2 pos = i_vertex_position;
+    pos.x = position_per_axis;
+
+    /*
+       Calculate the length of each line, so that the grid closes complete
+    */
+    pos.y *= u_grid_size * grid_count_quarter;
+
+    /*
+       Based on the instance id, determine whether this is an x axis or y axis
+       grid line
+    */
+    pos = mix(pos.xy, pos.yx, switch_factor);
+
+    mat4 mvp = u_vp_matrix * u_model_matrix;
+    gl_Position = mvp * vec4(pos.x, 0, pos.y, 1);
+    fragment_position = pos;
+    line_segment_index = symmetric_index;
+}

resources/shaders/simple_coloring.frag

@@ -0,0 +1,7 @@
+#version 460 core
+
+uniform vec4 u_color = vec4(1, 0, 1, 1);
+
+out vec4 o_color;
+
+void main() { o_color = u_color; }

resources/standard/basic_lit.shader

@@ -0,0 +1,2 @@
+../shaders/3d_project.vert
+../shaders/simple_coloring.frag

resources/standard/grid.shader

@@ -0,0 +1,2 @@
+../shaders/grid.vert
+../shaders/grid.frag

resources/standard/line.shader

@@ -0,0 +1,2 @@
+../shaders/3d_project.vert
+../shaders/simple_coloring.frag

src/CMakeLists.txt

@@ -62,6 +62,8 @@ add_library(
   viewport.cpp
   window.hpp
   window.cpp
+  experimental/editor_window.hpp
+  experimental/editor_window.cpp
   experimental/input_system.hpp
   experimental/input_system.cpp
   experimental/viewport.hpp

src/experimental/editor_window.cpp

@@ -0,0 +1,163 @@
+#include <optional>
+
+#include "experimental/editor_window.hpp"
+
+#include "asset_manager.hpp"
+#include "experimental/input_system.hpp"
+#include "renderer_3d.hpp"
+
+namespace experimental
+{
+
+editor_window::editor_window()
+{
+    on_user_initialize += [ this ](auto) { initialize(); };
+}
+
+editor_window::~editor_window() { }
+
+void editor_window::initialize()
+{
+    asset_manager::default_asset_manager()->load_asset(
+        "resources/standard/grid.shader");
+    asset_manager::default_asset_manager()->load_asset(
+        "resources/standard/line.shader");
+
+    _camera_position = { 5, 5, 5 };
+    _camera_direction = glm::normalize(glm::vec3 { 1, 1, 1 });
+
+    input_system::on_keypress += [ this ](int keycode)
+    {
+        // control local camera movement
+        switch (keycode)
+        {
+        // case GLFW_KEY_D:
+        // {
+        //     _camera_position.x += .1;
+        //     break;
+        // }
+        // case GLFW_KEY_A:
+        // {
+        //     _camera_position.x -= .1;
+        //     break;
+        // }
+        // case GLFW_KEY_SPACE:
+        // {
+        //     _camera_position.y += .1;
+        //     break;
+        // }
+        // case GLFW_KEY_LEFT_CONTROL:
+        // {
+        //     _camera_position.y -= .1;
+        //     break;
+        // }
+        case GLFW_KEY_W:
+        {
+            _camera_position -= _camera_direction * .07f;
+            break;
+        }
+        case GLFW_KEY_S:
+        {
+            _camera_position += _camera_direction * .07f;
+            break;
+        }
+        }
+    };
+    get_events().render += [ this ](auto re)
+    {
+        render_grid();
+        render_axis();
+    };
+    get_events().mouse_move += [ this ](auto me)
+    {
+        if (!get_has_grab())
+        {
+            _mouse_position = std::nullopt;
+            return;
+        }
+
+        if (!_mouse_position)
+        {
+            _mouse_position = me.get_local_position();
+            return;
+        }
+
+        auto diff = me.get_local_position() - _mouse_position.value();
+        _mouse_position = me.get_local_position();
+
+        _camera_direction =
+            glm::normalize(glm::rotate(glm::rotate(glm::identity<glm::quat>(),
+                                                   glm::radians(diff.x),
+                                                   glm::vec3(0, 1, 0)),
+                                       glm::radians(-diff.y),
+                                       glm::vec3(1, 0, 0)) *
+                           _camera_direction);
+    };
+}
+
+void editor_window::render_grid()
+{
+    auto camera_right =
+        glm::normalize(glm::cross(_camera_direction, { 0, 1, 0 }));
+    auto camera_up =
+        glm::normalize(glm::cross(camera_right, _camera_direction));
+    auto inverse_view_from_origin =
+        glm::mat4(glm::mat3(camera_right, camera_up, _camera_direction));
+    auto inverse_view =
+        glm::translate(glm::identity<glm::mat4>(), _camera_position) *
+        inverse_view_from_origin;
+    auto view = glm::inverse(inverse_view);
+    auto projection = glm::perspective(glm::radians(45.0f), 1.0f, 0.1f, 100.0f);
+
+    glViewport(0, 0, get_width(), get_height());
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    renderer_3d::draw_grid(0.3f, glm::identity<glm::mat4>(), view, projection);
+}
+
+void editor_window::render_axis()
+{
+    auto camera_right =
+        glm::normalize(glm::cross(_camera_direction, { 0, 1, 0 }));
+    auto camera_up =
+        glm::normalize(glm::cross(camera_right, _camera_direction));
+    auto inverse_view_from_origin =
+        glm::mat4(glm::mat3(camera_right, camera_up, _camera_direction));
+    auto inverse_view =
+        glm::translate(glm::identity<glm::mat4>(), _camera_position) *
+        inverse_view_from_origin;
+    auto view = glm::inverse(inverse_view);
+    auto projection = glm::perspective(glm::radians(45.0f), 1.0f, 0.1f, 100.0f);
+
+    unsigned axis_viewport_size = 80;
+    glViewport(get_width() - axis_viewport_size - 20,
+               get_height() - axis_viewport_size - 20,
+               axis_viewport_size,
+               axis_viewport_size);
+    view = glm::inverse(inverse_view_from_origin);
+
+    renderer_3d::draw_ray(glm::vec3 { -_camera_direction },
+                          glm::vec3 { 1, 0, 0 },
+                          0.3f,
+                          { 1, 0, 0, 1 },
+                          view,
+                          projection);
+    renderer_3d::draw_ray(glm::vec3 { -_camera_direction },
+                          glm::vec3 { 0, 1, 0 },
+                          0.3f,
+                          { 0, 1, 0, 1 },
+                          view,
+                          projection);
+    renderer_3d::draw_ray(glm::vec3 { -_camera_direction },
+                          glm::vec3 { 0, 0, 1 },
+                          0.3f,
+                          { 0, 0, 1, 1 },
+                          view,
+                          projection);
+}
+
+} // namespace experimental

src/experimental/editor_window.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "experimental/window.hpp"
+#include "utils.hpp"
+
+namespace experimental
+{
+
+class editor_window
+    : public window
+    , public singleton<editor_window>
+{
+public:
+    ~editor_window();
+
+private:
+    editor_window();
+
+    void initialize();
+    void render_grid();
+    void render_axis();
+
+    friend singleton_t;
+
+private:
+    glm::vec3 _camera_position;
+    glm::vec3 _camera_direction;
+    std::optional<glm::vec2> _mouse_position;
+};
+
+} // namespace experimental