ksys: Start adding more VFR utils

This commit is contained in:
Léo Lam 2021-01-25 18:17:56 +01:00
parent e33476bbc0
commit fdb69b6376
No known key found for this signature in database
GPG Key ID: 0DF30F9081000741
6 changed files with 244 additions and 22 deletions

View File

@ -628,7 +628,7 @@
0x000000710001b4d0,sub_710001B4D0,100,
0x000000710001b534,sub_710001B534,104,
0x000000710001b59c,sub_710001B59C,796,
0x000000710001b8b8,vfr::updateTimer,412,
0x000000710001b8b8,vfr::updateTimer,412,_ZN4ksys8VFRValue9lerpValueEPfRKffff
0x000000710001ba54,sub_710001BA54,60,
0x000000710001ba90,sub_710001BA90,60,
0x000000710001bacc,sub_710001BACC,288,
@ -91897,26 +91897,26 @@
0x00000071011c1960,sub_71011C1960,200,_ZN4ksys3VFR17ScopedDeltaSetterD1Ev
0x00000071011c1a28,VFR::isField29Set,8,_ZNK4ksys3VFR19hasIntervalOverrideEv
0x00000071011c1a30,VFR::x,8,_ZNK4ksys3VFR19getIntervalOverrideEv
0x00000071011c1a38,sub_71011C1A38,44,
0x00000071011c1a64,sub_71011C1A64,12,
0x00000071011c1a70,sub_71011C1A70,28,
0x00000071011c1a8c,sub_71011C1A8C,140,
0x00000071011c1b18,sub_71011C1B18,128,
0x00000071011c1b98,sub_71011C1B98,132,
0x00000071011c1c1c,sub_71011C1C1C,164,
0x00000071011c1cc0,sub_71011C1CC0,292,
0x00000071011c1de4,j_vfr::updateTimer,4,
0x00000071011c1de8,sub_71011C1DE8,220,
0x00000071011c1ec4,sub_71011C1EC4,52,
0x00000071011c1ef8,sub_71011C1EF8,192,
0x00000071011c1fb8,sub_71011C1FB8,148,
0x00000071011c204c,sub_71011C204C,204,
0x00000071011c2118,sub_71011C2118,300,
0x00000071011c2244,sub_71011C2244,16,
0x00000071011c2254,sub_71011C2254,24,
0x00000071011c226c,sub_71011C226C,24,
0x00000071011c2284,sub_71011C2284,44,
0x00000071011c22b0,sub_71011C22B0,184,
0x00000071011c1a38,sub_71011C1A38,44,_GLOBAL__sub_I_VFRValue.cpp?
0x00000071011c1a64,sub_71011C1A64,12,_ZN4ksys8VFRValueC1Ev
0x00000071011c1a70,sub_71011C1A70,28,_ZN4ksys8VFRValueC1ERKf
0x00000071011c1a8c,sub_71011C1A8C,140,_ZN4ksys8VFRValue11updateStatsEv
0x00000071011c1b18,sub_71011C1B18,128,_ZN4ksys8VFRValuepLERKf
0x00000071011c1b98,sub_71011C1B98,132,_ZN4ksys8VFRValuemLEf
0x00000071011c1c1c,sub_71011C1C1C,164,_ZN4ksys8VFRValue4lerpERKff
0x00000071011c1cc0,sub_71011C1CC0,292,_ZN4ksys8VFRValue4lerpERKfff
0x00000071011c1de4,j_vfr::updateTimer,4,_ZN4ksys8VFRValue4lerpERKffff
0x00000071011c1de8,sub_71011C1DE8,220,_ZN4ksys8VFRValue5chaseERKff
0x00000071011c1ec4,sub_71011C1EC4,52,_ZN4ksys8VFRVec3fC1ERKN4sead7Vector3IfEE
0x00000071011c1ef8,sub_71011C1EF8,192,_ZN4ksys8VFRVec3f11updateStatsEv?
0x00000071011c1fb8,sub_71011C1FB8,148,_ZN4ksys8VFRVec3fmLEf
0x00000071011c204c,sub_71011C204C,204,_ZN4ksys8VFRVec3f4lerpERKN4sead7Vector3IfEEf
0x00000071011c2118,sub_71011C2118,300,_ZN4ksys8VFRVec3f5chaseERKN4sead7Vector3IfEEf
0x00000071011c2244,sub_71011C2244,16,_ZN4ksys8VFRVec3fC1Ev
0x00000071011c2254,sub_71011C2254,24,_ZN4ksys8VFRValue8setToMaxERKf
0x00000071011c226c,sub_71011C226C,24,_ZN4ksys8VFRValue8setToMinERKf
0x00000071011c2284,sub_71011C2284,44,_ZN4ksys8VFRValue5clampERKfS2_
0x00000071011c22b0,sub_71011C22B0,184,_ZN4ksys8VFRVec3f9normalizeEf
0x00000071011c2368,AI_ActionBase::ctor,48,_ZN4ksys3act2ai6ActionC1ERKNS1_10ActionBase7InitArgE
0x00000071011c2398,AI_ActionBase::calcRecursively,12,_ZN4ksys3act2ai6Action4calcEv
0x00000071011c23a4,AI_ActionBase::playAS,288,

