diff options
47 files changed, 1758 insertions, 207 deletions
diff --git a/externals/CMakeLists.txt b/externals/CMakeLists.txt index f2a560f04..e59eeb489 100644 --- a/externals/CMakeLists.txt +++ b/externals/CMakeLists.txt @@ -139,3 +139,7 @@ if (NOT TARGET LLVM::Demangle) target_sources(demangle PRIVATE demangle/ItaniumDemangle.cpp) add_library(LLVM::Demangle ALIAS demangle) endif() + +add_library(stb STATIC) +target_include_directories(stb PUBLIC ./stb) +target_sources(stb PRIVATE stb/stb_dxt.cpp) diff --git a/externals/cubeb b/externals/cubeb -Subproject 75d9d125ee655ef80f3bfcd97ae5a805931042b +Subproject 48689ae7a73caeb747953f9ed664dc71d2f918d diff --git a/externals/stb/stb_dxt.cpp b/externals/stb/stb_dxt.cpp new file mode 100644 index 000000000..64f1f3d03 --- /dev/null +++ b/externals/stb/stb_dxt.cpp @@ -0,0 +1,765 @@ +// SPDX-FileCopyrightText: fabian "ryg" giesen +// SPDX-License-Identifier: MIT + +// stb_dxt.h - v1.12 - DXT1/DXT5 compressor + +#include <stb_dxt.h> + +#include <stdlib.h> +#include <string.h> + +#if !defined(STBD_FABS) +#include <math.h> +#endif + +#ifndef STBD_FABS +#define STBD_FABS(x) fabs(x) +#endif + +static const unsigned char stb__OMatch5[256][2] = { + {0, 0}, {0, 0}, {0, 1}, {0, 1}, {1, 0}, {1, 0}, {1, 0}, {1, 1}, {1, 1}, + {1, 1}, {1, 2}, {0, 4}, {2, 1}, {2, 1}, {2, 1}, {2, 2}, {2, 2}, {2, 2}, + {2, 3}, {1, 5}, {3, 2}, {3, 2}, {4, 0}, {3, 3}, {3, 3}, {3, 3}, {3, 4}, + {3, 4}, {3, 4}, {3, 5}, {4, 3}, {4, 3}, {5, 2}, {4, 4}, {4, 4}, {4, 5}, + {4, 5}, {5, 4}, {5, 4}, {5, 4}, {6, 3}, {5, 5}, {5, 5}, {5, 6}, {4, 8}, + {6, 5}, {6, 5}, {6, 5}, {6, 6}, {6, 6}, {6, 6}, {6, 7}, {5, 9}, {7, 6}, + {7, 6}, {8, 4}, {7, 7}, {7, 7}, {7, 7}, {7, 8}, {7, 8}, {7, 8}, {7, 9}, + {8, 7}, {8, 7}, {9, 6}, {8, 8}, {8, 8}, {8, 9}, {8, 9}, {9, 8}, {9, 8}, + {9, 8}, {10, 7}, {9, 9}, {9, 9}, {9, 10}, {8, 12}, {10, 9}, {10, 9}, {10, 9}, + {10, 10}, {10, 10}, {10, 10}, {10, 11}, {9, 13}, {11, 10}, {11, 10}, {12, 8}, {11, 11}, + {11, 11}, {11, 11}, {11, 12}, {11, 12}, {11, 12}, {11, 13}, {12, 11}, {12, 11}, {13, 10}, + {12, 12}, {12, 12}, {12, 13}, {12, 13}, {13, 12}, {13, 12}, {13, 12}, {14, 11}, {13, 13}, + {13, 13}, {13, 14}, {12, 16}, {14, 13}, {14, 13}, {14, 13}, {14, 14}, {14, 14}, {14, 14}, + {14, 15}, {13, 17}, {15, 14}, {15, 14}, {16, 12}, {15, 15}, {15, 15}, {15, 15}, {15, 16}, + {15, 16}, {15, 16}, {15, 17}, {16, 15}, {16, 15}, {17, 14}, {16, 16}, {16, 16}, {16, 17}, + {16, 17}, {17, 16}, {17, 16}, {17, 16}, {18, 15}, {17, 17}, {17, 17}, {17, 18}, {16, 20}, + {18, 17}, {18, 17}, {18, 17}, {18, 18}, {18, 18}, {18, 18}, {18, 19}, {17, 21}, {19, 18}, + {19, 18}, {20, 16}, {19, 19}, {19, 19}, {19, 19}, {19, 20}, {19, 20}, {19, 20}, {19, 21}, + {20, 19}, {20, 19}, {21, 18}, {20, 20}, {20, 20}, {20, 21}, {20, 21}, {21, 20}, {21, 20}, + {21, 20}, {22, 19}, {21, 21}, {21, 21}, {21, 22}, {20, 24}, {22, 21}, {22, 21}, {22, 21}, + {22, 22}, {22, 22}, {22, 22}, {22, 23}, {21, 25}, {23, 22}, {23, 22}, {24, 20}, {23, 23}, + {23, 23}, {23, 23}, {23, 24}, {23, 24}, {23, 24}, {23, 25}, {24, 23}, {24, 23}, {25, 22}, + {24, 24}, {24, 24}, {24, 25}, {24, 25}, {25, 24}, {25, 24}, {25, 24}, {26, 23}, {25, 25}, + {25, 25}, {25, 26}, {24, 28}, {26, 25}, {26, 25}, {26, 25}, {26, 26}, {26, 26}, {26, 26}, + {26, 27}, {25, 29}, {27, 26}, {27, 26}, {28, 24}, {27, 27}, {27, 27}, {27, 27}, {27, 28}, + {27, 28}, {27, 28}, {27, 29}, {28, 27}, {28, 27}, {29, 26}, {28, 28}, {28, 28}, {28, 29}, + {28, 29}, {29, 28}, {29, 28}, {29, 28}, {30, 27}, {29, 29}, {29, 29}, {29, 30}, {29, 30}, + {30, 29}, {30, 29}, {30, 29}, {30, 30}, {30, 30}, {30, 30}, {30, 31}, {30, 31}, {31, 30}, + {31, 30}, {31, 30}, {31, 31}, {31, 31}, +}; +static const unsigned char stb__OMatch6[256][2] = { + {0, 0}, {0, 1}, {1, 0}, {1, 1}, {1, 1}, {1, 2}, {2, 1}, {2, 2}, {2, 2}, + {2, 3}, {3, 2}, {3, 3}, {3, 3}, {3, 4}, {4, 3}, {4, 4}, {4, 4}, {4, 5}, + {5, 4}, {5, 5}, {5, 5}, {5, 6}, {6, 5}, {6, 6}, {6, 6}, {6, 7}, {7, 6}, + {7, 7}, {7, 7}, {7, 8}, {8, 7}, {8, 8}, {8, 8}, {8, 9}, {9, 8}, {9, 9}, + {9, 9}, {9, 10}, {10, 9}, {10, 10}, {10, 10}, {10, 11}, {11, 10}, {8, 16}, {11, 11}, + {11, 12}, {12, 11}, {9, 17}, {12, 12}, {12, 13}, {13, 12}, {11, 16}, {13, 13}, {13, 14}, + {14, 13}, {12, 17}, {14, 14}, {14, 15}, {15, 14}, {14, 16}, {15, 15}, {15, 16}, {16, 14}, + {16, 15}, {17, 14}, {16, 16}, {16, 17}, {17, 16}, {18, 15}, {17, 17}, {17, 18}, {18, 17}, + {20, 14}, {18, 18}, {18, 19}, {19, 18}, {21, 15}, {19, 19}, {19, 20}, {20, 19}, {20, 20}, + {20, 20}, {20, 21}, {21, 20}, {21, 21}, {21, 21}, {21, 22}, {22, 21}, {22, 22}, {22, 22}, + {22, 23}, {23, 22}, {23, 23}, {23, 23}, {23, 24}, {24, 23}, {24, 24}, {24, 24}, {24, 25}, + {25, 24}, {25, 25}, {25, 25}, {25, 26}, {26, 25}, {26, 26}, {26, 26}, {26, 27}, {27, 26}, + {24, 32}, {27, 27}, {27, 28}, {28, 27}, {25, 33}, {28, 28}, {28, 29}, {29, 28}, {27, 32}, + {29, 29}, {29, 30}, {30, 29}, {28, 33}, {30, 30}, {30, 31}, {31, 30}, {30, 32}, {31, 31}, + {31, 32}, {32, 30}, {32, 31}, {33, 30}, {32, 32}, {32, 33}, {33, 32}, {34, 31}, {33, 33}, + {33, 34}, {34, 33}, {36, 30}, {34, 34}, {34, 35}, {35, 34}, {37, 31}, {35, 35}, {35, 36}, + {36, 35}, {36, 36}, {36, 36}, {36, 37}, {37, 36}, {37, 37}, {37, 37}, {37, 38}, {38, 37}, + {38, 38}, {38, 38}, {38, 39}, {39, 38}, {39, 39}, {39, 39}, {39, 40}, {40, 39}, {40, 40}, + {40, 40}, {40, 41}, {41, 40}, {41, 41}, {41, 41}, {41, 42}, {42, 41}, {42, 42}, {42, 42}, + {42, 43}, {43, 42}, {40, 48}, {43, 43}, {43, 44}, {44, 43}, {41, 49}, {44, 44}, {44, 45}, + {45, 44}, {43, 48}, {45, 45}, {45, 46}, {46, 45}, {44, 49}, {46, 46}, {46, 47}, {47, 46}, + {46, 48}, {47, 47}, {47, 48}, {48, 46}, {48, 47}, {49, 46}, {48, 48}, {48, 49}, {49, 48}, + {50, 47}, {49, 49}, {49, 50}, {50, 49}, {52, 46}, {50, 50}, {50, 51}, {51, 50}, {53, 47}, + {51, 51}, {51, 52}, {52, 51}, {52, 52}, {52, 52}, {52, 53}, {53, 52}, {53, 53}, {53, 53}, + {53, 54}, {54, 53}, {54, 54}, {54, 54}, {54, 55}, {55, 54}, {55, 55}, {55, 55}, {55, 56}, + {56, 55}, {56, 56}, {56, 56}, {56, 57}, {57, 56}, {57, 57}, {57, 57}, {57, 58}, {58, 57}, + {58, 58}, {58, 58}, {58, 59}, {59, 58}, {59, 59}, {59, 59}, {59, 60}, {60, 59}, {60, 60}, + {60, 60}, {60, 61}, {61, 60}, {61, 61}, {61, 61}, {61, 62}, {62, 61}, {62, 62}, {62, 62}, + {62, 63}, {63, 62}, {63, 63}, {63, 63}, +}; + +static int stb__Mul8Bit(int a, int b) { + int t = a * b + 128; + return (t + (t >> 8)) >> 8; +} + +static void stb__From16Bit(unsigned char* out, unsigned short v) { + int rv = (v & 0xf800) >> 11; + int gv = (v & 0x07e0) >> 5; + int bv = (v & 0x001f) >> 0; + + // expand to 8 bits via bit replication + out[0] = static_cast<unsigned char>((rv * 33) >> 2); + out[1] = static_cast<unsigned char>((gv * 65) >> 4); + out[2] = static_cast<unsigned char>((bv * 33) >> 2); + out[3] = 0; +} + +static unsigned short stb__As16Bit(int r, int g, int b) { + return (unsigned short)((stb__Mul8Bit(r, 31) << 11) + (stb__Mul8Bit(g, 63) << 5) + + stb__Mul8Bit(b, 31)); +} + +// linear interpolation at 1/3 point between a and b, using desired rounding +// type +static int stb__Lerp13(int a, int b) { +#ifdef STB_DXT_USE_ROUNDING_BIAS + // with rounding bias + return a + stb__Mul8Bit(b - a, 0x55); +#else + // without rounding bias + // replace "/ 3" by "* 0xaaab) >> 17" if your compiler sucks or you really + // need every ounce of speed. + return (2 * a + b) / 3; +#endif +} + +// linear interpolation at 1/2 point between a and b +static int stb__Lerp12(int a, int b) { + return (a + b) / 2; +} + +// lerp RGB color +static void stb__Lerp13RGB(unsigned char* out, unsigned char* p1, unsigned char* p2) { + out[0] = (unsigned char)stb__Lerp13(p1[0], p2[0]); + out[1] = (unsigned char)stb__Lerp13(p1[1], p2[1]); + out[2] = (unsigned char)stb__Lerp13(p1[2], p2[2]); +} + +static void stb__Lerp12RGB(unsigned char* out, unsigned char* p1, unsigned char* p2) { + out[0] = (unsigned char)stb__Lerp12(p1[0], p2[0]); + out[1] = (unsigned char)stb__Lerp12(p1[1], p2[1]); + out[2] = (unsigned char)stb__Lerp12(p1[2], p2[2]); +} + +/****************************************************************************/ + +static void stb__Eval4Colors(unsigned char* color, unsigned short c0, unsigned short c1) { + stb__From16Bit(color + 0, c0); + stb__From16Bit(color + 4, c1); + stb__Lerp13RGB(color + 8, color + 0, color + 4); + stb__Lerp13RGB(color + 12, color + 4, color + 0); +} + +static void stb__Eval3Colors(unsigned char* color, unsigned short c0, unsigned short c1) { + stb__From16Bit(color + 0, c0); + stb__From16Bit(color + 4, c1); + stb__Lerp12RGB(color + 8, color + 0, color + 4); +} + +// The color matching function +static unsigned int stb__MatchColorsBlock(unsigned char* block, unsigned char* color) { + unsigned int mask = 0; + int dirr = color[0 * 4 + 0] - color[1 * 4 + 0]; + int dirg = color[0 * 4 + 1] - color[1 * 4 + 1]; + int dirb = color[0 * 4 + 2] - color[1 * 4 + 2]; + int dots[16]; + int stops[4]; + int i; + int c0Point, halfPoint, c3Point; + + for (i = 0; i < 16; i++) + dots[i] = block[i * 4 + 0] * dirr + block[i * 4 + 1] * dirg + block[i * 4 + 2] * dirb; + + for (i = 0; i < 4; i++) + stops[i] = color[i * 4 + 0] * dirr + color[i * 4 + 1] * dirg + color[i * 4 + 2] * dirb; + + // think of the colors as arranged on a line; project point onto that line, + // then choose next color out of available ones. we compute the crossover + // points for "best color in top half"/"best in bottom half" and then the same + // inside that subinterval. + // + // relying on this 1d approximation isn't always optimal in terms of euclidean + // distance, but it's very close and a lot faster. + // http://cbloomrants.blogspot.com/2008/12/12-08-08-dxtc-summary.html + + c0Point = (stops[1] + stops[3]); + halfPoint = (stops[3] + stops[2]); + c3Point = (stops[2] + stops[0]); + + for (i = 15; i >= 0; i--) { + int dot = dots[i] * 2; + mask <<= 2; + + if (dot < halfPoint) + mask |= (dot < c0Point) ? 1 : 3; + else + mask |= (dot < c3Point) ? 2 : 0; + } + + return mask; +} + +static unsigned int stb__MatchColorsAlphaBlock(unsigned char* block, unsigned char* color) { + unsigned int mask = 0; + int dirr = color[0 * 4 + 0] - color[1 * 4 + 0]; + int dirg = color[0 * 4 + 1] - color[1 * 4 + 1]; + int dirb = color[0 * 4 + 2] - color[1 * 4 + 2]; + int dots[16]; + int stops[3]; + int i; + int c0Point, c2Point; + + for (i = 0; i < 16; i++) + dots[i] = block[i * 4 + 0] * dirr + block[i * 4 + 1] * dirg + block[i * 4 + 2] * dirb; + + for (i = 0; i < 3; i++) + stops[i] = color[i * 4 + 0] * dirr + color[i * 4 + 1] * dirg + color[i * 4 + 2] * dirb; + + c0Point = (stops[1] + stops[2]); + c2Point = (stops[2] + stops[0]); + + for (i = 15; i >= 0; i--) { + int dot = dots[i] * 2; + mask <<= 2; + + if (block[i * 4 + 3] == 0) + mask |= 3; + else if (dot < c2Point) + mask |= (dot < c0Point) ? 0 : 2; + else + mask |= (dot < c0Point) ? 1 : 0; + } + + return mask; +} + +static void stb__ReorderColors(unsigned short* pmax16, unsigned short* pmin16) { + if (*pmin16 < *pmax16) { + unsigned short t = *pmin16; + *pmin16 = *pmax16; + *pmax16 = t; + } +} + +static void stb__FinalizeColors(unsigned short* pmax16, unsigned short* pmin16, + unsigned int* pmask) { + if (*pmax16 < *pmin16) { + unsigned short t = *pmin16; + *pmin16 = *pmax16; + *pmax16 = t; + *pmask ^= 0x55555555; + } +} + +// The color optimization function. (Clever code, part 1) +static void stb__OptimizeColorsBlock(unsigned char* block, unsigned short* pmax16, + unsigned short* pmin16) { + int mind, maxd; + unsigned char *minp, *maxp; + double magn; + int v_r, v_g, v_b; + static const int nIterPower = 4; + float covf[6], vfr, vfg, vfb; + + // determine color distribution + int cov[6]; + int mu[3], min[3], max[3]; + int ch, i, iter; + + for (ch = 0; ch < 3; ch++) { + const unsigned char* bp = ((const unsigned char*)block) + ch; + int muv, minv, maxv; + + muv = minv = maxv = bp[0]; + for (i = 4; i < 64; i += 4) { + muv += bp[i]; + if (bp[i] < minv) + minv = bp[i]; + else if (bp[i] > maxv) + maxv = bp[i]; + } + + mu[ch] = (muv + 8) >> 4; + min[ch] = minv; + max[ch] = maxv; + } + + // determine covariance matrix + for (i = 0; i < 6; i++) + cov[i] = 0; + + for (i = 0; i < 16; i++) { + int r = block[i * 4 + 0] - mu[0]; + int g = block[i * 4 + 1] - mu[1]; + int b = block[i * 4 + 2] - mu[2]; + + cov[0] += r * r; + cov[1] += r * g; + cov[2] += r * b; + cov[3] += g * g; + cov[4] += g * b; + cov[5] += b * b; + } + + // convert covariance matrix to float, find principal axis via power iter + for (i = 0; i < 6; i++) + covf[i] = static_cast<float>(cov[i]) / 255.0f; + + vfr = (float)(max[0] - min[0]); + vfg = (float)(max[1] - min[1]); + vfb = (float)(max[2] - min[2]); + + for (iter = 0; iter < nIterPower; iter++) { + float r = vfr * covf[0] + vfg * covf[1] + vfb * covf[2]; + float g = vfr * covf[1] + vfg * covf[3] + vfb * covf[4]; + float b = vfr * covf[2] + vfg * covf[4] + vfb * covf[5]; + + vfr = r; + vfg = g; + vfb = b; + } + + magn = STBD_FABS(vfr); + if (STBD_FABS(vfg) > magn) + magn = STBD_FABS(vfg); + if (STBD_FABS(vfb) > magn) + magn = STBD_FABS(vfb); + + if (magn < 4.0f) { // too small, default to luminance + v_r = 299; // JPEG YCbCr luma coefs, scaled by 1000. + v_g = 587; + v_b = 114; + } else { + magn = 512.0 / magn; + v_r = (int)(vfr * magn); + v_g = (int)(vfg * magn); + v_b = (int)(vfb * magn); + } + + minp = maxp = block; + mind = maxd = block[0] * v_r + block[1] * v_g + block[2] * v_b; + // Pick colors at extreme points + for (i = 1; i < 16; i++) { + int dot = block[i * 4 + 0] * v_r + block[i * 4 + 1] * v_g + block[i * 4 + 2] * v_b; + + if (dot < mind) { + mind = dot; + minp = block + i * 4; + } + + if (dot > maxd) { + maxd = dot; + maxp = block + i * 4; + } + } + + *pmax16 = stb__As16Bit(maxp[0], maxp[1], maxp[2]); + *pmin16 = stb__As16Bit(minp[0], minp[1], minp[2]); + stb__ReorderColors(pmax16, pmin16); +} + +static void stb__OptimizeColorsAlphaBlock(unsigned char* block, unsigned short* pmax16, + unsigned short* pmin16) { + int mind, maxd; + unsigned char *minp, *maxp; + double magn; + int v_r, v_g, v_b; + static const int nIterPower = 4; + float covf[6], vfr, vfg, vfb; + + // determine color distribution + int cov[6]; + int mu[3], min[3], max[3]; + int ch, i, iter; + + for (ch = 0; ch < 3; ch++) { + const unsigned char* bp = ((const unsigned char*)block) + ch; + int muv = 0, minv = 256, maxv = -1; + int num = 0; + + for (i = 0; i < 64; i += 4) { + if (bp[3 - ch] == 0) { + continue; + } + + muv += bp[i]; + if (bp[i] < minv) + minv = bp[i]; + else if (bp[i] > maxv) + maxv = bp[i]; + + num++; + } + + mu[ch] = num > 0 ? (muv + 8) / num : 0; + min[ch] = minv; + max[ch] = maxv; + } + + // determine covariance matrix + for (i = 0; i < 6; i++) + cov[i] = 0; + + for (i = 0; i < 16; i++) { + if (block[i * 4 + 3] == 0) { + continue; + } + + int r = block[i * 4 + 0] - mu[0]; + int g = block[i * 4 + 1] - mu[1]; + int b = block[i * 4 + 2] - mu[2]; + + cov[0] += r * r; + cov[1] += r * g; + cov[2] += r * b; + cov[3] += g * g; + cov[4] += g * b; + cov[5] += b * b; + } + + // convert covariance matrix to float, find principal axis via power iter + for (i = 0; i < 6; i++) + covf[i] = static_cast<float>(cov[i]) / 255.0f; + + vfr = (float)(max[0] - min[0]); + vfg = (float)(max[1] - min[1]); + vfb = (float)(max[2] - min[2]); + + for (iter = 0; iter < nIterPower; iter++) { + float r = vfr * covf[0] + vfg * covf[1] + vfb * covf[2]; + float g = vfr * covf[1] + vfg * covf[3] + vfb * covf[4]; + float b = vfr * covf[2] + vfg * covf[4] + vfb * covf[5]; + + vfr = r; + vfg = g; + vfb = b; + } + + magn = STBD_FABS(vfr); + if (STBD_FABS(vfg) > magn) + magn = STBD_FABS(vfg); + if (STBD_FABS(vfb) > magn) + magn = STBD_FABS(vfb); + + if (magn < 4.0f) { // too small, default to luminance + v_r = 299; // JPEG YCbCr luma coefs, scaled by 1000. + v_g = 587; + v_b = 114; + } else { + magn = 512.0 / magn; + v_r = (int)(vfr * magn); + v_g = (int)(vfg * magn); + v_b = (int)(vfb * magn); + } + + minp = maxp = NULL; + mind = 0x7fffffff; + maxd = -0x80000000; + + // Pick colors at extreme points + for (i = 0; i < 16; i++) { + if (block[i * 4 + 3] == 0) { + continue; + } + + int dot = block[i * 4 + 0] * v_r + block[i * 4 + 1] * v_g + block[i * 4 + 2] * v_b; + + if (dot < mind) { + mind = dot; + minp = block + i * 4; + } + + if (dot > maxd) { + maxd = dot; + maxp = block + i * 4; + } + } + + if (!maxp) { + // all alpha, no color + *pmin16 = 0xffff; + *pmax16 = 0; + } else { + // endpoint colors found + *pmax16 = stb__As16Bit(maxp[0], maxp[1], maxp[2]); + *pmin16 = stb__As16Bit(minp[0], minp[1], minp[2]); + + if (*pmax16 == *pmin16) { + // modify the endpoints to indicate presence of an alpha block + if (*pmax16 > 0) { + (*pmax16)--; + } else { + (*pmin16)++; + } + } + + stb__ReorderColors(pmax16, pmin16); + } +} + +static const float stb__midpoints5[32] = { + 0.015686f, 0.047059f, 0.078431f, 0.111765f, 0.145098f, 0.176471f, 0.207843f, 0.241176f, + 0.274510f, 0.305882f, 0.337255f, 0.370588f, 0.403922f, 0.435294f, 0.466667f, 0.5f, + 0.533333f, 0.564706f, 0.596078f, 0.629412f, 0.662745f, 0.694118f, 0.725490f, 0.758824f, + 0.792157f, 0.823529f, 0.854902f, 0.888235f, 0.921569f, 0.952941f, 0.984314f, 1.0f}; + +static const float stb__midpoints6[64] = { + 0.007843f, 0.023529f, 0.039216f, 0.054902f, 0.070588f, 0.086275f, 0.101961f, 0.117647f, + 0.133333f, 0.149020f, 0.164706f, 0.180392f, 0.196078f, 0.211765f, 0.227451f, 0.245098f, + 0.262745f, 0.278431f, 0.294118f, 0.309804f, 0.325490f, 0.341176f, 0.356863f, 0.372549f, + 0.388235f, 0.403922f, 0.419608f, 0.435294f, 0.450980f, 0.466667f, 0.482353f, 0.500000f, + 0.517647f, 0.533333f, 0.549020f, 0.564706f, 0.580392f, 0.596078f, 0.611765f, 0.627451f, + 0.643137f, 0.658824f, 0.674510f, 0.690196f, 0.705882f, 0.721569f, 0.737255f, 0.754902f, + 0.772549f, 0.788235f, 0.803922f, 0.819608f, 0.835294f, 0.850980f, 0.866667f, 0.882353f, + 0.898039f, 0.913725f, 0.929412f, 0.945098f, 0.960784f, 0.976471f, 0.992157f, 1.0f}; + +static unsigned short stb__Quantize5(float x) { + unsigned short q; + x = x < 0 ? 0 : x > 1 ? 1 : x; // saturate + q = (unsigned short)(x * 31); + q += (x > stb__midpoints5[q]); + return q; +} + +static unsigned short stb__Quantize6(float x) { + unsigned short q; + x = x < 0 ? 0 : x > 1 ? 1 : x; // saturate + q = (unsigned short)(x * 63); + q += (x > stb__midpoints6[q]); + return q; +} + +// The refinement function. (Clever code, part 2) +// Tries to optimize colors to suit block contents better. +// (By solving a least squares system via normal equations+Cramer's rule) +static int stb__RefineBlock(unsigned char* block, unsigned short* pmax16, unsigned short* pmin16, + unsigned int mask) { + static const int w1Tab[4] = {3, 0, 2, 1}; + static const int prods[4] = {0x090000, 0x000900, 0x040102, 0x010402}; + // ^some magic to save a lot of multiplies in the accumulating loop... + // (precomputed products of weights for least squares system, accumulated + // inside one 32-bit register) + + float f; + unsigned short oldMin, oldMax, min16, max16; + int i, akku = 0, xx, xy, yy; + int At1_r, At1_g, At1_b; + int At2_r, At2_g, At2_b; + unsigned int cm = mask; + + oldMin = *pmin16; + oldMax = *pmax16; + + if ((mask ^ (mask << 2)) < 4) // all pixels have the same index? + { + // yes, linear system would be singular; solve using optimal + // single-color match on average color + int r = 8, g = 8, b = 8; + for (i = 0; i < 16; ++i) { + r += block[i * 4 + 0]; + g += block[i * 4 + 1]; + b += block[i * 4 + 2]; + } + + r >>= 4; + g >>= 4; + b >>= 4; + + max16 = static_cast<unsigned short>((stb__OMatch5[r][0] << 11) | (stb__OMatch6[g][0] << 5) | + stb__OMatch5[b][0]); + min16 = static_cast<unsigned short>((stb__OMatch5[r][1] << 11) | (stb__OMatch6[g][1] << 5) | + stb__OMatch5[b][1]); + } else { + At1_r = At1_g = At1_b = 0; + At2_r = At2_g = At2_b = 0; + for (i = 0; i < 16; ++i, cm >>= 2) { + int step = cm & 3; + int w1 = w1Tab[step]; + int r = block[i * 4 + 0]; + int g = block[i * 4 + 1]; + int b = block[i * 4 + 2]; + + akku += prods[step]; + At1_r += w1 * r; + At1_g += w1 * g; + At1_b += w1 * b; + At2_r += r; + At2_g += g; + At2_b += b; + } + + At2_r = 3 * At2_r - At1_r; + At2_g = 3 * At2_g - At1_g; + At2_b = 3 * At2_b - At1_b; + + // extract solutions and decide solvability + xx = akku >> 16; + yy = (akku >> 8) & 0xff; + xy = (akku >> 0) & 0xff; + + f = 3.0f / 255.0f / static_cast<float>(xx * yy - xy * xy); + + max16 = static_cast<unsigned short>( + stb__Quantize5(static_cast<float>(At1_r * yy - At2_r * xy) * f) << 11); + max16 |= static_cast<unsigned short>( + stb__Quantize6(static_cast<float>(At1_g * yy - At2_g * xy) * f) << 5); + max16 |= static_cast<unsigned short>( + stb__Quantize5(static_cast<float>(At1_b * yy - At2_b * xy) * f) << 0); + + min16 = static_cast<unsigned short>( + stb__Quantize5(static_cast<float>(At2_r * xx - At1_r * xy) * f) << 11); + min16 |= static_cast<unsigned short>( + stb__Quantize6(static_cast<float>(At2_g * xx - At1_g * xy) * f) << 5); + min16 |= static_cast<unsigned short>( + stb__Quantize5(static_cast<float>(At2_b * xx - At1_b * xy) * f) << 0); + } + + *pmin16 = min16; + *pmax16 = max16; + stb__ReorderColors(pmax16, pmin16); + + return oldMin != min16 || oldMax != max16; +} + +// Color block compression +static void stb__CompressColorBlock(unsigned char* dest, unsigned char* block, int alpha, + int mode) { + unsigned int mask; + int i; + int refinecount; + unsigned short max16, min16; + unsigned char color[4 * 4]; + + refinecount = (mode & STB_DXT_HIGHQUAL) ? 2 : 1; + + // check if block is constant + for (i = 1; i < 16; i++) + if (((unsigned int*)block)[i] != ((unsigned int*)block)[0]) + break; + + if (i == 16 && block[3] == 0 && alpha) { // constant alpha + mask = 0xffffffff; + max16 = 0; + min16 = 0xffff; + } else if (i == 16) { // constant color + int r = block[0], g = block[1], b = block[2]; + mask = 0xaaaaaaaa; + max16 = static_cast<unsigned short>((stb__OMatch5[r][0] << 11) | (stb__OMatch6[g][0] << 5) | + stb__OMatch5[b][0]); + min16 = static_cast<unsigned short>((stb__OMatch5[r][1] << 11) | (stb__OMatch6[g][1] << 5) | + stb__OMatch5[b][1]); + } else if (alpha) { + stb__OptimizeColorsAlphaBlock(block, &max16, &min16); + stb__Eval3Colors(color, max16, min16); + mask = stb__MatchColorsAlphaBlock(block, color); + } else { + // first step: PCA+map along principal axis + stb__OptimizeColorsBlock(block, &max16, &min16); + if (max16 != min16) { + stb__Eval4Colors(color, max16, min16); + mask = stb__MatchColorsBlock(block, color); + } else + mask = 0; + + // third step: refine (multiple times if requested) + for (i = 0; i < refinecount; i++) { + unsigned int lastmask = mask; + + if (stb__RefineBlock(block, &max16, &min16, mask)) { + if (max16 != min16) { + stb__Eval4Colors(color, max16, min16); + mask = stb__MatchColorsBlock(block, color); + } else { + mask = 0; + break; + } + } + + if (mask == lastmask) + break; + } + } + + // write the color block + if (!alpha) + stb__FinalizeColors(&max16, &min16, &mask); + + dest[0] = (unsigned char)(max16); + dest[1] = (unsigned char)(max16 >> 8); + dest[2] = (unsigned char)(min16); + dest[3] = (unsigned char)(min16 >> 8); + dest[4] = (unsigned char)(mask); + dest[5] = (unsigned char)(mask >> 8); + dest[6] = (unsigned char)(mask >> 16); + dest[7] = (unsigned char)(mask >> 24); +} + +// Alpha block compression (this is easy for a change) +static void stb__CompressAlphaBlock(unsigned char* dest, unsigned char* src, int stride) { + int i, dist, bias, dist4, dist2, bits, mask; + + // find min/max color + int mn, mx; + mn = mx = src[0]; + + for (i = 1; i < 16; i++) { + if (src[i * stride] < mn) + mn = src[i * stride]; + else if (src[i * stride] > mx) + mx = src[i * stride]; + } + + // encode them + dest[0] = (unsigned char)mx; + dest[1] = (unsigned char)mn; + dest += 2; + + // determine bias and emit color indices + // given the choice of mx/mn, these indices are optimal: + // http://fgiesen.wordpress.com/2009/12/15/dxt5-alpha-block-index-determination/ + dist = mx - mn; + dist4 = dist * 4; + dist2 = dist * 2; + bias = (dist < 8) ? (dist - 1) : (dist / 2 + 2); + bias -= mn * 7; + bits = 0, mask = 0; + + for (i = 0; i < 16; i++) { + int a = src[i * stride] * 7 + bias; + int ind, t; + + // select index. this is a "linear scale" lerp factor between 0 (val=min) + // and 7 (val=max). + t = (a >= dist4) ? -1 : 0; + ind = t & 4; + a -= dist4 & t; + t = (a >= dist2) ? -1 : 0; + ind += t & 2; + a -= dist2 & t; + ind += (a >= dist); + + // turn linear scale into DXT index (0/1 are extremal pts) + ind = -ind & 7; + ind ^= (2 > ind); + + // write index + mask |= ind << bits; + if ((bits += 3) >= 8) { + *dest++ = (unsigned char)mask; + mask >>= 8; + bits -= 8; + } + } +} + +void stb_compress_bc1_block(unsigned char* dest, const unsigned char* src, int alpha, int mode) { + stb__CompressColorBlock(dest, (unsigned char*)src, alpha, mode); +} + +void stb_compress_bc3_block(unsigned char* dest, const unsigned char* src, int mode) { + unsigned char data[16][4]; + int i; + + stb__CompressAlphaBlock(dest, (unsigned char*)src + 3, 4); + dest += 8; + // make a new copy of the data in which alpha is opaque, + // because code uses a fast test for color constancy + memcpy(data, src, 4 * 16); + for (i = 0; i < 16; ++i) + data[i][3] = 255; + src = &data[0][0]; + + stb__CompressColorBlock(dest, (unsigned char*)src, 0, mode); +} diff --git a/externals/stb/stb_dxt.h b/externals/stb/stb_dxt.h new file mode 100644 index 000000000..07d1d1de4 --- /dev/null +++ b/externals/stb/stb_dxt.h @@ -0,0 +1,36 @@ +// SPDX-FileCopyrightText: fabian "ryg" giesen +// SPDX-License-Identifier: MIT + +// stb_dxt.h - v1.12 - DXT1/DXT5 compressor + +#ifndef STB_INCLUDE_STB_DXT_H +#define STB_INCLUDE_STB_DXT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef STB_DXT_STATIC +#define STBDDEF static +#else +#define STBDDEF extern +#endif + +// compression mode (bitflags) +#define STB_DXT_NORMAL 0 +#define STB_DXT_DITHER 1 // use dithering. was always dubious, now deprecated. does nothing! +#define STB_DXT_HIGHQUAL \ + 2 // high quality mode, does two refinement steps instead of 1. ~30-40% slower. + +STBDDEF void stb_compress_bc1_block(unsigned char* dest, + const unsigned char* src_rgba_four_bytes_per_pixel, int alpha, + int mode); + +STBDDEF void stb_compress_bc3_block(unsigned char* dest, const unsigned char* src, int mode); + +#define STB_COMPRESS_DXT_BLOCK + +#ifdef __cplusplus +} +#endif +#endif // STB_INCLUDE_STB_DXT_H diff --git a/src/common/settings.cpp b/src/common/settings.cpp index ba617aea1..ff53e80bb 100644 --- a/src/common/settings.cpp +++ b/src/common/settings.cpp @@ -61,6 +61,7 @@ void LogSettings() { log_setting("Renderer_NvdecEmulation", values.nvdec_emulation.GetValue()); log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue()); log_setting("Renderer_AsyncASTC", values.async_astc.GetValue()); + log_setting("Renderer_AstcRecompression", values.astc_recompression.GetValue()); log_setting("Renderer_UseVsync", values.vsync_mode.GetValue()); log_setting("Renderer_UseReactiveFlushing", values.use_reactive_flushing.GetValue()); log_setting("Renderer_ShaderBackend", values.shader_backend.GetValue()); @@ -224,6 +225,7 @@ void RestoreGlobalState(bool is_powered_on) { values.nvdec_emulation.SetGlobal(true); values.accelerate_astc.SetGlobal(true); values.async_astc.SetGlobal(true); + values.astc_recompression.SetGlobal(true); values.use_reactive_flushing.SetGlobal(true); values.shader_backend.SetGlobal(true); values.use_asynchronous_shaders.SetGlobal(true); diff --git a/src/common/settings.h b/src/common/settings.h index 36ffcd693..7f865b2a7 100644 --- a/src/common/settings.h +++ b/src/common/settings.h @@ -90,6 +90,12 @@ enum class AntiAliasing : u32 { LastAA = Smaa, }; +enum class AstcRecompression : u32 { + Uncompressed = 0, + Bc1 = 1, + Bc3 = 2, +}; + struct ResolutionScalingInfo { u32 up_scale{1}; u32 down_shift{0}; @@ -473,6 +479,9 @@ struct Values { SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true, "use_vulkan_driver_pipeline_cache"}; SwitchableSetting<bool> enable_compute_pipelines{false, "enable_compute_pipelines"}; + SwitchableSetting<AstcRecompression, true> astc_recompression{ + AstcRecompression::Uncompressed, AstcRecompression::Uncompressed, AstcRecompression::Bc3, + "astc_recompression"}; SwitchableSetting<u8> bg_red{0, "bg_red"}; SwitchableSetting<u8> bg_green{0, "bg_green"}; diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp index 366880711..bbfea7117 100644 --- a/src/core/hid/emulated_controller.cpp +++ b/src/core/hid/emulated_controller.cpp @@ -1283,9 +1283,14 @@ bool EmulatedController::HasNfc() const { } bool EmulatedController::WriteNfc(const std::vector<u8>& data) { - auto& nfc_output_device = output_devices[3]; + auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)]; + auto& nfc_virtual_output_device = output_devices[3]; + + if (nfc_output_device->SupportsNfc() != Common::Input::NfcState::NotSupported) { + return nfc_output_device->WriteNfcData(data) == Common::Input::NfcState::Success; + } - return nfc_output_device->WriteNfcData(data) == Common::Input::NfcState::Success; + return nfc_virtual_output_device->WriteNfcData(data) == Common::Input::NfcState::Success; } void EmulatedController::SetLedPattern() { diff --git a/src/core/hle/kernel/k_memory_block_manager.h b/src/core/hle/kernel/k_memory_block_manager.h index 7c0bd16f0..96496e990 100644 --- a/src/core/hle/kernel/k_memory_block_manager.h +++ b/src/core/hle/kernel/k_memory_block_manager.h @@ -144,14 +144,10 @@ private: class KScopedMemoryBlockManagerAuditor { public: - explicit KScopedMemoryBlockManagerAuditor(KMemoryBlockManager* m) : m_manager(m) { - ASSERT(m_manager->CheckState()); - } + explicit KScopedMemoryBlockManagerAuditor(KMemoryBlockManager* m) : m_manager(m) {} explicit KScopedMemoryBlockManagerAuditor(KMemoryBlockManager& m) : KScopedMemoryBlockManagerAuditor(std::addressof(m)) {} - ~KScopedMemoryBlockManagerAuditor() { - ASSERT(m_manager->CheckState()); - } + ~KScopedMemoryBlockManagerAuditor() = default; private: KMemoryBlockManager* m_manager; diff --git a/src/core/hle/service/nfc/common/amiibo_crypto.cpp b/src/core/hle/service/nfc/common/amiibo_crypto.cpp index f3901ee8d..b2bcb68c3 100644 --- a/src/core/hle/service/nfc/common/amiibo_crypto.cpp +++ b/src/core/hle/service/nfc/common/amiibo_crypto.cpp @@ -52,9 +52,6 @@ bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) { if (ntag_file.compability_container != 0xEEFF10F1U) { return false; } - if (amiibo_data.constant_value != 0xA5) { - return false; - } if (amiibo_data.model_info.tag_type != NFC::PackedTagType::Type2) { return false; } diff --git a/src/core/hle/service/nfc/common/device.cpp b/src/core/hle/service/nfc/common/device.cpp index 322bde2ed..0bd7900e1 100644 --- a/src/core/hle/service/nfc/common/device.cpp +++ b/src/core/hle/service/nfc/common/device.cpp @@ -119,18 +119,31 @@ bool NfcDevice::LoadNfcTag(std::span<const u8> data) { memcpy(&tag_data, data.data(), sizeof(NFP::EncryptedNTAG215File)); is_plain_amiibo = NFP::AmiiboCrypto::IsAmiiboValid(tag_data); + is_write_protected = false; + device_state = DeviceState::TagFound; + deactivate_event->GetReadableEvent().Clear(); + activate_event->Signal(); + + // Fallback for plain amiibos if (is_plain_amiibo) { - encrypted_tag_data = NFP::AmiiboCrypto::EncodedDataToNfcData(tag_data); LOG_INFO(Service_NFP, "Using plain amiibo"); - } else { - tag_data = {}; + encrypted_tag_data = NFP::AmiiboCrypto::EncodedDataToNfcData(tag_data); + return true; + } + + // Fallback for encrypted amiibos without keys + if (!NFP::AmiiboCrypto::IsKeyAvailable()) { + LOG_INFO(Service_NFC, "Loading amiibo without keys"); memcpy(&encrypted_tag_data, data.data(), sizeof(NFP::EncryptedNTAG215File)); + BuildAmiiboWithoutKeys(); + is_plain_amiibo = true; + is_write_protected = true; + return true; } - device_state = DeviceState::TagFound; - deactivate_event->GetReadableEvent().Clear(); - activate_event->Signal(); + tag_data = {}; + memcpy(&encrypted_tag_data, data.data(), sizeof(NFP::EncryptedNTAG215File)); return true; } @@ -346,23 +359,15 @@ Result NfcDevice::Mount(NFP::ModelType model_type, NFP::MountTarget mount_target return ResultWrongDeviceState; } - // The loaded amiibo is not encrypted - if (is_plain_amiibo) { - device_state = DeviceState::TagMounted; - mount_target = mount_target_; - return ResultSuccess; - } - if (!NFP::AmiiboCrypto::IsAmiiboValid(encrypted_tag_data)) { LOG_ERROR(Service_NFP, "Not an amiibo"); return ResultNotAnAmiibo; } - // Mark amiibos as read only when keys are missing - if (!NFP::AmiiboCrypto::IsKeyAvailable()) { - LOG_ERROR(Service_NFP, "No keys detected"); + // The loaded amiibo is not encrypted + if (is_plain_amiibo) { device_state = DeviceState::TagMounted; - mount_target = NFP::MountTarget::Rom; + mount_target = mount_target_; return ResultSuccess; } @@ -421,11 +426,11 @@ Result NfcDevice::Flush() { tag_data.write_counter++; - FlushWithBreak(NFP::BreakType::Normal); + const auto result = FlushWithBreak(NFP::BreakType::Normal); is_data_moddified = false; - return ResultSuccess; + return result; } Result NfcDevice::FlushDebug() { @@ -444,11 +449,11 @@ Result NfcDevice::FlushDebug() { tag_data.write_counter++; - FlushWithBreak(NFP::BreakType::Normal); + const auto result = FlushWithBreak(NFP::BreakType::Normal); is_data_moddified = false; - return ResultSuccess; + return result; } Result NfcDevice::FlushWithBreak(NFP::BreakType break_type) { @@ -457,6 +462,11 @@ Result NfcDevice::FlushWithBreak(NFP::BreakType break_type) { return ResultWrongDeviceState; } + if (is_write_protected) { + LOG_ERROR(Service_NFP, "No keys available skipping write request"); + return ResultSuccess; + } + std::vector<u8> data(sizeof(NFP::EncryptedNTAG215File)); if (is_plain_amiibo) { memcpy(data.data(), &tag_data, sizeof(tag_data)); @@ -1033,7 +1043,6 @@ Result NfcDevice::GetAll(NFP::NfpData& data) const { } NFP::CommonInfo common_info{}; - Service::Mii::MiiManager manager; const u64 application_id = tag_data.application_id; GetCommonInfo(common_info); @@ -1249,6 +1258,28 @@ void NfcDevice::UpdateRegisterInfoCrc() { tag_data.register_info_crc = crc.checksum(); } +void NfcDevice::BuildAmiiboWithoutKeys() { + Service::Mii::MiiManager manager; + auto& settings = tag_data.settings; + + tag_data = NFP::AmiiboCrypto::NfcDataToEncodedData(encrypted_tag_data); + + // Common info + tag_data.write_counter = 0; + tag_data.amiibo_version = 0; + settings.write_date = GetAmiiboDate(GetCurrentPosixTime()); + + // Register info + SetAmiiboName(settings, {'y', 'u', 'z', 'u', 'A', 'm', 'i', 'i', 'b', 'o'}); + settings.settings.font_region.Assign(0); + settings.init_date = GetAmiiboDate(GetCurrentPosixTime()); + tag_data.owner_mii = manager.BuildFromStoreData(manager.BuildDefault(0)); + + // Admin info + settings.settings.amiibo_initialized.Assign(1); + settings.settings.appdata_initialized.Assign(0); +} + u64 NfcDevice::GetHandle() const { // Generate a handle based of the npad id return static_cast<u64>(npad_id); diff --git a/src/core/hle/service/nfc/common/device.h b/src/core/hle/service/nfc/common/device.h index 98e1945c1..6a37e8458 100644 --- a/src/core/hle/service/nfc/common/device.h +++ b/src/core/hle/service/nfc/common/device.h @@ -110,6 +110,8 @@ private: void UpdateSettingsCrc(); void UpdateRegisterInfoCrc(); + void BuildAmiiboWithoutKeys(); + bool is_controller_set{}; int callback_key; const Core::HID::NpadIdType npad_id; @@ -128,6 +130,7 @@ private: bool is_data_moddified{}; bool is_app_area_open{}; bool is_plain_amiibo{}; + bool is_write_protected{}; NFP::MountTarget mount_target{NFP::MountTarget::None}; NFP::NTAG215File tag_data{}; diff --git a/src/input_common/drivers/joycon.cpp b/src/input_common/drivers/joycon.cpp index 8b57ebe07..b2b5677c8 100644 --- a/src/input_common/drivers/joycon.cpp +++ b/src/input_common/drivers/joycon.cpp @@ -195,8 +195,8 @@ void Joycons::RegisterNewDevice(SDL_hid_device_info* device_info) { OnMotionUpdate(port, type, id, value); }}, .on_ring_data = {[this](f32 ring_data) { OnRingConUpdate(ring_data); }}, - .on_amiibo_data = {[this, port](const std::vector<u8>& amiibo_data) { - OnAmiiboUpdate(port, amiibo_data); + .on_amiibo_data = {[this, port, type](const std::vector<u8>& amiibo_data) { + OnAmiiboUpdate(port, type, amiibo_data); }}, .on_camera_data = {[this, port](const std::vector<u8>& camera_data, Joycon::IrsResolution format) { @@ -291,9 +291,13 @@ Common::Input::NfcState Joycons::SupportsNfc(const PadIdentifier& identifier_) c return Common::Input::NfcState::Success; }; -Common::Input::NfcState Joycons::WriteNfcData(const PadIdentifier& identifier_, +Common::Input::NfcState Joycons::WriteNfcData(const PadIdentifier& identifier, const std::vector<u8>& data) { - return Common::Input::NfcState::NotSupported; + auto handle = GetHandle(identifier); + if (handle->WriteNfcData(data) != Joycon::DriverResult::Success) { + return Common::Input::NfcState::WriteFailed; + } + return Common::Input::NfcState::Success; }; Common::Input::DriverResult Joycons::SetPollingMode(const PadIdentifier& identifier, @@ -398,8 +402,9 @@ void Joycons::OnRingConUpdate(f32 ring_data) { SetAxis(identifier, 100, ring_data); } -void Joycons::OnAmiiboUpdate(std::size_t port, const std::vector<u8>& amiibo_data) { - const auto identifier = GetIdentifier(port, Joycon::ControllerType::Right); +void Joycons::OnAmiiboUpdate(std::size_t port, Joycon::ControllerType type, + const std::vector<u8>& amiibo_data) { + const auto identifier = GetIdentifier(port, type); const auto nfc_state = amiibo_data.empty() ? Common::Input::NfcState::AmiiboRemoved : Common::Input::NfcState::NewAmiibo; SetNfc(identifier, {nfc_state, amiibo_data}); diff --git a/src/input_common/drivers/joycon.h b/src/input_common/drivers/joycon.h index 5b40817e2..e3f0ad78f 100644 --- a/src/input_common/drivers/joycon.h +++ b/src/input_common/drivers/joycon.h @@ -81,7 +81,8 @@ private: void OnMotionUpdate(std::size_t port, Joycon::ControllerType type, int id, const Joycon::MotionData& value); void OnRingConUpdate(f32 ring_data); - void OnAmiiboUpdate(std::size_t port, const std::vector<u8>& amiibo_data); + void OnAmiiboUpdate(std::size_t port, Joycon::ControllerType type, + const std::vector<u8>& amiibo_data); void OnCameraUpdate(std::size_t port, const std::vector<u8>& camera_data, Joycon::IrsResolution format); diff --git a/src/input_common/helpers/joycon_driver.cpp b/src/input_common/helpers/joycon_driver.cpp index 83429a336..95106f16d 100644 --- a/src/input_common/helpers/joycon_driver.cpp +++ b/src/input_common/helpers/joycon_driver.cpp @@ -492,6 +492,26 @@ DriverResult JoyconDriver::SetRingConMode() { return result; } +DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data) { + std::scoped_lock lock{mutex}; + disable_input_thread = true; + + if (!supported_features.nfc) { + return DriverResult::NotSupported; + } + if (!nfc_protocol->IsEnabled()) { + return DriverResult::Disabled; + } + if (!amiibo_detected) { + return DriverResult::ErrorWritingData; + } + + const auto result = nfc_protocol->WriteAmiibo(data); + + disable_input_thread = false; + return result; +} + bool JoyconDriver::IsConnected() const { std::scoped_lock lock{mutex}; return is_connected.load(); diff --git a/src/input_common/helpers/joycon_driver.h b/src/input_common/helpers/joycon_driver.h index 72a9e71dc..e9b2fccbb 100644 --- a/src/input_common/helpers/joycon_driver.h +++ b/src/input_common/helpers/joycon_driver.h @@ -49,6 +49,7 @@ public: DriverResult SetIrMode(); DriverResult SetNfcMode(); DriverResult SetRingConMode(); + DriverResult WriteNfcData(std::span<const u8> data); void SetCallbacks(const JoyconCallbacks& callbacks); diff --git a/src/input_common/helpers/joycon_protocol/common_protocol.cpp b/src/input_common/helpers/joycon_protocol/common_protocol.cpp index 077d72cd0..51669261a 100644 --- a/src/input_common/helpers/joycon_protocol/common_protocol.cpp +++ b/src/input_common/helpers/joycon_protocol/common_protocol.cpp @@ -265,7 +265,7 @@ DriverResult JoyconCommonProtocol::SendMCUData(ReportMode report_mode, MCUSubCom DriverResult JoyconCommonProtocol::WaitSetMCUMode(ReportMode report_mode, MCUMode mode) { MCUCommandResponse output{}; - constexpr std::size_t MaxTries{8}; + constexpr std::size_t MaxTries{16}; std::size_t tries{}; do { diff --git a/src/input_common/helpers/joycon_protocol/joycon_types.h b/src/input_common/helpers/joycon_protocol/joycon_types.h index 1c8d294b0..5007b0e18 100644 --- a/src/input_common/helpers/joycon_protocol/joycon_types.h +++ b/src/input_common/helpers/joycon_protocol/joycon_types.h @@ -23,6 +23,7 @@ constexpr std::array<u8, 8> DefaultVibrationBuffer{0x0, 0x1, 0x40, 0x40, 0x0, 0x using MacAddress = std::array<u8, 6>; using SerialNumber = std::array<u8, 15>; +using TagUUID = std::array<u8, 7>; enum class ControllerType : u8 { None = 0x00, @@ -276,12 +277,13 @@ enum class MCUPacketFlag : u8 { LastCommandPacket = 0x08, }; -enum class NFCReadCommand : u8 { +enum class NFCCommand : u8 { CancelAll = 0x00, StartPolling = 0x01, StopPolling = 0x02, StartWaitingRecieve = 0x04, - Ntag = 0x06, + ReadNtag = 0x06, + WriteNtag = 0x08, Mifare = 0x0F, }; @@ -292,14 +294,19 @@ enum class NFCTagType : u8 { enum class NFCPages { Block0 = 0, + Block3 = 3, Block45 = 45, Block135 = 135, Block231 = 231, }; enum class NFCStatus : u8 { + Ready = 0x00, + Polling = 0x01, LastPackage = 0x04, + WriteDone = 0x05, TagLost = 0x07, + WriteReady = 0x09, }; enum class IrsMode : u8 { @@ -559,13 +566,32 @@ static_assert(sizeof(NFCReadBlockCommand) == 0x9, "NFCReadBlockCommand is an inv struct NFCReadCommandData { u8 unknown; u8 uuid_length; - u8 unknown_2; - std::array<u8, 6> uid; + TagUUID uid; NFCTagType tag_type; NFCReadBlockCommand read_block; }; static_assert(sizeof(NFCReadCommandData) == 0x13, "NFCReadCommandData is an invalid size"); +#pragma pack(push, 1) +struct NFCWriteCommandData { + u8 unknown; + u8 uuid_length; + TagUUID uid; + NFCTagType tag_type; + u8 unknown2; + u8 unknown3; + u8 unknown4; + u8 unknown5; + u8 unknown6; + u8 unknown7; + u8 unknown8; + u8 magic; + u16_be write_count; + u8 amiibo_version; +}; +static_assert(sizeof(NFCWriteCommandData) == 0x15, "NFCWriteCommandData is an invalid size"); +#pragma pack(pop) + struct NFCPollingCommandData { u8 enable_mifare; u8 unknown_1; @@ -576,9 +602,9 @@ struct NFCPollingCommandData { static_assert(sizeof(NFCPollingCommandData) == 0x05, "NFCPollingCommandData is an invalid size"); struct NFCRequestState { - NFCReadCommand command_argument; + NFCCommand command_argument; + u8 block_id; u8 packet_id; - INSERT_PADDING_BYTES(0x1); MCUPacketFlag packet_flag; u8 data_length; union { @@ -591,6 +617,18 @@ struct NFCRequestState { }; static_assert(sizeof(NFCRequestState) == 0x26, "NFCRequestState is an invalid size"); +struct NFCDataChunk { + u8 nfc_page; + u8 data_size; + std::array<u8, 0xFF> data; +}; + +struct NFCWritePackage { + NFCWriteCommandData command_data; + u8 number_of_chunks; + std::array<NFCDataChunk, 4> data_chunks; +}; + struct IrsConfigure { MCUCommand command; MCUSubCommand sub_command; diff --git a/src/input_common/helpers/joycon_protocol/nfc.cpp b/src/input_common/helpers/joycon_protocol/nfc.cpp index 14818ae33..3b7a628e5 100644 --- a/src/input_common/helpers/joycon_protocol/nfc.cpp +++ b/src/input_common/helpers/joycon_protocol/nfc.cpp @@ -34,6 +34,12 @@ DriverResult NfcProtocol::EnableNfc() { result = ConfigureMCU(config); } + if (result == DriverResult::Success) { + result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::NFC); + } + if (result == DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::Ready); + } return result; } @@ -56,13 +62,20 @@ DriverResult NfcProtocol::StartNFCPollingMode() { LOG_DEBUG(Input, "Start NFC pooling Mode"); ScopedSetBlocking sb(this); DriverResult result{DriverResult::Success}; - TagFoundData tag_data{}; if (result == DriverResult::Success) { - result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::NFC); + MCUCommandResponse output{}; + result = SendStopPollingRequest(output); + } + if (result == DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::Ready); + } + if (result == DriverResult::Success) { + MCUCommandResponse output{}; + result = SendStartPollingRequest(output); } if (result == DriverResult::Success) { - result = WaitUntilNfcIsReady(); + result = WaitUntilNfcIs(NFCStatus::Polling); } if (result == DriverResult::Success) { is_enabled = true; @@ -77,49 +90,94 @@ DriverResult NfcProtocol::ScanAmiibo(std::vector<u8>& data) { } update_counter = 0; - LOG_DEBUG(Input, "Start NFC pooling Mode"); + LOG_DEBUG(Input, "Scan for amiibos"); + ScopedSetBlocking sb(this); + DriverResult result{DriverResult::Success}; + TagFoundData tag_data{}; + + if (result == DriverResult::Success) { + result = IsTagInRange(tag_data); + } + + if (result == DriverResult::Success) { + std::string uuid_string; + for (auto& content : tag_data.uuid) { + uuid_string += fmt::format(" {:02x}", content); + } + LOG_INFO(Input, "Tag detected, type={}, uuid={}", tag_data.type, uuid_string); + result = GetAmiiboData(data); + } + + return result; +} + +DriverResult NfcProtocol::WriteAmiibo(std::span<const u8> data) { + LOG_DEBUG(Input, "Write amiibo"); ScopedSetBlocking sb(this); DriverResult result{DriverResult::Success}; + TagUUID tag_uuid = GetTagUUID(data); TagFoundData tag_data{}; if (result == DriverResult::Success) { - result = StartPolling(tag_data); + result = IsTagInRange(tag_data, 7); } if (result == DriverResult::Success) { - result = ReadTag(tag_data); + if (tag_data.uuid != tag_uuid) { + result = DriverResult::InvalidParameters; + } } if (result == DriverResult::Success) { - result = WaitUntilNfcIsReady(); + MCUCommandResponse output{}; + result = SendStopPollingRequest(output); } if (result == DriverResult::Success) { - result = StartPolling(tag_data, 7); + result = WaitUntilNfcIs(NFCStatus::Ready); } if (result == DriverResult::Success) { - result = GetAmiiboData(data); + MCUCommandResponse output{}; + result = SendStartPollingRequest(output, true); + } + if (result == DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::WriteReady); + } + if (result == DriverResult::Success) { + result = WriteAmiiboData(tag_uuid, data); + } + if (result == DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::WriteDone); + } + if (result == DriverResult::Success) { + MCUCommandResponse output{}; + result = SendStopPollingRequest(output); } return result; } bool NfcProtocol::HasAmiibo() { + if (update_counter++ < AMIIBO_UPDATE_DELAY) { + return true; + } + update_counter = 0; + ScopedSetBlocking sb(this); DriverResult result{DriverResult::Success}; TagFoundData tag_data{}; if (result == DriverResult::Success) { - result = StartPolling(tag_data); + result = IsTagInRange(tag_data, 7); } return result == DriverResult::Success; } -DriverResult NfcProtocol::WaitUntilNfcIsReady() { +DriverResult NfcProtocol::WaitUntilNfcIs(NFCStatus status) { constexpr std::size_t timeout_limit = 10; MCUCommandResponse output{}; std::size_t tries = 0; do { - auto result = SendStartWaitingRecieveRequest(output); + auto result = SendNextPackageRequest(output, {}); if (result != DriverResult::Success) { return result; @@ -129,18 +187,17 @@ DriverResult NfcProtocol::WaitUntilNfcIsReady() { } } while (output.mcu_report != MCUReport::NFCState || (output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 || - output.mcu_data[5] != 0x31 || output.mcu_data[6] != 0x00); + output.mcu_data[5] != 0x31 || output.mcu_data[6] != static_cast<u8>(status)); return DriverResult::Success; } -DriverResult NfcProtocol::StartPolling(TagFoundData& data, std::size_t timeout_limit) { - LOG_DEBUG(Input, "Start Polling for tag"); +DriverResult NfcProtocol::IsTagInRange(TagFoundData& data, std::size_t timeout_limit) { MCUCommandResponse output{}; std::size_t tries = 0; do { - const auto result = SendStartPollingRequest(output); + const auto result = SendNextPackageRequest(output, {}); if (result != DriverResult::Success) { return result; } @@ -149,32 +206,31 @@ DriverResult NfcProtocol::StartPolling(TagFoundData& data, std::size_t timeout_l } } while (output.mcu_report != MCUReport::NFCState || (output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 || - output.mcu_data[6] != 0x09); + (output.mcu_data[6] != 0x09 && output.mcu_data[6] != 0x04)); data.type = output.mcu_data[12]; - data.uuid.resize(output.mcu_data[14]); + data.uuid_size = std::min(output.mcu_data[14], static_cast<u8>(sizeof(TagUUID))); memcpy(data.uuid.data(), output.mcu_data.data() + 15, data.uuid.size()); return DriverResult::Success; } -DriverResult NfcProtocol::ReadTag(const TagFoundData& data) { - constexpr std::size_t timeout_limit = 10; +DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) { + constexpr std::size_t timeout_limit = 60; MCUCommandResponse output{}; std::size_t tries = 0; - std::string uuid_string; - for (auto& content : data.uuid) { - uuid_string += fmt::format(" {:02x}", content); - } + u8 package_index = 0; + std::size_t ntag_buffer_pos = 0; + auto result = SendReadAmiiboRequest(output, NFCPages::Block135); - LOG_INFO(Input, "Tag detected, type={}, uuid={}", data.type, uuid_string); + if (result != DriverResult::Success) { + return result; + } - tries = 0; - NFCPages ntag_pages = NFCPages::Block0; // Read Tag data - while (true) { - auto result = SendReadAmiiboRequest(output, ntag_pages); + while (tries++ < timeout_limit) { + result = SendNextPackageRequest(output, package_index); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); if (result != DriverResult::Success) { @@ -187,56 +243,51 @@ DriverResult NfcProtocol::ReadTag(const TagFoundData& data) { return DriverResult::ErrorReadingData; } - if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07 && - output.mcu_data[2] == 0x01) { - if (data.type != 2) { - continue; - } - switch (output.mcu_data[24]) { - case 0: - ntag_pages = NFCPages::Block135; - break; - case 3: - ntag_pages = NFCPages::Block45; - break; - case 4: - ntag_pages = NFCPages::Block231; - break; - default: - return DriverResult::ErrorReadingData; + if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07) { + std::size_t payload_size = (output.mcu_data[4] << 8 | output.mcu_data[5]) & 0x7FF; + if (output.mcu_data[2] == 0x01) { + memcpy(ntag_data.data() + ntag_buffer_pos, output.mcu_data.data() + 66, + payload_size - 60); + ntag_buffer_pos += payload_size - 60; + } else { + memcpy(ntag_data.data() + ntag_buffer_pos, output.mcu_data.data() + 6, + payload_size); } + package_index++; continue; } if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::LastPackage) { - // finished - SendStopPollingRequest(output); + LOG_INFO(Input, "Finished reading amiibo"); return DriverResult::Success; } - - // Ignore other state reports - if (output.mcu_report == MCUReport::NFCState) { - continue; - } - - if (tries++ > timeout_limit) { - return DriverResult::Timeout; - } } - return DriverResult::Success; + return DriverResult::Timeout; } -DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) { - constexpr std::size_t timeout_limit = 10; +DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<const u8> data) { + constexpr std::size_t timeout_limit = 60; + const auto nfc_data = MakeAmiiboWritePackage(tag_uuid, data); + const std::vector<u8> nfc_buffer_data = SerializeWritePackage(nfc_data); + std::span<const u8> buffer(nfc_buffer_data); MCUCommandResponse output{}; + u8 block_id = 1; + u8 package_index = 0; std::size_t tries = 0; + std::size_t current_position = 0; - NFCPages ntag_pages = NFCPages::Block135; - std::size_t ntag_buffer_pos = 0; - // Read Tag data - while (true) { - auto result = SendReadAmiiboRequest(output, ntag_pages); + LOG_INFO(Input, "Writing amiibo data"); + + auto result = SendWriteAmiiboRequest(output, tag_uuid); + + if (result != DriverResult::Success) { + return result; + } + + // Read Tag data but ignore the actual sent data + while (tries++ < timeout_limit) { + result = SendNextPackageRequest(output, package_index); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); if (result != DriverResult::Success) { @@ -250,47 +301,59 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) { } if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07) { - std::size_t payload_size = (output.mcu_data[4] << 8 | output.mcu_data[5]) & 0x7FF; - if (output.mcu_data[2] == 0x01) { - memcpy(ntag_data.data() + ntag_buffer_pos, output.mcu_data.data() + 66, - payload_size - 60); - ntag_buffer_pos += payload_size - 60; - } else { - memcpy(ntag_data.data() + ntag_buffer_pos, output.mcu_data.data() + 6, - payload_size); - } + package_index++; continue; } if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::LastPackage) { LOG_INFO(Input, "Finished reading amiibo"); - return DriverResult::Success; + break; } + } - // Ignore other state reports - if (output.mcu_report == MCUReport::NFCState) { - continue; + // Send Data. Nfc buffer size is 31, Send the data in smaller packages + while (current_position < buffer.size() && tries++ < timeout_limit) { + const std::size_t next_position = + std::min(current_position + sizeof(NFCRequestState::raw_data), buffer.size()); + const std::size_t block_size = next_position - current_position; + const bool is_last_packet = block_size < sizeof(NFCRequestState::raw_data); + + SendWriteDataAmiiboRequest(output, block_id, is_last_packet, + buffer.subspan(current_position, block_size)); + + const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); + + if ((output.mcu_report == MCUReport::NFCReadData || + output.mcu_report == MCUReport::NFCState) && + nfc_status == NFCStatus::TagLost) { + return DriverResult::ErrorReadingData; } - if (tries++ > timeout_limit) { - return DriverResult::Timeout; + // Increase position when data is confirmed by the joycon + if (output.mcu_report == MCUReport::NFCState && + (output.mcu_data[1] << 8) + output.mcu_data[0] == 0x0500 && + output.mcu_data[3] == block_id) { + block_id++; + current_position = next_position; } } - return DriverResult::Success; + return result; } -DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output) { +DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output, + bool is_second_attempt) { NFCRequestState request{ - .command_argument = NFCReadCommand::StartPolling, - .packet_id = 0x0, + .command_argument = NFCCommand::StartPolling, + .block_id = {}, + .packet_id = {}, .packet_flag = MCUPacketFlag::LastCommandPacket, .data_length = sizeof(NFCPollingCommandData), .nfc_polling = { - .enable_mifare = 0x01, - .unknown_1 = 0x00, - .unknown_2 = 0x00, + .enable_mifare = 0x00, + .unknown_1 = static_cast<u8>(is_second_attempt ? 0xe8 : 0x00), + .unknown_2 = static_cast<u8>(is_second_attempt ? 0x03 : 0x00), .unknown_3 = 0x2c, .unknown_4 = 0x01, }, @@ -306,10 +369,11 @@ DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output) { DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) { NFCRequestState request{ - .command_argument = NFCReadCommand::StopPolling, - .packet_id = 0x0, + .command_argument = NFCCommand::StopPolling, + .block_id = {}, + .packet_id = {}, .packet_flag = MCUPacketFlag::LastCommandPacket, - .data_length = 0, + .data_length = {}, .raw_data = {}, .crc = {}, }; @@ -321,12 +385,13 @@ DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) { output); } -DriverResult NfcProtocol::SendStartWaitingRecieveRequest(MCUCommandResponse& output) { +DriverResult NfcProtocol::SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id) { NFCRequestState request{ - .command_argument = NFCReadCommand::StartWaitingRecieve, - .packet_id = 0x0, + .command_argument = NFCCommand::StartWaitingRecieve, + .block_id = {}, + .packet_id = packet_id, .packet_flag = MCUPacketFlag::LastCommandPacket, - .data_length = 0, + .data_length = {}, .raw_data = {}, .crc = {}, }; @@ -340,17 +405,17 @@ DriverResult NfcProtocol::SendStartWaitingRecieveRequest(MCUCommandResponse& out DriverResult NfcProtocol::SendReadAmiiboRequest(MCUCommandResponse& output, NFCPages ntag_pages) { NFCRequestState request{ - .command_argument = NFCReadCommand::Ntag, - .packet_id = 0x0, + .command_argument = NFCCommand::ReadNtag, + .block_id = {}, + .packet_id = {}, .packet_flag = MCUPacketFlag::LastCommandPacket, .data_length = sizeof(NFCReadCommandData), .nfc_read = { .unknown = 0xd0, - .uuid_length = 0x07, - .unknown_2 = 0x00, + .uuid_length = sizeof(NFCReadCommandData::uid), .uid = {}, - .tag_type = NFCTagType::AllTags, + .tag_type = NFCTagType::Ntag215, .read_block = GetReadBlockCommand(ntag_pages), }, .crc = {}, @@ -363,12 +428,135 @@ DriverResult NfcProtocol::SendReadAmiiboRequest(MCUCommandResponse& output, NFCP output); } +DriverResult NfcProtocol::SendWriteAmiiboRequest(MCUCommandResponse& output, + const TagUUID& tag_uuid) { + NFCRequestState request{ + .command_argument = NFCCommand::ReadNtag, + .block_id = {}, + .packet_id = {}, + .packet_flag = MCUPacketFlag::LastCommandPacket, + .data_length = sizeof(NFCReadCommandData), + .nfc_read = + { + .unknown = 0xd0, + .uuid_length = sizeof(NFCReadCommandData::uid), + .uid = tag_uuid, + .tag_type = NFCTagType::Ntag215, + .read_block = GetReadBlockCommand(NFCPages::Block3), + }, + .crc = {}, + }; + + std::array<u8, sizeof(NFCRequestState)> request_data{}; + memcpy(request_data.data(), &request, sizeof(NFCRequestState)); + request_data[36] = CalculateMCU_CRC8(request_data.data(), 36); + return SendMCUData(ReportMode::NFC_IR_MODE_60HZ, MCUSubCommand::ReadDeviceMode, request_data, + output); +} + +DriverResult NfcProtocol::SendWriteDataAmiiboRequest(MCUCommandResponse& output, u8 block_id, + bool is_last_packet, + std::span<const u8> data) { + const auto data_size = std::min(data.size(), sizeof(NFCRequestState::raw_data)); + NFCRequestState request{ + .command_argument = NFCCommand::WriteNtag, + .block_id = block_id, + .packet_id = {}, + .packet_flag = + is_last_packet ? MCUPacketFlag::LastCommandPacket : MCUPacketFlag::MorePacketsRemaining, + .data_length = static_cast<u8>(data_size), + .raw_data = {}, + .crc = {}, + }; + memcpy(request.raw_data.data(), data.data(), data_size); + + std::array<u8, sizeof(NFCRequestState)> request_data{}; + memcpy(request_data.data(), &request, sizeof(NFCRequestState)); + request_data[36] = CalculateMCU_CRC8(request_data.data(), 36); + return SendMCUData(ReportMode::NFC_IR_MODE_60HZ, MCUSubCommand::ReadDeviceMode, request_data, + output); +} + +std::vector<u8> NfcProtocol::SerializeWritePackage(const NFCWritePackage& package) const { + const std::size_t header_size = + sizeof(NFCWriteCommandData) + sizeof(NFCWritePackage::number_of_chunks); + std::vector<u8> serialized_data(header_size); + std::size_t start_index = 0; + + memcpy(serialized_data.data(), &package, header_size); + start_index += header_size; + + for (const auto& data_chunk : package.data_chunks) { + const std::size_t chunk_size = + sizeof(NFCDataChunk::nfc_page) + sizeof(NFCDataChunk::data_size) + data_chunk.data_size; + + serialized_data.resize(start_index + chunk_size); + memcpy(serialized_data.data() + start_index, &data_chunk, chunk_size); + start_index += chunk_size; + } + + return serialized_data; +} + +NFCWritePackage NfcProtocol::MakeAmiiboWritePackage(const TagUUID& tag_uuid, + std::span<const u8> data) const { + return { + .command_data{ + .unknown = 0xd0, + .uuid_length = sizeof(NFCReadCommandData::uid), + .uid = tag_uuid, + .tag_type = NFCTagType::Ntag215, + .unknown2 = 0x00, + .unknown3 = 0x01, + .unknown4 = 0x04, + .unknown5 = 0xff, + .unknown6 = 0xff, + .unknown7 = 0xff, + .unknown8 = 0xff, + .magic = data[16], + .write_count = static_cast<u16>((data[17] << 8) + data[18]), + .amiibo_version = data[19], + }, + .number_of_chunks = 3, + .data_chunks = + { + MakeAmiiboChunk(0x05, 0x20, data), + MakeAmiiboChunk(0x20, 0xf0, data), + MakeAmiiboChunk(0x5c, 0x98, data), + }, + }; +} + +NFCDataChunk NfcProtocol::MakeAmiiboChunk(u8 page, u8 size, std::span<const u8> data) const { + constexpr u8 PAGE_SIZE = 4; + + if (static_cast<std::size_t>(page * PAGE_SIZE) + size >= data.size()) { + return {}; + } + + NFCDataChunk chunk{ + .nfc_page = page, + .data_size = size, + .data = {}, + }; + std::memcpy(chunk.data.data(), data.data() + (page * PAGE_SIZE), size); + return chunk; +} + NFCReadBlockCommand NfcProtocol::GetReadBlockCommand(NFCPages pages) const { switch (pages) { case NFCPages::Block0: return { .block_count = 1, }; + case NFCPages::Block3: + return { + .block_count = 1, + .blocks = + { + NFCReadBlock{0x03, 0x03}, + }, + }; case NFCPages::Block45: return { .block_count = 1, @@ -403,6 +591,17 @@ NFCReadBlockCommand NfcProtocol::GetReadBlockCommand(NFCPages pages) const { }; } +TagUUID NfcProtocol::GetTagUUID(std::span<const u8> data) const { + if (data.size() < 10) { + return {}; + } + + // crc byte 3 is omitted in this operation + return { + data[0], data[1], data[2], data[4], data[5], data[6], data[7], + }; +} + bool NfcProtocol::IsEnabled() const { return is_enabled; } diff --git a/src/input_common/helpers/joycon_protocol/nfc.h b/src/input_common/helpers/joycon_protocol/nfc.h index 4cb992d1d..eb58c427d 100644 --- a/src/input_common/helpers/joycon_protocol/nfc.h +++ b/src/input_common/helpers/joycon_protocol/nfc.h @@ -27,6 +27,8 @@ public: DriverResult ScanAmiibo(std::vector<u8>& data); + DriverResult WriteAmiibo(std::span<const u8> data); + bool HasAmiibo(); bool IsEnabled() const; @@ -37,27 +39,42 @@ private: struct TagFoundData { u8 type; - std::vector<u8> uuid; + u8 uuid_size; + TagUUID uuid; }; - DriverResult WaitUntilNfcIsReady(); - - DriverResult StartPolling(TagFoundData& data, std::size_t timeout_limit = 1); + DriverResult WaitUntilNfcIs(NFCStatus status); - DriverResult ReadTag(const TagFoundData& data); + DriverResult IsTagInRange(TagFoundData& data, std::size_t timeout_limit = 1); DriverResult GetAmiiboData(std::vector<u8>& data); - DriverResult SendStartPollingRequest(MCUCommandResponse& output); + DriverResult WriteAmiiboData(const TagUUID& tag_uuid, std::span<const u8> data); + + DriverResult SendStartPollingRequest(MCUCommandResponse& output, + bool is_second_attempt = false); DriverResult SendStopPollingRequest(MCUCommandResponse& output); - DriverResult SendStartWaitingRecieveRequest(MCUCommandResponse& output); + DriverResult SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id); DriverResult SendReadAmiiboRequest(MCUCommandResponse& output, NFCPages ntag_pages); + DriverResult SendWriteAmiiboRequest(MCUCommandResponse& output, const TagUUID& tag_uuid); + + DriverResult SendWriteDataAmiiboRequest(MCUCommandResponse& output, u8 block_id, + bool is_last_packet, std::span<const u8> data); + + std::vector<u8> SerializeWritePackage(const NFCWritePackage& package) const; + + NFCWritePackage MakeAmiiboWritePackage(const TagUUID& tag_uuid, std::span<const u8> data) const; + + NFCDataChunk MakeAmiiboChunk(u8 page, u8 size, std::span<const u8> data) const; + NFCReadBlockCommand GetReadBlockCommand(NFCPages pages) const; + TagUUID GetTagUUID(std::span<const u8> data) const; + bool is_enabled{}; std::size_t update_counter{}; }; diff --git a/src/input_common/input_engine.cpp b/src/input_common/input_engine.cpp index 91aa96aa7..e4c5b5b3c 100644 --- a/src/input_common/input_engine.cpp +++ b/src/input_common/input_engine.cpp @@ -380,13 +380,16 @@ void InputEngine::TriggerOnMotionChange(const PadIdentifier& identifier, int mot if (!configuring || !mapping_callback.on_data) { return; } + const auto old_value = GetMotion(identifier, motion); bool is_active = false; - if (std::abs(value.accel_x) > 1.5f || std::abs(value.accel_y) > 1.5f || - std::abs(value.accel_z) > 1.5f) { + if (std::abs(value.accel_x - old_value.accel_x) > 1.5f || + std::abs(value.accel_y - old_value.accel_y) > 1.5f || + std::abs(value.accel_z - old_value.accel_z) > 1.5f) { is_active = true; } - if (std::abs(value.gyro_x) > 0.6f || std::abs(value.gyro_y) > 0.6f || - std::abs(value.gyro_z) > 0.6f) { + if (std::abs(value.gyro_x - old_value.gyro_x) > 0.6f || + std::abs(value.gyro_y - old_value.gyro_y) > 0.6f || + std::abs(value.gyro_z - old_value.gyro_z) > 0.6f) { is_active = true; } if (!is_active) { diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt index a0009a36f..308d013d6 100644 --- a/src/video_core/CMakeLists.txt +++ b/src/video_core/CMakeLists.txt @@ -246,10 +246,14 @@ add_library(video_core STATIC texture_cache/util.h textures/astc.h textures/astc.cpp + textures/bcn.cpp + textures/bcn.h textures/decoders.cpp textures/decoders.h textures/texture.cpp textures/texture.h + textures/workers.cpp + textures/workers.h transform_feedback.cpp transform_feedback.h video_core.cpp @@ -275,7 +279,7 @@ add_library(video_core STATIC create_target_directory_groups(video_core) target_link_libraries(video_core PUBLIC common core) -target_link_libraries(video_core PUBLIC glad shader_recompiler) +target_link_libraries(video_core PUBLIC glad shader_recompiler stb) if (YUZU_USE_BUNDLED_FFMPEG AND NOT WIN32) add_dependencies(video_core ffmpeg-build) diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h index 98756e4da..65494097b 100644 --- a/src/video_core/buffer_cache/buffer_cache.h +++ b/src/video_core/buffer_cache/buffer_cache.h @@ -30,8 +30,8 @@ BufferCache<P>::BufferCache(VideoCore::RasterizerInterface& rasterizer_, } const s64 device_memory = static_cast<s64>(runtime.GetDeviceLocalMemory()); - const s64 min_spacing_expected = device_memory - 1_GiB - 512_MiB; - const s64 min_spacing_critical = device_memory - 1_GiB; + const s64 min_spacing_expected = device_memory - 1_GiB; + const s64 min_spacing_critical = device_memory - 512_MiB; const s64 mem_threshold = std::min(device_memory, TARGET_THRESHOLD); const s64 min_vacancy_expected = (6 * mem_threshold) / 10; const s64 min_vacancy_critical = (3 * mem_threshold) / 10; @@ -1664,7 +1664,7 @@ typename BufferCache<P>::Binding BufferCache<P>::StorageBufferBinding(GPUVAddr s // cbufs, which do not store the sizes adjacent to the addresses, so use the fully // mapped buffer size for now. const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr)); - return memory_layout_size; + return std::min(memory_layout_size, static_cast<u32>(8_MiB)); }(); const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(gpu_addr); if (!cpu_addr || size == 0) { diff --git a/src/video_core/renderer_opengl/gl_texture_cache.cpp b/src/video_core/renderer_opengl/gl_texture_cache.cpp index 31118886f..1e0823836 100644 --- a/src/video_core/renderer_opengl/gl_texture_cache.cpp +++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp @@ -233,6 +233,8 @@ void ApplySwizzle(GLuint handle, PixelFormat format, std::array<SwizzleSource, 4 const VideoCommon::ImageInfo& info) { if (IsPixelFormatASTC(info.format) && info.size.depth == 1 && !runtime.HasNativeASTC()) { return Settings::values.accelerate_astc.GetValue() && + Settings::values.astc_recompression.GetValue() == + Settings::AstcRecompression::Uncompressed && !Settings::values.async_astc.GetValue(); } // Disable other accelerated uploads for now as they don't implement swizzled uploads @@ -437,6 +439,19 @@ OGLTexture MakeImage(const VideoCommon::ImageInfo& info, GLenum gl_internal_form return GL_R32UI; } +[[nodiscard]] GLenum SelectAstcFormat(PixelFormat format, bool is_srgb) { + switch (Settings::values.astc_recompression.GetValue()) { + case Settings::AstcRecompression::Bc1: + return is_srgb ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT : GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + break; + case Settings::AstcRecompression::Bc3: + return is_srgb ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT : GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + break; + default: + return is_srgb ? GL_SRGB8_ALPHA8 : GL_RGBA8; + } +} + } // Anonymous namespace ImageBufferMap::~ImageBufferMap() { @@ -739,9 +754,16 @@ Image::Image(TextureCacheRuntime& runtime_, const VideoCommon::ImageInfo& info_, if (IsConverted(runtime->device, info.format, info.type)) { flags |= ImageFlagBits::Converted; flags |= ImageFlagBits::CostlyLoad; - gl_internal_format = IsPixelFormatSRGB(info.format) ? GL_SRGB8_ALPHA8 : GL_RGBA8; + + const bool is_srgb = IsPixelFormatSRGB(info.format); + gl_internal_format = is_srgb ? GL_SRGB8_ALPHA8 : GL_RGBA8; gl_format = GL_RGBA; gl_type = GL_UNSIGNED_INT_8_8_8_8_REV; + + if (IsPixelFormatASTC(info.format)) { + gl_internal_format = SelectAstcFormat(info.format, is_srgb); + gl_format = GL_NONE; + } } else { const auto& tuple = MaxwellToGL::GetFormatTuple(info.format); gl_internal_format = tuple.internal_format; @@ -1130,7 +1152,12 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI views{runtime.null_image_views} { const Device& device = runtime.device; if (True(image.flags & ImageFlagBits::Converted)) { - internal_format = IsPixelFormatSRGB(info.format) ? GL_SRGB8_ALPHA8 : GL_RGBA8; + const bool is_srgb = IsPixelFormatSRGB(info.format); + internal_format = is_srgb ? GL_SRGB8_ALPHA8 : GL_RGBA8; + + if (IsPixelFormatASTC(info.format)) { + internal_format = SelectAstcFormat(info.format, is_srgb); + } } else { internal_format = MaxwellToGL::GetFormatTuple(format).internal_format; } diff --git a/src/video_core/renderer_opengl/gl_texture_cache.h b/src/video_core/renderer_opengl/gl_texture_cache.h index 1190999a8..3e9b3302b 100644 --- a/src/video_core/renderer_opengl/gl_texture_cache.h +++ b/src/video_core/renderer_opengl/gl_texture_cache.h @@ -144,6 +144,10 @@ public: return state_tracker; } + void BarrierFeedbackLoop() const noexcept { + // OpenGL does not require a barrier for attachment feedback loops. + } + private: struct StagingBuffers { explicit StagingBuffers(GLenum storage_flags_, GLenum map_flags_); diff --git a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp index 8853cf0f7..b75d7220d 100644 --- a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp +++ b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp @@ -6,6 +6,7 @@ #include "common/assert.h" #include "common/common_types.h" #include "common/logging/log.h" +#include "common/settings.h" #include "video_core/engines/maxwell_3d.h" #include "video_core/renderer_vulkan/maxwell_to_vk.h" #include "video_core/surface.h" @@ -237,14 +238,25 @@ FormatInfo SurfaceFormat(const Device& device, FormatType format_type, bool with PixelFormat pixel_format) { ASSERT(static_cast<size_t>(pixel_format) < std::size(tex_format_tuples)); FormatTuple tuple = tex_format_tuples[static_cast<size_t>(pixel_format)]; - // Use A8B8G8R8_UNORM on hardware that doesn't support ASTC natively + // Transcode on hardware that doesn't support ASTC natively if (!device.IsOptimalAstcSupported() && VideoCore::Surface::IsPixelFormatASTC(pixel_format)) { const bool is_srgb = with_srgb && VideoCore::Surface::IsPixelFormatSRGB(pixel_format); - if (is_srgb) { - tuple.format = VK_FORMAT_A8B8G8R8_SRGB_PACK32; - } else { - tuple.format = VK_FORMAT_A8B8G8R8_UNORM_PACK32; - tuple.usage |= Storage; + + switch (Settings::values.astc_recompression.GetValue()) { + case Settings::AstcRecompression::Uncompressed: + if (is_srgb) { + tuple.format = VK_FORMAT_A8B8G8R8_SRGB_PACK32; + } else { + tuple.format = VK_FORMAT_A8B8G8R8_UNORM_PACK32; + tuple.usage |= Storage; + } + break; + case Settings::AstcRecompression::Bc1: + tuple.format = is_srgb ? VK_FORMAT_BC1_RGBA_SRGB_BLOCK : VK_FORMAT_BC1_RGBA_UNORM_BLOCK; + break; + case Settings::AstcRecompression::Bc3: + tuple.format = is_srgb ? VK_FORMAT_BC3_SRGB_BLOCK : VK_FORMAT_BC3_UNORM_BLOCK; + break; } } const bool attachable = (tuple.usage & Attachable) != 0; diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp index f1bcd5cd6..506b78f08 100644 --- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp +++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp @@ -481,12 +481,13 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) { if constexpr (Spec::enabled_stages[4]) { prepare_stage(4); } + texture_cache.UpdateRenderTargets(false); + texture_cache.CheckFeedbackLoop(views); ConfigureDraw(rescaling, render_area); } void GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling, const RenderAreaPushConstant& render_area) { - texture_cache.UpdateRenderTargets(false); scheduler.RequestRenderpass(texture_cache.GetFramebuffer()); if (!is_built.load(std::memory_order::relaxed)) { diff --git a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp index 47c74e4d8..8b65aeaeb 100644 --- a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp +++ b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp @@ -10,11 +10,16 @@ namespace Vulkan { +constexpr u64 FENCE_RESERVE_SIZE = 8; + MasterSemaphore::MasterSemaphore(const Device& device_) : device(device_) { if (!device.HasTimelineSemaphore()) { static constexpr VkFenceCreateInfo fence_ci{ .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = nullptr, .flags = 0}; - fence = device.GetLogical().CreateFence(fence_ci); + free_queue.resize(FENCE_RESERVE_SIZE); + std::ranges::generate(free_queue, + [&] { return device.GetLogical().CreateFence(fence_ci); }); + wait_thread = std::jthread([this](std::stop_token token) { WaitThread(token); }); return; } @@ -167,16 +172,53 @@ VkResult MasterSemaphore::SubmitQueueFence(vk::CommandBuffer& cmdbuf, VkSemaphor .pSignalSemaphores = &signal_semaphore, }; + auto fence = GetFreeFence(); auto result = device.GetGraphicsQueue().Submit(submit_info, *fence); if (result == VK_SUCCESS) { + std::scoped_lock lock{wait_mutex}; + wait_queue.emplace(host_tick, std::move(fence)); + wait_cv.notify_one(); + } + + return result; +} + +void MasterSemaphore::WaitThread(std::stop_token token) { + while (!token.stop_requested()) { + u64 host_tick; + vk::Fence fence; + { + std::unique_lock lock{wait_mutex}; + Common::CondvarWait(wait_cv, lock, token, [this] { return !wait_queue.empty(); }); + if (token.stop_requested()) { + return; + } + std::tie(host_tick, fence) = std::move(wait_queue.front()); + wait_queue.pop(); + } + fence.Wait(); fence.Reset(); gpu_tick.store(host_tick); gpu_tick.notify_all(); + + std::scoped_lock lock{free_mutex}; + free_queue.push_front(std::move(fence)); } +} - return result; +vk::Fence MasterSemaphore::GetFreeFence() { + std::scoped_lock lock{free_mutex}; + if (free_queue.empty()) { + static constexpr VkFenceCreateInfo fence_ci{ + .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = nullptr, .flags = 0}; + return device.GetLogical().CreateFence(fence_ci); + } + + auto fence = std::move(free_queue.back()); + free_queue.pop_back(); + return fence; } } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_master_semaphore.h b/src/video_core/renderer_vulkan/vk_master_semaphore.h index f2f61f781..1e7c90215 100644 --- a/src/video_core/renderer_vulkan/vk_master_semaphore.h +++ b/src/video_core/renderer_vulkan/vk_master_semaphore.h @@ -5,8 +5,10 @@ #include <atomic> #include <condition_variable> +#include <deque> #include <mutex> #include <thread> +#include <queue> #include "common/common_types.h" #include "common/polyfill_thread.h" @@ -17,6 +19,8 @@ namespace Vulkan { class Device; class MasterSemaphore { + using Waitable = std::pair<u64, vk::Fence>; + public: explicit MasterSemaphore(const Device& device); ~MasterSemaphore(); @@ -57,13 +61,22 @@ private: VkResult SubmitQueueFence(vk::CommandBuffer& cmdbuf, VkSemaphore signal_semaphore, VkSemaphore wait_semaphore, u64 host_tick); + void WaitThread(std::stop_token token); + + vk::Fence GetFreeFence(); + private: const Device& device; ///< Device. - vk::Fence fence; ///< Fence. vk::Semaphore semaphore; ///< Timeline semaphore. std::atomic<u64> gpu_tick{0}; ///< Current known GPU tick. std::atomic<u64> current_tick{1}; ///< Current logical tick. + std::mutex wait_mutex; + std::mutex free_mutex; + std::condition_variable_any wait_cv; + std::queue<Waitable> wait_queue; ///< Queue for the fences to be waited on by the wait thread. + std::deque<vk::Fence> free_queue; ///< Holds available fences for submission. std::jthread debug_thread; ///< Debug thread to workaround validation layer bugs. + std::jthread wait_thread; ///< Helper thread that waits for submitted fences. }; } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp index 1e80ce463..8c0dec590 100644 --- a/src/video_core/renderer_vulkan/vk_swapchain.cpp +++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp @@ -34,8 +34,8 @@ VkSurfaceFormatKHR ChooseSwapSurfaceFormat(vk::Span<VkSurfaceFormatKHR> formats) return found != formats.end() ? *found : formats[0]; } -static constexpr VkPresentModeKHR ChooseSwapPresentMode(bool has_imm, bool has_mailbox, - bool has_fifo_relaxed) { +static VkPresentModeKHR ChooseSwapPresentMode(bool has_imm, bool has_mailbox, + bool has_fifo_relaxed) { // Mailbox doesn't lock the application like FIFO (vsync) // FIFO present mode locks the framerate to the monitor's refresh rate Settings::VSyncMode setting = [has_imm, has_mailbox]() { diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp index 4d0481f2a..8711e2a87 100644 --- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp @@ -861,6 +861,10 @@ VkBuffer TextureCacheRuntime::GetTemporaryBuffer(size_t needed_size) { return *buffers[level]; } +void TextureCacheRuntime::BarrierFeedbackLoop() { + scheduler.RequestOutsideRenderPassOperationContext(); +} + void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies) { std::vector<VkBufferImageCopy> vk_in_copies(copies.size()); @@ -1268,7 +1272,9 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu if (IsPixelFormatASTC(info.format) && !runtime->device.IsOptimalAstcSupported()) { if (Settings::values.async_astc.GetValue()) { flags |= VideoCommon::ImageFlagBits::AsynchronousDecode; - } else if (Settings::values.accelerate_astc.GetValue() && info.size.depth == 1) { + } else if (Settings::values.astc_recompression.GetValue() == + Settings::AstcRecompression::Uncompressed && + Settings::values.accelerate_astc.GetValue() && info.size.depth == 1) { flags |= VideoCommon::ImageFlagBits::AcceleratedUpload; } flags |= VideoCommon::ImageFlagBits::Converted; @@ -1283,7 +1289,9 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu .usage = VK_IMAGE_USAGE_STORAGE_BIT, }; current_image = *original_image; - if (IsPixelFormatASTC(info.format) && !runtime->device.IsOptimalAstcSupported()) { + if (IsPixelFormatASTC(info.format) && !runtime->device.IsOptimalAstcSupported() && + Settings::values.astc_recompression.GetValue() == + Settings::AstcRecompression::Uncompressed) { const auto& device = runtime->device.GetLogical(); storage_image_views.reserve(info.resources.levels); for (s32 level = 0; level < info.resources.levels; ++level) { diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h index 4166b3d20..0f7a5ffd4 100644 --- a/src/video_core/renderer_vulkan/vk_texture_cache.h +++ b/src/video_core/renderer_vulkan/vk_texture_cache.h @@ -103,6 +103,8 @@ public: [[nodiscard]] VkBuffer GetTemporaryBuffer(size_t needed_size); + void BarrierFeedbackLoop(); + const Device& device; Scheduler& scheduler; MemoryAllocator& memory_allocator; diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h index b24086fce..fe13cac93 100644 --- a/src/video_core/texture_cache/texture_cache.h +++ b/src/video_core/texture_cache/texture_cache.h @@ -49,8 +49,8 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface& if constexpr (HAS_DEVICE_MEMORY_INFO) { const s64 device_memory = static_cast<s64>(runtime.GetDeviceLocalMemory()); - const s64 min_spacing_expected = device_memory - 1_GiB - 512_MiB; - const s64 min_spacing_critical = device_memory - 1_GiB; + const s64 min_spacing_expected = device_memory - 1_GiB; + const s64 min_spacing_critical = device_memory - 512_MiB; const s64 mem_threshold = std::min(device_memory, TARGET_THRESHOLD); const s64 min_vacancy_expected = (6 * mem_threshold) / 10; const s64 min_vacancy_critical = (3 * mem_threshold) / 10; @@ -86,10 +86,12 @@ void TextureCache<P>::RunGarbageCollector() { // used by the async decoder thread. return false; } + if (!aggressive_mode && True(image.flags & ImageFlagBits::CostlyLoad)) { + return false; + } const bool must_download = image.IsSafeDownload() && False(image.flags & ImageFlagBits::BadOverlap); - if (!high_priority_mode && - (must_download || True(image.flags & ImageFlagBits::CostlyLoad))) { + if (!high_priority_mode && must_download) { return false; } if (must_download) { @@ -137,7 +139,6 @@ void TextureCache<P>::TickFrame() { TickAsyncDecode(); runtime.TickFrame(); - critical_gc = 0; ++frame_tick; if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) { @@ -184,6 +185,42 @@ void TextureCache<P>::FillComputeImageViews(std::span<ImageViewInOut> views) { } template <class P> +void TextureCache<P>::CheckFeedbackLoop(std::span<const ImageViewInOut> views) { + const bool requires_barrier = [&] { + for (const auto& view : views) { + if (!view.id) { + continue; + } + auto& image_view = slot_image_views[view.id]; + + // Check color targets + for (const auto& ct_view_id : render_targets.color_buffer_ids) { + if (ct_view_id) { + auto& ct_view = slot_image_views[ct_view_id]; + if (image_view.image_id == ct_view.image_id) { + return true; + } + } + } + + // Check zeta target + if (render_targets.depth_buffer_id) { + auto& zt_view = slot_image_views[render_targets.depth_buffer_id]; + if (image_view.image_id == zt_view.image_id) { + return true; + } + } + } + + return false; + }(); + + if (requires_barrier) { + runtime.BarrierFeedbackLoop(); + } +} + +template <class P> typename P::Sampler* TextureCache<P>::GetGraphicsSampler(u32 index) { if (index > channel_state->graphics_sampler_table.Limit()) { LOG_DEBUG(HW_GPU, "Invalid sampler index={}", index); @@ -1469,7 +1506,7 @@ std::optional<typename TextureCache<P>::BlitImages> TextureCache<P>::GetBlitImag if (!copy.must_accelerate) { do { if (!src_id && !dst_id) { - break; + return std::nullopt; } if (src_id && True(slot_images[src_id].flags & ImageFlagBits::GpuModified)) { break; @@ -1847,10 +1884,6 @@ void TextureCache<P>::RegisterImage(ImageId image_id) { tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format); } total_used_memory += Common::AlignUp(tentative_size, 1024); - if (total_used_memory > critical_memory && critical_gc < GC_EMERGENCY_COUNTS) { - RunGarbageCollector(); - critical_gc++; - } image.lru_index = lru_cache.Insert(image_id, frame_tick); ForEachGPUPage(image.gpu_addr, image.guest_size_bytes, [this, image_id](u64 page) { diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h index 0720494e5..cc27286f7 100644 --- a/src/video_core/texture_cache/texture_cache_base.h +++ b/src/video_core/texture_cache/texture_cache_base.h @@ -148,6 +148,9 @@ public: /// Fill image_view_ids with the compute images in indices void FillComputeImageViews(std::span<ImageViewInOut> views); + /// Handle feedback loops during draws. + void CheckFeedbackLoop(std::span<const ImageViewInOut> views); + /// Get the sampler from the graphics descriptor table in the specified index Sampler* GetGraphicsSampler(u32 index); @@ -424,7 +427,6 @@ private: u64 minimum_memory; u64 expected_memory; u64 critical_memory; - size_t critical_gc; struct BufferDownload { GPUVAddr address; diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp index f1071aa23..95a5b47d8 100644 --- a/src/video_core/texture_cache/util.cpp +++ b/src/video_core/texture_cache/util.cpp @@ -18,6 +18,8 @@ #include "common/bit_util.h" #include "common/common_types.h" #include "common/div_ceil.h" +#include "common/scratch_buffer.h" +#include "common/settings.h" #include "video_core/compatible_formats.h" #include "video_core/engines/maxwell_3d.h" #include "video_core/memory_manager.h" @@ -28,6 +30,7 @@ #include "video_core/texture_cache/samples_helper.h" #include "video_core/texture_cache/util.h" #include "video_core/textures/astc.h" +#include "video_core/textures/bcn.h" #include "video_core/textures/decoders.h" namespace VideoCommon { @@ -120,7 +123,9 @@ template <u32 GOB_EXTENT> return { .width = AdjustMipBlockSize<GOB_SIZE_X>(num_tiles.width, block_size.width, level), .height = AdjustMipBlockSize<GOB_SIZE_Y>(num_tiles.height, block_size.height, level), - .depth = AdjustMipBlockSize<GOB_SIZE_Z>(num_tiles.depth, block_size.depth, level), + .depth = level == 0 + ? block_size.depth + : AdjustMipBlockSize<GOB_SIZE_Z>(num_tiles.depth, block_size.depth, level), }; } @@ -162,6 +167,13 @@ template <u32 GOB_EXTENT> } [[nodiscard]] constexpr Extent3D TileShift(const LevelInfo& info, u32 level) { + if (level == 0) { + return Extent3D{ + .width = info.block.width, + .height = info.block.height, + .depth = info.block.depth, + }; + } const Extent3D blocks = NumLevelBlocks(info, level); return Extent3D{ .width = AdjustTileSize(info.block.width, GOB_SIZE_X, blocks.width), @@ -585,6 +597,21 @@ u32 CalculateConvertedSizeBytes(const ImageInfo& info) noexcept { return info.size.width * BytesPerBlock(info.format); } static constexpr Extent2D TILE_SIZE{1, 1}; + if (IsPixelFormatASTC(info.format) && Settings::values.astc_recompression.GetValue() != + Settings::AstcRecompression::Uncompressed) { + const u32 bpp_div = + Settings::values.astc_recompression.GetValue() == Settings::AstcRecompression::Bc1 ? 2 + : 1; + // NumBlocksPerLayer doesn't account for this correctly, so we have to do it manually. + u32 output_size = 0; + for (s32 i = 0; i < info.resources.levels; i++) { + const auto mip_size = AdjustMipSize(info.size, i); + const u32 plane_dim = + Common::AlignUp(mip_size.width, 4U) * Common::AlignUp(mip_size.height, 4U); + output_size += (plane_dim * info.size.depth * info.resources.layers) / bpp_div; + } + return output_size; + } return NumBlocksPerLayer(info, TILE_SIZE) * info.resources.layers * CONVERTED_BYTES_PER_BLOCK; } @@ -885,6 +912,7 @@ BufferCopy UploadBufferCopy(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8> output, std::span<BufferImageCopy> copies) { u32 output_offset = 0; + Common::ScratchBuffer<u8> decode_scratch; const Extent2D tile_size = DefaultBlockSize(info.format); for (BufferImageCopy& copy : copies) { @@ -895,22 +923,58 @@ void ConvertImage(std::span<const u8> input, const ImageInfo& info, std::span<u8 ASSERT(copy.image_extent == mip_size); ASSERT(copy.buffer_row_length == Common::AlignUp(mip_size.width, tile_size.width)); ASSERT(copy.buffer_image_height == Common::AlignUp(mip_size.height, tile_size.height)); - if (IsPixelFormatASTC(info.format)) { + + const auto input_offset = input.subspan(copy.buffer_offset); + copy.buffer_offset = output_offset; + copy.buffer_row_length = mip_size.width; + copy.buffer_image_height = mip_size.height; + + const auto recompression_setting = Settings::values.astc_recompression.GetValue(); + const bool astc = IsPixelFormatASTC(info.format); + + if (astc && recompression_setting == Settings::AstcRecompression::Uncompressed) { Tegra::Texture::ASTC::Decompress( - input.subspan(copy.buffer_offset), copy.image_extent.width, - copy.image_extent.height, + input_offset, copy.image_extent.width, copy.image_extent.height, copy.image_subresource.num_layers * copy.image_extent.depth, tile_size.width, tile_size.height, output.subspan(output_offset)); + + output_offset += copy.image_extent.width * copy.image_extent.height * + copy.image_subresource.num_layers * CONVERTED_BYTES_PER_BLOCK; + } else if (astc) { + // BC1 uses 0.5 bytes per texel + // BC3 uses 1 byte per texel + const auto compress = recompression_setting == Settings::AstcRecompression::Bc1 + ? Tegra::Texture::BCN::CompressBC1 + : Tegra::Texture::BCN::CompressBC3; + const auto bpp_div = recompression_setting == Settings::AstcRecompression::Bc1 ? 2 : 1; + + const u32 plane_dim = copy.image_extent.width * copy.image_extent.height; + const u32 level_size = plane_dim * copy.image_extent.depth * + copy.image_subresource.num_layers * CONVERTED_BYTES_PER_BLOCK; + decode_scratch.resize_destructive(level_size); + + Tegra::Texture::ASTC::Decompress( + input_offset, copy.image_extent.width, copy.image_extent.height, + copy.image_subresource.num_layers * copy.image_extent.depth, tile_size.width, + tile_size.height, decode_scratch); + + compress(decode_scratch, copy.image_extent.width, copy.image_extent.height, + copy.image_subresource.num_layers * copy.image_extent.depth, + output.subspan(output_offset)); + + const u32 aligned_plane_dim = Common::AlignUp(copy.image_extent.width, 4) * + Common::AlignUp(copy.image_extent.height, 4); + + copy.buffer_size = + (aligned_plane_dim * copy.image_extent.depth * copy.image_subresource.num_layers) / + bpp_div; + output_offset += static_cast<u32>(copy.buffer_size); } else { - DecompressBC4(input.subspan(copy.buffer_offset), copy.image_extent, - output.subspan(output_offset)); - } - copy.buffer_offset = output_offset; - copy.buffer_row_length = mip_size.width; - copy.buffer_image_height = mip_size.height; + DecompressBC4(input_offset, copy.image_extent, output.subspan(output_offset)); - output_offset += copy.image_extent.width * copy.image_extent.height * - copy.image_subresource.num_layers * CONVERTED_BYTES_PER_BLOCK; + output_offset += copy.image_extent.width * copy.image_extent.height * + copy.image_subresource.num_layers * CONVERTED_BYTES_PER_BLOCK; + } } } @@ -1233,7 +1297,9 @@ u32 MapSizeBytes(const ImageBase& image) { static_assert(CalculateLevelSize(LevelInfo{{1920, 1080, 1}, {0, 2, 0}, {1, 1}, 2, 0}, 0) == 0x7f8000); -static_assert(CalculateLevelSize(LevelInfo{{32, 32, 1}, {0, 0, 4}, {1, 1}, 4, 0}, 0) == 0x4000); +static_assert(CalculateLevelSize(LevelInfo{{32, 32, 1}, {0, 0, 4}, {1, 1}, 4, 0}, 0) == 0x40000); + +static_assert(CalculateLevelSize(LevelInfo{{128, 8, 1}, {0, 4, 0}, {1, 1}, 4, 0}, 0) == 0x40000); static_assert(CalculateLevelOffset(PixelFormat::R8_SINT, {1920, 1080, 1}, {0, 2, 0}, 0, 7) == 0x2afc00); diff --git a/src/video_core/textures/astc.cpp b/src/video_core/textures/astc.cpp index a68bc0d77..fef0be31d 100644 --- a/src/video_core/textures/astc.cpp +++ b/src/video_core/textures/astc.cpp @@ -16,8 +16,8 @@ #include "common/alignment.h" #include "common/common_types.h" #include "common/polyfill_ranges.h" -#include "common/thread_worker.h" #include "video_core/textures/astc.h" +#include "video_core/textures/workers.h" class InputBitStream { public: @@ -1656,8 +1656,7 @@ void Decompress(std::span<const uint8_t> data, uint32_t width, uint32_t height, const u32 rows = Common::DivideUp(height, block_height); const u32 cols = Common::DivideUp(width, block_width); - static Common::ThreadWorker workers{std::max(std::thread::hardware_concurrency(), 2U) / 2, - "ASTCDecompress"}; + Common::ThreadWorker& workers{GetThreadWorkers()}; for (u32 z = 0; z < depth; ++z) { const u32 depth_offset = z * height * width * 4; diff --git a/src/video_core/textures/bcn.cpp b/src/video_core/textures/bcn.cpp new file mode 100644 index 000000000..671212a49 --- /dev/null +++ b/src/video_core/textures/bcn.cpp @@ -0,0 +1,87 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include <stb_dxt.h> +#include <string.h> + +#include "common/alignment.h" +#include "video_core/textures/bcn.h" +#include "video_core/textures/workers.h" + +namespace Tegra::Texture::BCN { + +using BCNCompressor = void(u8* block_output, const u8* block_input, bool any_alpha); + +template <u32 BytesPerBlock, bool ThresholdAlpha = false> +void CompressBCN(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth, + std::span<uint8_t> output, BCNCompressor f) { + constexpr u8 alpha_threshold = 128; + constexpr u32 bytes_per_px = 4; + const u32 plane_dim = width * height; + + Common::ThreadWorker& workers{GetThreadWorkers()}; + + for (u32 z = 0; z < depth; z++) { + for (u32 y = 0; y < height; y += 4) { + auto compress_row = [z, y, width, height, plane_dim, f, data, output]() { + for (u32 x = 0; x < width; x += 4) { + // Gather 4x4 block of RGBA texels + u8 input_colors[4][4][4]; + bool any_alpha = false; + + for (u32 j = 0; j < 4; j++) { + for (u32 i = 0; i < 4; i++) { + const size_t coord = + (z * plane_dim + (y + j) * width + (x + i)) * bytes_per_px; + + if ((x + i < width) && (y + j < height)) { + if constexpr (ThresholdAlpha) { + if (data[coord + 3] >= alpha_threshold) { + input_colors[j][i][0] = data[coord + 0]; + input_colors[j][i][1] = data[coord + 1]; + input_colors[j][i][2] = data[coord + 2]; + input_colors[j][i][3] = 255; + } else { + any_alpha = true; + memset(input_colors[j][i], 0, bytes_per_px); + } + } else { + memcpy(input_colors[j][i], &data[coord], bytes_per_px); + } + } else { + memset(input_colors[j][i], 0, bytes_per_px); + } + } + } + + const u32 bytes_per_row = BytesPerBlock * Common::DivideUp(width, 4U); + const u32 bytes_per_plane = bytes_per_row * Common::DivideUp(height, 4U); + f(output.data() + z * bytes_per_plane + (y / 4) * bytes_per_row + + (x / 4) * BytesPerBlock, + reinterpret_cast<u8*>(input_colors), any_alpha); + } + }; + workers.QueueWork(std::move(compress_row)); + } + workers.WaitForRequests(); + } +} + +void CompressBC1(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth, + std::span<uint8_t> output) { + CompressBCN<8, true>(data, width, height, depth, output, + [](u8* block_output, const u8* block_input, bool any_alpha) { + stb_compress_bc1_block(block_output, block_input, any_alpha, + STB_DXT_NORMAL); + }); +} + +void CompressBC3(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth, + std::span<uint8_t> output) { + CompressBCN<16, false>(data, width, height, depth, output, + [](u8* block_output, const u8* block_input, bool any_alpha) { + stb_compress_bc3_block(block_output, block_input, STB_DXT_NORMAL); + }); +} + +} // namespace Tegra::Texture::BCN diff --git a/src/video_core/textures/bcn.h b/src/video_core/textures/bcn.h new file mode 100644 index 000000000..6464af885 --- /dev/null +++ b/src/video_core/textures/bcn.h @@ -0,0 +1,17 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include <span> +#include <stdint.h> + +namespace Tegra::Texture::BCN { + +void CompressBC1(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth, + std::span<uint8_t> output); + +void CompressBC3(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth, + std::span<uint8_t> output); + +} // namespace Tegra::Texture::BCN diff --git a/src/video_core/textures/workers.cpp b/src/video_core/textures/workers.cpp new file mode 100644 index 000000000..a71c305f4 --- /dev/null +++ b/src/video_core/textures/workers.cpp @@ -0,0 +1,15 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "video_core/textures/workers.h" + +namespace Tegra::Texture { + +Common::ThreadWorker& GetThreadWorkers() { + static Common::ThreadWorker workers{std::max(std::thread::hardware_concurrency(), 2U) / 2, + "ImageTranscode"}; + + return workers; +} + +} // namespace Tegra::Texture diff --git a/src/video_core/textures/workers.h b/src/video_core/textures/workers.h new file mode 100644 index 000000000..008dd05b3 --- /dev/null +++ b/src/video_core/textures/workers.h @@ -0,0 +1,12 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "common/thread_worker.h" + +namespace Tegra::Texture { + +Common::ThreadWorker& GetThreadWorkers(); + +} diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp index f6e6f2736..3a7c2dedf 100644 --- a/src/video_core/vulkan_common/vulkan_device.cpp +++ b/src/video_core/vulkan_common/vulkan_device.cpp @@ -1001,6 +1001,11 @@ u64 Device::GetDeviceMemoryUsage() const { } void Device::CollectPhysicalMemoryInfo() { + // Account for resolution scaling in memory limits + const size_t normal_memory = 6_GiB; + const size_t scaler_memory = 1_GiB * Settings::values.resolution_info.ScaleUp(1); + + // Calculate limits using memory budget VkPhysicalDeviceMemoryBudgetPropertiesEXT budget{}; budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; const auto mem_info = @@ -1030,11 +1035,12 @@ void Device::CollectPhysicalMemoryInfo() { if (!is_integrated) { const u64 reserve_memory = std::min<u64>(device_access_memory / 8, 1_GiB); device_access_memory -= reserve_memory; + device_access_memory = std::min<u64>(device_access_memory, normal_memory + scaler_memory); return; } const s64 available_memory = static_cast<s64>(device_access_memory - device_initial_usage); device_access_memory = static_cast<u64>(std::max<s64>( - std::min<s64>(available_memory - 8_GiB, 4_GiB), static_cast<s64>(local_memory))); + std::min<s64>(available_memory - 8_GiB, 4_GiB), std::min<s64>(local_memory, 4_GiB))); } void Device::CollectToolingInfo() { diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp index 70737c54e..662651196 100644 --- a/src/yuzu/configuration/config.cpp +++ b/src/yuzu/configuration/config.cpp @@ -711,6 +711,7 @@ void Config::ReadRendererValues() { ReadGlobalSetting(Settings::values.nvdec_emulation); ReadGlobalSetting(Settings::values.accelerate_astc); ReadGlobalSetting(Settings::values.async_astc); + ReadGlobalSetting(Settings::values.astc_recompression); ReadGlobalSetting(Settings::values.use_reactive_flushing); ReadGlobalSetting(Settings::values.shader_backend); ReadGlobalSetting(Settings::values.use_asynchronous_shaders); @@ -1359,6 +1360,10 @@ void Config::SaveRendererValues() { Settings::values.nvdec_emulation.UsingGlobal()); WriteGlobalSetting(Settings::values.accelerate_astc); WriteGlobalSetting(Settings::values.async_astc); + WriteSetting(QString::fromStdString(Settings::values.astc_recompression.GetLabel()), + static_cast<u32>(Settings::values.astc_recompression.GetValue(global)), + static_cast<u32>(Settings::values.astc_recompression.GetDefault()), + Settings::values.astc_recompression.UsingGlobal()); WriteGlobalSetting(Settings::values.use_reactive_flushing); WriteSetting(QString::fromStdString(Settings::values.shader_backend.GetLabel()), static_cast<u32>(Settings::values.shader_backend.GetValue(global)), diff --git a/src/yuzu/configuration/config.h b/src/yuzu/configuration/config.h index 7d26e9ab6..9cb9db6cf 100644 --- a/src/yuzu/configuration/config.h +++ b/src/yuzu/configuration/config.h @@ -208,3 +208,4 @@ Q_DECLARE_METATYPE(Settings::ScalingFilter); Q_DECLARE_METATYPE(Settings::AntiAliasing); Q_DECLARE_METATYPE(Settings::RendererBackend); Q_DECLARE_METATYPE(Settings::ShaderBackend); +Q_DECLARE_METATYPE(Settings::AstcRecompression); diff --git a/src/yuzu/configuration/configure_graphics_advanced.cpp b/src/yuzu/configuration/configure_graphics_advanced.cpp index 1f3e489d0..896863f87 100644 --- a/src/yuzu/configuration/configure_graphics_advanced.cpp +++ b/src/yuzu/configuration/configure_graphics_advanced.cpp @@ -27,6 +27,7 @@ void ConfigureGraphicsAdvanced::SetConfiguration() { ui->async_present->setEnabled(runtime_lock); ui->renderer_force_max_clock->setEnabled(runtime_lock); ui->async_astc->setEnabled(runtime_lock); + ui->astc_recompression_combobox->setEnabled(runtime_lock); ui->use_asynchronous_shaders->setEnabled(runtime_lock); ui->anisotropic_filtering_combobox->setEnabled(runtime_lock); ui->enable_compute_pipelines_checkbox->setEnabled(runtime_lock); @@ -47,14 +48,20 @@ void ConfigureGraphicsAdvanced::SetConfiguration() { static_cast<int>(Settings::values.gpu_accuracy.GetValue())); ui->anisotropic_filtering_combobox->setCurrentIndex( Settings::values.max_anisotropy.GetValue()); + ui->astc_recompression_combobox->setCurrentIndex( + static_cast<int>(Settings::values.astc_recompression.GetValue())); } else { ConfigurationShared::SetPerGameSetting(ui->gpu_accuracy, &Settings::values.gpu_accuracy); ConfigurationShared::SetPerGameSetting(ui->anisotropic_filtering_combobox, &Settings::values.max_anisotropy); + ConfigurationShared::SetPerGameSetting(ui->astc_recompression_combobox, + &Settings::values.astc_recompression); ConfigurationShared::SetHighlight(ui->label_gpu_accuracy, !Settings::values.gpu_accuracy.UsingGlobal()); ConfigurationShared::SetHighlight(ui->af_label, !Settings::values.max_anisotropy.UsingGlobal()); + ConfigurationShared::SetHighlight(ui->label_astc_recompression, + !Settings::values.astc_recompression.UsingGlobal()); } } @@ -71,6 +78,8 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() { ui->use_reactive_flushing, use_reactive_flushing); ConfigurationShared::ApplyPerGameSetting(&Settings::values.async_astc, ui->async_astc, async_astc); + ConfigurationShared::ApplyPerGameSetting(&Settings::values.astc_recompression, + ui->astc_recompression_combobox); ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders, ui->use_asynchronous_shaders, use_asynchronous_shaders); @@ -105,6 +114,8 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() { Settings::values.renderer_force_max_clock.UsingGlobal()); ui->use_reactive_flushing->setEnabled(Settings::values.use_reactive_flushing.UsingGlobal()); ui->async_astc->setEnabled(Settings::values.async_astc.UsingGlobal()); + ui->astc_recompression_combobox->setEnabled( + Settings::values.astc_recompression.UsingGlobal()); ui->use_asynchronous_shaders->setEnabled( Settings::values.use_asynchronous_shaders.UsingGlobal()); ui->use_fast_gpu_time->setEnabled(Settings::values.use_fast_gpu_time.UsingGlobal()); @@ -144,6 +155,9 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() { ConfigurationShared::SetColoredComboBox( ui->anisotropic_filtering_combobox, ui->af_label, static_cast<int>(Settings::values.max_anisotropy.GetValue(true))); + ConfigurationShared::SetColoredComboBox( + ui->astc_recompression_combobox, ui->label_astc_recompression, + static_cast<int>(Settings::values.astc_recompression.GetValue(true))); } void ConfigureGraphicsAdvanced::ExposeComputeOption() { diff --git a/src/yuzu/configuration/configure_graphics_advanced.ui b/src/yuzu/configuration/configure_graphics_advanced.ui index 9ef7c8e8f..37757a918 100644 --- a/src/yuzu/configuration/configure_graphics_advanced.ui +++ b/src/yuzu/configuration/configure_graphics_advanced.ui @@ -70,6 +70,50 @@ </widget> </item> <item> + <widget class="QWidget" name="astc_recompression_layout" native="true"> + <layout class="QHBoxLayout" name="horizontalLayout_3"> + <property name="leftMargin"> + <number>0</number> + </property> + <property name="topMargin"> + <number>0</number> + </property> + <property name="rightMargin"> + <number>0</number> + </property> + <property name="bottomMargin"> + <number>0</number> + </property> + <item> + <widget class="QLabel" name="label_astc_recompression"> + <property name="text"> + <string>ASTC recompression:</string> + </property> + </widget> + </item> + <item> + <widget class="QComboBox" name="astc_recompression_combobox"> + <item> + <property name="text"> + <string>Uncompressed (Best quality)</string> + </property> + </item> + <item> + <property name="text"> + <string>BC1 (Low quality)</string> + </property> + </item> + <item> + <property name="text"> + <string>BC3 (Medium quality)</string> + </property> + </item> + </widget> + </item> + </layout> + </widget> + </item> + <item> <widget class="QCheckBox" name="async_present"> <property name="text"> <string>Enable asynchronous presentation (Vulkan only)</string> diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp index dc9a3d68f..c5bc472ca 100644 --- a/src/yuzu_cmd/config.cpp +++ b/src/yuzu_cmd/config.cpp @@ -318,6 +318,7 @@ void Config::ReadValues() { ReadSetting("Renderer", Settings::values.nvdec_emulation); ReadSetting("Renderer", Settings::values.accelerate_astc); ReadSetting("Renderer", Settings::values.async_astc); + ReadSetting("Renderer", Settings::values.astc_recompression); ReadSetting("Renderer", Settings::values.use_fast_gpu_time); ReadSetting("Renderer", Settings::values.use_vulkan_driver_pipeline_cache); diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h index 5e7c3ac04..644a30e59 100644 --- a/src/yuzu_cmd/default_ini.h +++ b/src/yuzu_cmd/default_ini.h @@ -360,6 +360,10 @@ accelerate_astc = # 0 (default): Off, 1: On async_astc = +# Recompress ASTC textures to a different format. +# 0 (default): Uncompressed, 1: BC1 (Low quality), 2: BC3: (Medium quality) +async_astc = + # Turns on the speed limiter, which will limit the emulation speed to the desired speed limit value # 0: Off, 1: On (default) use_speed_limit = diff --git a/src/yuzu_cmd/yuzu.cpp b/src/yuzu_cmd/yuzu.cpp index 5f39ece32..7b6d49c63 100644 --- a/src/yuzu_cmd/yuzu.cpp +++ b/src/yuzu_cmd/yuzu.cpp @@ -227,7 +227,7 @@ int main(int argc, char** argv) { }; while (optind < argc) { - int arg = getopt_long(argc, argv, "g:fhvp::c:", long_options, &option_index); + int arg = getopt_long(argc, argv, "g:fhvp::c:u:", long_options, &option_index); if (arg != -1) { switch (static_cast<char>(arg)) { case 'c': @@ -283,7 +283,7 @@ int main(int argc, char** argv) { break; case 'u': selected_user = atoi(optarg); - return 0; + break; case 'v': PrintVersion(); return 0; |