Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Standardtypen vs OpenGL und SDL Typen

  • 1
  • 2

Werbeanzeige

tobb

Treue Seele

  • »tobb« ist der Autor dieses Themas

Beiträge: 126

  • Private Nachricht senden

1

16.08.2007, 22:33

Standardtypen vs OpenGL und SDL Typen

Macht es wirklich Sinn
GLint anstatt int,
GLfloat anstatt float,
GLdouble anstatt double,
Uint32 anstatt unsigned int usw...
zu benutzen


Wenn ja, warum?

Crash

Alter Hase

Beiträge: 502

  • Private Nachricht senden

2

16.08.2007, 23:22

Hat soweit ich weiß was mit Plattformunabhängigkeit zu tun. Die typedefs können von Plattform zu Plattform variieren.
Mein Projekt: Rise of the Sylvan

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

3

17.08.2007, 09:14

Genau! In manchen Spezifikationen wird fest vorgeschrieben das ein int z.B. 32 Bit haben soll oder ein double 64 Bit. Um das zu realisieren werden Typendefinitionen mit unterschiedlichen "Quelltypen" erstellt die von Plattform zu Plattform variieren können. Eben um immer zu gewährleisten das ein Uint32 immer ein 32 Bit breiter unsigned Integraler Typ ist!

Es macht also durchaus Sinn diese Typen zu verwenden und es macht keinen Sinn Typendefinitionen aufzulösen, wie sich das so manche Foren(ex)mitglieder angewöhnt haben...
@D13_Dreinig

tobb

Treue Seele

  • »tobb« ist der Autor dieses Themas

Beiträge: 126

  • Private Nachricht senden

4

17.08.2007, 12:38

Ich weiß schon, dass diese Bibliothekstypen auf jeder Platform gleich sind und deshalb der portabilität dienen...
Aber nennt mir doch mal bitte ein Besipiel in dem es schlecht ist, ein int anstatt GLint oder ein float anstatt ein GLfloat zu verwenden!

Wenn ich die OpenGL-Funktion

Quellcode

 
1

glTexCoord2f(GLfloat s, GLfloat t);

folgendermaßen nutze

Quellcode

 
1

glTexCoord2f(1.0f, 0.5f);

Dann übergebe ich Werte vom Typ float und nicht GLfloat.
Dieser Code ist also nicht portabel?

Außerdem sieht float einfach hübscher aus als GLfloat und es ist dazu in den meisnten IDEs auchnoch blau :-)

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

5

17.08.2007, 12:44

Der Datentyp int ist nicht zwangsläufig mit 32 Bit definiert, genauso können andere Datentypen variieren. OpenGL legt aber für GLint evtl genau 32 Bit fest, wenn eine Routine jetzt genau von 32 Bit ausgeht und sie bekommt einen 16 Bit Wert hingebrezelt dann führt das ggf zu Laufzeitfehlern die arg schwer zu finden sind.
@D13_Dreinig

tobb

Treue Seele

  • »tobb« ist der Autor dieses Themas

Beiträge: 126

  • Private Nachricht senden

6

17.08.2007, 14:12

Das weiß ich.

Dennoch bleiben die konstaten Ausdrücke immer die Standardtypen:
3 => int
77 => int
1.0f => float
657ul => unsingned long

Daher macht das

Quellcode

 
1
2
3

float s = 1.0f;
float t = 0.6f;
glTexCoord2f(s, t);

keinen Unterschied zu

Quellcode

 
1
2
3

GLfloat s = 1.0f;
GLfloat t = 0.6f;
glTexCoord2f(s, t);

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

7

17.08.2007, 14:19

Es macht aber sehr wohl einen unterschied wenn du folgendes hast:

int = 32 Bit

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9

typedef unsigned int uint32;

void foo( unsigned int x )
{
    // x ist im wertbereich von 0-2^32-1

    // irgendwelche seltsamen berechnungen...  

}

foo( 0xffffffff ); // yo, passt!


Aber jetzt sind alle int Variablen auf einmal nurnoch 16 Bit breit:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9

