ashikk
/
kaliber
mirror of https://github.com/auygun/kaliber.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

vecmath

This commit is contained in:
Attila Uygun 2021-02-18 15:42:08 +01:00
parent f332246ea9
commit 1ae44b6a76
41 changed files with 2020 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
build/android/app/CMakeLists.txt
View File

@ -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

1
build/linux/Makefile
View File

@ -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 \

1
src/base/BUILD.gn
View File

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

18
src/base/collusion_test.cc
View File

@ -6,9 +6,9 @@
namespace base {
bool Intersection(const Vector2& center,
const Vector2& size,
const Vector2& point) {
bool Intersection(const Vector2f& center,
const Vector2f& size,
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,
const Vector2& size,
const Vector2& origin,
const Vector2& dir) {
Vector2 min = center - size / 2;
Vector2 max = center + size / 2;
bool Intersection(const Vector2f& center,
const Vector2f& size,
const Vector2f& origin,
const Vector2f& dir) {
Vector2f min = center - size / 2;
Vector2f max = center + size / 2;
float tmin = std::numeric_limits<float>::min();
float tmax = std::numeric_limits<float>::max();

14
src/base/collusion_test.h
View File

@ -6,17 +6,17 @@
namespace base {
// AABB vs point.
bool Intersection(const Vector2& center,
const Vector2& size,
const Vector2& point);
bool Intersection(const Vector2f& center,
const Vector2f& size,
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,
const Vector2& size,
const Vector2& origin,
const Vector2& dir);
bool Intersection(const Vector2f& center,
const Vector2f& size,
const Vector2f& origin,
const Vector2f& dir);
} // namespace base

21
src/base/vecmath.cc
View File

@ -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

1911
src/base/vecmath.h
View File

File diff suppressed because it is too large Load Diff

8
src/demo/credits.cc
View File

@ -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);
}

6
src/demo/demo.cc
View File

@ -193,9 +193,9 @@ 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],
Lerp(0.75f, 0.95f, rnd.GetFloat()) * weights[1],
Lerp(0.75f, 0.95f, rnd.GetFloat()) * weights[2], 1};
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]),
Lerp(0.1f, 0.5f, rnd.GetFloat()) * (1 - weights[1]),
Lerp(0.1f, 0.5f, rnd.GetFloat()) * (1 - weights[2]), 1};

26
src/demo/enemy.cc
View File

@ -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 Vector2& dir,
const Vector2f& origin,
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;
float enemy_weapon_dist = weapon_enemy_dir.Magnitude();
Vector2f weapon_enemy_dir = e.sprite.GetPosition() - origin;
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});

8
src/demo/enemy.h
View File

@ -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::Vector2& dir,
const base::Vector2f& origin,
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);

29
src/demo/hud.cc
View File

@ -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},
{0.905f, 0.493f, 0.194f, 1}};
const Vector4 kTextColor = {0.895f, 0.692f, 0.24f, 1};
const Vector4f kPprogressBarColor[2] = {{0.256f, 0.434f, 0.72f, 1},
{0.905f, 0.493f, 0.194f, 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);
pos -= engine.GetScreenSize() * Vector2(kHorizontalMargin, kVerticalMargin);
Vector2f pos = (engine.GetScreenSize() / 2 - text_[i].GetSize() / 2);
pos -=
engine.GetScreenSize() * Vector2f(kHorizontalMargin, kVerticalMargin);
Vector2 scale = engine.GetScreenSize() * Vector2(1, 0);
scale -= engine.GetScreenSize() * Vector2(kHorizontalMargin * 4, 0);
scale += text_[0].GetSize() * Vector2(0, 0.3f);
Vector2f scale = engine.GetScreenSize() * Vector2f(1, 0);
scale -= engine.GetScreenSize() * Vector2f(kHorizontalMargin * 4, 0);
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].SetColor(kPprogressBarColor[i] * Vector4(1, 1, 1, 0));
progress_bar_[i].Translate(pos * Vector2f(0, 1));
progress_bar_[i].SetColor(kPprogressBarColor[i] * Vector4f(1, 1, 1, 0));
pos -= progress_bar_[i].GetSize() * Vector2(0, 4);
text_[i].Translate(pos * Vector2(i ? 1 : -1, 1));
pos -= progress_bar_[i].GetSize() * Vector2f(0, 4);
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});

