public class Triangle : Intersectable
    {       
        public Vertex A;
        public Vertex B;
        public Vertex C;
        public Matrix4d Transformations;
        public Matrix4d Affine;       

        public override double Intersect(Ray ray)
        {
            ray.Origin = Vector4d.Transform(new Vector4d(ray.Origin, 1.0d), Transformations).Xyz; //Translation wird ignoriert!?!
            ray.Direction = Vector3d.Transform(ray.Direction, Affine); //Skalierung wird berücksichtigt, daher ist Rückskalierung nicht nötig
            if (ray.Direction.Y == 0.0d)
            {
                return -1.0d;
            }
            double distance = -ray.Origin.Y / ray.Direction.Y; //liegt auf XZ Ebene
            Vector3d Pos = ray.Origin + ray.Direction * distance;
            double absPosX = Pos.X < 0.0d ? -Pos.X : Pos.X;
            if (absPosX + Pos.Z > 1.0d || Pos.Z < 0.0d)
            {
                return -1.0d; //nicht getroffen
            }
            return distance;
        }

        public override Vertex Evaluate(Vector3d position, Ray ray)
        {
            Vector3d pos = Vector3d.Transform(position, Transformations);
            double ab = (pos.X + 1.0d) * 0.5d;           
            double aPart = ab - pos.Z * 0.5;
            double bPart = (1.0d - ab) - pos.Z * 0.5d;
            float a = (float)aPart;
            float b = (float)bPart;
            float c = (float)pos.Z;
            return Vertex.Create(position, A.Normal * aPart + B.Normal * bPart + C.Normal * pos.Z, A.Diffuse * a + B.Diffuse * b + C.Diffuse * c, A.Specular * a + B.Specular * b + C.Specular * c);
        }   

       
        public Triangle(Vertex _A, Vertex _B, Vertex _C)
        {
            A = _A;
            B = _B;
            C = _C;
            Vector3d AB = (_B.Pos - _A.Pos) * 0.5d;
            Vector3d Pos = (_A.Pos + _B.Pos) * 0.5d;
            Vector3d Height = _C.Pos - Pos;
            Vector3d N = Vector3d.Normalize(Vector3d.Cross(AB, Height));
            Transformations = new Matrix4d(AB.X, AB.Y, AB.Z, Pos.X, N.X, N.Y, N.Z, Pos.Y, Height.X, Height.Y, Height.Z, Pos.Z, 0.0d, 0.0d, 0.0d, 1.0d);
            Affine = Transformations;
            Affine.Row0.W = 0.0d;
            Affine.Row1.W = 0.0d;
            Affine.Row2.W = 0.0d;
            Affine.Row3.W = 1.0d;
            Affine.Row3.Z = 0.0d;
            Affine.Row3.Y = 0.0d;
            Affine.Row3.X = 0.0d;
            Transformations = Matrix4d.Invert(Transformations);
            Affine = Matrix4d.Invert(Affine);                             
              //Transformationen berechnen, die das Dreieck A = (-1, 0, 0) B = (1, 0, 0) C = (0, 0, 1) auf das Angegebene Dreieck abbilden, und diese dann umkehren.
        }
    }

new Matrix4d(AB.X, AB.Y, AB.Z, 0.0d, N.X, N.Y, N.Z, 0.0d, Height.X, Height.Y, Height.Z, 0.0d, Pos.X, Pos.Y, Pos.Z, 1.0d);