WebSVN – Kolibri OS – Diff – /programs/demos/bgitest/trunk/bgifont.inc


; BGIFONT.INC v1.0 beta
;
; Written in pure assembler by Ivushkin Andrey aka Willow
;
; Created: December 16, 2004
;
; Last changed: August 27, 2006
;
; Compile with FASM
 
; BGI constants
BGI_NODRAW   equ 0x10000
BGI_ITALIC   equ 0x20000
BGI_BOLD     equ 0x40000
BGI_HALEFT   equ 0x0
BGI_HARIGHT  equ 0x1000
BGI_HACENTER equ 0x2000
BGI_VABOTTOM equ 0x0
BGI_VATOP    equ 0x4000
BGI_VACENTER equ 0x8000
 
BGI_FREE     equ 0x80000000
BGI_HAMASK   equ 0x3000
BGI_VAMASK   equ 0xc000
 
; Freetext structure
struc BGIfree FontName,XY,Angle,ScaleX,ScaleY,StrPtr,StrLen,Color,Align
{
    dd FontName ;0
    dd XY	    ;4
    dd Angle	;8
    dd ScaleX	;12
    dd ScaleY	;16
    dd StrPtr	;20
    dd StrLen	;24
    dd Color	;28
    dd Align	;32
}
 
; font options structure
struc BGIrec FontName,CharsCount,FirstChar,UpperMargin,LowerMargin,\
    Widths,FirstData,EOF,font_data
{
 .FontName     dd ?  ; 0
 .CharsCount   db ?  ; 4
 .FirstChar    db ?  ; 5
 .UpperMargin  db ?  ; 6
 .LowerMargin  db ?  ; 7
 .Widths       dd ?  ; 8
 .FirstData    dd ?  ; 12
 .EOF	       dd ?    ; 16
 .font_data    dd ?  ; 20 follows (Offsets)
}
 
macro BGIfont_GetID
{
    call _BGIfont_GetID
}
 
macro BGIfont_Prepare
{
    call _BGIfont_Prepare
}
 
macro BGIfont_Freetext
{
    call _BGIfont_Freetext
}
 
macro BGIfont_Outtext
{
    call _BGIfont_Outtext
}
 
macro _FI name,_size
{
    db name
if BGI_LEVEL eq KERNEL
    dw _size
end if
}
 
BGIfont_names:
_FI 'LCOM',11485   ;7
_FI 'EURO',8117    ;5
_FI 'GOTH',13816   ;6
_FI 'LITT',3596    ;8
_FI 'TRIP',11932   ;14
_FI 'SCRI',8490    ;11
_FI 'SMAL',4162    ;13
_FI 'TSCR',12134   ;15
_FI 'SANS',8453    ;10
_FI 'SIMP',9522    ;12
BGIfont_names_end:
 
macro BGIfont_Init
{
; in:  ecx - number of fonts to load;
;      esi-> _FI structure
;      edi-> where to load
    push edi
if  BGI_LEVEL eq KERNEL
    mov  edi,0x40000
end if
  .nfont:
    mov  edx,[esi]
if  BGI_LEVEL eq KERNEL
    movzx ebx,word[esi+4]
    mov  [BGIfont_Prepare.okflag],'N'
end if
    call _BGIfont_Prepare
if ~ BGI_LEVEL eq KERNEL
    add  esi,4
else
    push esi
    test eax,eax
    jz	 .fail
    mov  [BGIfont_Prepare.okflag],'*'
  .fail:
    mov  esi,BGIfont_Prepare.font
    call boot_log
    pop  esi
    add  esi,6
end if
    loop .nfont
    dph2 _BGI_BOLD,300,550
;    movzx edi,byte[0x40000]
    pop  edi
}
 
BGIfont_get2head:
    shr  ecx,28 ; font #
    sub  ecx,4
    jb	 .exit2	; invalid #
    mov  edi,[BGIfont_Ptr]
    inc  edi
    cmp  cl,[edi-1]
    jae  .exit2 ; # too large
    jecxz .ex
  .fnext:
    mov  edi,[edi+16]
    loop .fnext
    jmp  .ex
  .exit2:
    xor  edi,edi
  .ex:
    ret
 
BGIfont_GetName:
; in: ecx-fontID;
; out: edx-font name.
    call BGIfont_get2head
    xor  edx,edx
    test edi,edi
    jz   .ex
    mov  edx,[edi]
  .ex:
    ret
 
macro dps2 _str
{
if ~ BGI_LEVEL eq KERNEL
  if LOAD_MSG eq 1
    dps _str
  end if
else
    pusha
    mov  esi,BGIfont_Prepare.okflag
    mov  byte[esi], _str
    call boot_log
    popa
end if
}
 
macro dph2 num,x,y
{
if  BGI_LEVEL eq KERNEL
    pusha
    mov  eax,0x00080100
    mov  ebx,num
    mov  ecx,x shl 16+y
    mov  edx,0xFF0000
    call display_number
    popa
end if
}
 
_BGIfont_GetID:
; in:  edx-font name;
; out: eax-fontID, edi->BGIrec
    push ecx edi
    mov  edi,[BGIfont_Ptr]
    movzx ecx,byte[edi] ; ecx-font count
    mov  eax,ecx
    inc  edi ; edi->FontName
    jecxz .ex
  .fnext:
    cmp  edx,[edi]
    jne  .floop
    sub  eax,ecx
    add  eax,4
    shl  eax,28
    jmp  .ex
  .floop:
    mov  edi,[edi+16]
    loop .fnext
  .num0:
    xor  eax,eax
  .ex:
    pop  edi ecx
    ret
 
_BGIfont_Prepare:
; in:  edx-font name, edi->pointer to load fonts (fonts_count)
; out: eax-ID of new font loaded; eax=0 error
    cmp  [BGIfont_Ptr],0
    jne  .already
    mov  [BGIfont_Ptr],edi
  .already:
    pusha
    mov  edi,[BGIfont_Ptr]
    movzx ecx,byte[edi] ; ecx-font count
    mov  eax,ecx
    inc  edi ; edi->FontName
    jecxz .fload
  .fnext:
    cmp  edx,[edi]
    jne  .loop
    sub  eax,ecx
    inc  eax
    jmp  .cr_id
  .loop:
    mov  edi,[edi+16]
    loop .fnext
  .fload:
    mov  dword[.font],edx ; filename
    mov  esi,edi     ; esi->FontName
    mov  [.dest],edi ; ptr to load font
