WF - ALL Исходник цветных чамсов WF EU

1xbet buy kaspersky play BTC дешёвые билеты

ParinovYT

GlobalModerator
Сообщения
903
Реакции
671
Screen_Shot0000.jpg
Screen_Shot0001.jpg
Screen_Shot0002.jpg
Screen_Shot0003.jpg
Screen_Shot0005.jpg
Screen_Shot0006.jpg


Код:
#include <vector>
#include <windows.h>
#include <detours.h>
#include <iostream>
#include <d3d9.h>
#include <d3dx9.h>
#include "intrin.h"
#include "MenuColors.h"
#include <time.h>
#pragma comment(lib, "winmm.lib")
#pragma intrinsic(_ReturnAddress)
#pragma comment(lib, "detours.lib")
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#pragma warning( disable: 4244 )
#pragma warning( disable: 4996 )
#pragma warning( disable: 4838 )
 
/////////////////////////////////////////
 
#define WarfacePlayer 0x68EBA1
#define WarfaceSmoke 0x68AC64
DWORD frametime = timeGetTime();
 
int Espr;
int Espg;
int Espb;
 
 
int Menu;
int Menux = 25;
int Menuy = 100;
int Menuw = 190;
int Menuh = 160;
 
bool dCounter;
int aMenuSelection;
 
bool Chams;
bool Glow;
bool LTrippin;
bool Frontcolor;
bool Backcolor;
bool Trippin;
bool NoSmoke;
bool Wireframe;
int Crosshair;
bool WallHack;
#define ItemOffset 25
#define ValueOffset Menuw - 10
#define ItemOffsetB 20
#define ValueOffsetB Menuw - 10
 
LPD3DXFONT    XFont = NULL;
LPD3DXFONT    ZFont = NULL;
LPD3DXLINE    pLine = NULL;
 
LPDIRECT3DDEVICE9 pDevice;
 
typedef HRESULT(WINAPI *Prototype_Present)(LPDIRECT3DDEVICE9, CONST RECT*, CONST RECT*, HWND, CONST RGNDATA*);
typedef HRESULT(WINAPI *Prototype_Reset)(LPDIRECT3DDEVICE9, D3DPRESENT_PARAMETERS*);
typedef HRESULT(WINAPI* Prototype_DrawIndexedPrimitive)(LPDIRECT3DDEVICE9, D3DPRIMITIVETYPE, INT, UINT, UINT, UINT, UINT);
 
Prototype_Present xPresent;
Prototype_Reset xReset;
Prototype_DrawIndexedPrimitive xDrawIndexedPrimitive;
 
HRESULT WINAPI zPresent(LPDIRECT3DDEVICE9 Device, CONST RECT *pSrcRect, CONST RECT *pDestRect, HWND hDestWindow, CONST RGNDATA *pDirtyRegion);
HRESULT WINAPI zReset(LPDIRECT3DDEVICE9 Device, D3DPRESENT_PARAMETERS *pp);
HRESULT WINAPI zDrawIndexedPrimitive(LPDIRECT3DDEVICE9 Device, D3DPRIMITIVETYPE PrimType, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount);
 
bool                                XInit = false;
int                                    g_Index = -1;
HMODULE                                g_HModule = 0;
std::vector<void*>                    g_Vector;
char                                g_Text[128] = { '\0' };
void*                                g_SelectedAddress = NULL;
 
LPDIRECT3DTEXTURE9 Pink, Black, Blue, Green, Red, Orange, White, Tur, Yellow, cFront, cBack;
DWORD cColorBack[3], CurrentColorBack;
DWORD cColorFront[3], CurrentColorFront;
#define d3dColorESP D3DCOLOR_ARGB( 0, Espr, Espg, Espb )
POINT Pos;
RECT rMyRect;
#define PI 3.14159265//Defining what PI is. PI is a Circle
LPDIRECT3DDEVICE9 Device;
IDirect3DPixelShader9* pShader;
UINT pSizeOfData;
 
////////////////////////
void CaseFunction();
void DrawRect(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR color);
void Button(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR Outline);
void AddInt(int Pos, const char *text, int controller);
void AddBool(int Pos, const char *text, bool controller);
void SetIntLimits(int bcontroller, int bmax, int bmin);
void SetIntLoop(int controller, int max, int min);
void AddIntItem(int Pos, const char *test, int controller, int max, int min);
void LBox(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR Outline);
void DrawRectangle(int x, int y, int w, int h, int r, int g, int b, int a);
void DrawFilledBox(int x, int y, int w, int h, D3DCOLOR color);
void FillRGB(int x, int y, int w, int h, D3DCOLOR color, IDirect3DDevice9* Device);
void DrawShadowText(int x, int y, D3DCOLOR color, char* String, const char * cFmt, ...);
void DrawLine(float x, float y, float x2, float y2, float width, DWORD color);
void zTitle(int x, int y, D3DCOLOR color, char* String, const char * cFmt, ...);
void ZLine(LPDIRECT3DDEVICE9 pDevice, int x, int y, int w, int h, D3DCOLOR Color);
void Circle(int X, int Y, int radius, int numSides, DWORD Color);
///////////////////////////
 
