int64_t GetImageSize(int width, int height) {
    // Размер в видеопамяти = ширина * высота * 4 (для RGBA, 4 байта на пиксель)
    return static_cast<int64_t>(width) * height * 4;
}

struct MEMORYDATA {
    int64_t i64MemoryTotal = 0;
    int64_t i64MemoryFree  = 0;
    int64_t i64MemoryUsed  = 0;
    //
    MEMORYSTATUS MemoryPtr;
    void getData(int64_t* mem,int64_t idx_data){
        memset(&MemoryPtr, 0, sizeof(MemoryPtr));
        ::GlobalMemoryStatus(&MemoryPtr);
        switch (idx_data) {
        case 0:
            *mem = (MemoryPtr.dwTotalPhys - MemoryPtr.dwAvailPhys) / 1024 / 1024 / 1024; // кол использованная память
            break;
        case 1:
            *mem = MemoryPtr.dwTotalPhys / 1024 / 1024 / 1024; // кол всего памяти
            break;
        case 2:
            *mem = MemoryPtr.dwAvailPhys / 1024 / 1024 / 1024; // кол свободная памяти
            break;
        }
    }
    std::string MemoryInfo() {
        getData(&i64MemoryTotal, 1);
        getData(&i64MemoryFree , 2);
        getData(&i64MemoryUsed , 0);
        std::string mem_str = 
            "Total:   " + std::to_string(i64MemoryTotal) + " GB"
            "\nUsed :   " + std::to_string(i64MemoryUsed)  + " GB"
            "\nFree :   " + std::to_string(i64MemoryFree)  + " GB";
        return mem_str;
    }
};
auto ptrMemory = std::make_unique<MEMORYDATA>();

struct EXCEPTIONS {
    bool ErrorTextures = false;
    std::string sLastError;
    void* pLastStack = nullptr;

    void log(std::string t) {
        std::cout << "Exception Error: " << t << std::endl;
    }

    void Write(const std::string& t, void* pErrorSegment) {
        ErrorTextures = true;
        sLastError += t + "\n";
        pLastStack = pErrorSegment;
        log("EXCEPTIONS::Write: " + t + ", StackPtr: " + std::to_string(reinterpret_cast<uintptr_t>(pErrorSegment)));
    }

    static std::string GetStackTrace(PEXCEPTION_POINTERS pExInfo) {
        std::stringstream ss;
        HANDLE process = GetCurrentProcess();
        STACKFRAME64 frame = { 0 };
        frame.AddrPC.Offset = pExInfo->ContextRecord->Rip;
        frame.AddrPC.Mode = AddrModeFlat;
        frame.AddrFrame.Offset = pExInfo->ContextRecord->Rbp;
        frame.AddrFrame.Mode = AddrModeFlat;
        frame.AddrStack.Offset = pExInfo->ContextRecord->Rsp;
        frame.AddrStack.Mode = AddrModeFlat;

        while (StackWalk64(IMAGE_FILE_MACHINE_AMD64, process, GetCurrentThread(), &frame, pExInfo->ContextRecord, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL)) {
            DWORD64 address = frame.AddrPC.Offset;
            char symbolBuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME] = { 0 };
            SYMBOL_INFO* symbol = (SYMBOL_INFO*)symbolBuffer;
            symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
            symbol->MaxNameLen = MAX_SYM_NAME;
            DWORD64 displacement = 0;
            if (SymFromAddr(process, address, &displacement, symbol)) {
                ss << "Function: " << symbol->Name << " + 0x" << std::hex << displacement << "\n";
            }
            else {
                ss << "Unknown function at 0x" << std::hex << address << "\n";
            }
        }
        return ss.str();
    }

    static LONG WINAPI CrashHandler(PEXCEPTION_POINTERS pExInfo) {
        std::string errorMsg;
        std::string errorCode;
        switch (pExInfo->ExceptionRecord->ExceptionCode) {
        case EXCEPTION_ILLEGAL_INSTRUCTION: // 0xC000001D
            errorCode = "Illegal Instruction (0xC000001D)";
            break;
        case EXCEPTION_ACCESS_VIOLATION: // 0xC0000005
            errorCode = "Access Violation (0xC0000005)";
            break;
        case EXCEPTION_STACK_OVERFLOW: // 0xC00000FD
            errorCode = "Stack Overflow (0xC00000FD)";
            break;
        default:
            errorCode = "Unknown Exception (0x" + std::to_string(pExInfo->ExceptionRecord->ExceptionCode) + ")";
            break;
        }
        std::string stackTrace = GetStackTrace(pExInfo);
        std::ofstream logFile("crash_log.txt", std::ios::app);
        logFile << "PahomEngine crashed!" << std::endl;
        logFile << "========================" << std::endl;
        logFile << "Crash at: " << __DATE__ << " " << __TIME__ << "\n";
        logFile << "Exception: " << errorCode << "\n";
        logFile << "Stack Trace:\n" << stackTrace << "\n";
        logFile << "------------------------\n";
        logFile.close();

        std::wstring msg = L"Fatal Error: "  + std::wstring(errorCode.begin(), errorCode.end()) +
            L"\nSee crash_log.txt for details.\nPlease send crash_log.txt to @hcppstudio.";
        MessageBox(NULL, msg.c_str(), L"PahomEngine::Exception", MB_OK | MB_ICONERROR);

        return EXCEPTION_EXECUTE_HANDLER;
    }

    void BugReport() {
        SetUnhandledExceptionFilter(CrashHandler);
    }

    void Cleanup() {
        SymCleanup(GetCurrentProcess());
    }
};
 std::unique_ptr<EXCEPTIONS> Exceptions = std::make_unique<EXCEPTIONS>();

