OLDSKOOL BITMAP FONT (POLICE BITMAP)

Commentaire de JulioDelphi le 28/11/2006 18:33:01 administrateur CS

tiens, on dirait que c'est comme le compo que j'avais fait :
http://www.delphifr.com/codes/COMPOSANT-TDBPFONTIMAGE-IMAGE-TEXTE-PARTIR-STRING_25070.aspx

Commentaire de f0xi le 28/11/2006 20:12:26 administrateur CS

bon ... mmm ... par ou commencer...

je vais etre dur, mais je vais etre clair :

sans parler des nombreuses erreur et lourdeur du code...
il y a une piste plus simple a choisir.

cette piste consiste a definir un tableau d'image de cette maniere :

Type
TCharsMap = array[char] of TPoint

et ensuite de suivre un ordre precis pour la disposition des lettres dans le bitmap :

[23x4]
< debut >
ligne 1 : < vide 0..31 >[espace en position 32]
ligne 2 : !"#$%&'()*+,-./0123456789:;<=>?@
ligne 3 : ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`
ligne 4 : abcdefghijklmnopqrstuvwxyz{|}~
ligne 5 : < vide 0..32 >
ligne 6 : < vide 0..32 >
ligne 7 : < vide 0..32 >
ligne 8 : < vide 0..32 >
< fin >

il n'y a plus qu'a decouper ensuite chaque caracteres selon leurs taille
cW := BMPFont.Width shr 5; {div 32}
cH := BMPFont.Height shr 3; {div 8}

puis a remplir le tableau avec les parametres :

var
  N,C,I : byte;

for N := 0 to 7 do begin
    I := N shl 5; {div 32}
    for C := 0 to 31 do
        CharsMap[char(N+I)] := point(cW*C,cH*N);

et finallement, il suffit d'utiliser copyrect pour copier un caractere directement :

procedure StrToBmp(const S : string; const OffsetX,OffsetY : integer; Bmp : TBitmap);
var P : Pchar;
    i : integer;
    Dr,Sr: TRect;
begin
  P := PChar(S);
  for i := 0 to Length(S)-1 do begin
      Sr.TopLeft     := CharsMap[P[i]];
      Sr.BottomRight := point(Dr.Left+cW, Dr.Top+cH);

      Dr.TopLeft     := point(OffSetX+(cW*i), OffSetY);
      Dr.BottomRight := Point(OffSetX+(cW*(i+1)), OffSetY+cH);

      BMP.Canvas.CopyRect(Dr, BMPFont.Canvas, Sr);
  end;
end;

ou tout autre methode permettant de sortir l'image correspondante au caractere, avec des variantes (affichage vertical, Harmonic, Circular, RandomOffset etc...)
On pourrait meme adapter le tout pour fonctionner avec les images PNG et ainsi avoir une vrai transparence, des effets d'ombres, glow ect..

finalement on gagne enormement en code et performance, surtout en memoire, puisque qu'on ne travail qu'avec des les coordonnées et l'image complete (et non avec un tableau de bitmap gourmant en ressource).

Commentaire de SiZiOUS le 28/11/2006 21:50:27

Evidemment c'est perfectible ;)

"sans parler des nombreuses erreur et lourdeur du code..." lourdeur de code sans doute mais les erreurs je veux bien savoir où histoire de progresser :)

Quand a faire des décalages à la place des divisions j'y pense jamais :/

Et en effet le tableau de bitmap c'est lourd en effet. J'ai fait ce que j'ai pu ^^

Commentaire de f0xi le 29/11/2006 03:04:21 administrateur CS

tu m'as fait reflechir et j'ai penser a une autre technique :



type
  // contient les index des caracteres dans l'image
  TCharsMap     = array[char] of byte;
  // permet de stocker une chaine "mappée"
  TMappedString = array of byte;


// methode a appeler en premier
// CharsEnum correspond aux lettres presente dans l'image
// dans l'ordre (gauche haut > droite bas) d'apparition
// NullIndex correspond a l'index "vide" pour les caracteres non presents (0 par exemple)
procedure CreateCharsMap(const CharsEnum : string; const NullIndex : byte; var CharsMap : TCharsMap);
var N : integer;
    C : char;
begin
   // on remplis avec NullIndex
   FillChar(CharsMap, 256, NullIndex);
  
   // pour chaque caracteres present on assigne l'index dans l'image
   for N := 1 to Length(CharsEnum) do
       CharsMap[CharsEnum[N]] := N-1;
end;

// methode permettant de transposer les index des caracteres majuscule au caracteres minuscule
procedure CopyUpIndexToLo(var CharsMap : TCharsMap);
var pS,pD : ^Char;
begin
  pS := @CharsMap;
  pD := @CharsMap;
  inc(pS,$41); {'A'}
  inc(pD,$61); {'a'}
  Move(pS^,pD^,26); {de 'A'..'Z' a 'a'..'z'}
end;

// methode permettant de transposer les index des caracteres minuscule au caracteres majuscule
procedure CopyLoIndexToUp(var CharsMap : TCharsMap);
var pS,pD : ^Char;
begin
  pS := @CharsMap;
  pD := @CharsMap;
  inc(pS,$61); {'a'}
  inc(pD,$41); {'A'}
  Move(pS^,pD^,26); {de 'a'..'z' a 'A'..'Z'}
end;

// Mapping d'une chaine ...
// S est la chaine a mapper
// CharsMap est la table d'index a utiliser pour le mapping
// MappedString est la table d'index resultante
procedure CreateMappedStr(const S : string; const CharsMap : TCharsMap; var MappedString : TMappedString);
var N : integer;
begin
  for N := 1 to Length(S) do
      MappedString[N-1] := CharsMap[S[N]];
end;


avantages :

+polyvalente : permet d'utiliser des fontes bitmaps differente plus ou moins complete et une utilisation plus large sur les traitements graphique en aval avec la gdi, gdi+, directX ou OpenGL, grace a son independance complete par rapport a ces derniers.

+performante : routines de traitements d'indexation et mapping plus simples, tout est pré-calculé avant les lourds traitements graphiques et reste stocké jusqu'a la fermeture du programme. Les ressources sont plus legere avec une consomation de 255 octets seulement pour chaque table d'index et un traitement rapide du mapping de chaine.

+ludique : un debutant saurat l'utiliser et l'implementer sans difficultées avec un minimum d'indications, un infographiste comprendrat immediatement comment construire l'image de la fonte, un developeur comprendras egalement trés vite qu'il peu enregistrer dans un fichier la chaine de base pour l'indexation (CharsEnum) et cela pour chaque fonte, ce qui permet de construire des programmes plus elaborés et plus souple niveau customisation/mise a jours.

Commentaire de f0xi le 29/11/2006 12:14:48 administrateur CS

pour la deuxieme technique tu verras c'est trés simple a mettre en place ...

il te suffit d'appeler comme suis :

var CharsMap : TCharsMap;
    MapStr   : TMappedString;

procedure FormX.OnCreate(sender : TObject);
begin
  CreateCharsMap(' !"****''()'+
                 '**,-. 0123'+
                 '456789:*<='+
                 '>**ABCDEFG'+
                 'HIJKLMNOPQ'+
                 'RSTUVWXYZ*', 0, CharsMap);
  CharsMap['*'] := 0;
  CopyUpIndexToLo(CharsMap);
end;


et ensuite, n'importe ou avant le dessins :

CreateMappedStr('Hello World!', CharsMap, MapStr);

ce qui donneras :

MapStr(40,37,44,44,47,0,55,47,50,44,36,2)