texteingaben in OGL, die auch angezeigt werden

SirNoname

morgen!

brauch für mein aktuelles projekt ne möglichkeit, n string einzugeben. is ja nich weiter schwer, nur will ich, dass das bereits geschriebene auf dem bildschirm erscheint. also im prinzip ne normale konsolen-mäßige eingabe ...
hab folgende möglichkeit genutzt:

glPrint("Text: ");

if ((keys['A']) && (keys[VK_SHIFT]))
    {  
    keys['A']=FALSE;
    strcat(pfad, "A");
    }   
if (keys['A']) 
    {
    keys['A']=FALSE;
    strcat(pfad, "a");
    }
if ((keys['B']) && (keys[VK_SHIFT]))
    {  
    keys['B']=FALSE;
    strcat(pfad, "B");
    }   
if (keys['B']) 
    {
    keys['B']=FALSE;
    strcat(pfad, "b");
    }

// das mit allen buchstaben und zahlen

glPrint(pfad);

wie man schon sieht wird das echt extremst lang wenn ich alle buchstaben, zahlen und sonderzeichen mit reinnehme. kennt ihr ne andere möglichkeit?

Timm

du machst eine schleife in der du dann alle buchstaben abtestest a-z(a=65 glaube ich) und wenn die gedrückte taste dabei ist(if(keys[i]==true)...) überprüfst du ob shift oder nicht setzt die taste wieder auf false und machst ein strcat sonderzeichen musst du dann halt wieder von Hand abfragen. :p

Aber ist auch noch ein bischen umständlich

Trienco

rechnen statt wolf tippen. wenn du tatsächlich key-codes und keine ascii zeichen benutzt wärs natürlich sinnvoll, sich die tabelle der codes anzusehen. mit extremer sicherheit sind die buchstaben aber in einer reihe und man kann bequem mit einer schleife drüber, mit simplem +-irgendwas den ascii code draus machen, bei shift nochmal offset für großbuchstaben druff und fertig.

bei meiner "konsole" gibts einige einschränkungen und der code ist nicht grade schön, weil zuviel auf einmal abgeht, aber prinzipiell läufts genauso. normalerweise sollte auch irgendeine funktion vorhanden sein, um keycodes in ascii umzuwandeln.

bemerkung am rand, für die konsole fand ich ein:
string buffer[MAX_LINES]
am bequemsten. und wenn man am ende ankommt einfach wieder bei 0 anfangen und überschreiben.

http://festini.device-zero.de/Programming/Downloads/jstart.zip
braucht allerdings ne dicke karte mit support für fragment programs. konsole sollte ^ sein, oder ~, je nach layout (zur not einfach umkonfigurieren)

TGGC

Also 'B' in "B" umzuwandeln kann echt nicht sooo schwer sein.

Bye, TGGC \-/

interpreter

Timm schrieb:

if(keys[i]==true)

Tipp:
if(keys[i])

spl*t

@Trienco:
wow, das macht ja schon fast Far Cry Konkurenz, respekt!
Aber wie meinst du das:

bemerkung am rand, für die konsole fand ich ein:
string buffer[MAX_LINES]
am bequemsten. und wenn man am ende ankommt einfach wieder bei 0 anfangen und überschreiben.

Ist buffer[0] die oberste Zeile, und buffer[MAX_LINES-1] die unterste? Wird dann, wenn du am ende angekommen bist, sowas gemacht:

for (int i=0; i<MAX_LINES -1; ++i) 
{
  buffer[i] = buffer[i+1];
}
buffer[MAX_LINES] = neue_zeile;

?

Trienco

spl@t schrieb:

@Trienco:
wow, das macht ja schon fast Far Cry Konkurenz, respekt!

naja, es hilft die heightmap und texturen aus der fc demo zu benutzen (macht den vergleich einfacher). aber ohne das ganze grünzeug fehlt einfach was. stolz bin ich da eigentlich nur auf den minimierten speicherverbrauch (der ab 4kx4k maps immer noch heftig ist.. außer auf nvidia, da gehts locker bis 8kx8k).

Ist buffer[0] die oberste Zeile, und buffer[MAX_LINES-1] die unterste? Wird dann, wenn du am ende angekommen bist, sowas gemacht:
for (int i=0; i<MAX_LINES -1; ++i) 
{
  buffer[i] = buffer[i+1];
}
buffer[MAX_LINES] = neue_zeile;
?

bloß nicht, alle strings zu versetzen wäre tödlich (auch wenn die string container an sich hoffentlich nicht groß sind).

stell dir das ganze einfach als ring vor. du startest bei der aktuellen position +1. von da läufst du bis MAX_LINES-1 und dann von 0 bis zur aktuellen position. allerdings braucht man das fast nie komplett.

neuer eintrag:
buffer[pos++]=irgendein string;
if (pos>=MAX_LINES) pos=0;

für die darstellung einfach von der aktuellen position x zeilen nach oben wandern (wobei x die sichtbare anzahl zeilen für die konsolenhöhe ist) und gegebenfalls (falls position<x) bei MAX_LINES-(x-position) anfangen (keine garantie auf berühmt "off by one" fehler).

die profiler graphen funktionieren übrigens genauso.

anmerkung, wenn es (wie bei einer konsole) nicht auf performance ankommt (spontan aus den fingern gesogen, also nicht blind übernehmen).

template<class T> class RingArray {
  int size;
  T* data;
public:
  RingArray(int s) : size(s) {data=new T[size];}
  ~RingArray() {delete[] data;}
  int FixIndex(int i) {
    i%=size;
    return (i>=0) ? i : size+i;
  }
  T& operator()(int i) {return data[FixIndex(i)];}
  T& operator[](int i) {return data[i];}
};

will mir jetzt spontan angenehmer als eine ringliste vorkommen und kapselt letztlich nur das obige, indem es "falsche" indices anpaßt. das modulo ist allerdings keine gute idee, wenn es extrem auf performance ankommt.

edit: ok, davon ausgehend, daß man extern seinen eigenen index mitschlept und potentiell nach längerem betrieb den integer sprengt ein wenig umgestellt. mit FixIndex läßt sich ein index wieder hinbiegen (also einfach hin und wieder mal aufrufen, damit der externe index nicht zu absurd ausufert). außerdem jetzt zwei zugriffsoperatoren, damit sorgt RArr(index) dafür, daß der index vorher angepaßt wird und RArr[index] nimmt stur den angegebenen (ohne überprüfung, falls performance wichtig ist).

und ja, für den mißbrauch des ()-operators gibts bestimmt wieder schelte *fg*.. wer stl-analog bleiben will macht daraus halt ne funktion T& At(int).

spl*t

Danke für die ausführliche Erklärung, wieder das dazu gelernt