ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Reformat all the things!

This commit is contained in:
spycrab 2018-04-12 14:18:04 +02:00
parent d27e85e9d7
commit 40bb9974f2
179 changed files with 1888 additions and 991 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/.clang-format
View File

@ -10,7 +10,7 @@ AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortFunctionsOnASingleLine: InlineOnly
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None

3
Source/Core/AudioCommon/AlsaSoundStream.cpp
View File

@ -186,7 +186,8 @@ bool AlsaSound::AlsaInit()
// it is probably a bad idea to try to send more than one buffer of data
if ((unsigned int)frames_to_deliver > buffer_size)
frames_to_deliver = buffer_size;
NOTICE_LOG(AUDIO, "ALSA gave us a %ld sample \"hardware\" buffer with %d periods. Will send %d "
NOTICE_LOG(AUDIO,
"ALSA gave us a %ld sample \"hardware\" buffer with %d periods. Will send %d "
"samples per fragments.",
buffer_size, periods, frames_to_deliver);

1
Source/Core/AudioCommon/AlsaSoundStream.h
View File

@ -29,6 +29,7 @@ public:
bool SetRunning(bool running) override;
static bool isValid() { return true; }
private:
// maximum number of frames the buffer can hold
static constexpr size_t BUFFER_SIZE_MAX = 8192;

1
Source/Core/AudioCommon/Mixer.h
View File

@ -44,6 +44,7 @@ public:
float GetCurrentSpeed() const { return m_speed.load(); }
void UpdateSpeed(float val) { m_speed.store(val); }
private:
static constexpr u32 MAX_SAMPLES = 1024 * 4; // 128 ms
static constexpr u32 INDEX_MASK = MAX_SAMPLES * 2 - 1;

1
Source/Core/AudioCommon/OpenSLESStream.h
View File

@ -17,6 +17,7 @@ public:
bool Init() override;
bool SetRunning(bool running) override { return running; }
static bool isValid() { return true; }
private:
std::thread thread;
Common::Event soundSyncEvent;

1
Source/Core/AudioCommon/WaveFile.h
View File

@ -37,6 +37,7 @@ public:
void SetSkipSilence(bool skip) { skip_silence = skip; }
void AddStereoSamplesBE(const short* sample_data, u32 count, int sample_rate); // big endian
u32 GetAudioSize() const { return audio_size; }
private:
static constexpr size_t BUFFER_SIZE = 32 * 1024;

1
Source/Core/Common/Analytics.h
View File

@ -148,6 +148,7 @@ public:
// For convenience.
void Send(AnalyticsReportBuilder& report) { Send(std::move(report)); }
protected:
void ThreadProc();

8
Source/Core/Common/Arm64Emitter.cpp
View File

@ -201,8 +201,12 @@ bool IsImmLogical(uint64_t value, unsigned int width, unsigned int* n, unsigned
// (1 + 2^d + 2^(2d) + ...), i.e. 0x0001000100010001 or similar. These can
// be derived using a table lookup on CLZ(d).
static const std::array<uint64_t, 6> multipliers = {{
0x0000000000000001UL, 0x0000000100000001UL, 0x0001000100010001UL, 0x0101010101010101UL,
0x1111111111111111UL, 0x5555555555555555UL,
0x0000000000000001UL,
0x0000000100000001UL,
0x0001000100010001UL,
0x0101010101010101UL,
0x1111111111111111UL,
0x5555555555555555UL,
}};
int multiplier_idx = CountLeadingZeros(d, kXRegSizeInBits) - 57;

1
Source/Core/Common/BitField.h
View File

@ -147,6 +147,7 @@ public:
constexpr operator T() const { return Value(); }
constexpr std::size_t StartBit() const { return position; }
constexpr std::size_t NumBits() const { return bits; }
private:
// StorageType is T for non-enum types and the underlying type of T if
// T is an enumeration. Note that T is wrapped within an enable_if in the

1
Source/Core/Common/BitSet.h
View File

@ -164,6 +164,7 @@ public:
constexpr int operator*() const { return m_bit; }
constexpr bool operator==(Iterator other) const { return m_bit == other.m_bit; }
constexpr bool operator!=(Iterator other) const { return m_bit != other.m_bit; }
private:
IntTy m_val;
int m_bit;

1
Source/Core/Common/BlockingLoop.h
View File

@ -230,6 +230,7 @@ public:
// This function should be triggered regularly over time so
// that we will fall back from the busy loop to sleeping.
void AllowSleep() { m_may_sleep.Set(); }
private:
std::mutex m_wait_lock;
std::mutex m_prepare_lock;

6
Source/Core/Common/CompatPatches.cpp
View File

@ -203,8 +203,7 @@ static bool GetModuleVersion(const wchar_t* name, Version* version)
void CompatPatchesInstall(LdrWatcher* watcher)
{
watcher->Install({{L"EZFRD64.dll", L"811EZFRD64.DLL"},
[](const LdrDllLoadEvent& event) {
watcher->Install({{L"EZFRD64.dll", L"811EZFRD64.DLL"}, [](const LdrDllLoadEvent& event) {
// *EZFRD64 is incldued in software packages for cheapo third-party gamepads
// (and gamepad adapters). The module cannot handle its heap being above 4GB,
// which tends to happen very often on modern Windows.
@ -214,8 +213,7 @@ void CompatPatchesInstall(LdrWatcher* watcher)
auto patcher = ImportPatcher(event.base_address);
patcher.PatchIAT("kernel32.dll", "HeapCreate", HeapCreateLow4GB);
}});
watcher->Install({{L"ucrtbase.dll"},
[](const LdrDllLoadEvent& event) {
watcher->Install({{L"ucrtbase.dll"}, [](const LdrDllLoadEvent& event) {
// ucrtbase implements caching between fseek/fread, old versions have a bug
// such that some reads return incorrect data. This causes noticable bugs
// in dolphin since we use these APIs for reading game images.

9
Source/Core/Common/Config/Enums.h
View File

@ -34,7 +34,12 @@ enum class System
};
constexpr std::array<LayerType, 7> SEARCH_ORDER{{
LayerType::CurrentRun, LayerType::CommandLine, LayerType::Movie, LayerType::Netplay,
LayerType::LocalGame, LayerType::GlobalGame, LayerType::Base,
LayerType::CurrentRun,
LayerType::CommandLine,
LayerType::Movie,
LayerType::Netplay,
LayerType::LocalGame,
LayerType::GlobalGame,
LayerType::Base,
}};
}

2
Source/Core/Common/Config/Layer.h
View File

@ -69,6 +69,7 @@ public:
Section(iterator begin_, iterator end_) : m_begin(begin_), m_end(end_) {}
iterator begin() const { return m_begin; }
iterator end() const { return m_end; }
private:
iterator m_begin;
iterator m_end;
@ -81,6 +82,7 @@ public:
ConstSection(iterator begin_, iterator end_) : m_begin(begin_), m_end(end_) {}
iterator begin() const { return m_begin; }
iterator end() const { return m_end; }
private:
iterator m_begin;
iterator m_end;

1
Source/Core/Common/DebugInterface.h
View File

@ -12,6 +12,7 @@ class DebugInterface
{
protected:
virtual ~DebugInterface() {}
public:
virtual std::string Disassemble(unsigned int /*address*/) { return "NODEBUGGER"; }
virtual std::string GetRawMemoryString(int /*memory*/, unsigned int /*address*/)

1
Source/Core/Common/FixedSizeQueue.h
View File

@ -51,6 +51,7 @@ public:
T& front() { return storage[head]; }
const T& front() const { return storage[head]; }
size_t size() const { return count; }
private:
std::array<T, N> storage;
int head = 0;

1
Source/Core/Common/Flag.h
View File

@ -38,6 +38,7 @@ public:
}
bool TestAndClear() { return TestAndSet(false); }
private:
std::atomic_bool m_val;
};

828
Source/Core/Common/GL/GLExtensions/GLExtensions.cpp
View File

@ -1041,301 +1041,566 @@ struct GLFunc
const GLFunc gl_function_array[] = {
// gl_1_1
GLFUNC_ALWAYS_REQUIRED(glClearIndex), GLFUNC_ALWAYS_REQUIRED(glIndexMask),
GLFUNC_ALWAYS_REQUIRED(glAlphaFunc), GLFUNC_ALWAYS_REQUIRED(glLogicOp),
GLFUNC_ALWAYS_REQUIRED(glPointSize), GLFUNC_ALWAYS_REQUIRED(glLineStipple),
GLFUNC_ALWAYS_REQUIRED(glPolygonMode), GLFUNC_ALWAYS_REQUIRED(glPolygonStipple),
GLFUNC_ALWAYS_REQUIRED(glGetPolygonStipple), GLFUNC_ALWAYS_REQUIRED(glEdgeFlag),
GLFUNC_ALWAYS_REQUIRED(glEdgeFlagv), GLFUNC_ALWAYS_REQUIRED(glClipPlane),
GLFUNC_ALWAYS_REQUIRED(glGetClipPlane), GLFUNC_ALWAYS_REQUIRED(glDrawBuffer),
GLFUNC_ALWAYS_REQUIRED(glEnableClientState), GLFUNC_ALWAYS_REQUIRED(glDisableClientState),
GLFUNC_ALWAYS_REQUIRED(glGetDoublev), GLFUNC_ALWAYS_REQUIRED(glPushAttrib),
GLFUNC_ALWAYS_REQUIRED(glPopAttrib), GLFUNC_ALWAYS_REQUIRED(glPushClientAttrib),
GLFUNC_ALWAYS_REQUIRED(glPopClientAttrib), GLFUNC_ALWAYS_REQUIRED(glRenderMode),
GLFUNC_ALWAYS_REQUIRED(glClearDepth), GLFUNC_ALWAYS_REQUIRED(glDepthRange),
GLFUNC_ALWAYS_REQUIRED(glClearAccum), GLFUNC_ALWAYS_REQUIRED(glAccum),
GLFUNC_ALWAYS_REQUIRED(glMatrixMode), GLFUNC_ALWAYS_REQUIRED(glOrtho),
GLFUNC_ALWAYS_REQUIRED(glFrustum), GLFUNC_ALWAYS_REQUIRED(glPushMatrix),
GLFUNC_ALWAYS_REQUIRED(glPopMatrix), GLFUNC_ALWAYS_REQUIRED(glLoadIdentity),
GLFUNC_ALWAYS_REQUIRED(glLoadMatrixd), GLFUNC_ALWAYS_REQUIRED(glLoadMatrixf),
GLFUNC_ALWAYS_REQUIRED(glMultMatrixd), GLFUNC_ALWAYS_REQUIRED(glMultMatrixf),
GLFUNC_ALWAYS_REQUIRED(glRotated), GLFUNC_ALWAYS_REQUIRED(glRotatef),
GLFUNC_ALWAYS_REQUIRED(glScaled), GLFUNC_ALWAYS_REQUIRED(glScalef),
GLFUNC_ALWAYS_REQUIRED(glTranslated), GLFUNC_ALWAYS_REQUIRED(glTranslatef),
GLFUNC_ALWAYS_REQUIRED(glIsList), GLFUNC_ALWAYS_REQUIRED(glDeleteLists),
GLFUNC_ALWAYS_REQUIRED(glGenLists), GLFUNC_ALWAYS_REQUIRED(glNewList),
GLFUNC_ALWAYS_REQUIRED(glEndList), GLFUNC_ALWAYS_REQUIRED(glCallList),
GLFUNC_ALWAYS_REQUIRED(glCallLists), GLFUNC_ALWAYS_REQUIRED(glListBase),
GLFUNC_ALWAYS_REQUIRED(glBegin), GLFUNC_ALWAYS_REQUIRED(glEnd),
GLFUNC_ALWAYS_REQUIRED(glVertex2d), GLFUNC_ALWAYS_REQUIRED(glVertex2f),
GLFUNC_ALWAYS_REQUIRED(glVertex2i), GLFUNC_ALWAYS_REQUIRED(glVertex2s),
GLFUNC_ALWAYS_REQUIRED(glVertex3d), GLFUNC_ALWAYS_REQUIRED(glVertex3f),
GLFUNC_ALWAYS_REQUIRED(glVertex3i), GLFUNC_ALWAYS_REQUIRED(glVertex3s),
GLFUNC_ALWAYS_REQUIRED(glVertex4d), GLFUNC_ALWAYS_REQUIRED(glVertex4f),
GLFUNC_ALWAYS_REQUIRED(glVertex4i), GLFUNC_ALWAYS_REQUIRED(glVertex4s),
GLFUNC_ALWAYS_REQUIRED(glVertex2dv), GLFUNC_ALWAYS_REQUIRED(glVertex2fv),
GLFUNC_ALWAYS_REQUIRED(glVertex2iv), GLFUNC_ALWAYS_REQUIRED(glVertex2sv),
GLFUNC_ALWAYS_REQUIRED(glVertex3dv), GLFUNC_ALWAYS_REQUIRED(glVertex3fv),
GLFUNC_ALWAYS_REQUIRED(glVertex3iv), GLFUNC_ALWAYS_REQUIRED(glVertex3sv),
GLFUNC_ALWAYS_REQUIRED(glVertex4dv), GLFUNC_ALWAYS_REQUIRED(glVertex4fv),
GLFUNC_ALWAYS_REQUIRED(glVertex4iv), GLFUNC_ALWAYS_REQUIRED(glVertex4sv),
GLFUNC_ALWAYS_REQUIRED(glNormal3b), GLFUNC_ALWAYS_REQUIRED(glNormal3d),
GLFUNC_ALWAYS_REQUIRED(glNormal3f), GLFUNC_ALWAYS_REQUIRED(glNormal3i),
GLFUNC_ALWAYS_REQUIRED(glNormal3s), GLFUNC_ALWAYS_REQUIRED(glNormal3bv),
GLFUNC_ALWAYS_REQUIRED(glNormal3dv), GLFUNC_ALWAYS_REQUIRED(glNormal3fv),
GLFUNC_ALWAYS_REQUIRED(glNormal3iv), GLFUNC_ALWAYS_REQUIRED(glNormal3sv),
GLFUNC_ALWAYS_REQUIRED(glIndexd), GLFUNC_ALWAYS_REQUIRED(glIndexf),
GLFUNC_ALWAYS_REQUIRED(glIndexi), GLFUNC_ALWAYS_REQUIRED(glIndexs),
GLFUNC_ALWAYS_REQUIRED(glIndexub), GLFUNC_ALWAYS_REQUIRED(glIndexdv),
GLFUNC_ALWAYS_REQUIRED(glIndexfv), GLFUNC_ALWAYS_REQUIRED(glIndexiv),
GLFUNC_ALWAYS_REQUIRED(glIndexsv), GLFUNC_ALWAYS_REQUIRED(glIndexubv),
GLFUNC_ALWAYS_REQUIRED(glColor3b), GLFUNC_ALWAYS_REQUIRED(glColor3d),
GLFUNC_ALWAYS_REQUIRED(glColor3f), GLFUNC_ALWAYS_REQUIRED(glColor3i),
GLFUNC_ALWAYS_REQUIRED(glColor3s), GLFUNC_ALWAYS_REQUIRED(glColor3ub),
GLFUNC_ALWAYS_REQUIRED(glColor3ui), GLFUNC_ALWAYS_REQUIRED(glColor3us),
GLFUNC_ALWAYS_REQUIRED(glColor4b), GLFUNC_ALWAYS_REQUIRED(glColor4d),
GLFUNC_ALWAYS_REQUIRED(glColor4f), GLFUNC_ALWAYS_REQUIRED(glColor4i),
GLFUNC_ALWAYS_REQUIRED(glColor4s), GLFUNC_ALWAYS_REQUIRED(glColor4ub),
GLFUNC_ALWAYS_REQUIRED(glColor4ui), GLFUNC_ALWAYS_REQUIRED(glColor4us),
GLFUNC_ALWAYS_REQUIRED(glColor3bv), GLFUNC_ALWAYS_REQUIRED(glColor3dv),
GLFUNC_ALWAYS_REQUIRED(glColor3fv), GLFUNC_ALWAYS_REQUIRED(glColor3iv),
GLFUNC_ALWAYS_REQUIRED(glColor3sv), GLFUNC_ALWAYS_REQUIRED(glColor3ubv),
GLFUNC_ALWAYS_REQUIRED(glColor3uiv), GLFUNC_ALWAYS_REQUIRED(glColor3usv),
GLFUNC_ALWAYS_REQUIRED(glColor4bv), GLFUNC_ALWAYS_REQUIRED(glColor4dv),
GLFUNC_ALWAYS_REQUIRED(glColor4fv), GLFUNC_ALWAYS_REQUIRED(glColor4iv),
GLFUNC_ALWAYS_REQUIRED(glColor4sv), GLFUNC_ALWAYS_REQUIRED(glColor4ubv),
GLFUNC_ALWAYS_REQUIRED(glColor4uiv), GLFUNC_ALWAYS_REQUIRED(glColor4usv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1d), GLFUNC_ALWAYS_REQUIRED(glTexCoord1f),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1i), GLFUNC_ALWAYS_REQUIRED(glTexCoord1s),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2d), GLFUNC_ALWAYS_REQUIRED(glTexCoord2f),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2i), GLFUNC_ALWAYS_REQUIRED(glTexCoord2s),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3d), GLFUNC_ALWAYS_REQUIRED(glTexCoord3f),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3i), GLFUNC_ALWAYS_REQUIRED(glTexCoord3s),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4d), GLFUNC_ALWAYS_REQUIRED(glTexCoord4f),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4i), GLFUNC_ALWAYS_REQUIRED(glTexCoord4s),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1dv), GLFUNC_ALWAYS_REQUIRED(glTexCoord1fv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1iv), GLFUNC_ALWAYS_REQUIRED(glTexCoord1sv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2dv), GLFUNC_ALWAYS_REQUIRED(glTexCoord2fv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2iv), GLFUNC_ALWAYS_REQUIRED(glTexCoord2sv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3dv), GLFUNC_ALWAYS_REQUIRED(glTexCoord3fv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3iv), GLFUNC_ALWAYS_REQUIRED(glTexCoord3sv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4dv), GLFUNC_ALWAYS_REQUIRED(glTexCoord4fv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4iv), GLFUNC_ALWAYS_REQUIRED(glTexCoord4sv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2d), GLFUNC_ALWAYS_REQUIRED(glRasterPos2f),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2i), GLFUNC_ALWAYS_REQUIRED(glRasterPos2s),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3d), GLFUNC_ALWAYS_REQUIRED(glRasterPos3f),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3i), GLFUNC_ALWAYS_REQUIRED(glRasterPos3s),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4d), GLFUNC_ALWAYS_REQUIRED(glRasterPos4f),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4i), GLFUNC_ALWAYS_REQUIRED(glRasterPos4s),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2dv), GLFUNC_ALWAYS_REQUIRED(glRasterPos2fv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2iv), GLFUNC_ALWAYS_REQUIRED(glRasterPos2sv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3dv), GLFUNC_ALWAYS_REQUIRED(glRasterPos3fv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3iv), GLFUNC_ALWAYS_REQUIRED(glRasterPos3sv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4dv), GLFUNC_ALWAYS_REQUIRED(glRasterPos4fv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4iv), GLFUNC_ALWAYS_REQUIRED(glRasterPos4sv),
GLFUNC_ALWAYS_REQUIRED(glRectd), GLFUNC_ALWAYS_REQUIRED(glRectf),
GLFUNC_ALWAYS_REQUIRED(glRecti), GLFUNC_ALWAYS_REQUIRED(glRects),
GLFUNC_ALWAYS_REQUIRED(glRectdv), GLFUNC_ALWAYS_REQUIRED(glRectfv),
GLFUNC_ALWAYS_REQUIRED(glRectiv), GLFUNC_ALWAYS_REQUIRED(glRectsv),
GLFUNC_ALWAYS_REQUIRED(glVertexPointer), GLFUNC_ALWAYS_REQUIRED(glNormalPointer),
GLFUNC_ALWAYS_REQUIRED(glColorPointer), GLFUNC_ALWAYS_REQUIRED(glIndexPointer),
GLFUNC_ALWAYS_REQUIRED(glTexCoordPointer), GLFUNC_ALWAYS_REQUIRED(glEdgeFlagPointer),
GLFUNC_ALWAYS_REQUIRED(glArrayElement), GLFUNC_ALWAYS_REQUIRED(glInterleavedArrays),
GLFUNC_ALWAYS_REQUIRED(glShadeModel), GLFUNC_ALWAYS_REQUIRED(glLightf),
GLFUNC_ALWAYS_REQUIRED(glLighti), GLFUNC_ALWAYS_REQUIRED(glLightfv),
GLFUNC_ALWAYS_REQUIRED(glLightiv), GLFUNC_ALWAYS_REQUIRED(glGetLightfv),
GLFUNC_ALWAYS_REQUIRED(glGetLightiv), GLFUNC_ALWAYS_REQUIRED(glLightModelf),
GLFUNC_ALWAYS_REQUIRED(glLightModeli), GLFUNC_ALWAYS_REQUIRED(glLightModelfv),
GLFUNC_ALWAYS_REQUIRED(glLightModeliv), GLFUNC_ALWAYS_REQUIRED(glMaterialf),
GLFUNC_ALWAYS_REQUIRED(glMateriali), GLFUNC_ALWAYS_REQUIRED(glMaterialfv),
GLFUNC_ALWAYS_REQUIRED(glMaterialiv), GLFUNC_ALWAYS_REQUIRED(glGetMaterialfv),
GLFUNC_ALWAYS_REQUIRED(glGetMaterialiv), GLFUNC_ALWAYS_REQUIRED(glColorMaterial),
GLFUNC_ALWAYS_REQUIRED(glPixelZoom), GLFUNC_ALWAYS_REQUIRED(glPixelStoref),
GLFUNC_ALWAYS_REQUIRED(glPixelTransferf), GLFUNC_ALWAYS_REQUIRED(glPixelTransferi),
GLFUNC_ALWAYS_REQUIRED(glPixelMapfv), GLFUNC_ALWAYS_REQUIRED(glPixelMapuiv),
GLFUNC_ALWAYS_REQUIRED(glPixelMapusv), GLFUNC_ALWAYS_REQUIRED(glGetPixelMapfv),
GLFUNC_ALWAYS_REQUIRED(glGetPixelMapuiv), GLFUNC_ALWAYS_REQUIRED(glGetPixelMapusv),
GLFUNC_ALWAYS_REQUIRED(glBitmap), GLFUNC_ALWAYS_REQUIRED(glDrawPixels),
GLFUNC_ALWAYS_REQUIRED(glCopyPixels), GLFUNC_ALWAYS_REQUIRED(glTexGend),
GLFUNC_ALWAYS_REQUIRED(glTexGenf), GLFUNC_ALWAYS_REQUIRED(glTexGeni),
GLFUNC_ALWAYS_REQUIRED(glTexGendv), GLFUNC_ALWAYS_REQUIRED(glTexGenfv),
GLFUNC_ALWAYS_REQUIRED(glTexGeniv), GLFUNC_ALWAYS_REQUIRED(glGetTexGendv),
GLFUNC_ALWAYS_REQUIRED(glGetTexGenfv), GLFUNC_ALWAYS_REQUIRED(glGetTexGeniv),
GLFUNC_ALWAYS_REQUIRED(glTexEnvf), GLFUNC_ALWAYS_REQUIRED(glTexEnvi),
GLFUNC_ALWAYS_REQUIRED(glTexEnvfv), GLFUNC_ALWAYS_REQUIRED(glTexEnviv),
GLFUNC_ALWAYS_REQUIRED(glGetTexEnvfv), GLFUNC_ALWAYS_REQUIRED(glGetTexEnviv),
GLFUNC_ALWAYS_REQUIRED(glClearIndex),
GLFUNC_ALWAYS_REQUIRED(glIndexMask),
GLFUNC_ALWAYS_REQUIRED(glAlphaFunc),
GLFUNC_ALWAYS_REQUIRED(glLogicOp),
GLFUNC_ALWAYS_REQUIRED(glPointSize),
GLFUNC_ALWAYS_REQUIRED(glLineStipple),
GLFUNC_ALWAYS_REQUIRED(glPolygonMode),
GLFUNC_ALWAYS_REQUIRED(glPolygonStipple),
GLFUNC_ALWAYS_REQUIRED(glGetPolygonStipple),
GLFUNC_ALWAYS_REQUIRED(glEdgeFlag),
GLFUNC_ALWAYS_REQUIRED(glEdgeFlagv),
GLFUNC_ALWAYS_REQUIRED(glClipPlane),
GLFUNC_ALWAYS_REQUIRED(glGetClipPlane),
GLFUNC_ALWAYS_REQUIRED(glDrawBuffer),
GLFUNC_ALWAYS_REQUIRED(glEnableClientState),
GLFUNC_ALWAYS_REQUIRED(glDisableClientState),
GLFUNC_ALWAYS_REQUIRED(glGetDoublev),
GLFUNC_ALWAYS_REQUIRED(glPushAttrib),
GLFUNC_ALWAYS_REQUIRED(glPopAttrib),
GLFUNC_ALWAYS_REQUIRED(glPushClientAttrib),
GLFUNC_ALWAYS_REQUIRED(glPopClientAttrib),
GLFUNC_ALWAYS_REQUIRED(glRenderMode),
GLFUNC_ALWAYS_REQUIRED(glClearDepth),
GLFUNC_ALWAYS_REQUIRED(glDepthRange),
GLFUNC_ALWAYS_REQUIRED(glClearAccum),
GLFUNC_ALWAYS_REQUIRED(glAccum),
GLFUNC_ALWAYS_REQUIRED(glMatrixMode),
GLFUNC_ALWAYS_REQUIRED(glOrtho),
GLFUNC_ALWAYS_REQUIRED(glFrustum),
GLFUNC_ALWAYS_REQUIRED(glPushMatrix),
GLFUNC_ALWAYS_REQUIRED(glPopMatrix),
GLFUNC_ALWAYS_REQUIRED(glLoadIdentity),
GLFUNC_ALWAYS_REQUIRED(glLoadMatrixd),
GLFUNC_ALWAYS_REQUIRED(glLoadMatrixf),
GLFUNC_ALWAYS_REQUIRED(glMultMatrixd),
GLFUNC_ALWAYS_REQUIRED(glMultMatrixf),
GLFUNC_ALWAYS_REQUIRED(glRotated),
GLFUNC_ALWAYS_REQUIRED(glRotatef),
GLFUNC_ALWAYS_REQUIRED(glScaled),
GLFUNC_ALWAYS_REQUIRED(glScalef),
GLFUNC_ALWAYS_REQUIRED(glTranslated),
GLFUNC_ALWAYS_REQUIRED(glTranslatef),
GLFUNC_ALWAYS_REQUIRED(glIsList),
GLFUNC_ALWAYS_REQUIRED(glDeleteLists),
GLFUNC_ALWAYS_REQUIRED(glGenLists),
GLFUNC_ALWAYS_REQUIRED(glNewList),
GLFUNC_ALWAYS_REQUIRED(glEndList),
GLFUNC_ALWAYS_REQUIRED(glCallList),
GLFUNC_ALWAYS_REQUIRED(glCallLists),
GLFUNC_ALWAYS_REQUIRED(glListBase),
GLFUNC_ALWAYS_REQUIRED(glBegin),
GLFUNC_ALWAYS_REQUIRED(glEnd),
GLFUNC_ALWAYS_REQUIRED(glVertex2d),
GLFUNC_ALWAYS_REQUIRED(glVertex2f),
GLFUNC_ALWAYS_REQUIRED(glVertex2i),
GLFUNC_ALWAYS_REQUIRED(glVertex2s),
GLFUNC_ALWAYS_REQUIRED(glVertex3d),
GLFUNC_ALWAYS_REQUIRED(glVertex3f),
GLFUNC_ALWAYS_REQUIRED(glVertex3i),
GLFUNC_ALWAYS_REQUIRED(glVertex3s),
GLFUNC_ALWAYS_REQUIRED(glVertex4d),
GLFUNC_ALWAYS_REQUIRED(glVertex4f),
GLFUNC_ALWAYS_REQUIRED(glVertex4i),
GLFUNC_ALWAYS_REQUIRED(glVertex4s),
GLFUNC_ALWAYS_REQUIRED(glVertex2dv),
GLFUNC_ALWAYS_REQUIRED(glVertex2fv),
GLFUNC_ALWAYS_REQUIRED(glVertex2iv),
GLFUNC_ALWAYS_REQUIRED(glVertex2sv),
GLFUNC_ALWAYS_REQUIRED(glVertex3dv),
GLFUNC_ALWAYS_REQUIRED(glVertex3fv),
GLFUNC_ALWAYS_REQUIRED(glVertex3iv),
GLFUNC_ALWAYS_REQUIRED(glVertex3sv),
GLFUNC_ALWAYS_REQUIRED(glVertex4dv),
GLFUNC_ALWAYS_REQUIRED(glVertex4fv),
GLFUNC_ALWAYS_REQUIRED(glVertex4iv),
GLFUNC_ALWAYS_REQUIRED(glVertex4sv),
GLFUNC_ALWAYS_REQUIRED(glNormal3b),
GLFUNC_ALWAYS_REQUIRED(glNormal3d),
GLFUNC_ALWAYS_REQUIRED(glNormal3f),
GLFUNC_ALWAYS_REQUIRED(glNormal3i),
GLFUNC_ALWAYS_REQUIRED(glNormal3s),
GLFUNC_ALWAYS_REQUIRED(glNormal3bv),
GLFUNC_ALWAYS_REQUIRED(glNormal3dv),
GLFUNC_ALWAYS_REQUIRED(glNormal3fv),
GLFUNC_ALWAYS_REQUIRED(glNormal3iv),
GLFUNC_ALWAYS_REQUIRED(glNormal3sv),
GLFUNC_ALWAYS_REQUIRED(glIndexd),
GLFUNC_ALWAYS_REQUIRED(glIndexf),
GLFUNC_ALWAYS_REQUIRED(glIndexi),
GLFUNC_ALWAYS_REQUIRED(glIndexs),
GLFUNC_ALWAYS_REQUIRED(glIndexub),
GLFUNC_ALWAYS_REQUIRED(glIndexdv),
GLFUNC_ALWAYS_REQUIRED(glIndexfv),
GLFUNC_ALWAYS_REQUIRED(glIndexiv),
GLFUNC_ALWAYS_REQUIRED(glIndexsv),
GLFUNC_ALWAYS_REQUIRED(glIndexubv),
GLFUNC_ALWAYS_REQUIRED(glColor3b),
GLFUNC_ALWAYS_REQUIRED(glColor3d),
GLFUNC_ALWAYS_REQUIRED(glColor3f),
GLFUNC_ALWAYS_REQUIRED(glColor3i),
GLFUNC_ALWAYS_REQUIRED(glColor3s),
GLFUNC_ALWAYS_REQUIRED(glColor3ub),
GLFUNC_ALWAYS_REQUIRED(glColor3ui),
GLFUNC_ALWAYS_REQUIRED(glColor3us),
GLFUNC_ALWAYS_REQUIRED(glColor4b),
GLFUNC_ALWAYS_REQUIRED(glColor4d),
GLFUNC_ALWAYS_REQUIRED(glColor4f),
GLFUNC_ALWAYS_REQUIRED(glColor4i),
GLFUNC_ALWAYS_REQUIRED(glColor4s),
GLFUNC_ALWAYS_REQUIRED(glColor4ub),
GLFUNC_ALWAYS_REQUIRED(glColor4ui),
GLFUNC_ALWAYS_REQUIRED(glColor4us),
GLFUNC_ALWAYS_REQUIRED(glColor3bv),
GLFUNC_ALWAYS_REQUIRED(glColor3dv),
GLFUNC_ALWAYS_REQUIRED(glColor3fv),
GLFUNC_ALWAYS_REQUIRED(glColor3iv),
GLFUNC_ALWAYS_REQUIRED(glColor3sv),
GLFUNC_ALWAYS_REQUIRED(glColor3ubv),
GLFUNC_ALWAYS_REQUIRED(glColor3uiv),
GLFUNC_ALWAYS_REQUIRED(glColor3usv),
GLFUNC_ALWAYS_REQUIRED(glColor4bv),
GLFUNC_ALWAYS_REQUIRED(glColor4dv),
GLFUNC_ALWAYS_REQUIRED(glColor4fv),
GLFUNC_ALWAYS_REQUIRED(glColor4iv),
GLFUNC_ALWAYS_REQUIRED(glColor4sv),
GLFUNC_ALWAYS_REQUIRED(glColor4ubv),
GLFUNC_ALWAYS_REQUIRED(glColor4uiv),
GLFUNC_ALWAYS_REQUIRED(glColor4usv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1d),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1f),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1i),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1s),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2d),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2f),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2i),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2s),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3d),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3f),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3i),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3s),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4d),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4f),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4i),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4s),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1dv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1fv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1iv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord1sv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2dv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2fv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2iv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord2sv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3dv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3fv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3iv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord3sv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4dv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4fv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4iv),
GLFUNC_ALWAYS_REQUIRED(glTexCoord4sv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2d),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2f),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2i),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2s),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3d),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3f),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3i),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3s),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4d),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4f),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4i),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4s),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2dv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2fv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2iv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos2sv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3dv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3fv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3iv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos3sv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4dv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4fv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4iv),
GLFUNC_ALWAYS_REQUIRED(glRasterPos4sv),
GLFUNC_ALWAYS_REQUIRED(glRectd),
GLFUNC_ALWAYS_REQUIRED(glRectf),
GLFUNC_ALWAYS_REQUIRED(glRecti),
GLFUNC_ALWAYS_REQUIRED(glRects),
GLFUNC_ALWAYS_REQUIRED(glRectdv),
GLFUNC_ALWAYS_REQUIRED(glRectfv),
GLFUNC_ALWAYS_REQUIRED(glRectiv),
GLFUNC_ALWAYS_REQUIRED(glRectsv),
GLFUNC_ALWAYS_REQUIRED(glVertexPointer),
GLFUNC_ALWAYS_REQUIRED(glNormalPointer),
GLFUNC_ALWAYS_REQUIRED(glColorPointer),
GLFUNC_ALWAYS_REQUIRED(glIndexPointer),
GLFUNC_ALWAYS_REQUIRED(glTexCoordPointer),
GLFUNC_ALWAYS_REQUIRED(glEdgeFlagPointer),
GLFUNC_ALWAYS_REQUIRED(glArrayElement),
GLFUNC_ALWAYS_REQUIRED(glInterleavedArrays),
GLFUNC_ALWAYS_REQUIRED(glShadeModel),
GLFUNC_ALWAYS_REQUIRED(glLightf),
GLFUNC_ALWAYS_REQUIRED(glLighti),
GLFUNC_ALWAYS_REQUIRED(glLightfv),
GLFUNC_ALWAYS_REQUIRED(glLightiv),
GLFUNC_ALWAYS_REQUIRED(glGetLightfv),
GLFUNC_ALWAYS_REQUIRED(glGetLightiv),
GLFUNC_ALWAYS_REQUIRED(glLightModelf),
GLFUNC_ALWAYS_REQUIRED(glLightModeli),
GLFUNC_ALWAYS_REQUIRED(glLightModelfv),
GLFUNC_ALWAYS_REQUIRED(glLightModeliv),
GLFUNC_ALWAYS_REQUIRED(glMaterialf),
GLFUNC_ALWAYS_REQUIRED(glMateriali),
GLFUNC_ALWAYS_REQUIRED(glMaterialfv),
GLFUNC_ALWAYS_REQUIRED(glMaterialiv),
GLFUNC_ALWAYS_REQUIRED(glGetMaterialfv),
GLFUNC_ALWAYS_REQUIRED(glGetMaterialiv),
GLFUNC_ALWAYS_REQUIRED(glColorMaterial),
GLFUNC_ALWAYS_REQUIRED(glPixelZoom),
GLFUNC_ALWAYS_REQUIRED(glPixelStoref),
GLFUNC_ALWAYS_REQUIRED(glPixelTransferf),
GLFUNC_ALWAYS_REQUIRED(glPixelTransferi),
GLFUNC_ALWAYS_REQUIRED(glPixelMapfv),
GLFUNC_ALWAYS_REQUIRED(glPixelMapuiv),
GLFUNC_ALWAYS_REQUIRED(glPixelMapusv),
GLFUNC_ALWAYS_REQUIRED(glGetPixelMapfv),
GLFUNC_ALWAYS_REQUIRED(glGetPixelMapuiv),
GLFUNC_ALWAYS_REQUIRED(glGetPixelMapusv),
GLFUNC_ALWAYS_REQUIRED(glBitmap),
GLFUNC_ALWAYS_REQUIRED(glDrawPixels),
GLFUNC_ALWAYS_REQUIRED(glCopyPixels),
GLFUNC_ALWAYS_REQUIRED(glTexGend),
GLFUNC_ALWAYS_REQUIRED(glTexGenf),
GLFUNC_ALWAYS_REQUIRED(glTexGeni),
GLFUNC_ALWAYS_REQUIRED(glTexGendv),
GLFUNC_ALWAYS_REQUIRED(glTexGenfv),
GLFUNC_ALWAYS_REQUIRED(glTexGeniv),
GLFUNC_ALWAYS_REQUIRED(glGetTexGendv),
GLFUNC_ALWAYS_REQUIRED(glGetTexGenfv),
GLFUNC_ALWAYS_REQUIRED(glGetTexGeniv),
GLFUNC_ALWAYS_REQUIRED(glTexEnvf),
GLFUNC_ALWAYS_REQUIRED(glTexEnvi),
GLFUNC_ALWAYS_REQUIRED(glTexEnvfv),
GLFUNC_ALWAYS_REQUIRED(glTexEnviv),
GLFUNC_ALWAYS_REQUIRED(glGetTexEnvfv),
GLFUNC_ALWAYS_REQUIRED(glGetTexEnviv),
GLFUNC_ALWAYS_REQUIRED(glGetTexLevelParameterfv),
GLFUNC_ALWAYS_REQUIRED(glGetTexLevelParameteriv), GLFUNC_ALWAYS_REQUIRED(glTexImage1D),
GLFUNC_ALWAYS_REQUIRED(glGetTexImage), GLFUNC_ALWAYS_REQUIRED(glPrioritizeTextures),
GLFUNC_ALWAYS_REQUIRED(glAreTexturesResident), GLFUNC_ALWAYS_REQUIRED(glTexSubImage1D),
GLFUNC_ALWAYS_REQUIRED(glCopyTexImage1D), GLFUNC_ALWAYS_REQUIRED(glCopyTexSubImage1D),
GLFUNC_ALWAYS_REQUIRED(glMap1d), GLFUNC_ALWAYS_REQUIRED(glMap1f),
GLFUNC_ALWAYS_REQUIRED(glMap2d), GLFUNC_ALWAYS_REQUIRED(glMap2f),
GLFUNC_ALWAYS_REQUIRED(glGetMapdv), GLFUNC_ALWAYS_REQUIRED(glGetMapfv),
GLFUNC_ALWAYS_REQUIRED(glGetMapiv), GLFUNC_ALWAYS_REQUIRED(glEvalCoord1d),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord1f), GLFUNC_ALWAYS_REQUIRED(glEvalCoord1dv),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord1fv), GLFUNC_ALWAYS_REQUIRED(glEvalCoord2d),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord2f), GLFUNC_ALWAYS_REQUIRED(glEvalCoord2dv),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord2fv), GLFUNC_ALWAYS_REQUIRED(glMapGrid1d),
GLFUNC_ALWAYS_REQUIRED(glMapGrid1f), GLFUNC_ALWAYS_REQUIRED(glMapGrid2d),
GLFUNC_ALWAYS_REQUIRED(glMapGrid2f), GLFUNC_ALWAYS_REQUIRED(glEvalPoint1),
GLFUNC_ALWAYS_REQUIRED(glEvalPoint2), GLFUNC_ALWAYS_REQUIRED(glEvalMesh1),
GLFUNC_ALWAYS_REQUIRED(glEvalMesh2), GLFUNC_ALWAYS_REQUIRED(glFogf),
GLFUNC_ALWAYS_REQUIRED(glFogi), GLFUNC_ALWAYS_REQUIRED(glFogfv),
GLFUNC_ALWAYS_REQUIRED(glFogiv), GLFUNC_ALWAYS_REQUIRED(glFeedbackBuffer),
GLFUNC_ALWAYS_REQUIRED(glPassThrough), GLFUNC_ALWAYS_REQUIRED(glSelectBuffer),
GLFUNC_ALWAYS_REQUIRED(glInitNames), GLFUNC_ALWAYS_REQUIRED(glLoadName),
GLFUNC_ALWAYS_REQUIRED(glPushName), GLFUNC_ALWAYS_REQUIRED(glPopName),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexImage2D), GL_ES_FUNC_ALWAYS_REQUIRED(glClearColor),
GL_ES_FUNC_ALWAYS_REQUIRED(glClear), GL_ES_FUNC_ALWAYS_REQUIRED(glColorMask),
GL_ES_FUNC_ALWAYS_REQUIRED(glBlendFunc), GL_ES_FUNC_ALWAYS_REQUIRED(glCullFace),
GL_ES_FUNC_ALWAYS_REQUIRED(glFrontFace), GL_ES_FUNC_ALWAYS_REQUIRED(glLineWidth),
GL_ES_FUNC_ALWAYS_REQUIRED(glPolygonOffset), GL_ES_FUNC_ALWAYS_REQUIRED(glScissor),
GL_ES_FUNC_ALWAYS_REQUIRED(glEnable), GL_ES_FUNC_ALWAYS_REQUIRED(glDisable),
GL_ES_FUNC_ALWAYS_REQUIRED(glIsEnabled), GL_ES_FUNC_ALWAYS_REQUIRED(glGetBooleanv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetFloatv), GL_ES_FUNC_ALWAYS_REQUIRED(glFinish),
GL_ES_FUNC_ALWAYS_REQUIRED(glFlush), GL_ES_FUNC_ALWAYS_REQUIRED(glHint),
GL_ES_FUNC_ALWAYS_REQUIRED(glDepthFunc), GL_ES_FUNC_ALWAYS_REQUIRED(glDepthMask),
GL_ES_FUNC_ALWAYS_REQUIRED(glViewport), GL_ES_FUNC_ALWAYS_REQUIRED(glDrawArrays),
GL_ES_FUNC_ALWAYS_REQUIRED(glDrawElements), GL_ES_FUNC_ALWAYS_REQUIRED(glPixelStorei),
GL_ES_FUNC_ALWAYS_REQUIRED(glReadPixels), GL_ES_FUNC_ALWAYS_REQUIRED(glStencilFunc),
GL_ES_FUNC_ALWAYS_REQUIRED(glStencilMask), GL_ES_FUNC_ALWAYS_REQUIRED(glStencilOp),
GL_ES_FUNC_ALWAYS_REQUIRED(glClearStencil), GL_ES_FUNC_ALWAYS_REQUIRED(glTexParameterf),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexParameteri), GL_ES_FUNC_ALWAYS_REQUIRED(glTexParameterfv),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexParameteriv), GL_ES_FUNC_ALWAYS_REQUIRED(glGetTexParameterfv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetTexParameteriv), GL_ES_FUNC_ALWAYS_REQUIRED(glGenTextures),
GL_ES_FUNC_ALWAYS_REQUIRED(glDeleteTextures), GL_ES_FUNC_ALWAYS_REQUIRED(glBindTexture),
GL_ES_FUNC_ALWAYS_REQUIRED(glIsTexture), GL_ES_FUNC_ALWAYS_REQUIRED(glTexSubImage2D),
GL_ES_FUNC_ALWAYS_REQUIRED(glCopyTexImage2D), GL_ES_FUNC_ALWAYS_REQUIRED(glCopyTexSubImage2D),
GL_ES3_FUNC_ALWAYS_REQUIRED(glReadBuffer), GL_ES32_FUNC_ALWAYS_REQUIRED(glGetPointerv),
GLFUNC_ALWAYS_REQUIRED(glGetTexLevelParameteriv),
GLFUNC_ALWAYS_REQUIRED(glTexImage1D),
GLFUNC_ALWAYS_REQUIRED(glGetTexImage),
GLFUNC_ALWAYS_REQUIRED(glPrioritizeTextures),
GLFUNC_ALWAYS_REQUIRED(glAreTexturesResident),
GLFUNC_ALWAYS_REQUIRED(glTexSubImage1D),
GLFUNC_ALWAYS_REQUIRED(glCopyTexImage1D),
GLFUNC_ALWAYS_REQUIRED(glCopyTexSubImage1D),
GLFUNC_ALWAYS_REQUIRED(glMap1d),
GLFUNC_ALWAYS_REQUIRED(glMap1f),
GLFUNC_ALWAYS_REQUIRED(glMap2d),
GLFUNC_ALWAYS_REQUIRED(glMap2f),
GLFUNC_ALWAYS_REQUIRED(glGetMapdv),
GLFUNC_ALWAYS_REQUIRED(glGetMapfv),
GLFUNC_ALWAYS_REQUIRED(glGetMapiv),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord1d),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord1f),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord1dv),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord1fv),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord2d),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord2f),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord2dv),
GLFUNC_ALWAYS_REQUIRED(glEvalCoord2fv),
GLFUNC_ALWAYS_REQUIRED(glMapGrid1d),
GLFUNC_ALWAYS_REQUIRED(glMapGrid1f),
GLFUNC_ALWAYS_REQUIRED(glMapGrid2d),
GLFUNC_ALWAYS_REQUIRED(glMapGrid2f),
GLFUNC_ALWAYS_REQUIRED(glEvalPoint1),
GLFUNC_ALWAYS_REQUIRED(glEvalPoint2),
GLFUNC_ALWAYS_REQUIRED(glEvalMesh1),
GLFUNC_ALWAYS_REQUIRED(glEvalMesh2),
GLFUNC_ALWAYS_REQUIRED(glFogf),
GLFUNC_ALWAYS_REQUIRED(glFogi),
GLFUNC_ALWAYS_REQUIRED(glFogfv),
GLFUNC_ALWAYS_REQUIRED(glFogiv),
GLFUNC_ALWAYS_REQUIRED(glFeedbackBuffer),
GLFUNC_ALWAYS_REQUIRED(glPassThrough),
GLFUNC_ALWAYS_REQUIRED(glSelectBuffer),
GLFUNC_ALWAYS_REQUIRED(glInitNames),
GLFUNC_ALWAYS_REQUIRED(glLoadName),
GLFUNC_ALWAYS_REQUIRED(glPushName),
GLFUNC_ALWAYS_REQUIRED(glPopName),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexImage2D),
GL_ES_FUNC_ALWAYS_REQUIRED(glClearColor),
GL_ES_FUNC_ALWAYS_REQUIRED(glClear),
GL_ES_FUNC_ALWAYS_REQUIRED(glColorMask),
GL_ES_FUNC_ALWAYS_REQUIRED(glBlendFunc),
GL_ES_FUNC_ALWAYS_REQUIRED(glCullFace),
GL_ES_FUNC_ALWAYS_REQUIRED(glFrontFace),
GL_ES_FUNC_ALWAYS_REQUIRED(glLineWidth),
GL_ES_FUNC_ALWAYS_REQUIRED(glPolygonOffset),
GL_ES_FUNC_ALWAYS_REQUIRED(glScissor),
GL_ES_FUNC_ALWAYS_REQUIRED(glEnable),
GL_ES_FUNC_ALWAYS_REQUIRED(glDisable),
GL_ES_FUNC_ALWAYS_REQUIRED(glIsEnabled),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetBooleanv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetFloatv),
GL_ES_FUNC_ALWAYS_REQUIRED(glFinish),
GL_ES_FUNC_ALWAYS_REQUIRED(glFlush),
GL_ES_FUNC_ALWAYS_REQUIRED(glHint),
GL_ES_FUNC_ALWAYS_REQUIRED(glDepthFunc),
GL_ES_FUNC_ALWAYS_REQUIRED(glDepthMask),
GL_ES_FUNC_ALWAYS_REQUIRED(glViewport),
GL_ES_FUNC_ALWAYS_REQUIRED(glDrawArrays),
GL_ES_FUNC_ALWAYS_REQUIRED(glDrawElements),
GL_ES_FUNC_ALWAYS_REQUIRED(glPixelStorei),
GL_ES_FUNC_ALWAYS_REQUIRED(glReadPixels),
GL_ES_FUNC_ALWAYS_REQUIRED(glStencilFunc),
GL_ES_FUNC_ALWAYS_REQUIRED(glStencilMask),
GL_ES_FUNC_ALWAYS_REQUIRED(glStencilOp),
GL_ES_FUNC_ALWAYS_REQUIRED(glClearStencil),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexParameterf),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexParameteri),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexParameterfv),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexParameteriv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetTexParameterfv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetTexParameteriv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGenTextures),
GL_ES_FUNC_ALWAYS_REQUIRED(glDeleteTextures),
GL_ES_FUNC_ALWAYS_REQUIRED(glBindTexture),
GL_ES_FUNC_ALWAYS_REQUIRED(glIsTexture),
GL_ES_FUNC_ALWAYS_REQUIRED(glTexSubImage2D),
GL_ES_FUNC_ALWAYS_REQUIRED(glCopyTexImage2D),
GL_ES_FUNC_ALWAYS_REQUIRED(glCopyTexSubImage2D),
GL_ES3_FUNC_ALWAYS_REQUIRED(glReadBuffer),
GL_ES32_FUNC_ALWAYS_REQUIRED(glGetPointerv),
// gl_1_2
GL_ES3_FUNC_ALWAYS_REQUIRED(glCopyTexSubImage3D),
GL_ES3_FUNC_ALWAYS_REQUIRED(glDrawRangeElements), GL_ES3_FUNC_ALWAYS_REQUIRED(glTexImage3D),
GL_ES3_FUNC_ALWAYS_REQUIRED(glDrawRangeElements),
GL_ES3_FUNC_ALWAYS_REQUIRED(glTexImage3D),
GL_ES3_FUNC_ALWAYS_REQUIRED(glTexSubImage3D),
// gl_1_3
GLFUNC_ALWAYS_REQUIRED(glClientActiveTexture), GLFUNC_ALWAYS_REQUIRED(glCompressedTexImage1D),
GLFUNC_ALWAYS_REQUIRED(glClientActiveTexture),
GLFUNC_ALWAYS_REQUIRED(glCompressedTexImage1D),
GLFUNC_ALWAYS_REQUIRED(glCompressedTexSubImage1D),
GLFUNC_ALWAYS_REQUIRED(glGetCompressedTexImage), GLFUNC_ALWAYS_REQUIRED(glLoadTransposeMatrixd),
GLFUNC_ALWAYS_REQUIRED(glLoadTransposeMatrixf), GLFUNC_ALWAYS_REQUIRED(glMultTransposeMatrixd),
GLFUNC_ALWAYS_REQUIRED(glMultTransposeMatrixf), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1d),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1dv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1f),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1fv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1i),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1iv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1s),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1sv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2d),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2dv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2f),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2fv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2i),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2iv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2s),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2sv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3d),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3dv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3f),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3fv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3i),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3iv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3s),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3sv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4d),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4dv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4f),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4fv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4i),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4iv), GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4s),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4sv), GL_ES_FUNC_ALWAYS_REQUIRED(glSampleCoverage),
GL_ES_FUNC_ALWAYS_REQUIRED(glActiveTexture), GL_ES_FUNC_ALWAYS_REQUIRED(glCompressedTexImage2D),
GLFUNC_ALWAYS_REQUIRED(glGetCompressedTexImage),
GLFUNC_ALWAYS_REQUIRED(glLoadTransposeMatrixd),
GLFUNC_ALWAYS_REQUIRED(glLoadTransposeMatrixf),
GLFUNC_ALWAYS_REQUIRED(glMultTransposeMatrixd),
GLFUNC_ALWAYS_REQUIRED(glMultTransposeMatrixf),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1d),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1dv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1f),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1fv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1i),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1iv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1s),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord1sv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2d),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2dv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2f),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2fv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2i),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2iv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2s),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord2sv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3d),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3dv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3f),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3fv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3i),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3iv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3s),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord3sv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4d),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4dv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4f),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4fv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4i),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4iv),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4s),
GLFUNC_ALWAYS_REQUIRED(glMultiTexCoord4sv),
GL_ES_FUNC_ALWAYS_REQUIRED(glSampleCoverage),
GL_ES_FUNC_ALWAYS_REQUIRED(glActiveTexture),
GL_ES_FUNC_ALWAYS_REQUIRED(glCompressedTexImage2D),
GL_ES_FUNC_ALWAYS_REQUIRED(glCompressedTexSubImage2D),
GL_ES3_FUNC_ALWAYS_REQUIRED(glCompressedTexImage3D),
GL_ES3_FUNC_ALWAYS_REQUIRED(glCompressedTexSubImage3D),
// gl_1_4
GLFUNC_ALWAYS_REQUIRED(glFogCoordPointer), GLFUNC_ALWAYS_REQUIRED(glFogCoordd),
GLFUNC_ALWAYS_REQUIRED(glFogCoorddv), GLFUNC_ALWAYS_REQUIRED(glFogCoordf),
GLFUNC_ALWAYS_REQUIRED(glFogCoordfv), GLFUNC_ALWAYS_REQUIRED(glMultiDrawArrays),
GLFUNC_ALWAYS_REQUIRED(glMultiDrawElements), GLFUNC_ALWAYS_REQUIRED(glPointParameterf),
GLFUNC_ALWAYS_REQUIRED(glPointParameterfv), GLFUNC_ALWAYS_REQUIRED(glPointParameteri),
GLFUNC_ALWAYS_REQUIRED(glPointParameteriv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3b),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3bv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3d),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3dv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3f),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3fv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3i),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3iv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3s),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3sv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3ub),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3ubv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3ui),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3uiv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3us),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3usv), GLFUNC_ALWAYS_REQUIRED(glSecondaryColorPointer),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2d), GLFUNC_ALWAYS_REQUIRED(glWindowPos2dv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2f), GLFUNC_ALWAYS_REQUIRED(glWindowPos2fv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2i), GLFUNC_ALWAYS_REQUIRED(glWindowPos2iv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2s), GLFUNC_ALWAYS_REQUIRED(glWindowPos2sv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3d), GLFUNC_ALWAYS_REQUIRED(glWindowPos3dv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3f), GLFUNC_ALWAYS_REQUIRED(glWindowPos3fv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3i), GLFUNC_ALWAYS_REQUIRED(glWindowPos3iv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3s), GLFUNC_ALWAYS_REQUIRED(glWindowPos3sv),
GL_ES_FUNC_ALWAYS_REQUIRED(glBlendColor), GL_ES_FUNC_ALWAYS_REQUIRED(glBlendEquation),
GLFUNC_ALWAYS_REQUIRED(glFogCoordPointer),
GLFUNC_ALWAYS_REQUIRED(glFogCoordd),
GLFUNC_ALWAYS_REQUIRED(glFogCoorddv),
GLFUNC_ALWAYS_REQUIRED(glFogCoordf),
GLFUNC_ALWAYS_REQUIRED(glFogCoordfv),
GLFUNC_ALWAYS_REQUIRED(glMultiDrawArrays),
GLFUNC_ALWAYS_REQUIRED(glMultiDrawElements),
GLFUNC_ALWAYS_REQUIRED(glPointParameterf),
GLFUNC_ALWAYS_REQUIRED(glPointParameterfv),
GLFUNC_ALWAYS_REQUIRED(glPointParameteri),
GLFUNC_ALWAYS_REQUIRED(glPointParameteriv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3b),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3bv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3d),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3dv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3f),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3fv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3i),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3iv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3s),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3sv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3ub),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3ubv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3ui),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3uiv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3us),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColor3usv),
GLFUNC_ALWAYS_REQUIRED(glSecondaryColorPointer),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2d),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2dv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2f),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2fv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2i),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2iv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2s),
GLFUNC_ALWAYS_REQUIRED(glWindowPos2sv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3d),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3dv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3f),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3fv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3i),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3iv),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3s),
GLFUNC_ALWAYS_REQUIRED(glWindowPos3sv),
GL_ES_FUNC_ALWAYS_REQUIRED(glBlendColor),
GL_ES_FUNC_ALWAYS_REQUIRED(glBlendEquation),
GL_ES_FUNC_ALWAYS_REQUIRED(glBlendFuncSeparate),
// gl_1_5
GLFUNC_ALWAYS_REQUIRED(glGetBufferSubData), GLFUNC_ALWAYS_REQUIRED(glGetQueryObjectiv),
GLFUNC_ALWAYS_REQUIRED(glMapBuffer), GL_ES_FUNC_ALWAYS_REQUIRED(glBindBuffer),
GL_ES_FUNC_ALWAYS_REQUIRED(glBufferData), GL_ES_FUNC_ALWAYS_REQUIRED(glBufferSubData),
GL_ES_FUNC_ALWAYS_REQUIRED(glDeleteBuffers), GL_ES_FUNC_ALWAYS_REQUIRED(glGenBuffers),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetBufferParameteriv), GL_ES_FUNC_ALWAYS_REQUIRED(glIsBuffer),
GL_ES3_FUNC_ALWAYS_REQUIRED(glBeginQuery), GL_ES3_FUNC_ALWAYS_REQUIRED(glDeleteQueries),
GL_ES3_FUNC_ALWAYS_REQUIRED(glEndQuery), GL_ES3_FUNC_ALWAYS_REQUIRED(glGenQueries),
GL_ES3_FUNC_ALWAYS_REQUIRED(glIsQuery), GL_ES3_FUNC_ALWAYS_REQUIRED(glGetQueryiv),
GLFUNC_ALWAYS_REQUIRED(glGetBufferSubData),
GLFUNC_ALWAYS_REQUIRED(glGetQueryObjectiv),
GLFUNC_ALWAYS_REQUIRED(glMapBuffer),
GL_ES_FUNC_ALWAYS_REQUIRED(glBindBuffer),
GL_ES_FUNC_ALWAYS_REQUIRED(glBufferData),
GL_ES_FUNC_ALWAYS_REQUIRED(glBufferSubData),
GL_ES_FUNC_ALWAYS_REQUIRED(glDeleteBuffers),
GL_ES_FUNC_ALWAYS_REQUIRED(glGenBuffers),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetBufferParameteriv),
GL_ES_FUNC_ALWAYS_REQUIRED(glIsBuffer),
GL_ES3_FUNC_ALWAYS_REQUIRED(glBeginQuery),
GL_ES3_FUNC_ALWAYS_REQUIRED(glDeleteQueries),
GL_ES3_FUNC_ALWAYS_REQUIRED(glEndQuery),
GL_ES3_FUNC_ALWAYS_REQUIRED(glGenQueries),
GL_ES3_FUNC_ALWAYS_REQUIRED(glIsQuery),
GL_ES3_FUNC_ALWAYS_REQUIRED(glGetQueryiv),
GL_ES3_FUNC_ALWAYS_REQUIRED(glGetQueryObjectuiv),
GL_ES3_FUNC_ALWAYS_REQUIRED(glGetBufferPointerv), GL_ES3_FUNC_ALWAYS_REQUIRED(glUnmapBuffer),
GL_ES3_FUNC_ALWAYS_REQUIRED(glGetBufferPointerv),
GL_ES3_FUNC_ALWAYS_REQUIRED(glUnmapBuffer),
// gl_2_0
GLFUNC_ALWAYS_REQUIRED(glGetVertexAttribdv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib1d),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib1dv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib1s),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib1sv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib2d),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib2dv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib2s),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib2sv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib3d),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib3dv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib3s),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib3sv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nbv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Niv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nsv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nub), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nubv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nuiv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nusv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4bv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4d),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4dv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4iv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4s), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4sv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4ubv), GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4uiv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4usv), GL_ES_FUNC_ALWAYS_REQUIRED(glAttachShader),
GLFUNC_ALWAYS_REQUIRED(glGetVertexAttribdv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib1d),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib1dv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib1s),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib1sv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib2d),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib2dv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib2s),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib2sv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib3d),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib3dv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib3s),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib3sv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nbv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Niv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nsv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nub),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nubv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nuiv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4Nusv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4bv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4d),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4dv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4iv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4s),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4sv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4ubv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4uiv),
GLFUNC_ALWAYS_REQUIRED(glVertexAttrib4usv),
GL_ES_FUNC_ALWAYS_REQUIRED(glAttachShader),
GL_ES_FUNC_ALWAYS_REQUIRED(glBindAttribLocation),
GL_ES_FUNC_ALWAYS_REQUIRED(glBlendEquationSeparate),
GL_ES_FUNC_ALWAYS_REQUIRED(glCompileShader), GL_ES_FUNC_ALWAYS_REQUIRED(glCreateProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glCreateShader), GL_ES_FUNC_ALWAYS_REQUIRED(glDeleteProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glDeleteShader), GL_ES_FUNC_ALWAYS_REQUIRED(glDetachShader),
GL_ES_FUNC_ALWAYS_REQUIRED(glCompileShader),
GL_ES_FUNC_ALWAYS_REQUIRED(glCreateProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glCreateShader),
GL_ES_FUNC_ALWAYS_REQUIRED(glDeleteProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glDeleteShader),
GL_ES_FUNC_ALWAYS_REQUIRED(glDetachShader),
GL_ES_FUNC_ALWAYS_REQUIRED(glDisableVertexAttribArray),
GL_ES_FUNC_ALWAYS_REQUIRED(glEnableVertexAttribArray),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetActiveAttrib), GL_ES_FUNC_ALWAYS_REQUIRED(glGetActiveUniform),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetActiveAttrib),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetActiveUniform),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetAttachedShaders),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetAttribLocation),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetProgramInfoLog), GL_ES_FUNC_ALWAYS_REQUIRED(glGetProgramiv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetShaderInfoLog), GL_ES_FUNC_ALWAYS_REQUIRED(glGetShaderSource),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetShaderiv), GL_ES_FUNC_ALWAYS_REQUIRED(glGetUniformLocation),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetUniformfv), GL_ES_FUNC_ALWAYS_REQUIRED(glGetUniformiv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetProgramInfoLog),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetProgramiv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetShaderInfoLog),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetShaderSource),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetShaderiv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetUniformLocation),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetUniformfv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetUniformiv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetVertexAttribPointerv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetVertexAttribfv),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetVertexAttribiv), GL_ES_FUNC_ALWAYS_REQUIRED(glIsProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glIsShader), GL_ES_FUNC_ALWAYS_REQUIRED(glLinkProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glShaderSource), GL_ES_FUNC_ALWAYS_REQUIRED(glStencilFuncSeparate),
GL_ES_FUNC_ALWAYS_REQUIRED(glGetVertexAttribiv),
GL_ES_FUNC_ALWAYS_REQUIRED(glIsProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glIsShader),
GL_ES_FUNC_ALWAYS_REQUIRED(glLinkProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glShaderSource),
GL_ES_FUNC_ALWAYS_REQUIRED(glStencilFuncSeparate),
GL_ES_FUNC_ALWAYS_REQUIRED(glStencilMaskSeparate),
GL_ES_FUNC_ALWAYS_REQUIRED(glStencilOpSeparate), GL_ES_FUNC_ALWAYS_REQUIRED(glUniform1f),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform1fv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniform1i),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform1iv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniform2f),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform2fv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniform2i),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform2iv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniform3f),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform3fv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniform3i),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform3iv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniform4f),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform4fv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniform4i),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform4iv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniformMatrix2fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniformMatrix3fv), GL_ES_FUNC_ALWAYS_REQUIRED(glUniformMatrix4fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUseProgram), GL_ES_FUNC_ALWAYS_REQUIRED(glValidateProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib1f), GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib1fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib2f), GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib2fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib3f), GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib3fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib4f), GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib4fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttribPointer), GL_ES3_FUNC_ALWAYS_REQUIRED(glDrawBuffers),
GL_ES_FUNC_ALWAYS_REQUIRED(glStencilOpSeparate),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform1f),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform1fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform1i),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform1iv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform2f),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform2fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform2i),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform2iv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform3f),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform3fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform3i),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform3iv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform4f),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform4fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform4i),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniform4iv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniformMatrix2fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniformMatrix3fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUniformMatrix4fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glUseProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glValidateProgram),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib1f),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib1fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib2f),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib2fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib3f),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib3fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib4f),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttrib4fv),
GL_ES_FUNC_ALWAYS_REQUIRED(glVertexAttribPointer),
GL_ES3_FUNC_ALWAYS_REQUIRED(glDrawBuffers),
// gl_2_1
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix2x3fv), GLFUNC_ALWAYS_REQUIRED(glUniformMatrix2x4fv),
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix3x2fv), GLFUNC_ALWAYS_REQUIRED(glUniformMatrix3x4fv),
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix4x2fv), GLFUNC_ALWAYS_REQUIRED(glUniformMatrix4x3fv),
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix2x3fv),
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix2x4fv),
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix3x2fv),
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix3x4fv),
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix4x2fv),
GLFUNC_ALWAYS_REQUIRED(glUniformMatrix4x3fv),
// gl_3_0
GLFUNC_REQUIRES(glBeginConditionalRender, "VERSION_3_0"),
@ -1412,8 +1677,10 @@ const GLFunc gl_function_array[] = {
GLFUNC_REQUIRES(glGetInternalformativ, "VERSION_4_2"),
GLFUNC_REQUIRES(glGetActiveAtomicCounterBufferiv, "VERSION_4_2"),
GLFUNC_REQUIRES(glBindImageTexture, "VERSION_4_2"),
GLFUNC_REQUIRES(glMemoryBarrier, "VERSION_4_2"), GLFUNC_REQUIRES(glTexStorage1D, "VERSION_4_2"),
GLFUNC_REQUIRES(glTexStorage2D, "VERSION_4_2"), GLFUNC_REQUIRES(glTexStorage3D, "VERSION_4_2"),
GLFUNC_REQUIRES(glMemoryBarrier, "VERSION_4_2"),
GLFUNC_REQUIRES(glTexStorage1D, "VERSION_4_2"),
GLFUNC_REQUIRES(glTexStorage2D, "VERSION_4_2"),
GLFUNC_REQUIRES(glTexStorage3D, "VERSION_4_2"),
GLFUNC_REQUIRES(glDrawTransformFeedbackInstanced, "VERSION_4_2"),
GLFUNC_REQUIRES(glDrawTransformFeedbackStreamInstanced, "VERSION_4_2"),
@ -1456,7 +1723,8 @@ const GLFunc gl_function_array[] = {
GLFUNC_REQUIRES(glDebugMessageCallback, "VERSION_4_3"),
GLFUNC_REQUIRES(glGetDebugMessageLog, "VERSION_4_3"),
GLFUNC_REQUIRES(glPushDebugGroup, "VERSION_4_3"),
GLFUNC_REQUIRES(glPopDebugGroup, "VERSION_4_3"), GLFUNC_REQUIRES(glObjectLabel, "VERSION_4_3"),
GLFUNC_REQUIRES(glPopDebugGroup, "VERSION_4_3"),
GLFUNC_REQUIRES(glObjectLabel, "VERSION_4_3"),
GLFUNC_REQUIRES(glGetObjectLabel, "VERSION_4_3"),
GLFUNC_REQUIRES(glObjectPtrLabel, "VERSION_4_3"),
GLFUNC_REQUIRES(glGetObjectPtrLabel, "VERSION_4_3"),
@ -1467,7 +1735,8 @@ const GLFunc gl_function_array[] = {
GLFUNC_REQUIRES(glClearTexSubImage, "VERSION_4_4"),
GLFUNC_REQUIRES(glBindBuffersBase, "VERSION_4_4"),
GLFUNC_REQUIRES(glBindBuffersRange, "VERSION_4_4"),
GLFUNC_REQUIRES(glBindTextures, "VERSION_4_4"), GLFUNC_REQUIRES(glBindSamplers, "VERSION_4_4"),
GLFUNC_REQUIRES(glBindTextures, "VERSION_4_4"),
GLFUNC_REQUIRES(glBindSamplers, "VERSION_4_4"),
GLFUNC_REQUIRES(glBindImageTextures, "VERSION_4_4"),
GLFUNC_REQUIRES(glBindVertexBuffers, "VERSION_4_4"),
@ -1574,7 +1843,8 @@ const GLFunc gl_function_array[] = {
GLFUNC_REQUIRES(glGetTextureSubImage, "VERSION_4_5"),
GLFUNC_REQUIRES(glGetCompressedTextureSubImage, "VERSION_4_5"),
GLFUNC_REQUIRES(glGetGraphicsResetStatus, "VERSION_4_5"),
GLFUNC_REQUIRES(glReadnPixels, "VERSION_4_5"), GLFUNC_REQUIRES(glTextureBarrier, "VERSION_4_5"),
GLFUNC_REQUIRES(glReadnPixels, "VERSION_4_5"),
GLFUNC_REQUIRES(glTextureBarrier, "VERSION_4_5"),
// AMD's video driver is trash and doesn't expose these function pointers
// Remove them for now until they learn how to implement the spec properly.
// GLFUNC_REQUIRES(glGetnCompressedTexImage, "VERSION_4_5"),
@ -2082,8 +2352,11 @@ static void InitExtensionList()
{
// Can't add NV_primitive_restart since function name changed
std::string gl310exts[] = {
"GL_ARB_draw_instanced", "GL_ARB_copy_buffer", "GL_ARB_texture_buffer_object",
"GL_ARB_texture_rectangle", "GL_ARB_uniform_buffer_object",
"GL_ARB_draw_instanced",
"GL_ARB_copy_buffer",
"GL_ARB_texture_buffer_object",
"GL_ARB_texture_rectangle",
"GL_ARB_uniform_buffer_object",
//"GL_NV_primitive_restart",
"VERSION_3_1",
};
@ -2095,9 +2368,14 @@ static void InitExtensionList()
// Quite a lot of these had their names changed when merged in to core
// Disable the ones that have
std::string gl300exts[] = {
"GL_ARB_map_buffer_range", "GL_ARB_color_buffer_float", "GL_ARB_texture_float",
"GL_ARB_half_float_pixel", "GL_ARB_framebuffer_object", "GL_ARB_texture_float",
"GL_ARB_vertex_array_object", "GL_ARB_depth_buffer_float",
"GL_ARB_map_buffer_range",
"GL_ARB_color_buffer_float",
"GL_ARB_texture_float",
"GL_ARB_half_float_pixel",
"GL_ARB_framebuffer_object",
"GL_ARB_texture_float",
"GL_ARB_vertex_array_object",
"GL_ARB_depth_buffer_float",
//"GL_EXT_texture_integer",
//"GL_EXT_gpu_shader4",
//"GL_APPLE_flush_buffer_range",

11
Source/Core/Common/GL/GLInterface/EGL.cpp
View File

@ -53,7 +53,8 @@ void cInterfaceEGL::DetectMode()
EGLint num_configs;
bool supportsGL = false, supportsGLES2 = false, supportsGLES3 = false;
std::array<int, 3> renderable_types{{
EGL_OPENGL_BIT, (1 << 6), /* EGL_OPENGL_ES3_BIT_KHR */
EGL_OPENGL_BIT,
(1 << 6), /* EGL_OPENGL_ES3_BIT_KHR */
EGL_OPENGL_ES2_BIT,
}};
@ -237,7 +238,13 @@ bool cInterfaceEGL::Create(void* window_handle, bool stereo, bool core)
if (supports_core_profile && core && s_opengl_mode == GLInterfaceMode::MODE_OPENGL)
{
std::array<std::pair<int, int>, 7> versions_to_try = {{
{4, 5}, {4, 4}, {4, 3}, {4, 2}, {4, 1}, {4, 0}, {3, 3},
{4, 5},
{4, 4},
{4, 3},
{4, 2},
{4, 1},
{4, 0},
{3, 3},
}};
for (const auto& version : versions_to_try)

1
Source/Core/Common/GL/GLInterface/EGL.h
View File

@ -35,6 +35,7 @@ protected:
return (EGLNativeWindowType)EGL_DEFAULT_DISPLAY;
}
virtual void ShutdownPlatform() {}
public:
void Swap() override;
void SwapInterval(int interval) override;

21
Source/Core/Common/GL/GLInterface/WGL.cpp
View File

@ -230,17 +230,26 @@ bool cInterfaceWGL::Create(void* window_handle, bool stereo, bool core)
PFD_TYPE_RGBA, // Request An RGBA Format
32, // Select Our Color Depth
0,
0, 0, 0, 0, 0, // Color Bits Ignored
0,
0,
0,
0,
0, // Color Bits Ignored
0, // 8bit Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
0,
0,
0,
0, // Accumulation Bits Ignored
0, // 0Bit Z-Buffer (Depth Buffer)
0, // 0bit Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
0,
0,
0 // Layer Masks Ignored
};
m_dc = GetDC(m_window_handle);
@ -358,12 +367,12 @@ HGLRC cInterfaceWGL::CreateCoreContext(HDC dc, HGLRC share_context)
for (const auto& version : try_versions)
{
// Construct list of attributes. Prefer a forward-compatible, core context.
std::array<int, 5 * 2> attribs = {
WGL_CONTEXT_PROFILE_MASK_ARB,
std::array<int, 5 * 2> attribs = {WGL_CONTEXT_PROFILE_MASK_ARB,
WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
#ifdef _DEBUG
WGL_CONTEXT_FLAGS_ARB,
WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB | WGL_CONTEXT_DEBUG_BIT_ARB,
WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB |
WGL_CONTEXT_DEBUG_BIT_ARB,
#else
WGL_CONTEXT_FLAGS_ARB,
WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,

2
Source/Core/Common/IniFile.h
View File

@ -76,6 +76,7 @@ public:
const std::string& GetName() const { return name; }
const SectionMap& GetValues() const { return values; }
bool HasLines() const { return !m_lines.empty(); }
protected:
std::string name;
@ -142,6 +143,7 @@ public:
static void ParseLine(const std::string& line, std::string* keyOut, std::string* valueOut);
const std::list<Section>& GetSections() const { return sections; }
private:
std::list<Section> sections;

1
Source/Core/Common/Lazy.h
View File

@ -35,6 +35,7 @@ public:
const T* operator->() const { return ComputeValue(); }
T& operator*() { return *ComputeValue(); }
T* operator->() { return ComputeValue(); }
private:
T* ComputeValue() const
{

1
Source/Core/Common/Logging/LogManager.cpp
View File

@ -48,6 +48,7 @@ public:
bool IsValid() const { return m_logfile.good(); }
bool IsEnabled() const { return m_enable; }
void SetEnable(bool enable) { m_enable = enable; }
private:
std::mutex m_log_lock;
std::ofstream m_logfile;

1
Source/Core/Common/Profiler.h
View File

@ -51,6 +51,7 @@ class ProfilerExecuter
public:
ProfilerExecuter(Profiler* _p) : m_p(_p) { m_p->Start(); }
~ProfilerExecuter() { m_p->Stop(); }
private:
Profiler* m_p;
};

1
Source/Core/Common/QoSSession.h
View File

@ -27,6 +27,7 @@ public:
QoSSession& operator=(QoSSession&& session);
QoSSession(QoSSession&& session) { *this = std::move(session); }
bool Successful() const { return m_success; }
private:
#if defined(_WIN32)
void* m_qos_handle = nullptr;

1
Source/Core/Common/Result.h
View File

@ -24,6 +24,7 @@ public:
const T* operator->() const { return &std::get<T>(m_variant); }
T& operator*() { return std::get<T>(m_variant); }
T* operator->() { return &std::get<T>(m_variant); }
private:
std::variant<ResultCode, T> m_variant;
};

2
Source/Core/Common/Semaphore.h
View File

@ -24,6 +24,7 @@ public:
~Semaphore() { CloseHandle(m_handle); }
void Wait() { WaitForSingleObject(m_handle, INFINITE); }
void Post() { ReleaseSemaphore(m_handle, 1, nullptr); }
private:
HANDLE m_handle;
};
@ -42,6 +43,7 @@ public:
~Semaphore() { sem_destroy(&m_handle); }
void Wait() { sem_wait(&m_handle); }
void Post() { sem_post(&m_handle); }
private:
sem_t m_handle;
};

1
Source/Core/Core/Boot/DolReader.h
View File

@ -28,6 +28,7 @@ public:
u32 GetEntryPoint() const override { return m_dolheader.entryPoint; }
bool LoadIntoMemory(bool only_in_mem1 = false) const override;
bool LoadSymbols() const override { return false; }
private:
enum
{

1
Source/Core/Core/Boot/ElfReader.h
View File

@ -63,6 +63,7 @@ public:
SectionID GetSectionByName(const char* name, int firstSection = 0) const; //-1 for not found
bool DidRelocate() const { return bRelocate; }
private:
void Initialize(u8* bytes);

94
Source/Core/Core/ConfigLoaders/IsSettingSaveable.cpp
View File

@ -23,57 +23,89 @@ bool IsSettingSaveable(const Config::ConfigLocation& config_location)
const static std::vector<Config::ConfigLocation> s_setting_saveable{
// Graphics.Hardware
Config::GFX_VSYNC.location, Config::GFX_ADAPTER.location,
Config::GFX_VSYNC.location,
Config::GFX_ADAPTER.location,
// Graphics.Settings
Config::GFX_WIDESCREEN_HACK.location, Config::GFX_ASPECT_RATIO.location,
Config::GFX_CROP.location, Config::GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES.location,
Config::GFX_SHOW_FPS.location, Config::GFX_SHOW_NETPLAY_PING.location,
Config::GFX_SHOW_NETPLAY_MESSAGES.location, Config::GFX_LOG_RENDER_TIME_TO_FILE.location,
Config::GFX_OVERLAY_STATS.location, Config::GFX_OVERLAY_PROJ_STATS.location,
Config::GFX_DUMP_TEXTURES.location, Config::GFX_HIRES_TEXTURES.location,
Config::GFX_CACHE_HIRES_TEXTURES.location, Config::GFX_DUMP_EFB_TARGET.location,
Config::GFX_DUMP_FRAMES_AS_IMAGES.location, Config::GFX_FREE_LOOK.location,
Config::GFX_USE_FFV1.location, Config::GFX_DUMP_FORMAT.location,
Config::GFX_DUMP_CODEC.location, Config::GFX_DUMP_ENCODER.location,
Config::GFX_DUMP_PATH.location, Config::GFX_BITRATE_KBPS.location,
Config::GFX_WIDESCREEN_HACK.location,
Config::GFX_ASPECT_RATIO.location,
Config::GFX_CROP.location,
Config::GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES.location,
Config::GFX_SHOW_FPS.location,
Config::GFX_SHOW_NETPLAY_PING.location,
Config::GFX_SHOW_NETPLAY_MESSAGES.location,
Config::GFX_LOG_RENDER_TIME_TO_FILE.location,
Config::GFX_OVERLAY_STATS.location,
Config::GFX_OVERLAY_PROJ_STATS.location,
Config::GFX_DUMP_TEXTURES.location,
Config::GFX_HIRES_TEXTURES.location,
Config::GFX_CACHE_HIRES_TEXTURES.location,
Config::GFX_DUMP_EFB_TARGET.location,
Config::GFX_DUMP_FRAMES_AS_IMAGES.location,
Config::GFX_FREE_LOOK.location,
Config::GFX_USE_FFV1.location,
Config::GFX_DUMP_FORMAT.location,
Config::GFX_DUMP_CODEC.location,
Config::GFX_DUMP_ENCODER.location,
Config::GFX_DUMP_PATH.location,
Config::GFX_BITRATE_KBPS.location,
Config::GFX_INTERNAL_RESOLUTION_FRAME_DUMPS.location,
Config::GFX_ENABLE_GPU_TEXTURE_DECODING.location, Config::GFX_ENABLE_PIXEL_LIGHTING.location,
Config::GFX_FAST_DEPTH_CALC.location, Config::GFX_MSAA.location, Config::GFX_SSAA.location,
Config::GFX_EFB_SCALE.location, Config::GFX_TEXFMT_OVERLAY_ENABLE.location,
Config::GFX_TEXFMT_OVERLAY_CENTER.location, Config::GFX_ENABLE_WIREFRAME.location,
Config::GFX_DISABLE_FOG.location, Config::GFX_BORDERLESS_FULLSCREEN.location,
Config::GFX_ENABLE_VALIDATION_LAYER.location, Config::GFX_BACKEND_MULTITHREADING.location,
Config::GFX_COMMAND_BUFFER_EXECUTE_INTERVAL.location, Config::GFX_SHADER_CACHE.location,
Config::GFX_ENABLE_GPU_TEXTURE_DECODING.location,
Config::GFX_ENABLE_PIXEL_LIGHTING.location,
Config::GFX_FAST_DEPTH_CALC.location,
Config::GFX_MSAA.location,
Config::GFX_SSAA.location,
Config::GFX_EFB_SCALE.location,
Config::GFX_TEXFMT_OVERLAY_ENABLE.location,
Config::GFX_TEXFMT_OVERLAY_CENTER.location,
Config::GFX_ENABLE_WIREFRAME.location,
Config::GFX_DISABLE_FOG.location,
Config::GFX_BORDERLESS_FULLSCREEN.location,
Config::GFX_ENABLE_VALIDATION_LAYER.location,
Config::GFX_BACKEND_MULTITHREADING.location,
Config::GFX_COMMAND_BUFFER_EXECUTE_INTERVAL.location,
Config::GFX_SHADER_CACHE.location,
Config::GFX_WAIT_FOR_SHADERS_BEFORE_STARTING.location,
Config::GFX_SHADER_COMPILATION_MODE.location, Config::GFX_SHADER_COMPILER_THREADS.location,
Config::GFX_SHADER_COMPILATION_MODE.location,
Config::GFX_SHADER_COMPILER_THREADS.location,
Config::GFX_SHADER_PRECOMPILER_THREADS.location,
Config::GFX_SW_ZCOMPLOC.location, Config::GFX_SW_ZFREEZE.location,
Config::GFX_SW_DUMP_OBJECTS.location, Config::GFX_SW_DUMP_TEV_STAGES.location,
Config::GFX_SW_DUMP_TEV_TEX_FETCHES.location, Config::GFX_SW_DRAW_START.location,
Config::GFX_SW_ZCOMPLOC.location,
Config::GFX_SW_ZFREEZE.location,
Config::GFX_SW_DUMP_OBJECTS.location,
Config::GFX_SW_DUMP_TEV_STAGES.location,
Config::GFX_SW_DUMP_TEV_TEX_FETCHES.location,
Config::GFX_SW_DRAW_START.location,
Config::GFX_SW_DRAW_END.location,
// Graphics.Enhancements
Config::GFX_ENHANCE_FORCE_FILTERING.location, Config::GFX_ENHANCE_MAX_ANISOTROPY.location,
Config::GFX_ENHANCE_POST_SHADER.location, Config::GFX_ENHANCE_FORCE_TRUE_COLOR.location,
Config::GFX_ENHANCE_FORCE_FILTERING.location,
Config::GFX_ENHANCE_MAX_ANISOTROPY.location,
Config::GFX_ENHANCE_POST_SHADER.location,
Config::GFX_ENHANCE_FORCE_TRUE_COLOR.location,
// Graphics.Stereoscopy
Config::GFX_STEREO_MODE.location, Config::GFX_STEREO_DEPTH.location,
Config::GFX_STEREO_CONVERGENCE_PERCENTAGE.location, Config::GFX_STEREO_SWAP_EYES.location,
Config::GFX_STEREO_CONVERGENCE.location, Config::GFX_STEREO_EFB_MONO_DEPTH.location,
Config::GFX_STEREO_MODE.location,
Config::GFX_STEREO_DEPTH.location,
Config::GFX_STEREO_CONVERGENCE_PERCENTAGE.location,
Config::GFX_STEREO_SWAP_EYES.location,
Config::GFX_STEREO_CONVERGENCE.location,
Config::GFX_STEREO_EFB_MONO_DEPTH.location,
Config::GFX_STEREO_DEPTH_PERCENTAGE.location,
// Graphics.Hacks
Config::GFX_HACK_EFB_ACCESS_ENABLE.location, Config::GFX_HACK_BBOX_ENABLE.location,
Config::GFX_HACK_EFB_ACCESS_ENABLE.location,
Config::GFX_HACK_BBOX_ENABLE.location,
Config::GFX_HACK_BBOX_PREFER_STENCIL_IMPLEMENTATION.location,
Config::GFX_HACK_FORCE_PROGRESSIVE.location, Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM.location,
Config::GFX_HACK_FORCE_PROGRESSIVE.location,
Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM.location,
Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM.location,
Config::GFX_HACK_DISABLE_COPY_TO_VRAM.location, Config::GFX_HACK_IMMEDIATE_XFB.location,
Config::GFX_HACK_DISABLE_COPY_TO_VRAM.location,
Config::GFX_HACK_IMMEDIATE_XFB.location,
Config::GFX_HACK_COPY_EFB_SCALED.location,
Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES.location,
Config::GFX_HACK_VERTEX_ROUDING.location,

3
Source/Core/Core/CoreTiming.cpp
View File

@ -260,7 +260,8 @@ void ScheduleEvent(s64 cycles_into_future, EventType* event_type, u64 userdata,
{
if (Core::WantsDeterminism())
{
ERROR_LOG(POWERPC, "Someone scheduled an off-thread \"%s\" event while netplay or "
ERROR_LOG(POWERPC,
"Someone scheduled an off-thread \"%s\" event while netplay or "
"movie play/record was active. This is likely to cause a desync.",
event_type->name->c_str());
}

3
Source/Core/Core/DSP/DSPAssembler.cpp
View File

@ -524,7 +524,8 @@ bool DSPAssembler::VerifyParams(const DSPOPCTemplate* opc, param_t* par, size_t
if (par[i].val >= 0x1e && par[i].val <= 0x1f)
{
fprintf(stderr, "%i : %s ", code_line, cur_line.c_str());
fprintf(stderr, "WARNING: $ACM%d register used instead of $ACC%d register Line: %d "
fprintf(stderr,
"WARNING: $ACM%d register used instead of $ACC%d register Line: %d "
"Param: %zu Ext: %d\n",
(par[i].val & 1), (par[i].val & 1), code_line, current_param,
static_cast<int>(type));

1
Source/Core/Core/DSP/DSPAssembler.h
View File

@ -63,6 +63,7 @@ public:
std::string GetErrorString() const { return last_error_str; }
AssemblerError GetError() const { return last_error; }
private:
struct param_t
{

1
Source/Core/Core/DSP/DSPBreakpoints.h
View File

@ -43,6 +43,7 @@ public:
void Clear() { memset(b, 0, sizeof(b)); }
void DeleteByAddress(u32 addr) { b[addr] = 0; }
private:
u8 b[65536];
};

6
Source/Core/Core/GeckoCode.cpp
View File

@ -139,7 +139,8 @@ static Installation InstallCodeHandlerLocked()
// If the code is not going to fit in the space we have left then we have to skip it
if (next_address + active_code.codes.size() * CODE_SIZE > end_address)
{
NOTICE_LOG(ACTIONREPLAY, "Too many GeckoCodes! Ran out of storage space in Game RAM. Could "
NOTICE_LOG(ACTIONREPLAY,
"Too many GeckoCodes! Ran out of storage space in Game RAM. Could "
"not write: \"%s\". Need %zu bytes, only %u remain.",
active_code.name.c_str(), active_code.codes.size() * CODE_SIZE,
end_address - next_address);
@ -238,7 +239,8 @@ void RunCodeHandler()
PowerPC::HostWrite_U64(riPS0(i), SP + 24 + 2 * i * sizeof(u64));
PowerPC::HostWrite_U64(riPS1(i), SP + 24 + (2 * i + 1) * sizeof(u64));
}
DEBUG_LOG(ACTIONREPLAY, "GeckoCodes: Initiating phantom branch-and-link. "
DEBUG_LOG(ACTIONREPLAY,
"GeckoCodes: Initiating phantom branch-and-link. "
"PC = 0x%08X, SP = 0x%08X, SFP = 0x%08X",
PC, SP, SFP);
LR = HLE_TRAMPOLINE_ADDRESS;

3
Source/Core/Core/HW/DSPHLE/UCodes/GBA.cpp
View File

@ -66,7 +66,8 @@ void ProcessGBACrypto(u32 address)
HLEMemory_Write_U32(dest_addr + 4, t3);
// Done!
DEBUG_LOG(DSPHLE, "\n%08x -> challenge: %08x, len: %08x, dest_addr: %08x, "
DEBUG_LOG(DSPHLE,
"\n%08x -> challenge: %08x, len: %08x, dest_addr: %08x, "
"palette: %08x, speed: %08x key: %08x, auth_code: %08x",
address, challenge, length, dest_addr, logo_palette, logo_speed_32, key, t3);
}

1
Source/Core/Core/HW/DSPHLE/UCodes/UCodes.h
View File

@ -51,6 +51,7 @@ public:
virtual void DoState(PointerWrap& p) { DoStateShared(p); }
static u32 GetCRC(UCodeInterface* ucode) { return ucode ? ucode->m_crc : UCODE_NULL; }
protected:
void PrepareBootUCode(u32 mail);

9
Source/Core/Core/HW/DSPHLE/UCodes/Zelda.cpp
View File

@ -1035,10 +1035,15 @@ void ZeldaAudioRenderer::ApplyReverb(bool post_rendering)
// Each of the 4 RPBs maps to one of these buffers.
MixingBuffer* reverb_buffers[4] = {
&m_buf_unk0_reverb, &m_buf_unk1_reverb, &m_buf_front_left_reverb, &m_buf_front_right_reverb,
&m_buf_unk0_reverb,
&m_buf_unk1_reverb,
&m_buf_front_left_reverb,
&m_buf_front_right_reverb,
};
std::array<s16, 8>* last8_samples_buffers[4] = {
&m_buf_unk0_reverb_last8, &m_buf_unk1_reverb_last8, &m_buf_front_left_reverb_last8,
&m_buf_unk0_reverb_last8,
&m_buf_unk1_reverb_last8,
&m_buf_front_left_reverb_last8,
&m_buf_front_right_reverb_last8,
};

12
Source/Core/Core/HW/DVD/DVDInterface.cpp
View File

@ -318,7 +318,8 @@ static u32 AdvanceDTK(u32 maximum_samples, u32* samples_to_process)
{
if (s_audio_position >= s_current_start + s_current_length)
{
DEBUG_LOG(DVDINTERFACE, "AdvanceDTK: NextStart=%08" PRIx64 ", NextLength=%08x, "
DEBUG_LOG(DVDINTERFACE,
"AdvanceDTK: NextStart=%08" PRIx64 ", NextLength=%08x, "
"CurrentStart=%08" PRIx64 ", CurrentLength=%08x, AudioPos=%08" PRIx64,
s_next_start, s_next_length, s_current_start, s_current_length, s_audio_position);
@ -825,7 +826,8 @@ void ExecuteCommand(u32 command_0, u32 command_1, u32 command_2, u32 output_addr
{
u64 iDVDOffset = (u64)command_1 << 2;
INFO_LOG(DVDINTERFACE, "Read: DVDOffset=%08" PRIx64
INFO_LOG(DVDINTERFACE,
"Read: DVDOffset=%08" PRIx64
", DMABuffer = %08x, SrcLength = %08x, DMALength = %08x",
iDVDOffset, output_address, command_2, output_length);
@ -948,7 +950,8 @@ void ExecuteCommand(u32 command_0, u32 command_1, u32 command_2, u32 output_addr
switch (command_0 >> 16 & 0xFF)
{
case 0x00: // Returns streaming status
INFO_LOG(DVDINTERFACE, "(Audio): Stream Status: Request Audio status "
INFO_LOG(DVDINTERFACE,
"(Audio): Stream Status: Request Audio status "
"AudioPos:%08" PRIx64 "/%08" PRIx64 " "
"CurrentStart:%08" PRIx64 " CurrentLength:%08x",
s_audio_position, s_current_start + s_current_length, s_current_start,
@ -1295,7 +1298,8 @@ void ScheduleReads(u64 offset, u32 length, const DiscIO::Partition& partition, u
s_read_buffer_end_offset - s_read_buffer_start_offset, wii_disc));
}
DEBUG_LOG(DVDINTERFACE, "Schedule reads: ECC blocks unbuffered=%d, buffered=%d, "
DEBUG_LOG(DVDINTERFACE,
"Schedule reads: ECC blocks unbuffered=%d, buffered=%d, "
"ticks=%" PRId64 ", time=%" PRId64 " us",
unbuffered_blocks, buffered_blocks, ticks_until_completion,
ticks_until_completion * 1000000 / SystemTimers::GetTicksPerSecond());

3
Source/Core/Core/HW/DVD/DVDThread.cpp
View File

@ -311,7 +311,8 @@ static void FinishRead(u64 id, s64 cycles_late)
const ReadRequest& request = result.first;
const std::vector<u8>& buffer = result.second;
DEBUG_LOG(DVDINTERFACE, "Disc has been read. Real time: %" PRIu64 " us. "
DEBUG_LOG(DVDINTERFACE,
"Disc has been read. Real time: %" PRIu64 " us. "
"Real time including delay: %" PRIu64 " us. "
"Emulated time including delay: %" PRIu64 " us.",
request.realtime_done_us - request.realtime_started_us,

1
Source/Core/Core/HW/GCMemcard/GCMemcard.h
View File

@ -81,6 +81,7 @@ public:
virtual void DoState(PointerWrap& p) = 0;
u32 GetCardId() const { return m_nintendo_card_id; }
bool IsAddressInBounds(u32 address) const { return address <= (m_memory_card_size - 1); }
protected:
int m_card_index;
u16 m_nintendo_card_id;

3
Source/Core/Core/HW/GCPadEmu.cpp
View File

@ -27,7 +27,8 @@ static const u16 button_bitmasks[] = {
};
static const u16 trigger_bitmasks[] = {
PAD_TRIGGER_L, PAD_TRIGGER_R,
PAD_TRIGGER_L,
PAD_TRIGGER_R,
};
static const u16 dpad_bitmasks[] = {PAD_BUTTON_UP, PAD_BUTTON_DOWN, PAD_BUTTON_LEFT,

6
Source/Core/Core/HW/MMIO.cpp
View File

@ -148,7 +148,8 @@ private:
std::function<T(u32)> InvalidReadLambda() const
{
return [](u32) {
DEBUG_ASSERT_MSG(MEMMAP, 0, "Called the read lambda on a write "
DEBUG_ASSERT_MSG(MEMMAP, 0,
"Called the read lambda on a write "
"complex handler.");
return 0;
};
@ -157,7 +158,8 @@ private:
std::function<void(u32, T)> InvalidWriteLambda() const
{
return [](u32, T) {
DEBUG_ASSERT_MSG(MEMMAP, 0, "Called the write lambda on a read "
DEBUG_ASSERT_MSG(MEMMAP, 0,
"Called the write lambda on a read "
"complex handler.");
};
}

3
Source/Core/Core/HW/MMIO.h
View File

@ -62,7 +62,8 @@ inline bool IsMMIOAddress(u32 address)
// The block ID can easily be computed by simply checking bit 24 (CC vs. CD).
inline u32 UniqueID(u32 address)
{
DEBUG_ASSERT_MSG(MEMMAP, ((address & 0xFFFF0000) == 0x0C000000) ||
DEBUG_ASSERT_MSG(MEMMAP,
((address & 0xFFFF0000) == 0x0C000000) ||
((address & 0xFFFF0000) == 0x0D000000) ||
((address & 0xFFFF0000) == 0x0D800000),
"Trying to get the ID of a non-existing MMIO address.");

14
Source/Core/Core/HW/VideoInterface.cpp
View File

@ -61,7 +61,8 @@ static UVIBorderBlankRegister m_BorderHBlank;
static u32 s_target_refresh_rate = 0;
static constexpr std::array<u32, 2> s_clock_freqs{{
27000000, 54000000,
27000000,
54000000,
}};
static u64 s_ticks_last_line_start; // number of ticks when the current full scanline started
@ -323,9 +324,8 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
}));
mmio->Register(
base | VI_HORIZONTAL_BEAM_POSITION, MMIO::ComplexRead<u16>([](u32) {
u16 value =
static_cast<u16>(1 +
m_HTiming0.HLW * (CoreTiming::GetTicks() - s_ticks_last_line_start) /
u16 value = static_cast<u16>(1 + m_HTiming0.HLW *
(CoreTiming::GetTicks() - s_ticks_last_line_start) /
(GetTicksPerHalfLine()));
return MathUtil::Clamp(value, static_cast<u16>(1), static_cast<u16>(m_HTiming0.HLW * 2));
}),
@ -644,12 +644,14 @@ static void LogField(FieldType field, u32 xfb_address)
static constexpr std::array<const char*, 2> field_type_names{{"Odd", "Even"}};
static const std::array<const UVIVBlankTimingRegister*, 2> vert_timing{{
&m_VBlankTimingOdd, &m_VBlankTimingEven,
&m_VBlankTimingOdd,
&m_VBlankTimingEven,
}};
const auto field_index = static_cast<size_t>(field);
DEBUG_LOG(VIDEOINTERFACE, "(VI->BeginField): Address: %.08X | WPL %u | STD %u | EQ %u | PRB %u | "
DEBUG_LOG(VIDEOINTERFACE,
"(VI->BeginField): Address: %.08X | WPL %u | STD %u | EQ %u | PRB %u | "
"ACV %u | PSB %u | Field %s",
xfb_address, m_PictureConfiguration.WPL, m_PictureConfiguration.STD,
m_VerticalTimingRegister.EQU, vert_timing[field_index]->PRB,

46
Source/Core/Core/HW/WiimoteEmu/Attachment/Classic.cpp
View File

@ -23,25 +23,54 @@ constexpr std::array<u8, 6> classic_id{{0x00, 0x00, 0xa4, 0x20, 0x01, 0x01}};
// Classic Controller calibration
constexpr std::array<u8, 0x10> classic_calibration{{
0xff, 0x00, 0x80, 0xff, 0x00, 0x80, 0xff, 0x00, 0x80, 0xff, 0x00, 0x80, 0x00, 0x00, 0x51, 0xa6,
0xff,
0x00,
0x80,
0xff,
0x00,
0x80,
0xff,
0x00,
0x80,
0xff,
0x00,
0x80,
0x00,
0x00,
0x51,
0xa6,
}};
constexpr std::array<u16, 9> classic_button_bitmasks{{
Classic::BUTTON_A, Classic::BUTTON_B, Classic::BUTTON_X, Classic::BUTTON_Y,
Classic::BUTTON_A,
Classic::BUTTON_B,
Classic::BUTTON_X,
Classic::BUTTON_Y,
Classic::BUTTON_ZL, Classic::BUTTON_ZR,
Classic::BUTTON_ZL,
Classic::BUTTON_ZR,
Classic::BUTTON_MINUS, Classic::BUTTON_PLUS,
Classic::BUTTON_MINUS,
Classic::BUTTON_PLUS,
Classic::BUTTON_HOME,
}};
constexpr std::array<const char*, 9> classic_button_names{{
"A", "B", "X", "Y", "ZL", "ZR", "-", "+", "Home",
"A",
"B",
"X",
"Y",
"ZL",
"ZR",
"-",
"+",
"Home",
}};
constexpr std::array<u16, 2> classic_trigger_bitmasks{{
Classic::TRIGGER_L, Classic::TRIGGER_R,
Classic::TRIGGER_L,
Classic::TRIGGER_R,
}};
constexpr std::array<const char*, 4> classic_trigger_names{{
@ -56,7 +85,10 @@ constexpr std::array<const char*, 4> classic_trigger_names{{
}};
constexpr std::array<u16, 4> classic_dpad_bitmasks{{
Classic::PAD_UP, Classic::PAD_DOWN, Classic::PAD_LEFT, Classic::PAD_RIGHT,
Classic::PAD_UP,
Classic::PAD_DOWN,
Classic::PAD_LEFT,
Classic::PAD_RIGHT,
}};
Classic::Classic(ExtensionReg& reg) : Attachment(_trans("Classic"), reg)

15
Source/Core/Core/HW/WiimoteEmu/Attachment/Drums.cpp
View File

@ -20,17 +20,26 @@ namespace WiimoteEmu
constexpr std::array<u8, 6> drums_id{{0x01, 0x00, 0xa4, 0x20, 0x01, 0x03}};
constexpr std::array<u16, 6> drum_pad_bitmasks{{
Drums::PAD_RED, Drums::PAD_YELLOW, Drums::PAD_BLUE, Drums::PAD_GREEN, Drums::PAD_ORANGE,
Drums::PAD_RED,
Drums::PAD_YELLOW,
Drums::PAD_BLUE,
Drums::PAD_GREEN,
Drums::PAD_ORANGE,
Drums::PAD_BASS,
}};
constexpr std::array<const char*, 6> drum_pad_names{{
_trans("Red"), _trans("Yellow"), _trans("Blue"), _trans("Green"), _trans("Orange"),
_trans("Red"),
_trans("Yellow"),
_trans("Blue"),
_trans("Green"),
_trans("Orange"),
_trans("Bass"),
}};
constexpr std::array<u16, 2> drum_button_bitmasks{{
Drums::BUTTON_MINUS, Drums::BUTTON_PLUS,
Drums::BUTTON_MINUS,
Drums::BUTTON_PLUS,
}};
Drums::Drums(ExtensionReg& reg) : Attachment(_trans("Drums"), reg)

17
Source/Core/Core/HW/WiimoteEmu/Attachment/Guitar.cpp
View File

@ -36,20 +36,29 @@ static const std::map<const ControlState, const u8> s_slider_bar_control_codes{
constexpr std::array<u8, 6> guitar_id{{0x00, 0x00, 0xa4, 0x20, 0x01, 0x03}};
constexpr std::array<u16, 5> guitar_fret_bitmasks{{
Guitar::FRET_GREEN, Guitar::FRET_RED, Guitar::FRET_YELLOW, Guitar::FRET_BLUE,
Guitar::FRET_GREEN,
Guitar::FRET_RED,
Guitar::FRET_YELLOW,
Guitar::FRET_BLUE,
Guitar::FRET_ORANGE,
}};
constexpr std::array<const char*, 5> guitar_fret_names{{
_trans("Green"), _trans("Red"), _trans("Yellow"), _trans("Blue"), _trans("Orange"),
_trans("Green"),
_trans("Red"),
_trans("Yellow"),
_trans("Blue"),
_trans("Orange"),
}};
constexpr std::array<u16, 2> guitar_button_bitmasks{{
Guitar::BUTTON_MINUS, Guitar::BUTTON_PLUS,
Guitar::BUTTON_MINUS,
Guitar::BUTTON_PLUS,
}};
constexpr std::array<u16, 2> guitar_strum_bitmasks{{
Guitar::BAR_UP, Guitar::BAR_DOWN,
Guitar::BAR_UP,
Guitar::BAR_DOWN,
}};
Guitar::Guitar(ExtensionReg& reg) : Attachment(_trans("Guitar"), reg)

3
Source/Core/Core/HW/WiimoteEmu/Attachment/Nunchuk.cpp
View File

@ -24,7 +24,8 @@ namespace WiimoteEmu
constexpr std::array<u8, 6> nunchuk_id{{0x00, 0x00, 0xa4, 0x20, 0x00, 0x00}};
constexpr std::array<u8, 2> nunchuk_button_bitmasks{{
Nunchuk::BUTTON_C, Nunchuk::BUTTON_Z,
Nunchuk::BUTTON_C,
Nunchuk::BUTTON_Z,
}};
Nunchuk::Nunchuk(ExtensionReg& reg) : Attachment(_trans("Nunchuk"), reg)

22
Source/Core/Core/HW/WiimoteEmu/Attachment/Turntable.cpp
View File

@ -23,14 +23,26 @@ namespace WiimoteEmu
constexpr std::array<u8, 6> turntable_id{{0x03, 0x00, 0xa4, 0x20, 0x01, 0x03}};
constexpr std::array<u16, 9> turntable_button_bitmasks{{
Turntable::BUTTON_L_GREEN, Turntable::BUTTON_L_RED, Turntable::BUTTON_L_BLUE,
Turntable::BUTTON_R_GREEN, Turntable::BUTTON_R_RED, Turntable::BUTTON_R_BLUE,
Turntable::BUTTON_MINUS, Turntable::BUTTON_PLUS, Turntable::BUTTON_EUPHORIA,
Turntable::BUTTON_L_GREEN,
Turntable::BUTTON_L_RED,
Turntable::BUTTON_L_BLUE,
Turntable::BUTTON_R_GREEN,
Turntable::BUTTON_R_RED,
Turntable::BUTTON_R_BLUE,
Turntable::BUTTON_MINUS,
Turntable::BUTTON_PLUS,
Turntable::BUTTON_EUPHORIA,
}};
constexpr std::array<const char*, 9> turntable_button_names{{
_trans("Green Left"), _trans("Red Left"), _trans("Blue Left"), _trans("Green Right"),
_trans("Red Right"), _trans("Blue Right"), "-", "+",
_trans("Green Left"),
_trans("Red Left"),
_trans("Blue Left"),
_trans("Green Right"),
_trans("Red Right"),
_trans("Blue Right"),
"-",
"+",
// i18n: This button name refers to a gameplay element in DJ Hero
_trans("Euphoria"),
}};

2
Source/Core/Core/HW/WiimoteEmu/WiimoteEmu.cpp
View File

@ -53,6 +53,7 @@ auto const PI = TAU / 2.0;
namespace WiimoteEmu
{
// clang-format off
static const u8 eeprom_data_0[] = {
// IR, maybe more
// assuming last 2 bytes are checksum
@ -64,6 +65,7 @@ static const u8 eeprom_data_0[] = {
ACCEL_ZERO_G, ACCEL_ZERO_G, ACCEL_ZERO_G, 0, ACCEL_ONE_G, ACCEL_ONE_G, ACCEL_ONE_G, 0, 0, 0xA3,
ACCEL_ZERO_G, ACCEL_ZERO_G, ACCEL_ZERO_G, 0, ACCEL_ONE_G, ACCEL_ONE_G, ACCEL_ONE_G, 0, 0, 0xA3,
};
// clang-format on
static const u8 motion_plus_id[] = {0x00, 0x00, 0xA6, 0x20, 0x00, 0x05};

1
Source/Core/Core/HW/WiimoteReal/IOAndroid.h
View File

@ -19,6 +19,7 @@ public:
WiimoteAndroid(int index);
~WiimoteAndroid() override;
std::string GetId() const override { return "Android " + std::to_string(m_mayflash_index); }
protected:
bool ConnectInternal() override;
void DisconnectInternal() override;

3
Source/Core/Core/HW/WiimoteReal/IOLinux.cpp
View File

@ -258,7 +258,8 @@ int WiimoteLinux::IORead(u8* buf)
if (errno == ENOTCONN)
{
// This can happen if the Bluetooth dongle is disconnected
ERROR_LOG(WIIMOTE, "Bluetooth appears to be disconnected. "
ERROR_LOG(WIIMOTE,
"Bluetooth appears to be disconnected. "
"Wiimote %i will be disconnected.",
m_index + 1);
}

1
Source/Core/Core/HW/WiimoteReal/IOWin.h
View File

@ -27,6 +27,7 @@ public:
WiimoteWindows(const std::basic_string<TCHAR>& path, WinWriteMethod initial_write_method);
~WiimoteWindows() override;
std::string GetId() const override { return UTF16ToUTF8(m_devicepath); }
protected:
bool ConnectInternal() override;
void DisconnectInternal() override;

6
Source/Core/Core/HW/WiimoteReal/IOhidapi.cpp
View File

@ -15,7 +15,8 @@ static bool IsDeviceUsable(const std::string& device_path)
hid_device* handle = hid_open_path(device_path.c_str());
if (handle == nullptr)
{
ERROR_LOG(WIIMOTE, "Could not connect to Wii Remote at \"%s\". "
ERROR_LOG(WIIMOTE,
"Could not connect to Wii Remote at \"%s\". "
"Do you have permission to access the device?",
device_path.c_str());
return false;
@ -96,7 +97,8 @@ bool WiimoteHidapi::ConnectInternal()
m_handle = hid_open_path(m_device_path.c_str());
if (m_handle == nullptr)
{
ERROR_LOG(WIIMOTE, "Could not connect to Wii Remote at \"%s\". "
ERROR_LOG(WIIMOTE,
"Could not connect to Wii Remote at \"%s\". "
"Do you have permission to access the device?",
m_device_path.c_str());
}

1
Source/Core/Core/HW/WiimoteReal/IOhidapi.h
View File

@ -17,6 +17,7 @@ public:
explicit WiimoteHidapi(const std::string& device_path);
~WiimoteHidapi() override;
std::string GetId() const override { return m_device_path; }
protected:
bool ConnectInternal() override;
void DisconnectInternal() override;

3
Source/Core/Core/IOS/ES/TitleManagement.cpp
View File

@ -278,7 +278,8 @@ ReturnCode ES::ImportContentBegin(Context& context, u64 title_id, u32 content_id
if (title_id != context.title_import_export.tmd.GetTitleId())
{
ERROR_LOG(IOS_ES, "ImportContentBegin: title id %016" PRIx64 " != "
ERROR_LOG(IOS_ES,
"ImportContentBegin: title id %016" PRIx64 " != "
"TMD title id %016" PRIx64 ", ignoring",
title_id, context.title_import_export.tmd.GetTitleId());
return ES_EINVAL;

1
Source/Core/Core/IOS/IOS.cpp
View File

@ -318,6 +318,7 @@ struct ARMBinary final
u32 GetHeaderSize() const { return Common::swap32(m_bytes.data()); }
u32 GetElfOffset() const { return Common::swap32(m_bytes.data() + 0x4); }
u32 GetElfSize() const { return Common::swap32(m_bytes.data() + 0x8); }
private:
std::vector<u8> m_bytes;
};

4
Source/Core/Core/IOS/IOSC.cpp
View File

@ -100,10 +100,13 @@ namespace HLE
{
constexpr u32 DEFAULT_DEVICE_ID = 0x0403AC68;
constexpr u32 DEFAULT_KEY_ID = 0x6AAB8C59;
constexpr std::array<u8, 30> DEFAULT_PRIVATE_KEY = {{
0x00, 0xAB, 0xEE, 0xC1, 0xDD, 0xB4, 0xA6, 0x16, 0x6B, 0x70, 0xFD, 0x7E, 0x56, 0x67, 0x70,
0x57, 0x55, 0x27, 0x38, 0xA3, 0x26, 0xC5, 0x46, 0x16, 0xF7, 0x62, 0xC9, 0xED, 0x73, 0xF2,
}};
// clang-format off
constexpr ECCSignature DEFAULT_SIGNATURE = {{
// R
0x00, 0xD8, 0x81, 0x63, 0xB2, 0x00, 0x6B, 0x0B, 0x54, 0x82, 0x88, 0x63, 0x81, 0x1C, 0x00, 0x71,
@ -112,6 +115,7 @@ constexpr ECCSignature DEFAULT_SIGNATURE = {{
0x00, 0x71, 0x8D, 0x82, 0x41, 0xEE, 0x45, 0x11, 0xC7, 0x3B, 0xAC, 0x08, 0xB6, 0x83, 0xDC, 0x05,
0xB8, 0xA8, 0x90, 0x1F, 0xA8, 0x2A, 0x0E, 0x4E, 0x76, 0xEF, 0x44, 0x72, 0x99, 0xF8,
}};
// clang-format on
const std::map<std::pair<IOSC::ObjectType, IOSC::ObjectSubType>, size_t> s_type_to_size_map = {{
{{IOSC::TYPE_SECRET_KEY, IOSC::SUBTYPE_AES128}, 16},

24
Source/Core/Core/IOS/Network/IP/Top.cpp
View File

@ -251,7 +251,8 @@ IPCCommandResult NetIPTop::HandleSocketRequest(const IOCtlRequest& request)
WiiSockMan& sm = WiiSockMan::GetInstance();
const s32 return_value = sm.NewSocket(af, type, prot);
INFO_LOG(IOS_NET, "IOCTL_SO_SOCKET "
INFO_LOG(IOS_NET,
"IOCTL_SO_SOCKET "
"Socket: %08x (%d,%d,%d), BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
return_value, af, type, prot, request.buffer_in, request.buffer_in_size,
request.buffer_out, request.buffer_out_size);
@ -353,7 +354,8 @@ IPCCommandResult NetIPTop::HandleSetSockOptRequest(const IOCtlRequest& request)
optlen = std::min(optlen, (u32)sizeof(optval));
Memory::CopyFromEmu(optval, request.buffer_in + 0x10, optlen);
INFO_LOG(IOS_NET, "IOCTL_SO_SETSOCKOPT(%08x, %08x, %08x, %08x) "
INFO_LOG(IOS_NET,
"IOCTL_SO_SETSOCKOPT(%08x, %08x, %08x, %08x) "
"BufferIn: (%08x, %i), BufferOut: (%08x, %i)"
"%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx",
@ -502,7 +504,8 @@ IPCCommandResult NetIPTop::HandleInetAToNRequest(const IOCtlRequest& request)
if (remoteHost == nullptr || remoteHost->h_addr_list == nullptr ||
remoteHost->h_addr_list[0] == nullptr)
{
INFO_LOG(IOS_NET, "IOCTL_SO_INETATON = -1 "
INFO_LOG(IOS_NET,
"IOCTL_SO_INETATON = -1 "
"%s, BufferIn: (%08x, %i), BufferOut: (%08x, %i), IP Found: None",
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size);
@ -510,7 +513,8 @@ IPCCommandResult NetIPTop::HandleInetAToNRequest(const IOCtlRequest& request)
}
Memory::Write_U32(Common::swap32(*(u32*)remoteHost->h_addr_list[0]), request.buffer_out);
INFO_LOG(IOS_NET, "IOCTL_SO_INETATON = 0 "
INFO_LOG(IOS_NET,
"IOCTL_SO_INETATON = 0 "
"%s, BufferIn: (%08x, %i), BufferOut: (%08x, %i), IP Found: %08X",
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size, Common::swap32(*(u32*)remoteHost->h_addr_list[0]));
@ -577,7 +581,8 @@ IPCCommandResult NetIPTop::HandlePollRequest(const IOCtlRequest& request)
ufds[i].events |= map.native;
unhandled_events &= ~map.wii;
}
DEBUG_LOG(IOS_NET, "IOCTL_SO_POLL(%d) "
DEBUG_LOG(IOS_NET,
"IOCTL_SO_POLL(%d) "
"Sock: %08x, Unknown: %08x, Events: %08x, "
"NativeEvents: %08x",
i, wii_fd, unknown, events, ufds[i].events);
@ -625,7 +630,8 @@ IPCCommandResult NetIPTop::HandleGetHostByNameRequest(const IOCtlRequest& reques
std::string hostname = Memory::GetString(request.buffer_in);
hostent* remoteHost = gethostbyname(hostname.c_str());
INFO_LOG(IOS_NET, "IOCTL_SO_GETHOSTBYNAME "
INFO_LOG(IOS_NET,
"IOCTL_SO_GETHOSTBYNAME "
"Address: %s, BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size);
@ -718,7 +724,8 @@ IPCCommandResult NetIPTop::HandleGetInterfaceOptRequest(const IOCtlVRequest& req
param5 = Memory::Read_U32(request.io_vectors[0].address + 4);
}
INFO_LOG(IOS_NET, "IOCTLV_SO_GETINTERFACEOPT(%08X, %08X, %X, %X, %X) "
INFO_LOG(IOS_NET,
"IOCTLV_SO_GETINTERFACEOPT(%08X, %08X, %X, %X, %X) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i) ",
param, param2, param3, param4, param5, request.in_vectors[0].address,
request.in_vectors[0].size,
@ -989,7 +996,8 @@ IPCCommandResult NetIPTop::HandleICMPPingRequest(const IOCtlVRequest& request)
if (ip_info.length != 8 || ip_info.addr_family != AF_INET)
{
INFO_LOG(IOS_NET, "IOCTLV_SO_ICMPPING strange IPInfo:\n"
INFO_LOG(IOS_NET,
"IOCTLV_SO_ICMPPING strange IPInfo:\n"
"length %x addr_family %x",
ip_info.length, ip_info.addr_family);
}

5
Source/Core/Core/IOS/Network/KD/NetKDRequest.cpp
View File

@ -165,7 +165,10 @@ u8 NetKDRequest::GetAreaCode(const std::string& area) const
u8 NetKDRequest::GetHardwareModel(const std::string& model) const
{
static const std::map<std::string, u8> models = {
{"RVL", MODEL_RVL}, {"RVT", MODEL_RVT}, {"RVV", MODEL_RVV}, {"RVD", MODEL_RVD},
{"RVL", MODEL_RVL},
{"RVT", MODEL_RVT},
{"RVV", MODEL_RVV},
{"RVD", MODEL_RVD},
};
auto entryPos = models.find(model);

3
Source/Core/Core/IOS/Network/MACUtils.cpp
View File

@ -38,7 +38,8 @@ void GetMACAddress(u8* mac)
SaveMACAddress(mac);
if (!wireless_mac.empty())
{
ERROR_LOG(IOS_NET, "The MAC provided (%s) is invalid. We have "
ERROR_LOG(IOS_NET,
"The MAC provided (%s) is invalid. We have "
"generated another one for you.",
Common::MacAddressToString(mac).c_str());
}

33
Source/Core/Core/IOS/Network/SSL.cpp
View File

@ -238,7 +238,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
WriteReturnValue(SSL_ERR_FAILED, BufferIn);
}
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_NEW (%d, %s) "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_NEW (%d, %s) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -275,7 +276,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
{
WriteReturnValue(SSL_ERR_ID, BufferIn);
}
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SHUTDOWN "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_SHUTDOWN "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -285,7 +287,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
}
case IOCTLV_NET_SSL_SETROOTCA:
{
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETROOTCA "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_SETROOTCA "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -325,7 +328,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
}
case IOCTLV_NET_SSL_SETBUILTINCLIENTCERT:
{
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETBUILTINCLIENTCERT "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_SETBUILTINCLIENTCERT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -371,7 +375,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
}
case IOCTLV_NET_SSL_REMOVECLIENTCERT:
{
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_REMOVECLIENTCERT "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_REMOVECLIENTCERT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -424,7 +429,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
{
WriteReturnValue(SSL_ERR_ID, BufferIn);
}
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETBUILTINROOTCA "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_SETBUILTINROOTCA "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -450,7 +456,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
{
WriteReturnValue(SSL_ERR_ID, BufferIn);
}
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_CONNECT "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_CONNECT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -486,7 +493,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
{
WriteReturnValue(SSL_ERR_ID, BufferIn);
}
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_WRITE "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_WRITE "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -510,7 +518,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
WriteReturnValue(SSL_ERR_ID, BufferIn);
}
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_READ(%d)"
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_READ(%d)"
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -529,7 +538,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
{
WriteReturnValue(SSL_ERR_ID, BufferIn);
}
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETROOTCADEFAULT "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_SETROOTCADEFAULT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",
@ -539,7 +549,8 @@ IPCCommandResult NetSSL::IOCtlV(const IOCtlVRequest& request)
}
case IOCTLV_NET_SSL_SETCLIENTCERTDEFAULT:
{
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_SETCLIENTCERTDEFAULT "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_SETCLIENTCERTDEFAULT "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferIn3: (%08x, %i), BufferOut: (%08x, %i), "
"BufferOut2: (%08x, %i), BufferOut3: (%08x, %i)",

6
Source/Core/Core/IOS/Network/Socket.cpp
View File

@ -393,7 +393,8 @@ void WiiSocket::Update(bool read, bool write, bool except)
}
}
INFO_LOG(IOS_SSL, "IOCTLV_NET_SSL_DOHANDSHAKE = (%d) "
INFO_LOG(IOS_SSL,
"IOCTLV_NET_SSL_DOHANDSHAKE = (%d) "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferOut: (%08x, %i), BufferOut2: (%08x, %i)",
ret, BufferIn, BufferInSize, BufferIn2, BufferInSize2, BufferOut,
@ -560,7 +561,8 @@ void WiiSocket::Update(bool read, bool write, bool except)
ReturnValue =
WiiSockMan::GetNetErrorCode(ret, BufferOutSize2 ? "SO_RECVFROM" : "SO_RECV", true);
INFO_LOG(IOS_NET, "%s(%d, %p) Socket: %08X, Flags: %08X, "
INFO_LOG(IOS_NET,
"%s(%d, %p) Socket: %08X, Flags: %08X, "
"BufferIn: (%08x, %i), BufferIn2: (%08x, %i), "
"BufferOut: (%08x, %i), BufferOut2: (%08x, %i)",
BufferOutSize2 ? "IOCTLV_SO_RECVFROM " : "IOCTLV_SO_RECV ", ReturnValue, data,

9
Source/Core/Core/IOS/SDIO/SDIOSlot0.cpp
View File

@ -561,7 +561,9 @@ std::array<u32, 4> SDIOSlot0::GetCSDv1() const
// Form the csd using the description above
return {{
0x007f003, 0x5b5f8000 | (c_size >> 2), 0x3ffc7f80 | (c_size << 30) | (c_size_mult << 15),
0x007f003,
0x5b5f8000 | (c_size >> 2),
0x3ffc7f80 | (c_size << 30) | (c_size_mult << 15),
0x07c04001 | (crc << 1),
}};
}
@ -616,7 +618,10 @@ std::array<u32, 4> SDIOSlot0::GetCSDv2() const
// Form the csd using the description above
return {{
0x400e005a, 0x5f590000 | (c_size >> 16), 0x00007f80 | (c_size << 16), 0x0a400001 | (crc << 1),
0x400e005a,
0x5f590000 | (c_size >> 16),
0x00007f80 | (c_size << 16),
0x0a400001 | (crc << 1),
}};
}

1
Source/Core/Core/IOS/USB/Bluetooth/BTBase.h
View File

@ -30,6 +30,7 @@ public:
virtual void UpdateSyncButtonState(bool is_held) {}
virtual void TriggerSyncButtonPressedEvent() {}
virtual void TriggerSyncButtonHeldEvent() {}
protected:
static constexpr int ACL_PKT_SIZE = 339;
static constexpr int ACL_PKT_NUM = 10;

9
Source/Core/Core/IOS/USB/Bluetooth/BTEmu.cpp
View File

@ -288,7 +288,8 @@ void BluetoothEmu::AddEventToQueue(const SQueuedEvent& _event)
m_EventQueue.size());
m_EventQueue.push_back(_event);
const SQueuedEvent& event = m_EventQueue.front();
DEBUG_LOG(IOS_WIIMOTE, "HCI event %x "
DEBUG_LOG(IOS_WIIMOTE,
"HCI event %x "
"being written from queue (%zu) to %08x...",
((hci_event_hdr_t*)event.m_buffer)->event, m_EventQueue.size() - 1,
m_HCIEndpoint->ios_request.address);
@ -400,7 +401,8 @@ void BluetoothEmu::ACLPool::WriteToEndpoint(USB::V0BulkMessage& endpoint)
const u16 size = packet.size;
const u16 conn_handle = packet.conn_handle;
DEBUG_LOG(IOS_WIIMOTE, "ACL packet being written from "
DEBUG_LOG(IOS_WIIMOTE,
"ACL packet being written from "
"queue to %08x",
endpoint.ios_request.address);
@ -1204,7 +1206,8 @@ void BluetoothEmu::CommandAcceptCon(const u8* input)
const hci_accept_con_cp* accept_connection = reinterpret_cast<const hci_accept_con_cp*>(input);
static char roles[][128] = {
{"Master (0x00)"}, {"Slave (0x01)"},
{"Master (0x00)"},
{"Slave (0x01)"},
};
INFO_LOG(IOS_WIIMOTE, "Command: HCI_CMD_ACCEPT_CON");

1
Source/Core/Core/IOS/USB/Bluetooth/BTEmu.h
View File

@ -87,6 +87,7 @@ private:
bool IsEmpty() const { return m_queue.empty(); }
// For SaveStates
void DoState(PointerWrap& p) { p.Do(m_queue); }
private:
struct Packet
{

2
Source/Core/Core/IOS/USB/Bluetooth/WiimoteDevice.h
View File

@ -34,6 +34,7 @@ public:
void Write16(u32 offset, u16 data) { *(u16*)&m_pBuffer[offset] = Common::swap16(data); }
void Write32(u32 offset, u32 data) { *(u32*)&m_pBuffer[offset] = Common::swap32(data); }
u8* GetPointer(u32 offset) { return &m_pBuffer[offset]; }
private:
u8* m_pBuffer;
};
@ -69,6 +70,7 @@ public:
u16 GetLMPSubVersion() const { return lmp_subversion; }
u16 GetManufactorID() const { return 0x000F; } // Broadcom Corporation
const u8* GetLinkKey() const { return m_LinkKey; }
private:
enum ConnectionState
{

1
Source/Core/Core/IOS/USB/LibusbDevice.h
View File

@ -36,6 +36,7 @@ public:
~LibusbConfigDescriptor();
libusb_config_descriptor* Get() const { return m_descriptor; }
bool IsValid() const { return m_descriptor != nullptr; }
private:
libusb_config_descriptor* m_descriptor = nullptr;
};

4
Source/Core/Core/PatchEngine.cpp
View File

@ -27,7 +27,9 @@
namespace PatchEngine
{
const char* PatchTypeStrings[] = {
"byte", "word", "dword",
"byte",
"word",
"dword",
};
static std::vector<Patch> onFrame;

1
Source/Core/Core/PowerPC/BreakPoints.h
View File

@ -93,6 +93,7 @@ public:
void Clear() { m_mem_checks.clear(); }
bool HasAny() const { return !m_mem_checks.empty(); }
private:
TMemChecks m_mem_checks;
};

1
Source/Core/Core/PowerPC/CachedInterpreter/CachedInterpreter.h
View File

@ -31,6 +31,7 @@ public:
JitBaseBlockCache* GetBlockCache() override { return &m_block_cache; }
const char* GetName() const override { return "Cached Interpreter"; }
const CommonAsmRoutinesBase* GetAsmRoutines() override { return nullptr; }
private:
struct Instruction;

1
Source/Core/Core/PowerPC/GDBStub.cpp
View File

@ -10,7 +10,6 @@
#include <unistd.h>
#ifdef _WIN32
#include <iphlpapi.h>
#include <iphlpapi.h>
#include <ws2tcpip.h>
#else
#include <netinet/in.h>

3
Source/Core/Core/PowerPC/Interpreter/Interpreter.cpp
View File

@ -92,7 +92,8 @@ static void Trace(UGeckoInstruction& inst)
}
std::string ppc_inst = GekkoDisassembler::Disassemble(inst.hex, PC);
DEBUG_LOG(POWERPC, "INTER PC: %08x SRR0: %08x SRR1: %08x CRval: %016lx FPSCR: %08x MSR: %08x LR: "
DEBUG_LOG(POWERPC,
"INTER PC: %08x SRR0: %08x SRR1: %08x CRval: %016lx FPSCR: %08x MSR: %08x LR: "
"%08x %s %08x %s",
PC, SRR0, SRR1, (unsigned long)PowerPC::ppcState.cr_val[0], PowerPC::ppcState.fpscr,
PowerPC::ppcState.msr, PowerPC::ppcState.spr[8], regs.c_str(), inst.hex,

2
Source/Core/Core/PowerPC/Interpreter/Interpreter_Branch.cpp
View File

@ -2,12 +2,12 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/PowerPC/Interpreter/Interpreter.h"
#include "Common/Assert.h"
#include "Common/CommonTypes.h"
#include "Core/ConfigManager.h"
#include "Core/CoreTiming.h"
#include "Core/HLE/HLE.h"
#include "Core/PowerPC/Interpreter/Interpreter.h"
#include "Core/PowerPC/PowerPC.h"
void Interpreter::bx(UGeckoInstruction inst)

2
Source/Core/Core/PowerPC/Jit64/Jit64_Tables.cpp
View File

@ -2,8 +2,8 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/PowerPC/Jit64/Jit.h"
#include "Core/PowerPC/Gekko.h"
#include "Core/PowerPC/Jit64/Jit.h"
static Jit64::Instruction dynaOpTable[64];
static Jit64::Instruction dynaOpTable4[1024];

2
Source/Core/Core/PowerPC/Jit64/Jit_Branch.cpp
View File

@ -2,12 +2,12 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/PowerPC/Jit64/Jit.h"
#include "Common/Assert.h"
#include "Common/CommonTypes.h"
#include "Common/x64Emitter.h"
#include "Core/CoreTiming.h"
#include "Core/PowerPC/Gekko.h"
#include "Core/PowerPC/Jit64/Jit.h"
#include "Core/PowerPC/Jit64/JitRegCache.h"
#include "Core/PowerPC/Jit64Common/Jit64PowerPCState.h"
#include "Core/PowerPC/PPCAnalyst.h"

2
Source/Core/Core/PowerPC/Jit64/Jit_LoadStoreFloating.cpp
View File

@ -2,10 +2,10 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/PowerPC/Jit64/Jit.h"
#include "Common/BitSet.h"
#include "Common/CommonTypes.h"
#include "Common/x64Emitter.h"
#include "Core/PowerPC/Jit64/Jit.h"
#include "Core/PowerPC/Jit64/JitRegCache.h"
#include "Core/PowerPC/Jit64Common/Jit64PowerPCState.h"

2
Source/Core/Core/PowerPC/Jit64/Jit_Paired.cpp
View File

@ -2,11 +2,11 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/PowerPC/Jit64/Jit.h"
#include "Common/CPUDetect.h"
#include "Common/CommonTypes.h"
#include "Common/MsgHandler.h"
#include "Common/x64Emitter.h"
#include "Core/PowerPC/Jit64/Jit.h"
#include "Core/PowerPC/Jit64/JitRegCache.h"
using namespace Gen;

2
Source/Core/Core/PowerPC/Jit64/Jit_SystemRegisters.cpp
View File

@ -2,13 +2,13 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/PowerPC/Jit64/Jit.h"
#include "Common/BitSet.h"
#include "Common/CPUDetect.h"
#include "Common/CommonTypes.h"
#include "Common/x64Emitter.h"
#include "Core/CoreTiming.h"
#include "Core/HW/ProcessorInterface.h"
#include "Core/PowerPC/Jit64/Jit.h"
#include "Core/PowerPC/Jit64/JitRegCache.h"
#include "Core/PowerPC/Jit64Common/Jit64PowerPCState.h"
#include "Core/PowerPC/PowerPC.h"

18
Source/Core/Core/PowerPC/Jit64Common/EmuCodeBlock.cpp
View File

@ -1059,7 +1059,8 @@ void EmuCodeBlock::SetFPRF(Gen::X64Reg xmm)
FixupBranch zeroExponent = J_CC(CC_Z);
// Nice normalized number: sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN;
LEA(32, RSCRATCH, MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_NN - MathUtil::PPC_FPCLASS_PN,
LEA(32, RSCRATCH,
MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_NN - MathUtil::PPC_FPCLASS_PN,
MathUtil::PPC_FPCLASS_PN));
continue1 = J();
@ -1073,7 +1074,8 @@ void EmuCodeBlock::SetFPRF(Gen::X64Reg xmm)
// Max exponent + no mantissa: sign ? PPC_FPCLASS_NINF : PPC_FPCLASS_PINF;
SetJumpTarget(notNAN);
LEA(32, RSCRATCH, MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_NINF - MathUtil::PPC_FPCLASS_PINF,
LEA(32, RSCRATCH,
MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_NINF - MathUtil::PPC_FPCLASS_PINF,
MathUtil::PPC_FPCLASS_PINF));
continue3 = J();
@ -1082,7 +1084,8 @@ void EmuCodeBlock::SetFPRF(Gen::X64Reg xmm)
FixupBranch zero = J_CC(CC_Z);
// No exponent + mantissa: sign ? PPC_FPCLASS_ND : PPC_FPCLASS_PD;
LEA(32, RSCRATCH, MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_ND - MathUtil::PPC_FPCLASS_PD,
LEA(32, RSCRATCH,
MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_ND - MathUtil::PPC_FPCLASS_PD,
MathUtil::PPC_FPCLASS_PD));
continue4 = J();
@ -1103,7 +1106,8 @@ void EmuCodeBlock::SetFPRF(Gen::X64Reg xmm)
FixupBranch infinity = J_CC(CC_E);
MOVQ_xmm(R(RSCRATCH), xmm);
SHR(64, R(RSCRATCH), Imm8(63));
LEA(32, RSCRATCH, MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_NN - MathUtil::PPC_FPCLASS_PN,
LEA(32, RSCRATCH,
MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_NN - MathUtil::PPC_FPCLASS_PN,
MathUtil::PPC_FPCLASS_PN));
continue1 = J();
SetJumpTarget(nan);
@ -1114,14 +1118,16 @@ void EmuCodeBlock::SetFPRF(Gen::X64Reg xmm)
SetJumpTarget(infinity);
MOVQ_xmm(R(RSCRATCH), xmm);
SHR(64, R(RSCRATCH), Imm8(63));
LEA(32, RSCRATCH, MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_NINF - MathUtil::PPC_FPCLASS_PINF,
LEA(32, RSCRATCH,
MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_NINF - MathUtil::PPC_FPCLASS_PINF,
MathUtil::PPC_FPCLASS_PINF));
continue3 = J();
SetJumpTarget(zeroExponent);
TEST(64, R(RSCRATCH), R(RSCRATCH));
FixupBranch zero = J_CC(CC_Z);
SHR(64, R(RSCRATCH), Imm8(63));
LEA(32, RSCRATCH, MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_ND - MathUtil::PPC_FPCLASS_PD,
LEA(32, RSCRATCH,
MScaled(RSCRATCH, MathUtil::PPC_FPCLASS_ND - MathUtil::PPC_FPCLASS_PD,
MathUtil::PPC_FPCLASS_PD));
continue4 = J();
SetJumpTarget(zero);

88
Source/Core/Core/PowerPC/JitArm64/JitArm64_RegCache.cpp
View File

@ -108,7 +108,17 @@ void Arm64GPRCache::Start(PPCAnalyst::BlockRegStats& stats)
bool Arm64GPRCache::IsCalleeSaved(ARM64Reg reg)
{
static constexpr std::array<ARM64Reg, 11> callee_regs{{
X28, X27, X26, X25, X24, X23, X22, X21, X20, X19, INVALID_REG,
X28,
X27,
X26,
X25,
X24,
X23,
X22,
X21,
X20,
X19,
INVALID_REG,
}};
return std::find(callee_regs.begin(), callee_regs.end(), EncodeRegTo64(reg)) != callee_regs.end();
@ -317,10 +327,37 @@ void Arm64GPRCache::GetAllocationOrder()
// Callee saved registers first in hopes that we will keep everything stored there first
static constexpr std::array<ARM64Reg, 29> allocation_order{{
// Callee saved
W27, W26, W25, W24, W23, W22, W21, W20, W19,
W27,
W26,
W25,
W24,
W23,
W22,
W21,
W20,
W19,
// Caller saved
W18, W17, W16, W15, W14, W13, W12, W11, W10, W9, W8, W7, W6, W5, W4, W3, W2, W1, W0, W30,
W18,
W17,
W16,
W15,
W14,
W13,
W12,
W11,
W10,
W9,
W8,
W7,
W6,
W5,
W4,
W3,
W2,
W1,
W0,
W30,
}};
for (ARM64Reg reg : allocation_order)
@ -545,11 +582,40 @@ void Arm64FPRCache::GetAllocationOrder()
{
static constexpr std::array<ARM64Reg, 32> allocation_order{{
// Callee saved
Q8, Q9, Q10, Q11, Q12, Q13, Q14, Q15,
Q8,
Q9,
Q10,
Q11,
Q12,
Q13,
Q14,
Q15,
// Caller saved
Q16, Q17, Q18, Q19, Q20, Q21, Q22, Q23, Q24, Q25, Q26, Q27, Q28, Q29, Q30, Q31, Q7, Q6, Q5,
Q4, Q3, Q2, Q1, Q0,
Q16,
Q17,
Q18,
Q19,
Q20,
Q21,
Q22,
Q23,
Q24,
Q25,
Q26,
Q27,
Q28,
Q29,
Q30,
Q31,
Q7,
Q6,
Q5,
Q4,
Q3,
Q2,
Q1,
Q0,
}};
for (ARM64Reg reg : allocation_order)
@ -574,7 +640,15 @@ void Arm64FPRCache::FlushByHost(ARM64Reg host_reg)
bool Arm64FPRCache::IsCalleeSaved(ARM64Reg reg)
{
static constexpr std::array<ARM64Reg, 9> callee_regs{{
Q8, Q9, Q10, Q11, Q12, Q13, Q14, Q15, INVALID_REG,
Q8,
Q9,
Q10,
Q11,
Q12,
Q13,
Q14,
Q15,
INVALID_REG,
}};
return std::find(callee_regs.begin(), callee_regs.end(), reg) != callee_regs.end();

4
Source/Core/Core/PowerPC/JitArm64/JitArm64_RegCache.h
View File

@ -85,6 +85,7 @@ public:
void IncrementLastUsed() { ++m_last_used; }
void SetDirty(bool dirty) { m_dirty = dirty; }
bool IsDirty() const { return m_dirty; }
private:
// For REG_REG
RegType m_type; // store type
@ -108,6 +109,7 @@ public:
void Unlock() { m_locked = false; }
Arm64Gen::ARM64Reg GetReg() const { return m_reg; }
bool operator==(const Arm64Gen::ARM64Reg& reg) { return reg == m_reg; }
private:
Arm64Gen::ARM64Reg m_reg;
bool m_locked;
@ -231,6 +233,7 @@ public:
void StoreRegisters(BitSet32 regs) { FlushRegisters(regs, false); }
void StoreCRRegisters(BitSet32 regs) { FlushCRRegisters(regs, false); }
protected:
// Get the order of the host registers
void GetAllocationOrder() override;
@ -284,6 +287,7 @@ public:
void FixSinglePrecision(size_t preg);
void StoreRegisters(BitSet32 regs) { FlushRegisters(regs, false); }
protected:
// Get the order of the host registers
void GetAllocationOrder() override;

2
Source/Core/Core/PowerPC/JitArm64/JitAsm.cpp
View File

@ -2,7 +2,6 @@
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "Core/PowerPC/JitArm64/Jit.h"
#include "Common/Arm64Emitter.h"
#include "Common/CommonTypes.h"
#include "Common/JitRegister.h"
@ -10,6 +9,7 @@
#include "Core/CoreTiming.h"
#include "Core/HW/CPU.h"
#include "Core/HW/Memmap.h"
#include "Core/PowerPC/JitArm64/Jit.h"
#include "Core/PowerPC/JitCommon/JitAsmCommon.h"
#include "Core/PowerPC/JitCommon/JitCache.h"
#include "Core/PowerPC/PowerPC.h"

6
Source/Core/Core/PowerPC/PPCAnalyst.cpp
View File

@ -433,7 +433,8 @@ void FindFunctions(u32 startAddr, u32 endAddr, PPCSymbolDB* func_db)
else
unniceSize /= numUnNice;
INFO_LOG(SYMBOLS, "Functions analyzed. %i leafs, %i nice, %i unnice."
INFO_LOG(SYMBOLS,
"Functions analyzed. %i leafs, %i nice, %i unnice."
"%i timer, %i rfi. %i are branchless leafs.",
numLeafs, numNice, numUnNice, numTimer, numRFI, numStraightLeaf);
INFO_LOG(SYMBOLS, "Average size: %i (leaf), %i (nice), %i(unnice)", leafSize, niceSize,
@ -798,7 +799,8 @@ u32 PPCAnalyzer::Analyze(u32 address, CodeBlock* block, CodeBuffer* buffer, u32
// bcx with conditional branch
conditional_continue = true;
}
else if (inst.OPCD == 19 && inst.SUBOP10 == 16 && ((inst.BO & BO_DONT_DECREMENT_FLAG) == 0 ||
else if (inst.OPCD == 19 && inst.SUBOP10 == 16 &&
((inst.BO & BO_DONT_DECREMENT_FLAG) == 0 ||
(inst.BO & BO_DONT_CHECK_CONDITION) == 0))
{
// bclrx with conditional branch

20
Source/Core/Core/PowerPC/PPCTables.cpp
View File

@ -34,10 +34,22 @@ size_t m_numInstructions;
namespace PowerPC
{
const std::array<u64, 16> m_crTable = {{
PPCCRToInternal(0x0), PPCCRToInternal(0x1), PPCCRToInternal(0x2), PPCCRToInternal(0x3),
PPCCRToInternal(0x4), PPCCRToInternal(0x5), PPCCRToInternal(0x6), PPCCRToInternal(0x7),
PPCCRToInternal(0x8), PPCCRToInternal(0x9), PPCCRToInternal(0xA), PPCCRToInternal(0xB),
PPCCRToInternal(0xC), PPCCRToInternal(0xD), PPCCRToInternal(0xE), PPCCRToInternal(0xF),
PPCCRToInternal(0x0),
PPCCRToInternal(0x1),
PPCCRToInternal(0x2),
PPCCRToInternal(0x3),
PPCCRToInternal(0x4),
PPCCRToInternal(0x5),
PPCCRToInternal(0x6),
PPCCRToInternal(0x7),
PPCCRToInternal(0x8),
PPCCRToInternal(0x9),
PPCCRToInternal(0xA),
PPCCRToInternal(0xB),
PPCCRToInternal(0xC),
PPCCRToInternal(0xD),
PPCCRToInternal(0xE),
PPCCRToInternal(0xF),
}};
} // namespace PowerPC

3
Source/Core/Core/PowerPC/PowerPC.cpp
View File

@ -184,7 +184,8 @@ static void InitializeCPUCore(int cpu_core)
const std::vector<CPUCore>& AvailableCPUCores()
{
static const std::vector<CPUCore> cpu_cores = {
CORE_INTERPRETER, CORE_CACHEDINTERPRETER,
CORE_INTERPRETER,
CORE_CACHEDINTERPRETER,
#ifdef _M_X86_64
CORE_JIT64,
#elif defined(_M_ARM_64)

4
Source/Core/Core/WiiUtils.cpp
View File

@ -575,8 +575,8 @@ class DiscSystemUpdater final : public SystemUpdater
{
public:
DiscSystemUpdater(UpdateCallback update_callback, const std::string& image_path)
: m_update_callback{std::move(update_callback)},
m_volume{DiscIO::CreateVolumeFromFilename(image_path)}
: m_update_callback{std::move(update_callback)}, m_volume{DiscIO::CreateVolumeFromFilename(
image_path)}
{
}
UpdateResult DoDiscUpdate();

7
Source/Core/DiscIO/DirectoryBlob.cpp
View File

@ -731,11 +731,12 @@ void DirectoryBlobPartition::WriteDirectory(const File::FSTEntry& parent_entry,
std::vector<File::FSTEntry> sorted_entries = parent_entry.children;
// Sort for determinism
std::sort(sorted_entries.begin(), sorted_entries.end(), [](const File::FSTEntry& one,
const File::FSTEntry& two) {
std::sort(sorted_entries.begin(), sorted_entries.end(),
[](const File::FSTEntry& one, const File::FSTEntry& two) {
const std::string one_upper = ASCIIToUppercase(one.virtualName);
const std::string two_upper = ASCIIToUppercase(two.virtualName);
return one_upper == two_upper ? one.virtualName < two.virtualName : one_upper < two_upper;
return one_upper == two_upper ? one.virtualName < two.virtualName :
one_upper < two_upper;
});
for (const File::FSTEntry& entry : sorted_entries)

2
Source/Core/DiscIO/DirectoryBlob.h
View File

@ -52,6 +52,7 @@ public:
bool operator>(const DiscContent& other) const { return other < *this; }
bool operator<=(const DiscContent& other) const { return !(*this < other); }
bool operator>=(const DiscContent& other) const { return !(*this > other); }
private:
u64 m_offset;
u64 m_size = 0;
@ -94,6 +95,7 @@ public:
const std::string& GetRootDirectory() const { return m_root_directory; }
const std::vector<u8>& GetHeader() const { return m_disc_header; }
const DiscContentContainer& GetContents() const { return m_contents; }
private:
void SetDiscHeaderAndDiscType(std::optional<bool> is_wii);
void SetBI2();

3
Source/Core/DiscIO/DiscExtractor.cpp
View File

@ -50,7 +50,8 @@ u64 ReadFile(const Volume& volume, const Partition& partition, const FileInfo* f
const u64 read_length = std::min(max_buffer_size, file_info->GetSize() - offset_in_file);
DEBUG_LOG(DISCIO, "Reading %" PRIx64 " bytes at %" PRIx64 " from file %s. Offset: %" PRIx64
DEBUG_LOG(DISCIO,
"Reading %" PRIx64 " bytes at %" PRIx64 " from file %s. Offset: %" PRIx64
" Size: %" PRIx32,
read_length, offset_in_file, file_info->GetPath().c_str(), file_info->GetOffset(),
file_info->GetSize());

1
Source/Core/DiscIO/DriveBlob.h
View File

@ -26,6 +26,7 @@ public:
BlobType GetBlobType() const override { return BlobType::DRIVE; }
u64 GetDataSize() const override { return m_size; }
u64 GetRawSize() const override { return m_size; }
private:
DriveReader(const std::string& drive);
bool GetBlock(u64 block_num, u8* out_ptr) override;

1
Source/Core/DiscIO/Filesystem.h
View File

@ -65,6 +65,7 @@ public:
// pointers, but will not invalidate copies of the iterator or file info object.
const FileInfo& operator*() const { return *m_file_info.get(); }
const FileInfo* operator->() const { return m_file_info.get(); }
private:
std::unique_ptr<FileInfo> m_file_info;
};

1
Source/Core/DiscIO/VolumeWii.h
View File

@ -67,6 +67,7 @@ public:
protected:
u32 GetOffsetShift() const override { return 2; }
private:
struct PartitionDetails
{

4
Source/Core/DolphinQt2/Config/Graphics/GeneralWidget.cpp
View File

@ -109,7 +109,9 @@ void GeneralWidget::CreateWidgets()
auto* shader_compilation_layout = new QGridLayout();
const std::array<const char*, 4> modes = {{
"Synchronous", "Synchronous (Ubershaders)", "Asynchronous (Ubershaders)",
"Synchronous",
"Synchronous (Ubershaders)",
"Asynchronous (Ubershaders)",
"Asynchronous (Skip Drawing)",
}};
for (size_t i = 0; i < modes.size(); i++)

3
Source/Core/DolphinQt2/Config/Mapping/IOWindow.cpp
View File

@ -198,7 +198,8 @@ void IOWindow::OnDetectButtonPressed()
releaseMouse();
releaseKeyboard();
removeEventFilter(BlockUserInputFilter::Instance());
}).detach();
})
.detach();
}
void IOWindow::OnRangeChanged(int value)

3
Source/Core/DolphinQt2/Debugger/BreakpointWidget.cpp
View File

@ -155,7 +155,8 @@ void BreakpointWidget::Update()
if (mbp.is_ranged)
{
m_table->setItem(i, 3, create_item(QStringLiteral("%1 - %2")
m_table->setItem(i, 3,
create_item(QStringLiteral("%1 - %2")
.arg(mbp.start_address, 8, 16, QLatin1Char('0'))
.arg(mbp.end_address, 8, 16, QLatin1Char('0'))));
}

7
Source/Core/DolphinQt2/Debugger/RegisterColumn.cpp
View File

@ -98,9 +98,10 @@ void RegisterColumn::Update()
switch (m_display)
{
case RegisterDisplay::Hex:
text = QStringLiteral("%1").arg(
m_value, (m_type == RegisterType::ibat || m_type == RegisterType::dbat ||
m_type == RegisterType::fpr || m_type == RegisterType::tb ?
text = QStringLiteral("%1").arg(m_value,
(m_type == RegisterType::ibat || m_type == RegisterType::dbat ||
m_type == RegisterType::fpr ||
m_type == RegisterType::tb ?
sizeof(u64) :
sizeof(u32)) *
2,

Some files were not shown because too many files have changed in this diff Show More