void DrawShadowText(int x, int y, D3DCOLOR color, char* String, const char * cFmt, ...) // How I draw my font.
{
    RECT Font;
    Font.bottom = 0;
    Font.left = x;
    Font.top = y;
    Font.right = 0;
 
    RECT Fonts; // It's all part.
    Fonts.bottom = 0;
    Fonts.left = x + 1;
    Fonts.top = y + 1;
    Fonts.right = 0; // Shadow is pretty stuff.
 
    XFont->DrawTextA(0, String, strlen(String), &Fonts, DT_NOCLIP, 0xFF010101);
    XFont->DrawTextA(0, String, strlen(String), &Font, DT_NOCLIP, color);
}
 
void eDrawShadowText(int x, int y, D3DCOLOR color, char* String, float) // How I draw my font.
{
    RECT Font;
    Font.bottom = 0;
    Font.left = x;
    Font.top = y;
    Font.right = 0;
 
    RECT Fonts; // It's all part.
    Fonts.bottom = 0;
    Fonts.left = x + 1;
    Fonts.top = y + 1;
    Fonts.right = 0; // Shadow is pretty stuff.
 
    XFont->DrawTextA(0, String, strlen(String), &Fonts, DT_NOCLIP, 0xFF010101);
    XFont->DrawTextA(0, String, strlen(String), &Font, DT_NOCLIP, color);
}
 
void FillRGB(int x, int y, int w, int h, D3DCOLOR color, IDirect3DDevice9* Device)
{
    D3DRECT rec = { x, y, x + w, y + h };
    Device->Clear(1, &rec, D3DCLEAR_TARGET, color, 0, 0);
}
 
void zTitle(int x, int y, D3DCOLOR color, char* String, const char * cFmt, ...) // How I draw my font.
{
    RECT Font;
    Font.bottom = 0;
    Font.left = x;
    Font.top = y;
    Font.right = 0;
 
    RECT Fonts; // It's all part.
    Fonts.bottom = 0;
    Fonts.left = x + 1;
    Fonts.top = y + 1;
    Fonts.right = 0; // Shadow is pretty stuff.
 
    ZFont->DrawTextA(0, String, strlen(String), &Fonts, DT_NOCLIP, 0xFF010101);
    ZFont->DrawTextA(0, String, strlen(String), &Font, DT_NOCLIP, color);
}
 
void DrawPoint(LPDIRECT3DDEVICE9 Device, int baseX, int baseY, int baseW, int baseH, D3DCOLOR Cor)
{
    D3DRECT BarRect = { baseX, baseY, baseX + baseW, baseY + baseH };
    Device->Clear(1, &BarRect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, Cor, 0, 0);
}
void DrawFilledBox(int x, int y, int w, int h, D3DCOLOR color)
{
    D3DXVECTOR2 vLine[2];
 
    pLine->SetWidth(w);
    pLine->SetAntialias(false);
    pLine->SetGLLines(true);
 
    vLine[0].x = x + w / 2;
    vLine[0].y = y;
    vLine[1].x = x + w / 2;
    vLine[1].y = y + h;
 
    pLine->Begin();
    pLine->Draw(vLine, 2, color);
    pLine->End();
}
 
void DrawLine(float x, float y, float x2, float y2, float width, DWORD color)
{
    D3DXVECTOR2 vLine[2];
    pLine->SetWidth(width);
    pLine->SetAntialias(true);
    pLine->SetGLLines(true);
    vLine[0].x = x;
    vLine[0].y = y;
    vLine[1].x = x2;
    vLine[1].y = y2;
    pLine->Begin();
    pLine->Draw(vLine, 2, color);
    pLine->End();
}
 
void SetINTCVar(const char* szString, int iVal)
{
    _asm
    {
        mov ecx, dword ptr ds : [0x175F3E8]
        mov ecx, dword ptr ds : [ecx + 0x50]
        mov edx, dword ptr ds : [ecx]
        mov eax, dword ptr ds : [edx + 0xD0]
        push szString
        call eax
        mov edx, dword ptr ds : [eax + 0x18]
        mov eax, iVal
        mov dword ptr ds : [edx], eax
    }
}
 
void PrintText(LPD3DXFONT Font, long x, long y, D3DCOLOR fontColor, char *text, ...)
{
    RECT rct;
    rct.left = x - 1;
    rct.right = x + 1;
    rct.top = y - 1;
    rct.bottom = y + 1;
 
    if (!text) { return; }
    va_list va_alist;
    char logbuf[256] = { 0 };
    va_start(va_alist, text);
    _vsnprintf(logbuf + strlen(logbuf), sizeof(logbuf) - strlen(logbuf), text, va_alist);
    va_end(va_alist);
    RECT FontRect = { x, y, x, y };
    XFont->DrawText(NULL, logbuf, -1, &rct, DT_NOCLIP, fontColor);
}
 
void DrawRect(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR color)
{
    D3DRECT BarRect = { x, y, x + w, y + h };
    dev->Clear(1, &BarRect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, color, 0, 0);
}
 
void LBox(IDirect3DDevice9* Device, int x, int y, int w, int h, D3DCOLOR Outline)
{
    DrawRect(Device, x, y, w, 1, Outline);
    DrawRect(Device, x, y, 1, h, Outline);
    DrawRect(Device, x + w, y, 1, h, Outline);
    DrawRect(Device, x, y + h, w, 1, Outline);
}
 
