init

framework/debug_info.h

@@ -0,0 +1,209 @@
+/* Copyright (c) 2019-2025, Arm Limited and Contributors
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "common/error.h"
+
+#include "common/glm_common.h"
+
+#include "common/helpers.h"
+
+namespace vkb
+{
+namespace field
+{
+/**
+ * @brief Base Field Interface class
+ */
+struct Base
+{
+	std::string label;
+
+	Base(const std::string &label) :
+	    label{label}
+	{}
+
+	virtual ~Base() = default;
+
+	virtual const std::string to_string() = 0;
+};
+
+/**
+ * @brief Static Field Implementation
+ *
+ * To be used for values that do not change often.
+ */
+template <typename T>
+struct Static : public Base
+{
+	T value;
+
+	Static(const std::string &label, const T &value) :
+	    Base(label),
+	    value{value}
+	{}
+
+	virtual ~Static() = default;
+
+	const std::string to_string() override
+	{
+		return vkb::to_string(value);
+	}
+};
+
+/**
+ * @brief Dynamic Field Implementation
+ *
+ * To be used for values that change frequently.
+ */
+template <typename T>
+struct Dynamic : public Base
+{
+	T &value;
+
+	Dynamic(const std::string &label, T &value) :
+	    Base(label),
+	    value{value}
+	{}
+
+	virtual ~Dynamic() = default;
+
+	const std::string to_string() override
+	{
+		return vkb::to_string(value);
+	}
+};
+
+/**
+ * @brief Vector Field Implementation
+ *
+ * To be used for values that have an X, Y and Z value.
+ */
+template <typename T>
+struct Vector final : public Static<T>
+{
+	T x, y, z;
+
+	Vector(const std::string &label, const glm::vec3 &vec) :
+	    Vector(label, vec.x, vec.y, vec.z)
+	{}
+	Vector(const std::string &label, T x, T y, T z) :
+	    Static<T>(label, x),
+	    x{x},
+	    y{y},
+	    z{z}
+	{}
+
+	virtual ~Vector() = default;
+
+	const std::string to_string() override
+	{
+		return "x: " + vkb::to_string(x) + " " +
+		       "y: " + vkb::to_string(y) + " " +
+		       "z: " + vkb::to_string(z);
+	}
+};
+
+/**
+ * @brief MinMax Field Implementation
+ *
+ * To be used for numbers that change a lot, keeping track of the high/low values.
+ */
+template <typename T>
+struct MinMax final : public Dynamic<T>
+{
+	T min, max;
+
+	MinMax(const std::string &label, T &value) :
+	    Dynamic<T>(label, value),
+	    min{value},
+	    max{value}
+	{
+		static_assert(std::is_arithmetic<T>::value, "MinMax must be templated to a numeric type.");
+	}
+
+	virtual ~MinMax() = default;
+
+	const std::string to_string() override
+	{
+		if (Dynamic<T>::value > max)
+		{
+			max = Dynamic<T>::value;
+		}
+		if (Dynamic<T>::value < min)
+		{
+			min = Dynamic<T>::value;
+		}
+		if (min == 0)
+		{
+			min = Dynamic<T>::value;
+		}
+
+		return "current: " + vkb::to_string(Dynamic<T>::value) + " min: " + vkb::to_string(min) + " max: " + vkb::to_string(max);
+	}
+};
+}        // namespace field
+
+/**
+ * @brief Manages the debug information
+ */
+class DebugInfo
+{
+  public:
+	const std::vector<std::unique_ptr<field::Base>> &get_fields() const;
+
+	/**
+	 * @brief   Calculates the field label with the most amount of characters
+	 * @returns The length of the longest label
+	 */
+	float get_longest_label() const;
+
+	/**
+	 * @brief Constructs and inserts a new field of type C<T>
+	 *
+	 * Replaces the field if it is of type static.
+	 */
+	template <template <typename> class C, typename T, typename... A>
+	void insert(const std::string &label, A &&...args)
+	{
+		static_assert(std::is_base_of<field::Base, C<T>>::value, "C is not a type of field::Base.");
+
+		for (auto &field : fields)
+		{
+			if (field->label == label)
+			{
+				if (dynamic_cast<typename field::template Static<T> *>(field.get()))
+				{
+					field = std::make_unique<C<T>>(label, args...);
+				}
+				return;
+			}
+		}
+
+		auto field = std::make_unique<C<T>>(label, std::forward<A>(args)...);
+		fields.push_back(std::move(field));
+	}
+
+  private:
+	std::vector<std::unique_ptr<field::Base>> fields;
+};
+}        // namespace vkb