Использование текста в анимации: Не существует подходящей функции преобразования из "Gdiplus::Font" в "Gdiplus::Font *"

@xamelione25 · Регистрация: 04.02.2013

Author24 — интернет-сервис помощи студентам

Ошибка в 290 строке:
Не существует подходящей функции преобразования из "Gdiplus::Font" в "Gdiplus::Font *"
Не понятно то, почему на скрине в пояснении-ссылке показано Font*, а в 160 строке нету звездочки (стоит просто Font).
Цель этого всего кода: мне нужно чтобы текст перемещался совместно с выше-прописанными элементами.
Если убрать эти строки, то программа запускается нормально, но текст остается на месте.

C++

#include <windows.h>
#include <windowsX.h>
#include <tchar.h>
#include <gdiplus.h>
#include <vector>
#include <gdiplusgraphics.h>    
#include <gdiplusheaders.h>
#include "Math.h"
#include <string>
#define ID_TIMER    1
#pragma comment(lib,"Gdiplus.lib")
 
 
using namespace Gdiplus;
using namespace std;
 
Bitmap* imgTextureMetall;
HWND hWnd = NULL;
MSG  msg;
BOOL bRet;
ULONG_PTR           gdiToken;
GdiplusStartupInput gdiStartupInput;
HDC  hdc;
PAINTSTRUCT ps;
//Bitmap* imgTrain = NULL;
 
/* -- ANIMATION DATA --*/
// массив точек, характеризующие ключевые и промежуточные кадры
std::vector<Gdiplus::PointF> startKeyVector;
Gdiplus::PointF* A;
Gdiplus::PointF* B;
Gdiplus::PointF* P;
Bitmap* imgRoad;
Image* gifTrain;
UINT framesCount;
UINT indexCurrentFrame;
int stage = 0;              // переменная для интерполяции
float t = 0.f;              // параметр для интерполяции
float k_sizeX = 0.6;            // коэффициент масштабирования
float k_sizeY = 0.6;            // коэффициент масштабирования
PointF sizeWheel(70, 70);
PointF sizeBigWheel(120, 120);
std::vector<Gdiplus::Font> startKeyVector1;
Gdiplus::Font* A;
Gdiplus::Font* B;
Gdiplus::Font* P;
/* ----------------------------------------------------- */
LRESULT CALLBACK MyWindowsProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
void OnDestroy(HWND hwnd);
void OnDisplay(HDC hdc);
void CopyArrToVector(PointF _array[], std::vector<Gdiplus::PointF>& _vector, int _size);
void CopyArrToVector1(Font _array[], std::vector<Gdiplus::Font>& _vector, int _size);
void CopyPointFToVector(PointF _point, std::vector<Gdiplus::PointF>& _vector);
PointF Tween(const PointF& A, const PointF& B, float t);
void Tween(const PointF* A, const PointF* B, PointF* P, int count, float t);
void IncrementT(int framesCount);
void OnDisplay_Wheels(Graphics& drawingBoard, PointF centerPointWheel, PointF sizeWheel, int wheels, float gap,
    SolidBrush& Brush1, Pen& Pen1, SolidBrush& Brush2, Pen& Pen2, std::vector<Gdiplus::PointF>& Vector);
 
