macro FindWordBig txt,mtk,[znk] {  
         common  local .1,ss
        mov eax,txt
         ss = 0
.1:      inc  eax
         cmp  byte  [eax],0
         jz   mtk
         forward
         cmp   [eax+ss],znk
         jnz  .1
       match c e, znk \{
       ;display c
       if c eq dword
            ss = ss+4
       else if c eq word
            ss = ss+2
       else if c eq byte
            ss = ss+1
       end if
       \}
           common
           add eax,ss
       }
macro enum app,[pp] {
       common
       struct app
       forward
       pp dd 0
       common
ends
      }
macro cNameFile chNam { local .l1,.ll
      jmp  .ll
      .l1 db chNam,0
.ll:  mov  eax,.l1
      }
macro RegsNameFile [chNam] { common
        Rr1 equ esi
        Rr1 equ ebx 
        Rr1 equ ecx
        Rr1 equ edx
        Rr1 equ eax
        forward
      local .l1,.ll
      jmp  .ll
      .l1 db chNam,0
.ll:  mov  Rr1,.l1
        restore Rr1
      }  
macro Fill address,[value] {
 common
  local i
  i = 0
  Mov eax, address
 forward
  Mov dword[eax + i], value
  i = i + 4
}
struc GUID def
 {
   match d1-d2-d3-d4-d5, def
    \{
      .Data1 dd 0x\#d1
      .Data2 dw 0x\#d2
      .Data3 dw 0x\#d3
      .Data4 db 0x\#d4 shr 8,0x\#d4 and 0FFh
      .Data5 db 0x\#d5 shr 40,0x\#d5 shr 32 and 0FFh,\
		0x\#d5 shr 24 and 0FFh,\
		0x\#d5 shr 16 and 0FFh,\
		0x\#d5 shr 8 and 0FFh,0x\#d5 and 0FFh
    \}
 }
macro CopyDoZnaka chFrom,chTo,chZnk { local h1,hh
	mov edx,chFrom
	mov ecx,chTo
h1:	mov al,[edx]
	test al,al
	jz  hh
	cmp al,chZnk
	jz  hh
	mov [ecx],al
	inc edx
	inc ecx
	jmp h1
hh:	mov word [ecx],0
	}
macro CopyMatrix chFrom,chTo { movups xmm1,dqword [chFrom]
	movups xmm2,dqword [chFrom+16]
	movups xmm3,dqword [chFrom+32]
	movups xmm4,dqword [chFrom+48]
	movups dqword [chTo],xmm1
	movups dqword [chTo+16],xmm2
	movups dqword [chTo+32],xmm3
	movups dqword [chTo+48],xmm4
				}
macro CheckMultisample chMSAA { local l1,l2
			DX11Call  pd3dDevice11,CheckMultisampleQualityLevels,DXGI_FORMAT_R8G8B8A8_UNORM,chMSAA,Status
	mov  ebp,1
	cmp dword [Status],0
	jnz  l1
	Msg `chMSAA#'x MSAA not supported !'
	mov  ebp,0
	jmp  l2
    l1: Msg `chMSAA#'x MSAA YES !' 
    l2: mov eax,ebp
	test eax,eax
			}
macro KeyHalt chKey,chMetka {local M1,M2,KeyHlt,OldKey

	       cmp  dword [OldKey],chKey
	       jz   M1
	       cmp    dword [KeyPr],chKey
	       jnz   chMetka
       M1:     mov    [KeyPr],0
	       mov  dword [OldKey],chKey
	       inc   byte [KeyHlt]
	       cmp   byte [KeyHlt],16	;zadergka
	       jbe   chMetka
	       mov   byte [KeyHlt],0
	       mov   dword [OldKey],0
	       jmp   M2
       KeyHlt: db    0
       OldKey: dd    0
       M2:
	      } 
