[Projekt] StoneQuest lebt noch!

[Zudomon]

Eine gute Font benötigt meines Wissens nach einiges an Arbeit. Da darfst du sicher mindestens ein halbes Jahr Zeit reinstecken. Ich würde dann lieber Priorität setzen und erst mal eine Default-Font vom OS nehmen :P

Also spontan ist mir dazu die einfachste Idee gekommen, vielleicht die Buchstaben auf ein Blatt Papier malen und einscannen. Letztendlich werden diese ja eh auf eine Textur geschrieben. Außerdem ist ja der Deutsch/Englische Zeichensatz nicht allzu Umfangreich. Also sollte doch da kein halbes Jahr drauf gehen, hoffe ich doch... :D
Besser wäre noch, wenn man das auch prozedural machen könnte, aber mir fällt dazu nichts vernünftiges ein, außer dass man die Fonts dann auch per Hand einprogrammiert. Hmmm...

Nur mal so am Rande, ich glaube nicht, dass es das Legenden-Ziel durch diese Maßnahmen leichter wird ;).

Das wohl nicht :D

[xq]

Trotzdem brauchst du für die Font dann auch Ligaturen und dynamische Distanzen zwischen den Buchstaben. Ansonsten sieht das sehr schnell ziemlich scheiße aus :D

[Schrompf]

Nen Fixed Width Font kannst Du in ner Stunde selber pinseln. Die Mindestdaten für ordentliches Rendering pro Zeichen einzutippen ist der mühsame Teil. Und das jagst Du dann durch Deinen Fontrenderer mit dutzenden gutgewählten Testzeilen und tunest die Parameter, bis es gut aussieht. Das ist sicher kein halbes Jahr, aber mühsam trotzdem. Und Du als Einzelkämpfer solltest Dich vielleicht mal darauf konzentrieren, potentiellen Käufern irgendwas bieten zu können, anstatt Deine wertvolle Arbeitszeit auf Neben-Schlachtfeldern aufzureiben.

[Zudomon]

Und Du als Einzelkämpfer solltest Dich vielleicht mal darauf konzentrieren, potentiellen Käufern irgendwas bieten zu können, anstatt Deine wertvolle Arbeitszeit auf Neben-Schlachtfeldern aufzureiben.

Ich kenne mich und würde diesen Schritt früher oder später sowieso gehen... daher denke ich, lieber früher als später. Zumal jetzt hab ich eben noch keine Spieler, denen ich verpflichtet. Da kann ich mir das noch erlauben. Und ich denke, es ist sowieso ätzend, bereits fertig integriertes neu zu schaffen. Deswegen sehe ich diesen Schritt motivierender, wenn es jetzt geschieht. Werde mal probieren, wie es ist, so ein paar Buchstaben nach zu programmieren und dann schauen, ob die Motivation überhaupt da ist.
Wenn ich das jetzt mache, kam mir gerade die Idee, vielleicht auch besondere Zeichen mit einfließen zu lassen, so wie bei Quake1... da ist das Q ja gleichzeitig das Logo... da muss mir nur was gescheites einfallen.

[Chromanoid]

Ich will Dir nicht reinquatschen, nur aufmerksam machen, und zwar auf eine Falle, in die ich in meinen eigenen Projekten sehr häufig tappe:
Bei mir ist es häufig Teil eines Aufschiebeverhaltens mich mit unwichtigen Details zu beschäftigen, um den wirklichen Problemstellen aus dem Weg zu gehen. Wenn mir das Lösen der wirklich essentiellen projektkritischen Probleme anfängt Kopfschmerzen zu bereiten, dann weiche ich auf kleine beherrschbare Probleme aus. Das ist selbst bei Hobbyprojekten gefährlich, weil man sich so leicht vormachen kann, das Projekt insgesamt sei in seiner Machbarkeit nicht gefährdet. Vielleicht geht Dir das ja auch so...

[Zudomon]

Vielleicht geht Dir das ja auch so...

Vielleicht ;) :D

Derweil habe ich mal einen kleinen Shader, der mir zumindest schonmal einen Buchstaben rendert...

Was irgendwie geil ist, wenn man bei der Zeile Parameter ändert, kommen schon sehr unterschiedliche Buchstabentypen raus. Ob das künstlerisch ist, sei mal dahin gestellt, aber ich wollte es mal zeigen :D

Ich weiß noch nicht so ganz, wie ich die Funktion so umbiegen kann, dass sie Splines unterstützt... überhaupt ist das alles noch mehr oder weniger rumspielerei... mal sehen, ob daraus mehr wird.

[Zudomon]

Hier noch ein kleines Update...
Im Pixelshader wird zufällig ein Buchstabe gewählt und gerendert. Dabei gibt es bisher nur A, E und F...
Ich denke mal, die Splines für Rundungen werde ich einfach in Einzelsegmente unterteilen.

