Wieder Probleme, aber diesmal mit GLUT...

[Matrix316]

Also ich soll ein kleines Programm schreiben was ein Fenster öffnet in dem man einen Text schreiben kann.

Das Fenster öffnet sich auch, aber beim Tippen erscheint kein Text...oder muss ich die Funktion irgendwie anders aufrufen oder wie oder was? :???:


#include <stdio.h>
#include <glut.h>
#include <string.h>

void window(void)
{

glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)
{
int len, i;
glRasterPos2f(x,y);
len = (int)strlen(string);
for (i=0; i<len;i++)
{
glutBitmapCharacter(font,string[i]);
}
}

int main(int argc, char *argv[])
{
int win;
char text;

glutInit(&argc, argv);
glutInitWindowSize(640,480);

win=glutCreateWindow("Ein Fenster");

bitmap_output(0,0,&text,GLUT_BITMAP_TIMES_ROMAN_10);

glutDisplayFunc(window);
glutMainLoop();
return 0;
}


oder sind die Buchstaben etwa schwarz und ich muss was an der Farbe ändern?

[Xmas]

???
Welche Buchstaben denn? Wo sollen die denn herkommen?

[zeckensack]

1. Du hast Glück, daß dir das nicht mit einem GPF absemmelt ;)
char text;
^^ was soll das denn?

2. Das display callback tut nichts. Wenn es Text rendern soll, dann solltest du das schleunigst mal ändern.

3. In main sollten nur die Callbacks registriert werden. Hier schon bitmap_output aufzurufen nützt dir herzlich wenig. Das erste was glutMainLoop macht, ist dein display callback aufzurufen, also selbst wenn du einen vernünftigen Text rendern würdest, der wird sofort wieder gelöscht (glClear).

4. Double buffering wäre wirklich zu bevorzugen (swappen nicht vergessen).

5. What XMas sez ;)
Du solltest ein Keyboard-Callback einrichten, das ASCII-Werte in einem (globalen) char-Array parkt und Neurendern veranlasst.

Mehr wird nicht verraten, sonst bleibt keine Arbeit mehr für dich über :)

[Matrix316]

Original geschrieben von Xmas
???
Welche Buchstaben denn? Wo sollen die denn herkommen?

Woher soll ich das wissen - da ist eben eine Funktion die angeblich für die Textausgabe genutzt werden kann. Mehr wurde nicht gesagt. :(

[Matrix316]

Original geschrieben von zeckensack
1. Du hast Glück, daß dir das nicht mit einem GPF absemmelt ;)
char text;
^^ was soll das denn?



Was das soll? In dem "void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)" steht da "char *string" Und das ist für mich erstmal eine Zeigervariable vom Typ char...

Und da char *text -> text immer abgestürzt ist, hab ichs halt mit char text -> &text probiert. ;)

PS.: Wenn ich wüsste wann und WO ich WAS aufrufen muss, dann würde ich hier nicht dumm rumfragen :P

[Exxtreme]

Original geschrieben von Matrix316
Was das soll? In dem "void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)" steht da "char *string" Und das ist für mich erstmal eine Zeigervariable vom Typ char...

Und da char *text -> text immer abgestürzt ist, hab ichs halt mit char text -> &text probiert. ;)

PS.: Wenn ich wüsste wann und WO ich WAS aufrufen muss, dann würde ich hier nicht dumm rumfragen :P
AAARRRGGHH!

Typ char ist EIN Zeichen. Die Funktion, die du da hast, erwartet einen nullterminierten String, sprich char text[x] oder char *text.

Und der wahrscheinliche Grund, warum dein char *text nicht funktioniert hat, ist weil du wohl vergessen hast, den Speicher vorher zu allokieren. Schau dir dazu die Doku zur Funktion malloc an.

[Matrix316]

Das kann ich aber nur wenn ich weiß wieviel Speicher ich brauche, oder?

Meint ihr jetzt das so ähnlich?

#include <stdio.h>
#include <glut.h>
#include <string.h>

void window(void)
{

glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)
{
int len, i;
glRasterPos2f(x,y);
len = (int)strlen(string);
for (i=0; i<len;i++)
{
glutBitmapCharacter(font,string[i]);
}
}

void KeyboardEingabe(unsigned char key, int x, int y)
{
char *text;
text=(char *) &key;
bitmap_output(0,0,text,GLUT_BITMAP_TIMES_ROMAN_24);

}

int main(int argc, char *argv[])
{
int win;
//char text;

glutInit(&argc, argv);
glutInitWindowSize(640,480);

win=glutCreateWindow("Ein Fenster");

glutKeyboardFunc(KeyboardEingabe);

glutDisplayFunc(window);
glutMainLoop();
return 0;
}


Jetzt erscheinen aber alle Buchstaben in der Mitte...

[Exxtreme]

Original geschrieben von Matrix316
Das kann ich aber nur wenn ich weiß wieviel Speicher ich brauche, oder?

Meint ihr jetzt das so ähnlich? (ok, es geht immer noch nicht aber vom Prinzip her)


#include <stdio.h>
#include <glut.h>
#include <string.h>

void window(void)
{

glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)
{
int len, i;
glRasterPos2f(x,y);
len = (int)strlen(string);
for (i=0; i<len;i++)
{
glutBitmapCharacter(font,string[i]);
}
}