/* ----------------------------------------------------- */
int WINAPI _tWinMain(HINSTANCE hInctance, HINSTANCE, LPTSTR lpszCmdLine, int nCmdShow) {
    WNDCLASSEX wndcls = { sizeof(WNDCLASSEX) };
    wndcls.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    wndcls.lpfnWndProc = MyWindowsProc;
    wndcls.hInstance = hInctance;
    wndcls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndcls.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndcls.hbrBackground = NULL; // (HBRUSH)GetStockObject(WHITE_BRUSH); // извлекает дескриптор предопределенного пера из wingdi.h
    wndcls.lpszMenuName = NULL;
    wndcls.lpszClassName = TEXT("MainWindow");
    wndcls.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
 
    if (0 == RegisterClassEx(&wndcls)) {
        return -1;
    }
 
    Status stRet = GdiplusStartup(&gdiToken, &gdiStartupInput, NULL);
    imgRoad = new Bitmap(L"road.jpg");
 
    hWnd = CreateWindowEx(0, TEXT("MainWindow"), TEXT("KGG3_animation"), WS_OVERLAPPEDWINDOW,
        50, 50, 1400, 800, NULL, NULL, hInctance, NULL);
    if (hWnd == NULL) {
        return -1;
    }
    ShowWindow(hWnd, nCmdShow);
    //imgTrain = new Bitmap(L"my_train.jpg");
    imgTextureMetall = new Bitmap(L"texture.jpeg");
    //UpdateWindow(hWnd);
 
    if (Ok == stRet) {
        while (GetMessage(&msg, NULL, 0, 0))
        {
            if (bRet == -1) {
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    GdiplusShutdown(gdiToken);
    return (int)msg.wParam;
}
 
/* ----------------------------------------------------- */
LRESULT CALLBACK MyWindowsProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
 
    case WM_ERASEBKGND:                             // подавить мерцание
        return 1;
 
    case WM_CREATE:
        gifTrain = Image::FromFile(L"parovoz.gif");
        indexCurrentFrame = 0;
        if (NULL != gifTrain) {
            framesCount = gifTrain->GetFrameCount(&FrameDimensionTime);
        }
        SetTimer(hWnd, ID_TIMER, 40, NULL);         // 3-ий параметр - частота изменения кадров 40мс; 4-ый - функция обратного вызова. 
        return 0;                                   //Если NULL, то посылается сообщение WM_TIMER
 
    case WM_TIMER:
        indexCurrentFrame = (indexCurrentFrame + 1) % framesCount;
        IncrementT(framesCount);
        gifTrain->SelectActiveFrame(&FrameDimensionTime, indexCurrentFrame);
        InvalidateRect(hWnd, NULL, FALSE);
        return 0;
 
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);        // получили дескриптор устройства по hWnd
        OnDisplay(hdc);
        EndPaint(hWnd, &ps);
        return 0;
 
        HANDLE_MSG(hWnd, WM_DESTROY, OnDestroy);
    }
 
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
 
void IncrementT(int framesCount) {
    if (t < 0) {
        stage = 0;
        t = 0;
    }
    else {
        t += (float)1 / framesCount * 3;
        if (t > 1) {
            t = 0;
            stage += 1;
        }
    }
}
void OnDestroy(HWND hwnd) {
    PostQuitMessage(0);
}
void CopyArrToVector(PointF _array[], std::vector<Gdiplus::PointF>& _vector, int _size) {
    for (int i = 0; i < _size; i++) {
        _vector.push_back(_array[i]);
    }
}
void CopyArrToVector1(Font _array[], std::vector<Gdiplus::Font>& _vector, int _size) {
    for (int i = 0; i < _size; i++) {
        _vector.push_back(_array[i]);
    }
}
void CopyPointFToVector(PointF _point, std::vector<Gdiplus::PointF>& _vector) {
    _vector.push_back(_point);
}
PointF Tween(const PointF& A, const PointF& B, float t) {
    return PointF(A.X * (1.f - t) + B.X * t, A.Y * (1.f - t) + B.Y * t);
}
void Tween(const PointF* A, const PointF* B, PointF* P, int count, float t) {
    for (int i = 0; i < count; ++i) {
        P[i] = Tween(A[i], B[i], t);
    }
}
void OnDisplay_Wheels(Graphics& drawingBoard, PointF centerPointWheel, PointF sizeWheel, int wheels, float gap,
    SolidBrush& Brush1, Pen& Pen1, SolidBrush& Brush2, Pen& Pen2, std::vector<Gdiplus::PointF>& Vector) {
    for (int i = 0; i < wheels; i++) {
        Rect rectWheel(centerPointWheel.X - sizeWheel.X / 2, centerPointWheel.Y - sizeWheel.Y / 2, sizeWheel.X, sizeWheel.Y);
        drawingBoard.FillEllipse(&Brush1, rectWheel);
        drawingBoard.DrawEllipse(&Pen1, rectWheel);
        drawingBoard.FillEllipse(&Brush2,
            float(centerPointWheel.X - sizeWheel.X / 2 * 0.71),
            float(centerPointWheel.Y - sizeWheel.Y / 2 * 0.71),
            sizeWheel.X * 0.71,
            sizeWheel.Y * 0.71);
        drawingBoard.DrawEllipse(&Pen2,
            float(centerPointWheel.X - sizeWheel.X / 2 * 0.71),
            float(centerPointWheel.Y - sizeWheel.Y / 2 * 0.71),
            sizeWheel.X * 0.71,
            sizeWheel.Y * 0.71);
        if (stage == 0 && t == 0) {
            Vector.push_back(centerPointWheel);
            if (i == 0) centerPointWheel.X += gap;
        }
    }
}
void OnDisplay(HDC hdc) {
    Graphics g(hdc);
    Rect rectInstance;
    g.GetVisibleClipBounds(&rectInstance);
    Bitmap backBuffer(rectInstance.Width, rectInstance.Height, &g);
    Graphics drawingBoard(&backBuffer);
 
    drawingBoard.Clear(Color::White);
    //drawingBoard.DrawImage(imgRoad, rectInstance);
    drawingBoard.SetSmoothingMode(SmoothingModeAntiAlias);
 
    //Graphics drawingBoard(hdc);
    //drawingBoard.Clear(Color::White);
    //drawingBoard.SetSmoothingMode(SmoothingModeAntiAlias);    
 
    Matrix affinMatrix;
 
    /*-- общие атрибуты --*/
    SolidBrush WhiteBrush(Color::White);
    SolidBrush blackBrush(Color(20, 20, 20));
    SolidBrush DarkGrayBrush(Color(108, 108, 108));
    SolidBrush BlueBrush(Color(56, 44, 144));
    SolidBrush SaddleBrownBrush(Color(128, 68, 4));
    SolidBrush BrunBrown(Color(68, 36, 4));
    SolidBrush DarkTurquoiseBrown(Color(0, 206, 209));
    SolidBrush DarkCyanBrown(Color(0, 139, 139));
    HatchBrush hatchBrush(HatchStyleDarkVertical, Color::Silver, Color::Wheat);
    TextureBrush textureBrush(imgTextureMetall);
    Pen BrushPen(Color(68, 36, 4));
    Pen blackPen(Color(0, 0, 0));
    Pen BluePen(Color(56, 44, 144));
    Pen texturePen(&textureBrush, 15);
    Color colorWhite(Color::White);
    Color windowsColors[4] = {
        Color::MediumTurquoise,
        Color::SkyBlue,
        Color::MediumTurquoise,
        Color::SteelBlue,
    };
 
    //линейный градиент
    LinearGradientBrush lgb(Rect(200, 200, 300, 150), Color::White, Color::White, 45.f);
    Color colors[3] = { Color(255, 0, 255, 255), Color(255, 0, 155, 155), Color(255, 0, 0, 0) };
    float pos[3] = { 0.0f, 0.3f, 1.0f };
 
    //составное перо
    Pen CompPen(Color::Black, 6.f);
    float comp[6] = { 0.0f, 0.2f, 0.3f, 0.7f, 0.8f, 1.0f };
    CompPen.SetCompoundArray(comp, 6);
    WrapMode wrapMode = WrapModeTile;
    int n = 4;
    int wheels = 2;         // кол-во колес
 
    // дорога
    drawingBoard.DrawLine(&texturePen, 0, 488, 1400, 488);
    RectF rectim(100.f, 520.f, 400.f, 200.f);
    drawingBoard.DrawImage(gifTrain, rectim);
 
    /* ---------------- ПЕРВЫЙ КЛЮЧЕВОЙ КАДР ---------------- */
    if (stage == 0 && t == 0) {
        /*-- левая половина рисунка --*/
        //голубой корпус
        PointF points[4] = { PointF(190, 410), PointF(150, 310), PointF(450, 310), PointF(400, 410) };
        // +4
        CopyArrToVector(points, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
        drawingBoard.DrawPolygon(&blackPen, points, 4);
 
        //серая антенна
        PointF pointsa[4] = { PointF(350, 300), PointF(510, 140), PointF(513, 143), PointF(355, 300) };
        // +4
        CopyArrToVector(pointsa, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkGrayBrush, pointsa, 4);
        drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
        drawingBoard.DrawCurve(&CompPen, pointsa, 4);
 
        //оконтовочный бортик (голубой)
        PointF pointsb[4] = { PointF(120, 300), PointF(480, 300), PointF(480, 320), PointF(120, 320) };
        // +4
        CopyArrToVector(pointsb, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkCyanBrown, pointsb, 4);
        drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
 
        //линейный градиент
        PointF WindowForwDoor[3] = { PointF(150,310), PointF(295,410), PointF(190,410) };
        PointF WindowBackDoor[3] = { PointF(450,310), PointF(400,410), PointF(295,410) };
        lgb.SetInterpolationColors(colors, pos, 3);
        drawingBoard.FillPolygon(&lgb, WindowForwDoor, 3);
        drawingBoard.FillPolygon(&lgb, WindowBackDoor, 3);
 
        /*-- вывод текста --*/
        Font font(L"Courier", 25.f, FontStyleBold);
        drawingBoard.DrawString(L"СССР", -1, &font, PointF(250, 360), &SaddleBrownBrush);
        CopyArrToVector1(font, startKeyVector1, 4);
        drawingBoard.FillPolygon(&lgb, WindowForwDoor, 3);
        drawingBoard.FillPolygon(&lgb, WindowBackDoor, 3);
 
        // колеса
        int wheel = 4; // количество колес
        int gap = 75; // расстояние между колесами
        Rect rectWheel(150, 400, 70, 70);
        for (int i = 0; i < wheel; i++)
        {
            drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
            drawingBoard.FillEllipse(&WhiteBrush, rectWheel.X + 14, rectWheel.Y + 14, rectWheel.Width - 28, rectWheel.Height - 28);
            drawingBoard.FillEllipse(&BrunBrown, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
            drawingBoard.DrawEllipse(&BrushPen, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
            rectWheel.X += gap;
        }
 
        P = new Gdiplus::PointF[startKeyVector.size()];
        A = new Gdiplus::PointF[startKeyVector.size()];
        B = new Gdiplus::PointF[startKeyVector.size()];
        for (int i = 0; i < startKeyVector.size(); ++i) {
            A[i] = startKeyVector[i];
            B[i] = startKeyVector[i];
        }
 
        affinMatrix.Translate(300.f, -100.f);
        affinMatrix.Scale(k_sizeX, k_sizeY);
        affinMatrix.TransformPoints(B, startKeyVector.size());
        g.DrawImage(&backBuffer, rectInstance);
    }
    else
        //----------------------------------------------------------------------------- stage == 0 && t <= 1.f
        if (stage == 0 && t <= 1) {
            Tween(A, B, P, startKeyVector.size(), t);
            int _i = 0;
            PointF points[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            //серая антенна
            PointF pointsa[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
            drawingBoard.DrawCurve(&CompPen, pointsa, 4);
 
            //оконтовочный бортик (голубой)
            PointF pointsb[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
 
            //линейный градиент
            PointF WindowForwDoor[3] = { PointF(150,310), PointF(295,410), PointF(190,410) };
            PointF WindowBackDoor[3] = { PointF(450,310), PointF(400,410), PointF(295,410) };
            lgb.SetInterpolationColors(colors, pos, 3);
            drawingBoard.FillPolygon(&lgb, WindowForwDoor, 3);
            drawingBoard.FillPolygon(&lgb, WindowBackDoor, 3);
 
            /*-- вывод текста --*/
            Font font(L"Courier", 25.f, FontStyleBold);
            drawingBoard.DrawString(L"СССР", -1, &font, PointF(250, 330), &SaddleBrownBrush);
 
 
            // колеса
            int wheel = 4; // количество колес
            int gap = 75; // расстояние между колесами
            Rect rectWheel(150, 400, 70, 70);
            for (int i = 0; i < wheel; i++)
            {
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, rectWheel.X + 14, rectWheel.Y + 14, rectWheel.Width - 28, rectWheel.Height - 28);
                drawingBoard.FillEllipse(&BrunBrown, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
                rectWheel.X += gap;
            }
            _i += 2;
 
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* ---------------- ВТОРОЙ КЛЮЧЕВОЙ КАДР ---------------- */
    //----------------------------------------------------------------------------- stage == 1 && t <= 1.f
        else if (stage == 1 && 0 <= t <= 1) {
            int _i = 0;
            if (t == 0) {
                for (int i = 0; i < startKeyVector.size(); ++i) {
                    A[i] = B[i];
                }
                affinMatrix.Translate(300.f, 300.f);
                affinMatrix.TransformPoints(B, startKeyVector.size());
            }
            Tween(A, B, P, startKeyVector.size(), t);
 
            PointF points[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            // серая антенна
            PointF pointsa[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
            drawingBoard.DrawCurve(&CompPen, pointsa, 4);
 
            //оконтовочный бортик (голубой)
            PointF pointsb[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
 
            //линейный градиент
            PointF WindowForwDoor[3] = { PointF(150,310), PointF(295,410), PointF(190,410) };
            PointF WindowBackDoor[3] = { PointF(450,310), PointF(400,410), PointF(295,410) };
            lgb.SetInterpolationColors(colors, pos, 3);
            drawingBoard.FillPolygon(&lgb, WindowForwDoor, 3);
            drawingBoard.FillPolygon(&lgb, WindowBackDoor, 3);
 
            /*-- вывод текста --*/
            Font font(L"Courier", 25.f, FontStyleBold);
            drawingBoard.DrawString(L"СССР", -1, &font, PointF(250, 330), &SaddleBrownBrush);
 
            // колеса
            int wheel = 4; // количество колес
            int gap = 75; // расстояние между колесами
            Rect rectWheel(150, 400, 70, 70);
            for (int i = 0; i < wheel; i++)
            {
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, rectWheel.X + 14, rectWheel.Y + 14, rectWheel.Width - 28, rectWheel.Height - 28);
                drawingBoard.FillEllipse(&BrunBrown, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
                rectWheel.X += gap;
            }
            _i += 2;
 
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* ---------------- ТРЕТИЙ КЛЮЧЕВОЙ КАДР ---------------- */
    //----------------------------------------------------------------------------- stage == 2 && t <= 1.f
        else if (stage == 2 && 0 <= t <= 1) {
            int _i = 0;
            if (t == 0) {
                //float k_sizeX = 1.5;
                //float k_sizeY = 1.5;
                for (int i = 0; i < startKeyVector.size(); ++i) {
                    A[i] = B[i];
                }
                PointF rotateCenter(850.f, 300.f);
                //affinMatrix.Shear(2, 0);
                affinMatrix.Translate(250, 0);
                affinMatrix.RotateAt(90, rotateCenter);
                affinMatrix.TransformPoints(B, startKeyVector.size());
            }
            Tween(A, B, P, startKeyVector.size(), t);
            PointF points[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            // серая антенна
            PointF pointsa[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
            drawingBoard.DrawCurve(&CompPen, pointsa, 4);
 
            //оконтовочный бортик (голубой)
            PointF pointsb[4] = {
                PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y),
                PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y)
            };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
 
            //линейный градиент
            PointF WindowForwDoor[3] = { PointF(150,310), PointF(295,410), PointF(190,410) };
            PointF WindowBackDoor[3] = { PointF(450,310), PointF(400,410), PointF(295,410) };
            lgb.SetInterpolationColors(colors, pos, 3);
            drawingBoard.FillPolygon(&lgb, WindowForwDoor, 3);
            drawingBoard.FillPolygon(&lgb, WindowBackDoor, 3);
 
            /*-- вывод текста --*/
            Font font(L"Courier", 25.f, FontStyleBold);
            drawingBoard.DrawString(L"СССР", -1, &font, PointF(250, 330), &SaddleBrownBrush);
 
            // колеса
            int wheel = 4; // количество колес
            int gap = 75; // расстояние между колесами
            Rect rectWheel(150, 400, 70, 70);
            for (int i = 0; i < wheel; i++)
            {
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, rectWheel.X + 14, rectWheel.Y + 14, rectWheel.Width - 28, rectWheel.Height - 28);
                drawingBoard.FillEllipse(&BrunBrown, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
                rectWheel.X += gap;
            }
            _i += 2;
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* ---------------------- КОНЕЦ ------------------------- */
        else {
            t = -1;
            k_sizeX = 0.6; k_sizeY = 0.6;
            startKeyVector.clear();
            affinMatrix.Reset();
        }
}

@Ygg · 04.02.2021, 17:52

Сообщение от xamelione25

Не понятно то, почему на скрине в пояснении-ссылке показано Font*, а в 160 строке нету звездочки (стоит просто Font).

Так квадратные скобочки за именем аргумента превращают тип в указатель.

C++

1	void CopyArrToVector1(Font _array[], std::vector<Gdiplus::Font>& _vector, int _size)

Функция требует на вход указатель на первый элемент массива, а вы ей пытаетесь вместо адреса передать сам элемент.

C++

1 2	Font font(L"Courier", 25.f, FontStyleBold); CopyArrToVector1(font, startKeyVector1, 4);

@xamelione25 · 04.02.2021, 17:58 **[ТС]**

Ygg, я может не сильно хорошо понимаю....

я пытался сделать и так как вы подсказали

C++

1	void CopyArrToVector1(Font _array(), std::vector<Gdiplus::Font>& _vector, int _size);

и так:

C++

1	void CopyArrToVector1(Font* _array[], std::vector<Gdiplus::Font>& _vector, int _size);

но у меня тогда вытекает другая ошибка: см.скрин

или нужно что-то другое исправить?

@xamelione25 · 04.02.2021, 18:02 **[ТС]**

Ygg, нашел еще один косяк - посыпались ошибки
отсутствуют экземпляры перегруженная функция ... соответствующие списку аргументов

@Ygg · 04.02.2021, 18:25

Сообщение от xamelione25

или нужно что-то другое исправить?

Можно оставить квадратные скобки, как и было.
Но при вызове добавить амперсант к переменной для взятия адреса.

C++

1 2	Font font(L"Courier", 25.f, FontStyleBold); CopyArrToVector1(&font, startKeyVector1, 4);

отсутствуют экземпляры перегруженная функция

Есть набор функций Graphics::FillPolygon. Функции отличаются друг от друга набором аргументов. Нет такого варианта функции, где вторым аргументом передавался бы фонт. Передача фонта для рисования линий сама по себе выглядит несколько странно.

@xamelione25 · 04.02.2021, 18:52 **[ТС]**

Ygg, а как поступить с 292 и 293 строками с FillPolygon???

Добавлено через 24 минуты
Ygg, может быть FillPolygon чем-то заменить??? Только вопрос в том ...чем заменить...я не знаю)))

@xamelione25 · 08.02.2021, 22:19 **[ТС]**

Ygg, подскажите а как повернуть эллипс, у меня почему-то с помощью RotateTransform вообще не получается никак повернуть его

Кликните здесь для просмотра всего текста

C++

...
int WINAPI _tWinMain(HINSTANCE hInctance, HINSTANCE, LPTSTR lpszCmdLine, int nCmdShow) {
    WNDCLASSEX wndcls = { sizeof(WNDCLASSEX) };
    wndcls.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    wndcls.lpfnWndProc = MyWindowsProc;
    wndcls.hInstance = hInctance;
    wndcls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndcls.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndcls.hbrBackground = NULL; // (HBRUSH)GetStockObject(WHITE_BRUSH); // извлекает дескриптор предопределенного пера из wingdi.h
    wndcls.lpszMenuName = NULL;
    wndcls.lpszClassName = TEXT("MainWindow");
    wndcls.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    if (0 == RegisterClassEx(&wndcls)) {
        return -1;
    }
 
    Status stRet = GdiplusStartup(&gdiToken, &gdiStartupInput, NULL);
    imgRoad = new Bitmap(L"road.jpg");
 
    hWnd = CreateWindowEx(0, TEXT("MainWindow"), TEXT("KGG3_animation"), WS_OVERLAPPEDWINDOW, 50, 50, 1400, 800, NULL, NULL, hInctance, NULL);
    if (hWnd == NULL) {
        return -1;
    }
    ShowWindow(hWnd, nCmdShow);
    //imgTrain = new Bitmap(L"my_train.jpg");
    imgTextureMetall = new Bitmap(L"texture.jpeg");
    //UpdateWindow(hWnd);
 
    if (Ok == stRet) {
        while (GetMessage(&msg, NULL, 0, 0))
        {
            if (bRet == -1) {
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    GdiplusShutdown(gdiToken);
    return (int)msg.wParam;
}
 
/* ------------------------- */
LRESULT CALLBACK MyWindowsProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
 
    case WM_ERASEBKGND: // подавить мерцание
        return 1;
 
    case WM_CREATE:
        gifTrain = Image::FromFile(L"Lunohod.gif");
        indexCurrentFrame = 0;
        if (NULL != gifTrain) {
            framesCount = gifTrain->GetFrameCount(&FrameDimensionTime);
        }
        SetTimer(hWnd, ID_TIMER, 50, NULL);  // 3-ий параметр - частота изменения кадров 40мс; 4-ый - функция обратного вызова. 
        return 0; //Если NULL, то посылается сообщение WM_TIMER
 
    case WM_TIMER:
        indexCurrentFrame = (indexCurrentFrame + 1) % framesCount;
        IncrementT(framesCount);
        gifTrain->SelectActiveFrame(&FrameDimensionTime, indexCurrentFrame);
        InvalidateRect(hWnd, NULL, FALSE);
        return 0;
 
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps); // получили дескриптор устройства по hWnd
        OnDisplay(hdc);
        EndPaint(hWnd, &ps);
        return 0;
 
        HANDLE_MSG(hWnd, WM_DESTROY, OnDestroy);
    }
 
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
void IncrementT(int framesCount) {
    if (t < 0) {
        stage = 0;
        t = 0;
    }
    else {
        t += (float)1 / framesCount * 3;
        if (t > 1) {
            t = 0;
            stage += 1;
        }
    }
}
void OnDestroy(HWND hwnd) {
    PostQuitMessage(0);
}
void CopyArrToVector(PointF _array[], std::vector<Gdiplus::PointF>& _vector, int _size) {
    for (int i = 0; i < _size; i++) {
        _vector.push_back(_array[i]);
    }
}
void CopyPointFToVector(PointF _point, std::vector<Gdiplus::PointF>& _vector) {
    _vector.push_back(_point);
}
PointF Tween(const PointF& A, const PointF& B, float t) {
    return PointF(A.X * (1.f - t) + B.X * t, A.Y * (1.f - t) + B.Y * t);
}
void Tween(const PointF* A, const PointF* B, PointF* P, int count, float t) {
    for (int i = 0; i < count; ++i) {
        P[i] = Tween(A[i], B[i], t);
    }
}
void OnDisplay_Wheels(Graphics& drawingBoard, PointF centerPointWheel, PointF sizeWheel, int wheels, float gap, SolidBrush& Brush1, Pen& Pen1, SolidBrush& Brush2, Pen& Pen2, std::vector<Gdiplus::PointF>& Vector) {
 
}
 
void RotateTransform(float angle)
{
}
 
void RotateTransformAngle(float angle)
{
}
 
void RotateTransform(float angle, MatrixOrder order)
{
}
 
void OnDisplay(HDC hdc) {
    Graphics g(hdc);
    Rect rectInstance;
    g.GetVisibleClipBounds(&rectInstance);
    Bitmap backBuffer(rectInstance.Width, rectInstance.Height, &g);
    Graphics drawingBoard(&backBuffer);
    drawingBoard.Clear(Color::White);
    drawingBoard.SetSmoothingMode(SmoothingModeAntiAlias);
    Matrix affinMatrix;
 
    /*-- общие атрибуты --*/
    SolidBrush greenBrush(Color(0, 180, 0));
    SolidBrush yellowBrush(Color::Yellow);
    SolidBrush orangeBrush(Color::Orange);
    SolidBrush redBrush(Color(255, 50, 50));
    SolidBrush blackBrush(Color(20, 20, 20));
    HatchBrush hatchBrush(HatchStyleDarkVertical, Color::Silver, Color::Wheat);
    TextureBrush textureBrush(imgTextureMetall);
    Pen greenPen(Color(0, 150, 0));
    Pen redPen(Color(255, 0, 0));
    Pen blackPen(Color(0, 0, 0));
    Pen orangePen(Color::Orange);
    Pen yellowPen(Color::Yellow);
    Pen WhitePen(Color(255, 255, 255));
    Pen texturePen(&textureBrush, 15);
    Color colorWhite(Color::White);
    SolidBrush WhiteBrush(Color::White);
    SolidBrush DarkGrayBrush(Color(108, 108, 108));
    SolidBrush BlueBrush(Color(56, 44, 144));
    SolidBrush SaddleBrownBrush(Color(128, 68, 4));
    SolidBrush BrunBrown(Color(68, 36, 4));
    SolidBrush DarkTurquoiseBrown(Color(0, 206, 209));
    SolidBrush DarkCyanBrown(Color(0, 139, 139));
    Pen BrushPen(Color(68, 36, 4));
    Pen BluePen(Color(56, 44, 144));
    Color windowsColors[4] = {
        Color::MediumTurquoise,
        Color::SkyBlue,
        Color::MediumTurquoise,
        Color::SteelBlue,
    };
    int n = 4;
    int wheels = 4; // кол-во колес
 
    //линейный градиент
    LinearGradientBrush pthGrBrush(Rect(200, 200, 300, 150), Color::White, Color::White, 45.f);
    LinearGradientBrush pthGrBrush2(Rect(200, 200, 300, 150), Color::White, Color::White, 45.f);
    Color colors[3] = { Color(255, 0, 255, 255), Color(255, 0, 155, 155), Color(255, 0, 0, 0) };
    float pos[3] = { 0.0f, 0.3f, 1.0f };
    Color colors1[3] = { Color(255, 0, 255, 255), Color(255, 0, 155, 155), Color(255, 0, 0, 0) };
    float pos1[3] = { 0.0f, 0.3f, 1.0f };
 
    //составное перо
    Pen CompPen(Color::Black, 6.f);
    float comp[6] = { 0.0f, 0.2f, 0.3f, 0.7f, 0.8f, 1.0f };
    CompPen.SetCompoundArray(comp, 6);
    WrapMode wrapMode = WrapModeTile;
 
    // дорога
    drawingBoard.DrawLine(&texturePen, 0, 488, 1400, 488);
    RectF rectim(100.f, 520.f, 400.f, 200.f);
    drawingBoard.DrawImage(gifTrain, rectim);
 
    /* ---------------- ПЕРВЫЙ КЛЮЧЕВОЙ КАДР ---------------- */
    if (stage == 0 && t == 0) {
        /*-- левая половина рисунка --*/
 
                // Большой Эллипс
        Matrix* m;
        PointF pointsc(120, 90);
        CopyPointFToVector(pointsc, startKeyVector);
        affinMatrix.RotateAt(1, PointF(pointsc.X, pointsc.Y));
 
        //голубой корпус
        PointF points[4] = { PointF(190, 410), PointF(150, 310), PointF(450, 310), PointF(400, 410) };
        // +4
        CopyArrToVector(points, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
        drawingBoard.DrawPolygon(&blackPen, points, 4);
 
        //оконтовочный бортик (голубой)
        PointF pointsa[4] = { PointF(120, 300), PointF(480, 300), PointF(480, 320), PointF(120, 320) };
        // +4
        CopyArrToVector(pointsa, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkCyanBrown, pointsa, 4);
        drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
 
        //серая антенна
        PointF pointsb[4] = { PointF(350, 300), PointF(510, 140), PointF(513, 143), PointF(355, 300) };
        // +4
        CopyArrToVector(pointsb, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkGrayBrush, pointsb, 4);
        drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
        drawingBoard.DrawCurve(&CompPen, pointsb, 4);
 
        //линейный градиент 1
        PointF windowsPoints[5] = { PointF(190, 410), PointF(150, 310), PointF(295, 410), PointF(450, 310), PointF(400, 410) };
        CopyArrToVector(windowsPoints, startKeyVector, 5);
        // +4
        PointF centerPointWindow(295, 410);  // координаты центра для окна
        // +1
        PathGradientBrush pthGrBrush(windowsPoints, 5); // кисть градиента контура
        pthGrBrush.SetCenterPoint(centerPointWindow);
        pthGrBrush.SetInterpolationColors(colors, pos, 5);
        pthGrBrush.SetSurroundColors(windowsColors, &n);
        drawingBoard.FillPolygon(&pthGrBrush, windowsPoints, 5);
        drawingBoard.DrawPolygon(&blackPen, windowsPoints, 5);
 
        // колеса
        float gap = 75.f; // расстояние между колесами
        PointF centerPointWheel1(190, 440);  // центр колеса
        PointF centerPointWheel2(263, 440);  // центр колеса
        PointF centerPointWheel3(337, 440);  // центр колеса
        PointF centerPointWheel4(410, 440);  // центр колеса
        CopyPointFToVector(centerPointWheel1, startKeyVector);
        CopyPointFToVector(centerPointWheel2, startKeyVector);
        CopyPointFToVector(centerPointWheel3, startKeyVector);
        CopyPointFToVector(centerPointWheel4, startKeyVector);
 
 
 
        // Надпись
        Font font(L"Courier", 25.f, FontStyleBold);
        drawingBoard.DrawString(L"СССР", -1, &font, PointF(250, 330), &SaddleBrownBrush);
 
        P = new Gdiplus::PointF[startKeyVector.size()];
        A = new Gdiplus::PointF[startKeyVector.size()];
        B = new Gdiplus::PointF[startKeyVector.size()];
        for (int i = 0; i < startKeyVector.size(); ++i) {
            A[i] = startKeyVector[i];
            B[i] = startKeyVector[i];
        }
 
        affinMatrix.Translate(300.f, -100.f);
        affinMatrix.Scale(k_sizeX, k_sizeY);
        affinMatrix.TransformPoints(B, startKeyVector.size());
        affinMatrix.TransformPoints(P, startKeyVector.size());
        g.RotateTransform(90);
        g.DrawImage(&backBuffer, rectInstance);
    }
    else
        //----------------------------------------------------------------------------- stage == 0 && t <= 1.f
        if (stage == 0 && t <= 1) {
            Tween(A, B, P, startKeyVector.size(), t);
            int _i = 0;
 
            //Большой Эллипс
            Matrix m;
            PointF pointsc = { PointF(P[_i].X, P[_i].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = 1 - ((1 - k_sizeX) * t);
                float ky = 1 - ((1 - k_sizeY) * t);
                g.RotateTransform(90);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.DrawEllipse(&BrushPen, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                //affinMatrix.RotateAt(0.52, PointF(pointsc[i].X, pointsc[i].Y));
                //drawingBoard.FillPolygon(&SaddleBrownBrush, pointsc, 1);
                //drawingBoard.DrawPolygon(&redPen, pointsc, 1);
            }
            _i += 1;
 
            //голубой корпус
            PointF points[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            //оконтовочный бортик (голубой)
            PointF pointsa[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
 
            //серая антенна
            PointF pointsb[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
            drawingBoard.DrawCurve(&CompPen, pointsb, 4);
 
            //линейный градиент 1
            PointF windowsPoints[5] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y), PointF(P[_i + 4].X, P[_i + 4].Y) };
            _i += 4;
            PointF centerPointWindow(P[_i].X, P[_i].Y); // координаты центра для окна
            _i += 1;
            PathGradientBrush pthGrBrush(windowsPoints, 5); // кисть градиента контура
            pthGrBrush.SetCenterPoint(centerPointWindow);
            pthGrBrush.SetInterpolationColors(colors, pos, 5);
            pthGrBrush.SetSurroundColors(windowsColors, &n);
            drawingBoard.FillPolygon(&pthGrBrush, windowsPoints, 5);
            drawingBoard.DrawPolygon(&blackPen, windowsPoints, 5);
 
            // колеса
            PointF centerPointWheel1[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = 1 - ((1 - k_sizeX) * t);
                float ky = 1 - ((1 - k_sizeY) * t);
                Rect rectWheel(centerPointWheel1[i].X - sizeWheel.X * kx / 2, centerPointWheel1[i].Y - sizeWheel.Y * ky / 2, sizeWheel.X * kx, sizeWheel.Y * ky);
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 3), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 3), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 3), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 3), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 5), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 5), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 5), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 5), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
            }
            _i += 4;
 
 
 
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* ---------------- ВТОРОЙ КЛЮЧЕВОЙ КАДР ---------------- */
    //----------------------------------------------------------------------------- stage == 1 && t <= 1.f
        else if (stage == 1 && 0 <= t <= 1) {
            int _i = 0;
            if (t == 0) {
                for (int i = 0; i < startKeyVector.size(); ++i) {
                    A[i] = B[i];
                }
                affinMatrix.Translate(300.f, 300.f);
                affinMatrix.TransformPoints(B, startKeyVector.size());
            }
            Tween(A, B, P, startKeyVector.size(), t);
 
            //Большой Эллипс
            Matrix m;
            PointF pointsc = { PointF(P[_i].X, P[_i].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = k_sizeX;
                float ky = k_sizeY;
                g.RotateTransform(90);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.DrawEllipse(&BrushPen, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                //drawingBoard.FillPolygon(&DarkCyanBrown, pointsc, 1);
                //drawingBoard.DrawPolygon(&redPen, pointsc, 1);
            }
            _i += 1;
 
            //голубой корпус
            PointF points[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            //оконтовочный бортик (голубой)
            PointF pointsa[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
 
            //серая антенна
            PointF pointsb[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
            drawingBoard.DrawCurve(&CompPen, pointsb, 4);
 
            //линейный градиент 1
            PointF windowsPoints[5] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y), PointF(P[_i + 4].X, P[_i + 4].Y) };
            _i += 4;
            PointF centerPointWindow(P[_i].X, P[_i].Y); // координаты центра для окна
            _i += 1;
            PathGradientBrush pthGrBrush(windowsPoints, 5); // кисть градиента контура
            pthGrBrush.SetCenterPoint(centerPointWindow);
            pthGrBrush.SetInterpolationColors(colors, pos, 5);
            pthGrBrush.SetSurroundColors(windowsColors, &n);
            drawingBoard.FillPolygon(&pthGrBrush, windowsPoints, 5);
            drawingBoard.DrawPolygon(&blackPen, windowsPoints, 5);
 
            // колеса
            PointF centerPointWheel1[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = k_sizeX;
                float ky = k_sizeY;
                Rect rectWheel(centerPointWheel1[i].X - sizeWheel.X * kx / 2, centerPointWheel1[i].Y - sizeWheel.Y * ky / 2, sizeWheel.X * kx, sizeWheel.Y * ky);
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.65), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.65), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.65), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.65), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.4), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.4), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.4), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.4), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
            }
            _i += 4;
 
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* ---------------- ТРЕТИЙ КЛЮЧЕВОЙ КАДР ---------------- */
    //----------------------------------------------------------------------------- stage == 2 && t <= 1.f
        else if (stage == 2 && 0 <= t <= 1) {
            int _i = 0;
            if (t == 0) {
                for (int i = 0; i < startKeyVector.size(); ++i) {
                    A[i] = B[i];
                }
                affinMatrix.Translate(250, 0);
                affinMatrix.RotateAt(90, PointF(850.f, 250.f));
                //affinMatrix.RotateTransform(90);
                affinMatrix.TransformPoints(B, startKeyVector.size());
            }
            Tween(A, B, P, startKeyVector.size(), t);
 
            //Большой Эллипс
            Matrix m;
            PointF pointsc = { PointF(P[_i].X, P[_i].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = k_sizeX;
                float ky = k_sizeY;
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.DrawEllipse(&BrushPen, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                //drawingBoard.FillPolygon(&DarkCyanBrown, pointsc, 1);
                //drawingBoard.DrawPolygon(&redPen, pointsc, 1);
            }
            _i += 1;
 
            //голубой корпус
            PointF points[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            //оконтовочный бортик (голубой)
            PointF pointsa[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
 
            //серая антенна
            PointF pointsb[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
            drawingBoard.DrawCurve(&CompPen, pointsb, 4);
 
            //линейный градиент 1
            PointF windowsPoints[5] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y), PointF(P[_i + 4].X, P[_i + 4].Y) };
            _i += 4;
            PointF centerPointWindow(P[_i].X, P[_i].Y); // координаты центра для окна
            _i += 1;
            PathGradientBrush pthGrBrush(windowsPoints, 5); // кисть градиента контура
            pthGrBrush.SetCenterPoint(centerPointWindow);
            pthGrBrush.SetInterpolationColors(colors, pos, 5);
            pthGrBrush.SetSurroundColors(windowsColors, &n);
            drawingBoard.FillPolygon(&pthGrBrush, windowsPoints, 5);
            drawingBoard.DrawPolygon(&blackPen, windowsPoints, 5);
 
            // колеса
            PointF centerPointWheel1[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = k_sizeX;
                float ky = k_sizeY;
                Rect rectWheel(centerPointWheel1[i].X - sizeWheel.X * kx / 2, centerPointWheel1[i].Y - sizeWheel.Y * ky / 2, sizeWheel.X * kx, sizeWheel.Y * ky);
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.65), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.65), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.65), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.65), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.4), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.4), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.4), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.4), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
            }
            _i += 4;
 
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* ---------------------- КОНЕЦ ------------------------- */
        else {
            t = -1;
            k_sizeX = 0.6; k_sizeY = 0.6;
            startKeyVector.clear();
            affinMatrix.Reset();
        }
}

