examples: particles: added gui settings for particle emitter

Author: San7o

TODO

@@ -1,4 +1,2 @@
-- implement signals for node scripts
-- particle playground example
-- make nodes types more modular
 - standard ECS library
+- implement signals for node scripts

examples/particles.cpp

@@ -11,11 +11,15 @@
 #include <brenta/logger.hpp>
 #include <brenta/gui.hpp>
 #include <brenta/window.hpp>
+#include <brenta/mouse.hpp>
 
 #include <bitset>
 
 using namespace brenta;
 
+void setup_gui(FrameBuffer &fb,
+               ParticleEmitter *emitter);
+
 int main()
 {
   const int SCR_WIDTH = 1280;
@@ -65,14 +69,134 @@ int main()
       .starting_spread(glm::vec3(3.0f, 10.0f, 3.0f))
       .starting_time_to_live(0.5f)
       .num_particles(1000)
-      .spawn_rate(0.01f)
+      .spawn_rate(0.99f)
       .scale(1.0f)
       .atlas_path("examples/assets/textures/particle_atlas.png")
       .atlas_width(8)
       .atlas_height(8)
       .atlas_index(3)
       .build();
 
+
+  Mouse mouse = {};
+  mouse.set_sensitivity(0.05f);
+  
+  Input::add_mouse_callback("rotate_camera",
+                            [camera, &mouse](double xpos, double ypos)
+  {
+    // Rotate the camera
+    if (Window::is_key_pressed(Key::LeftShift))
+    {
+      if (mouse.get_first())
+      {
+        mouse.set_x(xpos);
+        mouse.set_y(ypos);
+        mouse.set_first(false);
+      }
+
+      float xoffset = xpos - mouse.get_x();
+      float yoffset = mouse.get_y() - ypos;
+      mouse.set_x(xpos);
+      mouse.set_y(ypos);
+
+      auto sensitivity = mouse.get_sensitivity();
+      xoffset *= sensitivity;
+      yoffset *= sensitivity;
+
+      auto new_cam = camera->get_pos();
+      try {
+        Camera::Spherical scam = std::get<Camera::Spherical>(new_cam);
+        scam.theta += yoffset * sensitivity;
+        scam.phi   += xoffset * sensitivity;
+
+        if (scam.theta <= 0.01f) scam.theta = 0.01f;
+        if (scam.theta >= 3.13f) scam.theta = 3.13f;
+
+        camera->set_pos(scam);
+        
+      } catch ([[maybe_unused]] const std::bad_variant_access& ex) {
+        return;
+      }
+    }
+    // translate the cam center
+    else if (Window::is_key_pressed(Key::LeftControl))
+    {
+      if (mouse.get_first())
+      {
+        mouse.set_x(xpos);
+        mouse.set_y(ypos);
+        mouse.set_first(false);
+      }
+
+      float xoffset = xpos - mouse.get_x();
+      float yoffset = mouse.get_y() - ypos;
+      mouse.set_x(xpos);
+      mouse.set_y(ypos);
+
+      auto sensitivity = mouse.get_sensitivity();
+      xoffset *= sensitivity * 0.3f;
+      yoffset *= sensitivity * 0.3f;
+
+      auto new_cam = camera->get_pos();
+      try {
+        Camera::Spherical scam = std::get<Camera::Spherical>(new_cam);
+        glm::vec3 world_pos = camera->get_transform().get_pos();
+        // Local coordinate system
+        glm::vec3 fixed_center =
+          glm::vec3(scam.center.x, world_pos.y, scam.center.z);
+        // Unit vectors
+        glm::vec3 front =
+          glm::normalize(world_pos - fixed_center);
+        glm::vec3 right =
+          glm::normalize(glm::cross(front, camera->get_world_up()));
+
+        scam.center += right * glm::vec3(xoffset);
+        scam.center -= camera->get_world_up() * glm::vec3(yoffset);
+
+        camera->set_pos(scam);
+      } catch ([[maybe_unused]] const std::bad_variant_access& ex) {
+        return;
+      }
+    }
+    // zoom the camera
+    else if (Window::is_key_pressed(Key::LeftAlt))
+    {
+      if (mouse.get_first())
+      {
+        mouse.set_x(xpos);
+        mouse.set_y(ypos);
+        mouse.set_first(false);
+      }
+
+      float xoffset = xpos - mouse.get_x();
+      float yoffset = mouse.get_y() - ypos;
+      mouse.set_x(xpos);
+      mouse.set_y(ypos);
+
+      xoffset *= mouse.get_sensitivity();
+      yoffset *= mouse.get_sensitivity();
+      
+      auto new_cam = camera->get_pos();
+      try {
+        Camera::Spherical scam = std::get<Camera::Spherical>(new_cam);
+
+        scam.radius -= yoffset;
+        if (scam.radius <= 0.1f) scam.radius = 0.1f;
+
+        camera->set_pos(scam);
+      } catch ([[maybe_unused]] const std::bad_variant_access& ex) {
+        return;
+      }
+    }
+    else
+    {
+      mouse.set_first(true);
+    }
+  });
+  
+  Gui::load_font();
+  FrameBuffer fb(Window::get_width(), Window::get_height());  
+  
   //
   // Render loop
   //
@@ -81,15 +205,53 @@ int main()
   {
     if (Window::is_key_pressed(Key::Escape))
       Window::close();
-
+    // TODO: movement
+    
+    setup_gui(fb, &emitter);
+    
     Gl::set_color(Color::grey());
     Gl::clear();
 
+    fb.bind();
     emitter.update(Window::get_time().get_delta());
     emitter.render();
+    fb.unbind();
 
+    Gui::render();
+    
     Window::poll_events();
     Window::swap_buffers();
   }
   return 0;
 }
