Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #13226 from AndrewMeadows/workload-015

Browse source 
workload: disable regulation of workload regions by default
This commit is contained in:
Sam Gateau 2018-05-30 16:02:22 -07:00 committed by GitHub
commit d87b19522f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 59 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
interface/src/workload/GameWorkload.h
View file

@ -42,5 +42,4 @@ public:
workload::EnginePointer _engine;
};
#endif // hifi_GameWorkload_h

2
libraries/workload/src/workload/View.h
View file

@ -41,7 +41,7 @@ public:
// Fov stores the half field of view angle, and tan/cos/sin ready to go, default is fov of 90deg
glm::vec4 fov_halfAngle_tan_cos_sin { glm::quarter_pi<float>(), 1.0f, glm::root_two<float>() * 0.5f, glm::root_two<float>() * 0.5f};
// Origin position
// Origin position
glm::vec3 origin{ 0.0f };
// Origin radius

47
libraries/workload/src/workload/ViewTask.cpp
View file

@ -69,14 +69,11 @@ void SetupViews::run(const WorkloadContextPointer& renderContext, const Input& i
}
ControlViews::ControlViews() {
regionBackFronts[0] = glm::vec2(1.0f, 3.0f);
regionBackFronts[1] = glm::vec2(1.0f, 5.0f);
regionBackFronts[2] = glm::vec2(1.0f, 10.0f);
regionRegulators[0] = Regulator(std::chrono::milliseconds(2), regionBackFronts[0], 5.0f * regionBackFronts[0], glm::vec2(0.4f, 0.2f), 0.5f * glm::vec2(0.3f, 0.2f));
regionRegulators[1] = Regulator(std::chrono::milliseconds(2), regionBackFronts[1], 8.0f * regionBackFronts[1], glm::vec2(0.4f, 0.2f), 0.5f * glm::vec2(0.3f, 0.2f));
regionRegulators[2] = Regulator(std::chrono::milliseconds(2), regionBackFronts[2], 10.0f * regionBackFronts[2], glm::vec2(0.4f, 0.2f), 0.5f * glm::vec2(0.3f, 0.2f));
for (int32_t i = 0; i < workload::Region::NUM_VIEW_REGIONS; i++) {
regionBackFronts[i] = MIN_VIEW_BACK_FRONTS[i];
regionRegulators[i] = Regulator(std::chrono::milliseconds(2), MIN_VIEW_BACK_FRONTS[i], MAX_VIEW_BACK_FRONTS[i], glm::vec2(RELATIVE_STEP_DOWN), glm::vec2(RELATIVE_STEP_UP));
}
}
void ControlViews::configure(const Config& config) {
@ -107,14 +104,10 @@ void ControlViews::run(const workload::WorkloadContextPointer& runContext, const
}
glm::vec2 Regulator::run(const Timing_ns& regulationDuration, const Timing_ns& measured, const glm::vec2& current) {
glm::vec2 next = current;
// Regulate next value based on current moving toward the goal budget
float error_ms = std::chrono::duration<float, std::milli>(_budget - measured).count();
float coef = error_ms / std::chrono::duration<float, std::milli>(regulationDuration).count();
next += coef * (error_ms < 0.0f ? _speedDown : _speedUp);
return next;
float coef = glm::clamp(error_ms / std::chrono::duration<float, std::milli>(regulationDuration).count(), -1.0f, 1.0f);
return current * (1.0f + coef * (error_ms < 0.0f ? _relativeStepDown : _relativeStepUp));
}
glm::vec2 Regulator::clamp(const glm::vec2& backFront) const {
@ -122,21 +115,21 @@ glm::vec2 Regulator::clamp(const glm::vec2& backFront) const {
return glm::clamp(backFront, _minRange, _maxRange);
}
void ControlViews::regulateViews(workload::Views& outViews, const workload::Timings& timings) {
for (auto& outView : outViews) {
for (int r = 0; r < workload::Region::NUM_VIEW_REGIONS; r++) {
for (int32_t r = 0; r < workload::Region::NUM_VIEW_REGIONS; r++) {
outView.regionBackFronts[r] = regionBackFronts[r];
}
}
auto loopDuration = std::chrono::nanoseconds{ std::chrono::milliseconds(16) };
regionBackFronts[workload::Region::R1] = regionRegulators[workload::Region::R1].clamp(regionRegulators[workload::Region::R1].run(loopDuration, timings[0], regionBackFronts[workload::Region::R1]));
regionBackFronts[workload::Region::R2] = regionRegulators[workload::Region::R2].clamp(regionRegulators[workload::Region::R2].run(loopDuration, timings[0], regionBackFronts[workload::Region::R2]));
regionBackFronts[workload::Region::R3] = regionRegulators[workload::Region::R3].clamp(regionRegulators[workload::Region::R3].run(loopDuration, timings[1], regionBackFronts[workload::Region::R3]));
regionBackFronts[workload::Region::R1] = regionRegulators[workload::Region::R1].run(loopDuration, timings[0], regionBackFronts[workload::Region::R1]);
regionBackFronts[workload::Region::R2] = regionRegulators[workload::Region::R2].run(loopDuration, timings[0], regionBackFronts[workload::Region::R2]);
regionBackFronts[workload::Region::R3] = regionRegulators[workload::Region::R3].run(loopDuration, timings[1], regionBackFronts[workload::Region::R3]);
enforceRegionContainment();
// Export data config
_dataExport.ranges[workload::Region::R1] = regionBackFronts[workload::Region::R1];
_dataExport.ranges[workload::Region::R2] = regionBackFronts[workload::Region::R2];
_dataExport.ranges[workload::Region::R3] = regionBackFronts[workload::Region::R3];
@ -149,3 +142,19 @@ void ControlViews::regulateViews(workload::Views& outViews, const workload::Timi
workload::View::updateRegionsFromBackFronts(outView);
}
}
void ControlViews::enforceRegionContainment() {
// inner regions should never overreach outer
// and each region should never exceed its min/max limits
const glm::vec2 MIN_REGION_GAP = { 1.0f, 2.0f };
// enforce outside --> in
for (int32_t i = workload::Region::NUM_VIEW_REGIONS - 2; i >= 0; --i) {
int32_t j = i + 1;
regionBackFronts[i] = regionRegulators[i].clamp(glm::min(regionBackFronts[i], regionBackFronts[j] - MIN_REGION_GAP));
}
// enforce inside --> out
for (int32_t i = 1; i < workload::Region::NUM_VIEW_REGIONS; ++i) {
int32_t j = i - 1;
regionBackFronts[i] = regionRegulators[i].clamp(glm::max(regionBackFronts[i], regionBackFronts[j] + MIN_REGION_GAP));
}
}

48
libraries/workload/src/workload/ViewTask.h
View file

@ -24,9 +24,21 @@ QVariantList toVariantList(const QList<T> &list)
}
namespace workload {
const glm::vec2 DEFAULT_R1_BACK_FRONT = { 50.0f, 100.0f };
const glm::vec2 DEFAULT_R2_BACK_FRONT = { 75.0f, 150.0f };
const glm::vec2 DEFAULT_R3_BACK_FRONT = { 100.0f, 250.0f };
const std::vector<glm::vec2> MIN_VIEW_BACK_FRONTS = {
{ 3.0f, 4.0f },
{ 6.0f, 8.0f },
{ 9.0f, 12.0f }
};
const std::vector<glm::vec2> MAX_VIEW_BACK_FRONTS = {
{ 100.0f, 200.0f },
{ 150.0f, 300.0f },
{ 250.0f, 500.0f }
};
const float RELATIVE_STEP_DOWN = 0.05f;
const float RELATIVE_STEP_UP = 0.04f;
class SetupViewsConfig : public Job::Config{
Q_OBJECT
@ -44,7 +56,6 @@ namespace workload {
public:
float getR1Front() const { return data.r1Front; }
float getR1Back() const { return data.r1Back; }
float getR2Front() const { return data.r2Front; }
@ -70,14 +81,14 @@ namespace workload {
void setSimulateSecondaryCamera(bool use) { data.simulateSecondaryCamera = use; emit dirty(); }
struct Data {
float r1Back { DEFAULT_R1_BACK_FRONT.x };
float r1Front { DEFAULT_R1_BACK_FRONT.y };
float r1Back { MAX_VIEW_BACK_FRONTS[0].x };
float r1Front { MAX_VIEW_BACK_FRONTS[0].y };
float r2Back{ DEFAULT_R2_BACK_FRONT.x };
float r2Front{ DEFAULT_R2_BACK_FRONT.y };
float r2Back{ MAX_VIEW_BACK_FRONTS[1].x };
float r2Front{ MAX_VIEW_BACK_FRONTS[1].y };
float r3Back{ DEFAULT_R3_BACK_FRONT.x };
float r3Front{ DEFAULT_R3_BACK_FRONT.y };
float r3Back{ MAX_VIEW_BACK_FRONTS[2].x };
float r3Front{ MAX_VIEW_BACK_FRONTS[2].y };
bool freezeViews{ false };
bool useAvatarView{ false };
@ -181,7 +192,7 @@ namespace workload {
struct Data {
bool regulateViewRanges{ true };
bool regulateViewRanges{ false };
} data;
struct DataExport {
@ -203,16 +214,16 @@ namespace workload {
struct Regulator {
using Timing_ns = std::chrono::nanoseconds;
Timing_ns _budget{ std::chrono::milliseconds(2) };
glm::vec2 _minRange{ 2.0f, 5.0f };
glm::vec2 _maxRange{ 50.0f, 100.0f };
glm::vec2 _minRange{ MIN_VIEW_BACK_FRONTS[0] };
glm::vec2 _maxRange{ MAX_VIEW_BACK_FRONTS[0] };
glm::vec2 _speedDown{ 0.2f };
glm::vec2 _speedUp{ 0.1f };
glm::vec2 _relativeStepDown{ RELATIVE_STEP_DOWN };
glm::vec2 _relativeStepUp{ RELATIVE_STEP_UP };
Regulator() {}
Regulator(const Timing_ns& budget_ns, const glm::vec2& minRange, const glm::vec2& maxRange, const glm::vec2& speedDown, const glm::vec2& speedUp) :
_budget(budget_ns), _minRange(minRange), _maxRange(maxRange), _speedDown(speedDown), _speedUp(speedUp) {}
Regulator(const Timing_ns& budget_ns, const glm::vec2& minRange, const glm::vec2& maxRange, const glm::vec2& relativeStepDown, const glm::vec2& relativeStepUp) :
_budget(budget_ns), _minRange(minRange), _maxRange(maxRange), _relativeStepDown(relativeStepDown), _relativeStepUp(relativeStepUp) {}
glm::vec2 run(const Timing_ns& regulationDuration, const Timing_ns& measured, const glm::vec2& current);
glm::vec2 clamp(const glm::vec2& backFront) const;
@ -234,6 +245,7 @@ namespace workload {
std::array<Regulator, workload::Region::NUM_VIEW_REGIONS> regionRegulators;
void regulateViews(workload::Views& views, const workload::Timings& timings);
void enforceRegionContainment();
protected:
Config::Data _data;
@ -242,4 +254,4 @@ namespace workload {
} // namespace workload
#endif // hifi_workload_ViewTask_h
#endif // hifi_workload_ViewTask_h