@Ygg · 09.02.2021, 08:53

xamelione25, нужно изучать имеющиеся возможности, пробовать разные варианты. Я не специалист по GDI+, но минут за 30 вроде как-то повернул элипс: "без труда не выловишь и рыбку из пруда".

C++

#include <windows.h> 
 
#include <gdiplus.h> 
#pragma comment(lib, "Gdiplus")
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void DrawProc(HWND);
 
float g_angle = .0f;
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    ULONG_PTR gdiToken = 0;
    Gdiplus::GdiplusStartupInput gdiStartupInput;
    Gdiplus::GdiplusStartup(&gdiToken, &gdiStartupInput, NULL);
 
    WNDCLASSEX wc = { sizeof(wc) };
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.lpszClassName = TEXT("MyWindowClass");
    if (!RegisterClassEx(&wc))
    {
        MessageBox(NULL, TEXT("Cannot register class"), TEXT("Error"), MB_OK);
        return 0;
    }
 
    HWND hWnd = CreateWindow(TEXT("MyWindowClass"), TEXT("MyWindowTitle"), WS_OVERLAPPEDWINDOW, 200, 150, 400, 300, 0, 0, hInstance, 0);
    if (!hWnd)
    {
        MessageBox(NULL, TEXT("Cannot create main window"), TEXT("Error"), MB_OK);
        return 0;
    }
 
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
 
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    Gdiplus::GdiplusShutdown(gdiToken);
 
    return msg.wParam;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CREATE:
            SetTimer(hWnd, 1, 100, 0);
            break;
 
        case WM_TIMER:
            g_angle += 10;
            InvalidateRect(hWnd, 0, FALSE);
            break;
 
        case WM_PAINT:
            DrawProc(hWnd);
            break;
 
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
 
        default:
            return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
 
    return 0;
}
 