Can't render this file because it is too large.

Binary file not shown.

@ -1 +1 @@
Subproject commit bb92e59f569bf8e865a9710b03015352c137cc29
Subproject commit 785bd9cbc723960f10757bcf03a338f80812d1d9

View File

@ -19,4 +19,6 @@ target_sources(uking PRIVATE
Timer.h
VFR.cpp
VFR.h
VFRValue.cpp
VFRValue.h
)

View File

@ -0,0 +1,172 @@
#include "KingSystem/System/VFRValue.h"
#include <cmath>
#include <math/seadMathCalcCommon.h>
#include <prim/seadMemUtil.h>
#include "KingSystem/System/VFR.h"
#include "KingSystem/Utils/InitTimeInfo.h"
namespace ksys {
namespace {
util::InitTimeInfoEx sInitInfo;
f32 getLerpFactor(f32 t) {
return 1.0f - std::pow(1.0f - t, VFR::instance()->getDeltaTime());
}
template <typename T>
void updateStatsImpl(const T& value, T* prev_value, T* mean) {
const T new_mean = ((*prev_value + value) / 2) * VFR::instance()->getDeltaTime();
*prev_value = value;
*mean = new_mean;
}
template <typename T>
void addImpl(T* value, const T& v) {
*value += v * VFR::instance()->getDeltaTime();
}
template <typename T>
void multiplyImpl(T* value, f32 scalar) {
*value *= std::pow(scalar, VFR::instance()->getDeltaTime());
}
template <typename T>
void lerpImpl(T* value, const T& b, f32 t) {
*value += getLerpFactor(t) * (b - *value);
}
template <typename T>
void lerpImpl(T* value, const T& b, f32 t, f32 max_delta) {
const auto f = getLerpFactor(t);
const auto max_d = VFR::instance()->getDeltaTime() * max_delta;
const auto diff = b - *value;
const auto d = f * sead::absf(diff);
if (d > max_d)
*value += diff < 0.0 ? -max_d : max_d;
else
*value += f * diff;
}
template <typename T>
bool lerpImpl(T* value, const T& b, f32 t, f32 max_delta, f32 min_delta) {
const auto f = getLerpFactor(t);
const auto max_d = VFR::instance()->getDeltaTime() * max_delta;
const auto min_d = VFR::instance()->getDeltaTime() * min_delta;
const auto diff = b - *value;
const auto d = f * sead::absf(diff);
if (sead::absf(diff) <= min_d) {
*value = b;
return true;
}
if (d > max_d) {
*value += diff < 0.0 ? -max_d : max_d;
} else if (d < min_d) {
*value += diff < 0.0 ? -min_d : min_d;
} else {
*value += f * diff;
}
return false;
}
} // namespace
VFRValue::VFRValue() = default;
VFRValue::VFRValue(const f32& value) : value{value}, prev_value{value}, mean{value} {}
void VFRValue::updateStats() {
updateStatsImpl(value, &prev_value, &mean);
}
void VFRValue::operator+=(const f32& rhs) {
addImpl(&value, rhs);
}
void VFRValue::operator*=(f32 scalar) {
multiplyImpl(&value, scalar);
}
void VFRValue::lerp(const f32& b, f32 t) {
lerpImpl(&value, b, t);
}
void VFRValue::lerp(const f32& b, f32 t, f32 max_delta) {
lerpImpl(&value, b, t, max_delta);
}
bool VFRValue::lerp(const f32& b, f32 t, f32 max_delta, f32 min_delta) {
return lerpValue(&value, b, t, max_delta, min_delta);
}
bool VFRValue::lerpValue(f32* value, const f32& b, f32 t, f32 max_delta, f32 min_delta) {
return lerpImpl(value, b, t, max_delta, min_delta);
}
bool VFRValue::chase(const f32& target, f32 step) {
const auto delta = step * VFR::instance()->getDeltaTime();
return sead::Mathf::chase(&value, target, delta);
}
VFRVec3f::VFRVec3f() : value{0, 0, 0}, prev_value{0, 0, 0}, mean{0, 0, 0} {}
VFRVec3f::VFRVec3f(const sead::Vector3f& value) : value{value}, prev_value{value}, mean{value} {}
// NON_MATCHING: float regalloc
void VFRVec3f::updateStats() {
updateStatsImpl(value, &prev_value, &mean);
}
void VFRVec3f::operator*=(f32 scalar) {
multiplyImpl(&value, scalar);
}
void VFRVec3f::lerp(const sead::Vector3f& b, f32 t) {
lerpImpl(&value, b, t);
}
bool VFRVec3f::chase(const sead::Vector3f& target, f32 t) {
const auto delta = VFR::instance()->getDeltaTime() * t;
const auto diff = target - value;
const auto norm = sead::norm2(diff);
if (norm <= delta) {
sead::MemUtil::copy(&value, &target, sizeof(value));
return true;
}
value += diff * (1.0f / norm) * delta;
return false;
}
void VFRValue::setToMax(const f32& max) {
const auto a = value;
const auto b = max;
value = a < b ? b : a;
}
void VFRValue::setToMin(const f32& min) {
const auto a = value;
const auto b = min;
value = a > b ? b : a;
}
void VFRValue::clamp(const f32& min, const f32& max) {
const auto a = min;
const auto b = max;
value = sead::clamp(value, a, b);
}
void VFRVec3f::normalize(f32 new_norm) {
if (sead::norm2(value) > new_norm) {
const auto norm = sead::norm2(value);
if (norm > 0.0)
value *= new_norm / norm;
}
}
} // namespace ksys

