Вращение трех кругов по часовой стрелке

using System;
using System.Drawing;
using System.Windows.Forms;
 
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
 
namespace test
{
    public partial class Form1 : Form
    {
        //-------------------------------------------------------------
 
        public Form1()
        {
            InitializeComponent();
 
            InitializeD3d();
        }
 
        //-------------------------------------------------------------
 
        void InitializeD3d()
        {
            FillParameters();
 
            Dev = new Device
                        (
                            0,
                            DeviceType.Hardware,
                            this,
                            CreateFlags.HardwareVertexProcessing,
                            Parameters
                        );
 
            BuildDeclaration();
            BuildVertexBuffer();
            BuildShaders();
        }
 
        //-------------------------------------------------------------
 
        private void OnClick111(object sender, EventArgs e)
        {
            Close();
        }
 
        //-------------------------------------------------------------
 
        void FillParameters()
        {
            Parameters.AutoDepthStencilFormat = DepthFormat.D16;
            Parameters.BackBufferCount = 1;
            Parameters.BackBufferFormat = Format.Unknown;
            Parameters.BackBufferWidth = Width;
            Parameters.BackBufferHeight = Height;
            Parameters.DeviceWindow = this;
            Parameters.EnableAutoDepthStencil = true;
            Parameters.MultiSample = MultiSampleType.None;
            Parameters.PresentationInterval = PresentInterval.Immediate;
            Parameters.SwapEffect = SwapEffect.Discard;
            Parameters.Windowed = true;
        }
 
        //-------------------------------------------------------------
 
        void BuildDeclaration()
        {
            Dev.VertexDeclaration = new VertexDeclaration
            (
                Dev,
                Attributes
            );
        }
 
        //-------------------------------------------------------------
 
        void BuildVertexBuffer()
        {
            // вычисление размера одной вершины
 
            int VertexSize = VertexInformation.GetDeclarationVertexSize
            (
                Attributes,
                0
            );
 
            // создание вершинного буфера для размещения всех вершин сцены
 
            SceneBuffer = new VertexBuffer
            (
                Dev,
                VertexSize * VertexCount,
                Usage.WriteOnly,
                VertexFormats.None,
                Pool.Default // в видеопамяти
            );
 
            FillScene();
 
            // заполнение буфера данными
 
            SceneBuffer.SetData(Scene, 0, LockFlags.Discard);
 
            // указание буфера в качестве источника данных
 
            Dev.SetStreamSource(0, SceneBuffer, 0, VertexSize);
        }
 
        //-------------------------------------------------------------
 
        void FillScene()
        {
            int j = 0;
            for (float k = 0; (k <= 360); k++, j += 3)
            {
                Scene[j].x = 0;
                Scene[j].y = 0.5f;
                Scene[j].z = 0;
                Scene[j].w = 1;
 
                Scene[j].Color = Color.Green.ToArgb();
 
                Scene[j + 1].x = (float)(((Math.Cos((k + 1) * 3.14 / 180)) * 0.2));
                Scene[j + 1].y = (float)(((Math.Sin((k + 1) * 3.14 / 180)) * 0.2) + 0.5);
                Scene[j + 1].z = 0;
                Scene[j + 1].w = 1;
 
                Scene[j + 1].Color = Color.Yellow.ToArgb();
 
                Scene[j + 2].x = (float)(((Math.Cos(k * 3.14 / 180)) * 0.2));
                Scene[j + 2].y = (float)(((Math.Sin(k * 3.14 / 180)) * 0.2) + 0.5);
                Scene[j + 2].z = 0;
                Scene[j + 2].w = 1;
 
                Scene[j + 2].Color = Color.Green.ToArgb();
            }
            int t = 0;
            for (float k = 0; (k <= 360); k++, t += 3)
            {
                Scene[t + 1080].x = -0.5f;
                Scene[t + 1080].y = -0.5f;
                Scene[t + 1080].z = 0;
                Scene[t + 1080].w = 1;
 
                Scene[t + 1080].Color = Color.Green.ToArgb();
 
                Scene[t + 1081].x = (float)(((Math.Cos((k + 1) * 3.14 / 180)) * 0.2) - 0.5);
                Scene[t + 1081].y = (float)(((Math.Sin((k + 1) * 3.14 / 180)) * 0.2) - 0.5);
                Scene[t + 1081].z = 0;
                Scene[t + 1081].w = 1;
 
                Scene[t + 1081].Color = Color.Yellow.ToArgb();
 
                Scene[t + 1082].x = (float)(((Math.Cos(k * 3.14 / 180)) * 0.2) - 0.5);
                Scene[t + 1082].y = (float)(((Math.Sin(k * 3.14 / 180)) * 0.2) - 0.5);
                Scene[t + 1082].z = 0;
                Scene[t + 1082].w = 1;
 
                Scene[t + 1082].Color = Color.Green.ToArgb();
            }
 
            int b = 0;
            for (float k = 0; (k <= 360); k++, b += 3)
            {
                Scene[b + 2160].x = 0.5f;
                Scene[b + 2160].y = -0.5f;
                Scene[b + 2160].z = 0;
                Scene[b + 2160].w = 1;
 
                Scene[b + 2160].Color = Color.Green.ToArgb();
 
                Scene[b + 2161].x = (float)(((Math.Cos((k + 1) * 3.14 / 180)) * 0.2) + 0.5);
                Scene[b + 2161].y = (float)(((Math.Sin((k + 1) * 3.14 / 180)) * 0.2) - 0.5);
                Scene[b + 2161].z = 0;
                Scene[b + 2161].w = 1;
 
                Scene[b + 2161].Color = Color.Yellow.ToArgb();
 
                Scene[b + 2162].x = (float)(((Math.Cos(k * 3.14 / 180)) * 0.2) + 0.5);
                Scene[b + 2162].y = (float)(((Math.Sin(k * 3.14 / 180)) * 0.2) - 0.5);
                Scene[b + 2162].z = 0;
                Scene[b + 2162].w = 1;
 
                Scene[b + 2162].Color = Color.Green.ToArgb();
            }
 
 
 
 
        }
 
 
        //-------------------------------------------------------------
 
