# Changes 0.2.4-1

- Add GIT_BRANCH (for development and stable)
- Write  Documentation of
  - pd-core (exept of vec.hpp)
  - pd-app
  - pd-drivers
  - pd-lib3ds
  - pd-image
  - pd-image
  - pd-ui7

include/pd/core/bit_util.hpp

@@ -27,8 +27,21 @@ SOFTWARE.
 #include <pd/core/common.hpp>
 
 namespace PD {
+/**
+ * Binary Utillity Functions
+ */
 namespace BitUtil {
+/**
+ * Check if a 32 Bit number only set a sigle bit to 1
+ * @param v 32 bit unsigned int
+ * @return true if its a single bit number
+ */
 bool IsSingleBit(u32 v);
+/**
+ * Get the Next Power of two Number
+ * @param v Current Number
+ * @return Next Number thats a Pow of 2
+ */
 u32 GetPow2(u32 v);
 }  // namespace BitUtil
 }  // namespace PD

include/pd/core/color.hpp

@@ -27,56 +27,144 @@ SOFTWARE.
 #include <pd/core/common.hpp>
 
 namespace PD {
-/// @brief Color class (Supports hex, rgb(a)8, u32 input)
-/// @note no safeteychecks used here for performance
+/**
+ * Color class
+ *
+ * - Supports hex input starting with a # and 6 or 8 digits
+ * - Supports rgb(a) 8Bit unsigned number input
+ * - Supports rgb(a) float input from 0.0 to 1.0
+ * - Supports 32Bit input color
+ * @note Safetey checks are disabled for maximum performance
+ */
 class Color {
  public:
+  /**
+   * Default Constructor (all variables are set to 0)
+   */
   Color() : m_r(0), m_g(0), m_b(0), m_a(0) {}
+  /**
+   * Constructor for 32Bit Color Input
+   * @param color 32Bit Color value
+   */
   Color(u32 color) {
     m_a = (color >> 24) & 0xff;
     m_b = (color >> 16) & 0xff;
     m_g = (color >> 8) & 0xff;
     m_r = color & 0xff;
   }
+  /**
+   * Constructor for 8Bit Input
+   * @param r Red Value
+   * @param g Green Value
+   * @param b Blue Value
+   * @param a Optional Alpha Value (Defaults to 255)
+   */
   Color(u8 r, u8 g, u8 b, u8 a = 255) {
     m_r = r;
     m_g = g;
     m_b = b;
     m_a = a;
   }
+  /**
+   * Constructor for float Input
+   * @param r Red Value
+   * @param g Green Value
+   * @param b Blue Value
+   * @param a Optional Alpha Value (Defaults to 1.0f)
+   * @note There is no Check if the number is between 0.0 and 1.0
+   */
   Color(float r, float g, float b, float a = 1.f) {
     m_r = static_cast<u8>(255.f * r);
     m_g = static_cast<u8>(255.f * g);
     m_b = static_cast<u8>(255.f * b);
     m_a = static_cast<u8>(255.f * a);
   }
+  /**
+   * Constructor for Hex Input
+   * @param hex Hex String in `#ffffff` or `#ffffffff` format
+   */
   Color(const std::string& hex) { Hex(hex); }
+  /**
+   * Unused Deconstructor
+   */
   ~Color() {}
 
+  /**
+   * Create Color Object by Hex String
+   * @param hex Hex String in `#ffffff` or `#ffffffff` format
+   * @return Color class itself
+   */
   Color& Hex(const std::string& hex);
+  /**
+   * Convert this Color Object to Hex string
+   * @param rgba [default false] sets if 8 or 6 digit color should be returned
+   * @return Color Hex String
+   */
   std::string Hex(bool rgba = false) const;
 
+  /**
+   * Setter for Red
+   * @param v value
+   * @return Color class reference
+   */
   Color& r(u8 v) {
     m_r = v;
     return *this;
   }
+  /**
+   * Getter for Red
+   * @return Red Value
+   */
   u8 r() const { return m_r; }
+  /**
+   * Setter for Green
+   * @param v value
+   * @return Color class reference
+   */
   Color& g(u8 v) {
     m_g = v;
     return *this;
   }
+  /**
+   * Getter for Green
+   * @return Green Value
+   */
   u8 g() const { return m_r; }
+  /**
+   * Setter for Blue
+   * @param v value
+   * @return Color class reference
+   */
   Color& b(u8 v) {
     m_b = v;
     return *this;
   }
+  /**
+   * Getter for Blue
+   * @return Blue Value
+   */
   u8 b() const { return m_r; }
+  /**
+   * Setter for Alpha
+   * @param v value
+   * @return Color class reference
+   */
   Color& a(u8 v) {
     m_a = v;
     return *this;
   }
+  /**
+   * Getter for Alpha
+   * @return Alpha Value
+   */
   u8 a() const { return m_r; }
 
+  /**
+   * Fade from Current to another Color
+   * @param color Color to fade to
+   * @param p Amount (supports -1.0 to 1.0 for use of sine)
+   * @return Class Reference
+   */
   Color& Fade(const Color& color, float p) {
     m_a = static_cast<u8>((color.a() - m_a) * ((p + 1.f) / 2));
     m_b = static_cast<u8>((color.b() - m_b) * ((p + 1.f) / 2));
@@ -84,19 +172,39 @@ class Color {
     m_r = static_cast<u8>((color.r() - m_r) * ((p + 1.f) / 2));
     return *this;
   }
+  /**
+   * Get 32Bit Color Value
+   * @return 32Bit Color Value
+   */
   u32 Get() const { return (m_a << 24) | (m_b << 16) | (m_g << 8) | m_r; }
+  /**
+   * Get The Luminance of the Color
+   * @return luminance (from 0.0 to 1.0)
+   */
   float Luminance() const {
     // For Reference https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness
     return (0.3 * (m_r / 255.f) + 0.59 * (m_g / 255.f) + 0.11 * (m_b / 255.f));
   }
+  /**
+   * Check if the Color is Light or Dark
+   * @return true if light
+   */
   bool IsLight() const { return (Luminance() >= 0.5); }
 
+  /**
+   * Operator to cast Color to 32Bit Value
+   * @return 32Bit Color Value
+   */
   operator u32() const { return Get(); }
 
  private:
+  /** Red Value */
   u8 m_r;
+  /** Green Value */
   u8 m_g;
+  /** Blue Value */
   u8 m_b;
+  /** Alpha Value */
   u8 m_a;
 };
 }  // namespace PD

include/pd/core/common.hpp

@@ -38,43 +38,82 @@ SOFTWARE.
 #include <vector>
 
 namespace PD {
-// New Version of Smart CTOR
-// Using as Template class
+/**
+ * SmartCtor (std::shared_ptr) Template class for Smart Pointers
+ *
+ * - Just add : public PD::SmartCtor<YourClass> to your class
+ * @tparam T Your Class
+ */
 template <typename T>
 class SmartCtor {
  public:
-  /// @brief Type Reference
+  /** Reference alias for std::shared_ptr<Type> */
   using Ref = std::shared_ptr<T>;
 
-  /// @brief Creates a New Shared Pointer
-  /// @param ...args Arguments to forward
-  /// @return Shared Pointer (Reference)
+  /**
+   * static Function to Create a New Reference
+   * @param args Additional Arguments (Depends on your classes Constructors)
+   * @return New Reference Object
+   */
   template <typename... Args>
   static Ref New(Args&&... args) {
     return std::make_shared<T>(std::forward<Args>(args)...);
   }
 };
-/// @brief Wrapper for SmartCtor<Type>::New
-/// @tparam T class type
-/// @param ...args Arguments
-/// @return SmartCtor<T>::Ref type reference
-/// @note Not sure if this is solving the problem or
-/// if I schould switch back to the macro
+/**
+ * Wrapper for SmartCtor<Type>::New(Args)
+ * @tparam T Class Type
+ * @param args Arguments
+ * @return Type Reference (SmartPointer)
+ */
 template <typename T, typename... Args>
 SmartCtor<T>::Ref New(Args&&... args) {
   return SmartCtor<T>::New(std::forward<Args>(args)...);
 }
 // Defines
+
+/** alias for 64 Bit unsigned integer */
 using u64 = unsigned long long;
+/** alias for 32 Bit unsigned integer */
 using u32 = unsigned int;
+/** alias for 16 Bit unsigned integer */
 using u16 = unsigned short;
+/** alias for 8 Bit unsigned integer */
 using u8 = unsigned char;
 
+/**
+ * LinInfo Compile Information
+ */
 namespace LibInfo {
+/**
+ * Get the Compiler Name and Version the lib got Compiled with
+ * @return Compiler Name / Version
+ */
 const std::string CompiledWith();
+/**
+ * Get the C++ Version used to compile the lib
+ * @return C++ Version (__cplusplus)
+ */
 const std::string CxxVersion();
+/**
+ * Get the Buildtime of the Library
+ * @return Build Time
+ */
 const std::string BuildTime();
+/**
+ * Get the Library Version
+ * @return Library Version String
+ */
 const std::string Version();
+/**
+ * Get the Git Commit the Lib got compiled in
+ * @return Git Commit 7digit short hash
+ */
 const std::string Commit();
+/**
+ * Get the Git Branch which was active when compiling the lib
+ * @return Git Branch
+ */
+const std::string Branch();
 }  // namespace LibInfo
 }  // namespace PD

include/pd/core/io.hpp

@@ -26,8 +26,21 @@ SOFTWARE.
 #include <pd/core/common.hpp>
 
 namespace PD {
+/**
+ * Set of File Functions
+ */
 namespace IO {
+/**
+ * Load a File into an 8Bit Memory Buffer
+ * @param path Path to the File
+ * @return 8Bit FileBuffer
+ */
 std::vector<u8> LoadFile2Mem(const std::string& path);
+/**
+ * Hash a 8Bit Memory Buffer
+ * @param data 8Bit input Buffer
+ * @return 32Bit Hash
+ */
 u32 HashMemory(const std::vector<u8>& data);
 }  // namespace IO
 }  // namespace PD

include/pd/core/strings.hpp

@@ -26,23 +26,81 @@ SOFTWARE.
 #include <pd/core/common.hpp>
 
 namespace PD {
+/**
+ * Set of String Utillity Functions
+ */
 namespace Strings {
+/**
+ * Check if a String ends with a specific extension
+ * @param str Input string
+ * @param exts List of Extensions to check for
+ * @return true if one of the extensions is found in the String
+ */
 bool StringEndsWith(const std::string& str,
                     const std::vector<std::string>& exts);
+/**
+ * Function to Create a wstring of a string
+ * @param s Input String to Convert
+ * @return Result wstring
+ * @note Currently using std::filesystem::path for this as wstring_convert
+ * got removed in c++ 20
+ */
 std::wstring MakeWstring(const std::string& s);
+/**
+ * Generate a Formatted String by an Nanoseconds Input
+ * @param nanos Nanoseconds Input
+ * @return Result String
+ */
 const std::string FormatNanos(unsigned long long nanos);
+/**
+ * Generate a Formatted String by an Milliseconds Input
+ * @param millis Milliseconds Input
+ * @return Result String
+ */
 const std::string FormatMillis(unsigned long long millis);
+/**
+ * Create a formatted String by an input bytes value
+ * @param bytes value in bytes
+ * @result Formatted String for example `2.5MB`
+ */
 const std::string FormatBytes(unsigned long long bytes);
+/**
+ * Extract the Filename out of a Path
+ * @param path Path to extract from
+ * @param saperators Path Split Chars
+ * @return extracted filename
+ */
 const std::string GetFileName(const std::string& path,
                               const std::string& saperators = "/\\");
+/**
+ * Remove Extension from a Path / Filename
+ * @param path Input Path
+ * @return Path without Extension
+ */
 const std::string PathRemoveExtension(const std::string& path);
+/**
+ * Function to Convert a Type to a hex value
+ * @tparam T Type
+ * @param v value
+ * @return hex string beginning with 0x
+ */
 template <typename T>
 inline const std::string ToHex(const T& v) {
   std::stringstream s;
   s << "0x" << std::setfill('0') << std::setw(sizeof(v) * 2) << std::hex << v;
   return s.str();
 }
+/**
+ * Generate a Hash out of a string
+ * @param s String to hash
+ * @return 32Bit Hash
+ */
 u32 FastHash(const std::string& s);
+/**
+ * Function to Generate a Compiler Name and Version String
+ * Based on their Macros
+ * @return CompilerName: Version
+ */
 inline const std::string GetCompilerVersion() {
   /// As the function looks like this Project is meant to
   /// Be ported to other systems as well

include/pd/core/sys.hpp

@@ -27,12 +27,40 @@ SOFTWARE.
 #include <pd/core/timetrace.hpp>
 
 namespace PD {
+/**
+ * Namespace containing functions for get Millis and Get Nanos
+ */
 namespace Sys {
+/**
+ * alias for the TimeTrace Traces Map
+ */
 using TraceMap = std::map<std::string, TT::Res::Ref>;
+/**
+ * Get Current Time in Milliseconds
+ * @return 64Bit value of millis
+ */
 u64 GetTime();
+/**
+ * Get Current Time in Nanoseconds
+ * @return 64Bit value of nanos
+ */
 u64 GetNanoTime();
+/**
+ * Get a TimeTrace Reference by its string ID
+ * @param id trace name
+ * @return Trace reference or nullptr if not found
+ */
 TT::Res::Ref& GetTraceRef(const std::string& id);
+/**
+ * Check if a Trace with the name exists
+ * @param id tracename to search
+ * @return true if exist
+ */
 bool TraceExist(const std::string& id);
+/**
+ * Get TraceMap Reference
+ * @return edidable Reference to the TraceMap
+ */
 TraceMap& GetTraceMap();
 }  // namespace Sys
 }  // namespace PD

include/pd/core/timer.hpp

@@ -27,21 +27,58 @@ SOFTWARE.
 #include <pd/core/sys.hpp>
 
 namespace PD {
+/**
+ * Timer class
+ */
 class Timer : public SmartCtor<Timer> {
  public:
+  /**
+   * Constructor
+   * @param auto_start [default true] sets if timer should start after creation
+   */
   Timer(bool auto_start = true);
+  /**
+   * Unused Deconstructor
+   */
   ~Timer() {}
+  /**
+   * Resume Timer if Paused
+   */
   void Rseume();
+  /**
+   * Pause Timer if not Paused
+   */
   void Pause();
+  /**
+   * Update Timer
+   */
   void Update();
+  /**
+   * Reset Timer
+   */
   void Reset();
+  /**
+   * Check if the Timer is Running
+   * @return true if its running
+   */
   bool IsRunning() const;
+  /**
+   *  Get 64 Bit milliseconds value
+   *  @return 64Bit millis
+   */
   u64 Get();
+  /**
+   * Get as Seconds
+   * @return seconds as floating number
+   */
   double GetSeconds();
 
  private:
+  /** Start of the Timer */
   u64 start;
+  /** Current Time */
   u64 now;
+  /** Is Running */
   bool is_running = false;
 };
 }  // namespace PD

include/pd/core/timetrace.hpp

@@ -26,17 +26,32 @@ SOFTWARE.
 #include <pd/core/common.hpp>
 
 namespace PD {
+/**
+ * Class to calculate Maximum/Minimum and Average Timings
+ */
 class TimeStats : public SmartCtor<TimeStats> {
  public:
+  /**
+   * Constructor taking a lengh for the List
+   * @param l Lengh of the data list
+   */
   TimeStats(int l) : len(l), val(l, 0) {}
   ~TimeStats() = default;
 
+  /**
+   * Add a New Value to the list
+   * @param v value to add
+   */
   void Add(u64 v) {
     val[idx] = v;
     idx = next(idx);
     num_val = std::min(num_val + 1, len);
   }
 
+  /**
+   * Get Avarage Num
+   * @return Average
+   */
   u64 GetAverage() {
     if (!num_val) return 0.f;
     u64 res = 0;
@@ -46,6 +61,10 @@ class TimeStats : public SmartCtor<TimeStats> {
     return res / num_val;
   }
 
+  /**
+   * Get Minimum Num
+   * @return Minimum value
+   */
   u64 GetMin() {
     if (!num_val) return 0.f;
     u64 res = std::numeric_limits<u64>::max();
@@ -55,6 +74,10 @@ class TimeStats : public SmartCtor<TimeStats> {
     return res;
   }
 
+  /**
+   * Get Maximum Value
+   * @return Max Value
+   */
   u64 GetMax() {
     if (!num_val) return 0.f;
     u64 res = 0;
@@ -64,62 +87,168 @@ class TimeStats : public SmartCtor<TimeStats> {
     return res;
   }
 
+  /**
+   * Clear the List
+   */
   void Clear() {
     val.assign(len, 0);
     idx = 0;
     num_val = 0;
   }
 
+  /**
+   * Get Data Buffer
+   * @return data bufer (not edidable)
+   */
   const std::vector<u64> &GetData() { return val; }
+  /**
+   * Access an element in the list [not edidable]
+   * @return value to access
+   */
   const u64 &operator[](int i) { return val[smart_idx(i)]; }
+  /**
+   * Get List Lengh
+   * @return Lengh
+   */
   const size_t GetLen() { return len; }
+  /**
+   * Get Number of Values
+   * @return number of values
+   */
   const size_t GetNumValues() { return num_val; }
 
  private:
+  /**
+   * Get the Next Position to write to
+   * @param c current position
+   * @return next position
+   */
   size_t next(size_t c) const { return (c + 1) % len; }
+  /**
+   * Smart Indexing in for loops to make sure to
+   * not index a value that was not set yet
+   * @param v pos in for loop
+   * @return indexing pos
+   */
   size_t smart_idx(size_t v) const { return (idx + len - num_val + v) % len; }
 
+  /** Lengh of the list */
   int len = 0;
+  /** Value Storage */
   std::vector<u64> val;
   int idx = 0;
   int num_val = 0;
 };
+/**
+ * Timatrace Functions
+ */
 namespace TT {
+/**
+ * Data Structure for a TimeTrace Result
+ */
 class Res : public SmartCtor<Res> {
  public:
+  /** Constructore that Inits a protocol at size of 60 frames */
   Res() { protocol = TimeStats::New(60); }
   ~Res() = default;
 
+  /**
+   * Setter for the ID (Name)
+   * @param v ID of the Trace
+   */
   void SetID(const std::string &v) { id = v; }
+  /**
+   * Getter for the traces ID
+   * @return Trace ID
+   */
   const std::string GetID() { return id; }
+  /**
+   * Setter for the Start Value
+   * @param v start time
+   */
   void SetStart(u64 v) { start = v; }
+  /**
+   * Getter for the Start time
+   * @return start time
+   */
   u64 GetStart() { return start; }
+  /**
+   * Setter for the End Time
+   * @param v end time
+   */
   void SetEnd(u64 v) {
     end = v;
     protocol->Add(GetLastDiff());
   }
+  /**
+   * Getter for the End Time
+   * @result end time
+   */
   u64 GetEnd() { return end; }
 
+  /**
+   * Get Last Diffrence between end and start
+   * @return end - start
+   */
   u64 GetLastDiff() { return end - start; }
+  /**
+   * Get Protcol Reference
+   * @return Protocol Ref
+   */
   TimeStats::Ref GetProtocol() { return protocol; }
 
  private:
+  /** Trace ID */
   std::string id;
+  /** Start time */
   u64 start;
+  /** End Time */
   u64 end;
+  /** Protocol */
   TimeStats::Ref protocol;
 };
+/**
+ * Begin a Trace
+ * @param id Name of the Trace
+ */
 void Beg(const std::string &id);
+/**
+ * End a Trace
+ * @param id Name of the Trace
+ */
 void End(const std::string &id);
+/**
+ * Collect Start end end of the trace by tracking
+ * when the Scope object goes out of scope
+ *
+ * Example:
+ * ```cpp
+ * void SomeFunction() {
+ *    // Create a Scoped Trace called "SomeFunc"
+ *    PD::TT::Scope st("SomeFunc");
+ *    // Do your functions stuff
+ *    // End at the end it goes out of
+ *    // scope which collects the end time
+ * }
+ * ```
+ */
 class Scope {
  public:
+  /**
+   * Constructor requiring a Name for the Trace
+   * @param id Name of the Trace
+   */
   Scope(const std::string &id) {
     this->id = id;
     Beg(id);
   }
+  /**
+   * Deconstructor getting the end time when going out of scope
+   */
   ~Scope() { End(id); }
 
  private:
+  /** Trace Name/ID */
   std::string id;
 };
 }  // namespace TT

include/pd/core/tween.hpp

@@ -26,24 +26,35 @@ SOFTWARE.
 #include <pd/core/vec.hpp>
 
 namespace PD {
+/**
+ * D7 Tween Engine (or something like that)
+ * @tparam T Any Numeric value
+ */
 template <typename T>
 class Tween {
  public:
+  /**
+   * Effects Table
+   */
   enum Effect {
-    Linear,
-    EaseInQuad,
-    EaseOutQuad,
-    EaseInOutQuad,
-    EaseInCubic,
-    EaseOutCubic,
-    EaseInOutCubic,
-    EaseInSine,
-    EaseOutSine,
-    EaseInOutSine,
+    Linear,          ///< Linear Movement [works]
+    EaseInQuad,      ///< EaseInQuad Movement [works]
+    EaseOutQuad,     ///< EaseOutQuad Movement [works]
+    EaseInOutQuad,   ///< EaseInOutQuad Movement [works]
+    EaseInCubic,     ///< EaseInCubic Movement [not tested]
+    EaseOutCubic,    ///< EaseOutCubic Movement [not tested]
+    EaseInOutCubic,  ///< EaseInOutCubic Movement [disabled]
+    EaseInSine,      ///< EaseInSine Movement [works]
+    EaseOutSine,     ///< EaseOutSine Movement [works]
+    EaseInOutSine,   ///< EaseInOutSine Movement [not tested]
   };
-  Tween() {}
-  ~Tween() {}
+  Tween() = default;
+  ~Tween() = default;
 
+  /**
+   * Update Tween
+   * @param delta deltatime
+   */
   void Update(float delta) {
     time += delta / 1000.f;
     if (time > tend) {
@@ -52,44 +63,82 @@ class Tween {
     }
   }
 
+  /**
+   * Check if Tween is finished
+   * @return true if finished
+   */
   bool IsFinished() const { return finished; }
 
+  /**
+   * Force finish the animation
+   * @return Class reference
+   */
   Tween& Finish() {
     time = tend;
     finished = true;
     return *this;
   }
 
+  /**
+   * Set Start Value
+   * @tparam T datatype of the Tween
+   * @param start Start Value
+   * @return class Reference
+   */
   Tween& From(const T& start) {
     Reset();
     this->start = start;
     return *this;
   }
+  /**
+   * Set End Value
+   * @tparam T datatype of the Tween
+   * @param end End Value
+   * @return class Reference
+   */
   Tween& To(const T& end) {
     Reset();
     this->end = end;
     return *this;
   }
+  /**
+   * Set the Duration (in seconds)
+   * @param seconds Duration
+   * @return class Reference
+   */
   Tween& In(float seconds) {
     Reset();
     tend = seconds;
     return *this;
   }
+  /**
+   * Set Effect of the Tween
+   * @param e Effect
+   * @return class Reference
+   */
   Tween& As(const Effect& e) {
     effect = e;
     return *this;
   }
+  /**
+   * Reset to time 0
+   * @return class Reference
+   */
   Tween& Reset() {
     finished = false;
     time = 0.f;
     return *this;
   }
-  /// @brief Probably usefull for fading colors by animation
-  /// Used to create this caus dont wanted to create a
-  /// fade effect fpr keyboard without having to Tween functions
-  /// @return
+  /**
+   * Get the Prograss in percent (0.0 to 1.0) of the tween
+   * @return progress value
+   */
   float Progress() const { return time / tend; }
 
+  /**
+   * Swap Start and end Position of the Tween
+   * @return class reference
+   */
   Tween& Swap() {
     T temp = start;
     start = end;
@@ -97,6 +146,10 @@ class Tween {
     return *this;
   }
 
+  /**
+   * Operator that returns the current value calculated
+   * by time and effect
+   */
   operator T() {
     float t = 0.f;
     switch (effect) {
@@ -147,15 +200,23 @@ class Tween {
   }
 
  private:
+  /** Animation Effect */
   Effect effect;
+  /** Time */
   float time = 0.f;
-  // Defaulting to one to prevent div zero
-  // without a safetey check
-  // not implementing one cause if the user is
-  // Writing a In(0.f) its their fault
+  /**
+   * End time
+   * Defaulting to one to prevent div zero
+   * without a safetey check
+   * not implementing one cause if the user is
+   * Writing a In(0.f) its their fault
+   */
   float tend = 1.f;
+  /** Start value */
   T start;
+  /** end value */
   T end;
+  /** is finished value */
   bool finished = false;
 };
 }  // namespace PD

include/pd/core/vec.hpp

@@ -23,11 +23,9 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
-/**
- * Why Creating this:
- * Cause using makes coding much better structured
- * and easy to use like in glsl or glm
- */
+// Why Creating this:
+// Cause using makes coding much better structured
+// and easy to use like in glsl or glm
 
 #include <pd/core/common.hpp>