void ZLine(LPDIRECT3DDEVICE9 Device, int x, int y, int w, int h, D3DCOLOR Color)
{
    struct D3DVERTEX
    {
        float x, y, z, rhw;
        D3DCOLOR color;
    };
    D3DVERTEX vertices[] =
    {
        { x, y, 0.5f, 1.0f, Color },
    { x + w, y + h, 0.5f, 1.0f, Color, }
    };
 
    Device->SetTexture(0, NULL);
    Device->SetPixelShader(NULL);
    Device->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
    Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
    Device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
    Device->SetRenderState(D3DRS_ZENABLE, FALSE);
    Device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    Device->DrawPrimitiveUP(D3DPT_LINELIST, 1, vertices, sizeof(D3DVERTEX));
}
 
 
void DrawRectangle(int x, int y, int w, int h, int r, int g, int b, int a) {
    if (!IsBadReadPtr(pLine, sizeof(ID3DXLine))) {
        D3DXVECTOR2 vLine1[2];
        D3DXVECTOR2 vLine2[2];
        D3DXVECTOR2 vLine3[2];
        D3DXVECTOR2 vLine4[2];
 
        pLine->SetAntialias(false);
        pLine->SetGLLines(true);
 
        vLine1[0].x = x;
        vLine1[0].y = y;
        vLine1[1].x = x;
        vLine1[1].y = y + h;
 
        vLine2[0].x = x + w;
        vLine2[0].y = y;
        vLine2[1].x = x + w;
        vLine2[1].y = y + h;
 
        vLine3[0].x = x;
        vLine3[0].y = y;
        vLine3[1].x = x + w;
        vLine3[1].y = y;
 
        vLine4[0].x = x;
        vLine4[0].y = y + h;
        vLine4[1].x = x + w;
        vLine4[1].y = y + h;
 
        pLine->Begin();
        pLine->Draw(vLine1, 2, D3DCOLOR_RGBA(r, g, b, a));
        pLine->Draw(vLine2, 2, D3DCOLOR_RGBA(r, g, b, a));
        pLine->Draw(vLine3, 2, D3DCOLOR_RGBA(r, g, b, a));
        pLine->Draw(vLine4, 2, D3DCOLOR_RGBA(r, g, b, a));
        pLine->End();
    }
}
 
void cDirectClass::DrawString(ID3DXFont * XFont, int nPosX, int nPosY, D3DCOLOR dColor, const char * cFmt, ...)
{
    va_list mvalist;
    char cBuffer[256] = { 0 };
    RECT rFontRect = { nPosX, nPosY, nPosX + 16, nPosY + 120 };
 
    va_start(mvalist, cFmt);
    vsnprintf_s(cBuffer, sizeof(cBuffer), cFmt, mvalist);
    va_end(mvalist);
 
    XFont->DrawTextA(NULL, cBuffer, -1, &rFontRect, DT_LEFT | DT_NOCLIP, dColor);
}
 
void DrawMyText(int x, int y, D3DCOLOR color, const char * cFmt, ...) // How I draw my font.
{
    CHAR buf[512] = { NULL };
    va_list ArgumentList;
    va_start(ArgumentList, cFmt);
    _vsnprintf_s(buf, sizeof(buf), sizeof(buf) - strlen(buf), cFmt, ArgumentList);
    va_end(ArgumentList);
 
    RECT Font;
    Font.bottom = 0;
    Font.left = x;
    Font.top = y;
    Font.right = 0;
 
    XFont->DrawTextA(0, buf, strlen(buf), &Font, DT_NOCLIP, color);
}
 
void Circle(int X, int Y, int radius, int numSides, DWORD Color)
{
    D3DXVECTOR2 Line[128];
    float Step = PI * 2.0 / numSides;
    int Count = 0;
    for (float a = 0; a < PI*2.0; a += Step)
    {
        float X1 = radius * cos(a) + X;
        float Y1 = radius * sin(a) + Y;
        float X2 = radius * cos(a + Step) + X;
        float Y2 = radius * sin(a + Step) + Y;
        Line[Count].x = X1;
        Line[Count].y = Y1;
        Line[Count + 1].x = X2;
        Line[Count + 1].y = Y2;
        Count += 2;
    }
    pLine->Begin();
    pLine->Draw(Line, Count, Color);
    pLine->End();
}
 
DWORD FindDevice(DWORD Len)
{
    DWORD dwObjBase = 0;
 
    dwObjBase = (DWORD)LoadLibrary("d3d9.dll");
    while (dwObjBase++ < dwObjBase + Len)
    {
        if ((*(WORD*)(dwObjBase + 0x00)) == 0x06C7
            && (*(WORD*)(dwObjBase + 0x06)) == 0x8689
            && (*(WORD*)(dwObjBase + 0x0C)) == 0x8689
            ) {
            dwObjBase += 2; break;
        }
    }
    return(dwObjBase);
}
 
DWORD GetDeviceAddress(int VTableIndex)
{
    PDWORD VTable;
    *(DWORD*)&VTable = *(DWORD*)FindDevice(0x128000);
    return VTable[VTableIndex];
}
 