void DrawProc(HWND hWnd)
{
    Gdiplus::Graphics g(hWnd);
 
    Gdiplus::Pen pen(Gdiplus::Color::Black, 1);
 
    g.Clear(Gdiplus::Color::White);
    g.RotateTransform(g_angle, Gdiplus::MatrixOrderAppend);
    g.TranslateTransform(100.0f, 100.0f, Gdiplus::MatrixOrderAppend);
    g.DrawEllipse(&pen, -50, -25, 100, 50);
 
    ValidateRect(hWnd, 0);
}

@xamelione25 · 09.02.2021, 16:20 **[ТС]**

Ygg, а как здесь применить подавление мерцания (к тому коды который вы представили)???

C++

    Graphics g(hdc);
    Rect rectInstance;
    g.GetVisibleClipBounds(&rectInstance);
    Bitmap backBuffer(rectInstance.Width, rectInstance.Height, &g);
    Graphics drawingBoard(&backBuffer);
    drawingBoard.Clear(Color::White);
    drawingBoard.SetSmoothingMode(SmoothingModeAntiAlias);
    Matrix affinMatrix;

Добавлено через 3 минуты
Ygg, Непонятно почему помимо самого повернутого на угол эллипса у меня на третьем ключевом кадре эллипс совместно со всеми остальными элементами не поворачивается

