Utilité des types OpenGL GLint, GLfloat, GLvoid, etc.

Bonjour,

quelqu'un pourrait-il m'expliquer l'utilité d'utiliser les types OpenGL plutôt que les types de base : int, float, void, etc. ?

Merci d'avance et a+ :D

Bonjour
Il me semble qu'à l'origine, c'est pour être compatible sur tout les compilateurs / architecture : les types de bases sont parfois différents. (little / big endian; 32 / 64 bits ....)
Avec GLInt, GLFloat par de soucis de ce côté là -> la portabilité du code est facilitée.

c'est effectivement en partie la reponse...
cela permet d'etre compatible entre les langages (tout les langages n'ont pas le même type int...) mais surtout car dans la norme c/c++, la taille du type int n'est pas fixée mais est definit par la taille d'un entier processeur (32 bits sur un proc 32 bits, 64 sur un 64...) bien que cette specification ne soit pas suivie par la plus part des compilo, pour eviter les problemes de compatibilitée, les type GL* ont été introduits

conclusion : si tu fait un prog en utilisant des float, int et autre, ca marche sur ta machine (en fait plutot sur ton architecture materielle) mais pas forcement sur celle du voisin (qui a un MAC le lourd :lol: )

Ah ok, merci à vous pour ces infos ^^
Donc idem pour les autre lib j'imagine, par exemple DevIL, etc ?

Citation:

---

Envoyé par bafman

mais surtout car dans la norme c/c++, la taille du type int n'est pas fixée mais est definit par la taille d'un entier processeur (32 bits sur un proc 32 bits, 64 sur un 64...)

---

Permet moi de te corriger sur ce point :) Le standard ne dit pas que int doit etre de 32 bit si tu as un cpu 32 bit, ou 64 si tu as un 64 bit. C'est long qui a cette propriete. De plus, la relation suivante existe pour la longueur des types en bit:

Code:

---

char <= short <= int <= long

---

Donc tu peux tres bien avoir un cpu 32 bit qui possede un int de 16 bit. Ou n'importe quelle combinaison qui respecte la relation ecrite ci-haut.

Pour la petite histoire, sous DOS, un int était sur 16 bits et un long sur 32 bits. Lorsque l'on est passé sous Windows 95 (système dits "32 bits"). La taille d'un int est passé sur 32 bits est un long est resté sur 32 bits. L'implémentation des type GL* est extrèmement important sur des architectures qui ne sont pas compatible x86 (station Alpha par exemple). La type donnée peux varier énormement en nombre de bits sur la taille d'un pointeur. Sur station Alpha ils sont peut-être sur 64 bits et sur une console portable (une PSP), ils sont peut-être que sur 8 bits.

en fait on peut penser tt plein de trucs, mais ça sert à rien lol :)

gl.h :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

typedef unsigned int GLenum; typedef unsigned char GLboolean; typedef unsigned int GLbitfield; typedef signed char GLbyte; typedef short GLshort; typedef int GLint; typedef int GLsizei; typedef unsigned char GLubyte; typedef unsigned short GLushort; typedef unsigned int GLuint; typedef float GLfloat; typedef float GLclampf; typedef double GLdouble; typedef double GLclampd; typedef void GLvoid;

---

voilà comment ils sont défini... juste des typedef en gros c pareil d'utiliser int que GLint ;)

Là tu as l'entête C/Win32 mais j'aimerai bien voir l'entête pour du delphi par exemple

si les types de base sont pas les mêmes, ils créent des GLfloat comme en C pour justement avoir quelque chose de standard, le standard opengl avec ses types ect

Citation:

---

Envoyé par Bob.Killer

voilà comment ils sont défini... juste des typedef en gros c pareil d'utiliser int que GLint ;)

---

Bravo :lol: t'a tout compris... de travers...

si jamais tu utilise des int et que tu est obligé de changer de plateforme et que celle la fait 64 bits au lieu de 32 ca ne passera pas...

que fait un typedef ?

Un typedef crée un synonyme pour le type donné en paramètre :

Code:

---

typedef type_de_base synonyme;

---

Les intérêts sont multiples, par exemple simplifier l'écriture ou encore pouvoir modifier facilement un programme, par exemple au lieu d'utiliser :

Code:

---

std::vector<float> v1,v2;

---

on utilisera

Code:

---

1 2	typedef float my_real; std::vector<my_real> v1,v2;

---

quel intérêt ?
vous voulez changer la précision dans votre programme, si vous avez collé des float partout vous devez tout changer et attention à ne pas en oublier, alors qu'avec le typedef, une seule ligne à modifier

dans le cas d'opengl, cela permet d'adapter les types à une machine
c'est l'un des aspects d'un code souple et portable

:) donc voilà lol si on utilise gl.h et qu il défini les GL* à partir des int, double, float, ... de la machine on peut dire que int est équivalent à GLint et ainsi de suite non ?

On peut dire que GLint est synonyme de int mais pas l'inverse

C'est une question de logique et si cela est vrai pour le gl.h Win32 ça ne l'est pas forcément pour les autres gl.h

PS: J'aime pas le terme équivalence en programmation, c'est plus un terme destiné à l'alchimie (Joke Inside, ceux qui connaissent comprendront)

moi je connais juste le gl.h de win32 :) cela va poser pb qd on compilera avec un compilo 64bits qui va mettre le int sur 64bits car le typedef va mettre 64bits pour le GLint si je ne me trompe pas ...

Concernant le 64 bits, je t'invite à aller voir le topic quivant :
http://www.developpez.net/forums/viewtopic.php?t=333731
notemment le post de Voider (le 3ème)

tu y verra entre autre cette regle sur la longueur des types:
char <= short <= int <= long

Je remonte un peu ce topic des abysses, désolés :oops:
Je comprends absolument la redefinition des types de base par OpenGL, par contre je n'arrive pas à saisir l'utilité du type GLvoid ? Quand l'utiliser et quand ne pas l'utiliser ?
Merci à tous :)

personnelement je ne l'utilise jamais, mais tant qu'a redefinir les type, autant tous les faires :wink:

Ok merci ;)