using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Numerics;
using System.Windows.Forms;
 
namespace _2DTest
{
    public partial class Form1 : Form
    {
        private Transformable2D transformable = new Transformable2D();
 
        public Form1()
        {
            InitializeComponent();
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
 
            // Wende die Transformation auf die Grafik an
            e.Graphics.Transform = transformable.GetTransformationMatrix();
 
            // Beispielcode für die Verwendung von Vector2 und Punkten
            Vector2 point1 = new Vector2(50, 50);
            Vector2 point2 = new Vector2(100, 100);
 
            // Zeichne eine Linie zwischen den transformierten Punkten
            e.Graphics.DrawLine(Pens.Black, point1.X, point1.Y, point2.X, point2.Y);
        }
 
        // Ereignishandler für Tastendrücke zum Testen der Transformationen
        protected override void OnKeyDown(KeyEventArgs e)
        {
            base.OnKeyDown(e);
 
            switch (e.KeyCode)
            {
                case Keys.W:
                    transformable.Translate(0, -10); // Bewegung nach oben
                    break;
 
                case Keys.S:
                    transformable.Translate(0, 10); // Bewegung nach unten
                    break;
 
                case Keys.A:
                    transformable.Translate(-10, 0); // Bewegung nach links
                    break;
 
                case Keys.D:
                    transformable.Translate(10, 0); // Bewegung nach rechts
                    break;
 
                case Keys.R:
                    transformable.Rotate(15); // Rotation im Uhrzeigersinn um 15 Grad
                    break;
 
                case Keys.E:
                    transformable.Rotate(-15); // Rotation gegen den Uhrzeigersinn um 15 Grad
                    break;
 
                case Keys.Q:
                    transformable.Scale(1.1f, 1.1f); // Skalierung um 10%
                    break;
 
                case Keys.Z:
                    transformable.Scale(0.9f, 0.9f); // Skalierung um 10% verkleinern
                    break;
            }
 
            // Erzwinge ein Neuzeichnen des Formulars
            Invalidate();
        }
    }
 
    public class Transformable2D
    {
        private PointF position;
        private float rotation;
        private SizeF scale;
 
        public Transformable2D()
        {
            position = Point.Empty;
            rotation = 0f;
            scale = new SizeF(1, 1);
        }
 
        public void Translate(float dx, float dy)
        {
            position.X += dx;
            position.Y += dy;
        }
 
        public void Rotate(float angleInDegrees)
        {
            rotation += angleInDegrees;
        }
 
        public void Scale(float scaleX, float scaleY)
        {
            scale.Width *= scaleX;
            scale.Height *= scaleY;
        }
 
        public Matrix GetTransformationMatrix()
        {
            Matrix matrix = new Matrix();
            matrix.Translate(position.X, position.Y);
            matrix.Rotate(rotation);
            matrix.Scale(scale.Width, scale.Height);
            return matrix;
        }
    }
}
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Numerics;
using System.Windows.Forms;
 
namespace _3DTest
{
    public partial class Form1 : Form
    {
        private Timer timer1;
        private Transformable3D cubeTransform;
 
        private float TranslationSpeed = 5f;
        private float RotationSpeed = 0.05f;
        private float ScaleSpeed = 0.1f;
 
        public Form1()
        {
            InitializeComponent();
 
            this.KeyDown += Form1_KeyDown;
 
            cubeTransform = new Transformable3D();
            InitializeCube();
 
            // Initialisiere den Timer
            timer1 = new Timer();
            timer1.Interval = 16; // ungefähr 60 fps
            timer1.Tick += timer1_Tick;
            timer1.Start();
        }
 
        private void InitializeCube()
        {
            // Definiere die Eckpunkte des Würfels
            List<Vector3> cubePoints = new List<Vector3>
            {
                new Vector3(-1, -1, -1),
                new Vector3(1, -1, -1),
                new Vector3(1, 1, -1),
                new Vector3(-1, 1, -1),
                new Vector3(-1, -1, 1),
                new Vector3(1, -1, 1),
                new Vector3(1, 1, 1),
                new Vector3(-1, 1, 1),
            };
 
            // Setze die Punkte für den Würfel in der Transformable3D-Instanz
            cubeTransform.SetPoints(cubePoints);
        }
 
        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            // Verarbeite Tastendrücke für Bewegung, Rotation und Skalierung
 
 
 