@xamelione25 · 09.02.2021, 17:20 **[ТС]**

Ygg, я вот так сейчас сделал - но получается бредятина...

C++

#include <windows.h>
#include <windowsX.h>
#include <tchar.h>
#include <gdiplus.h>
#include <vector>
#include <gdiplusgraphics.h>    
#include <gdiplusheaders.h>
#include "Math.h"
#define ID_TIMER    1
#pragma comment(lib,"Gdiplus.lib")
using namespace Gdiplus;
using namespace std;
 
Bitmap* imgTextureMetall;
HWND hWnd = NULL;
MSG  msg;
BOOL bRet;
ULONG_PTR           gdiToken;
GdiplusStartupInput gdiStartupInput;
HDC  hdc;
PAINTSTRUCT ps;
//Bitmap* imgTrain = NULL;
 
/* -- ANIMATION DATA --*/
std::vector<Gdiplus::PointF> startKeyVector;
Gdiplus::PointF* A;
Gdiplus::PointF* B;
Gdiplus::PointF* P;
Bitmap* imgRoad;
Image* gifTrain;
UINT framesCount;
UINT indexCurrentFrame;
int stage = 0;           
float t = 0.f;          
float k_sizeX = 0.6;    
float k_sizeY = 0.6;      
float g_angle = -30.0f;
PointF sizeWheel(70, 70);
 
/* ---------- */
LRESULT CALLBACK MyWindowsProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
void OnDestroy(HWND hwnd);
void OnDisplay(HDC hdc);
void DrawProc(HWND hWnd);
void CopyArrToVector(PointF _array[], std::vector<Gdiplus::PointF>& _vector, int _size);
void CopyPointFToVector(PointF _point, std::vector<Gdiplus::PointF>& _vector);
PointF Tween(const PointF& A, const PointF& B, float t);
void Tween(const PointF* A, const PointF* B, PointF* P, int count, float t);
void IncrementT(int framesCount);
void OnDisplay_Wheels(Graphics& drawingBoard, PointF centerPointWheel, PointF sizeWheel, int wheels, float gap, SolidBrush& Brush1, Pen& Pen1, SolidBrush& Brush2, Pen& Pen2, std::vector<Gdiplus::PointF>& Vector);
 
