Merge pull request #569 from scratchcpp/sound_effects

Implement sound effects

Author: adazem009

README.md

@@ -124,7 +124,7 @@ libscratchcpp::Project p("https://scratch.mit.edu/projects/XXXXXX");
 
 - [x] Motion blocks
 - [x] Looks blocks
-- [ ] Sound blocks
+- [x] Sound blocks
 - [x] Event blocks
 - [x] Control blocks
 - [ ] Sensing blocks

include/scratchcpp/sound.h

@@ -16,6 +16,12 @@ class SoundPrivate;
 class LIBSCRATCHCPP_EXPORT Sound : public Asset
 {
     public:
+        enum class Effect
+        {
+            Pitch,
+            Pan
+        };
+
         Sound(const std::string &name, const std::string &id, const std::string &format);
         Sound(const Sound &) = delete;
         virtual ~Sound() { }
@@ -27,11 +33,12 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
         void setSampleCount(int newSampleCount);
 
         virtual void setVolume(double volume);
+        virtual void setEffect(Effect effect, double value);
 
         virtual void start();
         virtual void stop();
 
-        virtual bool isPlaying();
+        virtual bool isPlaying() const;
 
         Target *target() const;
         void setTarget(Target *target);

include/scratchcpp/target.h

@@ -7,6 +7,7 @@
 #include "global.h"
 #include "spimpl.h"
 #include "rect.h"
+#include "sound.h"
 
 namespace libscratchcpp
 {
@@ -88,6 +89,11 @@ class LIBSCRATCHCPP_EXPORT Target
         double volume() const;
         void setVolume(double newVolume);
 
+        virtual double soundEffect(Sound::Effect effect) const;
+        virtual void setSoundEffect(Sound::Effect effect, double value);
+
+        virtual void clearSoundEffects();
+
         virtual Rect boundingRect() const;
         virtual Rect fastBoundingRect() const;
 

src/audio/iaudioplayer.h

@@ -16,6 +16,12 @@ class IAudioPlayer
         virtual float volume() const = 0;
         virtual void setVolume(float volume) = 0;
 
+        virtual float pitch() const = 0;
+        virtual void setPitch(float pitch) = 0;
+
+        virtual float pan() const = 0;
+        virtual void setPan(float pan) = 0;
+
         virtual bool isLoaded() const = 0;
 
         virtual void start() = 0;

src/audio/internal/audioplayer.cpp

@@ -58,6 +58,8 @@ bool AudioPlayer::load(unsigned int size, const void *data, unsigned long sample
 
     m_loaded = true;
     ma_sound_set_volume(m_sound, m_volume);
+    ma_sound_set_pitch(m_sound, m_pitch);
+    ma_sound_set_pan(m_sound, m_pan);
     return true;
 }
 
@@ -81,6 +83,8 @@ bool AudioPlayer::loadCopy(IAudioPlayer *player)
     m_loaded = true;
     m_copy = true;
     ma_sound_set_volume(m_sound, m_volume);
+    ma_sound_set_pitch(m_sound, m_pitch);
+    ma_sound_set_pan(m_sound, m_pan);
     return true;
 }
 
@@ -99,6 +103,44 @@ void AudioPlayer::setVolume(float volume)
     ma_sound_set_volume(m_sound, volume);
 }
 