+
+void setup_gui(FrameBuffer &fb,
+               ParticleEmitter *emitter)
+{
+  Gui::new_frame(&fb, "particles");
+  Gui::push_font();
+  ImGui::Begin("Particle settings");
+
+  // Position and Movement
+  ImGui::SliderFloat3("Starting position",
+                      &emitter->starting_position.x, -50.0f, 50.0f);
+  ImGui::SliderFloat3("Starting velocity",
+                      &emitter->starting_velocity.x, -15.0f, 15.0f);
+  ImGui::SliderFloat3("Starting spread",
+                      &emitter->starting_spread.x, 0.0f, 10.0f);
+
+  // Timing and Life
+  ImGui::SliderFloat("Starting time to live",
+                     &emitter->starting_time_to_live, 0.0f, 15.0f);
+  ImGui::SliderFloat("Spawn rate",
+                     &emitter->spawn_rate, 0.0f, 1.0f);
+
+  // Quantity and Appearance
+  ImGui::SliderInt("Number of particles",
+                   &emitter->num_particles, 1, BRENTA_MAX_PARTICLES);
+  ImGui::SliderFloat("Scale",
+                     &emitter->scale, 0.01f, 5.0f);
+  
+  ImGui::End();
+  Gui::pop_font();
+}

include/brenta/renderer/particles.hpp

@@ -80,7 +80,7 @@ struct ParticleEmitter::Config
   glm::vec3               starting_spread       = {};
   float                   starting_time_to_live = 1.0f;
   int                     num_particles         = BRENTA_MAX_PARTICLES;
-  float                   spawn_rate            = 0.01f;
+  float                   spawn_rate            = 0.99f;
   float                   scale                 = 1.0f;
   std::filesystem::path   atlas_path            = "";
   int                     atlas_width           = 8;
@@ -96,6 +96,7 @@ class ParticleEmitter::Builder
   ParticleEmitter::Config conf = {};
 
 public:
+  
   Builder &starting_position(glm::vec3 starting_position);
   Builder &starting_velocity(glm::vec3 starting_velocity);
   Builder &starting_spread(glm::vec3 starting_spread);

src/renderer/particles.cpp