View File

@ -0,0 +1,48 @@
#pragma once
#include <basis/seadTypes.h>
#include <math/seadVector.h>
namespace ksys {
/// A time-scaled floating-point value.
struct VFRValue {
VFRValue();
explicit VFRValue(const f32& value);
void updateStats();
void operator+=(const f32& rhs);
void operator*=(f32 scalar);
void lerp(const f32& b, f32 t);
void lerp(const f32& b, f32 t, f32 max_delta);
bool lerp(const f32& b, f32 t, f32 max_delta, f32 min_delta);
static bool lerpValue(f32* value, const f32& b, f32 t, f32 max_delta, f32 min_delta);
bool chase(const f32& target, f32 step);
void setToMax(const f32& max);
void setToMin(const f32& min);
void clamp(const f32& min, const f32& max);
f32 value{};
f32 prev_value{};
f32 mean{};
};
/// A time-scaled Vector3f.
struct VFRVec3f {
VFRVec3f();
explicit VFRVec3f(const sead::Vector3f& value);
void updateStats();
void operator*=(f32 scalar);
void lerp(const sead::Vector3f& b, f32 t);
bool chase(const sead::Vector3f& target, f32 t);
/// Normalize the `value` vector if its norm is greater than `new_norm`.
/// Normalization will make the norm equal to `new_norm`.
void normalize(f32 new_norm);
sead::Vector3f value;
sead::Vector3f prev_value;
sead::Vector3f mean;
};
} // namespace ksys