+float AudioPlayer::pitch() const
+{
+    return m_pitch;
+}
+
+void AudioPlayer::setPitch(float pitch)
+{
+    /*
+     * 0.5 -> 220 Hz
+     * 1 -> 440 Hz
+     * 2 -> 880 Hz
+     * 4 -> 1760 Hz
+     * ...
+     */
+    m_pitch = pitch;
+
+    if (!m_loaded)
+        return;
+
+    ma_sound_set_pitch(m_sound, pitch);
+}
+
+float AudioPlayer::pan() const
+{
+    return m_pan;
+}
+
+void AudioPlayer::setPan(float pan)
+{
+    // -1 ... 0 ... 1
+    m_pan = pan;
+
+    if (!m_loaded)
+        return;
+
+    ma_sound_set_pan(m_sound, pan);
+}
+
 bool AudioPlayer::isLoaded() const
 {
     return m_loaded;

src/audio/internal/audioplayer.h

@@ -22,6 +22,12 @@ class AudioPlayer : public IAudioPlayer
         float volume() const override;
         void setVolume(float volume) override;
 
+        float pitch() const override;
+        void setPitch(float pitch) override;
+
+        float pan() const override;
+        void setPan(float pan) override;
+
         bool isLoaded() const override;
 
         void start() override;
@@ -36,6 +42,8 @@ class AudioPlayer : public IAudioPlayer
         bool m_copy = false;
         bool m_started = false;
         float m_volume = 1;
+        float m_pitch = 1;
+        float m_pan = 0;
 };
 
 } // namespace libscratchcpp

src/audio/internal/audioplayerstub.cpp

@@ -28,6 +28,26 @@ void AudioPlayerStub::setVolume(float volume)
     m_volume = volume;
 }
 
+float AudioPlayerStub::pitch() const
+{
+    return m_pitch;
+}
+
+void AudioPlayerStub::setPitch(float pitch)
+{
+    m_pitch = pitch;
+}
+
+float AudioPlayerStub::pan() const
+{
+    return m_pan;
+}
+
+void AudioPlayerStub::setPan(float pan)
+{
+    m_pan = pan;
+}
+
 bool AudioPlayerStub::isLoaded() const
 {
     return true;

src/audio/internal/audioplayerstub.h

@@ -18,6 +18,12 @@ class AudioPlayerStub : public IAudioPlayer
         float volume() const override;
         void setVolume(float volume) override;
 
+        float pitch() const override;
+        void setPitch(float pitch) override;
+
+        float pan() const override;
+        void setPan(float pan) override;
+
         bool isLoaded() const override;
 
         void start() override;
@@ -27,6 +33,8 @@ class AudioPlayerStub : public IAudioPlayer
 
     private:
         float m_volume = 1;
+        float m_pitch = 1;
+        float m_pan = 0;
 };
 
 } // namespace libscratchcpp

src/blocks/soundblocks.cpp

@@ -4,6 +4,7 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/target.h>
 #include <scratchcpp/input.h>
+#include <scratchcpp/field.h>
 #include <scratchcpp/sound.h>
 
 #include "soundblocks.h"
@@ -33,7 +34,10 @@ void SoundBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sound_play", &compilePlay);
     engine->addCompileFunction(this, "sound_playuntildone", &compilePlayUntilDone);
     engine->addCompileFunction(this, "sound_stopallsounds", &compileStopAllSounds);
+    engine->addCompileFunction(this, "sound_seteffectto", &compileSetEffectTo);
+    engine->addCompileFunction(this, "sound_changeeffectby", &compileChangeEffectBy);
     engine->addCompileFunction(this, "sound_changevolumeby", &compileChangeVolumeBy);
+    engine->addCompileFunction(this, "sound_cleareffects", &compileClearEffects);
     engine->addCompileFunction(this, "sound_setvolumeto", &compileSetVolumeTo);
     engine->addCompileFunction(this, "sound_volume", &compileVolume);
 
@@ -42,7 +46,15 @@ void SoundBlocks::registerBlocks(IEngine *engine)
 
     // Inputs
     engine->addInput(this, "SOUND_MENU", SOUND_MENU);
+    engine->addInput(this, "VALUE", VALUE);
     engine->addInput(this, "VOLUME", VOLUME);
+
+    // Fields
+    engine->addField(this, "EFFECT", EFFECT);
+
+    // Field values
+    engine->addFieldValue(this, "PITCH", PITCH);
+    engine->addFieldValue(this, "PAN", PAN);
 }
 
 void SoundBlocks::onInit(IEngine *engine)
@@ -118,6 +130,51 @@ void SoundBlocks::compileStopAllSounds(Compiler *compiler)
     compiler->addFunctionCall(&stopAllSounds);
 }
 
