procedure Triangle(vA,vB,vC:tV3DVertex;where:gfxImage);
var
     v1,v2,v3:tV3DVertex;
     color:longint;

     X1,X2,X3,Y1,Y2,Y3,Z1,Z2,Z3:longint;

     DX12,DX23,DX31,DY12,DY23,DY31:longint;
     FDX12,FDX23,FDX31,FDY12,FDY23,FDY31:longint;

     minx,maxx,miny,maxy:longint;

     C1,C2,C3:longint;

     CX1,CX2,CX3,CY1,CY2,CY3:longint;

     a,b,c,D:longint;
     Z:longint;
     initialZ:Longint;
     ddx,ddy:Longint;

     x,y:longint;

     my16:Longint;
begin


MakeProjection(vA,v1.X,v1.Y,v1.Z);
MakeProjection(vB,v2.X,v2.Y,v2.Z);
MakeProjection(vC,v3.X,v3.Y,v3.Z);



asm
     mov eax,16
     mov my16,eax
//  Y1:= round(16.0 * v1.y);
   finit
    fild my16
     fld v1.y
    fmul
    fist Y1
//  Y2:= round(16.0 * v2.y);
   finit
    fild my16
     fld v2.y
    fmul
    fist Y2
//  Y3:= round(16.0 * v3.y);
   finit
    fild my16
     fld v3.y
    fmul
    fist Y3
//  X1:= round(16.0 * v1.x);
   finit
    fild my16
     fld v1.x
    fmul
    fist X1
//  X2:= round(16.0 * v2.x);
  finit
   fild my16
     fld v2.x
    fmul
    fist X2
//  X3:= round(16.0 * v3.x);
  finit
   fild my16
     fld v3.x
    fmul
    fist X3
//   Z1:= round(16.0 * v1.z);
   finit
    fild my16
     fld v1.z
    fmul
    fist Z1
//Z2:= round(16.0 * v2.z);
   finit
    fild my16
     fld v2.z
    fmul
    fist Z2
//   Z3:= round(16.0 * v3.z);
   finit
    fild my16
     fld v3.z
    fmul
    fist Z3

// color:=RGB32(vA.r,vA.g,vA.b);
    mov ah,vA.r
    mov al,vA.g
    mov cl,vA.b
    and eax,$0000ffff
    shl eax,8
    mov al,cl
    mov color,eax

//        a:= ((y2 - y1)*(z3 - z1) shr 4) - ((y3 - y1)*(z2 - z1) shr 4);
    mov esi,z1
    mov edi,y1

    mov eax,z2
    sub eax,esi
    mov ebx,y3
    sub ebx,edi
   imul eax,ebx
    shr eax,4

    mov ebx,z3
    sub ebx,esi
    mov ecx,y2
    sub ecx,edi
   imul ebx,ecx
    shr ebx,4

    sub ebx,eax
    mov a,ebx

// b:= ((x2 - x1)*(z3 - z1) shr 4) - ((x3 - x1)*(z2 - z1) shr 4);
    mov edi,x1

    mov eax,z2
    sub eax,esi
    mov ebx,x3
    sub ebx,edi
   imul eax,ebx
    shr eax,4

    mov ebx,z2
    sub ebx,esi
    mov ecx,x2
    sub ecx,edi
   imul ebx,ecx
    shr ebx,4

    sub ebx,eax
    mov b,ebx

//  c:= ((x2 - x1)*(y3 - y1) shr 4) - ((x3 - x1)*(y2 - y1) shr 4);
    mov esi,y1

    mov eax,y2
    sub eax,esi
    mov ebx,x3
    sub ebx,edi
   imul eax,ebx
    shr eax,4

    mov ebx,y3
    sub ebx,esi
    mov ecx,x2
    sub ecx,edi
   imul ebx,ecx
    shr ebx,4

    sub ebx,eax
    mov c,ebx

// D:= (-x1*a) shr 4 + (y1*b) shr 4 - (z1*c) shr 4;
   imul esi,b
    shr esi,4

    mov eax,z1
   imul eax,c
    shr eax,4
    sub esi,eax

    mov eax,x1
    neg eax
   imul eax,a
    shr eax,4

    add eax,esi
    mov d,eax




//    DX12:= X1 - X2;
//    FDX12:= DX12 shl 4;
    mov esi,x1
    mov edi,x2
    mov edx,x3

    mov eax,esi
    sub eax,edi
    mov DX12,eax
    shl eax,4
    mov FDX12,eax
