Add expression variable watch helper and associated internal functions

Author: kblaschke

src/libprojectM/CMakeLists.txt

@@ -13,6 +13,8 @@ add_subdirectory(UserSprites)
 
 add_library(projectM_main OBJECT
         "${PROJECTM_EXPORT_HEADER}"
+        ExpressionVariableWatcher.cpp
+        ExpressionVariableWatcher.hpp
         Logging.cpp
         Logging.hpp
         Preset.hpp

src/libprojectM/ExpressionVariableWatcher.cpp

@@ -0,0 +1,129 @@
+#include "ExpressionVariableWatcher.hpp"
+
+#include "Utils.hpp"
+
+#include <projectM-4/debug.h>
+
+#include <cstdint>
+#include <string>
+#include <utility>
+
+namespace libprojectM {
+
+auto ExpressionVariableWatcher::Add(ExpressionBlocks block, uint32_t index, VariableName variableName) -> const ExpressionVariableWatcher::VariableValues*
+{
+    // Validate block value only, set index to 0 in blocks only occurring once.
+    switch (block)
+    {
+        case PROJECTM_EXPR_PER_FRAME:
+        case PROJECTM_EXPR_PER_POINT:
+            index = 0;
+
+        case PROJECTM_EXPR_SHAPE_PER_FRAME:
+        case PROJECTM_EXPR_WAVE_PER_FRAME:
+        case PROJECTM_EXPR_WAVE_PER_POINT:
+        case PROJECTM_EXPR_MILKDROP_SPRITE:
+            break;
+
+        default:
+            return nullptr;
+    }
+
+    libprojectM::Utils::ToLowerInPlace(variableName);
+
+    IndexedExpressionBlock const indexedBlock = std::make_pair(block, index);
+
+    auto blockInMap = m_watches.find(indexedBlock);
+    if (blockInMap == m_watches.end())
+    {
+        blockInMap = m_watches.insert({indexedBlock, {}}).first;
+    }
+
+    // If the watch was already registered with the given, return the existing pointer again.
+    auto variableWatch = blockInMap->second.find(variableName);
+    if (variableWatch != blockInMap->second.end())
+    {
+        return &variableWatch->second;
+    }
+
+    // New watch. Create a new value struct and return it.
+    return &blockInMap->second.insert({variableName, {}}).first->second;
+}
+
+auto ExpressionVariableWatcher::Remove(ExpressionBlocks block, uint32_t index, VariableName variableName) -> const ExpressionVariableWatcher::VariableValues*
+{
+    // Validate block value only, set index to 0 in blocks only occurring once.
+    switch (block)
+    {
+        case PROJECTM_EXPR_PER_FRAME:
+        case PROJECTM_EXPR_PER_POINT:
+            index = 0;
+
+        case PROJECTM_EXPR_SHAPE_PER_FRAME:
+        case PROJECTM_EXPR_WAVE_PER_FRAME:
+        case PROJECTM_EXPR_WAVE_PER_POINT:
+        case PROJECTM_EXPR_MILKDROP_SPRITE:
+            break;
+
+        default:
+            return nullptr;
+    }
+
+    libprojectM::Utils::ToLowerInPlace(variableName);
+
+    IndexedExpressionBlock const indexedBlock = std::make_pair(block, index);
+
+    auto blockInMap = m_watches.find(indexedBlock);
+    if (blockInMap == m_watches.end())
+    {
+        return nullptr;
+    }
+
+    auto variableWatch = blockInMap->second.find(variableName);
+    if (variableWatch == blockInMap->second.end())
+    {
+        return nullptr;
+    }
+
+    // Watch found, make a copy of the values struct pointer, then delete it.
+    const auto* oldValuesStruct = &variableWatch->second;
+
+    blockInMap->second.erase(variableWatch);
+
+    return oldValuesStruct;
+}
+
+void ExpressionVariableWatcher::Clear()
+{
+    m_watches.clear();
+}
+
+auto ExpressionVariableWatcher::GetBlockWatches(ExpressionBlocks block, uint32_t index) -> BlockWatches&
+{
+    // Validate block value only.
+    switch (block)
+    {
+        case PROJECTM_EXPR_PER_FRAME:
+        case PROJECTM_EXPR_PER_POINT:
+        case PROJECTM_EXPR_SHAPE_PER_FRAME:
+        case PROJECTM_EXPR_WAVE_PER_FRAME:
+        case PROJECTM_EXPR_WAVE_PER_POINT:
+        case PROJECTM_EXPR_MILKDROP_SPRITE:
+            break;
+
+        default:
+            throw InvalidBlockException("Block type " + std::to_string(block) + " is not supported!");
+    }
+
+    IndexedExpressionBlock const indexedBlock = std::make_pair(block, index);
+
+    auto blockInMap = m_watches.find(indexedBlock);
+    if (blockInMap == m_watches.end())
+    {
+        blockInMap = m_watches.insert({indexedBlock, {}}).first;
+    }
+
+    return blockInMap->second;
+}
+
+} // namespace libprojectM

src/libprojectM/ExpressionVariableWatcher.hpp

@@ -0,0 +1,120 @@
+/*
+* projectM -- Milkdrop-esque visualisation SDK
+ * Copyright (C)2003-2007 projectM Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * See 'LICENSE.txt' included within this release
+ *
+ */
+#pragma once
+
+#include <projectM-4/debug.h>
+
+#include <cstdint>
+#include <exception>
+#include <map>
+#include <string>
+#include <utility>
+
+namespace libprojectM {
+
+/**
+ * @class ExpressionVariableWatcher
+ * @brief Container class managing active expression variable watches.
+ *
+ * All watches are stored in a three-tiered map, with the first map using the block and index as key.
+ * The second level map associated each watched variable to the struct which will receive the
+ * values. This struct and is also used by the outside application to display or otherwise evaluate
+ * the values after a frame is rendered.
+ */
+class ExpressionVariableWatcher
+{
+public:
+    /**
+     * @brief Exception for an invalid block argument in GetBlockWatches().
+     */
+    class InvalidBlockException : public std::exception
+    {
+    public:
+        InvalidBlockException(std::string message)
+            : m_message(std::move(message))
+        {
+        }
+
+        ~InvalidBlockException() override = default;
+
+        auto what() const noexcept -> const char* override
+        {
+            return m_message.c_str();
+        }
+
+        auto message() const -> const std::string&
+        {
+            return m_message;
+        }
+
+    private:
+        std::string m_message;
+    };
+
+    using ExpressionBlocks = projectm_expression_blocks;                  //!< Alias for the projectm_expression_blocks public API enum.
+    using IndexedExpressionBlock = std::pair<ExpressionBlocks, uint32_t>; //!< A pair if ExpressionBlocks and the custom shape/waveform or sprite index.
+    using VariableName = std::string;                                     //!< the name of a watched variable, lower-case.
+    using VariableValues = projectm_expression_variable_values;           //!< Alias for the projectm_expression_variable_values public API struct.
+    using BlockWatches = std::map<VariableName, VariableValues>;          //!< A map of variable names to the associated value structs.
+
+    /**
+     * @brief Adds a new watch, or returns a pointer to the previously registered one.
+     * @param block The expression code block to add the watch for.
+     * @param index The custom shape/waveform or user sprite index.
+     * @param variableName The variable to watch.
+     * @return A pointer to the newly added values struct, if the watch was successfully added.
+     */
+    auto Add(ExpressionBlocks block, uint32_t index, VariableName variableName) -> const VariableValues*;
+
+    /**
+     * @brief Removes a previously registered variable watch.
+     * @param block The expression code block to remove the watch from.
+     * @param index The custom shape/waveform or user sprite index.
+     * @param variableName The variable to unwatch.
+     * @return If the previous watch was found, a pointer to the initially registered values struct,
+     *         or nullptr if no watch was found.
+     */
+    auto Remove(ExpressionBlocks block, uint32_t index, VariableName variableName) -> const VariableValues*;
+
+    /**
+     * Clears all previously registered watches.
+     */
+    void Clear();
+
+    /**
+     * @brief Returns all watched variables and their value structs for the given block and index.
+     * @throws InvalidBlockException Thrown if the passed block value is invalid.
+     * @param block The expression code block to return the watch list for.
+     * @param index The custom shape/waveform or user sprite index to return the watch list for.
+     * @return A reference to a map of type BlockWatches with all registered watched variables.
+     */
+    auto GetBlockWatches(ExpressionBlocks block, uint32_t index) -> BlockWatches&;
+
+private:
+    /**
+     * @brief Registered watches.
+     *
+     * A three-tiered map of indexed blocks, variables and the value struct returned to the application.
+     */
+    std::map<IndexedExpressionBlock, BlockWatches> m_watches;
+};
+
+} // namespace libprojectM

src/libprojectM/MilkdropPreset/MilkdropPreset.cpp

@@ -187,6 +187,14 @@ void MilkdropPreset::BindFramebuffer()
     }
 }
 