[marcgfx]

Ich will Dir nicht reinquatschen, nur aufmerksam machen, und zwar auf eine Falle, in die ich in meinen eigenen Projekten sehr häufig tappe:
Bei mir ist es häufig Teil eines Aufschiebeverhaltens mich mit unwichtigen Details zu beschäftigen, um den wirklichen Problemstellen aus dem Weg zu gehen. Wenn mir das Lösen der wirklich essentiellen projektkritischen Probleme anfängt Kopfschmerzen zu bereiten, dann weiche ich auf kleine beherrschbare Probleme aus. Das ist selbst bei Hobbyprojekten gefährlich, weil man sich so leicht vormachen kann, das Projekt insgesamt sei in seiner Machbarkeit nicht gefährdet. Vielleicht geht Dir das ja auch so...

das kenne ich auch zu gut...

@zodumon: verstehe ich das richtig, du willst jetzt einen eigenen font bauen/programmieren? erscheint mir schon etwas overkill. interessant finde ich es trotzdem :D

[Zudomon]

@zodumon: verstehe ich das richtig, du willst jetzt einen eigenen font bauen/programmieren? erscheint mir schon etwas overkill. interessant finde ich es trotzdem :D

Jetzt hat es doch wesentlich länger gedauert, als ich dachte... wegen entweiger Fehler... eigentlich wollte ich die Daten per Konstanten vorgeben, aber indexierter Zugriff im PixelShader 3.0 geht wohl nicht. Deswegen sind die Buchstabendaten nun auf einer Textur ausgelagert. Der Pixelshader kann jetzt eigentlich nur noch eine Variable Anzahl von Linien und Splines malen.
Damit male ich jetzt erstmal eine 512² Textur voll. Später kann das ganze dann in die normale Pipeline, wo daraus dann wiederrum eine Distancemap erstellt wird um dann die Fonts zu rendern, aber das kommt viel später. Erstmal möchte ich nun schauen, die anderen Großbuchstaben auch rein zubekommen.
A-F hab ich schon. Ist erstmal noch kein "besonderer" Font, sondern überhaupt erstmal was.
Dabei ist die Buchstaben Definition gerade noch so überschaubar.
L steht hier für Line und S für Spline... reimt sich sogar :D

Code: Alles auswählen

      case _l of
        0: begin // --- A ---
          L(0.1, 0.75, 0.3, 0.25);
          L(0.3, 0.25, 0.3+0.025, 0.25);
          L(0.3+0.025, 0.25, 0.5+0.025, 0.75);
          L(0.1675, 0.6, 0.425+0.025, 0.6);
        end;
        1: begin // --- B ---
          L(0.1,0.75,0.1,0.25);
          L(0.1,0.25,0.2,0.25);
          L(0.1,0.5,0.2,0.5);
          L(0.1,0.75,0.2,0.75);
          S(0.2,0.25, 0.45,0.25, 0.45,0.5, 0.2,0.5);
          S(0.2,0.5, 0.45,0.5, 0.45,0.75, 0.2,0.75);
        end;
        2: begin // --- C ---
          S(0.1,0.5, 0.1,0.35, 0.2,0.25, 0.3,0.25);
          S(0.3,0.25, 0.35,0.25, 0.4,0.25, 0.45,0.3);
          S(0.1,0.5, 0.1,0.65, 0.2,0.75, 0.3,0.75);
          S(0.3,0.75, 0.35,0.75, 0.4,0.75, 0.45,0.7);
        end;
        3: begin // --- D ---
          L(0.1,0.75,0.1,0.25);
          L(0.1,0.25,0.2,0.25);
          L(0.1,0.75,0.2,0.75);
          S(0.4,0.5, 0.4,0.35, 0.3,0.25, 0.2,0.25);
          S(0.4,0.5, 0.4,0.65, 0.3,0.75, 0.2,0.75);
        end;
        4: begin // --- E ---
          L(0.1,0.75,0.1,0.25);
          L(0.1,0.25,0.35,0.25);
          L(0.1,0.5,0.35,0.5);
          L(0.1,0.75,0.35,0.75);
        end;
        5: begin // --- F ---
          L(0.1,0.75,0.1,0.25);
          L(0.1,0.25,0.35,0.25);
          L(0.1,0.5,0.35,0.5);
        end;
      end;

Hier das Ergebnis:

[Zudomon]

Die Großbuchstaben hab ich geschafft und bis zur 3 bin ich gekommen... letztere sieht noch etwas krüppelig aus
Die Buchstabenbreiten werden auch schon ermittelt.
Bin jetzt erstmal weg.

[joeydee]