22
src/demo/menu.cc
View File

@ -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 Vector4 kColorHighlight = {5, 5, 5, 1};
const Vector4f kColorNormal = {1, 1, 1, 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)
tap_pos_[0] = tap_pos_[1] = event->GetVector();
else if (event->GetType() == InputEvent::kDrag)
if (event->GetType() == InputEvent::kDragStart) {
tap_pos_[0] = event->GetVector();
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});
}

2
src/demo/menu.h
View File

@ -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();

47
src/demo/player.cc
View File

@ -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) +
Vector2(0, weapon_[type].GetSize().y * 0.7f);
Vector2f(type == kDamageType_Green ? 3.5f : -3.5f, -2) +
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_;
float len = dir.Magnitude();
Vector2f dir = drag_end_ - drag_start_;
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;
}

16
src/demo/player.h
View File

@ -25,8 +25,8 @@ class Player {
void OnInputEvent(std::unique_ptr<eng::InputEvent> event);
base::Vector2 GetWeaponPos(DamageType type) const;
base::Vector2 GetWeaponScale() const;
base::Vector2f GetWeaponPos(DamageType type) 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::Vector2 drag_end_ = {0, 0};
base::Vector2f drag_start_ = {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 Drag(const base::Vector2& pos);
void DragStart(const base::Vector2f& pos);
void Drag(const base::Vector2f& pos);
void DragEnd();
void DragCancel();
bool ValidateDrag();

4
src/demo/sky_quad.cc
View File

@ -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);

14
src/demo/sky_quad.h
View File

@ -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; }
base::Vector4 GetColor() const override { return nebula_color_; }
void SetColor(const base::Vector4f& color) override { nebula_color_ = 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::Vector2 last_sky_offset_ = {0, 0};
base::Vector4 nebula_color_ = {0, 0, 0, 1};
base::Vector2 scale_ = {1, 1};
base::Vector2f sky_offset_ = {0, 0};
base::Vector2f last_sky_offset_ = {0, 0};
base::Vector4f nebula_color_ = {0, 0, 0, 1};
base::Vector2f scale_ = {1, 1};
eng::Animator color_animator_;

4
src/engine/animatable.cc
View File

@ -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;
}

26
src/engine/animatable.h
View File

@ -11,27 +11,27 @@ class Animatable : public Drawable {
Animatable() = default;
~Animatable() override = default;
void Translate(const base::Vector2& pos);
void Scale(const base::Vector2& scale);
void Translate(const base::Vector2f& pos);
void Scale(const base::Vector2f& scale);
void Scale(float scale);
void Rotate(float angle);
void SetPosition(const base::Vector2& pos) { position_ = pos; }
void SetSize(const base::Vector2& size) { size_ = size; }
void SetPosition(const base::Vector2f& pos) { position_ = pos; }
void SetSize(const base::Vector2f& size) { size_ = size; }
void SetTheta(float theta);
base::Vector2 GetPosition() const { return position_; }
base::Vector2 GetSize() const { return size_ * scale_; }
base::Vector2f GetPosition() const { return position_; }
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 base::Vector4 GetColor() const = 0;
virtual void SetColor(const base::Vector4f& color) = 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::Vector2 size_ = {1, 1};
base::Vector2 scale_ = {1, 1};
base::Vector2 rotation_ = {0, 1};
base::Vector2f position_ = {0, 0};
base::Vector2f size_ = {1, 1};
base::Vector2f scale_ = {1, 1};
base::Vector2f rotation_ = {0, 1};
float theta_ = 0;
};

