vecmath

build/android/app/CMakeLists.txt

@@ -54,7 +54,6 @@ add_library(kaliber SHARED
     ../../../src/base/sinc_resampler.cc
     ../../../src/base/task_runner.cc
     ../../../src/base/timer.cc
-    ../../../src/base/vecmath.cc
     ../../../src/base/worker.cc
     ../../../src/demo/credits.cc
     ../../../src/demo/demo.cc

build/linux/Makefile

@@ -79,7 +79,6 @@ GLTEST_SRC := \
   $(SRC_ROOT)/base/sinc_resampler.cc \
   $(SRC_ROOT)/base/task_runner.cc \
   $(SRC_ROOT)/base/timer.cc \
-  $(SRC_ROOT)/base/vecmath.cc \
   $(SRC_ROOT)/base/worker.cc \
   $(SRC_ROOT)/demo/credits.cc \
   $(SRC_ROOT)/demo/demo.cc \

src/base/BUILD.gn

@@ -18,7 +18,6 @@ source_set("base") {
     "task_runner.h",
     "timer.cc",
     "timer.h",
-    "vecmath.cc",
     "vecmath.h",
     "worker.cc",
     "worker.h",

src/base/collusion_test.cc

@@ -6,9 +6,9 @@
 
 namespace base {
 
-bool Intersection(const Vector2& center,
+bool Intersection(const Vector2f& center,
-                  const Vector2& size,
+                  const Vector2f& size,
-                  const Vector2& point) {
+                  const Vector2f& point) {
   float dx = point.x - center.x;
   float px = size.x / 2 - fabs(dx);
   if (px <= 0)
@@ -19,12 +19,12 @@ bool Intersection(const Vector2& center,
   return py > 0;
 }
 
-bool Intersection(const Vector2& center,
+bool Intersection(const Vector2f& center,
-                  const Vector2& size,
+                  const Vector2f& size,
-                  const Vector2& origin,
+                  const Vector2f& origin,
-                  const Vector2& dir) {
+                  const Vector2f& dir) {
-  Vector2 min = center - size / 2;
+  Vector2f min = center - size / 2;
-  Vector2 max = center + size / 2;
+  Vector2f max = center + size / 2;
 
   float tmin = std::numeric_limits<float>::min();
   float tmax = std::numeric_limits<float>::max();

src/base/collusion_test.h

@@ -6,17 +6,17 @@
 namespace base {
 
 // AABB vs point.
-bool Intersection(const Vector2& center,
+bool Intersection(const Vector2f& center,
-                  const Vector2& size,
+                  const Vector2f& size,
-                  const Vector2& point);
+                  const Vector2f& point);
 
 // Ray-AABB intersection test.
 // center, size: Center and size of the box.
 // origin, dir: Origin and direction of the ray.
-bool Intersection(const Vector2& center,
+bool Intersection(const Vector2f& center,
-                  const Vector2& size,
+                  const Vector2f& size,
-                  const Vector2& origin,
+                  const Vector2f& origin,
-                  const Vector2& dir);
+                  const Vector2f& dir);
 
 }  // namespace base
 

src/base/vecmath.cc

@@ -1,21 +0,0 @@
-#include "vecmath.h"
-
-using namespace std::string_literals;
-
-namespace base {
-
-std::string Vector2::ToString() {
-  return "("s + std::to_string(x) + ", "s + std::to_string(y) + ")"s;
-}
-
-Matrix4x4 Ortho(float left, float right, float bottom, float top) {
-  Matrix4x4 m(1);
-  m.c[0].x = 2.0f / (right - left);
-  m.c[1].y = 2.0f / (top - bottom);
-  m.c[2].z = -1.0f;
-  m.c[3].x = -(right + left) / (right - left);
-  m.c[3].y = -(top + bottom) / (top - bottom);
-  return m;
-}
-
-}  // namespace base

src/demo/credits.cc

@@ -18,7 +18,7 @@ constexpr char kCreditsLines[Credits::kNumLines][15] = {
 
 constexpr float kLineSpaces[Credits::kNumLines - 1] = {1.5f, 0.5f, 1.5f, 0.5f};
 
-const Vector4 kTextColor = {0.80f, 0.87f, 0.93f, 1};
+const Vector4f kTextColor = {0.80f, 0.87f, 0.93f, 1};
 constexpr float kFadeSpeed = 0.2f;
 
 }  // namespace
@@ -64,12 +64,12 @@ void Credits::Show() {
     text_[i].Create("credits", {1, kNumLines});
     text_[i].SetZOrder(50);
     text_[i].SetPosition({0, 0});
-    text_[i].SetColor(kTextColor * Vector4(1, 1, 1, 0));
+    text_[i].SetColor(kTextColor * Vector4f(1, 1, 1, 0));
     text_[i].SetFrame(i);
 
     if (i > 0) {
       text_[i].PlaceToBottomOf(text_[i - 1]);
-      text_[i].Translate(text_[i - 1].GetPosition() * Vector2(0, 1));
+      text_[i].Translate(text_[i - 1].GetPosition() * Vector2f(0, 1));
       text_[i].Translate({0, text_[i - 1].GetSize().y * -kLineSpaces[i - 1]});
     }
   }
@@ -94,7 +94,7 @@ void Credits::Hide() {
     text_animator_.SetEndCallback(Animator::kBlending, nullptr);
     text_animator_.SetVisible(false);
   });
-  text_animator_.SetBlending(kTextColor * Vector4(1, 1, 1, 0), kFadeSpeed);
+  text_animator_.SetBlending(kTextColor * Vector4f(1, 1, 1, 0), kFadeSpeed);
   text_animator_.Play(Animator::kBlending, false);
 }
 

src/demo/demo.cc

@@ -193,7 +193,7 @@ void Demo::UpdateGameState(float delta_time) {
 
         float weights[3] = {0, 0, 0};
         weights[dominant_channel] = 1;
-        Vector4 c = {Lerp(0.75f, 0.95f, rnd.GetFloat()) * weights[0],
+        Vector4f c = {Lerp(0.75f, 0.95f, rnd.GetFloat()) * weights[0],
                       Lerp(0.75f, 0.95f, rnd.GetFloat()) * weights[1],
                       Lerp(0.75f, 0.95f, rnd.GetFloat()) * weights[2], 1};
         c += {Lerp(0.1f, 0.5f, rnd.GetFloat()) * (1 - weights[0]),

src/demo/enemy.cc

@@ -96,19 +96,19 @@ bool Enemy::HasTarget(DamageType damage_type) {
   return GetTarget(damage_type) ? true : false;
 }
 
-Vector2 Enemy::GetTargetPos(DamageType damage_type) {
+Vector2f Enemy::GetTargetPos(DamageType damage_type) {
   DCHECK(damage_type > kDamageType_Invalid && damage_type < kDamageType_Any);
 
   EnemyUnit* target = GetTarget(damage_type);
   if (target)
     return target->sprite.GetPosition() -
-           Vector2(0, target->sprite.GetSize().y / 2.5f);
+           Vector2f(0, target->sprite.GetSize().y / 2.5f);
   return {0, 0};
 }
 
 void Enemy::SelectTarget(DamageType damage_type,
-                         const Vector2& origin,
+                         const Vector2f& origin,
-                         const Vector2& dir,
+                         const Vector2f& dir,
                          float snap_factor) {
   DCHECK(damage_type > kDamageType_Invalid && damage_type < kDamageType_Any);
 
@@ -132,8 +132,8 @@ void Enemy::SelectTarget(DamageType damage_type,
                             e.sprite.GetSize() * snap_factor, origin, dir))
       continue;
 
-    Vector2 weapon_enemy_dir = e.sprite.GetPosition() - origin;
+    Vector2f weapon_enemy_dir = e.sprite.GetPosition() - origin;
-    float enemy_weapon_dist = weapon_enemy_dir.Magnitude();
+    float enemy_weapon_dist = weapon_enemy_dir.Length();
     if (closest_dist > enemy_weapon_dist) {
       closest_dist = enemy_weapon_dist;
       best_enemy = &e;
@@ -238,7 +238,7 @@ void Enemy::TakeDamage(EnemyUnit* target, int damage) {
   } else {
     target->targetted_by_weapon_ = kDamageType_Invalid;
 
-    Vector2 s = target->sprite.GetSize() * Vector2(0.6f, 0.01f);
+    Vector2f s = target->sprite.GetSize() * Vector2f(0.6f, 0.01f);
     s.x *= (float)target->hit_points / (float)target->total_health;
     float t = (s.x - target->health_bar.GetSize().x) / 2;
     target->health_bar.SetSize(s);
@@ -279,14 +279,14 @@ void Enemy::SpawnNextEnemy() {
                                ? kDamageType_Any
                                : (DamageType)(rnd.Roll(2) - 1);
 
-  Vector2 s = engine.GetScreenSize();
+  Vector2f s = engine.GetScreenSize();
   int col;
   col = rnd.Roll(4) - 1;
   if (col == last_spawn_col_)
     col = (col + 1) % 4;
   last_spawn_col_ = col;
   float x = (s.x / 4) / 2 + (s.x / 4) * col - s.x / 2;
-  Vector2 pos = {x, s.y / 2};
+  Vector2f pos = {x, s.y / 2};
   float speed =
       enemy_type == kEnemyType_Tank ? 36.0f : (rnd.Roll(4) == 4 ? 6.0f : 10.0f);
 
@@ -295,7 +295,7 @@ void Enemy::SpawnNextEnemy() {
 
 void Enemy::Spawn(EnemyType enemy_type,
                   DamageType damage_type,
-                  const Vector2& pos,
+                  const Vector2f& pos,
                   float speed) {
   DCHECK(enemy_type > kEnemyType_Invalid && enemy_type < kEnemyType_Max);
   DCHECK(damage_type > kDamageType_Invalid && damage_type < kDamageType_Max);
@@ -318,7 +318,7 @@ void Enemy::Spawn(EnemyType enemy_type,
   }
   e.sprite.SetZOrder(11);
   e.sprite.SetVisible(true);
-  Vector2 spawn_pos = pos + Vector2(0, e.sprite.GetSize().y / 2);
+  Vector2f spawn_pos = pos + Vector2f(0, e.sprite.GetSize().y / 2);
   e.sprite.SetPosition(spawn_pos);
 
   e.sprite.SetFrame(enemy_frame_start[enemy_type][damage_type]);
@@ -337,13 +337,13 @@ void Enemy::Spawn(EnemyType enemy_type,
   e.blast.SetPosition(spawn_pos);
 
   e.health_base.SetZOrder(11);
-  e.health_base.SetSize(e.sprite.GetSize() * Vector2(0.6f, 0.01f));
+  e.health_base.SetSize(e.sprite.GetSize() * Vector2f(0.6f, 0.01f));
   e.health_base.SetPosition(spawn_pos);
   e.health_base.PlaceToBottomOf(e.sprite);
   e.health_base.SetColor({0.5f, 0.5f, 0.5f, 1});
 
   e.health_bar.SetZOrder(11);
-  e.health_bar.SetSize(e.sprite.GetSize() * Vector2(0.6f, 0.01f));
+  e.health_bar.SetSize(e.sprite.GetSize() * Vector2f(0.6f, 0.01f));
   e.health_bar.SetPosition(spawn_pos);
   e.health_bar.PlaceToBottomOf(e.sprite);
   e.health_bar.SetColor({0.161f, 0.89f, 0.322f, 1});

src/demo/enemy.h

@@ -29,11 +29,11 @@ class Enemy {
   void Pause(bool pause);
 
   bool HasTarget(DamageType damage_type);
-  base::Vector2 GetTargetPos(DamageType damage_type);
+  base::Vector2f GetTargetPos(DamageType damage_type);
 
   void SelectTarget(DamageType damage_type,
-                    const base::Vector2& origin,
+                    const base::Vector2f& origin,
-                    const base::Vector2& dir,
+                    const base::Vector2f& dir,
                     float snap_factor);
   void DeselectTarget(DamageType damage_type);
 
@@ -97,7 +97,7 @@ class Enemy {
 
   void Spawn(EnemyType enemy_type,
              DamageType damage_type,
-             const base::Vector2& pos,
+             const base::Vector2f& pos,
              float speed);
 
   EnemyUnit* GetTarget(DamageType damage_type);

src/demo/hud.cc

@@ -18,9 +18,9 @@ namespace {
 constexpr float kHorizontalMargin = 0.07f;
 constexpr float kVerticalMargin = 0.025f;
 
-const Vector4 kPprogressBarColor[2] = {{0.256f, 0.434f, 0.72f, 1},
+const Vector4f kPprogressBarColor[2] = {{0.256f, 0.434f, 0.72f, 1},
                                         {0.905f, 0.493f, 0.194f, 1}};
-const Vector4 kTextColor = {0.895f, 0.692f, 0.24f, 1};
+const Vector4f kTextColor = {0.895f, 0.692f, 0.24f, 1};
 
 }  // namespace
 
@@ -42,22 +42,23 @@ bool Hud::Initialize() {
   for (int i = 0; i < 2; ++i) {
     text_[i].Create("text"s + std::to_string(i));
     text_[i].SetZOrder(30);
-    text_[i].SetColor(kTextColor * Vector4(1, 1, 1, 0));
+    text_[i].SetColor(kTextColor * Vector4f(1, 1, 1, 0));
 
-    Vector2 pos = (engine.GetScreenSize() / 2 - text_[i].GetSize() / 2);
+    Vector2f pos = (engine.GetScreenSize() / 2 - text_[i].GetSize() / 2);
-    pos -= engine.GetScreenSize() * Vector2(kHorizontalMargin, kVerticalMargin);
+    pos -=
+        engine.GetScreenSize() * Vector2f(kHorizontalMargin, kVerticalMargin);
 
-    Vector2 scale = engine.GetScreenSize() * Vector2(1, 0);
+    Vector2f scale = engine.GetScreenSize() * Vector2f(1, 0);
-    scale -= engine.GetScreenSize() * Vector2(kHorizontalMargin * 4, 0);
+    scale -= engine.GetScreenSize() * Vector2f(kHorizontalMargin * 4, 0);
-    scale += text_[0].GetSize() * Vector2(0, 0.3f);
+    scale += text_[0].GetSize() * Vector2f(0, 0.3f);
 
     progress_bar_[i].SetZOrder(30);
     progress_bar_[i].SetSize(scale);
-    progress_bar_[i].Translate(pos * Vector2(0, 1));
+    progress_bar_[i].Translate(pos * Vector2f(0, 1));
-    progress_bar_[i].SetColor(kPprogressBarColor[i] * Vector4(1, 1, 1, 0));
+    progress_bar_[i].SetColor(kPprogressBarColor[i] * Vector4f(1, 1, 1, 0));
 
-    pos -= progress_bar_[i].GetSize() * Vector2(0, 4);
+    pos -= progress_bar_[i].GetSize() * Vector2f(0, 4);
-    text_[i].Translate(pos * Vector2(i ? 1 : -1, 1));
+    text_[i].Translate(pos * Vector2f(i ? 1 : -1, 1));
 
     progress_bar_animator_[i].Attach(&progress_bar_[i]);
 
@@ -111,7 +112,7 @@ void Hud::SetWave(int wave, bool flash) {
 void Hud::SetProgress(float progress) {
   progress = std::min(std::max(0.0f, progress), 1.0f);
   last_progress_ = progress;
-  Vector2 s = progress_bar_[0].GetSize() * Vector2(progress, 1);
+  Vector2f s = progress_bar_[0].GetSize() * Vector2f(progress, 1);
   float t = (s.x - progress_bar_[1].GetSize().x) / 2;
   progress_bar_[1].SetSize(s);
   progress_bar_[1].Translate({t, 0});

src/demo/menu.cc

@@ -22,11 +22,11 @@ constexpr char kMenuOption[Menu::kOption_Max][10] = {"continue", "start",
 
 constexpr float kMenuOptionSpace = 1.5f;
 
-const Vector4 kColorNormal = {1, 1, 1, 1};
+const Vector4f kColorNormal = {1, 1, 1, 1};
-const Vector4 kColorHighlight = {5, 5, 5, 1};
+const Vector4f kColorHighlight = {5, 5, 5, 1};
 constexpr float kBlendingSpeed = 0.12f;
 
-const Vector4 kColorFadeOut = {1, 1, 1, 0};
+const Vector4f kColorFadeOut = {1, 1, 1, 0};
 constexpr float kFadeSpeed = 0.2f;
 
 }  // namespace
@@ -76,10 +76,12 @@ bool Menu::Initialize() {
 }
 
 void Menu::OnInputEvent(std::unique_ptr<InputEvent> event) {
-  if (event->GetType() == InputEvent::kDragStart)
+  if (event->GetType() == InputEvent::kDragStart) {
-    tap_pos_[0] = tap_pos_[1] = event->GetVector();
+    tap_pos_[0] = event->GetVector();
-  else if (event->GetType() == InputEvent::kDrag)
     tap_pos_[1] = event->GetVector();
+  } else if (event->GetType() == InputEvent::kDrag) {
+    tap_pos_[1] = event->GetVector();
+  }
 
   if (event->GetType() != InputEvent::kDragEnd || IsAnimating())
     return;
@@ -88,10 +90,12 @@ void Menu::OnInputEvent(std::unique_ptr<InputEvent> event) {
     if (items_[i].hide)
       continue;
     if (!Intersection(items_[i].text.GetPosition(),
-                      items_[i].text.GetSize() * Vector2(1.2f, 2), tap_pos_[0]))
+                      items_[i].text.GetSize() * Vector2f(1.2f, 2),
+                      tap_pos_[0]))
       continue;
     if (!Intersection(items_[i].text.GetPosition(),
-                      items_[i].text.GetSize() * Vector2(1.2f, 2), tap_pos_[1]))
+                      items_[i].text.GetSize() * Vector2f(1.2f, 2),
+                      tap_pos_[1]))
       continue;
 
     items_[i].text_animator.SetEndCallback(Animator::kBlending,
@@ -111,7 +115,7 @@ void Menu::SetOptionEnabled(Option o, bool enable) {
       if (last >= 0) {
         items_[i].text.PlaceToBottomOf(items_[last].text);
         items_[i].text.Translate(items_[last].text.GetPosition() *
-                                 Vector2(0, 1));
+                                 Vector2f(0, 1));
         items_[i].text.Translate(
             {0, items_[last].text.GetSize().y * -kMenuOptionSpace});
       }

src/demo/menu.h

@@ -53,7 +53,7 @@ class Menu {
 
   Option selected_option_ = kOption_Invalid;
 
-  base::Vector2 tap_pos_[2] = {{0, 0}, {0, 0}};
+  base::Vector2f tap_pos_[2] = {{0, 0}, {0, 0}};
 
   bool CreateRenderResources();
 

src/demo/player.cc

@@ -57,21 +57,21 @@ void Player::OnInputEvent(std::unique_ptr<InputEvent> event) {
     DragCancel();
 }
 
-Vector2 Player::GetWeaponPos(DamageType type) const {
+Vector2f Player::GetWeaponPos(DamageType type) const {
   return Engine::Get().GetScreenSize() /
-             Vector2(type == kDamageType_Green ? 3.5f : -3.5f, -2) +
+             Vector2f(type == kDamageType_Green ? 3.5f : -3.5f, -2) +
-         Vector2(0, weapon_[type].GetSize().y * 0.7f);
+         Vector2f(0, weapon_[type].GetSize().y * 0.7f);
 }
 
-Vector2 Player::GetWeaponScale() const {
+Vector2f Player::GetWeaponScale() const {
   return weapon_[0].GetSize();
 }
 
-DamageType Player::GetWeaponType(const Vector2& pos) {
+DamageType Player::GetWeaponType(const Vector2f& pos) {
   DamageType closest_weapon = kDamageType_Invalid;
   float closest_dist = std::numeric_limits<float>::max();
   for (int i = 0; i < 2; ++i) {
-    float dist = (pos - weapon_[i].GetPosition()).Magnitude();
+    float dist = (pos - weapon_[i].GetPosition()).Length();
     if (dist < closest_dist) {
       closest_dist = dist;
       closest_weapon = (DamageType)i;
@@ -94,7 +94,7 @@ void Player::CooldownWeapon(DamageType type) {
   cooldown_animator_[type].Play(Animator::kFrames, false);
 }
 
-void Player::Fire(DamageType type, Vector2 dir) {
+void Player::Fire(DamageType type, Vector2f dir) {
   Engine& engine = Engine::Get();
   Enemy& enemy = static_cast<Demo*>(engine.GetGame())->GetEnemy();
 
@@ -103,12 +103,12 @@ void Player::Fire(DamageType type, Vector2 dir) {
   else
     dir *= engine.GetScreenSize().y * 1.3f;
 
-  float len = dir.Magnitude();
+  float len = dir.Length();
   beam_[type].SetSize({len, beam_[type].GetSize().y});
   beam_[type].SetPosition(weapon_[type].GetPosition());
 
   dir.Normalize();
-  float cos_theta = dir.DotProduct(Vector2(1, 0));
+  float cos_theta = dir.DotProduct(Vector2f(1, 0));
   float theta = acos(cos_theta) + M_PI;
   beam_[type].SetTheta(theta);
   auto offset = beam_[type].GetRotation() * (len / 2);
@@ -120,7 +120,7 @@ void Player::Fire(DamageType type, Vector2 dir) {
 
   spark_animator_[type].Stop(Animator::kMovement);
   float length = beam_[type].GetSize().x * 0.9f;
-  Vector2 movement = dir * -length;
+  Vector2f movement = dir * -length;
   // Convert from units per second to duration.
   float speed = 1.0f / (18.0f / length);
   spark_animator_[type].SetMovement(movement, speed);
@@ -139,7 +139,7 @@ void Player::SetupWeapons() {
     drag_sign_[i].SetZOrder(21);
     drag_sign_[i].SetFrame(i * 8);
 
-    Vector2 pos = GetWeaponPos((DamageType)i);
+    Vector2f pos = GetWeaponPos((DamageType)i);
 
     // Setup weapon.
     weapon_[i].Create("weapon_tex", {8, 2});
@@ -153,7 +153,7 @@ void Player::SetupWeapons() {
     beam_[i].SetZOrder(22);
     beam_[i].SetFrame(i);
     beam_[i].SetPosition(pos);
-    beam_[i].Translate(beam_[i].GetSize() * Vector2(-0.5f, -0.5f));
+    beam_[i].Translate(beam_[i].GetSize() * Vector2f(-0.5f, -0.5f));
 
     // Setup beam spark.
     beam_spark_[i].Create("weapon_tex", {8, 2});
@@ -200,7 +200,7 @@ void Player::UpdateTarget() {
   Demo* game = static_cast<Demo*>(engine.GetGame());
 
   if (drag_valid_) {
-    Vector2 dir = (drag_end_ - drag_start_).Normalize();
+    Vector2f dir = (drag_end_ - drag_start_).Normalize();
     game->GetEnemy().SelectTarget(active_weapon_, drag_start_, dir, 1.2f);
     if (!game->GetEnemy().HasTarget(active_weapon_))
       game->GetEnemy().SelectTarget(active_weapon_, drag_start_, dir, 2);
@@ -209,18 +209,19 @@ void Player::UpdateTarget() {
   }
 }
 
-void Player::DragStart(const Vector2& pos) {
+void Player::DragStart(const Vector2f& pos) {
   active_weapon_ = GetWeaponType(pos);
   if (active_weapon_ == kDamageType_Invalid)
     return;
 
-  drag_start_ = drag_end_ = pos;
+  drag_start_ = pos;
+  drag_end_ = pos;
 
   drag_sign_[active_weapon_].SetPosition(drag_start_);
   drag_sign_[active_weapon_].SetVisible(true);
 }
 
-void Player::Drag(const Vector2& pos) {
+void Player::Drag(const Vector2f& pos) {
   if (active_weapon_ == kDamageType_Invalid)
     return;
 
@@ -248,7 +249,7 @@ void Player::DragEnd() {
   active_weapon_ = kDamageType_Invalid;
   drag_sign_[type].SetVisible(false);
 
-  Vector2 fire_dir = (drag_start_ - drag_end_).Normalize();
+  Vector2f fire_dir = (drag_start_ - drag_end_).Normalize();
 
   if (drag_valid_ && !IsFiring(type)) {
     if (warmup_animator_[type].IsPlaying(Animator::kFrames)) {
@@ -265,7 +266,8 @@ void Player::DragEnd() {
   }
 
   drag_valid_ = false;
-  drag_start_ = drag_end_ = {0, 0};
+  drag_start_ = {0, 0};
+  drag_end_ = {0, 0};
 }
 
 void Player::DragCancel() {
@@ -289,16 +291,17 @@ void Player::DragCancel() {
   }
 
   drag_valid_ = false;
-  drag_start_ = drag_end_ = {0, 0};
+  drag_start_ = {0, 0};
+  drag_end_ = {0, 0};
 }
 
 bool Player::ValidateDrag() {
-  Vector2 dir = drag_end_ - drag_start_;
+  Vector2f dir = drag_end_ - drag_start_;
-  float len = dir.Magnitude();
+  float len = dir.Length();
   dir.Normalize();
   if (len < weapon_[active_weapon_].GetSize().y / 4)
     return false;
-  if (dir.DotProduct(Vector2(0, 1)) < 0)
+  if (dir.DotProduct(Vector2f(0, 1)) < 0)
     return false;
   return true;
 }

src/demo/player.h

@@ -25,8 +25,8 @@ class Player {
 
   void OnInputEvent(std::unique_ptr<eng::InputEvent> event);
 
-  base::Vector2 GetWeaponPos(DamageType type) const;
+  base::Vector2f GetWeaponPos(DamageType type) const;
-  base::Vector2 GetWeaponScale() const;
+  base::Vector2f GetWeaponScale() const;
 
  private:
   eng::ImageQuad drag_sign_[2];
@@ -41,24 +41,24 @@ class Player {
 
   DamageType active_weapon_ = kDamageType_Invalid;
 
-  base::Vector2 drag_start_ = {0, 0};
+  base::Vector2f drag_start_ = {0, 0};
-  base::Vector2 drag_end_ = {0, 0};
+  base::Vector2f drag_end_ = {0, 0};
   bool drag_valid_ = false;
 
-  DamageType GetWeaponType(const base::Vector2& pos);
+  DamageType GetWeaponType(const base::Vector2f& pos);
 
   void WarmupWeapon(DamageType type);
   void CooldownWeapon(DamageType type);
 
-  void Fire(DamageType type, base::Vector2 dir);
+  void Fire(DamageType type, base::Vector2f dir);
   bool IsFiring(DamageType type);
 
   void SetupWeapons();
 
   void UpdateTarget();
 
-  void DragStart(const base::Vector2& pos);
+  void DragStart(const base::Vector2f& pos);
-  void Drag(const base::Vector2& pos);
+  void Drag(const base::Vector2f& pos);
   void DragEnd();
   void DragCancel();
   bool ValidateDrag();

src/demo/sky_quad.cc

@@ -44,7 +44,7 @@ void SkyQuad::Update(float delta_time) {
 }
 
 void SkyQuad::Draw(float frame_frac) {
-  Vector2 sky_offset = Lerp(last_sky_offset_, sky_offset_, frame_frac);
+  Vector2f sky_offset = Lerp(last_sky_offset_, sky_offset_, frame_frac);
 
   shader_->Activate();
   shader_->SetUniform("scale", scale_);
@@ -61,7 +61,7 @@ void SkyQuad::ContextLost() {
   Create();
 }
 
-void SkyQuad::SwitchColor(const Vector4& color) {
+void SkyQuad::SwitchColor(const Vector4f& color) {
   color_animator_.SetBlending(color, 5,
                               std::bind(SmoothStep, std::placeholders::_1));
   color_animator_.Play(Animator::kBlending, false);

src/demo/sky_quad.h

@@ -30,25 +30,25 @@ class SkyQuad : public eng::Animatable {
   void SetFrame(size_t frame) override {}
   size_t GetFrame() const override { return 0; }
   size_t GetNumFrames() const override { return 0; }
-  void SetColor(const base::Vector4& color) override { nebula_color_ = color; }
+  void SetColor(const base::Vector4f& color) override { nebula_color_ = color; }
-  base::Vector4 GetColor() const override { return nebula_color_; }
+  base::Vector4f GetColor() const override { return nebula_color_; }
 
   // Drawable interface.
   void Draw(float frame_frac) override;
 
   void ContextLost();
 
-  void SwitchColor(const base::Vector4& color);
+  void SwitchColor(const base::Vector4f& color);
 
   void SetSpeed(float speed);
 
  private:
   std::unique_ptr<eng::Shader> shader_;
 
-  base::Vector2 sky_offset_ = {0, 0};
+  base::Vector2f sky_offset_ = {0, 0};
-  base::Vector2 last_sky_offset_ = {0, 0};
+  base::Vector2f last_sky_offset_ = {0, 0};
-  base::Vector4 nebula_color_ = {0, 0, 0, 1};
+  base::Vector4f nebula_color_ = {0, 0, 0, 1};
-  base::Vector2 scale_ = {1, 1};
+  base::Vector2f scale_ = {1, 1};
 
   eng::Animator color_animator_;
 

src/engine/animatable.cc

@@ -6,11 +6,11 @@ using namespace base;
 
 namespace eng {
 
-void Animatable::Translate(const Vector2& pos) {
+void Animatable::Translate(const Vector2f& pos) {
   position_ += pos;
 }
 
-void Animatable::Scale(const Vector2& scale) {
+void Animatable::Scale(const Vector2f& scale) {
   scale_ = scale;
 }
 

src/engine/animatable.h

@@ -11,27 +11,27 @@ class Animatable : public Drawable {
   Animatable() = default;
   ~Animatable() override = default;
 
-  void Translate(const base::Vector2& pos);
+  void Translate(const base::Vector2f& pos);
-  void Scale(const base::Vector2& scale);
+  void Scale(const base::Vector2f& scale);
   void Scale(float scale);
   void Rotate(float angle);
 
-  void SetPosition(const base::Vector2& pos) { position_ = pos; }
+  void SetPosition(const base::Vector2f& pos) { position_ = pos; }
-  void SetSize(const base::Vector2& size) { size_ = size; }
+  void SetSize(const base::Vector2f& size) { size_ = size; }
   void SetTheta(float theta);
 
-  base::Vector2 GetPosition() const { return position_; }
+  base::Vector2f GetPosition() const { return position_; }
-  base::Vector2 GetSize() const { return size_ * scale_; }
+  base::Vector2f GetSize() const { return size_ * scale_; }
   float GetTheta() const { return theta_; }
-  base::Vector2 GetRotation() const { return rotation_; }
+  base::Vector2f GetRotation() const { return rotation_; }
 
   // Pure virtuals for frame animation support.
   virtual void SetFrame(size_t frame) = 0;
   virtual size_t GetFrame() const = 0;
   virtual size_t GetNumFrames() const = 0;
 
-  virtual void SetColor(const base::Vector4& color) = 0;
+  virtual void SetColor(const base::Vector4f& color) = 0;
-  virtual base::Vector4 GetColor() const = 0;
+  virtual base::Vector4f GetColor() const = 0;
 
   void PlaceToLeftOf(const Animatable& s) {
     Translate({s.GetSize().x / -2.0f + GetSize().x / -2.0f, 0});
@@ -50,10 +50,10 @@ class Animatable : public Drawable {
   }
 
  protected:
-  base::Vector2 position_ = {0, 0};
+  base::Vector2f position_ = {0, 0};
-  base::Vector2 size_ = {1, 1};
+  base::Vector2f size_ = {1, 1};
-  base::Vector2 scale_ = {1, 1};
+  base::Vector2f scale_ = {1, 1};
-  base::Vector2 rotation_ = {0, 1};
+  base::Vector2f rotation_ = {0, 1};
   float theta_ = 0;
 };
 

src/engine/animator.cc

@@ -116,7 +116,7 @@ void Animator::SetEndCallback(int animation, base::Closure cb) {
     timer_cb_ = std::move(cb);
 }
 
-void Animator::SetMovement(Vector2 direction,
+void Animator::SetMovement(Vector2f direction,
                            float duration,
                            Interpolator interpolator) {
   movement_direction_ = direction;
@@ -138,7 +138,7 @@ void Animator::SetRotation(float trget,
     a.rotation_last_theta = 0;
 }
 
-void Animator::SetBlending(Vector4 target,
+void Animator::SetBlending(Vector4f target,
                            float duration,
                            Interpolator interpolator) {
   blending_target_ = target;
@@ -186,7 +186,7 @@ void Animator::EvalAnim(float frame_time) {
       float time = movement_time_ + movement_speed_ * frame_time;
       float interpolated_time =
           movement_interpolator_ ? movement_interpolator_(time) : time;
-      Vector2 pos = base::Lerp({0, 0}, movement_direction_, interpolated_time);
+      Vector2f pos = base::Lerp({0, 0}, movement_direction_, interpolated_time);
       a.animatable->Translate(pos - a.movement_last_pos);
       a.movement_last_pos = pos;
     }
@@ -204,7 +204,7 @@ void Animator::EvalAnim(float frame_time) {
       float time = blending_time_ + blending_speed_ * frame_time;
       float interpolated_time =
           blending_interpolator_ ? blending_interpolator_(time) : time;
-      Vector4 r =
+      Vector4f r =
           base::Lerp(a.blending_start, blending_target_, interpolated_time);
       a.animatable->SetColor(r);
     }

src/engine/animator.h

@@ -44,7 +44,7 @@ class Animator {
   void SetEndCallback(int animation, base::Closure cb);
 
   // Distance is the magnitude of direction vector. Duration is in seconds.
-  void SetMovement(base::Vector2 direction,
+  void SetMovement(base::Vector2f direction,
                    float duration,
                    Interpolator interpolator = nullptr);
 
@@ -53,7 +53,7 @@ class Animator {
                    float duration,
                    Interpolator interpolator = nullptr);
 
-  void SetBlending(base::Vector4 target,
+  void SetBlending(base::Vector4f target,
                    float duration,
                    Interpolator interpolator = nullptr);
 
@@ -76,9 +76,9 @@ class Animator {
  private:
   struct Element {
     Animatable* animatable;
-    base::Vector2 movement_last_pos = {0, 0};
+    base::Vector2f movement_last_pos = {0, 0};
     float rotation_last_theta = 0;
-    base::Vector4 blending_start = {0, 0, 0, 0};
+    base::Vector4f blending_start = {0, 0, 0, 0};
     int frame_start_ = 0;
   };
 
@@ -87,7 +87,7 @@ class Animator {
   unsigned int resume_flags_ = 0;
   std::vector<Element> elements_;
 
-  base::Vector2 movement_direction_ = {0, 0};
+  base::Vector2f movement_direction_ = {0, 0};
   float movement_speed_ = 0;
   float movement_time_ = 0;
   Interpolator movement_interpolator_;
@@ -99,7 +99,7 @@ class Animator {
   Interpolator rotation_interpolator_;
   base::Closure rotation_cb_;
 
-  base::Vector4 blending_target_ = {0, 0, 0, 0};
+  base::Vector4f blending_target_ = {0, 0, 0, 0};
   float blending_speed_ = 0;
   float blending_time_ = 0;
   Interpolator blending_interpolator_;

src/engine/engine.cc

@@ -53,18 +53,17 @@ Engine& Engine::Get() {
 }
 
 bool Engine::Initialize() {
-  // The orthogonal viewport is (-1.0 .. 1.0) for the short edge of the screen.
+  // Normalize viewport.
-  // For the long endge, it's calculated from aspect ratio.
   if (GetScreenWidth() > GetScreenHeight()) {
     float aspect_ratio = (float)GetScreenWidth() / (float)GetScreenHeight();
     LOG << "aspect ratio: " << aspect_ratio;
     screen_size_ = {aspect_ratio * 2.0f, 2.0f};
-    projection_ = base::Ortho(-aspect_ratio, aspect_ratio, -1.0f, 1.0f);
+    projection_.CreateOrthoProjection(-aspect_ratio, aspect_ratio, -1.0f, 1.0f);
   } else {
     float aspect_ratio = (float)GetScreenHeight() / (float)GetScreenWidth();
     LOG << "aspect_ratio: " << aspect_ratio;
     screen_size_ = {2.0f, aspect_ratio * 2.0f};
-    projection_ = base::Ortho(-1.0, 1.0, -aspect_ratio, aspect_ratio);
+    projection_.CreateOrthoProjection(-1.0, 1.0, -aspect_ratio, aspect_ratio);
   }
 
   LOG << "image scale factor: " << GetImageScaleFactor();
@@ -202,12 +201,12 @@ void Engine::Exit() {
   platform_->Exit();
 }
 
-Vector2 Engine::ToScale(const Vector2& vec) {
+Vector2f Engine::ToScale(const Vector2f& vec) {
   return GetScreenSize() * vec /
-         Vector2((float)GetScreenWidth(), (float)GetScreenHeight());
+         Vector2f((float)GetScreenWidth(), (float)GetScreenHeight());
 }
 
-Vector2 Engine::ToPosition(const Vector2& vec) {
+Vector2f Engine::ToPosition(const Vector2f& vec) {
   return ToScale(vec) - GetScreenSize() / 2.0f;
 }
 
@@ -285,7 +284,7 @@ void Engine::AddInputEvent(std::unique_ptr<InputEvent> event) {
 
   switch (event->GetType()) {
     case InputEvent::kDragEnd:
-      if (((GetScreenSize() / 2) * 0.9f - event->GetVector()).Magnitude() <=
+      if (((GetScreenSize() / 2) * 0.9f - event->GetVector()).Length() <=
           0.25f) {
         SetSatsVisible(!stats_->IsVisible());
         // TODO: Enqueue DragCancel so we can consume this event.
@@ -300,7 +299,7 @@ void Engine::AddInputEvent(std::unique_ptr<InputEvent> event) {
       break;
     case InputEvent::kDrag:
       if (stats_->IsVisible()) {
-        if ((stats_->GetPosition() - event->GetVector()).Magnitude() <=
+        if ((stats_->GetPosition() - event->GetVector()).Length() <=
             stats_->GetSize().y)
           stats_->SetPosition(event->GetVector());
         // TODO: Enqueue DragCancel so we can consume this event.
@@ -323,7 +322,7 @@ std::unique_ptr<InputEvent> Engine::GetNextInputEvent() {
         event = std::make_unique<InputEvent>(
             (InputEvent::Type)data["input_type"].asInt(),
             (size_t)data["pointer_id"].asUInt(),
-            Vector2(data["pos_x"].asFloat(), data["pos_y"].asFloat()));
+            Vector2f(data["pos_x"].asFloat(), data["pos_y"].asFloat()));
         ++replay_index_;
       }
       return event;

src/engine/engine.h

@@ -59,10 +59,10 @@ class Engine {
   void Exit();
 
   // Convert size from pixels to viewport scale.
-  base::Vector2 ToScale(const base::Vector2& vec);
+  base::Vector2f ToScale(const base::Vector2f& vec);
 
   // Convert position form pixels to viewport coordinates.
-  base::Vector2 ToPosition(const base::Vector2& vec);
+  base::Vector2f ToPosition(const base::Vector2f& vec);
 
   template <typename T>
   std::unique_ptr<T> CreateRenderResource() {
@@ -126,9 +126,9 @@ class Engine {
   int GetScreenHeight() const;
 
   // Return screen size in viewport scale.
-  base::Vector2 GetScreenSize() const { return screen_size_; }
+  base::Vector2f GetScreenSize() const { return screen_size_; }
 
-  const base::Matrix4x4& GetProjectionMatrix() const { return projection_; }
+  const base::Matrix4f& GetProjectionMatrix() const { return projection_; }
 
   int GetDeviceDpi() const;
 
@@ -175,8 +175,8 @@ class Engine {
   std::unique_ptr<Shader> pass_through_shader_;
   std::unique_ptr<Shader> solid_shader_;
 
-  base::Vector2 screen_size_ = {0, 0};
+  base::Vector2f screen_size_ = {0, 0};
-  base::Matrix4x4 projection_;
+  base::Matrix4f projection_;
 
   std::unique_ptr<Font> system_font_;
 

src/engine/image.cc

@@ -312,7 +312,7 @@ uint8_t* Image::GetBuffer() {
   return buffer_.get();
 }
 
-void Image::Clear(Vector4 rgba) {
+void Image::Clear(Vector4f rgba) {
   // Quantize the color to target resolution.
   uint8_t r = (uint8_t)(rgba.x * 255.0f), g = (uint8_t)(rgba.y * 255.0f),
           b = (uint8_t)(rgba.z * 255.0f), a = (uint8_t)(rgba.w * 255.0f);
@@ -345,10 +345,10 @@ void Image::GradientH() {
     memcpy(buffer_.get() + h * width_ * 4, buffer_.get(), width_ * 4);
 }
 
-void Image::GradientV(const Vector4& c1, const Vector4& c2, int height) {
+void Image::GradientV(const Vector4f& c1, const Vector4f& c2, int height) {
   // Fill each section with gradient.
   for (int h = 0; h < height_; ++h) {
-    Vector4 c = Lerp(c1, c2, fmod(h, height) / (float)height);
+    Vector4f c = Lerp(c1, c2, fmod(h, height) / (float)height);
     for (int x = 0; x < width_; ++x) {
       buffer_.get()[h * width_ * 4 + x * 4 + 0] = c.x * 255;
       buffer_.get()[h * width_ * 4 + x * 4 + 1] = c.y * 255;

src/engine/image.h

@@ -41,9 +41,11 @@ class Image {
 
   bool IsValid() const { return !!buffer_; }
 
-  void Clear(base::Vector4 rgba);
+  void Clear(base::Vector4f rgba);
   void GradientH();
-  void GradientV(const base::Vector4& c1, const base::Vector4& c2, int height);
+  void GradientV(const base::Vector4f& c1,
+                 const base::Vector4f& c2,
+                 int height);
 
  private:
   base::AlignedMemPtr<uint8_t[]> buffer_;

src/engine/image_quad.cc

@@ -32,8 +32,8 @@ void ImageQuad::Destory() {
 
 void ImageQuad::AutoScale() {
   auto& engine = Engine::Get();
-  Vector2 dimensions = {GetFrameWidth(), GetFrameHeight()};
+  Vector2f dimensions = {GetFrameWidth(), GetFrameHeight()};
-  Vector2 size = engine.ToScale(dimensions);
+  Vector2f size = engine.ToScale(dimensions);
   float s =
       static_cast<float>(engine.image_dpi()) * engine.GetImageScaleFactor();
   size *= static_cast<float>(engine.GetDeviceDpi()) / s;
@@ -63,7 +63,7 @@ void ImageQuad::Draw(float frame_frac) {
 
   texture_->Activate();
 
-  Vector2 tex_scale = {GetFrameWidth() / texture_->GetWidth(),
+  Vector2f tex_scale = {GetFrameWidth() / texture_->GetWidth(),
                         GetFrameHeight() / texture_->GetHeight()};
 
   Shader* shader = custom_shader_ ? custom_shader_.get()
@@ -100,7 +100,7 @@ float ImageQuad::GetFrameHeight() const {
 }
 
 // Return the uv offset for the given frame.
-Vector2 ImageQuad::GetUVOffset(int frame) const {
+Vector2f ImageQuad::GetUVOffset(int frame) const {
   DCHECK(frame < GetNumFrames())
       << "asset: " << asset_name_ << " frame: " << frame;
   return {(float)(frame % num_frames_[0]), (float)(frame / num_frames_[0])};

src/engine/image_quad.h

@@ -40,17 +40,17 @@ class ImageQuad : public Animatable {
   void SetFrame(size_t frame) override;
   size_t GetFrame() const override { return current_frame_; }
   size_t GetNumFrames() const override;
-  void SetColor(const base::Vector4& color) override { color_ = color; }
+  void SetColor(const base::Vector4f& color) override { color_ = color; }
-  base::Vector4 GetColor() const override { return color_; }
+  base::Vector4f GetColor() const override { return color_; }
 
   // Drawable interface.
   void Draw(float frame_frac) override;
 
  private:
-  using UniformValue = std::variant<base::Vector2,
+  using UniformValue = std::variant<base::Vector2f,
-                                    base::Vector3,
+                                    base::Vector3f,
-                                    base::Vector4,
+                                    base::Vector4f,
-                                    base::Matrix4x4,
+                                    base::Matrix4f,
                                     float,
                                     int>;
 
@@ -64,14 +64,14 @@ class ImageQuad : public Animatable {
   int frame_width_ = 0;
   int frame_height_ = 0;
 
-  base::Vector4 color_ = {1, 1, 1, 1};
+  base::Vector4f color_ = {1, 1, 1, 1};
 
   std::string asset_name_;
 
   float GetFrameWidth() const;
   float GetFrameHeight() const;
 
-  base::Vector2 GetUVOffset(int frame) const;
+  base::Vector2f GetUVOffset(int frame) const;
 };
 
 }  // namespace eng

src/engine/input_event.h

@@ -21,7 +21,7 @@ class InputEvent {
 
   InputEvent(Type type, size_t pointer_id)
       : type_(type), pointer_id_(pointer_id) {}
-  InputEvent(Type type, size_t pointer_id, const base::Vector2& vec)
+  InputEvent(Type type, size_t pointer_id, const base::Vector2f& vec)
       : type_(type), pointer_id_(pointer_id), vec_(vec) {}
   InputEvent(Type type) : type_(type) {}
   InputEvent(Type type, char key) : type_(type), key_(key) {}
@@ -31,14 +31,14 @@ class InputEvent {
 
   size_t GetPointerId() const { return pointer_id_; }
 
-  base::Vector2 GetVector() const { return vec_; }
+  base::Vector2f GetVector() const { return vec_; }
 
   char GetKeyPress() const { return key_; }
 
  private:
   Type type_ = kInvalid;
   size_t pointer_id_ = 0;
-  base::Vector2 vec_ = {0, 0};
+  base::Vector2f vec_ = {0, 0};
   char key_ = 0;
 };
 

src/engine/platform/platform_android.cc

@@ -232,7 +232,7 @@ int32_t PlatformAndroid::HandleInput(android_app* app, AInputEvent* event) {
     uint32_t flags = action & AMOTION_EVENT_ACTION_MASK;
     int32_t count = AMotionEvent_getPointerCount(event);
     int32_t pointer_id = AMotionEvent_getPointerId(event, index);
-    Vector2 pos[2] = {platform->pointer_pos_[0], platform->pointer_pos_[1]};
+    Vector2f pos[2] = {platform->pointer_pos_[0], platform->pointer_pos_[1]};
     for (auto i = 0; i < count; ++i) {
       int32_t id = AMotionEvent_getPointerId(event, i);
       pos[id] = {AMotionEvent_getX(event, i), AMotionEvent_getY(event, i)};
@@ -252,7 +252,7 @@ int32_t PlatformAndroid::HandleInput(android_app* app, AInputEvent* event) {
         platform->pointer_down_[pointer_id] = true;
         input_event =
             std::make_unique<InputEvent>(InputEvent::kDragStart, pointer_id,
-                                         pos[pointer_id] * Vector2(1, -1));
+                                         pos[pointer_id] * Vector2f(1, -1));
         break;
 
       case AMOTION_EVENT_ACTION_UP:
@@ -260,20 +260,21 @@ int32_t PlatformAndroid::HandleInput(android_app* app, AInputEvent* event) {
         // DLOG << "AMOTION_EVENT_ACTION_UP -   pointer_id: " << pointer_id;
         platform->pointer_pos_[pointer_id] = pos[pointer_id];
         platform->pointer_down_[pointer_id] = false;
-        input_event = std::make_unique<InputEvent>(
+        input_event =
-            InputEvent::kDragEnd, pointer_id, pos[pointer_id] * Vector2(1, -1));
+            std::make_unique<InputEvent>(InputEvent::kDragEnd, pointer_id,
+                                         pos[pointer_id] * Vector2f(1, -1));
         break;
 
       case AMOTION_EVENT_ACTION_MOVE:
         if (platform->pointer_down_[0] && pos[0] != platform->pointer_pos_[0]) {
           platform->pointer_pos_[0] = pos[0];
           input_event = std::make_unique<InputEvent>(InputEvent::kDrag, 0,
-                                                     pos[0] * Vector2(1, -1));
+                                                     pos[0] * Vector2f(1, -1));
         }
         if (platform->pointer_down_[1] && pos[1] != platform->pointer_pos_[1]) {
           platform->pointer_pos_[1] = pos[1];
           input_event = std::make_unique<InputEvent>(InputEvent::kDrag, 1,
-                                                     pos[1] * Vector2(1, -1));
+                                                     pos[1] * Vector2f(1, -1));
         }
         break;
 

src/engine/platform/platform_android.h

@@ -31,7 +31,7 @@ class PlatformAndroid : public PlatformBase {
  private:
   android_app* app_ = nullptr;
 
-  base::Vector2 pointer_pos_[2] = {{0, 0}, {0, 0}};
+  base::Vector2f pointer_pos_[2] = {{0, 0}, {0, 0}};
   bool pointer_down_[2] = {false, false};
 
   static int32_t HandleInput(android_app* app, AInputEvent* event);

src/engine/platform/platform_linux.cc

@@ -66,32 +66,32 @@ void PlatformLinux::Update() {
         break;
       }
       case MotionNotify: {
-        Vector2 v(e.xmotion.x, e.xmotion.y);
+        Vector2f v(e.xmotion.x, e.xmotion.y);
         v = engine_->ToPosition(v);
         // DLOG << "drag: " << v;
         auto input_event = std::make_unique<InputEvent>(InputEvent::kDrag, 0,
-                                                        v * Vector2(1, -1));
+                                                        v * Vector2f(1, -1));
         engine_->AddInputEvent(std::move(input_event));
         break;
       }
       case ButtonPress: {
         if (e.xbutton.button == 1) {
-          Vector2 v(e.xbutton.x, e.xbutton.y);
+          Vector2f v(e.xbutton.x, e.xbutton.y);
           v = engine_->ToPosition(v);
           // DLOG << "drag-start: " << v;
           auto input_event = std::make_unique<InputEvent>(
-              InputEvent::kDragStart, 0, v * Vector2(1, -1));
+              InputEvent::kDragStart, 0, v * Vector2f(1, -1));
           engine_->AddInputEvent(std::move(input_event));
         }
         break;
       }
       case ButtonRelease: {
         if (e.xbutton.button == 1) {
-          Vector2 v(e.xbutton.x, e.xbutton.y);
+          Vector2f v(e.xbutton.x, e.xbutton.y);
           v = engine_->ToPosition(v);
           // DLOG << "drag-end!";
           auto input_event = std::make_unique<InputEvent>(
-              InputEvent::kDragEnd, 0, v * Vector2(1, -1));
+              InputEvent::kDragEnd, 0, v * Vector2f(1, -1));
           engine_->AddInputEvent(std::move(input_event));
         }
         break;

src/engine/renderer/opengl/render_command.h

@@ -92,25 +92,25 @@ RENDER_COMMAND_END
 
 RENDER_COMMAND_BEGIN(CmdSetUniformVec2)
   std::string name;
-  base::Vector2 v;
+  base::Vector2f v;
   std::shared_ptr<void> impl_data;
 RENDER_COMMAND_END
 
 RENDER_COMMAND_BEGIN(CmdSetUniformVec3)
   std::string name;
-  base::Vector3 v;
+  base::Vector3f v;
   std::shared_ptr<void> impl_data;
 RENDER_COMMAND_END
 
 RENDER_COMMAND_BEGIN(CmdSetUniformVec4)
   std::string name;
-  base::Vector4 v;
+  base::Vector4f v;
   std::shared_ptr<void> impl_data;
 RENDER_COMMAND_END
 
 RENDER_COMMAND_BEGIN(CmdSetUniformMat4)
   std::string name;
-  base::Matrix4x4 m;
+  base::Matrix4f m;
   std::shared_ptr<void> impl_data;
 RENDER_COMMAND_END
 

src/engine/renderer/opengl/renderer_opengl.cc

@@ -110,7 +110,7 @@ void RendererOpenGL::ActivateShader(std::shared_ptr<void> impl_data) {
 
 void RendererOpenGL::SetUniform(std::shared_ptr<void> impl_data,
                                 const std::string& name,
-                                const base::Vector2& val) {
+                                const base::Vector2f& val) {
   auto cmd = std::make_unique<CmdSetUniformVec2>();
   cmd->name = name;
   cmd->v = val;
@@ -120,7 +120,7 @@ void RendererOpenGL::SetUniform(std::shared_ptr<void> impl_data,
 
 void RendererOpenGL::SetUniform(std::shared_ptr<void> impl_data,
                                 const std::string& name,
-                                const base::Vector3& val) {
+                                const base::Vector3f& val) {
   auto cmd = std::make_unique<CmdSetUniformVec3>();
   cmd->name = name;
   cmd->v = val;
@@ -130,7 +130,7 @@ void RendererOpenGL::SetUniform(std::shared_ptr<void> impl_data,
 
 void RendererOpenGL::SetUniform(std::shared_ptr<void> impl_data,
                                 const std::string& name,
-                                const base::Vector4& val) {
+                                const base::Vector4f& val) {
   auto cmd = std::make_unique<CmdSetUniformVec4>();
   cmd->name = name;
   cmd->v = val;
@@ -140,7 +140,7 @@ void RendererOpenGL::SetUniform(std::shared_ptr<void> impl_data,
 
 void RendererOpenGL::SetUniform(std::shared_ptr<void> impl_data,
                                 const std::string& name,
-                                const base::Matrix4x4& val) {
+                                const base::Matrix4f& val) {
   auto cmd = std::make_unique<CmdSetUniformMat4>();
   cmd->name = name;
   cmd->m = val;

src/engine/renderer/opengl/renderer_opengl.h

@@ -69,16 +69,16 @@ class RendererOpenGL : public Renderer {
 
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
-                  const base::Vector2& val) override;
+                  const base::Vector2f& val) override;
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
-                  const base::Vector3& val) override;
+                  const base::Vector3f& val) override;
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
-                  const base::Vector4& val) override;
+                  const base::Vector4f& val) override;
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
-                  const base::Matrix4x4& val) override;
+                  const base::Matrix4f& val) override;
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
                   float val) override;

src/engine/renderer/renderer.h

@@ -59,16 +59,16 @@ class Renderer {
 
   virtual void SetUniform(std::shared_ptr<void> impl_data,
                           const std::string& name,
-                          const base::Vector2& val) = 0;
+                          const base::Vector2f& val) = 0;
   virtual void SetUniform(std::shared_ptr<void> impl_data,
                           const std::string& name,
-                          const base::Vector3& val) = 0;
+                          const base::Vector3f& val) = 0;
   virtual void SetUniform(std::shared_ptr<void> impl_data,
                           const std::string& name,
-                          const base::Vector4& val) = 0;
+                          const base::Vector4f& val) = 0;
   virtual void SetUniform(std::shared_ptr<void> impl_data,
                           const std::string& name,
-                          const base::Matrix4x4& val) = 0;
+                          const base::Matrix4f& val) = 0;
   virtual void SetUniform(std::shared_ptr<void> impl_data,
                           const std::string& name,
                           float val) = 0;

src/engine/renderer/shader.cc

@@ -36,22 +36,22 @@ void Shader::Activate() {
     renderer_->ActivateShader(impl_data_);
 }
 
-void Shader::SetUniform(const std::string& name, const Vector2& v) {
+void Shader::SetUniform(const std::string& name, const Vector2f& v) {
   if (valid_)
     renderer_->SetUniform(impl_data_, name, v);
 }
 
-void Shader::SetUniform(const std::string& name, const Vector3& v) {
+void Shader::SetUniform(const std::string& name, const Vector3f& v) {
   if (valid_)
     renderer_->SetUniform(impl_data_, name, v);
 }
 
-void Shader::SetUniform(const std::string& name, const Vector4& v) {
+void Shader::SetUniform(const std::string& name, const Vector4f& v) {
   if (valid_)
     renderer_->SetUniform(impl_data_, name, v);
 }
 
-void Shader::SetUniform(const std::string& name, const Matrix4x4& m) {
+void Shader::SetUniform(const std::string& name, const Matrix4f& m) {
   if (valid_)
     renderer_->SetUniform(impl_data_, name, m);
 }

src/engine/renderer/shader.h

@@ -28,10 +28,10 @@ class Shader : public RenderResource {
 
   void Activate();
 
-  void SetUniform(const std::string& name, const base::Vector2& v);
+  void SetUniform(const std::string& name, const base::Vector2f& v);
-  void SetUniform(const std::string& name, const base::Vector3& v);
+  void SetUniform(const std::string& name, const base::Vector3f& v);
-  void SetUniform(const std::string& name, const base::Vector4& v);
+  void SetUniform(const std::string& name, const base::Vector4f& v);
-  void SetUniform(const std::string& name, const base::Matrix4x4& m);
+  void SetUniform(const std::string& name, const base::Matrix4f& m);
   void SetUniform(const std::string& name, float f);
   void SetUniform(const std::string& name, int i);
 

src/engine/renderer/vulkan/renderer_vulkan.cc

@@ -597,28 +597,28 @@ void RendererVulkan::ActivateShader(std::shared_ptr<void> impl_data) {
 
 void RendererVulkan::SetUniform(std::shared_ptr<void> impl_data,
                                 const std::string& name,
-                                const base::Vector2& val) {
+                                const base::Vector2f& val) {
   auto shader = reinterpret_cast<ShaderVulkan*>(impl_data.get());
   SetUniformInternal(shader, name, val);
 }
 
 void RendererVulkan::SetUniform(std::shared_ptr<void> impl_data,
                                 const std::string& name,
-                                const base::Vector3& val) {
+                                const base::Vector3f& val) {
   auto shader = reinterpret_cast<ShaderVulkan*>(impl_data.get());
   SetUniformInternal(shader, name, val);
 }
 
 void RendererVulkan::SetUniform(std::shared_ptr<void> impl_data,
                                 const std::string& name,
-                                const base::Vector4& val) {
+                                const base::Vector4f& val) {
   auto shader = reinterpret_cast<ShaderVulkan*>(impl_data.get());
   SetUniformInternal(shader, name, val);
 }
 
 void RendererVulkan::SetUniform(std::shared_ptr<void> impl_data,
                                 const std::string& name,
-                                const base::Matrix4x4& val) {
+                                const base::Matrix4f& val) {
   auto shader = reinterpret_cast<ShaderVulkan*>(impl_data.get());
   SetUniformInternal(shader, name, val);
 }

src/engine/renderer/vulkan/renderer_vulkan.h

@@ -52,16 +52,16 @@ class RendererVulkan : public Renderer {
 
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
-                  const base::Vector2& val) override;
+                  const base::Vector2f& val) override;
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
-                  const base::Vector3& val) override;
+                  const base::Vector3f& val) override;
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
-                  const base::Vector4& val) override;
+                  const base::Vector4f& val) override;
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
-                  const base::Matrix4x4& val) override;
+                  const base::Matrix4f& val) override;
   void SetUniform(std::shared_ptr<void> impl_data,
                   const std::string& name,
                   float val) override;

src/engine/solid_quad.h

@@ -14,14 +14,14 @@ class SolidQuad : public Animatable {
   void SetFrame(size_t frame) override {}
   size_t GetFrame() const override { return 0; }
   size_t GetNumFrames() const override { return 0; }
-  void SetColor(const base::Vector4& color) override { color_ = color; }
+  void SetColor(const base::Vector4f& color) override { color_ = color; }
-  base::Vector4 GetColor() const override { return color_; }
+  base::Vector4f GetColor() const override { return color_; }
 
   // Drawable interface.
   void Draw(float frame_frac) override;
 
  private:
-  base::Vector4 color_ = {1, 1, 1, 1};
+  base::Vector4f color_ = {1, 1, 1, 1};
 };
 
 }  // namespace eng