Wie ist denn am Ende der Anspruch an deine Schrift? Geht es nur um die Beschriftung von ein paar Buttons und Headlines? Oder geht es auch um gleichmäßigen Mengentext, also in Richtung vollwertiger Font?
("Mengen"-Text meint hier jetzt keine Buchseiten, sondern auch Sätze/Absätze wie z.B. dieser Post hier)

[Zudomon]

Mengen Text sollte schon möglich sein.
Heute werde ich nichts mehr schaffen... bin zu fertig (vom schwimmen :D), aber ein paar Ideen hab ich im Laufe des Tages noch bekommen.
Der Shader wird etwas reduziert, so dass der die Splines nicht mehr selbst in Liniensegmente unterteilt, das mache ich dann von außen. Außerdem soll es dann noch möglich sein, den Linenstart bzw. das Ende in eine beliebige Plane zu beenden. Soll heißen, wenn man sich z.B. mein A an sieht, dann ist das an den Füßen abgerundet. Ich möchte die Option haben, dass ich z.B. in diesem Fall das gerade abschneiden kann. Ich überlege auch, ob ich mir noch extra einen Editor baue, aber ich glaube, das lohnt letztendlich gar nicht, weil die Eingabe, da die Grundmechanik relativ einfach ist, auch gut per Code beschrieben werden kann. Bisher waren die Linien auch einzeln, was die Koordinatenangabe noch etwas aufwendig machte. Ich will dann morgen mal sehen, dass man Linenverbunde angeben kann. Und ich möchte mal schauen, dass ich den Font auch so parametrisiert bekomme, dass ich schon ein paar weitere Fonttypen damit generieren kann. Weil letztendlich soll mir diese Programmiererei dann auch Arbeit abnehmen. Habe da auch schon ein paar Ideen.

Das schöne ist, dass das ganze ja hinterher in die Textpipeline eingebunden werden kann. Ich muss lediglich ein Scharz-/Weißbild mit den Buchstaben erzeugen.

[Zudomon]

So ganz weiß ich noch nicht, wie ich beim Font generieren weiter vorgehen soll.
Die Splines werden nun vortesseliert, so dass der PixelShader wesentlich einfacher wird. Das hat aber eher den Grund, damit alles irgendwie einheitlich ist.

Nun hab ich mir kleine Funktionen gemacht...
LI -> ersetzt das einstige Liniensetzen
M -> bewege Cursor zu
L -> ziehe Linie
für die Splines hab ich mir noch nichts überlegt, erstmal ist die Frage, sollte man nun eher relative oder Absolute Werte nutzen?

So sah das A vorher aus:

Code: Alles auswählen

LI(0, y3, 0.2, y1);
LI(0.2, y1, 0.2+v, y1);
LI(0.2+v, y1, 0.4+v, y3);
LI(0.0675, y2+0.1, 0.325+v, y2+0.1);

Mit den neuen Funktionen:

Code: Alles auswählen

M(0, y3);
L(0.2, y1);
L(0.2+v, y1);
L(0.4+v, y3);
LI(0.0675, y2+0.1, 0.325+v, y2+0.1);

Die Frage ist auch, macht es Sinn obendrein noch in X und Y zu unterscheiden? Manchmal spart man dadurch ja auch einen Parameter. Vielleicht sollte man das MoveTo absolut und den Rest relativ machen. Ach mist, so viele Optionen! :lol:

[Zudomon]

Einzelfunktionen für X und Y, außerdem noch die Möglichkeit, die X und Y Parameter als absolut oder relativ anzugeben.
RA heißt dabei, X=relativ, Y=absolut. Die M Funktion setzt auf RR zurück.
Übrigens hat das Dach vom A 3 Linien statt der zu erwartenden 2, weil die reche Abwärtslinie etwas versetzt ist. sieht schöner aus und so entsteht dann im Dach keine Lücke.

Code: Alles auswählen

M(0, y3); RA; L(0.2, y1); LX(v); L(0.2, y3);
M(0.0675, y2b); LX(0.2575+v);

Aber richtig schwierig wirds nun beim B... eine Linie links, drei nach Rechts und dann noch 2 Splines. Also vielleicht wäre eine Art VB und IB da die bessere Lösung... bzw. ich habe noch keine Ahnung, wie man die Splines am besten angibt. Denn da wäre es toll, wenn der Punkt, der referenziert wird, den dazugehörigen Splines die gleichen Werte gibt, damit die Ableitung gut aussieht.

[xq]

Also ich würde das Zeichnen entweder total absolut oder total relativ machen. Du müsstest du dir halt nen Startpunkt definieren (Beispielsweise base-line deines Buchstabens), Schriftgröße geht ja mit Skalierung ohne Probleme, ansonsten ist das relativ/absolut Geschmackssache. Die Unterscheidung für nur X oder nur Y würde ich nicht machen...

[Zudomon]