typedef unsigned long uint32;

void foo( unsigned int x )
{
    // x ist im wertbereich von 0-2^32-1

    // irgendwelche seltsamen berechnungen...  

}

foo( 0xffffffff ); // ups...


Problemlos wäre:

C-/C++-Quelltext

 
1
2
3
4
5
6
7

void foo( uint32 x )
{
    // x ist im wertbereich von 0-2^32-1

    // irgendwelche seltsamen berechnungen...  

}

foo( 0xffffffff ); // yo, passt! uint32 ist garantiert 32 Bit breit!
@D13_Dreinig

tobb

Treue Seele

  • »tobb« ist der Autor dieses Themas

Beiträge: 126

  • Private Nachricht senden

8

17.08.2007, 14:34

ja natürlich! Das letzte foo ist gut, weil es uint32 als Parameter hat. So soll das ja auch sein, damit es portabel ist.
Das änder aber nichts daran, dass

Quellcode

 
1

foo(99999);

auf einem Rechner mit int = 16 bit schiefgeht.
Selbst mit

Quellcode

 
1
2
3
4
5

void foo(uint32 x)
{
    // x ist im wertbereich von 0-2^32-1
    // irgendwelche seltsamen berechnungen... 
}

Weil 99999 ein konstanter Ausdruck ist vom Typ int. Und wenn int 99999 nicht fassen kann, dann wird es eben abgeschnitten....

Intern müssen die OpenGL Funktionen ihre portablen Typen (GLint, GLfloat usw...) benutzen, das ist klar.
Ich selbst, als OpenGL nutzer, muss es aber nicht nutzen, weil es mir keinen Vorteil bringt. Egal wo ich eine Zahl im Quellcode hinschreibe, sie wird immer der plaformabhängige Typ sein und nicht der portable.
Ist doch so, oder?

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

9

17.08.2007, 14:41

Sagmal, was willst du überhaupt? Sobald du an OpenGL einen Wert weitergibst hast du darauf zu achten das dieser Wert den entsprechenden Wertbereich zur verfügung stellt, sonst kann es Fehler geben. Ob du jetzt für dich andere Typen verwendest ist vollkommen egal:

C-/C++-Quelltext

 
1
2
3
4

void foo( int c )
{
  glVertex3i( c, c, c ); 
}


Hier hast du dann je nach Plattform unterschiedliche Wertspannen. Mal 16 Bit, mal 32 Bit, ... Es kann also sein die Funktionalität von glVertex3i nicht ausgeschöpft werden kann. Das ist nicht besonders schlimm, schlimm wird es wenn eine Funktion davon ausgeht das ein Typ eine bestimmte größe hat. Dann kannst du Probleme bekommen, deshalb solltest du in dem Fall auch die entsprechenden Typendefinitonen verwenden.
@D13_Dreinig

tobb

Treue Seele

  • »tobb« ist der Autor dieses Themas

Beiträge: 126

  • Private Nachricht senden

10

17.08.2007, 16:11

OK, ganz kurz, was ich will:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9

void foo1(float f)
{
    glVertex3f(f, f, f);
}

void foo2(GLfloat f)
{
    glVertex3f(f, f, f);
}


Wir befinden uns nun auf einem System, auf dem float den Wert 99999.9f nicht speicher kann, GLfloat aber schon.

C-/C++-Quelltext

 
1
2
3
4
5

foo1(99999.9f); 
//geht schief, da 99999.9f nicht in float dargestellt werden kann


foo2(99999.9f);
//tja 99999.9f ist und bleibt nun mal ein float, egal ob der Parameter nun GLfloat ist oder nicht. Daher wird der Wert ebenfalls nichtin der Funktion ankommen... wozu also GLflaot benutzen?

Liege ich falsch?

PS: Und noch was. Manche Variablen verwende ich ind SDl und in OpenGL und ind Standard C++ Funktionen... alle verlangen unterschiedliche eigens definierte Typen... ist man nicht besser beraten, dann einfach die Standardtypen zu verwenden?

Werbeanzeige

  • 1
  • 2