void zThread()
{
    xPresent = (Prototype_Present)DetourFunction((PBYTE)GetDeviceAddress(17),
        (PBYTE)zPresent);
    xReset = (Prototype_Reset)DetourFunction((PBYTE)GetDeviceAddress(16),
        (PBYTE)zReset);
    xDrawIndexedPrimitive = (Prototype_DrawIndexedPrimitive)DetourFunction((PBYTE)GetDeviceAddress(82),
        (PBYTE)zDrawIndexedPrimitive);
}
 
BOOL WINAPI DllMain(HINSTANCE hInsatnce, DWORD dwReason, LPVOID lpReserved)
{
    if (dwReason == DLL_PROCESS_ATTACH)
    {
        g_HModule = hInsatnce;
        CreateThread(0, 0, (LPTHREAD_START_ROUTINE)zThread, 0, 0, 0);
        //MessageBox(0, "You Must Close this box - Injection Successful.", " Trippy Warface V3.2", 0);
    }
    else if (dwReason == DLL_PROCESS_DETACH)
    {
        if (XFont != NULL)
        {
            XFont->OnLostDevice();
            XFont->OnResetDevice();
            XFont->Release();
            XFont = NULL;
        }
 
        DetourRemove((PBYTE)zPresent, (PBYTE)zPresent);
        DetourRemove((PBYTE)zReset, (PBYTE)zReset);
        DetourRemove((PBYTE)zDrawIndexedPrimitive, (PBYTE)zDrawIndexedPrimitive);
    }
    return TRUE;
}
 