Also ich würde das Zeichnen entweder total absolut oder total relativ machen. Du müsstest du dir halt nen Startpunkt definieren (Beispielsweise base-line deines Buchstabens), Schriftgröße geht ja mit Skalierung ohne Probleme, ansonsten ist das relativ/absolut Geschmackssache. Die Unterscheidung für nur X oder nur Y würde ich nicht machen...

Also relativ finde ich schon gut eigentlich. Das Problem ist bei dem A allerdings, dass ich dann y1-y3 bzw. y3-y1 rechnen muss, statt einfach direkt die Koordinate nutzen zu können. Deswegen da nochmal die Einzelunterscheidung.

[Zudomon]

Ich weiß noch nicht, ob das der Weisheit letzter Schluss ist, aber so sieht es nun aus...

Der alte Code für das B... 4 Linien, 2 Splines:

Code: Alles auswählen

LI(0,0.75,0,0.25);
LI(0,0.25,0.1,0.25);
LI(0,0.5,0.1,0.5);
LI(0,0.75,0.1,0.75);
SP(0.1,0.25, 0.25,0, 0.25,0, 0.1,0.5);
SP(0.1,0.5, 0.25,0, 0.25,0, 0.1,0.75);

Der neue Code ist etwas kryptischer, aber bietet irgendwie mehr Flexibilität bei weniger Parametern:

Code: Alles auswählen

M(0.1,y1);
SP(0.25, 0);
RA;
LX(-0.1);
LY(y2);
LY(y3);
LX(0.1);
SP(0.25, 0);
MI(2);
LX(0.1);
SP(0.25, 0);
SI(0, 5, false, false);
SI(5, 4, false, false);

Dabei wird durch M erstmal der Cursor gesetzt. Jeder M, LX, LY und L generiert dabei einen Vertex, der später per Index angesprochen werden kann. SP setzt für den letzten Vertex eine Spline Komponente. RA setzt hier wieder auf x=relativ, y=absolut. Dabei wird jetzt zuerst eine kleine Linie nach Links, dann zur Mitte, dann nach ganz Unten gesetzt und von da aus wieder nach rechts. MI setzt den Cursor dann statt auf einen X/Y Wert auf die Position mit dem Index. Von da aus wird dann nochmal eine kleine Linie nach rechts gezeichnet. Nun hat man ein E, welches verkürzte Enden hat. SI lässt einen Spline mit dem Start- und Endindize Zeichnen. Die Booleanwerte geben an, ob die Spline-Koordinate gespiegelt werden soll.

EDIT:
Hier nochmal etwas vereinfachter code für das B...

Code: Alles auswählen

M(0,y1); RA;
LX(0.1); SP(0.25, 0);
MI(0); LY(y2); LX(0.1); SP(0.25, 0);
MI(2); LY(y3); LX(0.1); SP(0.25, 0);
SI(1, 3, false, false);
SI(3, 5, false, false);

EDIT2:
Irgendwie hab ich das Gefühl, noch kein Mittelding zwischen Einfachheit und Übersicht gefunden zu haben...

[Zudomon]

Und ein weiterer Versuch... ich glaube, jetzt hab ich es aber! :D :D :D

Nochmal der alte Code für A und B zum Vergleich:

Code: Alles auswählen

0: begin // --- A ---
    M(0, y3); RA;
    L(0.2, y1); LX(hh); L(0.2, y3);
    AA; M(0.0675, y2b); RA; LX(0.2575+hh);
  end;
1: begin // --- B ---
    M(0,y1);
    RA;
    LX(0.1); SP(0.25, 0);
    MI(0); LY(y2); LX(0.1); SP(0.25, 0);
    MI(2); LY(y3); LX(0.1); SP(0.25, 0);
    SI(1, 3, false, false);
    SI(3, 5, false, false);
  end;

Und der Neue für A und B:

Code: Alles auswählen

0: begin // --- A ---
    V(0, y3);
    V(0.2, y1);
    V(0.2+hh, y1);
    V(0.4+hh, y3);
    V(0.0675, y2b);
    V(0.3250, y2b);
    M(0); L(1); L(2); L(3);
    M(4); L(5);
  end;
1: begin // --- B ---
    V(0, y1);
    v(0, y2);
    v(0, y3);
    V(0.1, y1, 0.25, 0);
    v(0.1, y2, 0.25, 0);
    v(0.1, y3, 0.25, 0);
    M(1); L(4); S(3, false, false); L(0); L(2); L(5); S(4, false, false);
  end;

