yuzu-emu
/
yuzu
Archived
1
0
Fork 0
Code

common: Extract point into a common struct 

This is generic enough that it can be moved into the Common class for
reuse.
This commit is contained in:
Lioncash 2021-05-28 07:14:14 -04:00
parent d25648cb6c
commit 8171ad65cd
3 changed files with 65 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/common/CMakeLists.txt
View File

@ -154,6 +154,7 @@ add_library(common STATIC
param_package.cpp
param_package.h
parent_of_member.h
point.h
quaternion.h
ring_buffer.h
scm_rev.cpp

57
src/common/point.h Normal file
View File

@ -0,0 +1,57 @@
// Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include <type_traits>
namespace Common {
// Represents a point within a 2D space.
template <typename T>
struct Point {
static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type!");
T x{};
T y{};
#define ARITHMETIC_OP(op, compound_op) \
friend constexpr Point operator op(const Point& lhs, const Point& rhs) noexcept { \
return { \
.x = static_cast<T>(lhs.x op rhs.x), \
.y = static_cast<T>(lhs.y op rhs.y), \
}; \
} \
friend constexpr Point operator op(const Point& lhs, T value) noexcept { \
return { \
.x = static_cast<T>(lhs.x op value), \
.y = static_cast<T>(lhs.y op value), \
}; \
} \
friend constexpr Point operator op(T value, const Point& rhs) noexcept { \
return { \
.x = static_cast<T>(value op rhs.x), \
.y = static_cast<T>(value op rhs.y), \
}; \
} \
friend constexpr Point& operator compound_op(Point& lhs, const Point& rhs) noexcept { \
lhs.x = static_cast<T>(lhs.x op rhs.x); \
lhs.y = static_cast<T>(lhs.y op rhs.y); \
return lhs; \
} \
friend constexpr Point& operator compound_op(Point& lhs, T value) noexcept { \
lhs.x = static_cast<T>(lhs.x op value); \
lhs.y = static_cast<T>(lhs.y op value); \
return lhs; \
}
ARITHMETIC_OP(+, +=)
ARITHMETIC_OP(-, -=)
ARITHMETIC_OP(*, *=)
ARITHMETIC_OP(/, /=)
#undef ARITHMETIC_OP
friend constexpr bool operator==(const Point&, const Point&) = default;
};
} // namespace Common

36
src/core/hle/service/hid/controllers/gesture.h
View File

@ -7,6 +7,7 @@
#include <array>
#include "common/bit_field.h"
#include "common/common_types.h"
#include "common/point.h"
#include "core/frontend/input.h"
#include "core/hle/service/hid/controllers/controller_base.h"
@ -63,44 +64,21 @@ private:
};
static_assert(sizeof(Attribute) == 4, "Attribute is an invalid size");
template <typename T>
struct Point {
T x{};
T y{};
friend Point operator+(const Point& lhs, const Point& rhs) {
return {
.x = lhs.x + rhs.x,
.y = lhs.y + rhs.y,
};
}
friend Point operator-(const Point& lhs, const Point& rhs) {
return {
.x = lhs.x - rhs.x,
.y = lhs.y - rhs.y,
};
}
friend bool operator==(const Point&, const Point&) = default;
};
static_assert(sizeof(Point<s32_le>) == 8, "Point is an invalid size");
struct GestureState {
s64_le sampling_number;
s64_le sampling_number2;
s64_le detection_count;
TouchType type;
Direction direction;
Point<s32_le> pos;
Point<s32_le> delta;
Common::Point<s32_le> pos;
Common::Point<s32_le> delta;
f32 vel_x;
f32 vel_y;
Attribute attributes;
f32 scale;
f32 rotation_angle;
s32_le point_count;
std::array<Point<s32_le>, 4> points;
std::array<Common::Point<s32_le>, 4> points;
};
static_assert(sizeof(GestureState) == 0x68, "GestureState is an invalid size");
@ -111,14 +89,14 @@ private:
static_assert(sizeof(SharedMemory) == 0x708, "SharedMemory is an invalid size");
struct Finger {
Point<f32> pos{};
Common::Point<f32> pos{};
bool pressed{};
};
struct GestureProperties {
std::array<Point<s32_le>, MAX_POINTS> points{};
std::array<Common::Point<s32_le>, MAX_POINTS> points{};
std::size_t active_points{};
Point<s32_le> mid_point{};
Common::Point<s32_le> mid_point{};
s64_le detection_count{};
u64_le delta_time{};
f32 average_distance{};