8
src/engine/animator.cc
View File

@ -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);
}

12
src/engine/animator.h
View File

@ -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_;

19
src/engine/engine.cc
View File

@ -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.
// For the long endge, it's calculated from aspect ratio.
// Normalize viewport.
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;

12
src/engine/engine.h
View File

@ -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::Matrix4x4 projection_;
base::Vector2f screen_size_ = {0, 0};
base::Matrix4f projection_;
std::unique_ptr<Font> system_font_;

6
src/engine/image.cc
View File

@ -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;

6
src/engine/image.h
View File

@ -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_;

10
src/engine/image_quad.cc
View File

@ -32,8 +32,8 @@ void ImageQuad::Destory() {
void ImageQuad::AutoScale() {
auto& engine = Engine::Get();
Vector2 dimensions = {GetFrameWidth(), GetFrameHeight()};
Vector2 size = engine.ToScale(dimensions);
Vector2f dimensions = {GetFrameWidth(), GetFrameHeight()};
Vector2f size = engine.ToScale(dimensions);
float s =
static_cast<float>(engine.image_dpi()) * engine.GetImageScaleFactor();
size *= static_cast<float>(engine.GetDeviceDpi()) / s;
@ -63,8 +63,8 @@ void ImageQuad::Draw(float frame_frac) {
texture_->Activate();
Vector2 tex_scale = {GetFrameWidth() / texture_->GetWidth(),
GetFrameHeight() / texture_->GetHeight()};
Vector2f tex_scale = {GetFrameWidth() / texture_->GetWidth(),
GetFrameHeight() / texture_->GetHeight()};
Shader* shader = custom_shader_ ? custom_shader_.get()
: Engine::Get().GetPassThroughShader();
@ -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])};

16
src/engine/image_quad.h
View File

@ -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; }
base::Vector4 GetColor() const override { return color_; }
void SetColor(const base::Vector4f& color) override { color_ = color; }
base::Vector4f GetColor() const override { return color_; }
// Drawable interface.
void Draw(float frame_frac) override;
private:
using UniformValue = std::variant<base::Vector2,
base::Vector3,
base::Vector4,
base::Matrix4x4,
using UniformValue = std::variant<base::Vector2f,
base::Vector3f,
base::Vector4f,
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

6
src/engine/input_event.h
View File

@ -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;
};

13
src/engine/platform/platform_android.cc
View File

@ -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>(
InputEvent::kDragEnd, pointer_id, pos[pointer_id] * Vector2(1, -1));
input_event =
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;

2
src/engine/platform/platform_android.h
View File

@ -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);

12
src/engine/platform/platform_linux.cc
View File

@ -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;

8
src/engine/renderer/opengl/render_command.h
View File

@ -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

8
src/engine/renderer/opengl/renderer_opengl.cc
View File

@ -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;

8
src/engine/renderer/opengl/renderer_opengl.h
View File

@ -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;

8
src/engine/renderer/renderer.h
View File

@ -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;

8
src/engine/renderer/shader.cc
View File

@ -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);
}

8
src/engine/renderer/shader.h
View File

@ -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::Vector3& v);
void SetUniform(const std::string& name, const base::Vector4& v);
void SetUniform(const std::string& name, const base::Matrix4x4& m);
void SetUniform(const std::string& name, const base::Vector2f& v);
void SetUniform(const std::string& name, const base::Vector3f& v);
void SetUniform(const std::string& name, const base::Vector4f& v);
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);

8
src/engine/renderer/vulkan/renderer_vulkan.cc
View File

@ -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);
}

8
src/engine/renderer/vulkan/renderer_vulkan.h
View File

@ -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;

6
src/engine/solid_quad.h
View File

@ -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; }
base::Vector4 GetColor() const override { return color_; }
void SetColor(const base::Vector4f& color) override { color_ = 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