//Transform each vector (float[3]) of source array and write result into
//destination array; transformation is done by multiplying 4x4 matrix (it is
//assumed to be stored column-by-column) onto each of the source vectors with
//resulting vector stored in the corresponding position in the destination array
//It is assumed that w component of all vectors are 1
//The formula is the following:
//v2[0]=m[0]*v1[0]+m[4]*v1[1]+m[8]*v1[2]+m[12];
//v2[1]=m[1]*v1[0]+m[5]*v1[1]+m[9]*v1[2]+m[13]; 
//v2[2]=m[2]*v1[0]+m[6]*v1[1]+m[10]*v1[2]+m[14];
void __declspec(naked) __stdcall
TransformVertices3f(const void *Matrix4x4f_ColumnMajor,
                    const void *ArrayOfVec3f_Source,
                          void *ArrayOfVec3f_Destination,
                    unsigned int VertexCount){
 _asm{
  //Load pointers and counter
  mov eax,[esp+4]; //Move pointer to the matrix into accumulator
  mov esi,[esp+8]; //Move pointer to the source array into esi
  mov edi,[esp+12];//Move pointer to the destination array into edi
  mov ecx,[esp+16];//Move quantity of vectors into counter register
  //Load matrix
  movups xmm0,[eax   ]; //Load first column of matrix into xmm0
  movups xmm1,[eax+16]; //Load second column of matrix into xmm1
  movups xmm2,[eax+32]; //Load third column of matrix into xmm2
  movups xmm3,[eax+48]; //Load forth column of matrix into xmm3
  //Prepare writing mask
  mov eax,0x80808080;   //Set the high bits of 4 bytes of eax to 1's
  movd xmm7,eax;        //Move this mask into xmm7 low dword
  shufps xmm7,xmm7,0xC0;//Distribute mask pattern across first 3 dwords of xmm7
  //Vertex transformation' cycle
  LABEL_CYCLE_START:
   movups xmm4,[esi]; //Load vector {x,y,z,?} into xmm4
   pshufd xmm5,xmm4,0x00;//Load {x,x,x,x} into xmm5
   mulps xmm5,xmm0;     //Multiply first column of matrix by x
   pshufd xmm6,xmm4,0x55;//Load {y,y,y,y} into xmm6
   mulps xmm6,xmm1;     //Multiply second column of matrix by y
   addps xmm5,xmm6;    //Summ intermidiate results
   pshufd xmm6,xmm4,0xAA;//Load {z,z,z,z} into xmm6
   mulps xmm6,xmm2;     //Multiply third column of matrix by z
   addps xmm5,xmm6;    //Summ intermidiate results
   addps xmm5,xmm3;      //Add forth column of matrix to the result
   maskmovdqu xmm5,xmm7; //Write 3 dwords into destination buffer
   add esi,12; //Advance pointer to the source array by 12 bytes
   add edi,12; //Advance pointer to the destination array by 12 bytes
   loop LABEL_CYCLE_START;
  //Exit
  ret 16; //Return from function cleaning up the stack
 }
}
//______________________________________________________________________________