if ~ BGI_LEVEL eq KERNEL
 
        mov     eax, 70
        mov     ebx, .fontattr
        int     0x40
        test    eax, eax
        jnz     .fail
        dps2    '1'
        mov     eax, [.fileattr+32]
 
        mov     [.fsize], eax
    mov  ebx,.fontinfo
    mov  eax,70
    int  0x40	     ; ebx - file size
else
    push edi esi edx
    mov  eax,.font
    xor  ebx,ebx
    mov  esi,12
    mov  ecx,ebx
    mov  edx,edi
    call fileread
    pop  edx esi edi
    mov  ebp,edi
    add  ebp,ebx
    cmp  ebp,0x50000
    ja	 .fail
end if
    cmp  dword[edi],0x08084b50 ; 'PK',8,8
    jne  .fail
    dps2 '2'
    inc  edi
    mov  eax,26 ; #EOF
    mov  ecx,253
    cld
    repne scasb  ; skip Copyright
    test ecx,ecx
    jz	 .fail
    dps2  '3'
    cmp  edx,[edi+2] ; FontName
    jne  .fail
    dps2  '4'
    movzx ecx,word[edi] ; HeaderSize
    sub  ebx,ecx  ; Filesize-Headersize
    movzx eax,word[edi+6] ; FontSize
    cmp  eax,ebx
    jb	 .fail	  ; file truncated
    add  ecx,[.dest]
    dps2  '5'
    cmp  byte[ecx],'+'	; ParPrefix
    jne  .fail
; font is valid, let's fill parameter table
    dps2  '>'
    mov  [esi],edx ; FontName
    mov  edx,eax
    add  eax,ecx
    mov  [esi+16],eax ; Font EOF
    movzx eax,word[ecx+5]
    add  eax,ecx
    mov  [esi+12],eax
    lea  edi,[esi+4]  ; edi->CharsCount
    lea  esi,[ecx+1] ; esi->ParPrefix+1
    xor  eax,eax
    lodsw
    stosb  ; CharsCount
    inc  esi
    movsb  ; FirstChar
    add  esi,3
    lodsw
    stosb  ; UpperMargin
    movsb  ; LowerMargin
    add  esi,5 ; esi->offsets
    mov  eax,[esi]
    push edi ; edi->Widths
; prepare moving data
    add  edi,12 ; edi->offsets
    lea  ecx,[edx-16]
    rep  movsb
    pop  edi ; edi->Widths
    mov  [edi+8],esi ; EOF
;    mov  eax,[edi]
    movzx ecx,byte[edi-4] ; CharsCount
    lea  eax,[edi+12+ecx*2] ; eax->widths
    stosd  ; edi->FirstData
    add  eax,ecx
    stosd  ; edi->EOF
    mov  eax,[esp] ; eax->fonts_count
    inc  byte[eax] ; increase font counter
    movzx eax,byte[eax]
  .cr_id:
    add  eax,0x3   ; create unique ID
    shl  eax,28    ; to easy use in color(ecx)
    jmp  .exit
  .fail:
    xor  eax,eax
  .exit:
    mov  [esp+28],eax
    popa
    ret
 
if ~ BGI_LEVEL eq KERNEL
.fontinfo:
	dd 0
	dd 0
	dd 0
.fsize	dd 0
.dest	dd 0
.fontfullname:
	db BGIFONT_PATH
.font	db 'FONT.CHR',0
 
.fontattr:
        dd      5
        dd      0
        dd      0
        dd      0
        dd      .fileattr
        db      0
        dd      .fontfullname
.fileattr rd 40/4
else
  .dest   dd 0
  .font   db 'FONT    CHR'
  .okflag db ' ',0
end if
 
BGIfont_Coo:
; y->word[txt.y1], x->word[txt.x1]
    fild [txt.y1] ;y
    fmul st0,st0; y*y
    fild [txt.x1] ;x
    fmul st0,st0; x*x
    faddp  ; x*x+y*y
    fsqrt  ; sqrt, angle
    fild [txt.y1];y
    fabs
    fild [txt.x1] ; x
    fabs
    fpatan ; arctg(y/x)
  .skip:
    cmp  [txt.x1],0
    jge  .xplus
    fchs
    fadd st0,st3
  .xplus:
    cmp  [txt.y1],0
    jge  .yplus
    fchs
  .yplus:
    fadd st0,st2
    fsincos
    fmul st0,st2
    fiadd [txt.x0]
    fistp [txt.x1] ; x=r*cos a
    fmulp ; y=r*sin a,angle
    fiadd [txt.y0]
    fistp [txt.y1]
    ret
 
_BGIfont_Freetext:
; in: ebx-BGIfree structure
; out: eax-new drawing coords
    mov  edx,[ebx]
    call _BGIfont_GetID
    test eax,eax
    jnz  .fexists
    ret
  .fexists:
    pusha
    fninit
    fldpi
    fld  [pi180]
    fimul dword[ebx+8]
    fst  [BGIangle]
    mov  esi,[ebx+28]
    and  esi,0xffffff
    add  esi,eax
    mov  eax,[ebx+32]
    and  [deform],0
    test eax,BGI_ITALIC
    jz	 .norm
    mov  [deform],0.4
  .norm:
    mov  ebp,eax
    or	  ebp,BGI_FREE
    mov  eax,[ebx+12]
    mov  [Xscale],eax
    mov  eax,[ebx+16]
    mov  [Yscale],eax
    mov  ecx,[ebx+20]
    mov  edx,ebp
    and  edx,BGI_FREE+BGI_VAMASK+BGI_HAMASK
    add  edx,[ebx+24]
    mov  eax,[ebx+4]
    mov  ebx,esi
    add  ebx,0x6000000
    mov  [esp+4],edx
    mov  [esp+20],ecx
    jmp  txt
 
    pi180 dd 0.017453
 