macro PeekMessag
{
	  mov	  [msg.message], TRUE;FALSE
	       .while  [msg.message] <> WM_QUIT
	       invoke  PeekMessage, addr msg, NULL, 0, 0, PM_REMOVE
	       .if     eax <> NULL
	       invoke  TranslateMessage, addr msg
	       invoke  DispatchMessage, addr msg
	       .else

}
macro Msg chTxt {invoke MessageBox,0,chTxt,'Message',0}
macro Block failname {include "CodeBlock\"#`failname}
macro	ShowShaderError
	     {
	     push	eax
	     DX11Call  pErrorBlob,GetBufferPointer
	     invoke    MessageBox,0,eax,0,0
	     pop	eax
	     }
macro	Load chname,chbuffer
	     { pushd chname
	     pop     eax
	     mov    edx,chbuffer
	     Call   LoadFile
	     }
macro	 TransVec  vertex,matrix,vertex2
{
	; fld  dword [vertex]
	; fadd [matrix]
	; fstp [vertex2]
	movss  xmm1,dword [vertex]
	addss  xmm1,dword [matrix]
	movss  dword [vertex2],xmm1
}

macro	 TransVec3  vertex,n1,n2,n3,matrix,vertex2
{
	; fld  dword [vertex+n1]
	; fadd	[matrix#._41]
	; fstp [vertex2#.x]
	; fld  dword [vertex+n2]
	; fadd [matrix#._42]
	; fstp [vertex2#.y]
	; fld  dword [vertex+n3]
	; fadd	[matrix#._43]
	; fstp [vertex2#.z]
	 movss	xmm1,dword [vertex+n1]
	 addss	xmm1,dword [matrix#._41]
	 movss	dword [vertex2#.x],xmm1
	 movss	xmm1,dword [vertex+n2]
	 addss	xmm1,dword [matrix#._42]
	 movss	dword [vertex2#.y],xmm1
	 movss	xmm1,dword [vertex+n3]
	 addss	xmm1,dword [matrix#._43]
	 movss	dword [vertex2#.z],xmm1
}
macro	 TransVec4  vertex,matrix,vertex2
{
	 movups  xmm1,dqword [vertex]
	 movups  xmm2,dqword [matrix#._41]
	 addps	xmm1,xmm2
	 movups  dqword [vertex2],xmm1
}

 macro	DX11PrintInt   cX,cY,cTxt,chVl
		       {local RuM,new,gbnn
			pushd cTxt#"            "
		      ; cinvoke sprintf,Status22,cTxt#"%d",chVl
		      ; jmp	gbnn
      RuM:	       popd    esi
		       mov     ebx,chVl
		       mov     ebp,RuM-1 ;Gluchit sprintf esli v mesto EBP sdelat EDI ! Ne budet cifr posle 1-go DX11PrintInt !
		       mov     dword [ebp-3],$00202020
		       mov     dword [ebp-7],'    '
		       mov     dword [ebp-11],'    '
      ;Nuyy:		mov	al,byte [esi]
      ; 		cmp	al,'%'
      ; 		jz	Hjj
      ; 		mov	byte [ebp],al
      ; 		inc	ebp
      ; 		inc	esi
      ; 		jmp	Nuyy
     ; Hjj:		movups	xmm7,dqword [Eraser]
      ; 		movups	dqword [ebp],xmm7
       ;		add	ebp,10
		       mov     eax,ebx
		       ;sub	ecx,ecx
		       mov     ebx,10
      new:
		       sub     edx,edx
		       div     ebx
		       add	dl,48
		       dec	ebp
		       mov	byte [ebp],dl
		      ; push	edx
		      ; mov	 byte [Status+1+ecx],dl
		      ; inc	ecx
		       test    eax,eax
		       jnz     new
      gbnn:	       DX11PrintAt cX,cY,esi
		       }
 macro	DX11PrintFloat cX,cY,cTxt,chVl
		       {
		       FloatToTxt chVl,cTxt;View._11,"VIEW11"
		       DX11PrintAt cX,cY,Status22
		       }
 macro SetScrolBar ch1,ch2,cVal,cCmnd,cVl
		   {   xor	   eax,eax
		       mov	   al,byte [ch1]
		       mov	   ecx,eax
		       mov	   ebx,cVl
		       cCmnd	   eax,ebx     ;.     0  255.
		       Call	   SetScrolBarA
		       add	   [ch2],eax
		       fstp	   [cVal]
		   }

 macro Frustum char1
{
mov   edx,frustumPlanes
Call  CmpFrustum
and   bl,bl
jz    char1
Call  DoFrust
and   bl,bl
jz    char1
Call  DoFrust
and   bl,bl
jz    char1
Call  DoFrust
and   bl,bl
jz    char1
}
macro	ScalePlanka	chW,chH
{
	Set   Wplanka._11,chW
	Set   Wplanka._22,chH
}
macro FloatToTxt ch1,txt
{		fld	dword [ch1]
		fstp	[resultq]
		cinvoke sprintf, Status22, txt#" %1.6f", double [resultq] }
macro TimeFPS	cspeed,ch1
{
		invoke timeGetTime
		mov    ebx,[Timelast]
		mov    [tmm],eax
		mov    ecx,eax
		sub    eax,ebx
		cmp    al,cspeed
		jb     ch1
		mov    [Timelast],ecx
}
macro DX11LoadTexture cTxtFile,cTxtName
{
invoke	  D3DX11CreateShaderResourceViewFromFile,[pd3dDevice11],cTxtFile,NULL,NULL,cTxtName,NULL
}
macro ReleaseAll char1,char2
{
mov	    eax,char2
sub	    eax,char1
shr	    eax,2
mov	    edx,char1
mov	    ebp,eax
Call	    Releas	;In DX11 Dungeon2a.asm
}
macro	BgnLoop   ch0,ch2
	{local	moll
	Met	EQU moll
	CyclNum EQU ch2
	Reg	EQU ch0
	sub	Reg,Reg
	moll:
	}
macro	EndLoop
	{
		inc	Reg
		cmp	Reg,CyclNum
		jb	Met
	}
macro	BgnLoop2  ch0,ch2
	{
	local	moll2
	CyclNm2 EQU ch2
	Reg2	EQU ch0
	Met2	EQU moll2
	xor	Reg2,Reg2
	moll2:
	}
macro	EndLoop2
	{
		inc	Reg2
		cmp	Reg2,CyclNm2
		jb	Met2
	}
macro	DoLoopInc cCount,ch1
		{
		inc	eax
		cmp	eax,cCount
		jb	ch1
		}

macro	DoLoopDec cCount,ch1
		{
		dec	eax
		cmp	eax,cCount
		ja	ch1
		}
macro	PrintSprait chX,chY,ctexture
{
		mov    eax,chX
		mov    ebx,chY
		mov    esi,ctexture
		Call   PrintSpraite
}
macro	Button ctx,cty,ctxt,cbsx,cbsy,cjmp
{
		DX11PrintAt ctx,cty,ctxt
		Cmp2DRect ctx,cbsx,cty,cbsy,cjmp
		cmp    [bMousing],1
		jnz    cjmp
}
macro	Cmp2DRect sxb,sxe,syb,sye,mjmp
{
		mov    eax,sxb
		cmp    [mousePosit.x],eax
		jb     mjmp
		mov    eax,sxe
		cmp    eax,dword [mousePosit.x]
		jb     mjmp
		mov    eax,syb
		cmp    [mousePosit.y],eax
		jb     mjmp
		mov    eax,sye
		cmp    eax,[mousePosit.y]
		jb     mjmp
}

   macro DX11PrintAt ch1,ch2,ctxt
{
		mov	eax,ch1
		mov	ebx,ch2
		mov	edx,ctxt
		Call	TextAt
}

macro EndMessag
{
.endif 
.endw
}

macro	Set ch1,ch2
{mov	dword [ch1],ch2}

macro	Get ch1
{mov	eax,[ch1]}

macro	ErrorMsg texts,metka
{ local Ohi
if ErrorMsgFlag = TRUE
and	eax,eax
jz	Ohi
invoke	MessageBox,0,texts,Mes2,0
jmp	metka
Ohi:
end if
}

macro PrintValue stroka,value
{
cinvoke sprintf,Status,stroka,value
invoke	MessageBox,0, Status,"Value",0
}

macro PrintFloat stroka,value
{
finit
fld   dword [value]
fstp  [resultq]
cinvoke sprintf,Status,stroka,double [resultq]
invoke	MessageBox,0, Status,"Value",0
}

macro PrintMatrix ch1,ch2
{
		mov	  eax,[ch2]
		mov	  [InitDX11],eax
		PrintFloat ch1#"%f",InitDX11
}

macro  PrintVsuMatrix fch1
{
		PrintMatrix "M._11: ",fch1
		PrintMatrix "M._12: ",fch1+4
		PrintMatrix "M._13: ",fch1+8
		PrintMatrix "M._14: ",fch1+12

		PrintMatrix "M._21: ",fch1+16
		PrintMatrix "M._22: ",fch1+20
		PrintMatrix "M._23: ",fch1+24
		PrintMatrix "M._24: ",fch1+28

		PrintMatrix "M._31: ",fch1+32
		PrintMatrix "M._32: ",fch1+36
		PrintMatrix "M._33: ",fch1+40
		PrintMatrix "M._34: ",fch1+44

		PrintMatrix "M._41: ",fch1+48
		PrintMatrix "M._42: ",fch1+52
		PrintMatrix "M._43: ",fch1+56
		PrintMatrix "M._44: ",fch1+60
}

macro StringBytes name,strin
{
local	vbr
	jmp  vbr
	dd   0
name	db   strin,0
vbr:	mov  eax,vbr
	sub  eax,name
	mov  dword [name-4],eax
}

macro String name,strin
{
local	vbr
	jmp  vbr
name	db   strin,0
vbr:
}

macro CreatShader  ch1,ch2
{
DX11Call  pd3dDevice11,ch1,[BPointerVSBlob],[BSizeVSBlob] , NULL, ch2
mov	  dword [Status],eax
DX11Call  ppBlobOut,Release
mov	  eax,dword [Status]
}

macro LoadShader ch1,ch2,ch3
{
		mov	  [SFName],ch1
		mov	  eax,ch2
		mov	  ebx,ch3
		Call	  LoadShader2
}

macro CreatLayout ch1,ch2,ch3
{
DX11Call  pd3dDevice11,CreateInputLayout,ch1,ch2,[BPointerVSBlob],[BSizeVSBlob],ch3
}

macro SetLayout ch1
{DX11Call  g_pImmediateContext,IASetInputLayout,[ch1]}

macro	DX11Release ch1
{local NetRls
cmp    dword [ch1],0
jz     NetRls
DX11Call  ch1,Release
NetRls:
}

macro IniDX11 ch1
{
		Call	  InitDirectx11
		cmp	  [InitDX11],0
		jz	  ch1
}

macro DX11DrawMesh mesh
{
DX11Call  g_pImmediateContext,DrawIndexed,[mesh+8], 0, 0
}

macro DX11DrawMeshC mesh
{
mov eax,mesh
add eax,8
DX11Call  g_pImmediateContext,DrawIndexed, dword [eax], 0, 0
}

macro DX11SetAndDrawMesh mesh
{
DX11Call  g_pImmediateContext,IASetVertexBuffers,0, 1, mesh,mesh+12,offset
DX11Call  g_pImmediateContext,IASetIndexBuffer,dword [mesh+4], DXGI_FORMAT_R32_UINT, 0
DX11Call  g_pImmediateContext,DrawIndexed, dword [mesh+8], 0, 0
}
macro DX11SetDrawMesh mesh {	DX11Call  g_pImmediateContext,IASetVertexBuffers,0, 1, mesh,mesh+12,offset
				DX11Call  g_pImmediateContext,IASetIndexBuffer,dword [mesh+4], DXGI_FORMAT_R32_UINT, 0
				SetTexture 0,mesh#.Diffuse
				SetTexture 2,mesh#.Bump
				DX11Call  g_pImmediateContext,DrawIndexed, dword [mesh+8], 0, 0
			   }
macro DX11SetMesh mesh
{
DX11Call  g_pImmediateContext,IASetVertexBuffers,0, 1, mesh,mesh+12,offset
DX11Call  g_pImmediateContext,IASetIndexBuffer, [mesh+4], DXGI_FORMAT_R32_UINT, 0
SetTexture 0,mesh#.Diffuse
SetTexture 2,mesh#.Bump
}
macro DX11SetMeshB mesh
{
DX11Call  g_pImmediateContext,IASetVertexBuffers,0, 1, mesh,mesh+12,offset
DX11Call  g_pImmediateContext,IASetIndexBuffer,dword [mesh+4], DXGI_FORMAT_R32_UINT, 0
SetTexture 0,mesh+DX11Mesh.Diffuse
SetTexture 2,mesh+DX11Mesh.Bump
}

macro DX11SetMeshC mesh
{
mov eax,mesh
add eax,12
DX11Call  g_pImmediateContext,IASetVertexBuffers,0, 1, mesh,eax,offset
mov eax,mesh
add eax,4
DX11Call  g_pImmediateContext,IASetIndexBuffer,dword [eax], DXGI_FORMAT_R32_UINT, 0
mov eax,mesh
add eax,DX11Mesh.Diffuse
SetTexture 0,eax
mov eax,mesh
add eax,DX11Mesh.Bump
SetTexture 2,eax
}

macro DX11SetOnlyMesh mesh
{
DX11Call  g_pImmediateContext,IASetVertexBuffers,0, 1, mesh,mesh+12,offset
DX11Call  g_pImmediateContext,IASetIndexBuffer,dword [mesh+4], DXGI_FORMAT_R32_UINT, 0
}

macro DX11SetMeshVSPS mesh
{
DX11Call  g_pImmediateContext,IASetVertexBuffers,0, 1, mesh,mesh+12,offset
DX11Call  g_pImmediateContext,IASetIndexBuffer,dword [mesh+4], DXGI_FORMAT_R32_UINT, 0
SetTexture 0,mesh#.Diffuse
SetTexture 2,mesh#.Bump
SetPixelShader	 mesh#.PS
SetVertexShader  mesh#.VS
}

macro  DX11MeshDel nmesh
{
		.if	   [nmesh#.IndexBuffer]<>NULL
		DX11Call   nmesh#.IndexBuffer,Release
		mov	   dword [nmesh#.IndexBuffer],0
		.endif
		.if	   [nmesh#.VertexBuffer]<>NULL
		DX11Call   nmesh#.VertexBuffer,Release
		mov	   dword [nmesh#.VertexBuffer],0
		.endif
		.if	   [nmesh#.Bump]<>NULL
		DX11Call   nmesh#.Bump,Release
		mov	   dword [nmesh#.Bump],0
		.endif
		.if	   [nmesh#.Diffuse]<>NULL
		DX11Call   nmesh#.Diffuse,Release
		mov	   dword [nmesh#.Diffuse],0
		.endif
		.if	   [nmesh#.Empty]<>NULL
	       ; DX11Call   nmesh#.Empty,Release
		.endif
		.if	   [nmesh#.VS]<>NULL
		DX11Call   nmesh#.VS,Release
		mov	   dword [nmesh#.VS],0
		.endif
		.if	   [nmesh#.PS]<>NULL
		DX11Call   nmesh#.PS,Release
		mov	   dword [nmesh#.PS],0
		.endif
		.if	   [nmesh#.DS]<>NULL
		DX11Call   nmesh#.DS,Release
		mov	   dword [nmesh#.DS],0
		.endif
		.if	   [nmesh#.HS]<>NULL
		DX11Call   nmesh#.HS,Release
		mov	   dword [nmesh#.HS],0
		.endif
		.if	   [nmesh#.GS]<>NULL
		DX11Call   nmesh#.GS,Release
		mov	   dword [nmesh#.GS],0
		.endif
}

macro Load3DMesh filen,nmesh
{
		mov	  eax,filen
		mov	  ecx,nmesh
		Call	  Load3D
}

macro CheckKey char
{
invoke GetAsyncKeyState,char
mov	[keys],eax
}

macro KeyPressGoTo char
{
local	nopress

	mov eax,[keys]
	and eax,$8000
	test eax,eax
	je nopress
	jmp	char
nopress:
}

macro KeyPressCall proc
{
local	nopress

	mov eax,[keys]
	and eax,$8000
	test eax,eax
	je nopress
	Call	proc
nopress:
}

macro KeyNotPress char
{
	mov eax,[keys]
	and eax,$8000
	test eax,eax
	je char
}

macro BlendStateOff
{DX11Call  g_pImmediateContext,OMSetBlendState,0,0,0FFFFFFFFh}

macro SetBlendState ch1,ch2
{DX11Call  g_pImmediateContext,OMSetBlendState,[ch1], [ch2],0ffffffffH }

macro	CreatMesh ch1,ch2
{
mov	  eax,ch1#End-ch1
mov	  [CMesht2],ch1
mov	  [CMesht1],ch2
mov	  [IndxLen],ch2#End-ch2
CAll	  CreatMesh2
}

macro SetVertexCBuffer ch1,ch2
{
DX11Call  g_pImmediateContext,VSSetConstantBuffers, ch1, 1,ch2
}

macro  SetVertexShader ch1
{DX11Call  g_pImmediateContext,VSSetShader, [ch1], NULL, 0 }

macro  SetPixelShader ch1
{DX11Call  g_pImmediateContext,PSSetShader, [ch1], NULL, 0 }

macro  SetPixelCBuffer ch1,ch2
{DX11Call  g_pImmediateContext,PSSetConstantBuffers, ch1, 1,ch2  }

macro  SetTexture ch1,ch2
{DX11Call  g_pImmediateContext,PSSetShaderResources, ch1, 1,ch2}

macro SetTextureSamplers ch1,ch2
{DX11Call  g_pImmediateContext,PSSetSamplers, ch1, 1,ch2}

macro  DX11Print ch1
{		mov	edx,ch1
		Call	Text  }

macro ReleaseBukvi
{    mov     edx,bu0
     mov     ecx,48
rel2:
     push    edx
     push    ecx
     mov     eax,[edx]
     mov     [g_pTextureRV],eax
     cmp     dword [g_pTextureRV],0
     jz      Norl
     DX11Call  g_pTextureRV,Release
Norl:pop     ecx
     pop     edx
     add     edx,4
     loop    rel2

}

macro  UpdateCBuffer cbuf,dats
{DX11Call  g_pImmediateContext,UpdateSubresource,[cbuf], 0, NULL, dats, 0, 0 }

macro SetDepthStencil ch1,ch2
{DX11Call  g_pImmediateContext,OMSetDepthStencilState,[ch1],ch2}

macro SetRasterizer ch1
{DX11Call  g_pImmediateContext,RSSetState,[ch1]}