//    DX23:= X2 - X3;
//    FDX23:= DX23 shl 4;
    mov eax,edi
    sub eax,edx
    mov DX23,eax
    shl eax,4
    mov FDX23,eax
//    DX31:= X3 - X1;
//    FDX31:= DX31 shl 4;
    sub edx,esi
    mov DX31,edx
    shl edx,4
    mov FDX31,edx

//    DY12:= Y1 - Y2;
//    FDY12:= DY12 shl 4;
    mov esi,y1
    mov edi,y2
    mov edx,y3

    mov eax,esi
    sub eax,edi
    mov DY12,eax
    shl eax,4
    mov FDY12,eax
//    DY23:= Y2 - Y3;
//    FDY23:= DY23 shl 4;
    mov eax,edi
    sub eax,edx
    mov DY23,eax
    shl eax,4
    mov FDY23,eax
//    DY31:= Y3 - Y1;
//    FDY31:= DY31 shl 4;
    sub edx,esi
    mov DY31,edx
    shl edx,4
    mov FDY31,edx



// minx:= round(min(x1,min(x2, x3))) shr 4;
    mov esi,x1
    mov edi,x2
    mov edx,x3


    mov eax,esi
    mov ebx,edi
    mov ecx,edx


    cmp ebx,ecx
     jb @l1
    mov ebx,ecx
@l1:
    cmp eax,ebx
     jb @l2
    mov eax,ebx
@l2:
    shr eax,4
    mov minx,eax

//      maxx:= round(max(x1,max(x2, x3))) shr 4;
    mov eax,esi
    mov ebx,edi
    mov ecx,edx

    cmp ebx,ecx
     ja @l3
    mov ebx,ecx
@l3:
    cmp eax,ebx
     ja @l4
    mov eax,ebx
@l4:
    shr eax,4
    mov maxx,eax



    mov esi,y1
    mov edi,y2
    mov edx,y3

//        miny:= round(min(y1,min(y2, y3))) shr 4;
    mov eax,esi
    mov ebx,edi
    mov ecx,edx

    cmp ebx,ecx
     jb @l5
    mov ebx,ecx
@l5:
    cmp eax,ebx
     jb @l6
    mov eax,ebx
@l6:
    shr eax,4
    mov miny,eax

//        maxy:= round(max(y1,max(y2, y3))) shr 4;
    mov eax,esi
    mov ebx,edi
    mov ecx,edx

    cmp ebx,ecx
     ja @l7
    mov ebx,ecx
@l7:
    cmp eax,ebx
     ja @l8
    mov eax,ebx
@l8:
    shr eax,4
    mov maxy,eax



 //   C1:= DY12 * X1 - DX12 * Y1;
    mov eax,DX12
   imul eax,esi
    mov ebx,DY12
   imul ebx,X1
    sub ebx,eax
    mov C1,ebx
//    C2:= DY23 * X2 - DX23 * Y2;
    mov eax,DX23
   imul eax,edi
    mov ebx,DY23
   imul ebx,X2
    sub ebx,eax
    mov C2,ebx
//   C3:= DY31 * X3 - DX31 * Y3;
    mov eax,DX31
   imul eax,edx
    mov ebx,DY31
   imul ebx,X3
    sub ebx,eax
    mov C3,ebx


//    if (DY12 < 0) or ((DY12 = 0) and (DX12 > 0)) then inc(C1);
    mov eax,DY12
    cmp eax,0
     jb @l9
    mov eax,DY12
    cmp eax,0
    jne @l10
    mov eax,DX12
    cmp eax,0
     jb @l10
@l9:
    inc C1
@l10:


//    if (DY23 < 0) or ((DY23 = 0) and (DX23 > 0)) then inc(C2);
    mov eax,DY23
    cmp eax,0
     jb @l12
    mov eax,DY23
    cmp eax,0
    jne @l11
    mov eax,DX23
    cmp eax,0
     jb @l12
@l11:
    inc C2
@l12:

//    if (DY31 < 0) or ((DY31 = 0) and (DX31 > 0)) then inc(C3);
    mov eax,DY31
    cmp eax,0
    jb @l14
    mov eax,DY31
    cmp eax,0
    jne @l13
    mov eax,DX31
    cmp eax,0
    jb @l14
@l13:
    inc C3
@l14:





//    CY1:= C1 + DX12 * (miny shl 4) - DY12 * (minx shl 4);
     mov esi,miny
     shl esi,4
     mov edi,minx
     shl edi,4

     mov eax,DX12
    imul eax,esi
     mov ebx,DY12
    imul ebx,edi
     sub eax,ebx
     add eax,C1
     mov CY1,eax
