initial commit

bin/layers/opengl_panel/opengl_panel.cpp

@@ -0,0 +1,107 @@
+#include "opengl_panel.hpp"
+#include "utils.hpp"
+
+namespace sandbox
+{
+  cube::cube() 
+  {
+    hack::log()("create cube");
+
+    const std::filesystem::path vsp { "/mnt/raid/projects/vertex_engine/bin/layers/opengl_panel/shaders/vertes.shader" };
+    const std::filesystem::path fsp { "/mnt/raid/projects/vertex_engine/bin/layers/opengl_panel/shaders/frag.shader" };
+    add_shader(GL_VERTEX_SHADER, vsp);
+    add_shader(GL_FRAGMENT_SHADER, fsp);
+    shader_program::link();
+
+    m_vertices =  
+    { 
+     -0.1f,  0.0f,  0.7f,
+      0.1f,  0.0f,  0.7f,
+      0.1f,  0.0f, -0.7f,
+     -0.1f,  0.0f, -0.7f,
+      0.0f,  0.3f,  0.0f
+    };
+
+    m_indices = 
+    {
+      0, 1, 1, 4, 4, 0, 
+      0, 3, 3, 4, 4, 2, 
+      2, 1, 3, 2
+    };
+
+    buffer::link();
+  }
+
+  void cube::use() { shader_program::use(); }
+
+  void cube::set_scale(float val) { set("scale", val); }
+
+  void cube::set_position(glm::vec3 val) { set("position", val); }
+
+  void cube::set_color(glm::vec4 val) { set("color", val); }
+
+  void cube::render() { buffer::render(); }
+
+
+  void opengl_panel::on_attach() 
+  {
+    hack::log()("on_attach");
+  }
+
+  void opengl_panel::on_detach()
+  {
+    hack::log()("on_attach");
+  }
+
+  void opengl_panel::render()
+  {
+    // glm::mat4 view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
+    // glm::mat4 projection = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f);
+
+    cb_1.use();
+    // unsigned int viewLoc = glGetUniformLocation(cb_1.get_id(), "view");
+    // glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
+    // unsigned int projLoc = glGetUniformLocation(cb_1.get_id(), "projection");
+    // glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
+
+    float r = std::sin(glfwGetTime());
+    float g = std::cos(glfwGetTime());
+    cb_1.set_color(glm::vec4{ 0.85f, 0.45f, 0.95f, 0.f }); // розовый
+    cb_1.set_scale(1.0f + std::sin(glfwGetTime()) * 0.2f);
+    cb_1.set_position(glm::vec3{ 0.f, 0.5, 0.f });
+    cb_1.render();
+
+    r = std::cos(glfwGetTime());
+    g = std::sin(glfwGetTime());
+    cb_2.use();
+
+    // unsigned int viewLoc_1 = glGetUniformLocation(cb_2.get_id(), "view");
+    // glUniformMatrix4fv(viewLoc_1, 1, GL_FALSE, glm::value_ptr(view));
+    // unsigned int projLoc_1 = glGetUniformLocation(cb_2.get_id(), "projection");
+    // glUniformMatrix4fv(projLoc_1, 1, GL_FALSE, glm::value_ptr(projection));
+
+    cb_2.set_color(glm::vec4{ 0.66f, 0.66f, 0.66f, 0.f }); // серый/белый
+    cb_2.set_scale(1.0f - std::cos(glfwGetTime()) * 0.2f);
+    cb_2.set_position(glm::vec3{ r, g, 0.f });
+    cb_2.render();
+  }
+
+  void opengl_panel::on_event(VE::event e)
+  {
+    // для событий от перефирии
+    // if (e.m_type.type() == typeid(VE::event_type))
+    // {
+    //   auto t = std::any_cast<VE::event_type>(e.m_type);
+    //   if (t != VE::event_type::MOUSE_CURSOR_POSITION)
+    //     hack::log()((int)t);
+    // }
+
+    if (e.m_type.type() == typeid(test_event))
+    {
+      auto t = std::any_cast<test_event>(e.m_type);
+      if (t == test_event::TEST_EVEN)
+        hack::log()(std::any_cast<std::string>(e.m_data));
+    }
+  }
+}
+

bin/layers/opengl_panel/opengl_panel.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "VE.hpp"
+
+namespace sandbox
+{
+
+  class cube : public VE::opengl
+  {
+    public:
+      cube();
+      ~cube() = default;
+
+    public:
+      void set_scale(float val);
+      void set_position(glm::vec3 val);
+      void set_color(glm::vec4 val);
+      void use();
+      void render();
+  };
+
+  class opengl_panel : public VE::layer
+  {
+    VE_FN_OVERIDE();
+
+    cube cb_1;
+    cube cb_2;
+  };
+}
+

bin/layers/opengl_panel/shaders/frag.shader

@@ -0,0 +1,9 @@
+#version 330 core
+
+in vec4 v_color;
+out vec4 f_color;
+
+void main()
+{
+  f_color = v_color;
+} 

bin/layers/opengl_panel/shaders/vertes.shader

@@ -0,0 +1,22 @@
+#version 330 core
+
+layout (location = 0) in vec3 base_position;
+
+uniform float scale;
+uniform vec4  color;
+uniform vec3  position;
+
+uniform mat4 view;
+uniform mat4 model;
+uniform mat4 projection;
+
+out vec4 v_color;
+
+void main()
+{
+  vec3 p = base_position + position * scale ;
+  // gl_Position = projection * view * vec4(p, 1.0);
+  gl_Position = vec4(p, 1.0);
+  v_color = color;
+}
+