Обработка нажатии с клавиатуры

Функция getPressedKey
принимает
- int8_t key - Клавиша например 'C'
- bool isTurned - принимает true или false
——————————————————————————-
Логика работы:

Сначала мы проверяем наш флаг isTurned и если он true то будет работать в режиме кнопки, а если false то в режиме выключателя

//вот код. Если не будет функции то значит нет файла pdb   

//Функцию BugReport вызывать в начале int main и потом в конце программы Cleanup();


//Код
#include <dbghelp.h>
#pragma comment(lib, "dbghelp.lib")
struct CPPException {
    bool ErrorTextures = false;
    std::string sLastError;
    void* pLastStack = nullptr;

    void log(std::string t) {
        std::cout << "Exception Error: " << t << std::endl;
    }

    void Write(const std::string& t, void* pErrorSegment) {
        ErrorTextures = true;
        sLastError += t + "\n";
        pLastStack = pErrorSegment;
        log("EXCEPTIONS::Write: " + t + ", StackPtr: " + std::to_string(reinterpret_cast<uintptr_t>(pErrorSegment)));
    }

    static std::wstring GetStackTrace(PEXCEPTION_POINTERS pExInfo) {
        std::wstringstream ss;
        HANDLE process = GetCurrentProcess();
        HANDLE thread = GetCurrentThread();

        // Инициализация символов
        SymInitialize(process, NULL, TRUE); // Загружаем символы для всех модулей
        SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME); // Включаем линии и имена без декораций

        STACKFRAME64 frame = { 0 };
        frame.AddrPC.Offset = pExInfo->ContextRecord->Rip;
        frame.AddrPC.Mode = AddrModeFlat;
        frame.AddrFrame.Offset = pExInfo->ContextRecord->Rbp;
        frame.AddrFrame.Mode = AddrModeFlat;
        frame.AddrStack.Offset = pExInfo->ContextRecord->Rsp;
        frame.AddrStack.Mode = AddrModeFlat;

        while (StackWalk64(
            IMAGE_FILE_MACHINE_AMD64,
            process,
            thread,
            &frame,
            pExInfo->ContextRecord,
            NULL,
            SymFunctionTableAccess64,
            SymGetModuleBase64,
            NULL)) {
            DWORD64 address = frame.AddrPC.Offset;
            if (address == 0) break; // Конец стека

            // Форматирование адреса
            ss << L"[0x" << std::hex << std::setw(16) << std::setfill(L'0') << address << L"] ";

            // Получение имени функции
            char symbolBuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME] = { 0 };
            SYMBOL_INFO* symbol = (SYMBOL_INFO*)symbolBuffer;
            symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
            symbol->MaxNameLen = MAX_SYM_NAME;
            DWORD64 displacement = 0;

