Merhaba,

Belki grafik/demo programlarında kullanmak üzere, tıpkı LED ekranlardaki gibi dotFont çalışmasını (şimdilik 0-9, A, B, C, Ç D karakterleri yapıldı) aşağıda bulabilirsiniz. Özelliği bool veriyi byte'a çevirip kod içinde doğrudan kullanabileceğiniz veriyi ekrana döndürmesiydi. Yani bu kadar gereksiz kod/veri(*) bunun için...:)

Ayrıca sonda hangi desen ne sıklıkla kullandığı özetini veriyor. Belki satır/sütun (16x8 -> 8x16) yer değiştirilerse daha farklı (iyi/kötü) sonuç çıkabilir. Ama onun algoritmasını (şurada (http://www.kosbie.net/cmu/fall-08/15-100/handouts/notes-two-dimensional-arrays.html) bir şeyler var ama) beceremedim. Belki de sıkıştırmak gereksiz çünkü böyle bir veri yapısı topu topu 16 byte (cent variable type) yer kaplıyor. Ekrana çizilmesi ise yaklaşık 150 cycle/pixel (16x8 = 128) görünüyor. Henüz SDL'de denemedim ama iş görür gibi, ne dersiniz?

(*) Bu algoritma/veri yapısı mutlaka bir yerlerde vardır veya kullanılıyordur. Ancak bu hem Türkçe hem de kişiselleştirilebilir. Bir de BIOS'dan veri alıp da render ediyorlar galiba. O nasıl olur, hızlımı olur bilmiyorum. Ama siz de katkı sağlamak isterseniz ortalardan bir yerde harf dizisi (örneğin küçük harflere daha var!) desteği verirseniz hepimiz için bir kardır.

/*
 dotfont.d (23.08.2012)
*
* dmd dotfont sdl -L-lSDL -release
*/
//import sdl, core.stdc.stdio: printf;/*
import std.stdio;//*/

void analizEt_ve_Çevir(bool[][]*[] dotfont) {
 byte[][] abece;
 abece.length = dotfont.length;
 int[int] sayım;
 int xSay, say, xTopla;
 foreach(Y; dotfont) {
   foreach(y; *Y) {
     say = 0;
     foreach(p, x; y) {
       if(x) printf("Θ"); else printf("·");
       say += x ? 1 << p : 0;
     }
     abece[xSay] ~= cast(byte)say;
     printf("\n");
     sayım[say]++;
   }
   xSay++;
   sayım.writeln;
 }

 write("\n\nbyte[][] abece = ");
 abece.writeln(";\n\n");

 say = sayım.length - 1;
 // +1 boş satır, değeri sıfır (0) ve sayıca fazla: ~100-200 bayt
 say.writeln(" + 1 bayt farklı desen tespit edildi, bunlar:");
 writeln("==================================================");
 foreach(i; sayım.keys) {
   if(i) i.writeln("\t: ", std.array.replicate("*",
                    sayım[i]), "(", sayım[i], ")");
   xTopla += sayım[i];
 }
 writeln("==================================================");
 writefln("Toplam %d bayt veri analiz edildi ve\n"
          "%d'de 1'e algoritma ile özelleştirilebilir veya\n"
          "sıkıştırışabilir...", xTopla, xTopla / (say +1));
}

void main() {
 bool[][] sıfır = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                    [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                  ];
 bool[][] bir = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                  [ 0, 0, 1, 1, 1, 0, 0, 0 ],
                  [ 0, 1, 1, 1, 1, 0, 0, 0 ],
                  [ 1, 1, 0, 1, 1, 0, 0, 0 ],
                  [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                  [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                  [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                  [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                  [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                  [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                ];
 bool[][] iki = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                  [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                  [ 0, 0, 0, 0, 0, 1, 1, 0 ],
                  [ 0, 0, 0, 0, 1, 1, 0, 0 ],
                  [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                  [ 0, 0, 1, 1, 0, 0, 0, 0 ],
                  [ 0, 1, 1, 0, 0, 0, 0, 0 ],
                  [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                ];
 bool[][] üç = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                 [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                 [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                 [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                 [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                 [ 0, 0, 0, 0, 0, 1, 1, 0 ],
                 [ 0, 0, 0, 0, 0, 1, 1, 0 ],
                 [ 0, 0, 0, 1, 1, 1, 0, 0 ],
                 [ 0, 0, 0, 1, 1, 1, 1, 0 ],
                 [ 0, 0, 0, 0, 0, 1, 1, 0 ],
                 [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                 [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                 [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                 [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                 [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                 [ 0, 0, 0, 0, 0, 0, 0, 0 ]
               ];
 bool[][] dört = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 1, 1, 0, 0 ],
                   [ 0, 0, 0, 1, 1, 1, 0, 0 ],
                   [ 0, 0, 1, 1, 1, 1, 0, 0 ],
                   [ 0, 1, 1, 0, 1, 1, 0, 0 ],
                   [ 1, 1, 0, 0, 1, 1, 0, 0 ],
                   [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                   [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                   [ 0, 0, 0, 0, 1, 1, 0, 0 ],
                   [ 0, 0, 0, 0, 1, 1, 0, 0 ],
                   [ 0, 0, 0, 0, 1, 1, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                 ];
 bool[][] beş = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                  [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                  [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 0, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 0, 0, 0, 0, 0, 1, 1, 0 ],
                  [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                  [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                  [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                  [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                ];
 bool[][] altı = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                   [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                   [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                   [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                   [ 1, 1, 1, 1, 1, 1, 0, 0 ],
                   [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                   [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                   [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                   [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                   [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                 ];
 bool[][] yedi = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                   [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                   [ 0, 0, 0, 0, 0, 1, 1, 0 ],
                   [ 0, 0, 0, 0, 1, 1, 0, 0 ],
                   [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                   [ 0, 0, 1, 1, 0, 0, 0, 0 ],
                   [ 0, 0, 1, 1, 0, 0, 0, 0 ],
                   [ 0, 0, 1, 1, 0, 0, 0, 0 ],
                   [ 0, 0, 1, 1, 0, 0, 0, 0 ],
                   [ 0, 0, 1, 1, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                   [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                 ];
 bool[][] sekiz = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                    [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                    [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                  ];
 bool[][] dokuz = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                    [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 0, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 0, 0, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                    [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                    [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                    [ 0, 0, 0, 0, 0, 0, 0, 0 ]
                  ];
 bool[][] A = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 1, 0, 0, 0, 0 ],
                [ 0, 0, 1, 1, 1, 0, 0, 0 ],
                [ 0, 1, 1, 0, 1, 1, 0, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ]
              ];
 bool[][] B = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 1, 1, 1, 1, 0, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 0, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ]
              ];
 bool[][] C = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ]
              ];
 bool[][] Ç = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 0, 1, 1, 1, 1, 1, 0, 0 ],
                [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                [ 0, 0, 0, 1, 1, 0, 0, 0 ],
                [ 0, 0, 1, 1, 0, 0, 0, 0 ]
              ];
 bool[][] D = [ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 1, 1, 1, 1, 1, 1, 0, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 0, 0, 0, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 1, 0 ],
                [ 1, 1, 1, 1, 1, 1, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ],
                [ 0, 0, 0, 0, 0, 0, 0, 0 ]
              ];
 bool[][]*[] sayılar = [ &sıfır, &bir, &iki, &üç, &dört, &beş, &altı,
                         &yedi, &sekiz, &dokuz, &A, &B, &C, &Ç, &D ];

 analizEt_ve_Çevir(sayılar);
}

Çıktısı: (son kısmı)
'
20 + 1 bayt farklı desen tespit edildi, bunlar:

62 : *****************(17)
63 : ******(6)
126 : **(2)
127 : ************************************(36)
96 : *******(7)
3 : ***********(11)
99 : **************************************(38)
6 : *(1)
8 : *(1)
12 : *******(7)
48 : ******(6)
51 : *(1)
54 : **(2)
24 : **********(10)
56 : **(2)
27 : *(1)
120 : *(1)
28 : **(2)
60 : *(1)
30 : *(1)

Toplam 240 bayt veri analiz edildi ve
11'de 1'e algoritma ile özelleştirilebilir veya
sıkıştırışabilir...
'
Başarılar...

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (acehreli):

Dosya olayı hoş bir fikir ve bence denenmesi de gerekir. Ancak buradaki amacım çok farklı. Hiç bir dosya okumasına ihtiyaç bırakmadan (embedded), tek başına çalışabileceği (standalone) oyunlar geliştirmek istiyorum. Yoksa SDL_ttf kütüphanesi ile (ilintileri hazır sdl.d içinde) 'font'lar 'render' edilip ekrana istediğimiz boyutta yansıtılabiliyor.

Alıntı (acehreli):

Ayrıca burada uretgen.d'deki gibi dilim kullanmadım. Sanırım veri sıkıştırması (olasılık kuramı) açısından da çok zor ve gereksiz bir şey olacak. Tamam, Kutuları Kapat (http://ddili.org/forum/post/7429) oyununda kullanmıştım; zar yüzeyleri, bu tür veri yapısını oluşturmak için uygun. Ama burada yaptığım farklı bir şey. Tüm dizileri tek parametre (ve üçüncü bir döngü!) ile işleve aktarabiliyorum. Bu bir nevi işaretçi dizi/parametre yöntemi. Yani parametre aslında bir işaretçi kümesi. Bunu uretgen.d'de keşfetmiştim çünkü parametre sayıları gittikçe artınca kullanışsız oluyor. Gerçi struct gibi olanaklar var ama dizileri ve işaretçileri (tabi ki dilimleri) çok seviyorum...:)

Alıntı (acehreli):

Bunu program bize veriyor. Örneğin rakamlar sadece 100 + 1 byte yer kaplıyor:

byte[][] rakam = [ [  62, 127, 99, 99,  99,  99,  99,  99, 127,  62 ], // sıfır
                  [  24,  28, 30, 27,  24,  24,  24,  24,  24, 127 ], // bir
                  [  62, 127, 99, 96,  48,  24,  12,   6, 127, 127 ], // iki
                  [  62, 127, 96, 96,  56, 120,  96,  99, 127,  62 ], // üç
                  [  48,  56, 60, 54,  51, 127, 127,  48,  48,  48 ], // dört
                  [ 127, 127,  3,  3, 127, 126,  96,  99, 127,  62 ], // beş
                  [  62, 127, 99,  3,  63, 127,  99,  99, 127,  62 ], // altı
                  [ 127, 127, 96, 48,  24,  12,  12,  12,  12,  12 ], // yedi
                  [  62, 127, 99, 99,  62, 127,  99,  99, 127,  62 ], // sekiz
                  [  62, 127, 99, 99, 127, 126,  96,  99, 127,  62 ]  // dokuz
                ];

Bunları ekrana yansıtmak için ise şu kodu işletmeniz yeterli:

import sdl, std.math;
// derlemek için: dmd noktalıRakam sdl -L-lSDL -release
void main(){
 SDL_Surface* ekran = SDL_SetVideoMode(650, 100, 0, SDL_HWSURFACE);

 void yuvarlakÇiz(int x, int y, int r, int c = int.max) {
   int len, ofs;
   for(int i = 0; i < 2 * r; i++) {
     len = cast(int)sqrt(cast(float)(r ^^ 2 - (r - i) ^^ 2));
     ofs = (y - r + i) * (ekran.pitch / 4) + x - len;
     for(int j = 0; j < len << 1; j++) (cast(uint*) ekran.pixels)[ofs + j] = c;
   }
 }

 auto sütun(byte veri) {
   bool[8] sonuç;
   for(int i = 0; i < 8; i++) {
     sonuç[i] = 1 << i & veri ?
                true :
                false;
   }
   return sonuç;
 }

 void veriyiNoktalar_ile_Yansıt(byte[][] veri, int r = 10) {
   int x = r * 2, y = r * 2;
   int x_tmp;

   foreach(rakam; veri) {
     foreach(satır; rakam) {
       x_tmp = x;
       foreach(bas; sütun(satır)) {
         if(bas) yuvarlakÇiz(x, y, r);
         x += r * 2;
       }
       x = x_tmp;
       y += r * 2;
     }
     x += r * 16 + 1;
     y = r * 2;
   }
 }
 veriyiNoktalar_ile_Yansıt(rakam, 4);
 SDL_Flip(ekran); // önbellekten ekrana yansıt...
 SDL_Delay(2000); // 2 sn. bekle!
 SDL_Quit();
}

Çıktısı:
http://img33.imageshack.us/img33/287/rakamlar.png
Alıntı (acehreli):

Programcılığa ilk başladığımdan beri kullandığım herhangi bir şeyi sayan bir sayaç/counter. Bunu kendimce bir gelenek haline getirdim, bana özel ve kimse kullanmak zorunda değil. Size anlamsız gelse de gittikçe başka varyasyonlarını türetmeye başladım. Örneğin xTopla (herhangi bir şeyi parametre ile topla) gibi ve hatta xKonumla/yKonumla. Yani bu bir Macar Notasyonu değil, Salih Notasyonu'dur! Seviyorum n'apayım ve eminim yazdığım bir çok programda xSay'ı göreceksiniz; görürseniz beni hatırlayın emi...:)

Dip Not: Bu arada evet, xSay'ın olduğu yer de say olması ve emir anlamını içermesi saçma olmuş. Sonuçta bu sadece bir tool ve tek bir amacı var, önceki cevapta naklettiğim diziyi doğru bir şekilde elde etmek. Aklıma çok renkli şeyler gelmediği ve kısaca geçmek istediğim için öyle isimlendirmişim.

Sevgiler, saygılar...

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

• Harf bilgilerini bir dosyadan okuyabilirsin. Böylece font değiştirmek gerektiğinde koda dokunulmamış olur. Font dedim de aklım geldi ;) bir font dosya düzenini okuyabilsen o zaman karakterleri senin çizmen de gerekmez.

• Dizileri yer kazanma amacıyla bool seçtiysen hatırlatmak istiyorum: her bool da bir bayttır. true ve false yerine 0 ve 1 kullandığına bakılırsa hiçbir zarar görmeden ubyte da kullanabilirsin.

Aslında bool'un tek bitlik bilgi olmasından yararlanarak sekizer sekizer ubyte'lara yerleştirerek yer kazancı da sağlanabilir. std.container.Array'in bool özellemesi bunu yapar. Şurada 'struct Array(T) if (is(T == bool));' özellemesinde kısaca söylemişler:

http://dlang.org/phobos/std_container.html

• Erdem'in geçen gün değinmesinden cesaretle ben de dile getiriyorum: Değişken isimlerinin başındaki x'in anlamı ne? Örneğin xSay ile say arasındaki fark ne? Bir de, say deyince emir kipinde olduğu için benim kulağıma uygun gelmedi. Onları işlev isimlerine ayırmak daha uygun.

• Kendim denemeden soruyorum: Türün arasına gösterge sıkıştırmak gerçekten gerekti mi? Dilimler zaten referans türleri olduklarından sanki bool[][][] da olurmuş gibi geliyor. (Denemedim.)

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]