void KeyboardEingabe(char key, int x, int y)
{
char *text;
text=&key;
bitmap_output(0,0,text,GLUT_BITMAP_TIMES_ROMAN_10);
}

int main(int argc, char *argv[])
{
int win;
//char text;

glutInit(&argc, argv);
glutInitWindowSize(640,480);

win=glutCreateWindow("Ein Fenster");

glutKeyboardFunc(KeyboardEingabe);

glutDisplayFunc(window);
glutMainLoop();
return 0;
}

Das wird wieder nicht funktionieren. :)

Du verwechselst nämlich "char text" mit einem nullterminierten String. Ich empfehle dir mal die Doku zum Thema Strings durchzulesen.

Kleiner Tipp, ein String ist ein Char-Array mit einer binären Null hintendran.

[Matrix316]

Ich weiß was ein String ist, aber ich weiß nicht WIE LANGE dieser sein soll, oder kann ich den auch unbestimmt initialisieren? Ich glaub das geht net, oder?

So quasi: char text[];

[zeckensack]

Preisfrage:
void KeyboardEingabe(unsigned char key, int x, int y)
{
char *text;
text=(char *) &key;
bitmap_output(0,0,text,GLUT_BITMAP_TIMES_ROMAN_24);

}
Woher soll diese Funktion wissen, welche Zeichen bereits früher eingegeben wurden?
Sollte man diese nicht irgendwo für später abspeichern? Oder zumindest die Position, an der das nächste Zeichen gerendert werden soll ("Cursor eins nach rechts") ...
:grübel:

Habt ihr C-Grundlagen schon gehabt, oder wird das vorausgesetzt?
Ohne ein paar Grundlagen in Sachen scoping (von Variablen) und Arrays/Zeigern wird das für dich sehr sehr schwierig werden, wenn nicht jetzt, dann bei der nächsten Aufgabe dieser Art.

PS: Ich mein's nur gut. Wenn du die Lösung fertig vorgesetzt bekommst, dann lernst du IMO nichts dabei :)

[Exxtreme]

Original geschrieben von Matrix316
Ich weiß was ein String ist, aber ich weiß nicht WIE LANGE dieser sein soll, oder kann ich den auch unbestimmt initialisieren? Ich glaub das geht net, oder?

So quasi: char text[];
Ein String ist ein nullterminiertes Array. am ende des Strings MUSS immer eine binäre Null sein sprich "\0".

Und da die Funktion einen String will um korrekt zu funktionieren, dann musst du ihr einen String geben.

Ich würde zum testen einen festen String nehmen nach dem Motto "char text[] = "Dies ist ein Test" und erstmal auf Tastatureingaben verzichten.

[Matrix316]

C-Grundlagen hatten wir im 2. Semester, das war vor ca. 2 Jahren. ;D

Arrays sind aber kein Problem, außer man weiß nicht wie lange sie sein sollen...=)

Und in C++ und Java gabs keine Callbacks (ebensowenig in c).

Jedenfalls gehts jetzt, zwar nicht gut, aber so einigermaßen (könnts ja mal ausprobieren):


#include <stdio.h>
#include <glut.h>
#include <string.h>

GLfloat stelle=-0.8, zeile=0.8;

void window(void)
{

glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)
{
int len, i;
glRasterPos2f(x,y);
len = (int)strlen(string);
for (i=0; i<len;i++)
{
glutBitmapCharacter(font,string[i]);
}
}

void KeyboardEingabe(unsigned char key, int x, int y)
{

char *text;
text=(char *) &key;
bitmap_output(stelle,0.4,text,GLUT_BITMAP_TIMES_ROMAN_24);
stelle = stelle + 0.1;
if (stelle > 1)
{
zeile=zeile-0.1;
stelle=-0.8;
}
}

int main(int argc, char *argv[])
{
int win;

glutInit(&argc, argv);
glutInitWindowSize(640,480);

win=glutCreateWindow("Ein Fenster");

glutKeyboardFunc(KeyboardEingabe);

glutDisplayFunc(window);
glutMainLoop();
return 0;
}

[Matrix316]

Original geschrieben von Exxtreme
Ein String ist ein nullterminiertes Array. am ende des Strings MUSS immer eine binäre Null sein sprich "\0".

Und da die Funktion einen String will um korrekt zu funktionieren, dann musst du ihr einen String geben.

Ich würde zum testen einen festen String nehmen nach dem Motto "char text[] = "Dies ist ein Test" und erstmal auf Tastatureingaben verzichten.

Kannst du vielleicht noch erklären wie man es mit array UND Tastatureingabe macht?

Ich meine den array kann ich ja erst ausgeben wenn er ausgefüllt ist, oder? Ich will/soll es aber so haben, dass man jede Taste gleich am Bildschirm sieht. Ginge das überhaupt, weil der String wäre ja garnicht abgeschlossen, wenn ich erst am Anfang des Strings bin, oder?

[Exxtreme]

Original geschrieben von Matrix316
Kannst du vielleicht noch erklären wie man es mit array UND Tastatureingabe macht?

Ich meine den array kann ich ja erst ausgeben wenn er ausgefüllt ist, oder? Ich will/soll es aber so haben, dass man jede Taste gleich am Bildschirm sieht. Ginge das überhaupt, weil der String wäre ja garnicht abgeschlossen, wenn ich erst am Anfang des Strings bin, oder? Es geht schon. :)