+void SoundBlocks::compileSetEffectTo(Compiler *compiler)
+{
+    compiler->addInput(VALUE);
+    int option = compiler->field(EFFECT)->specialValueId();
+
+    switch (option) {
+        case PITCH:
+            compiler->addFunctionCall(&setPitchEffectTo);
+            break;
+
+        case PAN:
+            compiler->addFunctionCall(&setPanEffectTo);
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
+}
+
+void SoundBlocks::compileChangeEffectBy(Compiler *compiler)
+{
+    compiler->addInput(VALUE);
+    int option = compiler->field(EFFECT)->specialValueId();
+
+    switch (option) {
+        case PITCH:
+            compiler->addFunctionCall(&changePitchEffectBy);
+            break;
+
+        case PAN:
+            compiler->addFunctionCall(&changePanEffectBy);
+            break;
+
+        default:
+            assert(false);
+            break;
+    }
+}
+
+void SoundBlocks::compileClearEffects(Compiler *compiler)
+{
+    compiler->addFunctionCall(&clearEffects);
+}
+
 void SoundBlocks::compileChangeVolumeBy(Compiler *compiler)
 {
     compiler->addInput(VOLUME);
@@ -296,6 +353,46 @@ unsigned int SoundBlocks::stopAllSounds(VirtualMachine *vm)
     return 0;
 }
 
+unsigned int SoundBlocks::setPitchEffectTo(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffect(Sound::Effect::Pitch, vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::setPanEffectTo(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffect(Sound::Effect::Pan, vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::changePitchEffectBy(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffect(Sound::Effect::Pitch, target->soundEffect(Sound::Effect::Pitch) + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::changePanEffectBy(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->setSoundEffect(Sound::Effect::Pan, target->soundEffect(Sound::Effect::Pan) + vm->getInput(0, 1)->toDouble());
+
+    return 1;
+}
+
+unsigned int SoundBlocks::clearEffects(VirtualMachine *vm)
+{
+    if (Target *target = vm->target())
+        target->clearSoundEffects();
+
+    return 0;
+}
+
 unsigned int SoundBlocks::changeVolumeBy(VirtualMachine *vm)
 {
     if (Target *target = vm->target())

src/blocks/soundblocks.h

@@ -20,17 +20,19 @@ class SoundBlocks : public IBlockSection
         enum Inputs
         {
             SOUND_MENU,
+            VALUE,
             VOLUME
         };
 
         enum Fields
         {
-
+            EFFECT
         };
 
         enum FieldValues
         {
-
+            PITCH,
+            PAN
         };
 
         std::string name() const override;
@@ -42,6 +44,9 @@ class SoundBlocks : public IBlockSection
         static void compilePlay(Compiler *compiler);
         static void compilePlayUntilDone(Compiler *compiler);
         static void compileStopAllSounds(Compiler *compiler);
+        static void compileSetEffectTo(Compiler *compiler);
+        static void compileChangeEffectBy(Compiler *compiler);
+        static void compileClearEffects(Compiler *compiler);
         static void compileChangeVolumeBy(Compiler *compiler);
         static void compileSetVolumeTo(Compiler *compiler);
         static void compileVolume(Compiler *compiler);
@@ -62,6 +67,12 @@ class SoundBlocks : public IBlockSection
 
         static unsigned int stopAllSounds(VirtualMachine *vm);
 
+        static unsigned int setPitchEffectTo(VirtualMachine *vm);
+        static unsigned int setPanEffectTo(VirtualMachine *vm);
+        static unsigned int changePitchEffectBy(VirtualMachine *vm);
+        static unsigned int changePanEffectBy(VirtualMachine *vm);
+        static unsigned int clearEffects(VirtualMachine *vm);
+
         static unsigned int changeVolumeBy(VirtualMachine *vm);
         static unsigned int setVolumeTo(VirtualMachine *vm);
         static unsigned int volume(VirtualMachine *vm);