From 18c4a901018f3487825ee6ab30d014d9795b2750 Mon Sep 17 00:00:00 2001 From: Perttu Ahola Date: Mon, 12 Mar 2012 08:38:15 +0200 Subject: [PATCH] Add quicktune.{cpp,h} --- src/CMakeLists.txt | 1 + src/quicktune.cpp | 87 ++++++++++++++++++++++++++ src/quicktune.h | 148 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 236 insertions(+) create mode 100644 src/quicktune.cpp create mode 100644 src/quicktune.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e9fddf8c0..cec42719a 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -94,6 +94,7 @@ configure_file( ) set(common_SRCS + quicktune.cpp subgame.cpp inventorymanager.cpp mods.cpp diff --git a/src/quicktune.cpp b/src/quicktune.cpp new file mode 100644 index 000000000..66b9804df --- /dev/null +++ b/src/quicktune.cpp @@ -0,0 +1,87 @@ +/* +Minetest-c55 +Copyright (C) 2012 celeron55, Perttu Ahola + +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 +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include "quicktune.h" +#include +#include + +static std::map g_values; +static std::vector g_names; +JMutex *g_mutex = NULL; + +static void makeMutex() +{ + if(!g_mutex){ + g_mutex = new JMutex(); + g_mutex->Init(); + } +} + +std::vector getQuicktuneNames() +{ + return g_names; +} + +/*std::map getQuicktuneValues() +{ + makeMutex(); + JMutexAutoLock lock(*g_mutex); + return g_values; +}*/ + +QuicktuneValue getQuicktuneValue(const std::string &name) +{ + makeMutex(); + JMutexAutoLock lock(*g_mutex); + std::map::iterator i = g_values.find(name); + if(i == g_values.end()){ + QuicktuneValue val; + val.type = QUICKTUNE_NONE; + return val; + } + return i->second; +} + +void setQuicktuneValue(const std::string &name, const QuicktuneValue &val) +{ + makeMutex(); + JMutexAutoLock lock(*g_mutex); + g_values[name] = val; +} + +void updateQuicktuneValue(const std::string &name, QuicktuneValue &val) +{ + makeMutex(); + JMutexAutoLock lock(*g_mutex); + std::map::iterator i = g_values.find(name); + if(i == g_values.end()){ + g_values[name] = val; + g_names.push_back(name); + return; + } + QuicktuneValue &ref = i->second; + switch(val.type){ + case QUICKTUNE_NONE: + break; + case QUICKTUNE_FLOAT: + val.value_float.current = ref.value_float.current; + break; + } +} + diff --git a/src/quicktune.h b/src/quicktune.h new file mode 100644 index 000000000..bebf1cbe1 --- /dev/null +++ b/src/quicktune.h @@ -0,0 +1,148 @@ +/* +Minetest-c55 +Copyright (C) 2012 celeron55, Perttu Ahola + +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 +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef QUICKTUNE_HEADER +#define QUICKTUNE_HEADER + +#include "irrlichttypes.h" +#include +#include +#include +#include "utility.h" + +enum QuicktuneValueType{ + QUICKTUNE_NONE, + QUICKTUNE_FLOAT +}; +struct QuicktuneValue +{ + QuicktuneValueType type; + union{ + struct{ + float current; + float min; + float max; + } value_float; + }; +}; + +std::vector getQuicktuneNames(); +//std::map getQuicktuneNames(); +QuicktuneValue getQuicktuneValue(const std::string &name); +void setQuicktuneValue(const std::string &name, const QuicktuneValue &val); + +class QuicktuneShortcutter +{ +private: + std::vector m_names; + u32 m_selected_i; + std::string m_message; +public: + std::string getMessage() + { + std::string s = m_message; + m_message = ""; + return s; + } + std::string getSelectedName() + { + if(m_selected_i < m_names.size()) + return m_names[m_selected_i]; + return ""; + } + void next() + { + m_names = getQuicktuneNames(); + if(m_selected_i < m_names.size()-1) + m_selected_i++; + else + m_selected_i = 0; + m_message = std::string("Selected \"")+getSelectedName()+"\""; + } + void prev() + { + m_names = getQuicktuneNames(); + if(m_selected_i > 0) + m_selected_i--; + else + m_selected_i = m_names.size()-1; + m_message = std::string("Selected \"")+getSelectedName()+"\""; + } + void inc() + { + QuicktuneValue val = getQuicktuneValue(getSelectedName()); + switch(val.type){ + case QUICKTUNE_NONE: + break; + case QUICKTUNE_FLOAT: + val.value_float.current += 0.05 * (val.value_float.max - val.value_float.min); + if(val.value_float.current > val.value_float.max) + val.value_float.current = val.value_float.max; + m_message = std::string("\"")+getSelectedName() + +"\" = "+ftos(val.value_float.current); + break; + default: + m_message = std::string("\"")+getSelectedName() + +"\" has unknown value type"; + } + setQuicktuneValue(getSelectedName(), val); + } + void dec() + { + QuicktuneValue val = getQuicktuneValue(getSelectedName()); + switch(val.type){ + case QUICKTUNE_NONE: + break; + case QUICKTUNE_FLOAT: + val.value_float.current -= 0.05 * (val.value_float.max - val.value_float.min); + if(val.value_float.current < val.value_float.max) + val.value_float.current = val.value_float.max; + m_message = std::string("\"")+getSelectedName() + +"\" = "+ftos(val.value_float.current); + break; + default: + m_message = std::string("\"")+getSelectedName() + +"\" has unknown value type"; + } + setQuicktuneValue(getSelectedName(), val); + } +}; + +void updateQuicktuneValue(const std::string &name, QuicktuneValue &val); + +#ifndef NDEBUG + +#define QUICKTUNE_FLOAT(var, min, max, name){\ + QuicktuneValue qv;\ + qv.type = QUICKTUNE_FLOAT;\ + qv.value_float.current = var;\ + qv.value_float.min = min;\ + qv.value_float.min = max;\ + updateQuicktune(name, qv);\ + var = qv.value_float.current;\ +} + +#else // NDEBUG + +#define QUICKTUNE_FLOAT(var, min, max, name){} + +#endif + +#endif + -- 2.25.1