/* ----------- */
int WINAPI _tWinMain(HINSTANCE hInctance, HINSTANCE, LPTSTR lpszCmdLine, int nCmdShow) {
    ULONG_PTR gdiToken = 0;
    Gdiplus::GdiplusStartupInput gdiStartupInput;
    Gdiplus::GdiplusStartup(&gdiToken, &gdiStartupInput, NULL);
    WNDCLASSEX wndcls = { sizeof(wndcls) };
    wndcls.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    wndcls.lpfnWndProc = MyWindowsProc;
    wndcls.hInstance = hInctance;
    wndcls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndcls.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndcls.hbrBackground = NULL; 
    wndcls.lpszMenuName = NULL;
    wndcls.lpszClassName = TEXT("MainWindow");
    wndcls.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    if (0 == RegisterClassEx(&wndcls)) {
        return -1;
    }
    Status stRet = GdiplusStartup(&gdiToken, &gdiStartupInput, NULL);
    imgRoad = new Bitmap(L"road.jpg");
 
    hWnd = CreateWindowEx(0, TEXT("MainWindow"), TEXT("KGG3_animation"), WS_OVERLAPPEDWINDOW, 50, 50, 1400, 800, NULL, NULL, hInctance, NULL);
    if (hWnd == NULL) {
        return -1;
    }
    ShowWindow(hWnd, nCmdShow);
    imgTextureMetall = new Bitmap(L"texture.jpeg");
    UpdateWindow(hWnd);
 
    if (Ok == stRet) {
        while (GetMessage(&msg, NULL, 0, 0))
        {
            if (bRet == -1) {
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    GdiplusShutdown(gdiToken);
    return (int)msg.wParam;
}
 
/* ---------- */
LRESULT CALLBACK MyWindowsProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
    case WM_ERASEBKGND: // подавить мерцание
        return 1;
    case WM_CREATE:
        gifTrain = Image::FromFile(L"Lunohod.gif");
        indexCurrentFrame = 0;
        if (NULL != gifTrain) {
            framesCount = gifTrain->GetFrameCount(&FrameDimensionTime);
        }
        SetTimer(hWnd, ID_TIMER, 50, NULL);  
        return 0;
    case WM_TIMER:
        indexCurrentFrame = (indexCurrentFrame + 1) % framesCount;
        IncrementT(framesCount);
        gifTrain->SelectActiveFrame(&FrameDimensionTime, indexCurrentFrame);
        InvalidateRect(hWnd, NULL, FALSE);
        return 0;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps); 
        //OnDisplay(hdc);
        DrawProc(hWnd);
        EndPaint(hWnd, &ps);
        return 0;
        HANDLE_MSG(hWnd, WM_DESTROY, OnDestroy);
    }
 
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
void IncrementT(int framesCount) {
    if (t < 0) {
        stage = 0;
        t = 0;
    }
    else {
        t += (float)1 / framesCount * 3;
        if (t > 1) {
            t = 0;
            stage += 1;
        }
    }
}
void OnDestroy(HWND hwnd) {
    PostQuitMessage(0);
}
void CopyArrToVector(PointF _array[], std::vector<Gdiplus::PointF>& _vector, int _size) {
    for (int i = 0; i < _size; i++) {
        _vector.push_back(_array[i]);
    }
}
void CopyPointFToVector(PointF _point, std::vector<Gdiplus::PointF>& _vector) {
    _vector.push_back(_point);
}
PointF Tween(const PointF& A, const PointF& B, float t) {
    return PointF(A.X * (1.f - t) + B.X * t, A.Y * (1.f - t) + B.Y * t);
}
void Tween(const PointF* A, const PointF* B, PointF* P, int count, float t) {
    for (int i = 0; i < count; ++i) {
        P[i] = Tween(A[i], B[i], t);
    }
}
void OnDisplay_Wheels(Graphics& drawingBoard, PointF centerPointWheel, PointF sizeWheel, int wheels, float gap, SolidBrush& Brush1, Pen& Pen1, SolidBrush& Brush2, Pen& Pen2, std::vector<Gdiplus::PointF>& Vector) {
}
 
void DrawProc(HWND hWnd)
{
    Gdiplus::Graphics g(hWnd);
    Rect rectInstance;
    g.GetVisibleClipBounds(&rectInstance);
    Bitmap backBuffer(rectInstance.Width, rectInstance.Height, &g);
    Graphics drawingBoard(&backBuffer);
    drawingBoard.Clear(Gdiplus::Color::White);
    drawingBoard.SetSmoothingMode(SmoothingModeAntiAlias);
    ValidateRect(hWnd, 0);
    Matrix affinMatrix;
 
/*-- общие атрибуты --*/
    SolidBrush greenBrush(Color(0, 180, 0));
    SolidBrush yellowBrush(Color::Yellow);
    SolidBrush orangeBrush(Color::Orange);
    SolidBrush redBrush(Color(255, 50, 50));
    SolidBrush blackBrush(Color(20, 20, 20));
    HatchBrush hatchBrush(HatchStyleDarkVertical, Color::Silver, Color::Wheat);
    TextureBrush textureBrush(imgTextureMetall);
    Pen greenPen(Color(0, 150, 0));
    Pen redPen(Color(255, 0, 0));
    Pen blackPen(Color(0, 0, 0));
    Pen orangePen(Color::Orange);
    Pen yellowPen(Color::Yellow);
    Pen WhitePen(Color(255, 255, 255));
    Pen texturePen(&textureBrush, 15);
    Color colorWhite(Color::White);
    SolidBrush WhiteBrush(Color::White);
    SolidBrush DarkGrayBrush(Color(108, 108, 108));
    SolidBrush BlueBrush(Color(56, 44, 144));
    SolidBrush SaddleBrownBrush(Color(128, 68, 4));
    SolidBrush BrunBrown(Color(68, 36, 4));
    SolidBrush DarkTurquoiseBrown(Color(0, 206, 209));
    SolidBrush DarkCyanBrown(Color(0, 139, 139));
    Pen BrushPen(Color(68, 36, 4));
    Pen BluePen(Color(56, 44, 144));
    Color windowsColors[4] = {
        Color::MediumTurquoise,
        Color::SkyBlue,
        Color::MediumTurquoise,
        Color::SteelBlue,
    };
    int n = 4;
    int wheels = 4;
 
    //линейный градиент
    LinearGradientBrush pthGrBrush(Rect(200, 200, 300, 150), Color::White, Color::White, 45.f);
    LinearGradientBrush pthGrBrush2(Rect(200, 200, 300, 150), Color::White, Color::White, 45.f);
    Color colors[3] = { Color(255, 0, 255, 255), Color(255, 0, 155, 155), Color(255, 0, 0, 0) };
    float pos[3] = { 0.0f, 0.3f, 1.0f };
    Color colors1[3] = { Color(255, 0, 255, 255), Color(255, 0, 155, 155), Color(255, 0, 0, 0) };
    float pos1[3] = { 0.0f, 0.3f, 1.0f };
 
    //составное перо
    Pen CompPen(Color::Black, 6.f);
    float comp[6] = { 0.0f, 0.2f, 0.3f, 0.7f, 0.8f, 1.0f };
    CompPen.SetCompoundArray(comp, 6);
    WrapMode wrapMode = WrapModeTile;
 
    // дорога
    drawingBoard.DrawLine(&texturePen, 0, 488, 1400, 488);
    RectF rectim(100.f, 520.f, 400.f, 200.f);
    drawingBoard.DrawImage(gifTrain, rectim);
 
    /* -------- ПЕРВЫЙ КЛЮЧЕВОЙ КАДР ----------- */
    if (stage == 0 && t == 0) {
        /*-- левая половина рисунка --*/
 
        //голубой корпус
        PointF points[4] = { PointF(190, 410), PointF(150, 310), PointF(450, 310), PointF(400, 410) };
        // +4
        CopyArrToVector(points, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
        drawingBoard.DrawPolygon(&blackPen, points, 4);
 
        //оконтовочный бортик (голубой)
        PointF pointsa[4] = { PointF(120, 300), PointF(480, 300), PointF(480, 320), PointF(120, 320) };
        // +4
        CopyArrToVector(pointsa, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkCyanBrown, pointsa, 4);
        drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
 
        //серая антенна
        PointF pointsb[4] = { PointF(350, 300), PointF(510, 140), PointF(513, 143), PointF(355, 300) };
        // +4
        CopyArrToVector(pointsb, startKeyVector, 4);
        drawingBoard.FillPolygon(&DarkGrayBrush, pointsb, 4);
        drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
        drawingBoard.DrawCurve(&CompPen, pointsb, 4);
 
        //линейный градиент 1
        PointF windowsPoints[5] = { PointF(190, 410), PointF(150, 310), PointF(295, 410), PointF(450, 310), PointF(400, 410) };
        CopyArrToVector(windowsPoints, startKeyVector, 5);
        // +4
        PointF centerPointWindow(295, 410);  
        // +1
        PathGradientBrush pthGrBrush(windowsPoints, 5);
        pthGrBrush.SetCenterPoint(centerPointWindow);
        pthGrBrush.SetInterpolationColors(colors, pos, 5);
        pthGrBrush.SetSurroundColors(windowsColors, &n);
        drawingBoard.FillPolygon(&pthGrBrush, windowsPoints, 5);
        drawingBoard.DrawPolygon(&blackPen, windowsPoints, 5);
 
        // колеса
        float gap = 75.f; // расстояние между колесами
        PointF centerPointWheel1(190, 440);  
        PointF centerPointWheel2(263, 440);  
        PointF centerPointWheel3(337, 440);  
        PointF centerPointWheel4(410, 440); 
        CopyPointFToVector(centerPointWheel1, startKeyVector);
        CopyPointFToVector(centerPointWheel2, startKeyVector);
        CopyPointFToVector(centerPointWheel3, startKeyVector);
        CopyPointFToVector(centerPointWheel4, startKeyVector);
 
        // Большой Эллипс
        PointF pointsc(120, 90);
        CopyPointFToVector(pointsc, startKeyVector);
 
        // Надпись
        Font font(L"Courier", 25.f, FontStyleBold);
        drawingBoard.DrawString(L"СССР", -1, &font, PointF(250, 330), &SaddleBrownBrush);
 
        P = new Gdiplus::PointF[startKeyVector.size()];
        A = new Gdiplus::PointF[startKeyVector.size()];
        B = new Gdiplus::PointF[startKeyVector.size()];
        for (int i = 0; i < startKeyVector.size(); ++i) {
            A[i] = startKeyVector[i];
            B[i] = startKeyVector[i];
        }
 
        affinMatrix.Translate(300.f, -100.f);
        affinMatrix.Scale(k_sizeX, k_sizeY);
        affinMatrix.TransformPoints(B, startKeyVector.size());
        g.DrawImage(&backBuffer, rectInstance);
    }
    else
        //------------- stage == 0 && t <= 1.f
        if (stage == 0 && t <= 1) {
            Tween(A, B, P, startKeyVector.size(), t);
            int _i = 0;
 
            //голубой корпус
            PointF points[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            //оконтовочный бортик (голубой)
            PointF pointsa[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
 
            //серая антенна
            PointF pointsb[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
            drawingBoard.DrawCurve(&CompPen, pointsb, 4);
 
            //линейный градиент 1
            PointF windowsPoints[5] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y), PointF(P[_i + 4].X, P[_i + 4].Y) };
            _i += 4;
            PointF centerPointWindow(P[_i].X, P[_i].Y); 
            _i += 1;
            PathGradientBrush pthGrBrush(windowsPoints, 5);
            pthGrBrush.SetCenterPoint(centerPointWindow);
            pthGrBrush.SetInterpolationColors(colors, pos, 5);
            pthGrBrush.SetSurroundColors(windowsColors, &n);
            drawingBoard.FillPolygon(&pthGrBrush, windowsPoints, 5);
            drawingBoard.DrawPolygon(&blackPen, windowsPoints, 5);
 
            // колеса
            PointF centerPointWheel1[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = 1 - ((1 - k_sizeX) * t);
                float ky = 1 - ((1 - k_sizeY) * t);
                Rect rectWheel(centerPointWheel1[i].X - sizeWheel.X * kx / 2, centerPointWheel1[i].Y - sizeWheel.Y * ky / 2, sizeWheel.X * kx, sizeWheel.Y * ky);
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 3), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 3), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 3), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 3), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 5), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 5), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 5), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 5), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
            }
            _i += 4;
 
            //Большой Эллипс
            PointF pointsc = { PointF(P[_i].X, P[_i].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = 1 - ((1 - k_sizeX) * t);
                float ky = 1 - ((1 - k_sizeY) * t);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.DrawEllipse(&BrushPen, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.RotateTransform(g_angle, Gdiplus::MatrixOrderAppend);
            }
            _i += 1;
 
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* -------- ВТОРОЙ КЛЮЧЕВОЙ КАДР -------- */
        else if (stage == 1 && 0 <= t <= 1) {
            int _i = 0;
            if (t == 0) {
                for (int i = 0; i < startKeyVector.size(); ++i) {
                    A[i] = B[i];
                }
                affinMatrix.Translate(300.f, 300.f);
                affinMatrix.TransformPoints(B, startKeyVector.size());
            }
            Tween(A, B, P, startKeyVector.size(), t);
 
            //голубой корпус
            PointF points[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            //оконтовочный бортик (голубой)
            PointF pointsa[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
 
            //серая антенна
            PointF pointsb[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
            drawingBoard.DrawCurve(&CompPen, pointsb, 4);
 
            //линейный градиент 1
            PointF windowsPoints[5] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y), PointF(P[_i + 4].X, P[_i + 4].Y) };
            _i += 4;
            PointF centerPointWindow(P[_i].X, P[_i].Y); 
            _i += 1;
            PathGradientBrush pthGrBrush(windowsPoints, 5); 
            pthGrBrush.SetCenterPoint(centerPointWindow);
            pthGrBrush.SetInterpolationColors(colors, pos, 5);
            pthGrBrush.SetSurroundColors(windowsColors, &n);
            drawingBoard.FillPolygon(&pthGrBrush, windowsPoints, 5);
            drawingBoard.DrawPolygon(&blackPen, windowsPoints, 5);
 
            // колеса
            PointF centerPointWheel1[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = k_sizeX;
                float ky = k_sizeY;
                Rect rectWheel(centerPointWheel1[i].X - sizeWheel.X * kx / 2, centerPointWheel1[i].Y - sizeWheel.Y * ky / 2, sizeWheel.X * kx, sizeWheel.Y * ky);
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.65), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.65), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.65), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.65), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.4), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.4), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.4), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.4), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
            }
            _i += 4;
 
            //Большой Эллипс
            PointF pointsc = { PointF(P[_i].X, P[_i].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = k_sizeX;
                float ky = k_sizeY;
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.DrawEllipse(&BrushPen, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.RotateTransform(g_angle, Gdiplus::MatrixOrderAppend);
            }
            _i += 1;
 
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* -------- ТРЕТИЙ КЛЮЧЕВОЙ КАДР ------- */
        else if (stage == 2 && 0 <= t <= 1) {
            int _i = 0;
            if (t == 0) {
                for (int i = 0; i < startKeyVector.size(); ++i) {
                    A[i] = B[i];
                }
                affinMatrix.Translate(250, 0);
                affinMatrix.RotateAt(90, PointF(850.f, 250.f));
                affinMatrix.TransformPoints(B, startKeyVector.size());
            }
            Tween(A, B, P, startKeyVector.size(), t);
 
            //голубой корпус
            PointF points[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
            drawingBoard.DrawPolygon(&blackPen, points, 4);
            _i += 4;
 
            //оконтовочный бортик (голубой)
            PointF pointsa[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkCyanBrown, pointsa, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
 
            //серая антенна
            PointF pointsb[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            _i += 4;
            drawingBoard.FillPolygon(&DarkGrayBrush, pointsb, 4);
            drawingBoard.DrawPolygon(&blackPen, pointsb, 4);
            drawingBoard.DrawCurve(&CompPen, pointsb, 4);
 
            //линейный градиент 1
            PointF windowsPoints[5] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y), PointF(P[_i + 4].X, P[_i + 4].Y) };
            _i += 4;
            PointF centerPointWindow(P[_i].X, P[_i].Y);
            _i += 1;
            PathGradientBrush pthGrBrush(windowsPoints, 5);
            pthGrBrush.SetCenterPoint(centerPointWindow);
            pthGrBrush.SetInterpolationColors(colors, pos, 5);
            pthGrBrush.SetSurroundColors(windowsColors, &n);
            drawingBoard.FillPolygon(&pthGrBrush, windowsPoints, 5);
            drawingBoard.DrawPolygon(&blackPen, windowsPoints, 5);
 
            // колеса
            PointF centerPointWheel1[4] = { PointF(P[_i].X, P[_i].Y), PointF(P[_i + 1].X, P[_i + 1].Y), PointF(P[_i + 2].X, P[_i + 2].Y), PointF(P[_i + 3].X, P[_i + 3].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = k_sizeX;
                float ky = k_sizeY;
                Rect rectWheel(centerPointWheel1[i].X - sizeWheel.X * kx / 2, centerPointWheel1[i].Y - sizeWheel.Y * ky / 2, sizeWheel.X * kx, sizeWheel.Y * ky);
                drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
                drawingBoard.DrawEllipse(&BrushPen, rectWheel);
                drawingBoard.FillEllipse(&WhiteBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.65), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.65), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.65), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.65), sizeWheel.X * kx * 0.65, sizeWheel.Y * ky * 0.65);
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.4), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.4), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
                drawingBoard.DrawEllipse(&BrushPen, float(centerPointWheel1[i].X - sizeWheel.X * kx / 2 * 0.4), float(centerPointWheel1[i].Y - sizeWheel.Y * ky / 2 * 0.4), sizeWheel.X * kx * 0.4, sizeWheel.Y * ky * 0.4);
            }
            _i += 4;
 
            //Большой Эллипс
            PointF pointsc = { PointF(P[_i].X, P[_i].Y) };
            for (int i = 0; i < wheels; i++) {
                float kx = k_sizeX;
                float ky = k_sizeY;
                drawingBoard.FillEllipse(&SaddleBrownBrush, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.DrawEllipse(&BrushPen, float(pointsc.X - sizeWheel.X * kx), float(pointsc.Y - sizeWheel.Y * ky), sizeWheel.X * kx * 2, sizeWheel.Y * ky * 4);
                drawingBoard.RotateTransform(g_angle, Gdiplus::MatrixOrderAppend);
            }
            _i += 1;
 
            g.DrawImage(&backBuffer, rectInstance);
        }
    /* ------ КОНЕЦ ------ */
        else {
            t = -1;
            k_sizeX = 0.6; k_sizeY = 0.6;
            startKeyVector.clear();
            affinMatrix.Reset();
        }
}
 
void OnDisplay(HDC hdc) {
}

@Ygg · 09.02.2021, 17:43

xamelione25, объясните толком, что вы хотите сделать и что не получается? Ваш код слишком большой, к тому же его нельзя скомпилировать и запустить.