_BGIfont_Outtext:
; in: ebx-[x][y], ecx-color, edx-string, esi-length
    pusha
    mov  ebp,esi
if ~ BGI_LEVEL eq KERNEL
    mov  eax,ebx
    mov  ebx,ecx
    mov  ecx,edx
    mov  edx,esi
end if
; in: eax-[x][y], ebx-color, ecx-string, edx-length
txt:
if  ~ BGI_LEVEL eq KERNEL
  if  BGI_WINDOW_CLIP eq 1
    pusha
    mov  eax,9
    mov  ebx,BGI_PRC_INFO
    mov  ecx,-1
    int  0x40
    popa
  end if
end if
    mov  [.y0],ax
    shr  eax,16
    mov  [.x0],ax
    mov  ecx,ebx ; color
    and  ebx,0xfffffff
    mov  [.color],ebx
    call BGIfont_get2head
    test edi,edi
    jz   .exit
    mov  ecx,[esp+4]; str length
    mov  esi,[esp+20]; str ptr
    movzx eax,byte[edi+5]
    push ecx
    and  ecx,0xff
    jnz  .lenok
    add  esp,4
    jmp  .ex2
  .lenok:
    pusha
    push dword[txt.y0]
    and  dword[txt.y0],0
    xor  edx,edx
    mov  ebx,[edi+8]
   .next:
    call txt.BGIfont_GetChar
    movzx eax,byte[ebx+eax]
    add  edx,eax
    loop .next
    mov  ecx,edx ; ecx - x size
    movzx dx,byte[edi+6]
    mov  [BGIheight],dx
    mov  ebx,[esp+36]
    and  ebx,BGI_HAMASK
    cmp  ebx,BGI_HARIGHT
    je   .nova
    ja   .subv
    xor  ecx,ecx
    jmp  .nova
  .subv:
    shr  cx,1
  .nova:
    mov  ebx,[esp+36]
    and  ebx,BGI_VAMASK
    cmp  ebx,BGI_VATOP
    je   .def
    ja   .subh
    xor  edx,edx
    jmp  .def
  .subh:
    shr  dx,1
  .def:
    call txt.BGIfont_Deform
    pop  dword[txt.y0]
    popa
    pop  ebx
    mov  ax,[txt.y1]
    sub  [txt.y0],ax
    mov  ax,[txt.x1]
    sub  [txt.x0],ax
    xor  eax,eax
    cld
.mloop:
    push [.y0]
    pop  [.y]
    push [.x0]
    pop  [.x]
    call .BGIfont_GetChar
    push esi
    lea  esi,[edi+20] ; offset
    movzx edx,word[esi+eax*2] ; ofs1
    add  edx,[edi+12]
    inc  eax
    cmp  al,[edi+4]
    je	 .eof
    movzx eax,word[esi+eax*2]; ofs2
    add   eax,[edi+12]
    jmp   .prc_vec
  .eof:
    mov  eax,[edi+16] ; ofs2=eof
  .prc_vec:  ; edx-vec cmd ifs, eax-cmd limit
    mov  [.vec_end],eax
    push ecx
  .vec_loop:
    mov  ax,word[edx]
    push edx
    mov  ecx,eax
    and  eax,0x8080 ; op
    and  ecx,0x7f ; xx
    mov  edx,[edx+1]
    and  edx,0x7f ; yy
    cmp  edx,63
    jbe  .positive
    sub  edx,128  ; yy-=128
  .positive:
    cmp  ecx,63
    jbe  .positive2
    sub  ecx,128  ; xx-=128
  .positive2:
    call .BGIfont_Deform
    cmp  eax,0x8080
    jne  .noline
    test ebp,BGI_NODRAW
    jnz  .noline
; draw vector
if ~ BGI_LEVEL eq KERNEL
    push eax
    mov  ebx,dword[.x1]
    mov  ecx,dword[.y1]
  if BGI_WINDOW_CLIP eq 1
    movzx eax,[.x]
    cmp  eax,dword[BGI_PRC_INFO+42]
    ja   .nobold
    movzx eax,[.y]
    cmp  eax,dword[BGI_PRC_INFO+46]
    ja  .nobold
    xor  eax,eax
    cmp  ax,bx
    jg   .nobold
    cmp  ax,cx
    jg   .nobold
  end if
    mov  edx,[.color]
; \begin{diamond}[18.08.2006]
; starting from K0530 kernel interprets flag 0x1000000 as
; negate existing pixels colors, disregarding passed color
; we do not want this
    and  edx, 0xFFFFFF
; \end{diamond}[18.08.2006]
    mov  eax,38
    int  0x40
    test ebp,BGI_BOLD
    jz	 .nobold
    test ebp,BGI_FREE
    jnz  .free5
  .free5:
    add  ebx,1 shl 16+1
    int  0x40
  .nobold:
    pop  eax
else
    pusha
    mov  eax,dword[.x1]
    mov  ebx,dword[.y1]
    mov  ecx,[.color]
;    call syscall_drawline
    test dword[esp+8],BGI_BOLD
    jz	 .nobold
    add  eax,1 shl 16+1
;    call syscall_drawline
  .nobold:
    popa
end if
  .noline:
    pop  edx
    test eax,eax
    je	 .eovecs  ; op=0
    push [.y1]
    pop  [.y]
    push [.x1]
    pop  [.x]
    add  edx,2
    cmp  edx,[.vec_end]
    jb	 .vec_loop
  .eovecs:
    pop  ecx esi
    push [.y]
    pop  [.y0]
    push [.x]
    pop  [.x0]
    loop .mloop1
    jmp  .exit
  .mloop1:
    jmp  .mloop
  .exit:
    mov  eax,dword[.y0]
    mov  [esp+28],eax
  .ex2:
    popa
    ret
 