        void BuildShaders()
        {
            string errors;
            ConstantTable table;
 
            GraphicsStream token = ShaderLoader.CompileShaderFromFile
            (
                "vsh.txt",
                "main",
                null,
                null,
                ShaderLoader.GetVertexShaderProfile(Dev),
                ShaderFlags.None,
                out errors,
                out table
            );
 
            Dev.VertexShader = new VertexShader(Dev, token);
 
            token.Dispose();
 
            token = ShaderLoader.CompileShaderFromFile
                        (
                            "psh.txt",
                            "main",
                            null,
                            null,
                            ShaderLoader.GetPixelShaderProfile(Dev),
                            ShaderFlags.None,
                            out errors,
                            out table
                        );
 
            Dev.PixelShader = new PixelShader(Dev, token);
        }
 
        //-------------------------------------------------------------
 
        Device Dev;
 
        PresentParameters Parameters = new PresentParameters();
 
        //-------------------------------------------------------------
 
        // Пользовательская структура с описанием вершины
 
        struct Vertex
        {
            public float x, y, z, w; // позиция в 3D пространстве
            public int Color; // цвет вершины
        }
 
        const int VertexCount = 6000;
 
        // массив вершин сцены
        Vertex[] Scene = new Vertex[VertexCount];
 
        //-------------------------------------------------------------
 
        // декларация содержимого пользовательской структуры Vertex
 
        VertexElement[] Attributes = 
        {
            new VertexElement
            (
                0,
                0,
                DeclarationType.Float4,
                DeclarationMethod.Default,
                DeclarationUsage.Position,
                0
            ),
 
            new VertexElement
            (
                0,
                sizeof(float) * 4,
                DeclarationType.Color,
                DeclarationMethod.Default,
                DeclarationUsage.Color,
                0
            ),
 
            VertexElement.VertexDeclarationEnd
        };
 
        //-------------------------------------------------------------
 
        VertexBuffer SceneBuffer;
 
        //-------------------------------------------------------------
 
        private void OnPaint123(object sender, PaintEventArgs e)
        {
            Dev.Clear
            (
                ClearFlags.Target | ClearFlags.ZBuffer,
                Color.Black,
                0,
                0
            );
 
            Dev.BeginScene();
 
            Dev.DrawPrimitives(PrimitiveType.TriangleList, 0, 2000);
 
            Dev.EndScene();
 
            Dev.Present();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
 
        }
 
        //-------------------------------------------------------------
    }
}

//вращение вокруг оси X, fi - угол поворота
Dev.Transform.World = Matrix.RotationX(fi);

var w = Matrix.RotationX(fi);