            switch (e.KeyCode)
            {
                // Bewegung
                case Keys.Left:
                    cubeTransform.Translate(new Vector3(-TranslationSpeed, 0, 0));
                    break;
                case Keys.Right:
                    cubeTransform.Translate(new Vector3(TranslationSpeed, 0, 0));
                    break;
                case Keys.Up:
                    cubeTransform.Translate(new Vector3(0, -TranslationSpeed, 0));
                    break;
                case Keys.Down:
                    cubeTransform.Translate(new Vector3(0, TranslationSpeed, 0));
                    break;
 
                // Rotation
                case Keys.A:
                    cubeTransform.Rotate(new Vector3(0, 0, RotationSpeed));
                    break;
                case Keys.D:
                    cubeTransform.Rotate(new Vector3(0, 0, -RotationSpeed));
                    break;
                case Keys.W:
                    cubeTransform.Rotate(new Vector3(RotationSpeed, 0, 0));
                    break;
                case Keys.S:
                    cubeTransform.Rotate(new Vector3(-RotationSpeed, 0, 0));
                    break;
 
                // Skalierung
                case Keys.Add:
                    cubeTransform.Scale(new Vector3(1 + ScaleSpeed, 1 + ScaleSpeed, 1 + ScaleSpeed));
                    break;
                case Keys.Subtract:
                    cubeTransform.Scale(new Vector3(1 - ScaleSpeed, 1 - ScaleSpeed, 1 - ScaleSpeed));
                    break;
            }
 
 
            // Aktualisiere die Zeichenfläche nach jeder Änderung
            Refresh();
        }
 
        private void timer1_Tick(object sender, EventArgs e)
        {
 
            Refresh();
 
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
 
            // Rufe die Transformationsmatrix des Würfels ab
            Matrix4x4 transformationMatrix = cubeTransform.GetTransformationMatrix();
 
            // Wende die Transformation auf jeden Punkt des Würfels an
            List<Vector3> transformedPoints = cubeTransform.TransformPoints(transformationMatrix);
 
            // Zeichne die Linien des Würfels
            using (var pen = new Pen(Color.Black))
            {
                // Zeichne die Kanten des Würfels
                for (int i = 0; i < 4; i++)
                {
                    PointF point1 = new PointF(transformedPoints[i].X, transformedPoints[i].Y);
                    PointF point2 = new PointF(transformedPoints[(i + 1) % 4].X, transformedPoints[(i + 1) % 4].Y);
 
                    e.Graphics.DrawLine(pen, point1, point2);
 
                    point1 = new PointF(transformedPoints[i + 4].X, transformedPoints[i + 4].Y);
                    point2 = new PointF(transformedPoints[((i + 1) % 4) + 4].X, transformedPoints[((i + 1) % 4) + 4].Y);
 
                    e.Graphics.DrawLine(pen, point1, point2);
 
                    point1 = new PointF(transformedPoints[i].X, transformedPoints[i].Y);
                    point2 = new PointF(transformedPoints[i + 4].X, transformedPoints[i + 4].Y);
 
                    e.Graphics.DrawLine(pen, point1, point2);
                }
 
                // Zeichne die Kanten zwischen den Ecken
                for (int i = 0; i < 4; i++)
                {
                    PointF point1 = new PointF(transformedPoints[i].X, transformedPoints[i].Y);
                    PointF point2 = new PointF(transformedPoints[(i + 4) % 8].X, transformedPoints[(i + 4) % 8].Y);
 
                    e.Graphics.DrawLine(pen, point1, point2);
                }
            }
        }
 
    }
 
    public class Transformable3D
    {
        private List<Vector3> points;
 
        public Transformable3D()
        {
            points = new List<Vector3>();
        }
 
        public void SetPoints(List<Vector3> newPoints)
        {
            points = newPoints;
        }
 
        public void Translate(Vector3 translation)
        {
            for (int i = 0; i < points.Count; i++)
            {
                points[i] += translation;
            }
        }
 
        public void Rotate(Vector3 rotation)
        {
            Matrix4x4 rotationMatrixX = Matrix4x4.CreateRotationX(rotation.X);
            Matrix4x4 rotationMatrixY = Matrix4x4.CreateRotationY(rotation.Y);
            Matrix4x4 rotationMatrixZ = Matrix4x4.CreateRotationZ(rotation.Z);
 
            Matrix4x4 combinedRotation = rotationMatrixX * rotationMatrixY * rotationMatrixZ;
 
            for (int i = 0; i < points.Count; i++)
            {
                points[i] = Vector3.Transform(points[i], combinedRotation);
            }
        }
 
        public void Scale(Vector3 scale)
        {
            for (int i = 0; i < points.Count; i++)
            {
                points[i] *= scale;
            }
        }
 
        public Matrix4x4 GetTransformationMatrix()
        {
            return Matrix4x4.Identity;
        }
 
        public List<Vector3> TransformPoints(Matrix4x4 transformationMatrix)
        {
            List<Vector3> transformedPoints = new List<Vector3>();
 
            foreach (var point in points)
            {
                transformedPoints.Add(Vector3.Transform(point, transformationMatrix));
            }
 
            return transformedPoints;
        }
    }
}