anchor.diff:  
     end;
   
  -  Tvec3 = class
  +  Tvec3 = class(TObject)
       private
  -      var hx,hy,hz: real;
  +      hx,hy,hz: real;
  +
  +      class function TDown: Tvec3; static;
  +      class function TUp: Tvec3; static;
  +      class function TLeft: Tvec3;  static;
  +      class function TRight: Tvec3;  static;
  +      class function TForward: Tvec3; static;
  +      class function TBackward: Tvec3; static;
   
       public
         constructor Create(tx: real = 0; ty: real = 0; tz: real = 0);
  
positive.code: //Warning: I can't find any document about template function
  //Therefore, i can't solve Dot func duplication
  
  unit Vector;
  
  
negative.code:                             Cross.Z := para1.X * para2.Y - para1.Y * para2.X;
                end;
  
                constructor Tvec4.Create(tx: real = 0; ty: real = 0; tz: real = 0; tw: real = 0);
                begin
                              hx:= tx; hy:= ty; hz:= tz; hw:= tw;
                end;
  
                constructor Tvec4.Create(t1: Tvec3; t2: real = 0);
                begin
                              hx:= t1.X; hy:= t1.Y; hz:= t1.Z; hw:= t2;
                end;
  
                function Tvec4.Length: real;
                begin
                              Length:= Sqrt(Power(hx,2) + Power(hy,2) +
                              Power(hz,2) + Power(hw,2));
                end;
  
                function Tvec4.Normalize: Tvec4;
                var tmp: real;
                begin
                              tmp:= Sqrt(Power(hx,2) + Power(hy,2) +
                              Power(hz,2) + Power(hw,2));
                              Normalize:= self/ tmp;
                end;
  
                operator + (para1, para2: Tvec4) add: Tvec4;
                begin
                           add := Tvec4.Create;
                           add.X := para1.X + para2.X;
                           add.Y := para1.Y + para2.Y;
                           add.Z := para1.Z + para2.Z;
                           add.W := para1.W + para2.W;
                end;
  
                operator - (para1, para2: Tvec4) sub: Tvec4;
                begin
                           sub := Tvec4.Create;
                           sub.X := para1.X - para2.X;
                           sub.Y := para1.Y - para2.Y;
                           sub.Z := para1.Z - para2.Z;
                           sub.W := para1.W - para2.W;
                end;
  
                operator * (para1, para2: Tvec4) mul: Tvec4;
                begin
                           mul := Tvec4.Create;
                           mul.X := para1.X * para2.X;
                           mul.Y := para1.Y * para2.Y;
                           mul.Z := para1.Z * para2.Z;
                           mul.W := para1.W * para2.W;
                end;
  
                operator / (para1, para2: Tvec4) divide: Tvec4;
                begin
                           divide := Tvec4.Create;
                           divide.X := para1.X / para2.X;
                           divide.Y := para1.Y / para2.Y;
                           divide.Z := para1.Z / para2.Z;
                           divide.W := para1.W / para2.W;
                end;
  
                operator + (para1:Tvec4 ; para2: real) addf: Tvec4;
                begin
                           addf := Tvec4.Create;
                           addf.X := para1.X + para2;
                           addf.Y := para1.Y + para2;
                           addf.Z := para1.Z + para2;
                           addf.W := para1.W + para2;
                end;
  
                operator - (para1:Tvec4 ; para2: real) subf: Tvec4;
                begin
                           subf := Tvec4.Create;
                           subf.X := para1.X - para2;
                           subf.Y := para1.Y - para2;
                           subf.Z := para1.Z - para2;
                           subf.W := para1.W - para2;
                end;
  
                operator * (para1:Tvec4 ; para2: real) mulf: Tvec4;
                begin
                           mulf := Tvec4.Create;
                           mulf.X := para1.X * para2;
                           mulf.Y := para1.Y * para2;
                           mulf.Z := para1.Z * para2;
                           mulf.W := para1.W * para2;
                end;
  
                operator / (para1:Tvec4 ; para2: real) dividef: Tvec4;
                begin
                           dividef := Tvec4.Create;
                           dividef.X := para1.X / para2;
                           dividef.Y := para1.Y / para2;
                           dividef.Z := para1.Z / para2;
                           dividef.W := para1.W / para2;
                end;
  
  end.
  
  
  