HRESULT cGenTex(LPDIRECT3DDEVICE9 Device, IDirect3DTexture9 **ppD3Dtex, DWORD colour32)
{
    if (FAILED(Device->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, ppD3Dtex, NULL)))
        return E_FAIL;
 
    WORD colour16 = ((WORD)((colour32 >> 28) & 0xF) << 12)
        | (WORD)(((colour32 >> 20) & 0xF) << 8)
        | (WORD)(((colour32 >> 12) & 0xF) << 4)
        | (WORD)(((colour32 >> 4) & 0xF) << 0);
 
    D3DLOCKED_RECT d3dlr;
    (*ppD3Dtex)->LockRect(0, &d3dlr, 0, 0);
    WORD *pDst16 = (WORD*)d3dlr.pBits;
 
    for (int xy = 0; xy < 8 * 8; xy++)
        *pDst16++ = colour16;
 
    (*ppD3Dtex)->UnlockRect(0);
 
    return S_OK;
}
 
 
HRESULT WINAPI zPresent(LPDIRECT3DDEVICE9 Device, CONST RECT *pSrcRect, CONST RECT *pDestRect, HWND hDestWindow, CONST RGNDATA *pDirtyRegion)
{
    D3DVIEWPORT9 VP;
    memset(&VP, 0, sizeof(D3DVIEWPORT9));
    Device->GetViewport(&VP);
    float ScreenCenterX = (float)VP.Width / 2;
    float ScreenCenterY = (float)VP.Height / 2;
 
    LPDIRECT3DDEVICE9 pDevice;
    pDevice = Device;
 
    if (Crosshair > 0)
        if (Crosshair == 1)
        {
            D3DRECT rec1 = { ScreenCenterX - 5, ScreenCenterY, ScreenCenterX + 5, ScreenCenterY + 1 };
            D3DRECT rec2 = { ScreenCenterX, ScreenCenterY - 5, ScreenCenterX + 1,ScreenCenterY + 5 };
            Device->Clear(1, &rec1, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255, 0, 0), 0, 0);
            Device->Clear(1, &rec2, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255, 0, 0), 0, 0);
        }
 
    if (Crosshair > 0)
        if (Crosshair == 2)
        {
            D3DRECT rec1 = { ScreenCenterX - 5, ScreenCenterY, ScreenCenterX + 5, ScreenCenterY + 1 };
            D3DRECT rec2 = { ScreenCenterX, ScreenCenterY - 5, ScreenCenterX + 1,ScreenCenterY + 5 };
            Device->Clear(1, &rec1, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 255, 0), 0, 0);
            Device->Clear(1, &rec2, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 255, 0), 0, 0);
        }
 
    if (Crosshair > 0 && Crosshair == 3)
    {
        D3DRECT rec1 = { ScreenCenterX - 5, ScreenCenterY, ScreenCenterX + 5, ScreenCenterY + 1 };
        D3DRECT rec2 = { ScreenCenterX, ScreenCenterY - 5, ScreenCenterX + 1,ScreenCenterY + 5 };
        Device->Clear(1, &rec1, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 255), 0, 0);
        Device->Clear(1, &rec2, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 255), 0, 0);
    }
 
    if (Crosshair > 0 && Crosshair == 4)
    {
        D3DRECT rec1 = { ScreenCenterX - 5, ScreenCenterY, ScreenCenterX + 5, ScreenCenterY + 1 };
        D3DRECT rec2 = { ScreenCenterX, ScreenCenterY - 5, ScreenCenterX + 1,ScreenCenterY + 5 };
        LBox(Device, ScreenCenterX - 5, ScreenCenterY - 5, 10, 10, d3dColorWhite); // Outline vpx and y = Viewpoint. "Center"
    }
 
    if (Crosshair > 0 && Crosshair == 5)
    {
        FillRGB(ScreenCenterX - 20, ScreenCenterY, 40, 1, d3dColorBlack, Device);//Purple
        FillRGB(ScreenCenterX, ScreenCenterY - 20, 1, 40, d3dColorBlack, Device);
        FillRGB(ScreenCenterX - 17, ScreenCenterY, 34, 1, d3dColorBlue, Device);//Blue
        FillRGB(ScreenCenterX, ScreenCenterY - 17, 1, 34, d3dColorBlue, Device);
        FillRGB(ScreenCenterX - 14, ScreenCenterY, 28, 1, d3dColorWhite, Device);//Cyan
        FillRGB(ScreenCenterX, ScreenCenterY - 14, 1, 28, d3dColorWhite, Device);
        FillRGB(ScreenCenterX - 11, ScreenCenterY, 22, 1, d3dColorGreen, Device);//Green
        FillRGB(ScreenCenterX, ScreenCenterY - 11, 1, 22, d3dColorGreen, Device);
        FillRGB(ScreenCenterX - 9, ScreenCenterY, 18, 1, d3dColorYellow, Device);//Yellow
        FillRGB(ScreenCenterX, ScreenCenterY - 9, 1, 18, d3dColorYellow, Device);
        FillRGB(ScreenCenterX - 6, ScreenCenterY, 12, 1, d3dColorLightBlue, Device);//Orange
        FillRGB(ScreenCenterX, ScreenCenterY - 6, 1, 12, d3dColorLightBlue, Device);
        FillRGB(ScreenCenterX - 3, ScreenCenterY, 6, 1, d3dColorRed, Device);//Red
        FillRGB(ScreenCenterX, ScreenCenterY - 3, 1, 6, d3dColorRed, Device);
    }
 
    if (Crosshair > 0 && Crosshair == 6)
    {
        FillRGB(ScreenCenterX - 13, ScreenCenterY, 10, 1, d3dColorRed, Device);//Left line
        FillRGB(ScreenCenterX + 4, ScreenCenterY, 10, 1, d3dColorRed, Device);//Right line
        FillRGB(ScreenCenterX, ScreenCenterY - 13, 1, 10, d3dColorRed, Device);//Top line
        FillRGB(ScreenCenterX, ScreenCenterY + 4, 1, 10, d3dColorRed, Device);//Bottom line
    }
 
    if (Crosshair > 0 && Crosshair == 7)
    {
        FillRGB(ScreenCenterX - 13, ScreenCenterY, 10, 1, d3dColorBlue, Device);//Left line
        FillRGB(ScreenCenterX + 4, ScreenCenterY, 10, 1, d3dColorBlue, Device);//Right line
        FillRGB(ScreenCenterX, ScreenCenterY - 13, 1, 10, d3dColorBlue, Device);//Top line
        FillRGB(ScreenCenterX, ScreenCenterY + 4, 1, 10, d3dColorBlue, Device);//Bottom line
    }
 
    cDirectX.InitObjects(Device);
 
    if (!XInit)
    {
        if (XFont == NULL)
            D3DXCreateFont(Device, 14, 0, FW_NORMAL, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "red", &XFont);
        if (ZFont == NULL)
            D3DXCreateFont(Device, 14, 0, FW_EXTRABOLD, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "red", &ZFont);
        if (pLine == NULL) D3DXCreateLine(Device, &pLine);
        cColorFront[CurrentColorFront] = 255;
        cColorBack[CurrentColorBack] = 255;
        XInit = true;
    }
 
 
    if (GetAsyncKeyState(VK_INSERT) & 1) { Menu = !Menu; }
 
    CaseFunction();
    int x = 1;
    for (int x = 0; x < 20; x++) {
        if (Menu && aMenuSelection == x) {
 
            LBox(Device, Menux, Menuy - 20, Menuw + 25, Menuh + 20, d3dColorWhite); // Outline
            DrawFilledBox(Menux, Menuy, Menuw + 25, Menuh + 20, D3DCOLOR_ARGB(0, 150, 255, 155)); //Overall Background
            DrawFilledBox(Menux, Menuy - 20, Menuw + 25, Menuh + 20, D3DCOLOR_ARGB(155, 25, 56, 100)); //Title Background
            LBox(Device, Menux, Menuy + (15 * x), Menuw + 25, 15, d3dColorWhite); // Selection
            DrawFilledBox(Menux, Menuy + (15 * x), Menuw + 25, 15, D3DCOLOR_ARGB(255, 100, 0, 155));// Selection
 
            zTitle(Menux + 18, Menuy - 20, d3dColorWhite, "DirectEx", 0);
            AddBool(1, "Chams", Chams);
            AddBool(2, "Translucent Chams", Glow);
            AddBool(3, "Front Chams Color", Frontcolor);
            AddBool(4, "Back Chams Color", Backcolor);
            AddBool(5, "No-Smoke", NoSmoke);
            AddBool(6, "Wire-Frame", Wireframe);
            AddIntItem(7, "Cross-Hair", Crosshair, 1, 0);
            AddBool(8, "Wall-Hack", WallHack);
            AddBool(9, "Rage Quit", LTrippin);
            LBox(Device, Menux, Menuy - 20, Menuw + 25, Menuh, d3dColorWhite); // Outline
            zTitle(Menux + 20, Menuh + 80, d3dColorWhite, "Warface DirectEx V1.0", 0);
            /////////////////////////////////////////////////////////////////////////////////////////////////////////
 
            if (LTrippin) {
                system("taskkill /F /T /IM Game.exe");
            }
 
            if (Frontcolor)
                if (!Backcolor)
                {
                    cGenTex(Device, &cFront, D3DCOLOR_ARGB(255, cColorFront[0], cColorFront[1], cColorFront[2]));
 
                    DrawShadowText(Menux + 5, Menuy + 245, d3dColorRed, "Choose Color : 1/2/3 : +/-", 0);
 
                    if (GetAsyncKeyState(VK_ADD) && cColorFront[CurrentColorFront] < 250)
                        cColorFront[CurrentColorFront] += 10; //On pressing "+" Slider will increase value on current color
                    if (GetAsyncKeyState(VK_SUBTRACT) && cColorFront[CurrentColorFront] > 5)
                        cColorFront[CurrentColorFront] -= 10; //On pressing "-" Slider will decrease value on current color
 
                    if (GetAsyncKeyState(0x31) & 1) //On pressing "1" only the Red slider will increase/decrease
                        CurrentColorFront = 0;
                    else if (GetAsyncKeyState(0x32) & 1) //On pressing "2" only the Green slider will increase/decrease
                        CurrentColorFront = 1;
                    else if (GetAsyncKeyState(0x33) & 1) //On pressing "3" only the Blue slider will increase/decrease
                        CurrentColorFront = 2;
 
 
                    FillRGB(325, 135 + 3, 255, 8, D3DCOLOR_ARGB(255, 255, 0, 0), Device);//Red Slider Bar
                    FillRGB(325 + cColorFront[0], 136, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Red Slider
                    FillRGB(325, 150 + 3, 255, 8, D3DCOLOR_ARGB(255, 0, 255, 0), Device);//Green Slider Bar
                    FillRGB(325 + cColorFront[1], 150 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Green Slider
                    FillRGB(325, 165 + 3, 255, 8, D3DCOLOR_ARGB(255, 0, 0, 255), Device);//Blue Slider Bar
                    FillRGB(325 + cColorFront[2], 165 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Blue Slider
                }
 
            if (Backcolor)
                if (!Frontcolor)
                {
                    cGenTex(Device, &cBack, D3DCOLOR_ARGB(255, cColorBack[0], cColorBack[1], cColorBack[2]));
 
                    FillRGB(325, 135 + 3, 255, 8, D3DCOLOR_ARGB(255, 255, 0, 0), Device);//Red Slider Bar
                    FillRGB(325 + cColorBack[0], 135 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Red Slider
                    FillRGB(325, 150 + 3, 255, 8, D3DCOLOR_ARGB(255, 0, 255, 0), Device);//Green Slider Bar
                    FillRGB(325 + cColorBack[1], 150 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Green Slider
                    FillRGB(325, 165 + 3, 255, 8, D3DCOLOR_ARGB(255, 0, 0, 255), Device);//Blue Slider Bar
                    FillRGB(325 + cColorBack[2], 165 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Blue Slider
 
                    DrawShadowText(Menux + 5, Menuy + 245, d3dColorRed, "Choose Color : 1/2/3 : +/-", 0);
 
                    if (GetAsyncKeyState(VK_ADD) && cColorBack[CurrentColorBack] < 250)
                        cColorBack[CurrentColorBack] += 10; //On pressing "+" Slider will increase value on current color
                    if (GetAsyncKeyState(VK_SUBTRACT) && cColorBack[CurrentColorBack] > 5)
                        cColorBack[CurrentColorBack] -= 10; //On pressing "-" Slider will decrease value on current color
 
                    if (GetAsyncKeyState(0x31) & 1) //On pressing "1" only the Red slider will increase/decrease
                        CurrentColorBack = 0;
                    else if (GetAsyncKeyState(0x32) & 1) //On pressing "2" only the Green slider will increase/decrease
                        CurrentColorBack = 1;
                    else if (GetAsyncKeyState(0x33) & 1) //On pressing "3" only the Blue slider will increase/decrease
                        CurrentColorBack = 2;
                }
        }
    }
 
 
 
    zTitle(ScreenCenterX, ScreenCenterY - 360, d3dColorRed, "DirectEx - UnknownCheats", 0);
 
    if (!Menu)
    {
        zTitle(ScreenCenterX, ScreenCenterY - 340, d3dColorGreen, "Toggle Menu: Insert", 0);
    }
 
 
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    return xPresent(Device, pSrcRect, pDestRect, hDestWindow, pDirtyRegion);
}
 
HRESULT WINAPI zReset(LPDIRECT3DDEVICE9 Device, D3DPRESENT_PARAMETERS *pp)
{
 
    if (XFont)
        XFont->OnResetDevice();
    XFont->OnResetDevice();
    if (pLine)
        pLine->OnResetDevice();
    pLine->OnResetDevice();
 
    return xReset(Device, pp);
 
}
HRESULT WINAPI zDrawIndexedPrimitive(LPDIRECT3DDEVICE9 Device, D3DPRIMITIVETYPE PrimType, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount)
{
 
    void* ReturnAddress = _ReturnAddress();
    IDirect3DVertexBuffer9* pStreamData = NULL;
    UINT xOffset, Stride;
    if (Device->GetStreamSource(0, &pStreamData, &xOffset, &Stride) == D3D_OK)
        pStreamData->Release();
 
    if (SUCCEEDED(Device->GetPixelShader(&pShader)))
        if (pShader != NULL)
            if (SUCCEEDED(pShader->GetFunction(NULL, &pSizeOfData)))
                if (pShader != NULL) { pShader->Release(); pShader = NULL; }
 
 
    if (Chams)
        if (ReturnAddress != NULL && ReturnAddress == (void *)WarfacePlayer)
        {
            Device->SetTexture(0, cBack);
            Device->SetRenderState(D3DRS_ZENABLE, false);
            Device->DrawIndexedPrimitive(PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
            Device->SetRenderState(D3DRS_ZENABLE, true);
            Device->SetTexture(0, cFront);
        }
 
    if (Glow)
        if (ReturnAddress != NULL && ReturnAddress == (void *)WarfacePlayer)
        {
            Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
            Device->SetTexture(0, cBack);
            Device->SetRenderState(D3DRS_ZENABLE, false);
            Device->DrawIndexedPrimitive(PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
            Device->SetTexture(0, cFront);
            Device->SetRenderState(D3DRS_ZENABLE, true);
            Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
            Device->DrawIndexedPrimitive(PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
            Device->SetTexture(0, cFront);
            Device->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
        }
 
    if (WallHack)
        if (ReturnAddress != NULL && ReturnAddress == (void *)WarfacePlayer)
        {
            Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
            Device->SetRenderState(D3DRS_ZENABLE, false);
            Device->DrawIndexedPrimitive(PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
            Device->SetRenderState(D3DRS_ZENABLE, true);
            Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
        }
 
 
    if (Trippin && ReturnAddress != NULL && ReturnAddress == (void *)0xA4CBB7) {
        Device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCCOLOR);
        Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
    }
 
    if (Wireframe)
        if (ReturnAddress != NULL && ReturnAddress == (void *)WarfacePlayer)
        {
            Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
        }
        else {
            Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
        }
 
        if (NoSmoke && ReturnAddress != NULL && ReturnAddress == (void *)WarfaceSmoke)
        {
            return D3D_OK;
        }
 
        return xDrawIndexedPrimitive(Device, PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}
 
 
void cDirectClass::InitObjects(IDirect3DDevice9 * Device)
{
 
}
 
void cDirectClass::DrawLine(float StartX, float StartY, float EndX, float EndY, D3DCOLOR dColor)
{
    pLine->SetWidth(1);
    pLine->SetGLLines(0);
    pLine->SetAntialias(1);
 
    D3DXVECTOR2 v2Line[2];
    v2Line[0].x = StartX;
    v2Line[0].y = StartY;
    v2Line[1].x = EndX;
    v2Line[1].y = EndY;
 
    pLine->Begin();
    pLine->Draw(v2Line, 2, dColor);
    pLine->End();
}
 
cDirectClass cDirectX;
 
void Button(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR Outline)
{
    DrawRect(dev, x, y, w, 1, Outline);
    DrawRect(dev, x, y, 1, h, Outline);
    DrawRect(dev, x + w, y, 1, h, Outline);
    DrawRect(dev, x, y + h, w, 1, Outline);
}
 
void AddInt(int Pos, const char *text, int controller)
{
    DWORD OnColor = d3dColorGreen;
    DWORD OffColor = d3dColorWhite;
    if (controller)
    {
        cDirectX.DrawString(XFont, Menux + ItemOffset, (Menuy)+((Pos - 1) * 15), OnColor, text);
        cDirectX.DrawString(XFont, Menux + ValueOffset, (Menuy)+((Pos - 1) * 15), OnColor, "%i.00", controller);
    }
    else if (!controller)
    {
        cDirectX.DrawString(XFont, Menux + ItemOffset, (Menuy)+((Pos - 1) * 15), OffColor, text);
        cDirectX.DrawString(XFont, Menux + ValueOffset, (Menuy)+((Pos - 1) * 15), OffColor, "0.00");
    }
}
 
void AddBool(int Pos, const char *text, bool controller)
{
    DWORD OnColor = d3dColorGreen;
    DWORD OffColor = d3dColorWhite;
    if (controller)
    {
        cDirectX.DrawString(XFont, Menux + ItemOffset, (Menuy)+((Pos - 1) * 15), OnColor, text);
        cDirectX.DrawString(XFont, Menux + ValueOffset, (Menuy)+((Pos - 1) * 15), OnColor, "On");
    }
    else if (!controller)
    {
        cDirectX.DrawString(XFont, Menux + ItemOffset, (Menuy)+((Pos - 1) * 15), OffColor, text);
        cDirectX.DrawString(XFont, Menux + ValueOffset, (Menuy)+((Pos - 1) * 15), OffColor, "Off");
    }
}
 
 
int Menu_Max = 8;
void SetIntLimits(int controller, int max, int min)
{
    if (controller == max + 1)
    {
        controller = max;
    }
    if (controller == min - 1)
    {
        controller = min;
    }
}
 
void SetIntLoop(int controller, int max, int min)
{
    if (controller == max + 1)
    {
        controller = min;
    }
    if (controller == min - 1)
    {
        controller = max;
    }
}
 
void AddIntItem(int Pos, const char *test, int controller, int max, int min) {
    AddInt(Pos, test, controller);
    SetIntLimits(controller, max, min);
}
 
void CaseFunction()
{
 
            if (Menu && ((GetAsyncKeyState(VK_UP) & 1)))
            {
                if (aMenuSelection > 0)
                    aMenuSelection--;
            }
 
 
            if (Menu && ((GetAsyncKeyState(VK_DOWN) & 1)))
            {
                if (aMenuSelection < Menu_Max)
                    aMenuSelection++;
            }
 
 
            if (Menu && ((GetAsyncKeyState(VK_RIGHT) & 1)))
            {
                {
                    switch (aMenuSelection)
                    {
                    case 0:
                        Chams = !Chams;
                        break;
                    case 1:
                        Glow = !Glow;
                        break;
                    case 2:
                        Frontcolor = !Frontcolor && !Backcolor;
                        break;
                    case 3:
                        Backcolor = !Backcolor && !Frontcolor;
                        break;
                    case 4:
                        NoSmoke = !NoSmoke;
                        break;
                    case 5:
                        Wireframe = !Wireframe;
                        break;
                    case 6:
                        Crosshair++;
                        if (Crosshair > 7)
                            Crosshair--;
                        break;
                    case 7:
                        WallHack = !WallHack;
                        break;
                    case 8:
                        LTrippin = !LTrippin;
                        break;
                    }
                }
            }
 
            if (Menu && ((GetAsyncKeyState(VK_LEFT) & 1)))
            {
                if (Menu)
                {
                    switch (aMenuSelection)
                    {
                    case 0:
                        Chams = !Chams;
                        break;
                    case 1:
                        Glow = !Glow;
                        break;
                    case 2:
                        Frontcolor = !Frontcolor && !Backcolor;
                        break;
                    case 3:
                        Backcolor = !Backcolor && !Frontcolor;
                        break;
                    case 4:
                        NoSmoke = !NoSmoke;
                        break;
                    case 5:
                        Wireframe = !Wireframe;
                        break;
                    case 6:
                        Crosshair--;
                        if (Crosshair < 0)
                            Crosshair++;
                        break;
                    case 7:
                        WallHack = !WallHack;
                        break;
                    case 8:
                        LTrippin = !LTrippin;
                        break;
                    }
                }
            }
}

Код:
#pragma once
#include < Windows.h>
#include < Iostream>
#include < Stdio.h>
#include < Fstream>
#include < D3dx9.h>
#include < D3d9.h>
#include < psapi.h>
 
static ID3DXFont * m_pFont1 = NULL;
static ID3DXLine * XLine = NULL;
 
#define d3dColorRed D3DCOLOR_XRGB( 255, 0, 0 )
#define d3dColorBlue D3DCOLOR_XRGB( 0, 0, 255 )
#define d3dColorYellow D3DCOLOR_XRGB( 255, 255, 0 )
#define d3dColorGreen D3DCOLOR_XRGB(0, 255, 0 )
#define d3dColorLightBlue D3DCOLOR_XRGB(0, 191, 255 )
#define d3dColorBlack D3DCOLOR_XRGB(0, 0, 0 )
#define d3dColorWhite D3DCOLOR_XRGB( 255, 255, 255 )
#define d3dColorGrey D3DCOLOR_ARGB( 160 ,160, 160, 160 )
 
const BYTE red[58] = { //
    0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00
};
 
const BYTE orange[58] = { //
    0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA5, 0xFF, 0x00
};
 
const BYTE bGreen[60] = //
{
    0x42, 0x4D, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
    0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x20, 0xA0, 0x00, 0x00, 0xFF, 0xFF
};
 
const BYTE bBlue[60] = //
{
    0x42, 0x4D, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
    0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0xFF, 0x00, 0x00, 0x00, 0x00, 0x00
};
 
const BYTE bWhite[58] = //
{
    0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
    0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0xFF, 0xFF, 0xFF, 0x00
};
 
const BYTE bYellow[60] = //
{
    0x42, 0x4D, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
    0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
};
 
const BYTE bPink[58] = //
{
    0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
    0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x80, 0x00, 0xFF, 0x00
};
 
const BYTE bTur[60] = //
{
    0x42, 0x4D, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
    0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00
};
 
const BYTE bBlack[58] = { //
    0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
 
class cDirectClass
{
public:
 
    cDirectClass(void)
    {
    }
 
    ~cDirectClass(void)
    {
    }
 
    void InitObjects(IDirect3DDevice9 * pDevice);
    void DrawLine(float StartX, float StartY, float EndX, float EndY, D3DCOLOR dColor);
    void FillRGBA(float fPosX, float fPosY, float fWidth, float fHeight, D3DCOLOR dColor);
    void DrawString(ID3DXFont * pFont, int nPosX, int nPosY, D3DCOLOR dColor, const char * cFmt, ...);
};
 
extern cDirectClass cDirectX;
 

ParinovYT

GlobalModerator
Сообщения
903
Реакции
671
Если надо могу дллку подкрепить
 
kaspersky keys
Верх