//Transform each vector (float[3]) of source array and write result into
//destination array; transformation is done by multiplying 4x4 matrix (it is
//assumed to be stored column-by-column) onto each of the source vectors with
//resulting vector stored in the corresponding position in the destination array
//It is assumed that w component of all vectors are 1
//The formula is the following:
//Vdst[0]=m[0]*Vsrc[0]+m[4]*Vsrc[1]+m[8]*Vsrc[2]+m[12];
//Vdst[1]=m[1]*Vsrc[0]+m[5]*Vsrc[1]+m[9]*Vsrc[2]+m[13];
//Vdst[2]=m[2]*Vsrc[0]+m[6]*Vsrc[1]+m[10]*Vsrc[2]+m[14];
void __declspec(naked) __stdcall
TransformVertices3f(const void *Matrix4x4f_ColumnMajor,
                    const void *ArrayOfVec3f_Source,
                          void *ArrayOfVec3f_Destination,
                    unsigned int VertexCount){
 _asm{
  //Load pointers and counter
  mov eax,[esp+4]; //Move pointer to the matrix into accumulator
  mov esi,[esp+8]; //Move pointer to the source array into esi
  mov edi,[esp+12];//Move pointer to the destination array into edi
  mov ecx,[esp+16];//Move quantity of vectors into counter register
  //Load matrix
  movups xmm0,[eax   ]; //Load {m[0],m[1],m[2],m[3]} into xmm0
  movups xmm1,[eax+16]; //Load {m[4],m[5],m[6],m[7]} into xmm1
  movups xmm2,[eax+32]; //Load {m[8],m[9],m[10],m[11]} into xmm2
  movups xmm3,[eax+48]; //Load {m[12],m[13],m[14],m[15]} into xmm3
  //Reorder matrix elements (it will help to cheat 1 op per cycle)
  shufps xmm0,xmm0,0x9C; //xmm0: {m[0],m[3],m[1],m[2]}
  shufps xmm1,xmm1,0x9C; //xmm1: {m[4],m[7],m[5],m[6]}
  shufps xmm2,xmm2,0x9C; //xmm2: {m[8],m[11],m[9],m[10]}
  shufps xmm3,xmm3,0x9C; //xmm3: {m[12],m[15],m[13],m[14]}
  //Start of vertex transformation' cycle
  LABEL_CYCLE_START:
   //Load vector {x,y,z,?} into xmm4
   movups xmm4,[esi];
   //Perform transformation
   pshufd xmm5,xmm4,0x55;//Load {y,y,y,y} into xmm5
   mulps xmm5,xmm1;      //Mult {m[4],m[7],m[5],m[6]} and y
   pshufd xmm6,xmm4,0xAA;//Load {z,z,z,z} into xmm6
   addps xmm5,xmm3;      //Add {m12,m15,m13,m14} to y*{m4,m7,m5,m6}
   mulps xmm6,xmm2;      //Mult {m[8],m[11],m[9],m[10]} and z
   shufps xmm4,xmm4,0x00;//Load {x,x,x,x} into xmm4
   addps xmm5,xmm6; //xmm5 = y*{m4,m7,m5,m6}+z*{m8,m11,m9,m10}+{m12,m15,m13,m14}
   mulps xmm4,xmm0;      //Mult {m[0],m[3],m[1],m[2]} and x
   addps xmm4,xmm5;      //xmm4 = {Xt,Wt,Yt,Zt}
   //Write resulting vector: x and then y&z
   movss [edi],xmm4;    //Write x
   movhps [edi+4],xmm4; //Write y and z
   //Advance arrays' pointers to the next vector position
   add esi,12; //Advance pointer to the source array by 12 bytes
   add edi,12; //Advance pointer to the destination array by 12 bytes
   loop LABEL_CYCLE_START; //Jump to the beginning of the cycle
  //Exit
  ret 16; //Return from function cleaning up the stack
 }
}
//______________________________________________________________________________