Du musst bei einer Neueingabe das Feld dynamisch vergrössern. Wie gesagt, schau dir "malloc" und "memcpy" an.

[Matrix316]

Bringt das eigentlich was im Vergleich zu dem wie es jetzt ist?

Kann man es eigentlich auch so machen, das man den Text löschen bzw. formatieren kann?

[Matrix316]

Ok, wenn das keiner weiß, dann was ganz neues :P

es gibt ja

glutMenuEntry(...)

und

glutAddSubMenu(...)

nur wie bekomme ich jetzt einen "MenuEntry" in das SubMenu?

EDIT: Ok, hat sich erledigt. Man muss nicht wissen wie es geht, man muss nur wissen wo ein gutes Tutorial zu finden ist. :D :bäh:

[Matrix316]

fehlposting

[Matrix316]

Und jetzt die alles entscheidende Preisfrage:

Kann ich bei diesem Programm es so einrichten, dass die Schriftart/Farbe/Größe/Position in jedem Fenster für sich einstellbar ist, OHNE, dass ich jeweils doppelte Variablen und Funktionen benötige? Oder MUSS ich durch den Aufbau des Programmes doppelte Variablen (Funktionen?) benutzen?


#include <stdio.h>
#include <glut.h>
#include <string.h>

#define helvetic 1
#define times 2
#define grose10 3
#define grose18 4
#define grose24 5
#define rot 6
#define blau 7
#define weiss 8
#define close 9



//globale Variablen
GLfloat stelle1=-0.8, zeile1 = 0.8;
float r=1.0,g=1.0,b=1.0;
int artgrose=1018; //Default-Schriftart

void window(void)
{
glClear(GL_COLOR_BUFFER_BIT);

glFlush();
//glutPostRedisplay();
//glutSwapBuffers();
}

void MenueOptions(int number)
{
/*
1011=Helvetica 10
1018=Helvetica 18
1110=TimesRoman 10
1124=TimesRoman 24
*/
switch (number)
{
case helvetic:
if (artgrose==1110)
{
artgrose=1010;
}
if (artgrose==1124)
{
artgrose=1018;
}

break;

case times:
if (artgrose==1010)
{
artgrose=1110;
}
if (artgrose==1018)
{
artgrose=1124;
}

break;

case grose10:
if (artgrose==1018)
{
artgrose=1010;
}
else if (artgrose==1124)
{
artgrose=1110;
}
break;

case grose18:
if (artgrose !=1110 || artgrose !=1124)
{
artgrose=1018;
}
break;

case grose24:
if (artgrose !=1010 || artgrose !=1024)
{
artgrose=1124;
}
break;

case rot:
r=1.0;
g=0.0;
b=0.0;
break;

case blau:
r=0.0;
g=0.0;
b=1.0;
break;

case weiss:
r=1.0;
g=1.0;
b=1.0;
break;

case close:

glutDestroyWindow(glutGetWindow());

}
}

void menue()
{
int imenu,iSubmenuART,iSubmenuGROSE,iSubmenuFARBE;

iSubmenuART=glutCreateMenu(MenueOptions);
glutAddMenuEntry("Helvetica",helvetic);
glutAddMenuEntry("Times Roman",times);

iSubmenuGROSE=glutCreateMenu(MenueOptions);
glutAddMenuEntry("10",grose10);
glutAddMenuEntry("18",grose18);
glutAddMenuEntry("24",grose24);

iSubmenuFARBE=glutCreateMenu(MenueOptions);
glutAddMenuEntry("rot",rot);
glutAddMenuEntry("blau",blau);
glutAddMenuEntry("Weiss",weiss);

imenu=glutCreateMenu(MenueOptions);
glutAddSubMenu("Schriftart",iSubmenuART);
glutAddSubMenu("Schriftfarbe",iSubmenuFARBE);
glutAddSubMenu("Schriftgröße",iSubmenuGROSE);
glutAddMenuEntry("schliessen",close);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}

void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)
{
int len, i;
//GLfloat stelle=-0.8, zeile = 0.8;
glRasterPos2f(x,y);
len = (int)strlen(string);

for (i=0; i<len;i++)
{
glColor3f(r,g,b);
glutBitmapCharacter(font,string[i]);
}
}

void KeyboardEingabe(unsigned char key, int x, int y)
{
char *text;
text=(char *) &key;

if (artgrose==1010)
{
bitmap_output(stelle,zeile,text,GLUT_BITMAP_HELVETICA_10);
}
if (artgrose==1018)
{
bitmap_output(stelle,zeile,text,GLUT_BITMAP_HELVETICA_18);
}
if (artgrose==1110)
{
bitmap_output(stelle,zeile,text,GLUT_BITMAP_TIMES_ROMAN_10);
}
if (artgrose==1124)
{
bitmap_output(stelle,zeile,text,GLUT_BITMAP_TIMES_ROMAN_24);
}

stelle = stelle + 0.1;
if (stelle > 1)
{
zeile=zeile-0.1;
stelle=-0.8;
}

}


int main(int argc, char *argv[])
{
int iwin1,iwin2;

glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);

iwin1=glutCreateWindow("Fenster Nummer 1");
iwin2=glutCreateWindow("Fenster Nummer 2");