.BGIfont_Deform:
    test ebp,BGI_FREE
    jnz  .free0
    movzx ebx,byte[.color+3] ;ebx=scale
    imul ecx,ebx
    add  ecx,2
    shr  ecx,2
    imul edx,ebx
    add  edx,2
    shr  edx,2
    neg  edx
    mov  [.x1],cx
    mov  [.y1],dx
    jmp  .add
  .free0:
    mov  [.x1],cx
    mov  [.y1],dx
    fild [.y1]
    fld  st0
    fmul [Yscale]
    fchs
    fistp [.y1]
    fmul [deform]
    fiadd [.x1]
    fmul [Xscale]
    fistp [.x1]
    cmp  [BGIangle],0
    je	 .add
    call BGIfont_Coo
    jmp  .eax
  .add:
    mov  cx,[.x0]
    add  [.x1],cx
    mov  cx,[.y0]
    add  [.y1],cx
  .eax:
    ret
 
.BGIfont_GetChar:
; in:  esi -> string; edi -> BGIrec
; out: esi -> next char; al - char obtained
    lodsb  ; al - char from str
    sub  al,[edi+5]
    jb	 .out
    cmp  al,[edi+4]
    jb	 .in
  .out:
    xor  al,al ; al - 1st symbol available
  .in:
    ret
 
.y0	 dw ?
.x0	 dw ?
 
.x1	 dw ?
.x	 dw ?
.y1	 dw ?
.y	 dw ?
 
.color	 dd ?
.vec_end dd ?
BGIfont_Ptr  dd 0
BGIheight dw ?
deform dd ?
BGIangle dd ?
Xscale  dd ?
Yscale  dd ?