void __declspec(naked) __stdcall
TransformVertices3fx4(const void *Matrix4x4f_ColumnMajor,
                      const void *ArrayOfVec3f_Source,
                            void *ArrayOfVec3f_Destination,
                      unsigned int VertexCount){
 _asm{
  //Load pointers and counter
  mov eax,[esp+4]; //Move pointer to the matrix into accumulator
  mov esi,[esp+8]; //Move pointer to the source array into esi
  mov edi,[esp+12];//Move pointer to the destination array into edi
  mov ecx,[esp+16];//Move quantity of vectors into counter register
  //Load matrix
  movups xmm0,[eax   ]; //Load {m[0],m[1],m[2],m[3]} into xmm0
  movups xmm1,[eax+16]; //Load {m[4],m[5],m[6],m[7]} into xmm1
  movups xmm2,[eax+32]; //Load {m[8],m[9],m[10],m[11]} into xmm2
  movups xmm3,[eax+48]; //Load {m[12],m[13],m[14],m[15]} into xmm3

  //Start of vertex transformation' cycle
  LABEL_CYCLE_4_START:
   movups xmm4,[esi];   //Load {x1,y1,z1,x2} into xmm4

     //xmm4:{x1,y1,z1,x2}; xmm5:{-,-,-,-}; xmm6:{-,-,-,-}; xmm7:{-,-,-,-}

   pshufd xmm6,xmm4,00000000b;//Load {x1,x1,x1,x1} into xmm6
    mulps xmm6,xmm0;         //Mult {m0...m3} and x1
     addps xmm6,xmm3;       //xmm6: {m0...m3}*x1 + {m12...m15}
   pshufd xmm7,xmm4,01010101b;//Load {y1,y1,y1,y1} into xmm7
    mulps xmm7,xmm1;         //Mult {m4...m7} and y1
     addps xmm6,xmm7;       //xmm6: {m0...m3}*x1 + {m4...m7}*y1 + {m12...m15}
   pshufd xmm7,xmm4,10101010b;//Load {z1,z1,z1,z1} into xmm7
    mulps xmm7,xmm2;         //Mult {m8...m11} and z1
     addps xmm6,xmm7;       //xmm6: {X1,Y1,Z1,W1}

   movups xmm5,[esi+16];//Load {y2,z2,x3,y3} into xmm5

     //xmm4:{-,-,-,x2}; xmm5:{y2,z2,x3,y3}; xmm6:{X1,Y1,Z1,-}; xmm7:{-,-,-,-}

   shufps xmm4,xmm4,11111111b;//Load {x2,x2,x2,x2} into xmm4
    mulps xmm4,xmm0;         //Mult {m0...m3} and x2
     addps xmm4,xmm3;       //xmm4: {m0...m3}*x2 + {m12...m15}
   pshufd xmm7,xmm5,00000000b;//Load {y2,y2,y2,y2} into xmm7
    mulps xmm7,xmm1;         //Mult {m4...m7} and y2
     addps xmm4,xmm7;       //xmm4: {m0...m3}*x2 + {m4...m7}*y2 + {m12...m15}
   pshufd xmm7,xmm5,01010101b;//Load {z2,z2,z2,z2} into xmm7
    mulps xmm7,xmm2;         //Mult {m8...m11} and z2
     addps xmm7,xmm4;       //xmm7: {X2,Y2,Z2,W2}

     //xmm4:{-,-,-,-}; xmm5:{-,-,x3,y3}; xmm6:{X1,Y1,Z1,-}; xmm7:{X2,Y2,Z2,-}

   movups xmm4,[esi+32];      //Load {z3,x4,y4,z4} into xmm4
   shufps xmm6,xmm6,00100100b;//Get {X1,Y1,Z1, X1} in xmm6
   movss xmm6,xmm7;           //Get {X2,Y1,Z1, X1} in xmm6
   shufps xmm6,xmm6,00100111b;//Get {X1,Y1,Z1, X2} in xmm6
   add esi,48; //Advance pointer to the source array by 48 bytes
   movups [edi],xmm6;         //Store {X1,Y1,Z1,X2} into destination buffer

     //xmm4:{z3,x4,y4,z4}; xmm5:{-,-,x3,y3}; xmm6:{-,-,-,-}; xmm7:{-,Y2,Z2,-}

   pshufd xmm6,xmm5,10101010b;//Load {x3,x3,x3,x3} into xmm6
    mulps xmm6,xmm0;         //Mult {m0...m3} and x3
     addps xmm6,xmm3;       //xmm6: {m0...m3}*x3 + {m12...m15}
   shufps xmm5,xmm5,11111111b;//Load {y3,y3,y3,y3} into xmm5
    mulps xmm5,xmm1;         //Mult {m4...m7} and y3
     addps xmm5,xmm6;       //xmm5: {m0...m3}*x3 + {m4...m7}*y3 + {m12...m15}
   pshufd xmm6,xmm4,00000000b;//Load {z3,z3,z3,z3} into xmm6
    mulps xmm6,xmm2;         //Mult {m8...m11} and z3
     addps xmm6,xmm5;       //Get {X3,Y3,Z3,W3} in xmm6

     //xmm4:{-,x4,y4,z4}; xmm5:{-,-,-,-}; xmm6:{X3,Y3,Z3,-}; xmm7:{-,Y2,Z2,-}

   shufps xmm7,xmm6,01001001b;//Get {Y2,Z2,X3,Y3} in xmm7
   movups [edi+16],xmm7;      //Store {Y2,Z2,X3,Y3} into destination buffer

     //xmm4:{-,x4,y4,z4}; xmm5:{-,-,-,-}; xmm6:{-,-,Z3,-}; xmm7:{-,-,-,-}

   pshufd xmm5,xmm4,01010101b;//Load {x4,x4,x4,x4} into xmm5
    mulps xmm5,xmm0;         //Mult {m0...m3} and x4
     addps xmm5,xmm3;       //xmm5: {m0...m3}*x4 + {m12...m15}
   pshufd xmm7,xmm4,10101010b;//Load {y4,y4,y4,y4} into xmm7
    mulps xmm7,xmm1;         //Mult {m4...m7} and y4
     addps xmm5,xmm7;       //xmm5: {m0...m3}*x4 + {m4...m7}*y4 + {m12...m15}
   shufps xmm4,xmm4,11111111b;//Load {z4,z4,z4,z4} into xmm4
    mulps xmm4,xmm2;         //Mult {m8...m11} and z4
     addps xmm5,xmm4;       //Get {X4,Y4,Z4,W4} in xmm5

     //xmm4:{-,-,-,-}; xmm5:{X4,Y4,Z4,-}; xmm6:{-,-,Z3,-}; xmm7:{-,-,-,-}

   movss xmm6,xmm5;           //Get {X4,-,Z3,-} in xmm6
   shufps xmm6,xmm5,10010010b;//Get {Z3,X4,Y4,Z4} in xmm6
   movups [edi+32],xmm6;      //Store {Z3,X4,Y4,Z4} into destination buffer
   add edi,48; //Advance pointer to the destination array by 48 bytes
   sub ecx,4;
   jnz LABEL_CYCLE_4_START; //Jump to the beginning of the cycle

  //Exit
  LABEL_EXIT:
  ret 16; //Return from function cleaning up the stack
 }
}
//______________________________________________________________________________