//    CY2:= C2 + DX23 * (miny shl 4) - DY23 * (minx shl 4);
     mov eax,DX23
    imul eax,esi
     mov ebx,DY23
    imul ebx,edi
     sub eax,ebx
     add eax,C2
     mov CY2,eax

//    CY3:= C3 + DX31 * (miny shl 4) - DY31 * (minx shl 4);
     mov eax,DX31
    imul eax,esi
     mov ebx,DY31
    imul ebx,edi
     sub eax,ebx
     add eax,C3
     mov CY3,eax

//  if (c shr 4) = 0 then exit;

     mov eax,c
     shr eax,4
     cmp eax,0
     jne @ok
     jmp @L1
    @ok:

//   initialZ:= (((A * -(minx)) shr 4 + ((B * -(miny)) shr 4 -D)) div (C shr 4));



    mov eax,minx
    neg eax
   imul eax,A
    shr eax,4

    mov ebx,miny
    neg ebx
   imul ebx,B
    shr ebx,4
    sub ebx,D
    add eax,ebx

    mov ebx,C
    shr ebx,4
    cdq
   idiv ebx

    mov initialZ,eax



//    ddx:= ((-A) div (C shr 4));

    mov eax,A
    neg eax
    cdq
   idiv ebx
    mov ddx,eax

//    ddy:= ((-B) div (C shr 4));
    mov eax,B
    neg eax
    cdq
   idiv ebx
    mov ddy,eax

//    for y:= miny to maxy do begin

      mov eax,miny
      mov y,eax
@YLoop:

        //  CX1:=CY1;
         mov eax,CY1
         mov CX1,eax
        // CX2:=CY2;
         mov eax,CY2
         mov CX2,eax
        //CX3:=CY3;
         mov eax,CY3
         mov CX3,eax

        //Z:=initialZ;
         mov eax,initialZ
         mov Z,eax

//        for x:=minx to maxx do begin
         mov eax,minx
         mov x,eax
         @XLoop:


//            if (CX1 > 0) and (CX2 > 0) and (CX3 > 0) then begin
                  mov eax,CX1
                  cmp eax,0
                  jle @SkipPixel
                  mov eax,CX2
                  cmp eax,0
                  jle @SkipPixel
                  mov eax,CX3
                  cmp eax,0
                  jle @SkipPixel


//                  Z:=Z+ddx;

                   mov edx,z
                   add edx,ddx
                   mov z,edx
//                 tempZ:=z-(zAddValue shl 4);
                   mov eax,zAddValue
                   shl eax,4
                   sub edx,eax
                   mov esi,edx   // tempZ
                // if tempZ < getL(zbuffer+(y * xscale + x) shl 2) then begin

                 //      PutPixel32(x, y, color, where);

                 mov eax,x
                 mov edx,y
                 mov ecx,color

                imul edx,where.width
                 add edx,eax
                 shl edx,2

                 mov edi,edx

                 add edi,zBuffer
                 mov eax,esi   // tempZ
                 cmp eax,[edi]
                 jle @SkipPixel

                 mov [edi],eax

                 add edx,where.data
                 mov [edx],ecx
         @SkipPixel:

                     //   putL(zbuffer+(y*xscale + x) shl 2,tempZ);
                  //end;

//            CX1:=CX1-FDY12;
              mov eax,CX1
              sub eax,FDY12
              mov CX1,eax
//            CX2:=CX2-FDY23;
              mov eax,CX2
              sub eax,FDY23
              mov CX2,eax
//            CX3:=CX3-FDY31;
              mov eax,CX3
              sub eax,FDY31
              mov CX3,eax


        mov eax,x
        inc eax
        mov x,eax
        cmp eax,maxx
         jbe @Xloop
//        jmp @XLoop

//        initialZ:=initialZ+ddy;
          mov eax,initialZ
          add eax,ddy
          mov initialZ,eax

//        CY1:=CY1+FDX12;
          mov eax,CY1
          add eax,FDX12
          mov CY1,eax
//        CY2:=CY2+FDX23;
          mov eax,CY2
          add eax,FDX23
          mov CY2,eax
//        CY3:=CY3+FDX31;
          mov eax,CY3
          add eax,FDX31
          mov CY3,eax

        inc y
        mov eax,y
        cmp eax,maxy
        jbe @Yloop
  @Q1:

end;
end;