@@ -35,18 +35,18 @@ struct ParticleSettings {
 
 ParticleEmitter::ParticleEmitter(Config conf)
 {
-  this->starting_position = conf.starting_position;
-  this->starting_velocity = conf.starting_velocity;
-  this->starting_spread = conf.starting_spread;
+  this->starting_position     = conf.starting_position;
+  this->starting_velocity     = conf.starting_velocity;
+  this->starting_spread       = conf.starting_spread;
   this->starting_time_to_live = conf.starting_time_to_live;
-  this->num_particles = conf.num_particles;
-  this->spawn_rate = conf.spawn_rate;
-  this->scale = conf.scale;
-  this->atlas_width = conf.atlas_width;
-  this->atlas_height = conf.atlas_height;
-  this->atlas_index = conf.atlas_index;
-  this->current_fbo_index = 0;
-  this->cam = conf.cam;
+  this->num_particles         = conf.num_particles;
+  this->spawn_rate            = conf.spawn_rate;
+  this->scale                 = conf.scale;
+  this->atlas_width           = conf.atlas_width;
+  this->atlas_height          = conf.atlas_height;
+  this->atlas_index           = conf.atlas_index;
+  this->current_fbo_index     = 0;
+  this->cam                   = conf.cam;
 
   // Load Texture Atlas
   this->atlas =
@@ -127,14 +127,14 @@ void ParticleEmitter::update(float delta_time)
   this->shader_update->use();
 
   ParticleSettings settings = {
-    .gravity = glm::vec3(0.0f, -9.81f, 0.0f),
-    .deltaTime = delta_time,
-    .emitterVel = this->starting_velocity,
-    .emitterTTL = this->starting_time_to_live,
-    .emitterPos = this->starting_position,
+    .gravity          = glm::vec3(0.0f, -9.81f, 0.0f),
+    .deltaTime        = delta_time,
+    .emitterVel       = this->starting_velocity,
+    .emitterTTL       = this->starting_time_to_live,
+    .emitterPos       = this->starting_position,
     .spawnProbability = this->spawn_rate,
-    .emitterSpread = this->starting_spread,
-    .__padding = 0.0f,
+    .emitterSpread    = this->starting_spread,
+    .__padding        = 0.0f,
   };
 
   // ubo

src/renderer/shaders/c/particle_update_vs.c

@@ -25,8 +25,9 @@ static const char* particle_update_vs = "#version 330 core\n"
 "void main()\n"
 "{\n"
 "  float random = rand(vec2(deltaTime * float(gl_VertexID)));\n"
-"  if (random < spawnProbability)\n"
+"  if (random > spawnProbability)\n"
 "  {\n"
+"    // New particle\n"
 "    outPosition = emitterPos;\n"
 "    outVelocity = emitterVel + emitterSpread *\n"
 "      vec3(rand(vec2(float(gl_VertexID + 1.0))) -0.5,\n"
@@ -38,12 +39,14 @@ static const char* particle_update_vs = "#version 330 core\n"
 "\n"
 "  if (inTTL <= 0.0)\n"
 "  {\n"
+"    // Delete particle\n"
 "    outPosition = inPosition;\n"
 "    outVelocity = vec3(0.0);\n"
 "    outTTL = -1.0;\n"
 "    return;\n"
 "  }\n"
 "\n"
+"  // Update particle\n"
 "  outTTL = inTTL - deltaTime;\n"
 "\n"
 "  vec3 processed_velocity = inVelocity;\n"

src/renderer/shaders/particle_update.vs

@@ -25,8 +25,9 @@ float rand(vec2 co);
 void main()
 {
   float random = rand(vec2(deltaTime * float(gl_VertexID)));
-  if (random < spawnProbability)
+  if (random > spawnProbability)
   {
+    // New particle
     outPosition = emitterPos;
     outVelocity = emitterVel + emitterSpread *
       vec3(rand(vec2(float(gl_VertexID + 1.0))) -0.5,
@@ -38,12 +39,14 @@ void main()
 
   if (inTTL <= 0.0)
   {
+    // Delete particle
     outPosition = inPosition;
     outVelocity = vec3(0.0);
     outTTL = -1.0;
     return;
   }
 
+  // Update particle
   outTTL = inTTL - deltaTime;
 
   vec3 processed_velocity = inVelocity;