Was hat sich geändert? Die Koordinaten werden wieder ausschließlich Absolut angegeben... dabei erstellt V einen Vertex, bei 4 Koordinaten wird gleichzeitig die Spline Komponenten angegeben.
M bewegt nun nicht den IndexCursor, nicht den Cursor. L Zeichnet eine Linie von dem CursorIndex zum angegeben Index. S genauso, aber ein Spline statt Linie.
Zumindest finde ich das nun schon sehr übersichtlich. Das ganze hat mich zwar jetzt nochmal Zeit gekostet, aber ich glaube, das kommt mir dann bei den anderen Buchstaben sehr zu gute.

[joeydee]

Mengen Text sollte schon möglich sein.

Dann solltest du die Mikrotypographie nicht unterschätzen, sonst wirkt es schnell unharmonisch. Abstände sind dabei nur eins ("To" ist z.B. unterschnitten, d.h. negativer Abstand zur Bounding-Box).
Im Prinzip muss man aber schon beim einzelnen Buchstabendesign einige optische Täuschungen manuell ausgleichen, bevor ein Schriftbild harmonisch wirkt. Schon bei sehr uniform und geometrisch wirkenden Schriften wie Arial sind z.B. die Balkenstärken nie gleich dick, und offensichtlich gleich lange Balken sind in Wahrheit unterschiedlich lang (E ist so ein Beispiel: die 3 Querbalken sind alle unterschiedlich lang, das F ist nicht deckungsgleich mit den oberen beiden E-Balken, der mittlere Balken sitzt gar nicht exakt mittig, ...). Anderes Beispiel: der rechte Balken vom "q" ist oben und unten nicht gleich breit. Außerdem: Rundungen gehen bei allen Schriften i.d.R. über die Schriftlinie/Versalhöhe hinaus (O ist höher als M). Und und und...
Sowas sind keine Design-Kapriolen des jeweiligen Künstlers, sondern notwendig um alle Buchstaben von Weitem möglichst "gleich" bzw. harmonisch aussehen zu lassen, egal wie sie aufgebaut sind und welche Buchstaben aufeinandertreffen. Da gibts leider auch keine festen Regeln, so wenig wie man halt eine optische Täuschung vermessen und parametrisiert korrigieren kann.
Interessant evtl: http://www.dma.ufg.ac.at/app/link/Allge ... 3/sub/6465

Gut, denselben Anspruch muss man an ein Game nicht haben, es sei den du willst eine Font-Engine vermarkten, dann wäre das Plichtprogramm. Ich will dir das auch nicht madig machen, im Gegenteil, da das alles auf sehr hohem Niveau ist, denke ich du solltest das wenigstens mal gehört haben :)
Weiter so.

[Zudomon]

Ja, vielen Dank für deinen Beitrag! :D
Ich hatte schon bei dem B die ganze Zeit das Gefühl, dass der obere Bauch größer ist als der untere und hab mir schon gedacht, dass dies durch eine optische Täuschung kommt. War auch gerade am Überlegen, ob ich das noch rekursiv aufeinander aufbaue... z.B. E eine Erweiterung zum F... nun erwähnst du ja genau das und ich bin mir nicht mehr sicher, ob das ganze dann Sinn hat, so aufzubauen.

Ich werde, wenn ich was habe, hier auf jeden Fall mal öfter posten, weil gerade hier kann man ja gut Feedback bekommen. Und wie du schon sagst, ich werde zwar ein wenig probieren in der Richtung, aber auch nicht zu sehr, damit nicht zu viel Zeit drauf geht.

Abstände sind dabei nur eins ("To" ist z.B. unterschnitten, d.h. negativer Abstand zur Bounding-Box).

Ist das dann generell bei dem Buchstabe oder überhaupt bei genau dieser Buchstaben Verbindung? Weil letzteres wird doch generell gar nicht beachtet, wenn man daraus Bitmapfonts macht.

[Zudomon]

Soweit, so gut.
Aber um ehrlich zu sein traue ich mich nicht so ganz an die Kleinbuchstaben... noch mehr Rundungen...

[joeydee]

Ja, ich musste das in meiner Ausbildung (Schriftsetzer) lernen und skizzieren können. Alles weiß ich zwar nicht mehr und würde heute sicher durchfallen :D aber auf ein paar Sachen achte ich immer sofort.

Ich würde auf alle Fälle die mittleren Balken von E und F kürzer machen. Sämtliche Rundungen ein wenig über die gedachte Linie hinausgehen lassen (C,G,J,O,Q,S,U). Wie schon erkannt beim B den oberen Bogen kleiner, ebenso die 8. K evtl nicht wie ein I< mittig treffen, sondern die Balken versetzen, muss aber nicht. S: unteren Bogen etwas größer als der obere. 5 oberen Teil kleiner. Das V würde ich etwas schmaler, nur unwesentlich breiter als das U machen. Bei B,P,R erst ein Stückchen gerade, dann den Bogen anfangen, im Moment stürzt er etwas ab. Die J-Rundung etwas breiter, vielleicht so wie die 0 (Null). Das wars von mir auf den ersten Blick.
Auch so eine unerwartete Überraschung: das kleine l ist in manchen Schriften höher als das große I. Kleinbuchstaben sind da sowieso nochmal etwas komplexer, verschiedene Oberlängen und so (t vs. l kann auch unterschiedlich hoch sein).
In dem Link sind am Ende ein paar Dinge genannt, die aber in der Regel bei jeder Schrift gleich/gespiegelt sind (Teile von dbqp usw.), in der Richtung kannst du ja schonmal optimieren.