+void MilkdropPreset::UpdateWatches(ExpressionVariableWatcher& watcher)
+{
+}
+
+void MilkdropPreset::RemoveWatches()
+{
+}
+
 void MilkdropPreset::PerFrameUpdate()
 {
     m_perFrameContext.LoadStateVariables(m_state);
@@ -227,7 +235,7 @@ void MilkdropPreset::Load(std::istream& stream)
 
     if (!parser.Read(stream))
     {
-        const std::string error =  "[MilkdropPreset] Could not parse preset data.";
+        const std::string error = "[MilkdropPreset] Could not parse preset data.";
         LOG_ERROR(error)
         throw MilkdropPresetLoadException(error);
     }

src/libprojectM/MilkdropPreset/MilkdropPreset.hpp

@@ -24,6 +24,7 @@
 #pragma once
 
 #include "Border.hpp"
+#include "Constants.hpp"
 #include "CustomShape.hpp"
 #include "CustomWaveform.hpp"
 #include "DarkenCenter.hpp"
@@ -32,37 +33,42 @@
 #include "PerFrameContext.hpp"
 #include "PerPixelContext.hpp"
 #include "PerPixelMesh.hpp"
-#include "Preset.hpp"
 #include "Waveform.hpp"
 
+#include <ExpressionVariableWatcher.hpp>
+#include <Preset.hpp>
+
+#include <Audio/FrameAudioData.hpp>
+
 #include <Renderer/CopyTexture.hpp>
 #include <Renderer/Framebuffer.hpp>
+#include <Renderer/RenderContext.hpp>
+#include <Renderer/Texture.hpp>
+#include <Renderer/TextureAttachment.hpp>
 
+#include <array>
+#include <istream>
 #include <memory>
 #include <string>
 
 namespace libprojectM {
-class PresetFileParser;
-
 namespace MilkdropPreset {
 
 class Factory;
 
-class MilkdropPreset : public ::libprojectM::Preset
+class MilkdropPreset : public Preset
 {
 
 public:
     /**
      * @brief LoadCode a MilkdropPreset by filename with input and output buffers specified.
-     * @param factory The factory class that created this preset instance.
      * @param absoluteFilePath the absolute file path of a MilkdropPreset to load from the file system
      */
     MilkdropPreset(const std::string& absoluteFilePath);
 
     /**
      * @brief LoadCode a MilkdropPreset from an input stream with input and output buffers specified.
      * @param presetData an already initialized input stream to read the MilkdropPreset file from
-     * @param presetOutputs initialized and filled with data parsed from a MilkdropPreset
      */
     MilkdropPreset(std::istream& presetData);
 
@@ -77,7 +83,7 @@ class MilkdropPreset : public ::libprojectM::Preset
      * @param audioData The frame audio data.
      * @param renderContext The current rendering context/information.
      */
-    void RenderFrame(const libprojectM::Audio::FrameAudioData& audioData,
+    void RenderFrame(const Audio::FrameAudioData& audioData,
                      const Renderer::RenderContext& renderContext) override;
 
     auto OutputTexture() const -> std::shared_ptr<Renderer::Texture> override;
@@ -86,6 +92,10 @@ class MilkdropPreset : public ::libprojectM::Preset
 
     void BindFramebuffer() override;
 
+    void UpdateWatches(ExpressionVariableWatcher& watcher) override;
+
+    void RemoveWatches() override;
+
 private:
     void PerFrameUpdate();