Passo 1: Obtenção e Extração do EasyX

Baixe o instalador do EasyX (por exemplo, EasyX_20220901.exe). Renomeie o arquivo para a extensão .7z e extraia o conteúdo para uma pasta local.

Passo 2: Identificação do Diretório do Visual Studio

Navegue até o diretório de instalação do Visual Studio 2022. Um caminho comum é:

\Microsoft Visual Studio\2022\Professional\VC\Auxiliary\VS

Passo 3: Cópia dos Arquivos Necessários

Dentro da pasta extraída, localize as subpastas include e lib. Copie seus conteúdos para os respectivos diretórios dentro da pasta de instalação do Visual Studio, conforme a estrutura de pastas do VS.

Passo 4: Verificação da Instalação com um Exemplo Gráfico

Compile e execute o seguinte código C++ para confirmar a integração. O exemplo cria uma esfera 3D com pontos aleatórios, aplica rotações e a projeta na tela usando perspectiva.

// Demonstração: Esfera 3D Rotativa com EasyX
// Ambiente: Visual Studio 2022, EasyX

#include <graphics.h>
#include <ctime>
#include <cmath>
#include <conio.h>

#define TOTAL_PONTOS 5000
#define VALOR_PI 3.1415926536

// Estrutura para representar um ponto no espaço 3D
struct Ponto3D {
    double coordX;
    double coordY;
    double coordZ;
};

Ponto3D pontos[TOTAL_PONTOS];
double zObservador = 3.0;

// Gera pontos aleatórios na superfície de uma esfera
void GerarPontos() {
    std::srand(static_cast<unsigned>(std::time(nullptr)));
    for (int i = 0; i < TOTAL_PONTOS; ++i) {
        pontos[i].coordZ = 2.0 * std::rand() / RAND_MAX - 1.0;
        double projecaoXY = std::sqrt(1.0 - pontos[i].coordZ * pontos[i].coordZ);
        double angulo = 2 * VALOR_PI * std::rand() / RAND_MAX;
        pontos[i].coordX = std::cos(angulo) * projecaoXY;
        pontos[i].coordY = std::sin(angulo) * projecaoXY;
    }
}

// Rotaciona um ponto em torno do eixo X
void RotacionarX(Ponto3D &ponto, double angulo) {
    double yTemp = ponto.coordY;
    ponto.coordY = ponto.coordY * std::cos(angulo) + ponto.coordZ * std::sin(-angulo);
    ponto.coordZ = yTemp * std::sin(angulo) + ponto.coordZ * std::cos(angulo);
}

// Rotaciona um ponto em torno do eixo Y
void RotacionarY(Ponto3D &ponto, double angulo) {
    double xTemp = ponto.coordX;
    ponto.coordX = ponto.coordX * std::cos(angulo) + ponto.coordZ * std::sin(-angulo);
    ponto.coordZ = xTemp * std::sin(angulo) + ponto.coordZ * std::cos(angulo);
}

// Rotaciona um ponto em torno do eixo Z
void RotacionarZ(Ponto3D &ponto, double angulo) {
    double xTemp = ponto.coordX;
    ponto.coordX = ponto.coordX * std::cos(angulo) + ponto.coordY * std::sin(-angulo);
    ponto.coordY = xTemp * std::sin(angulo) + ponto.coordY * std::cos(angulo);
}

// Projeta um ponto 3D em coordenadas 2D com perspectiva
POINT ProjetarPonto(Ponto3D ponto) {
    POINT ponto2D;
    double fatorPerspectiva = zObservador / (zObservador - ponto.coordZ);
    ponto2D.x = static_cast<int>(ponto.coordX * fatorPerspectiva * 200 + 0.5) + 320;
    ponto2D.y = static_cast<int>(ponto.coordY * fatorEspectiva * 200 + 0.5) + 240;
    return ponto2D;
}

// Atraso preciso em milissegundos
void AtrasoMs(int ms) {
    static clock_t marcador = clock();
    marcador += ms * CLOCKS_PER_SEC / 1000;
    if (clock() > marcador)
        marcador = clock();
    else
        while (clock() < marcador)
            Sleep(1);
}

// Gerencia o buffer de vídeo diretamente
class GerenciadorGrafico {
private:
    DWORD* bufferPixels;
    int largura;
    int altura;

public:
    GerenciadorGrafico(int w, int h) : largura(w), altura(h) {
        initgraph(w, h);
        BeginBatchDraw();
        bufferPixels = GetImageBuffer();
    }

    ~GerenciadorGrafico() {
        EndBatchDraw();
        closegraph();
    }

    void DesenharPonto(int x, int y, COLORREF cor) {
        if (x >= 0 && x < largura && y >= 0 && y < altura)
            bufferPixels[y * largura + x] = BGR(cor);
    }

    void AtualizarTela() {
        FlushBatchDraw();
    }
};

int main() {
    GerenciadorGrafico dispositivo(640, 480);
    GerarPontos();

    while (!_kbhit()) {
        cleardevice();
        for (int i = 0; i < TOTAL_PONTOS; ++i) {
            RotacionarX(pontos[i], VALOR_PI / 800);
            RotacionarY(pontos[i], VALOR_PI / 600);
            RotacionarZ(pontos[i], VALOR_PI / 400);

            int tomCinza = static_cast<int>(pontos[i].coordZ * 100) + 155;
            POINT p2D = ProjetarPonto(pontos[i]);
            dispositivo.DesenharPonto(p2D.x, p2D.y, RGB(tomCinza, tomCinza, tomCinza));
        }
        dispositivo.AtualizarTela();
        AtrasoMs(10);
    }
    return 0;
}