Rename AmbientSound to SoundObject and revert to old AmbientSound

data/images/engine/editor/objects.stoi

@@ -365,24 +365,21 @@
   (object
     (class "particles-ghosts")
     (icon "images/engine/editor/ghostparticles.png"))
-
-
-
 ;;  +-- This should be disabled, as it probably won't support multiple textures
 ;;  |   per config object.
 ;;  v                               ~ Semphris
   (object
     (class "particles-custom")
     (icon "images/engine/editor/particle.png"))
-
-
-
   (object
     (class "particles-custom-file")
     (icon "images/engine/editor/particle_file.png"))
   (object
     (class "textscroller")
     (icon "images/engine/editor/textscroller.png"))
+  (object
+    (class "sound-object")
+    (icon "images/engine/editor/ambientsound.png"))
  )
 
  (objectgroup

src/object/ambient_sound.cpp

@@ -1,6 +1,5 @@
 //  SuperTux
 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
-//                2023 mrkubax10 <mrkubax10@onet.pl>
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -22,122 +21,253 @@
 #include "audio/sound_manager.hpp"
 #include "audio/sound_source.hpp"
 #include "editor/editor.hpp"
+#include "object/camera.hpp"
+#include "supertux/sector.hpp"
 #include "util/reader_mapping.hpp"
+#include "video/drawing_context.hpp"
 
 AmbientSound::AmbientSound(const ReaderMapping& mapping) :
-  GameObject(mapping),
+  MovingObject(mapping),
   ExposedObject<AmbientSound, scripting::AmbientSound>(this),
-  m_sample(),
-  m_sound_source(),
-  m_volume(),
-  m_play_interval(),
-  m_delay(0.0f),
-  m_playing(false),
-  m_scheduled_for_removal(false)
+  sample(),
+  sound_source(),
+  latency(),
+  distance_factor(),
+  distance_bias(),
+  silence_distance(),
+  maximumvolume(),
+  targetvolume(),
+  currentvolume(0)
 {
-  mapping.get("sample", m_sample, "");
-  mapping.get("volume", m_volume, 1.0f);
-  mapping.get("play-interval", m_play_interval, 0.0f);
+  m_col.m_group = COLGROUP_DISABLED;
 
-  prepare_sound_source();
+  float w, h;
+  mapping.get("x", m_col.m_bbox.get_left(), 0.0f);
+  mapping.get("y", m_col.m_bbox.get_top(), 0.0f);
+  mapping.get("width" , w, 32.0f);
+  mapping.get("height", h, 32.0f);
+  m_col.m_bbox.set_size(w, h);
+
+  mapping.get("distance_factor",distance_factor, 0.0f);
+  mapping.get("distance_bias"  ,distance_bias  , 0.0f);
+  mapping.get("sample"         ,sample         , "");
+  mapping.get("volume"         ,maximumvolume  , 1.0f);
+
+  // Square all distances (saves us a sqrt later).
+
+  if (!Editor::is_active()) {
+    distance_bias*=distance_bias;
+    distance_factor*=distance_factor;
+  }
+
+  // Set default silence_distance.
+
+  if (distance_factor == 0)
+    silence_distance = std::numeric_limits<float>::max();
+  else
+    silence_distance = 1/distance_factor;
+
+  mapping.get("silence_distance",silence_distance);
+
+  if (!Editor::is_active()) {
+    sound_source.reset(); // Resetting the sound source to stop playing at the beginning.
+    SoundManager::current()->preload(sample);
+  }
+  latency=0;
 }
 
-AmbientSound::AmbientSound(float vol, float play_interval, const std::string& file) :
+AmbientSound::AmbientSound(const Vector& pos, float factor, float bias, float vol, const std::string& file) :
   ExposedObject<AmbientSound, scripting::AmbientSound>(this),
-  m_sample(file),
-  m_sound_source(),
-  m_volume(vol),
-  m_play_interval(play_interval),
-  m_delay(0.0f),
-  m_playing(false),
-  m_scheduled_for_removal(false)
+  sample(file),
+  sound_source(),
+  latency(0),
+  distance_factor(factor * factor),
+  distance_bias(bias * bias),
+  silence_distance(),
+  maximumvolume(vol),
+  targetvolume(),
+  currentvolume()
 {
-  prepare_sound_source();
+  m_col.m_group = COLGROUP_DISABLED;
+
+  m_col.m_bbox.set_pos(pos);
+  m_col.m_bbox.set_size(32, 32);
+
+  // Set default silence_distance.
+
+  if (distance_factor == 0)
+    silence_distance = std::numeric_limits<float>::max();
+  else
+    silence_distance = 1/distance_factor;
+
+  if (!Editor::is_active()) {
+    sound_source.reset(); // Resetting the sound source to stop playing at the beginning.
+    SoundManager::current()->preload(sample);
+  }
 }
 
 AmbientSound::~AmbientSound()
 {
-  stop_looping_sounds();
+  stop_playing();
+}
+
+ObjectSettings
+AmbientSound::get_settings()
+{
+  ObjectSettings result = MovingObject::get_settings();
+
+  result.add_sound(_("Sound"), &sample, "sample");
+  result.add_float(_("Distance factor"), &distance_factor, "distance_factor");
+  result.add_float(_("Distance bias"), &distance_bias, "distance_bias");
+  result.add_float(_("Volume"), &maximumvolume, "volume");
+
+  result.reorder({"sample", "distance_factor", "distance_bias", "volume", "region", "name", "x", "y", "width", "height"});
+
+  return result;
 }
 
 void
-AmbientSound::update(float dt_sec)
+AmbientSound::after_editor_set()
+{
+}
+
+void
+AmbientSound::stop_playing()
 {
-  if (m_scheduled_for_removal)
-  {
+  sound_source.reset();
+}
+
+void
+AmbientSound::start_playing()
+{
+  if (Editor::is_active()) return;
+
+  try {
+    sound_source = SoundManager::current()->create_sound_source(sample);
+    if (!sound_source)
+      throw std::runtime_error("file not found");
+
+    sound_source->set_gain(0);
+    sound_source->set_looping(true);
+    sound_source->set_position(m_col.m_bbox.get_middle());
+    currentvolume=targetvolume=1e-20f;
+    sound_source->play();
+  } catch(std::exception& e) {
+    log_warning << "Couldn't play '" << sample << "': " << e.what() << "" << std::endl;
+    sound_source.reset();
     remove_me();
-    return;
   }
+}
 
-  if (!m_sound_source->playing())
-  {
-    if (m_playing && m_delay>=m_play_interval)
-    {
-      m_sound_source->play();
-      m_delay = 0.0f;
+void
+AmbientSound::update(float dt_sec)
+{
+  if (latency-- <= 0) {
+    float px,py;
+    float rx,ry;
+
+    // Get the central position of the camera.
+    px=Sector::get().get_camera().get_center().x;
+    py=Sector::get().get_camera().get_center().y;
+
+    // Determine the nearest point within the area bounds.
+    rx=px<m_col.m_bbox.get_left()?m_col.m_bbox.get_left():
+      (px<m_col.m_bbox.get_right()?px:m_col.m_bbox.get_right());
+    ry=py<m_col.m_bbox.get_top()?m_col.m_bbox.get_top():
+      (py<m_col.m_bbox.get_bottom()?py:m_col.m_bbox.get_bottom());
+
+    // Calculate the square of the distance.
+    float sqrdistance=(px-rx)*(px-rx)+(py-ry)*(py-ry);
+    sqrdistance-=distance_bias;
+
+    // Inside the bias: full volume (distance 0).
+    if (sqrdistance<0)
+      sqrdistance=0;
+
+    // Calculate target volume - will never become 0.
+    targetvolume=1/(1+sqrdistance*distance_factor);
+    float rise=targetvolume/currentvolume;
+
+    // Determine the rise/fall half-life.
+    currentvolume *= powf(rise, dt_sec * 10.0f);
+    currentvolume += 1e-6f; // volume is at least 1e-6 (0 would never rise)
+
+    if (sound_source != nullptr) {
+
+      // Set the volume.
+      sound_source->set_gain(currentvolume*maximumvolume);
+
+      if (sqrdistance>=silence_distance && currentvolume < 1e-3f)
+        stop_playing();
+      latency=0;
+    } else {
+      if (sqrdistance<silence_distance) {
+        start_playing();
+        latency=0;
+      }
+      else // Set a reasonable latency.
+        latency = static_cast<int>(0.001f / distance_factor);
+      //(int)(10*((sqrdistance-silence_distance)/silence_distance));
     }
-    m_delay+=dt_sec;
   }
+
+  // Heuristically measured "good" maximum latency.
+
+  // if (latency > 0.001 / distance_factor)
+  //   latency =
 }
 
-ObjectSettings
-AmbientSound::get_settings()
+#ifndef SCRIPTING_API
+void
+AmbientSound::set_pos(const Vector& pos)
+{
+  MovingObject::set_pos(pos);
+}
+#endif
+
+void
+AmbientSound::set_pos(float x, float y)
 {
-  ObjectSettings result = GameObject::get_settings();
+  m_col.m_bbox.set_pos(Vector(x, y));
+}
 
-  result.add_sound(_("Sound"), &m_sample, "sample");
-  result.add_float(_("Volume"), &m_volume, "volume");
-  result.add_float(_("Play interval"), &m_play_interval, "play-interval");
+float
+AmbientSound::get_pos_x() const
+{
+  return m_col.m_bbox.get_left();
+}
 
-  result.reorder({"sample", "volume", "play-interval", "name"});
+float
+AmbientSound::get_pos_y() const
+{
+  return m_col.m_bbox.get_top();
+}
 
-  return result;
+HitResponse
+AmbientSound::collision(GameObject& other, const CollisionHit& hit_)
+{
+  return ABORT_MOVE;
 }
 
 void
-AmbientSound::stop_looping_sounds()
+AmbientSound::draw(DrawingContext& context)
 {
-  if (m_sound_source)
-  {
-    m_sound_source->stop(false);
-    m_playing = false;
+  if (Editor::is_active()) {
+    context.color().draw_filled_rect(m_col.m_bbox, Color(0.0f, 0.0f, 1.0f, 0.6f),
+                                     0.0f, LAYER_OBJECTS);
   }
 }
 
 void
-AmbientSound::play_looping_sounds()
+AmbientSound::stop_looping_sounds()
 {
-  if (!Editor::is_active() && m_sound_source)
-  {
-    m_playing = true;
-    m_delay = 0.0f;
-  }
+  stop_playing();
 }
 
 void
-AmbientSound::prepare_sound_source()
+AmbientSound::play_looping_sounds()
 {
-  try
-  {
-    m_sound_source = SoundManager::current()->create_sound_source(m_sample);
-    if (!m_sound_source)
-      throw std::runtime_error("file not found");
-    m_sound_source->set_gain(m_volume);
-    m_sound_source->set_relative(true);
-
-    if (!Editor::is_active())
-    {
-      m_playing = true;
-      m_delay = 0.0f;
-      m_sound_source->play();
-    }
-  }
-  catch(const std::exception& e)
-  {
-    log_warning << "Couldn't play '" << m_sample << "': " << e.what() << "" << std::endl;
-    m_sound_source.reset();
-    m_scheduled_for_removal = true;
-  }
+  start_playing();
 }
 
-/* EOF */
+/* EOF */