Rev 131	Rev 205
1	; BGIFONT.INC v1.0 beta	1	; BGIFONT.INC v1.0 beta
2	;	2	;
3	; Written in pure assembler by Ivushkin Andrey aka Willow	3	; Written in pure assembler by Ivushkin Andrey aka Willow
4	;	4	;
5	; Created: December 16, 2004	5	; Created: December 16, 2004
6	;	6	;
7	; Last changed: February 2, 2005	7	; Last changed: August 27, 2006
8	;	8	;
9	; Compile with FASM	9	; Compile with FASM
10		10
11	; BGI constants	11	; BGI constants
12	BGI_NODRAW equ 0x10000	12	BGI_NODRAW equ 0x10000
13	BGI_ITALIC equ 0x20000	13	BGI_ITALIC equ 0x20000
14	BGI_BOLD equ 0x40000	14	BGI_BOLD equ 0x40000
15	BGI_HALEFT equ 0x0	15	BGI_HALEFT equ 0x0
16	BGI_HARIGHT equ 0x1000	16	BGI_HARIGHT equ 0x1000
17	BGI_HACENTER equ 0x2000	17	BGI_HACENTER equ 0x2000
18	BGI_VABOTTOM equ 0x0	18	BGI_VABOTTOM equ 0x0
19	BGI_VATOP equ 0x4000	19	BGI_VATOP equ 0x4000
20	BGI_VACENTER equ 0x8000	20	BGI_VACENTER equ 0x8000
21		21
22	BGI_FREE equ 0x80000000	22	BGI_FREE equ 0x80000000
23	BGI_HAMASK equ 0x3000	23	BGI_HAMASK equ 0x3000
24	BGI_VAMASK equ 0xc000	24	BGI_VAMASK equ 0xc000
25		25
26	; Freetext structure	26	; Freetext structure
27	struc BGIfree FontName,XY,Angle,ScaleX,ScaleY,StrPtr,StrLen,Color,Align	27	struc BGIfree FontName,XY,Angle,ScaleX,ScaleY,StrPtr,StrLen,Color,Align
28	{	28	{
29	dd FontName ;0	29	dd FontName ;0
30	dd XY ;4	30	dd XY ;4
31	dd Angle ;8	31	dd Angle ;8
32	dd ScaleX ;12	32	dd ScaleX ;12
33	dd ScaleY ;16	33	dd ScaleY ;16
34	dd StrPtr ;20	34	dd StrPtr ;20
35	dd StrLen ;24	35	dd StrLen ;24
36	dd Color ;28	36	dd Color ;28
37	dd Align ;32	37	dd Align ;32
38	}	38	}
39		39
40	; font options structure	40	; font options structure
41	struc BGIrec FontName,CharsCount,FirstChar,UpperMargin,LowerMargin,\	41	struc BGIrec FontName,CharsCount,FirstChar,UpperMargin,LowerMargin,\
42	Widths,FirstData,EOF,font_data	42	Widths,FirstData,EOF,font_data
43	{	43	{
44	.FontName dd ? ; 0	44	.FontName dd ? ; 0
45	.CharsCount db ? ; 4	45	.CharsCount db ? ; 4
46	.FirstChar db ? ; 5	46	.FirstChar db ? ; 5
47	.UpperMargin db ? ; 6	47	.UpperMargin db ? ; 6
48	.LowerMargin db ? ; 7	48	.LowerMargin db ? ; 7
49	.Widths dd ? ; 8	49	.Widths dd ? ; 8
50	.FirstData dd ? ; 12	50	.FirstData dd ? ; 12
51	.EOF dd ? ; 16	51	.EOF dd ? ; 16
52	.font_data dd ? ; 20 follows (Offsets)	52	.font_data dd ? ; 20 follows (Offsets)
53	}	53	}
54		54
55	macro BGIfont_GetID	55	macro BGIfont_GetID
56	{	56	{
57	call _BGIfont_GetID	57	call _BGIfont_GetID
58	}	58	}
59		59
60	macro BGIfont_Prepare	60	macro BGIfont_Prepare
61	{	61	{
62	call _BGIfont_Prepare	62	call _BGIfont_Prepare
63	}	63	}
64		64
65	macro BGIfont_Freetext	65	macro BGIfont_Freetext
66	{	66	{
67	call _BGIfont_Freetext	67	call _BGIfont_Freetext
68	}	68	}
69		69
70	macro BGIfont_Outtext	70	macro BGIfont_Outtext
71	{	71	{
72	call _BGIfont_Outtext	72	call _BGIfont_Outtext
73	}	73	}
74		74
75	macro _FI name,_size	75	macro _FI name,_size
76	{	76	{
77	db name	77	db name
78	if BGI_LEVEL eq KERNEL	78	if BGI_LEVEL eq KERNEL
79	dw _size	79	dw _size
80	end if	80	end if
81	}	81	}
82		82
83	BGIfont_names:	83	BGIfont_names:
84	_FI 'LCOM',11485 ;7	84	_FI 'LCOM',11485 ;7
85	_FI 'EURO',8117 ;5	85	_FI 'EURO',8117 ;5
86	_FI 'GOTH',13816 ;6	86	_FI 'GOTH',13816 ;6
87	_FI 'LITT',3596 ;8	87	_FI 'LITT',3596 ;8
88	_FI 'TRIP',11932 ;14	88	_FI 'TRIP',11932 ;14
89	_FI 'SCRI',8490 ;11	89	_FI 'SCRI',8490 ;11
90	_FI 'SMAL',4162 ;13	90	_FI 'SMAL',4162 ;13
91	_FI 'TSCR',12134 ;15	91	_FI 'TSCR',12134 ;15
92	_FI 'SANS',8453 ;10	92	_FI 'SANS',8453 ;10
93	_FI 'SIMP',9522 ;12	93	_FI 'SIMP',9522 ;12
94	BGIfont_names_end:	94	BGIfont_names_end:
95		95
96	macro BGIfont_Init	96	macro BGIfont_Init
97	{	97	{
98	; in: ecx - number of fonts to load;	98	; in: ecx - number of fonts to load;
99	; esi-> _FI structure	99	; esi-> _FI structure
100	; edi-> where to load	100	; edi-> where to load
101	push edi	101	push edi
102	if BGI_LEVEL eq KERNEL	102	if BGI_LEVEL eq KERNEL
103	mov edi,0x40000	103	mov edi,0x40000
104	end if	104	end if
105	.nfont:	105	.nfont:
106	mov edx,[esi]	106	mov edx,[esi]
107	if BGI_LEVEL eq KERNEL	107	if BGI_LEVEL eq KERNEL
108	movzx ebx,word[esi+4]	108	movzx ebx,word[esi+4]
109	mov [BGIfont_Prepare.okflag],'N'	109	mov [BGIfont_Prepare.okflag],'N'
110	end if	110	end if
111	call _BGIfont_Prepare	111	call _BGIfont_Prepare
112	if ~ BGI_LEVEL eq KERNEL	112	if ~ BGI_LEVEL eq KERNEL
113	add esi,4	113	add esi,4
114	else	114	else
115	push esi	115	push esi
116	test eax,eax	116	test eax,eax
117	jz .fail	117	jz .fail
118	mov [BGIfont_Prepare.okflag],'*'	118	mov [BGIfont_Prepare.okflag],'*'
119	.fail:	119	.fail:
120	mov esi,BGIfont_Prepare.font	120	mov esi,BGIfont_Prepare.font
121	call boot_log	121	call boot_log
122	pop esi	122	pop esi
123	add esi,6	123	add esi,6
124	end if	124	end if
125	loop .nfont	125	loop .nfont
126	dph2 _BGI_BOLD,300,550	126	dph2 _BGI_BOLD,300,550
127	; movzx edi,byte[0x40000]	127	; movzx edi,byte[0x40000]
128	pop edi	128	pop edi
129	}	129	}
130		130
131	BGIfont_get2head:	131	BGIfont_get2head:
132	shr ecx,28 ; font #	132	shr ecx,28 ; font #
133	sub ecx,4	133	sub ecx,4
134	jb .exit2 ; invalid #	134	jb .exit2 ; invalid #
135	mov edi,[BGIfont_Ptr]	135	mov edi,[BGIfont_Ptr]
136	inc edi	136	inc edi
137	cmp cl,[edi-1]	137	cmp cl,[edi-1]
138	jae .exit2 ; # too large	138	jae .exit2 ; # too large
139	jecxz .ex	139	jecxz .ex
140	.fnext:	140	.fnext:
141	mov edi,[edi+16]	141	mov edi,[edi+16]
142	loop .fnext	142	loop .fnext
143	jmp .ex	143	jmp .ex
144	.exit2:	144	.exit2:
145	xor edi,edi	145	xor edi,edi
146	.ex:	146	.ex:
147	ret	147	ret
148		148
149	BGIfont_GetName:	149	BGIfont_GetName:
150	; in: ecx-fontID;	150	; in: ecx-fontID;
151	; out: edx-font name.	151	; out: edx-font name.
152	call BGIfont_get2head	152	call BGIfont_get2head
153	xor edx,edx	153	xor edx,edx
154	test edi,edi	154	test edi,edi
155	jz .ex	155	jz .ex
156	mov edx,[edi]	156	mov edx,[edi]
157	.ex:	157	.ex:
158	ret	158	ret
159		159
160	macro dps2 _str	160	macro dps2 _str
161	{	161	{
162	if ~ BGI_LEVEL eq KERNEL	162	if ~ BGI_LEVEL eq KERNEL
163	if LOAD_MSG eq 1	163	if LOAD_MSG eq 1
164	dps _str	164	dps _str
165	end if	165	end if
166	else	166	else
167	pusha	167	pusha
168	mov esi,BGIfont_Prepare.okflag	168	mov esi,BGIfont_Prepare.okflag
169	mov byte[esi], _str	169	mov byte[esi], _str
170	call boot_log	170	call boot_log
171	popa	171	popa
172	end if	172	end if
173	}	173	}
174		174
175	macro dph2 num,x,y	175	macro dph2 num,x,y
176	{	176	{
177	if BGI_LEVEL eq KERNEL	177	if BGI_LEVEL eq KERNEL
178	pusha	178	pusha
179	mov eax,0x00080100	179	mov eax,0x00080100
180	mov ebx,num	180	mov ebx,num
181	mov ecx,x shl 16+y	181	mov ecx,x shl 16+y
182	mov edx,0xFF0000	182	mov edx,0xFF0000
183	call display_number	183	call display_number
184	popa	184	popa
185	end if	185	end if
186	}	186	}
187		187
188	_BGIfont_GetID:	188	_BGIfont_GetID:
189	; in: edx-font name;	189	; in: edx-font name;
190	; out: eax-fontID, edi->BGIrec	190	; out: eax-fontID, edi->BGIrec
191	push ecx edi	191	push ecx edi
192	mov edi,[BGIfont_Ptr]	192	mov edi,[BGIfont_Ptr]
193	movzx ecx,byte[edi] ; ecx-font count	193	movzx ecx,byte[edi] ; ecx-font count
194	mov eax,ecx	194	mov eax,ecx
195	inc edi ; edi->FontName	195	inc edi ; edi->FontName
196	jecxz .ex	196	jecxz .ex
197	.fnext:	197	.fnext:
198	cmp edx,[edi]	198	cmp edx,[edi]
199	jne .floop	199	jne .floop
200	sub eax,ecx	200	sub eax,ecx
201	add eax,4	201	add eax,4
202	shl eax,28	202	shl eax,28
203	jmp .ex	203	jmp .ex
204	.floop:	204	.floop:
205	mov edi,[edi+16]	205	mov edi,[edi+16]
206	loop .fnext	206	loop .fnext
207	.num0:	207	.num0:
208	xor eax,eax	208	xor eax,eax
209	.ex:	209	.ex:
210	pop edi ecx	210	pop edi ecx
211	ret	211	ret
212		212
213	_BGIfont_Prepare:	213	_BGIfont_Prepare:
214	; in: edx-font name, edi->pointer to load fonts (fonts_count)	214	; in: edx-font name, edi->pointer to load fonts (fonts_count)
215	; out: eax-ID of new font loaded; eax=0 error	215	; out: eax-ID of new font loaded; eax=0 error
216	cmp [BGIfont_Ptr],0	216	cmp [BGIfont_Ptr],0
217	jne .already	217	jne .already
218	mov [BGIfont_Ptr],edi	218	mov [BGIfont_Ptr],edi
219	.already:	219	.already:
220	pusha	220	pusha
221	mov edi,[BGIfont_Ptr]	221	mov edi,[BGIfont_Ptr]
222	movzx ecx,byte[edi] ; ecx-font count	222	movzx ecx,byte[edi] ; ecx-font count
223	mov eax,ecx	223	mov eax,ecx
224	inc edi ; edi->FontName	224	inc edi ; edi->FontName
225	jecxz .fload	225	jecxz .fload
226	.fnext:	226	.fnext:
227	cmp edx,[edi]	227	cmp edx,[edi]
228	jne .loop	228	jne .loop
229	sub eax,ecx	229	sub eax,ecx
230	inc eax	230	inc eax
231	jmp .cr_id	231	jmp .cr_id
232	.loop:	232	.loop:
233	mov edi,[edi+16]	233	mov edi,[edi+16]
234	loop .fnext	234	loop .fnext
235	.fload:	235	.fload:
236	mov dword[.font],edx ; filename	236	mov dword[.font],edx ; filename
237	mov esi,edi ; esi->FontName	237	mov esi,edi ; esi->FontName
238	mov [.dest],edi ; ptr to load font	238	mov [.dest],edi ; ptr to load font
239	if ~ BGI_LEVEL eq KERNEL	239	if ~ BGI_LEVEL eq KERNEL
240	mov [.fsize],1	-
241	mov eax,58	240	mov eax, 70
242	mov ebx,.fontinfo	241	mov ebx, .fontattr
243	int 0x40	242	int 0x40
244	test eax,eax	243	test eax, eax
245	jnz .fail	244	jnz .fail
246	dps2 '1'	245	dps2 '1'
247	shr ebx,9	246	mov eax, [.fileattr+32]
248	inc ebx	-
249	mov [.fsize],ebx	247	mov [.fsize], eax
250	mov ebx,.fontinfo	248	mov ebx,.fontinfo
251	mov eax,58	249	mov eax,70
252	int 0x40 ; ebx - file size	250	int 0x40 ; ebx - file size
253	else	251	else
254	push edi esi edx	252	push edi esi edx
255	mov eax,.font	253	mov eax,.font
256	xor ebx,ebx	254	xor ebx,ebx
257	mov esi,12	255	mov esi,12
258	mov ecx,ebx	256	mov ecx,ebx
259	mov edx,edi	257	mov edx,edi
260	call fileread	258	call fileread
261	pop edx esi edi	259	pop edx esi edi
262	mov ebp,edi	260	mov ebp,edi
263	add ebp,ebx	261	add ebp,ebx
264	cmp ebp,0x50000	262	cmp ebp,0x50000
265	ja .fail	263	ja .fail
266	end if	264	end if
267	cmp dword[edi],0x08084b50 ; 'PK',8,8	265	cmp dword[edi],0x08084b50 ; 'PK',8,8
268	jne .fail	266	jne .fail
269	dps2 '2'	267	dps2 '2'
270	inc edi	268	inc edi
271	mov eax,26 ; #EOF	269	mov eax,26 ; #EOF
272	mov ecx,253	270	mov ecx,253
273	cld	271	cld
274	repne scasb ; skip Copyright	272	repne scasb ; skip Copyright
275	test ecx,ecx	273	test ecx,ecx
276	jz .fail	274	jz .fail
277	dps2 '3'	275	dps2 '3'
278	cmp edx,[edi+2] ; FontName	276	cmp edx,[edi+2] ; FontName
279	jne .fail	277	jne .fail
280	dps2 '4'	278	dps2 '4'
281	movzx ecx,word[edi] ; HeaderSize	279	movzx ecx,word[edi] ; HeaderSize
282	sub ebx,ecx ; Filesize-Headersize	280	sub ebx,ecx ; Filesize-Headersize
283	movzx eax,word[edi+6] ; FontSize	281	movzx eax,word[edi+6] ; FontSize
284	cmp eax,ebx	282	cmp eax,ebx
285	jb .fail ; file truncated	283	jb .fail ; file truncated
286	add ecx,[.dest]	284	add ecx,[.dest]
287	dps2 '5'	285	dps2 '5'
288	cmp byte[ecx],'+' ; ParPrefix	286	cmp byte[ecx],'+' ; ParPrefix
289	jne .fail	287	jne .fail
290	; font is valid, let's fill parameter table	288	; font is valid, let's fill parameter table
291	dps2 '>'	289	dps2 '>'
292	mov [esi],edx ; FontName	290	mov [esi],edx ; FontName
293	mov edx,eax	291	mov edx,eax
294	add eax,ecx	292	add eax,ecx
295	mov [esi+16],eax ; Font EOF	293	mov [esi+16],eax ; Font EOF
296	movzx eax,word[ecx+5]	294	movzx eax,word[ecx+5]
297	add eax,ecx	295	add eax,ecx
298	mov [esi+12],eax	296	mov [esi+12],eax
299	lea edi,[esi+4] ; edi->CharsCount	297	lea edi,[esi+4] ; edi->CharsCount
300	lea esi,[ecx+1] ; esi->ParPrefix+1	298	lea esi,[ecx+1] ; esi->ParPrefix+1
301	xor eax,eax	299	xor eax,eax
302	lodsw	300	lodsw
303	stosb ; CharsCount	301	stosb ; CharsCount
304	inc esi	302	inc esi
305	movsb ; FirstChar	303	movsb ; FirstChar
306	add esi,3	304	add esi,3
307	lodsw	305	lodsw
308	stosb ; UpperMargin	306	stosb ; UpperMargin
309	movsb ; LowerMargin	307	movsb ; LowerMargin
310	add esi,5 ; esi->offsets	308	add esi,5 ; esi->offsets
311	mov eax,[esi]	309	mov eax,[esi]
312	push edi ; edi->Widths	310	push edi ; edi->Widths
313	; prepare moving data	311	; prepare moving data
314	add edi,12 ; edi->offsets	312	add edi,12 ; edi->offsets
315	lea ecx,[edx-16]	313	lea ecx,[edx-16]
316	rep movsb	314	rep movsb
317	pop edi ; edi->Widths	315	pop edi ; edi->Widths
318	mov [edi+8],esi ; EOF	316	mov [edi+8],esi ; EOF
319	; mov eax,[edi]	317	; mov eax,[edi]
320	movzx ecx,byte[edi-4] ; CharsCount	318	movzx ecx,byte[edi-4] ; CharsCount
321	lea eax,[edi+12+ecx*2] ; eax->widths	319	lea eax,[edi+12+ecx*2] ; eax->widths
322	stosd ; edi->FirstData	320	stosd ; edi->FirstData
323	add eax,ecx	321	add eax,ecx
324	stosd ; edi->EOF	322	stosd ; edi->EOF
325	mov eax,[esp] ; eax->fonts_count	323	mov eax,[esp] ; eax->fonts_count
326	inc byte[eax] ; increase font counter	324	inc byte[eax] ; increase font counter
327	movzx eax,byte[eax]	325	movzx eax,byte[eax]
328	.cr_id:	326	.cr_id:
329	add eax,0x3 ; create unique ID	327	add eax,0x3 ; create unique ID
330	shl eax,28 ; to easy use in color(ecx)	328	shl eax,28 ; to easy use in color(ecx)
331	jmp .exit	329	jmp .exit
332	.fail:	330	.fail:
333	xor eax,eax	331	xor eax,eax
334	.exit:	332	.exit:
335	mov [esp+28],eax	333	mov [esp+28],eax
336	popa	334	popa
337	ret	335	ret
338		336
339	if ~ BGI_LEVEL eq KERNEL	337	if ~ BGI_LEVEL eq KERNEL
340	.fontinfo:	338	.fontinfo:
341	dd 0	339	dd 0
342	dd 0	340	dd 0
-		341	dd 0
343	.fsize dd 0	342	.fsize dd 0
344	.dest dd 0	343	.dest dd 0
345	dd 0x10000	344	.fontfullname:
346	db BGIFONT_PATH	345	db BGIFONT_PATH
347	.font db 'FONT.CHR',0	346	.font db 'FONT.CHR',0
-		347
-		348	.fontattr:
-		349	dd 5
-		350	dd 0
-		351	dd 0
-		352	dd 0
-		353	dd .fileattr
-		354	db 0
-		355	dd .fontfullname
-		356	.fileattr rd 40/4
348	else	357	else
349	.dest dd 0	358	.dest dd 0
350	.font db 'FONT CHR'	359	.font db 'FONT CHR'
351	.okflag db ' ',0	360	.okflag db ' ',0
352	end if	361	end if
353		362
354	BGIfont_Coo:	363	BGIfont_Coo:
355	; y->word[txt.y1], x->word[txt.x1]	364	; y->word[txt.y1], x->word[txt.x1]
356	fild [txt.y1] ;y	365	fild [txt.y1] ;y
357	fmul st0,st0; y*y	366	fmul st0,st0; y*y
358	fild [txt.x1] ;x	367	fild [txt.x1] ;x
359	fmul st0,st0; x*x	368	fmul st0,st0; x*x
360	faddp ; xx+yy	369	faddp ; xx+yy
361	fsqrt ; sqrt, angle	370	fsqrt ; sqrt, angle
362	fild [txt.y1];y	371	fild [txt.y1];y
363	fabs	372	fabs
364	fild [txt.x1] ; x	373	fild [txt.x1] ; x
365	fabs	374	fabs
366	fpatan ; arctg(y/x)	375	fpatan ; arctg(y/x)
367	.skip:	376	.skip:
368	cmp [txt.x1],0	377	cmp [txt.x1],0
369	jge .xplus	378	jge .xplus
370	fchs	379	fchs
371	fadd st0,st3	380	fadd st0,st3
372	.xplus:	381	.xplus:
373	cmp [txt.y1],0	382	cmp [txt.y1],0
374	jge .yplus	383	jge .yplus
375	fchs	384	fchs
376	.yplus:	385	.yplus:
377	fadd st0,st2	386	fadd st0,st2
378	fsincos	387	fsincos
379	fmul st0,st2	388	fmul st0,st2
380	fiadd [txt.x0]	389	fiadd [txt.x0]
381	fistp [txt.x1] ; x=r*cos a	390	fistp [txt.x1] ; x=r*cos a
382	fmulp ; y=r*sin a,angle	391	fmulp ; y=r*sin a,angle
383	fiadd [txt.y0]	392	fiadd [txt.y0]
384	fistp [txt.y1]	393	fistp [txt.y1]
385	ret	394	ret
386		395
387	_BGIfont_Freetext:	396	_BGIfont_Freetext:
388	; in: ebx-BGIfree structure	397	; in: ebx-BGIfree structure
389	; out: eax-new drawing coords	398	; out: eax-new drawing coords
390	mov edx,[ebx]	399	mov edx,[ebx]
391	call _BGIfont_GetID	400	call _BGIfont_GetID
392	test eax,eax	401	test eax,eax
393	jnz .fexists	402	jnz .fexists
394	ret	403	ret
395	.fexists:	404	.fexists:
396	pusha	405	pusha
397	fninit	406	fninit
398	fldpi	407	fldpi
399	fld [pi180]	408	fld [pi180]
400	fimul dword[ebx+8]	409	fimul dword[ebx+8]
401	fst [BGIangle]	410	fst [BGIangle]
402	mov esi,[ebx+28]	411	mov esi,[ebx+28]
403	and esi,0xffffff	412	and esi,0xffffff
404	add esi,eax	413	add esi,eax
405	mov eax,[ebx+32]	414	mov eax,[ebx+32]
406	and [deform],0	415	and [deform],0
407	test eax,BGI_ITALIC	416	test eax,BGI_ITALIC
408	jz .norm	417	jz .norm
409	mov [deform],0.4	418	mov [deform],0.4
410	.norm:	419	.norm:
411	mov ebp,eax	420	mov ebp,eax
412	or ebp,BGI_FREE	421	or ebp,BGI_FREE
413	mov eax,[ebx+12]	422	mov eax,[ebx+12]
414	mov [Xscale],eax	423	mov [Xscale],eax
415	mov eax,[ebx+16]	424	mov eax,[ebx+16]
416	mov [Yscale],eax	425	mov [Yscale],eax
417	mov ecx,[ebx+20]	426	mov ecx,[ebx+20]
418	mov edx,ebp	427	mov edx,ebp
419	and edx,BGI_FREE+BGI_VAMASK+BGI_HAMASK	428	and edx,BGI_FREE+BGI_VAMASK+BGI_HAMASK
420	add edx,[ebx+24]	429	add edx,[ebx+24]
421	mov eax,[ebx+4]	430	mov eax,[ebx+4]
422	mov ebx,esi	431	mov ebx,esi
423	add ebx,0x6000000	432	add ebx,0x6000000
424	mov [esp+4],edx	433	mov [esp+4],edx
425	mov [esp+20],ecx	434	mov [esp+20],ecx
426	jmp txt	435	jmp txt
427		436
428	pi180 dd 0.017453	437	pi180 dd 0.017453
429		438
430	_BGIfont_Outtext:	439	_BGIfont_Outtext:
431	; in: ebx-[x][y], ecx-color, edx-string, esi-length	440	; in: ebx-[x][y], ecx-color, edx-string, esi-length
432	pusha	441	pusha
433	mov ebp,esi	442	mov ebp,esi
434	if ~ BGI_LEVEL eq KERNEL	443	if ~ BGI_LEVEL eq KERNEL
435	mov eax,ebx	444	mov eax,ebx
436	mov ebx,ecx	445	mov ebx,ecx
437	mov ecx,edx	446	mov ecx,edx
438	mov edx,esi	447	mov edx,esi
439	end if	448	end if
440	; in: eax-[x][y], ebx-color, ecx-string, edx-length	449	; in: eax-[x][y], ebx-color, ecx-string, edx-length
441	txt:	450	txt:
442	if ~ BGI_LEVEL eq KERNEL	451	if ~ BGI_LEVEL eq KERNEL
443	if BGI_WINDOW_CLIP eq 1	452	if BGI_WINDOW_CLIP eq 1
444	pusha	453	pusha
445	mov eax,9	454	mov eax,9
446	mov ebx,BGI_PRC_INFO	455	mov ebx,BGI_PRC_INFO
447	mov ecx,-1	456	mov ecx,-1
448	int 0x40	457	int 0x40
449	popa	458	popa
450	end if	459	end if
451	end if	460	end if
452	mov [.y0],ax	461	mov [.y0],ax
453	shr eax,16	462	shr eax,16
454	mov [.x0],ax	463	mov [.x0],ax
455	mov ecx,ebx ; color	464	mov ecx,ebx ; color
456	and ebx,0xfffffff	465	and ebx,0xfffffff
457	mov [.color],ebx	466	mov [.color],ebx
458	call BGIfont_get2head	467	call BGIfont_get2head
459	test edi,edi	468	test edi,edi
460	jz .exit	469	jz .exit
461	mov ecx,[esp+4]; str length	470	mov ecx,[esp+4]; str length
462	mov esi,[esp+20]; str ptr	471	mov esi,[esp+20]; str ptr
463	movzx eax,byte[edi+5]	472	movzx eax,byte[edi+5]
464	push ecx	473	push ecx
465	and ecx,0xff	474	and ecx,0xff
466	jnz .lenok	475	jnz .lenok
467	add esp,4	476	add esp,4
468	jmp .ex2	477	jmp .ex2
469	.lenok:	478	.lenok:
470	pusha	479	pusha
471	push dword[txt.y0]	480	push dword[txt.y0]
472	and dword[txt.y0],0	481	and dword[txt.y0],0
473	xor edx,edx	482	xor edx,edx
474	mov ebx,[edi+8]	483	mov ebx,[edi+8]
475	.next:	484	.next:
476	call txt.BGIfont_GetChar	485	call txt.BGIfont_GetChar
477	movzx eax,byte[ebx+eax]	486	movzx eax,byte[ebx+eax]
478	add edx,eax	487	add edx,eax
479	loop .next	488	loop .next
480	mov ecx,edx ; ecx - x size	489	mov ecx,edx ; ecx - x size
481	movzx dx,byte[edi+6]	490	movzx dx,byte[edi+6]
-		491	mov [BGIheight],dx
482	mov ebx,[esp+36]	492	mov ebx,[esp+36]
483	and ebx,BGI_HAMASK	493	and ebx,BGI_HAMASK
484	cmp ebx,BGI_HARIGHT	494	cmp ebx,BGI_HARIGHT
485	je .nova	495	je .nova
486	ja .subv	496	ja .subv
487	xor ecx,ecx	497	xor ecx,ecx
488	jmp .nova	498	jmp .nova

Subversion Repositories Kolibri OS

(root)/programs/demos/bgitest/trunk/bgifont.inc – Rev 131 → 205