Abstände:
Erstmal geht es nach Abstand vor/nach, was je Buchstabe fest definiert wird. Links und rechts vom T null, rechts vom F null oder so... HI steht damit normalerweise etwas weiter auseinander als TI, da H rechts einen positiven Wert hat.
Jetzt kann man natürlich nicht T rechts und/oder o links negativ definieren, sonst klappen andere Kombinationen damit nicht mehr. Soweit ich weiß werden da in Font-Dateien Paartabellen hinterlegt, die Spezialfälle behandeln. Generell kann man das kaum angeben. Ich würde da nach Fällen suchen, wo rechts/links zweimal null (oder ein kleiner Wert) aufeinandertrifft. Beispiele: To wird unterschnitten, Tk aber nicht, Ho auch nicht, Vo wird wieder unterschnitten, Va je nach a-Form ggf. weniger, VA natürlich (es sei denn es ist ein eckiges A), usw...
Vielleicht kommst du da auch über so ein Fontdesignprogramm an Tabellen ran, um zu sehen was generell alles in Frage kommt?

Was auch mal interessant wäre: wenn man die Schrift ein paar(tausend)mal mit verschiedenen (Zufalls-)Texten rendert, Grauwert und so Sachen ermittelt und Abstände optimiert, selbstlernend die Tabellen erstellen sozusagen - keine Ahnung ob da was bei rauskommt.

Da steckt übrigens nicht nur ein ästhetischer, sondern auch ein praktischer Sinn dahinter: Je mehr das alles stimmt, desto weniger bleibt das Auge unbewusst an "Mehlklumpen" in der Soße oder anderen ungewollten Auffälligkeiten hängen, und desto flüssiger und weniger ermüdend ist ein längerer Text zu lesen. Daher gibts auch z.B. Fließtext-Fonts, Finanz-Fonts (mit nochmal besonderem Augenmerk auf Ziffern), oder rein grafische Fonts für Headlines mit wenigen Worten, wo man die Abstände zusätzlich von Hand ausgleicht. Solange du da keine Bibel mit abdruckst, musst du auch nicht sämtliche Details perfektionieren :D

[Zudomon]

KRASS!
Das ist ja auch schon wieder eine Wissenschaft für sich. Also was die Abstandsunterschreitungen und so angeht, da scheint es also schon nach der Form zu gehen, je nachdem, wie das zusammen passt. Aber in wie weit ich da was mache, weiß ich noch nicht. Das würde ja auch dann eher das Font-Rendering betreffen, statt jetzt das Erstellen der Buchstaben. Vielleicht könnte man bei den Buchstaben noch eine Art Formindex dazu geben. Also je nachdem, wie links und rechts vom Buchstaben die Form ist würden dann automatisch diese Abstände geringer ausfallen. Also ein A hätte links und rechts einen "unten breit, oben schmal" Form... wenn dann AA steht, dann werden die nicht zusammen gequetscht, weil die, wie bei Puzzleteilen nicht zusammen passen. Bei dem V hingegen ist links und rechts "oben breit, unten schmal", daher würde dann ein VV wie beim AA nicht den Abstand verringern, ein VA oder ein AV aber schon.
Danke für dein Feedback... werde ich einarbeiten und das Ergebnis zeigen. Ich versuche mich von Design her an Calibri zu orientieren. Den habe ich bereits verwendet und finde, das ist ein guter Basisfont.

[Zudomon]

@joeydee
So, ich habe mal versucht, deine Kritik mit einfließen zu lassen. Was meinst du? Also richtig perfekt wird das wohl nicht... dafür ist das über Quellcode echt etwas frimmelig. ;) :D

[Zudomon]

Es geht voran... :D

Programmieren ist sooo geil! :D
Der Anfangswiderstand ist zwar immer extremst hoch, aber dafür wird es dann immer einfacher und das exponentiell. Der erste Buchstabe eine Qual. Und am Ende macht man Dinge, für die Designer lange brauchen würden in Minuten. Ich denke nämlich, dass man aus diesem "Basis-Font" auch schnell anderes genieren kann hinterher.

Cool ist, dass nun die Buchstaben, so wie sich das beim proggen gehört, aufeinander aufbauen können... z.B.:
E = F + 1 Strich
G = C + 2 Striche
B = P + Strich und Bogen
R = P + Bogen