Вы схематично рисуете луноход?
Для чего тут нужен элипс?
Вы хотите поворачивать элипс отдельно от лунохода или вместе с ним?

@xamelione25 · 09.02.2021, 17:55 **[ТС]**

Ygg, у меня изначально имеется луноход нарисованный до этого как растровое изображение - см.скрин

у меня проблема сейчас в том что:
1. Я нем могу поставить эллипс (для начала хотя бы большой, маленькие я потом по аналогии сделаю).

Я сначала столкнулся с тем что он относительно самого лунохода не поворачивался (~на -30.0f.), и позже еще столкнулся с проблемой того, что он не разворачивается вместе с луноходом на третьем кадре ...

На данный момент у меня вообще появились еще два лишних эллипса, а тот который был (он прописан в строке кода 276) изначально - так и остался ... плюс эти два они только присутствуют на первом кадре - потом пропадают.

2. аналогичная ситуация как с эллипсом у меня состоит и с надписью "СССР" (см. строки в коде 280,281).
На данный момент она вообще не отображается, а изначально она просто оставалась как вкопанная на начальном месте, хотя она должна находиться на корпусе (трапеции) лунохода, и иметь аналогичную маневренность как и сам луноход в целом (аналогично крутиться и перемещаться).

@xamelione25 · 09.02.2021, 18:12 **[ТС]**

Ygg,

Сообщение от Ygg

Для чего тут нужен эллипс?

Так это же и есть спутниковая тарелка на луноходе (только под углом).

Сообщение от Ygg

Вы хотите поворачивать эллипс отдельно от лунохода или вместе с ним?

Вместе с ним ... как сам эллипс, там и надпись. Только сам эллипс должен быть дополнительно наклонен относительно корпуса

@Ygg · 09.02.2021, 18:25

xamelione25, у вас на рисунке справа "палка" с насаженными на неё "элипсами", а слева большой "элипс". Нужно и то и другое или на рисунке совмещено что хочется и что получается?

Мне кажется, вы изначально какой-то не правильный подход выбрали. Как я понял, для "анимации" вы пытаетесь рассчитать координаты всех элементов и рисуете эти элементы по новым координатам. Вам же проще было бы сделать функцию, которая принимает на вход Graphics и рисует на нём луноход в базовом состоянии. А для анимации вам нужно только рассчитывать преобразования, применять их к Graphics и вызывать с этим Graphics единую функцию рисования лунохода.

@xamelione25 · 09.02.2021, 18:31 **[ТС]**

Ygg, мне нужно просто данный рисунок преобразовать в анимацию, таким, как он представлен на картинке (она прорисована здесь - см. код ниже). Характер самой анимации (тобишь все эффекты - перемещение кручение) нужно оставить такой же, какой она имеет на данный момент (то что на данный момент имеется в коде выше 10пост).

C++

#include <windows.h>
#include <windowsX.h>
#include <tchar.h>
#include <gdiplus.h>
#include <gdiplus.h>
#include <gdiplusgraphics.h> // ф-ции графического вывода
#include <gdiplusheaders.h>  // ф-ции для вывода текста, изображения
#pragma comment(lib,"Gdiplus.lib")
/* ----------------------------------------------------- */
using namespace Gdiplus;
HWND hWnd = NULL;
HDC dc = GetDC(hWnd);
HBRUSH brush;
MSG  msg;
BOOL bRet;
ULONG_PTR           gdiToken;
GdiplusStartupInput gdiStartupInput;
HDC  hdc;           // дескриптор объекта устройства
PAINTSTRUCT ps;
Bitmap* imgTrain = NULL;
Bitmap* imgTextureMetall = NULL;
/* ----------------------------------------------------- */
LRESULT CALLBACK MyWindowsProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
void OnDestroy(HWND hwnd);
void OnDisplay(HDC hdc);
/* ----------------------------------------------------- */
int WINAPI _tWinMain(HINSTANCE hInctance, HINSTANCE, LPTSTR lpszCmdLine, int nCmdShow) {
    WNDCLASSEX wndcls = { sizeof(WNDCLASSEX) };
    wndcls.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    wndcls.lpfnWndProc = MyWindowsProc;
    wndcls.hInstance = hInctance;
    wndcls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndcls.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndcls.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); // извлекает дескриптор предопределенного пера из wingdi.h
    wndcls.lpszMenuName = NULL;
    wndcls.lpszClassName = TEXT("MainWindow");
    wndcls.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
 
    if (0 == RegisterClassEx(&wndcls)) {
        return -1;
    }
    hWnd = CreateWindowEx(0, TEXT("MainWindow"), TEXT("KGG1"), WS_OVERLAPPEDWINDOW,
        50, 50, 1400, 700, NULL, NULL, hInctance, NULL);
    if (hWnd == NULL) {
        return -1;
    }
    ShowWindow(hWnd, nCmdShow);
 
    // инициализируем библиотеку gdi
    Status stRet = GdiplusStartup(&gdiToken, &gdiStartupInput, NULL);
    imgTrain = new Bitmap(L"Lunohod.jpg");
    imgTextureMetall = new Bitmap(L"texture.jpeg");
    UpdateWindow(hWnd);
 
    if (Ok == stRet) {
        while (GetMessage(&msg, NULL, 0, 0))
        {
            if (bRet == -1) {
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    GdiplusShutdown(gdiToken);
    return (int)msg.wParam;
}
/* ----------------------------------------------------- */
LRESULT CALLBACK MyWindowsProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) 
{
    switch (uMsg) 
    {
        HANDLE_MSG(hWnd, WM_DESTROY, OnDestroy);
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps); // получили дескриптор устройства по hWnd
        OnDisplay(hdc);
        EndPaint(hWnd, &ps);
        return 0;
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
 
void OnDestroy(HWND hwnd) 
{
    PostQuitMessage(0);
}
 
void OnDisplay(HDC hdc) 
{
    Graphics drawingBoard(hdc);
    drawingBoard.SetSmoothingMode(SmoothingModeAntiAlias);  // включаем режим сглаживания линий (для колес)
 
    /*-- общие атрибуты --*/ //сплошные кисти
    SolidBrush WhiteBrush(Color::White);
    SolidBrush blackBrush(Color(20, 20, 20));
    SolidBrush DarkGrayBrush(Color(108, 108, 108));
    SolidBrush BlueBrush(Color(56, 44, 144));
    SolidBrush SaddleBrownBrush(Color(128, 68, 4));
    SolidBrush BrunBrown(Color(68, 36, 4));
    SolidBrush DarkTurquoiseBrown(Color(0, 206, 209));
    SolidBrush DarkCyanBrown(Color(0, 139, 139));
    HatchBrush hatchBrush(HatchStyleDarkVertical, Color::Silver, Color::Wheat);
    TextureBrush textureBrush(imgTextureMetall);
    Pen BrushPen(Color(68, 36, 4));
    Pen blackPen(Color(0, 0, 0));
    Pen BluePen(Color(56, 44, 144));
    Pen texturePen(&textureBrush, 15);
    Color colorWhite(Color::White);
 
    //линейный градиент
    LinearGradientBrush lgb(Rect(200, 200, 300, 150), Color::White, Color::White, 45.f);
    Color colors[3] = {Color(255, 0, 255, 255), Color(255, 0, 155, 155), Color(255, 0, 0, 0)};
    float pos[3] = {0.0f, 0.3f, 1.0f};
 
    //составное перо
    Pen CompPen(Color::Black, 6.f);
    float comp[6] = {0.0f, 0.2f, 0.3f, 0.7f, 0.8f, 1.0f};
    CompPen.SetCompoundArray(comp, 6);
    WrapMode wrapMode = WrapModeTile;
 
    /*-- вывод изображения --*/
    float fRatio = (float)imgTrain->GetHeight() / (float)imgTrain->GetWidth();
    int imgWidth = 500;
    int imgHeight = imgWidth * fRatio;
    int imgX = 800;
    int imgY = 200;
    drawingBoard.DrawImage(imgTrain, imgX, imgY, imgWidth, imgHeight);
 
    //голубой корпус
    Point points[4] =  {Point(190, 410), Point(150, 310), Point(450, 310), Point(400, 410)};
    drawingBoard.FillPolygon(&DarkTurquoiseBrown, points, 4);
    drawingBoard.DrawPolygon(&blackPen, points, 4);
 
    //линейный градиент
    Point WindowForwDoor[3] = { Point(150,310), Point(295,410), Point(190,410) };
    Point WindowBackDoor[3] = { Point(450,310), Point(400,410), Point(295,410) };
 
    /*-- вывод текста --*/
    Font font(L"Courier", 25.f, FontStyleBold);
    drawingBoard.DrawString(L"СССР", -1, &font, PointF(250, 330), &SaddleBrownBrush);
 
    //серая антенна
    Point pointsa[4] = { Point(350, 300), Point(510, 140), Point(513, 143), Point(355, 300) };
    drawingBoard.FillPolygon(&DarkGrayBrush, pointsa, 4);
    drawingBoard.DrawPolygon(&blackPen, pointsa, 4);
    drawingBoard.DrawCurve(&CompPen, pointsa, 4);
 
    //Большой эллипс
    drawingBoard.RotateTransform(70);
    drawingBoard.FillEllipse(&BlueBrush, 115, -95, 220, 100);
    drawingBoard.RotateTransform(-70);
 
    //оконтовочный бортик (голубой)
    points[0] = Point(120, 300); points[1] = Point(480, 300); points[2] = Point(480, 320); points[3] = Point(120, 320);
    drawingBoard.FillPolygon(&DarkCyanBrown, points, 4);
    drawingBoard.DrawPolygon(&blackPen, points, 4);
 
    //эллипс 1
    drawingBoard.RotateTransform(40);
    drawingBoard.FillEllipse(&DarkGrayBrush, 430, -55, 70, 30);
    drawingBoard.RotateTransform(-40);
 
    //эллипс 2
    drawingBoard.RotateTransform(40);
    drawingBoard.FillEllipse(&DarkGrayBrush, 439, -85, 60, 26);
    drawingBoard.RotateTransform(-40);
 
    //эллипс 3
    drawingBoard.RotateTransform(40);
    drawingBoard.FillEllipse(&DarkGrayBrush, 448, -110, 50, 22);
    drawingBoard.RotateTransform(-40);
 
    //эллипс 4
    drawingBoard.RotateTransform(40);
    drawingBoard.FillEllipse(&DarkGrayBrush, 456, -130, 40, 18);
    drawingBoard.RotateTransform(-40);
 
    //эллипс 5
    drawingBoard.RotateTransform(40);
    drawingBoard.FillEllipse(&DarkGrayBrush, 463, -146, 30, 14);
    drawingBoard.RotateTransform(-40);
 
    lgb.SetInterpolationColors(colors, pos, 3);
 
    drawingBoard.FillPolygon(&lgb, WindowForwDoor, 3);
    drawingBoard.FillPolygon(&lgb, WindowBackDoor, 3);
 
    // колеса
    int wheel = 4; // количество колес
    int gap = 75; // расстояние между колесами
    Rect rectWheel(150, 400, 70, 70);
    for (int i = 0; i < wheel; i++)
    {
        drawingBoard.FillEllipse(&SaddleBrownBrush, rectWheel);
        drawingBoard.FillEllipse(&WhiteBrush, rectWheel.X + 14, rectWheel.Y + 14, rectWheel.Width - 28, rectWheel.Height - 28);
        drawingBoard.FillEllipse(&BrunBrown, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
        drawingBoard.DrawEllipse(&BrushPen, rectWheel.X + 20, rectWheel.Y + 20, rectWheel.Width - 40, rectWheel.Height - 40);
        rectWheel.X += gap;
    }
}

@xamelione25 · 09.02.2021, 18:55 **[ТС]**

Ygg, вот у меня сейчас проект в таком состоянии:

@xamelione25 · 10.02.2021, 11:45 **[ТС]**

Ygg, не смотрели еще?

@Ygg · 10.02.2021, 13:37

Сообщение от xamelione25

не смотрели еще?

У меня сейчас нет свободного времени, что бы всё посмотреть и попробовать.
Небольшой пример к мысли из предыдущего моего сообщения.

Мне кажется, вы изначально какой-то не правильный подход выбрали. Как я понял, для "анимации" вы пытаетесь рассчитать координаты всех элементов и рисуете эти элементы по новым координатам. Вам же проще было бы сделать функцию, которая принимает на вход Graphics и рисует на нём луноход в базовом состоянии. А для анимации вам нужно только рассчитывать преобразования, применять их к Graphics и вызывать с этим Graphics единую функцию рисования лунохода.

C++

#include <windows.h> 
 
#define _USE_MATH_DEFINES
#include <math.h> 
 
#include <gdiplus.h> 
#pragma comment(lib, "Gdiplus")
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
void DrawProc(HWND);
void DrawProc(Gdiplus::Graphics& g);
 
int g_step = 0;
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    ULONG_PTR gdiToken = 0;
    Gdiplus::GdiplusStartupInput gdiStartupInput;
    Gdiplus::GdiplusStartup(&gdiToken, &gdiStartupInput, NULL);
 
    WNDCLASSEX wc = { sizeof(wc) };
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.lpszClassName = TEXT("MyWindowClass");
    if (!RegisterClassEx(&wc))
    {
        MessageBox(NULL, TEXT("Cannot register class"), TEXT("Error"), MB_OK);
        return 0;
    }
 
    HWND hWnd = CreateWindow(TEXT("MyWindowClass"), TEXT("MyWindowTitle"), WS_OVERLAPPEDWINDOW, 200, 150, 400, 300, 0, 0, hInstance, 0);
    if (!hWnd)
    {
        MessageBox(NULL, TEXT("Cannot create main window"), TEXT("Error"), MB_OK);
        return 0;
    }
 
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
 
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    Gdiplus::GdiplusShutdown(gdiToken);
 
    return msg.wParam;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CREATE:
            SetTimer(hWnd, 1, 100, 0);
            break;
 
        case WM_TIMER:
            g_step++;
            InvalidateRect(hWnd, 0, FALSE);
            break;
 
        case WM_PAINT:
            DrawProc(hWnd);
            ValidateRect(hWnd, 0);
            break;
 
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
 
        default:
            return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
 
    return 0;
}
 
void DrawProc(HWND hWnd)
{
    Gdiplus::Graphics g(hWnd);
 
    g.Clear(Gdiplus::Color::White);
 
    // заставляем крутиться на 360 градусов вокруг точки (100.f, 100.f)
    {
        float angl = 360.f * g_step / 50;
 
        g.ResetTransform();
        g.TranslateTransform(100.f, 100.f);
        g.RotateTransform(angl);
        DrawProc(g);
    }
 
    // заставляем двигаться горизонтально
    {
        float dist = 5.f * g_step;
 
        g.ResetTransform();
        g.TranslateTransform(100.f + dist, 100.f);
        DrawProc(g);
    }
 
    // поворачиваем на 30 градусов и заставляем двигаться наклонно
    {
        float angl = 30.f;
        float dist = 5.f * g_step;
 
        g.ResetTransform();
        g.RotateTransform(angl);
        g.TranslateTransform(100.f + dist, 100.f);
        DrawProc(g);
 
        g.ResetTransform();
        g.TranslateTransform(100.f + dist * cos(angl * M_PI / 180), 100.f + dist * sin(angl * M_PI / 180));
        g.RotateTransform(angl);
        DrawProc(g);
    }
 
    if (g_step == 50)
        g_step = 0;
}
 
// рисуем свою картинку в начале координат
void DrawProc(Gdiplus::Graphics& g)
{
    Gdiplus::Pen pen(Gdiplus::Color::Black, 1);
 
    g.DrawRectangle(&pen, -50, -25, 100, 50);
 
    g.RotateTransform(45);
    g.TranslateTransform(50.0f, 25.0f);
    g.DrawEllipse(&pen, -50, -25, 100, 50);
    g.TranslateTransform(-50.0f, -25.0f);
    g.RotateTransform(-45);
}

@xamelione25 · 10.02.2021, 14:46 **[ТС]**

Ygg, я вроде по немногу понимать начинаю)))
Единственное можете показать (в коде) как сделать по вашему коду (допустим из тех анимационных эффектов которые вы прописали в коде) последовательное отображение анимационных эффектов, чтобы они шли не параллельно а последовательно.

