| | #include <windows.h>
|
| | #pragma comment(lib, "winmm.lib")
|
| | #define _USE_MATH_DEFINES 1
|
| | #include <cmath>
|
| | #define M_PI 3.14159265358979323846264338327950288
|
| | #pragma comment(lib, "msimg32.lib")
|
| |
|
| | #define Wave(i, xSize, ySize) (sin(i / ((float)xSize) * M_PI) * (ySize))
|
| | #define SquareWave(t, freq, sampleCount) (int)(((BYTE)(2.f * (FLOAT)(freq) * ((t) / (FLOAT)(sampleCount))) % 2) == 0 ? 1.f : -1.f)
|
| | #define TriangleWave(t, freq, sampleCount) (int)(4.f * ( FLOAT )fabs(((FLOAT)(t) / ((FLOAT)(sampleCount) / (FLOAT)(freq))) - floor(((FLOAT)(t) / ((FLOAT)(sampleCount) / (FLOAT)(freq)))) - .5f) - 1.f)
|
| | int sch(int v) {
|
| | return (int)(tan(cos(ceil(v >> 10)))) ^ (((int)((99999 * sin(v * M_PI / 180.0) + 99999) / 15) >> 6));
|
| | }
|
| |
|
| | static unsigned long xx = 123456789, yy = 362436069, zz = 521288629;
|
| | DWORD xs;
|
| | VOID SeedXorshift32(DWORD dwSeed) {
|
| | xs = dwSeed;
|
| | }
|
| | DWORD xorshift32() {
|
| | xs ^= xs << 13;
|
| | xs ^= xs >> 17;
|
| | xs ^= xs << 5;
|
| | return xs;
|
| | }VOID WINAPI train(HDC hdc, int w, int h, int xPower, int yPower, DWORD dwRop) {
|
| | if (xPower >= w) xPower = w - 1; if (yPower >= h) yPower = h - 1;
|
| | HBITMAP screenshot = CreateCompatibleBitmap(hdc, w, h);
|
| | HDC hdc2 = CreateCompatibleDC(hdc); rand() % 6;
|
| | SelectObject(hdc2, screenshot);
|
| | BitBlt(hdc2, 0, 0, w, h, hdc, 0, 0, SRCCOPY);
|
| | BitBlt(hdc, xPower > 0 ? xPower : 0, yPower > 0 ? yPower : 0, w - abs(xPower), h - abs(yPower), hdc, xPower < 0 ? -xPower : 0, yPower < 0 ? -yPower : 0, dwRop);
|
| | BitBlt(hdc, xPower < 0 ? w + xPower : 0, 0, abs(xPower), h, hdc2, xPower > 0 ? w - xPower : 0, 0, dwRop);
|
| | BitBlt(hdc, 0, yPower < 0 ? h + yPower : 0, w, abs(yPower), hdc2, 0, yPower > 0 ? h - yPower : 0, dwRop);
|
| | DeleteDC(hdc2); DeleteObject(screenshot);
|
| | }
|
| | HDC hdcMemory, origHDC; HBITMAP hScreenshot;
|
| | VOID WINAPI pixelatehdc(HDC hdc, int w, int h, int power, int stretchmode, DWORD dwRop)
|
| | {
|
| | origHDC = hdc; hdcMemory = CreateCompatibleDC(origHDC);
|
| | hScreenshot = CreateCompatibleBitmap(origHDC, w / power, h / power);
|
| | SelectObject(hdcMemory, hScreenshot);
|
| | SetStretchBltMode(hdcMemory, stretchmode);
|
| | StretchBlt(hdcMemory, 0, 0, w / power, h / power, origHDC, 0, 0, w, h, SRCCOPY);
|
| | StretchBlt(origHDC, 0, 0, w, h, hdcMemory, 0, 0, w / power, h / power, dwRop);
|
| | }
|
| |
|
| | POINT pt[3]; RECT rekt;
|
| | VOID WINAPI rotatehdc(HWND hWnd, HDC hDC, int w, int h, int power) {
|
| | GetWindowRect(hWnd, &rekt);
|
| | pt[0].x = rekt.left + power; pt[0].y = rekt.top - power;
|
| | pt[1].x = rekt.right + power; pt[1].y = rekt.top + power;
|
| | pt[2].x = rekt.left - power; pt[2].y = rekt.bottom - power;
|
| | PlgBlt(hDC, pt, hDC, rekt.left, rekt.top, rekt.right - rekt.left, rekt.bottom - rekt.top, 0, 0, 0);
|
| | }
|
| |
|
| | COLORREF RndRGB() {
|
| | int clr = xorshift32() % 5;
|
| | if (clr == 0) return RGB(255, 0, 0); if (clr == 1) return RGB(0, 255, 0); if (clr == 2) return RGB(0, 0, 255); if (clr == 3) return RGB(255, 0, 255); if (clr == 4) return RGB(255, 255, 0);
|
| | }
|
| | VOID WINAPI soundboom()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 24] = {};
|
| |
|
| | for (DWORD t = 1; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(SquareWave(t, t, t * 999999));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI soundmash()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 24] = {};
|
| |
|
| | for (DWORD t = 1; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(SquareWave(t, t, t & 999999));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound1()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 24] = {};
|
| |
|
| | for (DWORD t = 1; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(t & t >> t + t << 13 - t << SquareWave(t, t * sin(t), 320000) - t / 2 >> t | t << 100 & t);
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound2()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 32] = {};
|
| |
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>((t & t >> t + t << 13 - t << SquareWave(t, t * sin(t), 320000) - t / 2 >> t | t << 100 & t) | sch(t));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound3()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 32] = {};
|
| |
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(((t & t >> t + t << 13 - t << SquareWave(t, t * sin(t), 320000)) - t / 2 >> t | t << 100) & t * (int)log10(t * M_PI / 3373));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound4()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 28] = {};
|
| |
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>((t + t & t % 257) | t - 0x00ac000e ^ t ^ t & 0x34589ac | t ^ t - (t ^ t >> 3 & 0x00e64cd));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound5()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 44000, 44000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[44000 * 22] = {};
|
| |
|
| | for (DWORD t = 1; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(t ^ t >> 9);
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound6()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 44000, 44000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 29] = {};
|
| |
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(t * tanf(t >> 10));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound7()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 44000, 44000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 31] = {};
|
| |
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(t * tanf(t >> 8));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | int rnm = 0;
|
| | int mp(int c, int m, int rn, int rm) {
|
| | if (c > m && c < rm) return rn; else return 0;
|
| | }
|
| | VOID WINAPI sound8()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 30] = {};
|
| |
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(((t * t >> 4) / 3) | (t * t >> 3 * 5) | mp(t, 32000 * 11, sch(t), 32000 * 23));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound9()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 30] = { };
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t) {
|
| | buffer[t] = static_cast<char>(t);
|
| | }
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI sound10()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 32000, 32000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 30] = {};
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t) {
|
| | buffer[t] = static_cast<char>(SquareWave(t, t, (t >> 8 & t >> 13) * 999999));
|
| | }
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| | VOID WINAPI soundfinal()
|
| | {
|
| | HWAVEOUT hWaveOut = 0;
|
| | WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, 44000, 44000, 1, 8, 0 };
|
| | waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
|
| | char buffer[32000 * 30] = {};
|
| |
|
| | for (DWORD t = 0; t < sizeof(buffer); ++t)
|
| | buffer[t] = static_cast<char>(((int)(tan(t >> 8) * t) & 100));
|
| |
|
| | WAVEHDR header = { buffer, sizeof(buffer), 0, 0, 0, 0, 0, 0 };
|
| | waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
|
| | waveOutClose(hWaveOut);
|
| | }
|
| |
|
| | DWORD WINAPI glchart(LPVOID lpParam) {
|
| | int ticks = GetTickCount(), w = GetSystemMetrics(0), h = GetSystemMetrics(1);
|
| | RGBQUAD* data = (RGBQUAD*)VirtualAlloc(0, (w * h + w) * sizeof(RGBQUAD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
|
| | SeedXorshift32(__rdtsc());
|
| | for (int i = 1;; i++, i %= 21) {
|
| | if (!i) for (int c = 0; c < 100; c++) InvalidateRect(0, 0, 0);
|
| | HDC hdc = GetDC(0), hdcMem = CreateCompatibleDC(hdc); HBITMAP hbm = CreateBitmap(w, h, 1, 32, data);
|
| | SelectObject(hdcMem, hbm); BitBlt(hdcMem, 0, 0, w, h, hdc, 0, 0, SRCCOPY);
|
| | GetBitmapBits(hbm, w * h * 4, data);
|
| | int v = 0; BYTE bt = 0;
|
| | if ((GetTickCount() - ticks) > 60000) bt = 2 + xorshift32() & 0xff;
|
| | for (int i = 1; w * h > i; i++) {
|
| | if (i % h == 0 && xorshift32() % 100 == 0) v = 3 + xorshift32() % 50;
|
| | ((BYTE*)(data + i))[v % 3] += ((BYTE*)(data + bt))[bt] ^ i;
|
| | }
|
| | SetBitmapBits(hbm, w * h * 4, data); BitBlt(hdc, 0, 0, w, h, hdcMem, 0, 0, SRCCOPY);
|
| | DeleteObject(hbm); DeleteObject(hdcMem);
|
| | DeleteObject(hdc);
|
| | Sleep(90);
|
| | }
|
| | }
|
| | DWORD WINAPI shk(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1);
|
| | while (1) {
|
| | SelectObject(desk, CreateSolidBrush(RGB(245, 245, 66)));
|
| | for (int angle = 0; angle < 361; angle++) {
|
| | int x = 100 * cos(angle * M_PI / 180.F), y = 100 * sin(angle * M_PI / 180.F);
|
| | train(desk, sw, sh, x, y, SRCCOPY ^ 0x2021e20);
|
| | Sleep(0.5);
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI pl2(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1);
|
| | SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | SelectObject(desk, CreateSolidBrush(RndRGB()));
|
| | BitBlt(desk, 0, 0, sw, sh, desk, 0, 0, rand() % 2 ? PATINVERT : NOTSRCCOPY ^ PATCOPY);
|
| | Sleep(349);
|
| | }
|
| | }
|
| | DWORD WINAPI pxl(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1);
|
| | SeedXorshift32(__rdtsc());
|
| | while (true) {
|
| | pixelatehdc(desk, sw, sh, 8.4, STRETCH_DELETESCANS, SRCCOPY);
|
| | DeleteDC(origHDC); DeleteDC(hdcMemory); DeleteObject(hScreenshot);
|
| | Sleep(605);
|
| | }
|
| | }
|
| | DWORD WINAPI rtscr(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1);
|
| | SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | int v = xorshift32() % 3;
|
| | if (v == 0) { StretchBlt(desk, 0, 0, sw, sh, desk, sw, 0, -sw, sh, SRCCOPY); }
|
| | if (v == 1) { StretchBlt(desk, 0, 0, sw, sh, desk, 0, sh, sw, -sh, SRCCOPY); }
|
| | if (v == 2) { StretchBlt(desk, 0, 0, sw, sh, desk, sw, sh, -sw, -sh, SRCCOPY); }
|
| | Sleep(100);
|
| | }
|
| | }
|
| | DWORD WINAPI hrwvs(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), xSize = sh / 11, ySize = 8, power = 43, dw = SRCCOPY, delay = 6;
|
| | SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | HDC hdcMem = CreateCompatibleDC(desk); HBITMAP screenshot = CreateCompatibleBitmap(desk, sw, sh);
|
| | SelectObject(hdcMem, screenshot); BitBlt(hdcMem, 0, 0, sw, sh, desk, 0, 0, SRCCOPY);
|
| | for (int i = 0; i < power; i++) {
|
| | for (int i = 0; i < sh + 5; i++) {
|
| | int wave = sin(i / ((float)xSize) * M_PI) * (ySize); BitBlt(hdcMem, 0, i, sw, 1, desk, wave, i, dw);
|
| | } BitBlt(desk, 0, 0, sw, sh, hdcMem, 0, 0, SRCCOPY); Sleep(delay);
|
| | }
|
| | for (int i = 0; i < power; i++) {
|
| | for (int i = 0; i < sh + 5; i++) {
|
| | int wave = sin(i / ((float)xSize) * M_PI) * (ySize); BitBlt(hdcMem, 0, i, sw, 1, desk, -wave, i, dw);
|
| | }BitBlt(desk, 0, 0, sw, sh, hdcMem, 0, 0, SRCCOPY); Sleep(delay);
|
| | }
|
| | for (int i = 0; i < power; i++) {
|
| | for (int i = 0; i < sh + 5; i++) {
|
| | int wave = sin(i / ((float)xSize) * M_PI) * (ySize); BitBlt(hdcMem, 0, i, sw, 1, desk, -wave, i, dw);
|
| | }BitBlt(desk, 0, 0, sw, sh, hdcMem, 0, 0, SRCCOPY); Sleep(delay);
|
| | }
|
| | for (int i = 0; i < power; i++) {
|
| | for (int i = 0; i < sh + 5; i++) {
|
| | int wave = sin(i / ((float)xSize) * M_PI) * (ySize); BitBlt(hdcMem, 0, i, sw, 1, desk, wave, i, dw);
|
| | }BitBlt(desk, 0, 0, sw, sh, hdcMem, 0, 0, SRCCOPY); Sleep(delay);
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI shd(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1);
|
| | SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | for (int r = 18; r < 256; r++) {
|
| | SelectObject(desk, CreateSolidBrush(RGB(r, 0, 0)));
|
| | BitBlt(desk, 0, 0, sw, sh, desk, xorshift32() % 3 - 1, xorshift32() % 3 - 1, SRCCOPY | 0x00ac000e); Sleep(1);
|
| | }
|
| | for (int c = 0; c < 11; c++) InvalidateRect(0, 0, 0);
|
| |
|
| | for (int g = 18; g < 256; g++) {
|
| | SelectObject(desk, CreateSolidBrush(RGB(0, g, 0)));
|
| | BitBlt(desk, 0, 0, sw, sh, desk, xorshift32() % 3 - 1, xorshift32() % 3 - 1, SRCCOPY | 0x00ac000e); Sleep(1);
|
| | }
|
| | for (int c = 0; c < 11; c++) InvalidateRect(0, 0, 0);
|
| |
|
| | for (int b = 18; b < 256; b++) {
|
| | SelectObject(desk, CreateSolidBrush(RGB(0, 0, b)));
|
| | BitBlt(desk, 0, 0, sw, sh, desk, xorshift32() % 3 - 1, xorshift32() % 3 - 1, SRCCOPY | 0x00ac000e); Sleep(1);
|
| | }
|
| | for (int c = 0; c < 11; c++) InvalidateRect(0, 0, 0);
|
| | }
|
| | }
|
| | DWORD WINAPI invcc(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), size = 100, radius = 227;
|
| | SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | int origX1 = xorshift32() % sw, origY1 = xorshift32() % sh;
|
| | int origX2 = -20 + xorshift32() % (sw + 20), origY2 = -20 + xorshift32() % (sh + 20);
|
| | int origX3 = -30 + xorshift32() % (sw + 30), origY3 = -30 + xorshift32() % (sh + 30);
|
| | int origX4 = -20 + xorshift32() % (sw + 20), origY4 = -20 + xorshift32() % (sh + 20);
|
| | int origX5 = xorshift32() % sw, origY5 = xorshift32() % sh;
|
| | for (int angle = 0; angle < 1081; angle += 12.1) {
|
| | InvalidateRect(0, 0, 0);
|
| | int x1 = radius * cos(angle * M_PI / 180.0) + origX1, y1 = radius * sin(angle * M_PI / 180.0) + origY1;
|
| | int x2 = radius * cos(angle * M_PI / 180.0) + origX2, y2 = radius * sin(angle * M_PI / 180.0) + origY2;
|
| | int x3 = radius * cos(angle * M_PI / 180.0) + origX3, y3 = radius * sin(angle * M_PI / 180.0) + origY3;
|
| | int x4 = radius * cos(angle * M_PI / 180.0) + origX4, y4 = radius * sin(angle * M_PI / 180.0) + origY4;
|
| | int x5 = radius * cos(angle * M_PI / 180.0) + origX5, y5 = radius * sin(angle * M_PI / 180.0) + origY5;
|
| | if (angle < 720) size += 20; if (angle > 720) size -= 39;
|
| | HRGN circle1 = CreateEllipticRgn(x1, y1, x1 - size, y1 - size);
|
| | HRGN circle2 = CreateEllipticRgn(x2, y2, x2 - size, y2 - size);
|
| | HRGN circle3 = CreateEllipticRgn(x3, y3, x3 - size, y3 - size);
|
| | HRGN circle4 = CreateEllipticRgn(x4, y4, x4 - size, y4 - size);
|
| | HRGN circle5 = CreateEllipticRgn(x5, y5, x5 - size, y5 - size);
|
| | InvertRgn(desk, circle1); InvertRgn(desk, circle2); InvertRgn(desk, circle3); InvertRgn(desk, circle4); InvertRgn(desk, circle5);
|
| | Sleep(26.4);
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI scmv(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), radius = 11.5f;
|
| | double moveangle = 0; SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | desk = GetDC(0);
|
| | double ax = (cos(moveangle) * radius), ay = (sin(moveangle) * radius);
|
| | BitBlt(desk, 0, 0, sw, sh, desk, ax, ay, SRCCOPY);
|
| | moveangle = fmod(moveangle + M_PI / radius, M_PI * radius);
|
| | Sleep(12);
|
| | }
|
| | }
|
| |
|
| | DWORD WINAPI wvs3(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), xSize = 9, ySize = xSize + 2;
|
| | SeedXorshift32(__rdtsc());
|
| | double angle = 0;
|
| | for (int c = 0;; c++, c %= 509) {
|
| | if (!c) InvalidateRect(0, 0, 0);
|
| | int origY = xorshift32() % sh, h = ySize;
|
| | for (int i = origY; i < origY + 80; i += ySize / 2) {
|
| | int p = (cos(angle) * xSize);
|
| | angle = fmod(angle + M_PI / xSize, M_PI * xSize);
|
| | BitBlt(desk, 0, i, sw, h, desk, p, i, SRCCOPY);
|
| | Sleep(0.99999999999);
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI swrl(LPVOID lpParam) {
|
| | HDC desk;
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), xSize = sw / 4, ySize = 8;
|
| | SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | desk = GetDC(0); HDC hdcMem = CreateCompatibleDC(desk);
|
| | HBITMAP screenshot = CreateCompatibleBitmap(desk, sw, sh);
|
| | SelectObject(hdcMem, screenshot);
|
| | BitBlt(hdcMem, 0, 0, sw, sh, desk, 0, 0, SRCCOPY);
|
| | for (int i = 0; i < sw + 10; i++) {
|
| | int wave = sin(i / ((float)xSize) * M_PI) * (ySize);
|
| | BitBlt(hdcMem, i, 0, 1, sh, hdcMem, i, wave, SRCCOPY);
|
| | BitBlt(hdcMem, 0, i, sw, 1, hdcMem, wave, i, SRCCOPY);
|
| | }
|
| | BLENDFUNCTION blend = { AC_SRC_OVER, 0, 111, 0 };
|
| | AlphaBlend(desk, 0, 0, sw, sh, hdcMem, 0, 0, sw, sh, blend);
|
| | DeleteDC(desk); DeleteDC(hdcMem); DeleteObject(screenshot);
|
| | }
|
| | }
|
| | DWORD WINAPI wvs4(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), xSize = 4, ySize = 60;
|
| | SeedXorshift32(__rdtsc()); double angle = 0;
|
| | while (1) {
|
| | int origY = xorshift32() % sh, h = ySize;
|
| | for (int i = origY; i < origY + 80; i += ySize / 2) {
|
| | int p = (cos(angle) * xSize);
|
| | angle = fmod(angle + M_PI / xSize, M_PI * xSize);
|
| | BitBlt(desk, 0, i, sw, h, desk, p, i, SRCCOPY); Sleep(0.99999999999);
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI plgscr(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(0), counter = 0, v = 0;
|
| | POINT pt[3]; RECT rekt;
|
| | SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | if ((xorshift32() % 100 + 1) % 29 == 0) for (int i = 0; i < 40; i++) InvalidateRect(0, 0, 0);
|
| | v = xorshift32() % 2;
|
| | if (v == 0) counter = 61; else counter = -61;
|
| | GetWindowRect(GetDesktopWindow(), &rekt);
|
| | for (int c = 0; c < 4 + xorshift32() % 5; c++) {
|
| | pt[0].x = rekt.left + counter; pt[0].y = rekt.top - counter;
|
| | pt[1].x = rekt.right + counter; pt[1].y = rekt.top + counter;
|
| | pt[2].x = rekt.left - counter; pt[2].y = rekt.bottom - counter;
|
| | PlgBlt(desk, pt, desk, rekt.left, rekt.top, rekt.right - rekt.left, rekt.bottom - rekt.top, 0, 0, 0);
|
| | Sleep(21.6);
|
| | Sleep(19);
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI plgscr2(LPVOID lpParam) {
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(0), counter = -107.8f;
|
| | POINT pt[3]; RECT rekt;
|
| | SeedXorshift32(__rdtsc());
|
| | while (1) {
|
| | GetWindowRect(GetDesktopWindow(), &rekt);
|
| | pt[0].x = rekt.left + counter; pt[0].y = rekt.top - counter;
|
| | pt[1].x = rekt.right + counter; pt[1].y = rekt.top + counter;
|
| | pt[2].x = rekt.left - counter; pt[2].y = rekt.bottom - counter;
|
| | PlgBlt(desk, pt, desk, rekt.left, rekt.top, rekt.right - rekt.left, rekt.bottom - rekt.top, 0, 0, 0);
|
| | Sleep(200);
|
| | }
|
| | }
|
| | DWORD WINAPI cltr(LPVOID lpParam) {
|
| | int w = GetSystemMetrics(0), h = GetSystemMetrics(1);
|
| | RGBQUAD* data = (RGBQUAD*)VirtualAlloc(0, (w * h + w) * sizeof(RGBQUAD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); int r = 2, g = 1, b = 4, power = 22;
|
| | SeedXorshift32(__rdtsc()); HDC hdc, hdcMem; HBITMAP hbm;
|
| | for (int i = 0;; i++, i %= 3) {
|
| | hdc = GetDC(0); hdcMem = CreateCompatibleDC(hdc); hbm = CreateBitmap(w, h, 1, 32, data);
|
| | SelectObject(hdcMem, hbm);
|
| | BitBlt(hdcMem, 0, 0, w, h, hdc, 0, 0, SRCCOPY); GetBitmapBits(hbm, w * h * 4, data);
|
| | for (int i = 0; w * h > i; i++) {
|
| | int v = 1 + xorshift32() % 13;
|
| | ((BYTE*)(data + i))[r] = ((BYTE*)(data + i + v + power))[r] + 5.2;
|
| | ((BYTE*)(data + i))[g] = ((BYTE*)(data + i + v + power))[g] + 5.2;
|
| | ((BYTE*)(data + i))[b] = ((BYTE*)(data + i + v + power))[b] + 5.2;
|
| | }
|
| | SetBitmapBits(hbm, w * h * 4, data); BitBlt(hdc, 0, 0, w, h, hdcMem, 0, 0, SRCCOPY);
|
| | DeleteObject(hbm); DeleteObject(hdcMem);
|
| | DeleteObject(hdc);
|
| | }
|
| | }
|
| | DWORD WINAPI omg(LPVOID lpParam) {
|
| | int w = GetSystemMetrics(0), h = GetSystemMetrics(1);
|
| | RGBQUAD* data = (RGBQUAD*)VirtualAlloc(0, (w * h + w) * sizeof(RGBQUAD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); int rgb = MAXDWORD64, v = 0, radius = 17.4f; double angle = 0;
|
| | SeedXorshift32(__rdtsc()); HDC hdc, hdcMem; HBITMAP hbm;
|
| | for (int i = 0;; i++, i %= 6) {
|
| | if (!i) for (int c = 0; c < 21; c++)InvalidateRect(0, 0, 0);
|
| | hdc = GetDC(0); hdcMem = CreateCompatibleDC(hdc); hbm = CreateBitmap(w, h, 1, 32, data);
|
| | SelectObject(hdcMem, hbm);
|
| | BitBlt(hdcMem, 0, 0, w, h, hdc, 0, 0, SRCCOPY); GetBitmapBits(hbm, w * h * 4, data);
|
| | for (int i = 0; w * h > i; i++) {
|
| | if (i % h == 0 && xorshift32() % 100 == 0) v = 1 + xorshift32() % 6;
|
| | rgb ^= (int)data + i % 255;
|
| | ((BYTE*)(data + i))[v] = rgb;
|
| | }
|
| | float x = cos(angle) * radius, y = sin(angle) * radius;
|
| | SetBitmapBits(hbm, w * h * 4, data); BitBlt(hdc, 0, 0, w, h, hdcMem, x, y, SRCCOPY);
|
| | DeleteObject(hbm); DeleteObject(hdcMem);
|
| | DeleteObject(hdc);
|
| | Sleep(39.7);
|
| | angle = fmod(angle + M_PI / radius, M_PI * radius);
|
| | }
|
| | }
|
| | DWORD WINAPI expdes(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), radius = 100.f, size = 200, origX = xorshift32() % sw, origY = xorshift32() % sh - (size / 2);
|
| | double angle = 0;
|
| | while (1) {
|
| | if (radius < sw) radius++; if (radius > sw - 2) { Sleep(100); origX = (xorshift32() % sw); origY = (xorshift32() % sh); radius = 10; };
|
| | int x = (cos(angle + radius) * radius) + origX, y = (sin(angle + radius) * radius) + origY, newSize = size + 16.4f;
|
| | int sx = (cos(angle + radius) * 1.9f), sy = (sin(angle + radius) * 1.9f);
|
| | BitBlt(desk, x + sx, y + sy, size, size, desk, x, y, SRCCOPY);
|
| | angle = fmod(angle + M_PI / radius, M_PI * radius);
|
| | Sleep(0.999999999999);
|
| | }
|
| | }
|
| | DWORD WINAPI plbt(LPVOID lpParam) {
|
| | HDC desk = GetDC(0); SeedXorshift32(__rdtsc());
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1);
|
| | while (1) {
|
| | desk = GetDC(0);
|
| | int a = xorshift32() % sw, b = xorshift32() % sh;
|
| | BitBlt(desk, a, b, sw, sh, desk, a + cos(xorshift32() % 101 - 50), b + sin(xorshift32() % 101 - 50), SRCCOPY);
|
| | }
|
| | }
|
| | DWORD WINAPI rnbaur(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), radius = 3.f, size = 200.f, origX = (sw / 2) - (size / 2), origY = (sh / 2) - (size / 2);
|
| | double angle = 0;
|
| | while (1) {
|
| | if (radius < sw) radius += size + 44; if (radius > (sw - 2)) { InvalidateRect(0, 0, 0); origX = xorshift32() % (sw - size); origY = xorshift32() % (sh - size); radius = 50.f; };
|
| | SelectObject(desk, CreateSolidBrush(RGB(xorshift32() % 256, xorshift32() % 256, xorshift32() % 256)));
|
| | for (int c = 0; c < ((radius * 2) + 90.8f); c++) {
|
| | double x = (cos(angle + radius) * radius) + origX, y = (sin(angle + radius) * radius) + origY;
|
| | BitBlt(desk, x, y, size, size, desk, x, y, MERGECOPY);
|
| | angle = fmod(angle + M_PI / radius, M_PI * radius);
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI pxl2(LPVOID lpParam) {
|
| | HDC desk = GetDC(0); SeedXorshift32(__rdtsc());
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), size = 200;
|
| | while (1) {
|
| | desk = GetDC(0);
|
| | for (int x = 0; x < sw; x += size) {
|
| | for (int y = 0; y < sh; y += size) {
|
| | StretchBlt(desk, x, y, size, size, desk, x, y, size + 13, size + 13, SRCCOPY);
|
| | StretchBlt(desk, x, y, size, size, desk, x, y, size - 13, size - 13, SRCCOPY);
|
| | }
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI schl(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), radius = 17.f; double angle = 0;
|
| | int size = 200, origX = (sw / 2) - (size / 2), origY = (sh / 2) - (size / 2);
|
| | while (1) {
|
| | for (int c = 0; c < 34567; c++) {
|
| | if (radius < sw + 1) radius += 1.f; if (radius > sw - 2) { radius = 17.f; }
|
| | float x = (cos(angle + radius) * radius) + origX, y = (sin(angle + radius) * radius) + origY,
|
| | sx = (cos(angle + radius) * (radius + 1)) + origX, sy = (sin(angle + radius) * (radius + 1)) + origY;
|
| | BitBlt(desk, x, y, size, size, desk, sx, sy, SRCCOPY);
|
| | angle = fmod(angle + M_PI / radius, M_PI * radius);
|
| | }
|
| | origX = -size + xorshift32() % (sw + size); origY = -size + xorshift32() % (sh + size);
|
| | }
|
| | }
|
| | DWORD WINAPI scbm(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), radius = 17.f; double angle = 0;
|
| | int size = 200, origX = (sw / 2) - (size / 2), origY = (sh / 2) - (size / 2);
|
| | while (1) {
|
| | for (int c = 0; c < 17659; c++) {
|
| | if (radius < sw + 1) radius += 1.f; if (radius > sw - 2) { radius = 17.f; }
|
| | float x = (cos(angle + radius) * radius) + origX, y = (sin(angle + radius) * radius) + origY,
|
| | sx = (cos(angle + radius) * (radius - 1)) + origX, sy = (sin(angle + radius) * (radius - 1)) + origY;
|
| | BitBlt(desk, x, y, size, size, desk, sx, sy, SRCCOPY);
|
| | angle = fmod(angle + M_PI / radius, M_PI * radius);
|
| | }
|
| | }
|
| | }
|
| | DWORD WINAPI glh(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk = GetDC(0), hdcMem; HBITMAP screenshot;
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1);
|
| | RGBQUAD* data = (RGBQUAD*)VirtualAlloc(0, (sw * sh + sw) * sizeof(RGBQUAD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
|
| | while (1) {
|
| | hdcMem = CreateCompatibleDC(desk); screenshot = CreateBitmap(sw, sh, 1, 32, data);
|
| | SelectObject(hdcMem, screenshot);
|
| | BitBlt(hdcMem, 0, 0, sw, sh, desk, 0, 0, SRCCOPY); GetBitmapBits(screenshot, sw * sh * 4, data);
|
| | int v = xorshift32() % 3, c = 0;
|
| | if (v == 0) c = 2; if (v == 1) c = 1; if (v == 3) c = 4;
|
| | for (int i = 0; i < sw * sh; i++) {
|
| | ((BYTE*)(data + i))[c] = i;
|
| | }
|
| | SetBitmapBits(screenshot, sw * sh * 4, data); BitBlt(desk, 0, 0, sw, sh, hdcMem, 0, 0, SRCCOPY);
|
| | DeleteDC(hdcMem); DeleteObject(screenshot);
|
| | Sleep(2);
|
| | }
|
| | }
|
| | DWORD WINAPI rtscr2(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk;
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), p = 0, v = 0;
|
| | while (1) {
|
| | v = xorshift32() % 2; if (v == 0) p = -51; else p = 51;
|
| | for (int i = 0; i < 4; i++) {
|
| | desk = GetDC(0); HDC hdcMem = CreateCompatibleDC(desk);
|
| | HBITMAP screenshot = CreateCompatibleBitmap(desk, sw, sh);
|
| |
|
| | SelectObject(hdcMem, screenshot);
|
| | BitBlt(hdcMem, 0, 0, sw, sh, desk, 0, 0, SRCCOPY);
|
| |
|
| | rotatehdc(GetDesktopWindow(), hdcMem, sw, sh, p);
|
| |
|
| | BLENDFUNCTION blend = { AC_SRC_OVER, 0, 110, 0 };
|
| | AlphaBlend(desk, 0, 0, sw, sh, hdcMem, 0, 0, sw, sh, blend);
|
| |
|
| | DeleteDC(hdcMem); DeleteDC(desk); DeleteObject(screenshot);
|
| | Sleep(1);
|
| | }
|
| | }
|
| | }
|
| |
|
| | DWORD WINAPI blr(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk;
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), size = 199;
|
| | while (1) {
|
| | desk = GetDC(0); HDC hdcMem = CreateCompatibleDC(desk);
|
| | HBITMAP screenshot = CreateCompatibleBitmap(desk, sw, sh);
|
| | SelectObject(hdcMem, screenshot);
|
| | BitBlt(hdcMem, 0, 0, sw, sh, desk, 0, 0, SRCCOPY);
|
| | for (int i = 0; i < 30; i++) {
|
| | int x = -size + xorshift32() % (sw + size), y = -size + xorshift32() % (sh + size);
|
| | BitBlt(hdcMem, x, y, size, size, hdcMem, x + xorshift32() % 17 - 8, y + xorshift32() % 17 - 8, SRCCOPY);
|
| | }
|
| | BLENDFUNCTION blend = { AC_SRC_OVER, 0, 50, 0 };
|
| | AlphaBlend(desk, 0, 0, sw, sh, hdcMem, 0, 0, sw, sh, blend);
|
| | DeleteObject(screenshot); DeleteDC(hdcMem); DeleteDC(desk);
|
| | }
|
| | }
|
| | DWORD WINAPI bnic(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), iw = GetSystemMetrics(11), ih = GetSystemMetrics(12), radius = 160.9f;
|
| | int origX = (sw / 2) - (radius / 2), origY = (sh / 2) - (radius / 2), x = 0, y = 0, centerX = 0, centerY = 0,
|
| | vx = 15, vy = 17;
|
| | double angle = 0;
|
| | LPCWSTR icons[6] = { IDI_ERROR, IDI_WARNING, IDI_QUESTION, IDI_INFORMATION, IDI_SHIELD, IDI_APPLICATION };
|
| | while (1) {
|
| | HICON icon = LoadIcon(0, icons[xorshift32() % 6]);
|
| |
|
| | origX += vx;
|
| | if (origX < 0) vx = -vx;
|
| | else if (origX + iw > sw) vx = -vx;
|
| | origY += vy;
|
| | if (origY < 0) vy = -vy;
|
| | else if (origY + ih > sh) vy = -vy;
|
| | for (int i = 0; i < radius + (iw + ih); i++) {
|
| | centerX = origX - (iw / 2); centerY = origY - (ih / 2);
|
| | x = (cos(angle) * radius) + centerX; y = (sin(angle) * radius) + centerY;
|
| |
|
| | DrawIcon(desk, x, y, icon);
|
| |
|
| | angle = fmod(angle + M_PI / radius, M_PI * radius);
|
| | }
|
| | Sleep(1);
|
| | }
|
| | }
|
| | DWORD WINAPI fnl(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk = GetDC(0);
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1), h = sh / 44;
|
| | for (int i = 0;; i++, i %= 6) {
|
| | if (!i) InvalidateRect(0, 0, 0);
|
| | for (int y = 0; y < sh + 1; y += h) {
|
| | int v = xorshift32() % 2;
|
| | if (v == 0) BitBlt(desk, 0, y, sw, h, desk, 0 + 23, y, SRCCOPY);
|
| | if (v == 1) BitBlt(desk, 0, y, sw, h, desk, 0 - 23, y, SRCCOPY);
|
| | }
|
| | Sleep(1);
|
| | }
|
| | }
|
| | DWORD WINAPI rnbscr(LPVOID lpParam) {
|
| | int w = GetSystemMetrics(0), h = GetSystemMetrics(1);
|
| | RGBQUAD* data = (RGBQUAD*)VirtualAlloc(0, (w * h + w) * sizeof(RGBQUAD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); int r = 2, g = 1, b = 4, c1 = r, c2 = r, c3 = r, v = 0, power = 5.f;
|
| | SeedXorshift32(__rdtsc()); HDC hdc, hdcMem; HBITMAP hbm;
|
| | for (int i = 0;; i++, i %= 3) {
|
| | for (int cn = 0; cn < 255 / 14; cn++) {
|
| | hdc = GetDC(0); hdcMem = CreateCompatibleDC(hdc); hbm = CreateBitmap(w, h, 1, 32, data);
|
| | SelectObject(hdcMem, hbm);
|
| | BitBlt(hdcMem, 0, 0, w, h, hdc, 0, 0, SRCCOPY); GetBitmapBits(hbm, w * h * 4, data);
|
| | for (int i = 0; w * h > i; i++) {
|
| | int r = GetRValue(((BYTE*)(data + i))[2]) % 255, g = GetGValue(((BYTE*)(data + i))[1]) % 255, b = GetBValue(((BYTE*)(data + i))[4]) % 255;
|
| | ((BYTE*)(data + i))[c1] = (((BYTE*)(data + i))[c1]) + power;
|
| | ((BYTE*)(data + i))[c2] = (((BYTE*)(data + i))[c2]) + power;
|
| | ((BYTE*)(data + i))[c3] = (((BYTE*)(data + i))[c3]) + power;
|
| | }
|
| | SetBitmapBits(hbm, w * h * 4, data); pixelatehdc(hdcMem, w, h, 4.0, STRETCH_DELETESCANS, SRCCOPY);
|
| | BitBlt(hdc, 0, 0, w, h, hdcMem, 0, 0, SRCCOPY);
|
| | DeleteObject(hbm); DeleteObject(hdcMem); DeleteDC(origHDC); DeleteDC(hdcMemory);
|
| | DeleteObject(hdc); DeleteObject(hScreenshot);
|
| | }
|
| | v++;
|
| | if (v > 0) c2 = g;
|
| | if (v > 1) { c3 = b; }
|
| | if (v > 3) { InvalidateRect(0, 0, 0); c1 = r; c2 = r; c3 = r; v = 0; }
|
| | }
|
| | }
|
| | DWORD WINAPI pxl3(LPVOID lpParam) {
|
| | SeedXorshift32(__rdtsc());
|
| | HDC desk, hdcMem;
|
| | int sw = GetSystemMetrics(0), sh = GetSystemMetrics(1);
|
| | while (1) {
|
| | for (int i = 0; i < 87; i++) InvalidateRect(0, 0, 0);
|
| | for (int p = 2; p < sw / 16; p += 2) {
|
| | desk = GetDC(0); hdcMem = CreateCompatibleDC(desk);
|
| | HBITMAP screenshot = CreateCompatibleBitmap(desk, sw / p, sh / p);
|
| | SetStretchBltMode(hdcMem, STRETCH_DELETESCANS);
|
| | SelectObject(hdcMem, screenshot);
|
| | StretchBlt(hdcMem, 0, 0, sw / p, sh / p, desk, 0, 0, sw, sh, SRCCOPY);
|
| | StretchBlt(desk, 0, 0, sw, sh, hdcMem, 0, 0, sw / p, sh / p, SRCCOPY);
|
| | DeleteDC(desk); DeleteDC(hdcMem); DeleteObject(screenshot);
|
| | Sleep(64);
|
| | }
|
| | Sleep(1000);
|
| | for (int i = 0; i < 87; i++) InvalidateRect(0, 0, 0);
|
| | }
|
| | }
|
| |
|
| | int main(
|
| | HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
| | LPSTR lpCmdLine, int nCmdShow
|
| | )
|
| | {
|
| | if (MessageBoxW(NULL, L"Run Malware?", L"Polyhydroxyalkanoates.exe", MB_YESNO | MB_ICONEXCLAMATION) == IDNO)
|
| | {
|
| | ExitProcess(0);
|
| | }
|
| | else
|
| | {
|
| | if (MessageBoxW(NULL, L"Are you sure?", L"Polyhydroxyalkanoates.exe", MB_YESNO | MB_ICONEXCLAMATION) == IDNO)
|
| | {
|
| | ExitProcess(0);
|
| | }
|
| | else
|
| | {
|
| | Sleep(1000);
|
| | sound1();
|
| | HANDLE pixelating = CreateThread(0, 0, pxl, 0, 0, 0);
|
| | Sleep(24000);
|
| | sound2();
|
| | TerminateThread(pixelating, 0);
|
| | HANDLE blurmash = CreateThread(0, 0, blr, 0, 0, 0);
|
| | HANDLE shadow = CreateThread(0, 0, shd, 0, 0, 0);
|
| | Sleep(32000);
|
| | for (int i = 0; i < 79; i++) InvalidateRect(0, 0, 0);
|
| | TerminateThread(blurmash, 0); TerminateThread(shadow, 0);
|
| | sound3();
|
| | HANDLE payload2 = CreateThread(0, 0, pl2, 0, 0, 0);
|
| | HANDLE rotatescreen = CreateThread(0, 0, rtscr, 0, 0, 0);
|
| | Sleep(16000);
|
| | TerminateThread(rotatescreen, 0);
|
| | for (int i = 0; i < 79; i++) InvalidateRect(0, 0, 0);
|
| | HANDLE sinewaves = CreateThread(0, 0, hrwvs, 0, 0, 0);
|
| | Sleep(16000);
|
| | TerminateThread(sinewaves, 0); TerminateThread(payload2, 0);
|
| | sound4();
|
| | HANDLE glitchart = CreateThread(0, 0, glchart, 0, 0, 0);
|
| | Sleep(14000);
|
| | TerminateThread(glitchart, 0);
|
| | for (int i = 0; i < 79; i++) InvalidateRect(0, 0, 0);
|
| | HANDLE shake = CreateThread(0, 0, shk, 0, 0, 0);
|
| | Sleep(14000);
|
| | TerminateThread(shake, 0);
|
| | for (int i = 0; i < 79; i++) InvalidateRect(0, 0, 0);
|
| | soundboom();
|
| | HANDLE explodedesktop = CreateThread(0, 0, expdes, 0, 0, 0);
|
| | Sleep(24000);
|
| | TerminateThread(explodedesktop, 0);
|
| | sound5();
|
| | HANDLE invertcircles = CreateThread(0, 0, invcc, 0, 0, 0);
|
| | Sleep(28000);
|
| | TerminateThread(invertcircles, 0);
|
| | sound6();
|
| | HANDLE waves3 = CreateThread(0, 0, wvs3, 0, 0, 0);
|
| | HANDLE rotatescreen2 = CreateThread(0, 0, plgscr, 0, 0, 0);
|
| | HANDLE screenmove = CreateThread(0, 0, scmv, 0, 0, 0);
|
| | Sleep(30000);
|
| | TerminateThread(screenmove, 0); TerminateThread(rotatescreen2, 0); TerminateThread(waves3, 0); for (int i = 0; i < 79; i++) InvalidateRect(0, 0, 0);
|
| | sound8();
|
| | HANDLE waves4 = CreateThread(0, 0, wvs4, 0, 0, 0);
|
| | HANDLE colortrain = CreateThread(0, 0, cltr, 0, 0, 0);
|
| | Sleep(14000);
|
| | TerminateThread(colortrain, 0);
|
| | HANDLE colorlines = CreateThread(0, 0, omg, 0, 0, 0);
|
| | Sleep(16000);
|
| | TerminateThread(waves4, 0); TerminateThread(colorlines, 0);
|
| | for (int i = 0; i < 79; i++) InvalidateRect(0, 0, 0);
|
| | HANDLE thr0 = CreateThread(0, 0, glchart, 0, 0, 0);
|
| | Sleep(5000);
|
| | }
|
| | }
|
| | } |
