# Rewrite Stage 1.5

- Added Overlays (Performance / Keyboaed)
- Keyboard has Gamepad Movement WIP (kinda)
- Work on UI7 Started
- Added Input Manager
- Added Message Boxes (Animated)
- Added Signle Header Tween func for animated stuff (Keyboard Messages, etc)
- Add FastHash (Maybe useful later)
- Using const & for vec in lithium
- Add ability to copy a command by a Ref
- Make Lists in Commands OpenAccess for Modification (StaticObject)
- Add Static Object (System to PreRender Suff that never changes) but can still be recolored or moved
- Add Layer and Font change functions
- Make Renderer Tools (RotateCorner, CreateRect, CreateLine, InBox, OptiCommandList) static (OpenAccess)
- Add ReIndexing to PushCommand
- Add Ability to Init vec3 and vec4 with vec2 and add .xy and .zw to vec4
- Fully Animated Keyboard that currently has problem of Top Down GamePad movement
- Add Func to Get GamePad Icon Codepoints for TextRenderer
- Made deltatime a float
- Using filesystem::path().wstring for convertation (works)
- Add a New InBox to Renderer that only checks if a point is inside a boundingbox
- Disable Font loading on Renderer Init due to 3ds Freezes when using SystemFont
- Make SystemFont lineheight 10% larger than it is to be nearly the same size as the ttf fonts
- Fix Some SpaceOffsets between TTF and SystemFont Rendering
- Cleanup the Update Rendermode Func
- Use LayerRenderSystem by default now as it now runs faster even with ttf fonts

include/pd/maths/tween.hpp

@@ -0,0 +1,138 @@
+#pragma once
+
+#include <pd/maths/vec.hpp>
+
+namespace PD {
+template <typename T>
+class Tween {
+ public:
+  enum Effect {
+    Linear,
+    EaseInQuad,
+    EaseOutQuad,
+    EaseInOutQuad,
+    EaseInCubic,
+    EaseOutCubic,
+    EaseInOutCubic,
+    EaseInSine,
+    EaseOutSine,
+    EaseInOutSine,
+  };
+  Tween() {}
+  ~Tween() {}
+
+  void Update(float delta) {
+    time += delta / 1000.f;
+    if (time > tend) {
+      finished = true;
+      time = tend;
+    }
+  }
+
+  bool IsFinished() const { return finished; }
+
+  Tween& Finish() {
+    time = tend;
+    finished = true;
+    return *this;
+  }
+
+  Tween& From(const T& start) {
+    Reset();
+    this->start = start;
+    return *this;
+  }
+  Tween& To(const T& end) {
+    Reset();
+    this->end = end;
+    return *this;
+  }
+  Tween& In(float seconds) {
+    Reset();
+    tend = seconds;
+    return *this;
+  }
+  Tween& As(const Effect& e) {
+    effect = e;
+    return *this;
+  }
+  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
+  float Progress() const { return time / tend; }
+
+  Tween& Swap() {
+    T temp = start;
+    start = end;
+    end = temp;
+    return *this;
+  }
+
+  operator T() {
+    float t = 0.f;
+    switch (effect) {
+      case EaseInQuad:
+        t = time / tend;
+        return (end - start) * t * t + start;
+        break;
+      case EaseOutQuad:
+        t = time / tend;
+        return -(end - start) * t * (t - 2) + start;
+        break;
+      case EaseInOutQuad:
+        t = time / (tend / 2);
+        if (t < 1) return (end - start) / 2 * t * t + start;
+        t--;
+        return -(end - start) / 2 * (t * (t - 2) - 1) + start;
+        break;
+      case EaseInCubic:
+        t = time / tend;
+        return (end - start) * t * t * t + start;
+        break;
+      case EaseOutCubic:
+        t = time / tend;
+        t--;
+        return (end - start) * (t * t * t + 1) + start;
+        break;
+      // case EaseInOutCubic:
+      //   t = time / (tend / 2);
+      //   if (t < 1) return (end - start) / 2 * t * t * t + start;
+      //   t--;
+      //   return (end - start) / 2 * (t * t * t * 2) + start;
+      //   break;
+      case EaseInSine:
+        return -(end - start) * cos(time / tend * (M_PI / 2)) + (end - start) +
+               start;
+        break;
+      case EaseOutSine:
+        return (end - start) * sin(time / tend * (M_PI / 2)) + start;
+        break;
+      case EaseInOutSine:
+        return -(end - start) / 2 * (cos(M_PI * time / tend) - 1) + start;
+        break;
+
+      default:  // Linear
+        return (end - start) * (time / tend) + start;
+        break;
+    }
+  }
+
+ private:
+  Effect effect;
+  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
+  float tend = 1.f;
+  T start;
+  T end;
+  bool finished = false;
+};
+}  // namespace PD

include/pd/maths/vec.hpp

@@ -332,6 +332,20 @@ struct vec4 {
     v[3] = i;
   }
 
+  vec4(const vec3 &xyz, float w) {
+    v[0] = xyz[0];
+    v[1] = xyz[1];
+    v[2] = xyz[2];
+    v[3] = w;
+  }
+
+  vec4(float x, const vec3 &yzw) {
+    v[0] = x;
+    v[1] = yzw[1];
+    v[2] = yzw[2];
+    v[3] = yzw[3];
+  }
+
   // Operators
   // Add
   vec4 &operator+=(const vec4 &i) {
@@ -371,7 +385,7 @@ struct vec4 {
   }
 
   // Base
-  vec3 operator-() const { return vec3(-v[0], -v[1], -v[2]); }
+  vec4 operator-() const { return vec4(-v[0], -v[1], -v[2], -v[3]); }
   float operator[](int i) const { return v[i]; }
   float &operator[](int i) { return v[i]; }
 
@@ -380,7 +394,7 @@ struct vec4 {
     return v[0] * v[0] + v[1] * v[1] + v[2] * v[2] + v[3] * v[3];
   }
 
-  // Vec2 Acess
+  // Vec Acess
   float x() const { return v[0]; }
   float &x() { return v[0]; }
   float y() const { return v[1]; }
@@ -389,6 +403,10 @@ struct vec4 {
   float &z() { return v[2]; }
   float w() const { return v[3]; }
   float &w() { return v[3]; }
+  vec2 xy() const { return vec2(v[0], v[1]); }
+  vec2 zw() const { return vec2(v[2], v[3]); }
+  vec3 xyz() const { return vec3(v[0], v[1], v[2]); }
+  vec3 yzw() const { return vec3(v[1], v[2], v[3]); }
   // Quaternion Acess
   float r() const { return v[0]; }
   float &r() { return v[0]; }
@@ -398,6 +416,10 @@ struct vec4 {
   float &j() { return v[2]; }
   float i() const { return v[3]; }
   float &i() { return v[3]; }
+  vec2 rk() const { return vec2(v[0], v[1]); }
+  vec2 ji() const { return vec2(v[2], v[3]); }
+  vec3 rkj() const { return vec3(v[0], v[1], v[2]); }
+  vec3 kji() const { return vec3(v[1], v[2], v[3]); }
   // Internal Values
   float v[4];
 };