@Ygg · 10.02.2021, 14:58

Последовательно как-то так

C++

void DrawProc(HWND hWnd)
{
    Gdiplus::Graphics g(hWnd);
 
    g.Clear(Gdiplus::Color::White);
 
    // заставляем крутиться на 360 градусов вокруг точки (100.f, 100.f)
    if (g_step < 50)
    {
        float angl = 360.f * g_step / 50;
 
        g.ResetTransform();
        g.TranslateTransform(100.f, 100.f);
        g.RotateTransform(angl);
        DrawProc(g);
    }
 
    // заставляем двигаться горизонтально
    else if (g_step < 100)
    {
        float dist = 5.f * (g_step-50);
 
        g.ResetTransform();
        g.TranslateTransform(100.f + dist, 100.f);
        DrawProc(g);
    }
 
    // поворачиваем на 30 градусов и заставляем двигаться наклонно
    else if (g_step <= 150)
    {
        float angl = 30.f;
        float dist = 5.f * (g_step-100);
 
        g.ResetTransform();
        g.RotateTransform(angl);
        g.TranslateTransform(100.f + dist, 100.f);
        DrawProc(g);
 
        g.ResetTransform();
        g.TranslateTransform(100.f + dist * cos(angl * M_PI / 180), 100.f + dist * sin(angl * M_PI / 180));
        g.RotateTransform(angl);
        DrawProc(g);
    }
 
    if (g_step == 150)
        g_step = 0;
}

@xamelione25 -4 / 5 / 2 Регистрация: 04.02.2013 Сообщений: 1,827
	04.02.2021, 18:02 [ТС]	4
	Ygg, нашел еще один косяк - посыпались ошибки отсутствуют экземпляры перегруженная функция ... соответствующие списку аргументов Миниатюры 0

@xamelione25 -4 / 5 / 2 Регистрация: 04.02.2013 Сообщений: 1,827
	04.02.2021, 18:52 [ТС]	6
	Ygg, а как поступить с 292 и 293 строками с FillPolygon??? Добавлено через 24 минуты Ygg, может быть FillPolygon чем-то заменить??? Только вопрос в том ...чем заменить...я не знаю))) 0

@Ygg 2710 / 864 / 327 Регистрация: 10.02.2018 Сообщений: 2,044
	09.02.2021, 17:43	11
	xamelione25, объясните толком, что вы хотите сделать и что не получается? Ваш код слишком большой, к тому же его нельзя скомпилировать и запустить. Вы схематично рисуете луноход? Для чего тут нужен элипс? Вы хотите поворачивать элипс отдельно от лунохода или вместе с ним? 0

@xamelione25 -4 / 5 / 2 Регистрация: 04.02.2013 Сообщений: 1,827
	09.02.2021, 17:55 [ТС]	12
	Ygg, у меня изначально имеется луноход нарисованный до этого как растровое изображение - см.скрин у меня проблема сейчас в том что: 1. Я нем могу поставить эллипс (для начала хотя бы большой, маленькие я потом по аналогии сделаю). Я сначала столкнулся с тем что он относительно самого лунохода не поворачивался (~на -30.0f.), и позже еще столкнулся с проблемой того, что он не разворачивается вместе с луноходом на третьем кадре ... На данный момент у меня вообще появились еще два лишних эллипса, а тот который был (он прописан в строке кода 276) изначально - так и остался ... плюс эти два они только присутствуют на первом кадре - потом пропадают. 2. аналогичная ситуация как с эллипсом у меня состоит и с надписью "СССР" (см. строки в коде 280,281). На данный момент она вообще не отображается, а изначально она просто оставалась как вкопанная на начальном месте, хотя она должна находиться на корпусе (трапеции) лунохода, и иметь аналогичную маневренность как и сам луноход в целом (аналогично крутиться и перемещаться). Миниатюры 0

@xamelione25 -4 / 5 / 2 Регистрация: 04.02.2013 Сообщений: 1,827
	09.02.2021, 18:12 [ТС]	13
	Ygg, Сообщение от Ygg Для чего тут нужен эллипс? Так это же и есть спутниковая тарелка на луноходе (только под углом). Сообщение от Ygg Вы хотите поворачивать эллипс отдельно от лунохода или вместе с ним? Вместе с ним ... как сам эллипс, там и надпись. Только сам эллипс должен быть дополнительно наклонен относительно корпуса 0

@Ygg 2710 / 864 / 327 Регистрация: 10.02.2018 Сообщений: 2,044
	09.02.2021, 18:25	14
	xamelione25, у вас на рисунке справа "палка" с насаженными на неё "элипсами", а слева большой "элипс". Нужно и то и другое или на рисунке совмещено что хочется и что получается? Мне кажется, вы изначально какой-то не правильный подход выбрали. Как я понял, для "анимации" вы пытаетесь рассчитать координаты всех элементов и рисуете эти элементы по новым координатам. Вам же проще было бы сделать функцию, которая принимает на вход Graphics и рисует на нём луноход в базовом состоянии. А для анимации вам нужно только рассчитывать преобразования, применять их к Graphics и вызывать с этим Graphics единую функцию рисования лунохода. 0

@xamelione25 -4 / 5 / 2 Регистрация: 04.02.2013 Сообщений: 1,827
	10.02.2021, 11:45 [ТС]	17
	Ygg, не смотрели еще? 0

@xamelione25 -4 / 5 / 2 Регистрация: 04.02.2013 Сообщений: 1,827
	10.02.2021, 14:46 [ТС]	19
	Ygg, я вроде по немногу понимать начинаю))) Единственное можете показать (в коде) как сделать по вашему коду (допустим из тех анимационных эффектов которые вы прописали в коде) последовательное отображение анимационных эффектов, чтобы они шли не параллельно а последовательно. 0

Использование текста в анимации: Не существует подходящей функции преобразования из "Gdiplus::Font" в "Gdiplus::Font *"

Решение