Und so sieht z.B. das große G mittlerweile im Code aus:

Code: Alles auswählen

      'G': begin
        LET('C');
        V(0.35, y2);
        V(0.2, y2);
        S(4, 6);
      end;

Und einige Kleinbuchstaben sind ja nur skalierte Versionen der Großen... da kann man mit einem Stückchen Code schon 7 Kleinbuchstaben erschlagen! :D

Code: Alles auswählen

      'c', 'o', 's', 'v', 'w', 'x', 'z': begin
        Let(UpCase(_ll));
        SCL(0,y3,sls,sls);
      end;

[Alexander Kornrumpf]

Und am Ende macht man Dinge, für die Designer lange brauchen würden in Minuten.

Der Punkt ist halt, bei einem Designer sieht es hinterher gut aus und bei dir wie Comic Sans.

[Zudomon]

Und am Ende macht man Dinge, für die Designer lange brauchen würden in Minuten.

Der Punkt ist halt, bei einem Designer sieht es hinterher gut aus und bei dir wie Comic Sans.

Manche Menschen haben ein gewisses Maß an Weitsicht, andere nicht... :D
1. sieht der Font garantiert nicht aus, wie Comic Sans, falls er das für dich doch tut, solltest du an deiner Wahrnehmung arbeiten
2. ist das Gezeigte nur ein Zwischenprodukt
3. wenn du das Potential hinter Programmieren nicht erkennst, solltest du dich vielleicht in einem andren Bereich verwirklichen
4. wie wäre es, statt zu sticheln (und das ist, soweit ich mich erinnere, nicht das erste mal), konstruktive Kritik zu bringen, wie z.B. joeydee
5. kannst du ja mal selbst einen Font machen und dann schauen wir mal, wie gut du das hinbekommst :D

Nun fehlen nur noch 'e' und 'g'

Hier noch eine in 2 Minuten gemachte "Comic Sans" variante (noch nicht ganz... aber einfach mal die Punkte durchschütteln bringt schon einen netten Effekt)

[Spiele Programmierer]

Ich glaube, du hast die Quintessenz seiner Aussage sehr geschickt übersehen. ;)
Du steckst hier viel Zeit in etwas, dass am Ende gleichermaßen schlechter aussieht, weniger funktional ist als auch unnötig Zeit in Anspruch genommen hat.

Manche Menschen haben ein gewisses Maß an Weitsicht, andere nicht...

Nun, mit meiner Weitsicht stelle ich fest, dass zum Beispiel Unicode über 100 000 Zeichen definiert. Ich habe mal starke Zweifel, dass du mit deinem bisherigen "weitsichtigen" Verfahren zum Beispiel chinesische Zeichen vernünftig definieren können wirst. Soweit ich das verstanden habe, würdest du aber gerne diverse Übersetzungen anbieten. Insofern glaube ich nicht, dass das Verfahren weitsichtig ist.

1. Das war bestimmt metaphorisch in Bezug auf die Qualität gemeint.
2. ... bedeutet, dass du noch viel mehr Zeit reininvestieren musst.
3. Das Potential von Programmieren ist nicht überall gleich groß. Buchstaben zu programmieren (die visuell gut aussehen) scheint mir nicht unbedingt Potential zu haben und ist insbesondere als Teil eines Spiels bisschen fehl am Platz.
4. Es ist auch nicht konstruktiv, im Rahmen eines Spiels eine Font als Quellcode zu definieren. Die konstruktivste Kritik scheint mir zu sein, dich dazu abzuraten und eine fertige Font zu nehmen.
5. Naja, ich nehme einfach eine fertige Font. Warum sollte ich ein Font mit Programmcode selbst definieren?

Dein Ego mit der Anforderung "alles selbst gemacht zu haben" steht dir scheinbar enorm im Weg zu deinem eigentlichen Ziel, ein Spiel (selbst) zu entwickeln. So, ich hoffe die Kritik wirkt nicht zu hart. ;)
Meine Sorge ist nur, dass du hier gerade total an deinem eigentlichen Ziel, dem Spiel als auch den Spielern vorbeiarbeitest, ohne dass dir das voll bewusst ist. Das finde ich ein wenig schade.

[marcgfx]

ich finde es zwar cool, was du hier machst, aber sinnvoll erscheint es mir nicht.

realitätscheck: ob jetzt comic-sans oder nicht, der aufwand ist enorm für etwas, das du schon in einer schöneren form hattest. gibt dir das font-erstellen irgend einen mehrwert, den auch andere schätzen werden? es ist doch egal, ob du alles selbst gemacht hast (binary auf der selbst gelöteten hardware?). es ist schwer genug ein spiel fertig zu bekommen ohne sich selber steine in den weg zu legen. wenn es dir um die erfahrung geht einen eigenen font zu erstellen, ich finds absolut cool. als sinnvolle arbeit um ein spiel fertig zu bekommen ist es aber nicht verteidigbar.

