mirror of
https://git.h3cjp.net/H3cJP/yuzu.git
synced 2024-11-14 12:53:03 +00:00
Merge pull request #2167 from lioncash/namespace
common: Move Quaternion, Rectangle, Vec2, Vec3, and Vec4 into the Common namespace
This commit is contained in:
commit
66e023fba2
|
@ -55,36 +55,36 @@ constexpr u8 Convert8To6(u8 value) {
|
||||||
/**
|
/**
|
||||||
* Decode a color stored in RGBA8 format
|
* Decode a color stored in RGBA8 format
|
||||||
* @param bytes Pointer to encoded source color
|
* @param bytes Pointer to encoded source color
|
||||||
* @return Result color decoded as Math::Vec4<u8>
|
* @return Result color decoded as Common::Vec4<u8>
|
||||||
*/
|
*/
|
||||||
inline Math::Vec4<u8> DecodeRGBA8(const u8* bytes) {
|
inline Common::Vec4<u8> DecodeRGBA8(const u8* bytes) {
|
||||||
return {bytes[3], bytes[2], bytes[1], bytes[0]};
|
return {bytes[3], bytes[2], bytes[1], bytes[0]};
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Decode a color stored in RGB8 format
|
* Decode a color stored in RGB8 format
|
||||||
* @param bytes Pointer to encoded source color
|
* @param bytes Pointer to encoded source color
|
||||||
* @return Result color decoded as Math::Vec4<u8>
|
* @return Result color decoded as Common::Vec4<u8>
|
||||||
*/
|
*/
|
||||||
inline Math::Vec4<u8> DecodeRGB8(const u8* bytes) {
|
inline Common::Vec4<u8> DecodeRGB8(const u8* bytes) {
|
||||||
return {bytes[2], bytes[1], bytes[0], 255};
|
return {bytes[2], bytes[1], bytes[0], 255};
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Decode a color stored in RG8 (aka HILO8) format
|
* Decode a color stored in RG8 (aka HILO8) format
|
||||||
* @param bytes Pointer to encoded source color
|
* @param bytes Pointer to encoded source color
|
||||||
* @return Result color decoded as Math::Vec4<u8>
|
* @return Result color decoded as Common::Vec4<u8>
|
||||||
*/
|
*/
|
||||||
inline Math::Vec4<u8> DecodeRG8(const u8* bytes) {
|
inline Common::Vec4<u8> DecodeRG8(const u8* bytes) {
|
||||||
return {bytes[1], bytes[0], 0, 255};
|
return {bytes[1], bytes[0], 0, 255};
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Decode a color stored in RGB565 format
|
* Decode a color stored in RGB565 format
|
||||||
* @param bytes Pointer to encoded source color
|
* @param bytes Pointer to encoded source color
|
||||||
* @return Result color decoded as Math::Vec4<u8>
|
* @return Result color decoded as Common::Vec4<u8>
|
||||||
*/
|
*/
|
||||||
inline Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
|
inline Common::Vec4<u8> DecodeRGB565(const u8* bytes) {
|
||||||
u16_le pixel;
|
u16_le pixel;
|
||||||
std::memcpy(&pixel, bytes, sizeof(pixel));
|
std::memcpy(&pixel, bytes, sizeof(pixel));
|
||||||
return {Convert5To8((pixel >> 11) & 0x1F), Convert6To8((pixel >> 5) & 0x3F),
|
return {Convert5To8((pixel >> 11) & 0x1F), Convert6To8((pixel >> 5) & 0x3F),
|
||||||
|
@ -94,9 +94,9 @@ inline Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
|
||||||
/**
|
/**
|
||||||
* Decode a color stored in RGB5A1 format
|
* Decode a color stored in RGB5A1 format
|
||||||
* @param bytes Pointer to encoded source color
|
* @param bytes Pointer to encoded source color
|
||||||
* @return Result color decoded as Math::Vec4<u8>
|
* @return Result color decoded as Common::Vec4<u8>
|
||||||
*/
|
*/
|
||||||
inline Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
|
inline Common::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
|
||||||
u16_le pixel;
|
u16_le pixel;
|
||||||
std::memcpy(&pixel, bytes, sizeof(pixel));
|
std::memcpy(&pixel, bytes, sizeof(pixel));
|
||||||
return {Convert5To8((pixel >> 11) & 0x1F), Convert5To8((pixel >> 6) & 0x1F),
|
return {Convert5To8((pixel >> 11) & 0x1F), Convert5To8((pixel >> 6) & 0x1F),
|
||||||
|
@ -106,9 +106,9 @@ inline Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
|
||||||
/**
|
/**
|
||||||
* Decode a color stored in RGBA4 format
|
* Decode a color stored in RGBA4 format
|
||||||
* @param bytes Pointer to encoded source color
|
* @param bytes Pointer to encoded source color
|
||||||
* @return Result color decoded as Math::Vec4<u8>
|
* @return Result color decoded as Common::Vec4<u8>
|
||||||
*/
|
*/
|
||||||
inline Math::Vec4<u8> DecodeRGBA4(const u8* bytes) {
|
inline Common::Vec4<u8> DecodeRGBA4(const u8* bytes) {
|
||||||
u16_le pixel;
|
u16_le pixel;
|
||||||
std::memcpy(&pixel, bytes, sizeof(pixel));
|
std::memcpy(&pixel, bytes, sizeof(pixel));
|
||||||
return {Convert4To8((pixel >> 12) & 0xF), Convert4To8((pixel >> 8) & 0xF),
|
return {Convert4To8((pixel >> 12) & 0xF), Convert4To8((pixel >> 8) & 0xF),
|
||||||
|
@ -138,9 +138,9 @@ inline u32 DecodeD24(const u8* bytes) {
|
||||||
/**
|
/**
|
||||||
* Decode a depth value and a stencil value stored in D24S8 format
|
* Decode a depth value and a stencil value stored in D24S8 format
|
||||||
* @param bytes Pointer to encoded source values
|
* @param bytes Pointer to encoded source values
|
||||||
* @return Resulting values stored as a Math::Vec2
|
* @return Resulting values stored as a Common::Vec2
|
||||||
*/
|
*/
|
||||||
inline Math::Vec2<u32> DecodeD24S8(const u8* bytes) {
|
inline Common::Vec2<u32> DecodeD24S8(const u8* bytes) {
|
||||||
return {static_cast<u32>((bytes[2] << 16) | (bytes[1] << 8) | bytes[0]), bytes[3]};
|
return {static_cast<u32>((bytes[2] << 16) | (bytes[1] << 8) | bytes[0]), bytes[3]};
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -149,7 +149,7 @@ inline Math::Vec2<u32> DecodeD24S8(const u8* bytes) {
|
||||||
* @param color Source color to encode
|
* @param color Source color to encode
|
||||||
* @param bytes Destination pointer to store encoded color
|
* @param bytes Destination pointer to store encoded color
|
||||||
*/
|
*/
|
||||||
inline void EncodeRGBA8(const Math::Vec4<u8>& color, u8* bytes) {
|
inline void EncodeRGBA8(const Common::Vec4<u8>& color, u8* bytes) {
|
||||||
bytes[3] = color.r();
|
bytes[3] = color.r();
|
||||||
bytes[2] = color.g();
|
bytes[2] = color.g();
|
||||||
bytes[1] = color.b();
|
bytes[1] = color.b();
|
||||||
|
@ -161,7 +161,7 @@ inline void EncodeRGBA8(const Math::Vec4<u8>& color, u8* bytes) {
|
||||||
* @param color Source color to encode
|
* @param color Source color to encode
|
||||||
* @param bytes Destination pointer to store encoded color
|
* @param bytes Destination pointer to store encoded color
|
||||||
*/
|
*/
|
||||||
inline void EncodeRGB8(const Math::Vec4<u8>& color, u8* bytes) {
|
inline void EncodeRGB8(const Common::Vec4<u8>& color, u8* bytes) {
|
||||||
bytes[2] = color.r();
|
bytes[2] = color.r();
|
||||||
bytes[1] = color.g();
|
bytes[1] = color.g();
|
||||||
bytes[0] = color.b();
|
bytes[0] = color.b();
|
||||||
|
@ -172,7 +172,7 @@ inline void EncodeRGB8(const Math::Vec4<u8>& color, u8* bytes) {
|
||||||
* @param color Source color to encode
|
* @param color Source color to encode
|
||||||
* @param bytes Destination pointer to store encoded color
|
* @param bytes Destination pointer to store encoded color
|
||||||
*/
|
*/
|
||||||
inline void EncodeRG8(const Math::Vec4<u8>& color, u8* bytes) {
|
inline void EncodeRG8(const Common::Vec4<u8>& color, u8* bytes) {
|
||||||
bytes[1] = color.r();
|
bytes[1] = color.r();
|
||||||
bytes[0] = color.g();
|
bytes[0] = color.g();
|
||||||
}
|
}
|
||||||
|
@ -181,7 +181,7 @@ inline void EncodeRG8(const Math::Vec4<u8>& color, u8* bytes) {
|
||||||
* @param color Source color to encode
|
* @param color Source color to encode
|
||||||
* @param bytes Destination pointer to store encoded color
|
* @param bytes Destination pointer to store encoded color
|
||||||
*/
|
*/
|
||||||
inline void EncodeRGB565(const Math::Vec4<u8>& color, u8* bytes) {
|
inline void EncodeRGB565(const Common::Vec4<u8>& color, u8* bytes) {
|
||||||
const u16_le data =
|
const u16_le data =
|
||||||
(Convert8To5(color.r()) << 11) | (Convert8To6(color.g()) << 5) | Convert8To5(color.b());
|
(Convert8To5(color.r()) << 11) | (Convert8To6(color.g()) << 5) | Convert8To5(color.b());
|
||||||
|
|
||||||
|
@ -193,7 +193,7 @@ inline void EncodeRGB565(const Math::Vec4<u8>& color, u8* bytes) {
|
||||||
* @param color Source color to encode
|
* @param color Source color to encode
|
||||||
* @param bytes Destination pointer to store encoded color
|
* @param bytes Destination pointer to store encoded color
|
||||||
*/
|
*/
|
||||||
inline void EncodeRGB5A1(const Math::Vec4<u8>& color, u8* bytes) {
|
inline void EncodeRGB5A1(const Common::Vec4<u8>& color, u8* bytes) {
|
||||||
const u16_le data = (Convert8To5(color.r()) << 11) | (Convert8To5(color.g()) << 6) |
|
const u16_le data = (Convert8To5(color.r()) << 11) | (Convert8To5(color.g()) << 6) |
|
||||||
(Convert8To5(color.b()) << 1) | Convert8To1(color.a());
|
(Convert8To5(color.b()) << 1) | Convert8To1(color.a());
|
||||||
|
|
||||||
|
@ -205,7 +205,7 @@ inline void EncodeRGB5A1(const Math::Vec4<u8>& color, u8* bytes) {
|
||||||
* @param color Source color to encode
|
* @param color Source color to encode
|
||||||
* @param bytes Destination pointer to store encoded color
|
* @param bytes Destination pointer to store encoded color
|
||||||
*/
|
*/
|
||||||
inline void EncodeRGBA4(const Math::Vec4<u8>& color, u8* bytes) {
|
inline void EncodeRGBA4(const Common::Vec4<u8>& color, u8* bytes) {
|
||||||
const u16 data = (Convert8To4(color.r()) << 12) | (Convert8To4(color.g()) << 8) |
|
const u16 data = (Convert8To4(color.r()) << 12) | (Convert8To4(color.g()) << 8) |
|
||||||
(Convert8To4(color.b()) << 4) | Convert8To4(color.a());
|
(Convert8To4(color.b()) << 4) | Convert8To4(color.a());
|
||||||
|
|
||||||
|
|
|
@ -7,7 +7,7 @@
|
||||||
#include <cstdlib>
|
#include <cstdlib>
|
||||||
#include <type_traits>
|
#include <type_traits>
|
||||||
|
|
||||||
namespace MathUtil {
|
namespace Common {
|
||||||
|
|
||||||
constexpr float PI = 3.14159265f;
|
constexpr float PI = 3.14159265f;
|
||||||
|
|
||||||
|
@ -41,4 +41,4 @@ struct Rectangle {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
} // namespace MathUtil
|
} // namespace Common
|
||||||
|
|
|
@ -6,12 +6,12 @@
|
||||||
|
|
||||||
#include "common/vector_math.h"
|
#include "common/vector_math.h"
|
||||||
|
|
||||||
namespace Math {
|
namespace Common {
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
class Quaternion {
|
class Quaternion {
|
||||||
public:
|
public:
|
||||||
Math::Vec3<T> xyz;
|
Vec3<T> xyz;
|
||||||
T w{};
|
T w{};
|
||||||
|
|
||||||
Quaternion<decltype(-T{})> Inverse() const {
|
Quaternion<decltype(-T{})> Inverse() const {
|
||||||
|
@ -38,12 +38,12 @@ public:
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
auto QuaternionRotate(const Quaternion<T>& q, const Math::Vec3<T>& v) {
|
auto QuaternionRotate(const Quaternion<T>& q, const Vec3<T>& v) {
|
||||||
return v + 2 * Cross(q.xyz, Cross(q.xyz, v) + v * q.w);
|
return v + 2 * Cross(q.xyz, Cross(q.xyz, v) + v * q.w);
|
||||||
}
|
}
|
||||||
|
|
||||||
inline Quaternion<float> MakeQuaternion(const Math::Vec3<float>& axis, float angle) {
|
inline Quaternion<float> MakeQuaternion(const Vec3<float>& axis, float angle) {
|
||||||
return {axis * std::sin(angle / 2), std::cos(angle / 2)};
|
return {axis * std::sin(angle / 2), std::cos(angle / 2)};
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace Math
|
} // namespace Common
|
||||||
|
|
|
@ -33,7 +33,7 @@
|
||||||
#include <cmath>
|
#include <cmath>
|
||||||
#include <type_traits>
|
#include <type_traits>
|
||||||
|
|
||||||
namespace Math {
|
namespace Common {
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
class Vec2;
|
class Vec2;
|
||||||
|
@ -690,4 +690,4 @@ constexpr Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
|
||||||
return MakeVec(x, yzw[0], yzw[1], yzw[2]);
|
return MakeVec(x, yzw[0], yzw[1], yzw[2]);
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace Math
|
} // namespace Common
|
||||||
|
|
|
@ -12,12 +12,12 @@ namespace Layout {
|
||||||
|
|
||||||
// Finds the largest size subrectangle contained in window area that is confined to the aspect ratio
|
// Finds the largest size subrectangle contained in window area that is confined to the aspect ratio
|
||||||
template <class T>
|
template <class T>
|
||||||
static MathUtil::Rectangle<T> maxRectangle(MathUtil::Rectangle<T> window_area,
|
static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area,
|
||||||
float screen_aspect_ratio) {
|
float screen_aspect_ratio) {
|
||||||
float scale = std::min(static_cast<float>(window_area.GetWidth()),
|
float scale = std::min(static_cast<float>(window_area.GetWidth()),
|
||||||
window_area.GetHeight() / screen_aspect_ratio);
|
window_area.GetHeight() / screen_aspect_ratio);
|
||||||
return MathUtil::Rectangle<T>{0, 0, static_cast<T>(std::round(scale)),
|
return Common::Rectangle<T>{0, 0, static_cast<T>(std::round(scale)),
|
||||||
static_cast<T>(std::round(scale * screen_aspect_ratio))};
|
static_cast<T>(std::round(scale * screen_aspect_ratio))};
|
||||||
}
|
}
|
||||||
|
|
||||||
FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
|
FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
|
||||||
|
@ -29,8 +29,8 @@ FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
|
||||||
|
|
||||||
const float emulation_aspect_ratio{static_cast<float>(ScreenUndocked::Height) /
|
const float emulation_aspect_ratio{static_cast<float>(ScreenUndocked::Height) /
|
||||||
ScreenUndocked::Width};
|
ScreenUndocked::Width};
|
||||||
MathUtil::Rectangle<unsigned> screen_window_area{0, 0, width, height};
|
Common::Rectangle<unsigned> screen_window_area{0, 0, width, height};
|
||||||
MathUtil::Rectangle<unsigned> screen = maxRectangle(screen_window_area, emulation_aspect_ratio);
|
Common::Rectangle<unsigned> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
|
||||||
|
|
||||||
float window_aspect_ratio = static_cast<float>(height) / width;
|
float window_aspect_ratio = static_cast<float>(height) / width;
|
||||||
|
|
||||||
|
|
|
@ -16,7 +16,7 @@ struct FramebufferLayout {
|
||||||
unsigned width{ScreenUndocked::Width};
|
unsigned width{ScreenUndocked::Width};
|
||||||
unsigned height{ScreenUndocked::Height};
|
unsigned height{ScreenUndocked::Height};
|
||||||
|
|
||||||
MathUtil::Rectangle<unsigned> screen;
|
Common::Rectangle<unsigned> screen;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Returns the ration of pixel size of the screen, compared to the native size of the undocked
|
* Returns the ration of pixel size of the screen, compared to the native size of the undocked
|
||||||
|
|
|
@ -124,7 +124,7 @@ using AnalogDevice = InputDevice<std::tuple<float, float>>;
|
||||||
* Orientation is determined by right-hand rule.
|
* Orientation is determined by right-hand rule.
|
||||||
* Units: deg/sec
|
* Units: deg/sec
|
||||||
*/
|
*/
|
||||||
using MotionDevice = InputDevice<std::tuple<Math::Vec3<float>, Math::Vec3<float>>>;
|
using MotionDevice = InputDevice<std::tuple<Common::Vec3<float>, Common::Vec3<float>>>;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* A touch device is an input device that returns a tuple of two floats and a bool. The floats are
|
* A touch device is an input device that returns a tuple of two floats and a bool. The floats are
|
||||||
|
|
|
@ -23,7 +23,7 @@ u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, std::vector
|
||||||
|
|
||||||
void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height,
|
void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height,
|
||||||
u32 stride, NVFlinger::BufferQueue::BufferTransformFlags transform,
|
u32 stride, NVFlinger::BufferQueue::BufferTransformFlags transform,
|
||||||
const MathUtil::Rectangle<int>& crop_rect) {
|
const Common::Rectangle<int>& crop_rect) {
|
||||||
VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
|
VAddr addr = nvmap_dev->GetObjectAddress(buffer_handle);
|
||||||
LOG_TRACE(Service,
|
LOG_TRACE(Service,
|
||||||
"Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
|
"Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
|
||||||
|
|
|
@ -25,7 +25,7 @@ public:
|
||||||
/// Performs a screen flip, drawing the buffer pointed to by the handle.
|
/// Performs a screen flip, drawing the buffer pointed to by the handle.
|
||||||
void flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height, u32 stride,
|
void flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height, u32 stride,
|
||||||
NVFlinger::BufferQueue::BufferTransformFlags transform,
|
NVFlinger::BufferQueue::BufferTransformFlags transform,
|
||||||
const MathUtil::Rectangle<int>& crop_rect);
|
const Common::Rectangle<int>& crop_rect);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
std::shared_ptr<nvmap> nvmap_dev;
|
std::shared_ptr<nvmap> nvmap_dev;
|
||||||
|
|
|
@ -63,7 +63,7 @@ const IGBPBuffer& BufferQueue::RequestBuffer(u32 slot) const {
|
||||||
}
|
}
|
||||||
|
|
||||||
void BufferQueue::QueueBuffer(u32 slot, BufferTransformFlags transform,
|
void BufferQueue::QueueBuffer(u32 slot, BufferTransformFlags transform,
|
||||||
const MathUtil::Rectangle<int>& crop_rect) {
|
const Common::Rectangle<int>& crop_rect) {
|
||||||
auto itr = std::find_if(queue.begin(), queue.end(),
|
auto itr = std::find_if(queue.begin(), queue.end(),
|
||||||
[&](const Buffer& buffer) { return buffer.slot == slot; });
|
[&](const Buffer& buffer) { return buffer.slot == slot; });
|
||||||
ASSERT(itr != queue.end());
|
ASSERT(itr != queue.end());
|
||||||
|
|
|
@ -67,14 +67,14 @@ public:
|
||||||
Status status = Status::Free;
|
Status status = Status::Free;
|
||||||
IGBPBuffer igbp_buffer;
|
IGBPBuffer igbp_buffer;
|
||||||
BufferTransformFlags transform;
|
BufferTransformFlags transform;
|
||||||
MathUtil::Rectangle<int> crop_rect;
|
Common::Rectangle<int> crop_rect;
|
||||||
};
|
};
|
||||||
|
|
||||||
void SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer);
|
void SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer);
|
||||||
std::optional<u32> DequeueBuffer(u32 width, u32 height);
|
std::optional<u32> DequeueBuffer(u32 width, u32 height);
|
||||||
const IGBPBuffer& RequestBuffer(u32 slot) const;
|
const IGBPBuffer& RequestBuffer(u32 slot) const;
|
||||||
void QueueBuffer(u32 slot, BufferTransformFlags transform,
|
void QueueBuffer(u32 slot, BufferTransformFlags transform,
|
||||||
const MathUtil::Rectangle<int>& crop_rect);
|
const Common::Rectangle<int>& crop_rect);
|
||||||
std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer();
|
std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer();
|
||||||
void ReleaseBuffer(u32 slot);
|
void ReleaseBuffer(u32 slot);
|
||||||
u32 Query(QueryType type);
|
u32 Query(QueryType type);
|
||||||
|
|
|
@ -420,7 +420,7 @@ public:
|
||||||
u32_le fence_is_valid;
|
u32_le fence_is_valid;
|
||||||
std::array<Fence, 2> fences;
|
std::array<Fence, 2> fences;
|
||||||
|
|
||||||
MathUtil::Rectangle<int> GetCropRect() const {
|
Common::Rectangle<int> GetCropRect() const {
|
||||||
return {crop_left, crop_top, crop_right, crop_bottom};
|
return {crop_left, crop_top, crop_right, crop_bottom};
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
|
@ -32,12 +32,12 @@ public:
|
||||||
}
|
}
|
||||||
|
|
||||||
void BeginTilt(int x, int y) {
|
void BeginTilt(int x, int y) {
|
||||||
mouse_origin = Math::MakeVec(x, y);
|
mouse_origin = Common::MakeVec(x, y);
|
||||||
is_tilting = true;
|
is_tilting = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
void Tilt(int x, int y) {
|
void Tilt(int x, int y) {
|
||||||
auto mouse_move = Math::MakeVec(x, y) - mouse_origin;
|
auto mouse_move = Common::MakeVec(x, y) - mouse_origin;
|
||||||
if (is_tilting) {
|
if (is_tilting) {
|
||||||
std::lock_guard<std::mutex> guard(tilt_mutex);
|
std::lock_guard<std::mutex> guard(tilt_mutex);
|
||||||
if (mouse_move.x == 0 && mouse_move.y == 0) {
|
if (mouse_move.x == 0 && mouse_move.y == 0) {
|
||||||
|
@ -45,7 +45,7 @@ public:
|
||||||
} else {
|
} else {
|
||||||
tilt_direction = mouse_move.Cast<float>();
|
tilt_direction = mouse_move.Cast<float>();
|
||||||
tilt_angle =
|
tilt_angle =
|
||||||
std::clamp(tilt_direction.Normalize() * sensitivity, 0.0f, MathUtil::PI * 0.5f);
|
std::clamp(tilt_direction.Normalize() * sensitivity, 0.0f, Common::PI * 0.5f);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -56,7 +56,7 @@ public:
|
||||||
is_tilting = false;
|
is_tilting = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
std::tuple<Math::Vec3<float>, Math::Vec3<float>> GetStatus() {
|
std::tuple<Common::Vec3<float>, Common::Vec3<float>> GetStatus() {
|
||||||
std::lock_guard<std::mutex> guard(status_mutex);
|
std::lock_guard<std::mutex> guard(status_mutex);
|
||||||
return status;
|
return status;
|
||||||
}
|
}
|
||||||
|
@ -66,17 +66,17 @@ private:
|
||||||
const std::chrono::steady_clock::duration update_duration;
|
const std::chrono::steady_clock::duration update_duration;
|
||||||
const float sensitivity;
|
const float sensitivity;
|
||||||
|
|
||||||
Math::Vec2<int> mouse_origin;
|
Common::Vec2<int> mouse_origin;
|
||||||
|
|
||||||
std::mutex tilt_mutex;
|
std::mutex tilt_mutex;
|
||||||
Math::Vec2<float> tilt_direction;
|
Common::Vec2<float> tilt_direction;
|
||||||
float tilt_angle = 0;
|
float tilt_angle = 0;
|
||||||
|
|
||||||
bool is_tilting = false;
|
bool is_tilting = false;
|
||||||
|
|
||||||
Common::Event shutdown_event;
|
Common::Event shutdown_event;
|
||||||
|
|
||||||
std::tuple<Math::Vec3<float>, Math::Vec3<float>> status;
|
std::tuple<Common::Vec3<float>, Common::Vec3<float>> status;
|
||||||
std::mutex status_mutex;
|
std::mutex status_mutex;
|
||||||
|
|
||||||
// Note: always keep the thread declaration at the end so that other objects are initialized
|
// Note: always keep the thread declaration at the end so that other objects are initialized
|
||||||
|
@ -85,8 +85,8 @@ private:
|
||||||
|
|
||||||
void MotionEmuThread() {
|
void MotionEmuThread() {
|
||||||
auto update_time = std::chrono::steady_clock::now();
|
auto update_time = std::chrono::steady_clock::now();
|
||||||
Math::Quaternion<float> q = MakeQuaternion(Math::Vec3<float>(), 0);
|
Common::Quaternion<float> q = Common::MakeQuaternion(Common::Vec3<float>(), 0);
|
||||||
Math::Quaternion<float> old_q;
|
Common::Quaternion<float> old_q;
|
||||||
|
|
||||||
while (!shutdown_event.WaitUntil(update_time)) {
|
while (!shutdown_event.WaitUntil(update_time)) {
|
||||||
update_time += update_duration;
|
update_time += update_duration;
|
||||||
|
@ -96,18 +96,18 @@ private:
|
||||||
std::lock_guard<std::mutex> guard(tilt_mutex);
|
std::lock_guard<std::mutex> guard(tilt_mutex);
|
||||||
|
|
||||||
// Find the quaternion describing current 3DS tilting
|
// Find the quaternion describing current 3DS tilting
|
||||||
q = MakeQuaternion(Math::MakeVec(-tilt_direction.y, 0.0f, tilt_direction.x),
|
q = Common::MakeQuaternion(
|
||||||
tilt_angle);
|
Common::MakeVec(-tilt_direction.y, 0.0f, tilt_direction.x), tilt_angle);
|
||||||
}
|
}
|
||||||
|
|
||||||
auto inv_q = q.Inverse();
|
auto inv_q = q.Inverse();
|
||||||
|
|
||||||
// Set the gravity vector in world space
|
// Set the gravity vector in world space
|
||||||
auto gravity = Math::MakeVec(0.0f, -1.0f, 0.0f);
|
auto gravity = Common::MakeVec(0.0f, -1.0f, 0.0f);
|
||||||
|
|
||||||
// Find the angular rate vector in world space
|
// Find the angular rate vector in world space
|
||||||
auto angular_rate = ((q - old_q) * inv_q).xyz * 2;
|
auto angular_rate = ((q - old_q) * inv_q).xyz * 2;
|
||||||
angular_rate *= 1000 / update_millisecond / MathUtil::PI * 180;
|
angular_rate *= 1000 / update_millisecond / Common::PI * 180;
|
||||||
|
|
||||||
// Transform the two vectors from world space to 3DS space
|
// Transform the two vectors from world space to 3DS space
|
||||||
gravity = QuaternionRotate(inv_q, gravity);
|
gravity = QuaternionRotate(inv_q, gravity);
|
||||||
|
@ -131,7 +131,7 @@ public:
|
||||||
device = std::make_shared<MotionEmuDevice>(update_millisecond, sensitivity);
|
device = std::make_shared<MotionEmuDevice>(update_millisecond, sensitivity);
|
||||||
}
|
}
|
||||||
|
|
||||||
std::tuple<Math::Vec3<float>, Math::Vec3<float>> GetStatus() const override {
|
std::tuple<Common::Vec3<float>, Common::Vec3<float>> GetStatus() const override {
|
||||||
return device->GetStatus();
|
return device->GetStatus();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -44,10 +44,10 @@ void Fermi2D::HandleSurfaceCopy() {
|
||||||
const u32 src_blit_y2{
|
const u32 src_blit_y2{
|
||||||
static_cast<u32>((regs.blit_src_y + (regs.blit_dst_height * regs.blit_dv_dy)) >> 32)};
|
static_cast<u32>((regs.blit_src_y + (regs.blit_dst_height * regs.blit_dv_dy)) >> 32)};
|
||||||
|
|
||||||
const MathUtil::Rectangle<u32> src_rect{src_blit_x1, src_blit_y1, src_blit_x2, src_blit_y2};
|
const Common::Rectangle<u32> src_rect{src_blit_x1, src_blit_y1, src_blit_x2, src_blit_y2};
|
||||||
const MathUtil::Rectangle<u32> dst_rect{regs.blit_dst_x, regs.blit_dst_y,
|
const Common::Rectangle<u32> dst_rect{regs.blit_dst_x, regs.blit_dst_y,
|
||||||
regs.blit_dst_x + regs.blit_dst_width,
|
regs.blit_dst_x + regs.blit_dst_width,
|
||||||
regs.blit_dst_y + regs.blit_dst_height};
|
regs.blit_dst_y + regs.blit_dst_height};
|
||||||
|
|
||||||
if (!rasterizer.AccelerateSurfaceCopy(regs.src, regs.dst, src_rect, dst_rect)) {
|
if (!rasterizer.AccelerateSurfaceCopy(regs.src, regs.dst, src_rect, dst_rect)) {
|
||||||
UNIMPLEMENTED();
|
UNIMPLEMENTED();
|
||||||
|
|
|
@ -503,7 +503,7 @@ public:
|
||||||
f32 translate_z;
|
f32 translate_z;
|
||||||
INSERT_PADDING_WORDS(2);
|
INSERT_PADDING_WORDS(2);
|
||||||
|
|
||||||
MathUtil::Rectangle<s32> GetRect() const {
|
Common::Rectangle<s32> GetRect() const {
|
||||||
return {
|
return {
|
||||||
GetX(), // left
|
GetX(), // left
|
||||||
GetY() + GetHeight(), // top
|
GetY() + GetHeight(), // top
|
||||||
|
|
|
@ -100,7 +100,7 @@ struct FramebufferConfig {
|
||||||
|
|
||||||
using TransformFlags = Service::NVFlinger::BufferQueue::BufferTransformFlags;
|
using TransformFlags = Service::NVFlinger::BufferQueue::BufferTransformFlags;
|
||||||
TransformFlags transform_flags;
|
TransformFlags transform_flags;
|
||||||
MathUtil::Rectangle<int> crop_rect;
|
Common::Rectangle<int> crop_rect;
|
||||||
};
|
};
|
||||||
|
|
||||||
namespace Engines {
|
namespace Engines {
|
||||||
|
|
|
@ -47,8 +47,8 @@ public:
|
||||||
/// Attempt to use a faster method to perform a surface copy
|
/// Attempt to use a faster method to perform a surface copy
|
||||||
virtual bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
virtual bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
||||||
const MathUtil::Rectangle<u32>& src_rect,
|
const Common::Rectangle<u32>& src_rect,
|
||||||
const MathUtil::Rectangle<u32>& dst_rect) {
|
const Common::Rectangle<u32>& dst_rect) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -779,8 +779,8 @@ void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {
|
||||||
|
|
||||||
bool RasterizerOpenGL::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
bool RasterizerOpenGL::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
||||||
const MathUtil::Rectangle<u32>& src_rect,
|
const Common::Rectangle<u32>& src_rect,
|
||||||
const MathUtil::Rectangle<u32>& dst_rect) {
|
const Common::Rectangle<u32>& dst_rect) {
|
||||||
MICROPROFILE_SCOPE(OpenGL_Blits);
|
MICROPROFILE_SCOPE(OpenGL_Blits);
|
||||||
res_cache.FermiCopySurface(src, dst, src_rect, dst_rect);
|
res_cache.FermiCopySurface(src, dst, src_rect, dst_rect);
|
||||||
return true;
|
return true;
|
||||||
|
@ -1034,7 +1034,7 @@ void RasterizerOpenGL::SyncViewport(OpenGLState& current_state) {
|
||||||
for (std::size_t i = 0; i < viewport_count; i++) {
|
for (std::size_t i = 0; i < viewport_count; i++) {
|
||||||
auto& viewport = current_state.viewports[i];
|
auto& viewport = current_state.viewports[i];
|
||||||
const auto& src = regs.viewports[i];
|
const auto& src = regs.viewports[i];
|
||||||
const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[i].GetRect()};
|
const Common::Rectangle<s32> viewport_rect{regs.viewport_transform[i].GetRect()};
|
||||||
viewport.x = viewport_rect.left;
|
viewport.x = viewport_rect.left;
|
||||||
viewport.y = viewport_rect.bottom;
|
viewport.y = viewport_rect.bottom;
|
||||||
viewport.width = viewport_rect.GetWidth();
|
viewport.width = viewport_rect.GetWidth();
|
||||||
|
|
|
@ -62,8 +62,8 @@ public:
|
||||||
void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
|
void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
|
||||||
bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
const Tegra::Engines::Fermi2D::Regs::Surface& dst,
|
||||||
const MathUtil::Rectangle<u32>& src_rect,
|
const Common::Rectangle<u32>& src_rect,
|
||||||
const MathUtil::Rectangle<u32>& dst_rect) override;
|
const Common::Rectangle<u32>& dst_rect) override;
|
||||||
bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr,
|
bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr,
|
||||||
u32 pixel_stride) override;
|
u32 pixel_stride) override;
|
||||||
bool AccelerateDrawBatch(bool is_indexed) override;
|
bool AccelerateDrawBatch(bool is_indexed) override;
|
||||||
|
|
|
@ -399,7 +399,7 @@ static const FormatTuple& GetFormatTuple(PixelFormat pixel_format, ComponentType
|
||||||
return format;
|
return format;
|
||||||
}
|
}
|
||||||
|
|
||||||
MathUtil::Rectangle<u32> SurfaceParams::GetRect(u32 mip_level) const {
|
Common::Rectangle<u32> SurfaceParams::GetRect(u32 mip_level) const {
|
||||||
u32 actual_height{std::max(1U, unaligned_height >> mip_level)};
|
u32 actual_height{std::max(1U, unaligned_height >> mip_level)};
|
||||||
if (IsPixelFormatASTC(pixel_format)) {
|
if (IsPixelFormatASTC(pixel_format)) {
|
||||||
// ASTC formats must stop at the ATSC block size boundary
|
// ASTC formats must stop at the ATSC block size boundary
|
||||||
|
@ -1062,8 +1062,8 @@ void RasterizerCacheOpenGL::FastLayeredCopySurface(const Surface& src_surface,
|
||||||
}
|
}
|
||||||
|
|
||||||
static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
|
static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
|
||||||
const MathUtil::Rectangle<u32>& src_rect,
|
const Common::Rectangle<u32>& src_rect,
|
||||||
const MathUtil::Rectangle<u32>& dst_rect, GLuint read_fb_handle,
|
const Common::Rectangle<u32>& dst_rect, GLuint read_fb_handle,
|
||||||
GLuint draw_fb_handle, GLenum src_attachment = 0, GLenum dst_attachment = 0,
|
GLuint draw_fb_handle, GLenum src_attachment = 0, GLenum dst_attachment = 0,
|
||||||
std::size_t cubemap_face = 0) {
|
std::size_t cubemap_face = 0) {
|
||||||
|
|
||||||
|
@ -1193,7 +1193,7 @@ static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
|
||||||
void RasterizerCacheOpenGL::FermiCopySurface(
|
void RasterizerCacheOpenGL::FermiCopySurface(
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
|
const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& dst_config,
|
const Tegra::Engines::Fermi2D::Regs::Surface& dst_config,
|
||||||
const MathUtil::Rectangle<u32>& src_rect, const MathUtil::Rectangle<u32>& dst_rect) {
|
const Common::Rectangle<u32>& src_rect, const Common::Rectangle<u32>& dst_rect) {
|
||||||
|
|
||||||
const auto& src_params = SurfaceParams::CreateForFermiCopySurface(src_config);
|
const auto& src_params = SurfaceParams::CreateForFermiCopySurface(src_config);
|
||||||
const auto& dst_params = SurfaceParams::CreateForFermiCopySurface(dst_config);
|
const auto& dst_params = SurfaceParams::CreateForFermiCopySurface(dst_config);
|
||||||
|
|
|
@ -28,7 +28,7 @@ namespace OpenGL {
|
||||||
|
|
||||||
class CachedSurface;
|
class CachedSurface;
|
||||||
using Surface = std::shared_ptr<CachedSurface>;
|
using Surface = std::shared_ptr<CachedSurface>;
|
||||||
using SurfaceSurfaceRect_Tuple = std::tuple<Surface, Surface, MathUtil::Rectangle<u32>>;
|
using SurfaceSurfaceRect_Tuple = std::tuple<Surface, Surface, Common::Rectangle<u32>>;
|
||||||
|
|
||||||
using SurfaceTarget = VideoCore::Surface::SurfaceTarget;
|
using SurfaceTarget = VideoCore::Surface::SurfaceTarget;
|
||||||
using SurfaceType = VideoCore::Surface::SurfaceType;
|
using SurfaceType = VideoCore::Surface::SurfaceType;
|
||||||
|
@ -71,7 +71,7 @@ struct SurfaceParams {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Returns the rectangle corresponding to this surface
|
/// Returns the rectangle corresponding to this surface
|
||||||
MathUtil::Rectangle<u32> GetRect(u32 mip_level = 0) const;
|
Common::Rectangle<u32> GetRect(u32 mip_level = 0) const;
|
||||||
|
|
||||||
/// Returns the total size of this surface in bytes, adjusted for compression
|
/// Returns the total size of this surface in bytes, adjusted for compression
|
||||||
std::size_t SizeInBytesRaw(bool ignore_tiled = false) const {
|
std::size_t SizeInBytesRaw(bool ignore_tiled = false) const {
|
||||||
|
@ -430,8 +430,8 @@ public:
|
||||||
/// Copies the contents of one surface to another
|
/// Copies the contents of one surface to another
|
||||||
void FermiCopySurface(const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
|
void FermiCopySurface(const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
|
||||||
const Tegra::Engines::Fermi2D::Regs::Surface& dst_config,
|
const Tegra::Engines::Fermi2D::Regs::Surface& dst_config,
|
||||||
const MathUtil::Rectangle<u32>& src_rect,
|
const Common::Rectangle<u32>& src_rect,
|
||||||
const MathUtil::Rectangle<u32>& dst_rect);
|
const Common::Rectangle<u32>& dst_rect);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void LoadSurface(const Surface& surface);
|
void LoadSurface(const Surface& surface);
|
||||||
|
|
|
@ -39,7 +39,7 @@ struct TextureInfo {
|
||||||
/// Structure used for storing information about the display target for the Switch screen
|
/// Structure used for storing information about the display target for the Switch screen
|
||||||
struct ScreenInfo {
|
struct ScreenInfo {
|
||||||
GLuint display_texture;
|
GLuint display_texture;
|
||||||
const MathUtil::Rectangle<float> display_texcoords{0.0f, 0.0f, 1.0f, 1.0f};
|
const Common::Rectangle<float> display_texcoords{0.0f, 0.0f, 1.0f, 1.0f};
|
||||||
TextureInfo texture;
|
TextureInfo texture;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
@ -102,7 +102,7 @@ private:
|
||||||
|
|
||||||
/// Used for transforming the framebuffer orientation
|
/// Used for transforming the framebuffer orientation
|
||||||
Tegra::FramebufferConfig::TransformFlags framebuffer_transform_flags;
|
Tegra::FramebufferConfig::TransformFlags framebuffer_transform_flags;
|
||||||
MathUtil::Rectangle<int> framebuffer_crop_rect;
|
Common::Rectangle<int> framebuffer_crop_rect;
|
||||||
};
|
};
|
||||||
|
|
||||||
} // namespace OpenGL
|
} // namespace OpenGL
|
||||||
|
|
|
@ -398,7 +398,7 @@ void GraphicsSurfaceWidget::OnUpdate() {
|
||||||
|
|
||||||
for (unsigned int y = 0; y < surface_height; ++y) {
|
for (unsigned int y = 0; y < surface_height; ++y) {
|
||||||
for (unsigned int x = 0; x < surface_width; ++x) {
|
for (unsigned int x = 0; x < surface_width; ++x) {
|
||||||
Math::Vec4<u8> color;
|
Common::Vec4<u8> color;
|
||||||
color[0] = texture_data[x + y * surface_width + 0];
|
color[0] = texture_data[x + y * surface_width + 0];
|
||||||
color[1] = texture_data[x + y * surface_width + 1];
|
color[1] = texture_data[x + y * surface_width + 1];
|
||||||
color[2] = texture_data[x + y * surface_width + 2];
|
color[2] = texture_data[x + y * surface_width + 2];
|
||||||
|
|
Loading…
Reference in a new issue