glutSetWindow(iwin1);
glutKeyboardFunc(KeyboardEingabe);
glutDisplayFunc(window);
menue();

glutSetWindow(iwin2);
glutKeyboardFunc(KeyboardEingabe);
glutDisplayFunc(window);
menue();

glutMainLoop();
return 0;
}

[Matrix316]

Arbeitet denn hier keiner mit GLUT oder sowas?`

Weiß ZUFÄLLIG jemand, warum das Programm abstürzt, wenn ich den "bitmap_output(...)" in "void window(void)" aufrufe?

Mir wurde gesagt die funktion wird dort aufgerufen, weil man so für jedes Fenster unabhängig die Schriftart ändern kann...


#include <stdio.h>
#include <glut.h>
#include <string.h>

#define helvetic 1
#define times 2
#define grose10 3
#define grose18 4
#define grose24 5
#define rot 6
#define blau 7
#define weiss 8
#define close 9



//globale Variablen
GLfloat stelle1=-0.9, zeile1 = 0.9;
GLfloat stelle2=-0.9, zeile2 = 0.9;
float r=1.0,g=1.0,b=1.0;

int artgrose=1018; //Default-Schriftart

int iwin1,iwin2;
char text1[255]=" ";
char text2[255]=" ";


//Funktionen
void window(void);
void bitmap_output(GLfloat x, GLfloat y, char *string, void *font);
void KeyboardEingabe(unsigned char key, int x, int y);
void MenueOptions(int number);
void menue();


int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);

iwin1=glutCreateWindow("Fenster Nummer 1");
iwin2=glutCreateWindow("Fenster Nummer 2");

glutSetWindow(iwin1);
glutKeyboardFunc(KeyboardEingabe);
glutDisplayFunc(window);
menue();

glutSetWindow(iwin2);
glutKeyboardFunc(KeyboardEingabe);
glutDisplayFunc(window);
menue();

glutMainLoop();
return 0;
}


void window(void)
{
//glClear(GL_COLOR_BUFFER_BIT);
if (artgrose==1010)
{
bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_HELVETICA_10);
}
if (artgrose==1018)
{
bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_HELVETICA_18);
}
if (artgrose==1110)
{
bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_TIMES_ROMAN_10);
}
if (artgrose==1124)
{
bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_TIMES_ROMAN_24);
}
glFlush();

}



void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)
{
int len, i;
glRasterPos2f(x,y);
len = (int)strlen(string);

for (i=0; i<len;i++)
{
glutBitmapCharacter(font,string[i]);
}
}

void KeyboardEingabe(unsigned char key, int x, int y)
{


strcat(text1,(const char *)key);

stelle1 = stelle1 + 0.1;
if (stelle1 > 1)
{
zeile1=zeile1-0.1;
stelle1=-0.9;
}

//char *text1;
//*text1=(char []) &key;
//const char * help = ;

//char text1[]=" ";
//*text1 = key;

// bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_HELVETICA_18);
/*if (artgrose==1010)
{
bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_HELVETICA_10);
}
if (artgrose==1018)
{
bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_HELVETICA_18);
}
if (artgrose==1110)
{
bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_TIMES_ROMAN_10);
}
if (artgrose==1124)
{
bitmap_output(stelle1,zeile1,text1,GLUT_BITMAP_TIMES_ROMAN_24);
}*/

}

void MenueOptions(int number)
{
/*
1011=Helvetica 10
1018=Helvetica 18
1110=TimesRoman 10
1124=TimesRoman 24
*/
switch (number)
{
case helvetic:
if (artgrose==1110)
{
artgrose=1010;

}
if (artgrose==1124)
{
artgrose=1018;

}

break;

case times:
if (artgrose==1010)
{
artgrose=1110;

}
if (artgrose==1018)
{
artgrose=1124;

}

break;

case grose10:
if (artgrose==1018)
{
artgrose=1010;

}
else if (artgrose==1124)
{
artgrose=1110;

}
break;

case grose18:
if (artgrose !=1110 || artgrose !=1124)
{
artgrose=1018;

}
break;

case grose24:
if (artgrose !=1010 || artgrose !=1024)
{
artgrose=1124;

}
break;

case rot:
glColor3f(1.0,0.0,0.0);

break;

case blau:
glColor3f(0.0,0.0,1.0);

break;

case weiss:
glColor3f(1.0,1.0,1.0);

break;

case close:

glutDestroyWindow(glutGetWindow());

}
}

void menue()
{
int imenu,iSubmenuART,iSubmenuGROSE,iSubmenuFARBE;

iSubmenuART=glutCreateMenu(MenueOptions);
glutAddMenuEntry("Helvetica",helvetic);
glutAddMenuEntry("Times Roman",times);

iSubmenuGROSE=glutCreateMenu(MenueOptions);
glutAddMenuEntry("10",grose10);
glutAddMenuEntry("18",grose18);
glutAddMenuEntry("24",grose24);

iSubmenuFARBE=glutCreateMenu(MenueOptions);
glutAddMenuEntry("rot",rot);
glutAddMenuEntry("blau",blau);
glutAddMenuEntry("Weiss",weiss);

imenu=glutCreateMenu(MenueOptions);
glutAddSubMenu("Schriftart",iSubmenuART);
glutAddSubMenu("Schriftfarbe",iSubmenuFARBE);
glutAddSubMenu("Schriftgröße",iSubmenuGROSE);
glutAddMenuEntry("schliessen",close);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}


Helft mir (Obi Wan Kenobi)! Ihr seid meine letzte Hoffnung! :help: :zweifel:

[Matrix316]

Mann mann mann kennt sich denn sonst keiner aus oder WILL keiner antworten??? :motz: :@#$!%: *grrr* ;(

[Crushinator]

Original geschrieben von Matrix316
Mann mann mann kennt sich denn sonst keiner aus oder WILL keiner antworten??? :motz: :@#$!%: *grrr* ;( :tuschel: Ich kann im Momment nicht so richtig, weil ich in den letzten Tagen die Arbeit etwas vernachläßigt habe und dies jetzt erstmal nachholen muß. Wenn sich bis zum WoE kein Anderer Deines Problems angenommen hat, werde ich mich mit Dir ausführlich darüber auseinander setzen, versprochen.

[Matrix316]

Original geschrieben von crushinator
:tuschel: Ich kann im Momment nicht so richtig, weil ich in den letzten Tagen die Arbeit etwas vernachläßigt habe und dies jetzt erstmal nachholen muß. Wenn sich bis zum WoE kein Anderer Deines Problems angenommen hat, werde ich mich mit Dir ausführlich darüber auseinander setzen, versprochen.

Bis zum WE wirds eng weil es am 3.11. fertig sein MUSS.

Allerdings hab ich jetzt ein Beispiel gefunden wo auch Text ausgegeben wird. Jedoch ohne Eingabe. Aber ich probier selbst noch etwas rum.

[Xmas]

Original geschrieben von Matrix316
Bringt das eigentlich was im Vergleich zu dem wie es jetzt ist?

Kann man es eigentlich auch so machen, das man den Text löschen bzw. formatieren kann?
Ob es was bringt, kannst nur du selbst wissen.

Ja, natürlich kann man es so machen dass man den Text löschen und formatieren kann. Stellt sich die Frage, wieviel Aufwand du betreiben willst.


Original geschrieben von Matrix316
Und jetzt die alles entscheidende Preisfrage:

Kann ich bei diesem Programm es so einrichten, dass die Schriftart/Farbe/Größe/Position in jedem Fenster für sich einstellbar ist, OHNE, dass ich jeweils doppelte Variablen und Funktionen benötige? Oder MUSS ich durch den Aufbau des Programmes doppelte Variablen (Funktionen?) benutzen?
Fasse zusammengehörende Variablen (und Funktionen) in Strukturen (bzw. Klassen) zusammen. Globale Variablen sollten auf ein Minimum beschränkt werden.

[Xmas]

Original geschrieben von Matrix316
Weiß ZUFÄLLIG jemand, warum das Programm abstürzt, wenn ich den "bitmap_output(...)" in "void window(void)" aufrufe?


void KeyboardEingabe(unsigned char key, int x, int y)
{
strcat(text1,(const char *)key);

:o
Das Programm stürzt mit Sicherheit schon hier ab.
Ein char ist kein String, und auch ganz bestimmt kein Pointer auf char, da kannst du noch so viel casten. Wenn du ein einzelnes Zeichen an einen String anhängen willst, solltest du das so tun:

int slen = strlen(text1);
if(slen < MAXLEN)
{
text1[slen] = key;
text1[slen+1] = '\0';
}

Wobei MAXLEN die maximal zulässige Länge des Strings darstellt (1 weniger als Bytes reserviert sind).


Ich habe dein Posting mal in der Breite etwas bearbeitet, da war eine ziemlich lange Leerzeile drin.

[Matrix316]

Hm mir wurde gesagt, bei einem "Nullterminated String" (oder ist das: char text1[255]=" "; noch keiner? Muss ich das \0 manuell einfügen?) kann man mit "strcat" einzelne Buchstaben anfügen.

Wie issen das eigentlich, wenn ich jetzt sagen wir mal eine Zeichenkette habe und gebe den Text aus, muss ich dann die Ausgabe bzw. die "Space" Taste, also das Weiterrücken des Textes immer noch Manuell machen (mit Zeile/Spalte) oder geht das dann automatisch? :kratz2:

[Xmas]

Original geschrieben von Matrix316
Hm mir wurde gesagt, bei einem "Nullterminated String" (oder ist das: char text1[255]=" "; noch keiner? Muss ich das \0 manuell einfügen?) kann man mit "strcat" einzelne Buchstaben anfügen.
1) Alles was du in doppelte Anführungszeichen ("") einschließt ist ein nullterminierter String in C/C++. Mit ' ' kannst du nur einzelne char angeben, diese sind nicht terminiert, sondern einfach nur ein einzelner char oder wchar_t im Speicher. Das Prefix L wird für Multibyte Character benutzt (Unicode), also z.B. L"Dies ist ein MBC-String".

Die folgenden Darstellungen sind jeweils identisch:
char a = 'a';
char a = 97;


char str[2] = "b";
char str[2] = { 'b', '\0' };
char str[2] = { 98, 0 };

Ein String ist ein Array von char (Standard) oder wchar_t (Multibyte), das Ende des Strings wird durch eine binäre 0 gekennzeichnet.

2) strcat kann nicht einzelne chars an einen nullterminierten String anfügen, sondern nur zwei nullterminierte Strings zusammenfügen. Wenn du ein einzelnes Zeichen anfügen willst, musst du das Zeichen an die Stelle der terminierenden Null schreiben und diese um eine Stelle weiterschieben, so wie in meinem Beispiel gemacht.

Wie issen das eigentlich, wenn ich jetzt sagen wir mal eine Zeichenkette habe und gebe den Text aus, muss ich dann die Ausgabe bzw. die "Space" Taste, also das Weiterrücken des Textes immer noch Manuell machen (mit Zeile/Spalte) oder geht das dann automatisch? :kratz2:
Ich würde mal davon ausgehen das glutBitmapCharacter die Rasterposition entsprechend nach rechts schiebt. Zeilenumbrüche musst du allerdings selbst machen.

[Matrix316]

Aaaha.

Nur jetzt hab ich ein ganz großes Problem: glut geht nicht mehr...:(

Es kommt die Fehlermeldung:

Fatal Error in:...verzeichnis der exe... failed to create OpenGL rendering context.

Das einzige was ich seit gestern geändert habe ist, dass ich einen anderen Treiber (44.65 anstatt 52.16) installiert habe, jetzt hab ich den 52.16 wieder drauf, aber es geht immer noch nicht...(und zwar nicht nur bei meinem Programm sondern bei einem anderen glut Programm kommt der gleiche Fehler...)

EDIT: Ein Hoch auf die Systemwiederherstellung ;), es geht wieder...

[Matrix316]

Original geschrieben von Xmas


int slen = strlen(text1);
if(slen < MAXLEN)
{
text1[slen] = key;
text1[slen+1] = '\0';
}



Ouhaaaa das geht ja sogar. ;D JUHUUUU...

Er gibt sogar die Werte jetzt nacheinander aus, nur der Zeilenumbruch fehlt noch...

[Matrix316]

Also ich hab jetzt eine relativ lauffähige Version, wo es nur 2 Probleme gibt: Wie mach ich quasi ein "new line" mit einem String und er schreibt den Text gleichzeitig in BEIDE Fenster. Die Farbe kann ich in beiden separat wechseln, die Schriftart ändert er für beide Fenster gleichzeitig...


#include <stdio.h>
#include <glut.h>
#include <string.h>

#define helvetic 1
#define times 2
#define grose10 3
#define grose18 4
#define grose24 5
#define rot 6
#define blau 7
#define weiss 8
#define close 9


//globale Variablen
GLfloat stelle1=-0.9, zeile1 = 0.9;
//GLfloat stelle2=-0.9, zeile2 = 0.9;
float r=1.0,g=1.0,b=1.0;

int artgrose=(int)GLUT_BITMAP_HELVETICA_18; //Default-Schriftart

int iwin1, iwin2;
struct font{char text1[255];char text2[255];}text;

//Funktionen
void window(void);
void bitmap_output(GLfloat x, GLfloat y, char *string, void *font);
void KeyboardEingabe(unsigned char key, int x, int y);
void MenueOptions(int number);
void menue();

int main(int argc, char *argv[])
{
text.text1[255]='\0';
text.text2[255]='\0';
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE);

iwin1=glutCreateWindow("Fenster Nummer 1");
iwin2=glutCreateWindow("Fenster Nummer 2");

glutSetWindow(iwin1);
glutKeyboardFunc(KeyboardEingabe);
glutDisplayFunc(window);
menue();

glutSetWindow(iwin2);
glutKeyboardFunc(KeyboardEingabe);
glutDisplayFunc(window);
menue();

glutMainLoop();
return 0;
}


void window(void)
{

glClear(GL_COLOR_BUFFER_BIT);

glutPostRedisplay();

bitmap_output(-0.9,0,text.text1,(void *)artgrose);

glutSwapBuffers();

}



void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)
{
int len, i;
glRasterPos2f(x,y);
len = (int)strlen(string);

for (i=0; i<len;i++)
{
glutBitmapCharacter(font,string[i]);
}
}

void KeyboardEingabe(unsigned char key, int x, int y)
{
//strcat(text.text1,(const char *)key);

int slen = strlen(text.text1);
int MAXLEN=255;
if(slen < MAXLEN)
{
text.text1[slen] = key;
text.text1[slen+1] = '\0';

// stelle1 = stelle1 + 0.1;

// if (stelle1 > 1)
// {
// zeile1=zeile1-0.1;
// stelle1=-0.9;
// }
}

}

void MenueOptions(int number)
{

switch (number)
{
case helvetic:
if (artgrose==(int)GLUT_BITMAP_TIMES_ROMAN_10)
{
artgrose=(int)GLUT_BITMAP_HELVETICA_10;

}
if (artgrose==(int)GLUT_BITMAP_TIMES_ROMAN_24)
{
artgrose=(int)GLUT_BITMAP_HELVETICA_18;

}

break;

case times:
if (artgrose==(int)GLUT_BITMAP_HELVETICA_10)
{
artgrose=(int)GLUT_BITMAP_TIMES_ROMAN_10;

}
if (artgrose==(int)GLUT_BITMAP_HELVETICA_18)
{
artgrose=(int)GLUT_BITMAP_TIMES_ROMAN_24;

}

break;

case grose10:
if (artgrose==(int)GLUT_BITMAP_HELVETICA_18)
{
artgrose=(int)GLUT_BITMAP_HELVETICA_10;

}
else if (artgrose==(int)GLUT_BITMAP_TIMES_ROMAN_24)
{
artgrose=(int)GLUT_BITMAP_TIMES_ROMAN_10;

}
break;

case grose18:
if (artgrose !=(int)GLUT_BITMAP_TIMES_ROMAN_10 || artgrose !=(int)GLUT_BITMAP_TIMES_ROMAN_24)
{
artgrose=(int)GLUT_BITMAP_HELVETICA_18;

}
break;

case grose24:
if (artgrose !=(int)GLUT_BITMAP_HELVETICA_10 || artgrose !=(int)GLUT_BITMAP_HELVETICA_18)
{
artgrose=(int)GLUT_BITMAP_TIMES_ROMAN_24;

}
break;

case rot:
glColor3f(1.0,0.0,0.0);

break;

case blau:
glColor3f(0.0,0.0,1.0);

break;

case weiss:
glColor3f(1.0,1.0,1.0);

break;

case close:

glutDestroyWindow(glutGetWindow());

}
}

void menue()
{
int imenu,iSubmenuART,iSubmenuGROSE,iSubmenuFARBE;

iSubmenuART=glutCreateMenu(MenueOptions);
glutAddMenuEntry("Helvetica",helvetic);
glutAddMenuEntry("Times Roman",times);

iSubmenuGROSE=glutCreateMenu(MenueOptions);
glutAddMenuEntry("10",grose10);
glutAddMenuEntry("18",grose18);
glutAddMenuEntry("24",grose24);

iSubmenuFARBE=glutCreateMenu(MenueOptions);
glutAddMenuEntry("rot",rot);
glutAddMenuEntry("blau",blau);
glutAddMenuEntry("Weiss",weiss);

imenu=glutCreateMenu(MenueOptions);
glutAddSubMenu("Schriftart",iSubmenuART);
glutAddSubMenu("Schriftfarbe",iSubmenuFARBE);
glutAddSubMenu("Schriftgröße",iSubmenuGROSE);
glutAddMenuEntry("schliessen",close);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}

[Matrix316]

Jetzt geht sogar das mit den unterschiedlichen Schriftarten in unterschiedlichen Fenstern - nun fehlt nur noch der Zeilenumbruch...=)


#include <stdio.h>
#include <glut.h>
#include <string.h>

#define helvetic 1
#define times 2
#define grose10 3
#define grose18 4
#define grose24 5
#define rot 6
#define blau 7
#define weiss 8
#define close 9


//globale Variablen
GLfloat stelle1=-0.9, zeile1 = 0.9;
//GLfloat stelle2=-0.9, zeile2 = 0.9;
float r=1.0,g=1.0,b=1.0;
int artgrose1=(int)GLUT_BITMAP_HELVETICA_18; //Default-Schriftart
int artgrose2=(int)GLUT_BITMAP_HELVETICA_18; //Default-Schriftart

int iwin1, iwin2;
struct font{char text1[255];char text2[255];}text;

//Funktionen
void window(void);
void bitmap_output(GLfloat x, GLfloat y, char *string, void *font);
void KeyboardEingabe(unsigned char key, int x, int y);
void MenueOptions(int number);
void menue();

int main(int argc, char *argv[])
{
text.text1[255]='\0';
text.text2[255]='\0';
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE);

iwin1=glutCreateWindow("Fenster Nummer 1");
iwin2=glutCreateWindow("Fenster Nummer 2");

glutSetWindow(iwin1);
glutKeyboardFunc(KeyboardEingabe);
glutDisplayFunc(window);
menue();

glutSetWindow(iwin2);
glutKeyboardFunc(KeyboardEingabe);
glutDisplayFunc(window);
menue();

glutMainLoop();
return 0;
}

void window(void)
{

glClear(GL_COLOR_BUFFER_BIT);

glutPostRedisplay();

if (glutGetWindow()==iwin1){
bitmap_output(-0.9,0,text.text1,(void *)artgrose1);
}

if (glutGetWindow()==iwin2){
bitmap_output(-0.9,0,text.text2,(void *)artgrose2);
}

glutSwapBuffers();

}


void bitmap_output(GLfloat x, GLfloat y, char *string, void *font)
{
int len, i;
glRasterPos2f(x,y);
len = (int)strlen(string);

for (i=0; i<len;i++)
{
glutBitmapCharacter(font,string[i]);
}
}

void KeyboardEingabe(unsigned char key, int x, int y)
{
//strcat(text.text1,(const char *)key);

if (glutGetWindow()==iwin1){
int slen = strlen(text.text1);
int MAXLEN=255;
if(slen < MAXLEN)
{
text.text1[slen] = key;
text.text1[slen+1] = '\0';

// stelle1 = stelle1 + 0.1;

// if (stelle1 > 1)
// {
// zeile1=zeile1-0.1;
// stelle1=-0.9;
// }
}
}

if (glutGetWindow()==iwin2){
int slen = strlen(text.text2);
int MAXLEN=255;
if(slen < MAXLEN)
{
text.text2[slen] = key;
text.text2[slen+1] = '\0';

// stelle1 = stelle1 + 0.1;

// if (stelle1 > 1)
// {
// zeile1=zeile1-0.1;
// stelle1=-0.9;
// }
}
}
}

void MenueOptions(int number)
{

switch (number)
{
if (glutGetWindow()==iwin1){

case helvetic:

if (glutGetWindow()==iwin1){

if (artgrose1==(int)GLUT_BITMAP_TIMES_ROMAN_10)
{
artgrose1=(int)GLUT_BITMAP_HELVETICA_10;
}
if (artgrose1==(int)GLUT_BITMAP_TIMES_ROMAN_24)
{
artgrose1=(int)GLUT_BITMAP_HELVETICA_18;
}
}

if (glutGetWindow()==iwin2){

if (artgrose2==(int)GLUT_BITMAP_TIMES_ROMAN_10)
{
artgrose2=(int)GLUT_BITMAP_HELVETICA_10;
}
if (artgrose2==(int)GLUT_BITMAP_TIMES_ROMAN_24)
{
artgrose2=(int)GLUT_BITMAP_HELVETICA_18;
}
}

break;

case times:

if (glutGetWindow()==iwin1){

if (artgrose1==(int)GLUT_BITMAP_HELVETICA_10)
{

artgrose1=(int)GLUT_BITMAP_TIMES_ROMAN_10;

}
if (artgrose1==(int)GLUT_BITMAP_HELVETICA_18)
{

artgrose1=(int)GLUT_BITMAP_TIMES_ROMAN_24;

}
}

if (glutGetWindow()==iwin2){

if (artgrose2==(int)GLUT_BITMAP_HELVETICA_10)
{

artgrose2=(int)GLUT_BITMAP_TIMES_ROMAN_10;

}
if (artgrose2==(int)GLUT_BITMAP_HELVETICA_18)
{

artgrose2=(int)GLUT_BITMAP_TIMES_ROMAN_24;

}
}

break;

case grose10:

if (glutGetWindow()==iwin1){

if (artgrose1==(int)GLUT_BITMAP_HELVETICA_18)
{

artgrose1=(int)GLUT_BITMAP_HELVETICA_10;

}
else if (artgrose1==(int)GLUT_BITMAP_TIMES_ROMAN_24)
{

artgrose1=(int)GLUT_BITMAP_TIMES_ROMAN_10;

}
}

if (glutGetWindow()==iwin2){

if (artgrose2==(int)GLUT_BITMAP_HELVETICA_18)
{

artgrose2=(int)GLUT_BITMAP_HELVETICA_10;

}
else if (artgrose2==(int)GLUT_BITMAP_TIMES_ROMAN_24)
{

artgrose2=(int)GLUT_BITMAP_TIMES_ROMAN_10;

}
}

break;

case grose18:

if (glutGetWindow()==iwin1){

if (artgrose1 !=(int)GLUT_BITMAP_TIMES_ROMAN_10 || artgrose1 !=(int)GLUT_BITMAP_TIMES_ROMAN_24)
{

artgrose1=(int)GLUT_BITMAP_HELVETICA_18;

}
}

if (glutGetWindow()==iwin2){

if (artgrose2 !=(int)GLUT_BITMAP_TIMES_ROMAN_10 || artgrose2 !=(int)GLUT_BITMAP_TIMES_ROMAN_24)
{

artgrose2=(int)GLUT_BITMAP_HELVETICA_18;

}
}

break;

case grose24:

if (glutGetWindow()==iwin1){

if (artgrose2 !=(int)GLUT_BITMAP_HELVETICA_10 || artgrose2 !=(int)GLUT_BITMAP_HELVETICA_18)
{

artgrose2=(int)GLUT_BITMAP_TIMES_ROMAN_24;

}
}

if (glutGetWindow()==iwin2){

if (artgrose2 !=(int)GLUT_BITMAP_HELVETICA_10 || artgrose2 !=(int)GLUT_BITMAP_HELVETICA_18)
{

artgrose2=(int)GLUT_BITMAP_TIMES_ROMAN_24;

}
}

break;

}



case rot:
glColor3f(1.0,0.0,0.0);

break;

case blau:
glColor3f(0.0,0.0,1.0);

break;

case weiss:
glColor3f(1.0,1.0,1.0);

break;

case close:

glutDestroyWindow(glutGetWindow());

}
}

void menue()
{
int imenu,iSubmenuART,iSubmenuGROSE,iSubmenuFARBE;

iSubmenuART=glutCreateMenu(MenueOptions);
glutAddMenuEntry("Helvetica",helvetic);
glutAddMenuEntry("Times Roman",times);

iSubmenuGROSE=glutCreateMenu(MenueOptions);
glutAddMenuEntry("10",grose10);
glutAddMenuEntry("18",grose18);
glutAddMenuEntry("24",grose24);

iSubmenuFARBE=glutCreateMenu(MenueOptions);
glutAddMenuEntry("rot",rot);
glutAddMenuEntry("blau",blau);
glutAddMenuEntry("Weiss",weiss);

imenu=glutCreateMenu(MenueOptions);
glutAddSubMenu("Schriftart",iSubmenuART);
glutAddSubMenu("Schriftfarbe",iSubmenuFARBE);
glutAddSubMenu("Schriftgröße",iSubmenuGROSE);
glutAddMenuEntry("schliessen",close);
glutAttachMenu(GLUT_RIGHT_BUTTON);
}