            if (SymFromAddr(process, address, &displacement, symbol)) {
                // Конвертация char* в wstring
                std::string funcName(symbol->Name);
                std::wstring wFuncName(funcName.begin(), funcName.end()); // Простое преобразование (или используйте MultiByteToWideChar для точности)
                ss << L"Function: " << wFuncName << L" + 0x" << std::hex << displacement;
            }
            else {
                ss << L"Unknown function";
            }

            // Получение имени файла и номера строки
            IMAGEHLP_LINE64 line = { 0 };
            line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
            DWORD lineDisplacement = 0;
            if (SymGetLineFromAddr64(process, address, &lineDisplacement, &line)) {
                // Конвертация char* в wstring
                std::string fileName(line.FileName);
                std::wstring wFileName(fileName.begin(), fileName.end());
                ss << L" at " << wFileName << L":" << std::dec << line.LineNumber;
            }

            // Получение имени модуля
            IMAGEHLP_MODULE64 module = { 0 };
            module.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
            if (SymGetModuleInfo64(process, address, &module)) {
                // ModuleName — это TCHAR*, в Unicode-проекте это wchar_t*
                ss << L" in module " << module.ModuleName;
            }

            ss << L"\n";
        }

        // Очистка символов
        SymCleanup(process);
        return ss.str();
    }

    static LONG WINAPI CrashHandler(PEXCEPTION_POINTERS pExInfo) {
        std::wstring errorMsg;
        std::wstring errorCode;
        std::string errorMsgA;
        std::string errorCodeA;
        switch (pExInfo->ExceptionRecord->ExceptionCode) {
        case EXCEPTION_ILLEGAL_INSTRUCTION: // 0xC000001D
            errorCode = L"Неподдерживамая инструкция (0xC000001D)";
            errorCodeA = "Ошибка доступа к памяти (0xC0000005)";
            break;
        case EXCEPTION_ACCESS_VIOLATION: // 0xC0000005
            errorCode = L"Ошибка доступа к памяти (0xC0000005)";
            errorCodeA = "Ошибка доступа к памяти (0xC0000005)";
            break;
        case EXCEPTION_STACK_OVERFLOW: // 0xC00000FD
            errorCode = L"Переполнение буфера (0xC00000FD)";
            errorCodeA = "Переполнение буфера (0xC00000FD)";
            break;
        default:
            errorCode = L"Неизвестное исключение (0x" + std::wstring(std::to_string(pExInfo->ExceptionRecord->ExceptionCode).begin(), std::to_string(pExInfo->ExceptionRecord->ExceptionCode).end()) + L")";
            errorCodeA = "Неизвестное исключение (0x" + std::to_string(pExInfo->ExceptionRecord->ExceptionCode) + ")";
            break;
        }
        std::wstring stackTraceW = GetStackTrace(pExInfo);
        std::ofstream logFile("crash_log.txt", std::ios::app);
        logFile << "PahomEngine crashed!" << std::endl;
        logFile << "========================" << std::endl;
        logFile << "Crash at:     " << __DATE__ << " " << __TIME__ << "\n";
        logFile << "Exception:    " << errorCodeA << "\n";
        logFile << "Stack Trace:\n" << std::string(stackTraceW.begin(), stackTraceW.end()).c_str() << "\n";
        logFile << "------------------------\n";
        logFile.close();

        std::wstring msg = L"ImPlayer вылетел\n=======================\nКритическая ошибка: " + errorCode + L"\n------------------- STACK TRACE ---------------\n"+ std::wstring(stackTraceW.begin(), stackTraceW.end()) +
            L"\nSee crash_log.txt for details.\nPlease send crash_log.txt to @hcppstudio.";
        MessageBox(NULL, msg.c_str(), L"ImPlayer::Exception", MB_OK | MB_ICONERROR);

        return EXCEPTION_EXECUTE_HANDLER;
    }

    void BugReport() {
        // Инициализация символов (один раз при старте)
        SymInitialize(GetCurrentProcess(), NULL, TRUE);
        SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME);
        SetUnhandledExceptionFilter(CrashHandler);
    }

    void Cleanup() {
        SymCleanup(GetCurrentProcess());
    }
};
std::unique_ptr<CPPException> pCppException = std::make_unique<CPPException>();
//Проверка указателя то что он не nullptr чтобы не было ошибки доступа к неинициализированной памяти

if(pCppException){
std::cout «" pCppException is true" « std::endl;
}