noch weniger sinnvoll ist sich gegenseitig ans bein zu pissen. sei es zu behaupten man könne was besseres machen als ein designer, sei es zu behaupten ein font sehe aus wie comic-sans oder sei es einem anderen abzuraten weiter zu programmieren. ist doch kinderkacke.

[Zudomon]

Zunächst mal entscheidet jeder für sein Projekt selbst, was er gerne machen möchte und was nicht. Und wenn es mir besonders wichtig ist, meinen Content selbst zu erschaffen, dann ist das nun erstmal so...
Ja, ich hatte vorher schöne Fonts, aber ich konnte nicht sicher gehen, ob diese installiert sind. Außerdem ist es nicht immer so einfach zu ermitteln, welche Fonts kommerziell genutzt werden können bzw. mit welcher Lizens. Gut, schreckt vielleicht andere nicht ab, sie zu verwenden. Für mich ist das unerheblich, weil es eben für mich unter Kontent fällt, also ich es gerne selbst machen würde.

Ich beziehe mich mal auf dich jetzt "Spiele Programmierer", da du ja für Alexander geantwortet hast.

Ich glaube, du hast die Quintessenz seiner Aussage sehr geschickt übersehen.
Du steckst hier viel Zeit in etwas, dass am Ende gleichermaßen schlechter aussieht, weniger funktional ist als auch unnötig Zeit in Anspruch genommen hat.

Mag sein, dass das seine Quintessenz ist, aber genau genommen kann man nicht wissen, ob es hinterher schlechter aussieht. Ich will auch gar nicht mal behaupten, dass mein Ergebnis besser wird (diesen Anspruch habe ich ehrlich gesagt auch gar nicht), aber zu sagen,

bei einem Designer sieht es hinterher gut aus und bei dir wie Comic Sans.

impliziert ja, dass meins nicht gut aussieht (bzw. aussehen kann) sondern halt wie Comic Sans. Wobei ich gar nicht wissen möchte, wie viel Designarbeit in eine Schriftart wie "Comic Sans" fließt. Weil mal eben ist das auch nicht gemacht!
Wie auch immer, fühl ich mich angegriffen durch. Zumal es eben auch unhaltbar ist, da die Quintessenz in Comic Sans wohl keine geraden Linien beinhaltet, da fängt es schon an. Und da ich meine mich halt daran zu erinnern, wie gerade er sich damals schon beschwert hat, dass ich immer nur "Nahaufnahmen" von Grass poste und dass ihr ja "so langsam wüsstet, dass meine Engine das gut darstellen kann", glaube ich einfach, dass es eine ähnliche Stichelei war. Warum muss man solche Kommentare bringen?

So, und nun mal zur Weitsicht! Warum wird denn immer mehr prozedural erschaffen? Weil das Ganze sonst nicht mehr Handlebar wird.
Was vergleicht ihr hier nun eigentlich?
Selbst programmiert vs Fertiges benutzen
oder, und das tue ich:
Selbst programmiert vs Selbst designen

Das man einfach einen fertigen Font benutzen kann, okay, ist klar, geht schneller, braucht man nicht drüber debattieren. Erfüllt aber nicht meinen Anspruch des selbst Schaffens.

Nun, mit meiner Weitsicht stelle ich fest, dass zum Beispiel Unicode über 100 000 Zeichen definiert.

Hahahahaha! :lol: Das ist ja wohl ein Witz! Also 100 000 Zeichen programmieren ist nicht weitsichtig... was denn dann? Willst die per Hand malen? Na da bin ich mal gespannt. Ach ne, du vergleichst da bestimmt auch wieder einfach mit "einen fertigen Font" benutzen, oder?
Aber mal von dem Unicode abgesehen:

Außerdem ist ja der Deutsch/Englische Zeichensatz nicht allzu Umfangreich. Also sollte doch da kein halbes Jahr drauf gehen, hoffe ich doch... :D

(http://zfx.info/viewtopic.php?f=10&t=37 ... 300#p50860)

So, nun nochmal zu meiner Quintessenz... öffne ein Font Programm deiner Wahl und lass uns, sagen wir, 5 verschiedene Fonts erstellen... ohne Unicode... ich denke, programmiert komme ich schneller dahin. Und ich habe den Begriff "Designer" genommen, um den Unterschied zwischen designen und programmieren deutlich zu machen. Das heißt nicht, dass Font Künstler da nicht besser mit ihrem Weg sind. Wobei ich der Meinung bin, auf lange Sicht schlägt programmieren immer designen. Allerdings erst in Sphären, wo wohl keiner von uns bisher dran reicht. ;)