Je m'amuse depuis quelques temps avec OpenGL en Carbon sur mon viel iMac
et ça se passe plutot bien.
Mais je rencontre un soucis de précision avec le Z-Buffer. Comme
j'essaye de représenter une simulation du système solaire j'ai affaire
de de grandes echelles, d'autant plus que j'ai ajouté un fond étoilé
très éloigné et qu'en même temps je désire afficher les objets très
proche.
Ce genre de situation abouti est des abbérations pour les objets
éloignés.
J'ai beau essayé différentes combinaison de zNear et zFar je m'en sort
que moyennement.
J'ai bien étudié la question de bien compris le fonctionnement
logarithmique du Z-Buffer.
J'ai aussi regardé de plus près et je me suis aperçut que le Z-Buffer
utilisé par défaut est de 16 bits. Alors que ma carte (pourtant vieille)
supporte le 24 ou 32 bits : mais je ne trouve aucune informations sur
les moyens d'accéder a des Z-Buffer 24 ou 32 bits.
Des pistes ?
--
Pierre-Alain Dorange
Vidéo, DV et QuickTime <http://alcazar.xbecom.com/videogarage/>
Clarus, the DogCow <http://clarus.chez.tiscali.fr/>
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
lucsky
Pierre-Alain Dorange wrote:
J'ai aussi regardé de plus près et je me suis aperçut que le Z-Buffer utilisé par défaut est de 16 bits. Alors que ma carte (pourtant vieille) supporte le 24 ou 32 bits : mais je ne trouve aucune informations sur les moyens d'accéder a des Z-Buffer 24 ou 32 bits.
Des pistes ?
La précision du Depth Buffer peut être choisie à la creation du contexte OpenGL, qui varient selon l'API utilisée.
Il suffit en général de spécifier l'attribut kivabien dans les spécifications du pixel format: - NSOpenGLPFADepthSize pour le NSOpenGLPixelFormat de Cocoa. - kCGLPFADepthSize pour le CGLChoosePixelFormat de CoreGraphics. - AGL_DEPTH_SIZE pour le aglChoosePixelFormat d'AGL. - etc...
Et si 32 bits ne suffisent toujours pas, la FAQ OpenGL indique qu'un rendu multipass est une solution "courante":
"There is no way that a standard-sized depth buffer will have enough precision for my astronomically large scene. What are my options?
The typical approach is to use a multipass technique. The application might divide the geometry database into regions that don't interfere with each other in Z. The geometry in each region is then rendered, starting at the furthest region, with a clear of the depth buffer before each region is rendered. This way the precision of the entire depth buffer is made available to each region."
J'ai aussi regardé de plus près et je me suis aperçut que le Z-Buffer
utilisé par défaut est de 16 bits. Alors que ma carte (pourtant vieille)
supporte le 24 ou 32 bits : mais je ne trouve aucune informations sur
les moyens d'accéder a des Z-Buffer 24 ou 32 bits.
Des pistes ?
La précision du Depth Buffer peut être choisie à la creation du contexte
OpenGL, qui varient selon l'API utilisée.
Il suffit en général de spécifier l'attribut kivabien dans les
spécifications du pixel format:
- NSOpenGLPFADepthSize pour le NSOpenGLPixelFormat de Cocoa.
- kCGLPFADepthSize pour le CGLChoosePixelFormat de CoreGraphics.
- AGL_DEPTH_SIZE pour le aglChoosePixelFormat d'AGL.
- etc...
Et si 32 bits ne suffisent toujours pas, la FAQ OpenGL indique qu'un
rendu multipass est une solution "courante":
"There is no way that a standard-sized depth buffer will have enough
precision for my astronomically large scene. What are my options?
The typical approach is to use a multipass technique. The application
might divide the geometry database into regions that don't interfere
with each other in Z. The geometry in each region is then rendered,
starting at the furthest region, with a clear of the depth buffer before
each region is rendered. This way the precision of the entire depth
buffer is made available to each region."
J'ai aussi regardé de plus près et je me suis aperçut que le Z-Buffer utilisé par défaut est de 16 bits. Alors que ma carte (pourtant vieille) supporte le 24 ou 32 bits : mais je ne trouve aucune informations sur les moyens d'accéder a des Z-Buffer 24 ou 32 bits.
Des pistes ?
La précision du Depth Buffer peut être choisie à la creation du contexte OpenGL, qui varient selon l'API utilisée.
Il suffit en général de spécifier l'attribut kivabien dans les spécifications du pixel format: - NSOpenGLPFADepthSize pour le NSOpenGLPixelFormat de Cocoa. - kCGLPFADepthSize pour le CGLChoosePixelFormat de CoreGraphics. - AGL_DEPTH_SIZE pour le aglChoosePixelFormat d'AGL. - etc...
Et si 32 bits ne suffisent toujours pas, la FAQ OpenGL indique qu'un rendu multipass est une solution "courante":
"There is no way that a standard-sized depth buffer will have enough precision for my astronomically large scene. What are my options?
The typical approach is to use a multipass technique. The application might divide the geometry database into regions that don't interfere with each other in Z. The geometry in each region is then rendered, starting at the furthest region, with a clear of the depth buffer before each region is rendered. This way the precision of the entire depth buffer is made available to each region."
J'ai aussi regardé de plus près et je me suis aperçut que le Z-Buffer utilisé par défaut est de 16 bits. Alors que ma carte (pourtant vieille) supporte le 24 ou 32 bits : mais je ne trouve aucune informations sur les moyens d'accéder a des Z-Buffer 24 ou 32 bits.
Des pistes ?
La précision du Depth Buffer peut être choisie à la creation du contexte OpenGL, qui varient selon l'API utilisée.
Il suffit en général de spécifier l'attribut kivabien dans les spécifications du pixel format: - NSOpenGLPFADepthSize pour le NSOpenGLPixelFormat de Cocoa. - kCGLPFADepthSize pour le CGLChoosePixelFormat de CoreGraphics. - AGL_DEPTH_SIZE pour le aglChoosePixelFormat d'AGL. - etc...
OK, pour le moment je me sers juste de base d'un exemple GLU basique fournit avec XCode, je vais étudier ça car va falloir de toute façon que j'intégre tout ça proprement dans une interface.
[...] Et si 32 bits ne suffisent toujours pas, la FAQ OpenGL indique qu'un rendu multipass est une solution "courante":
"There is no way that a standard-sized depth buffer will have enough precision for my astronomically large scene. What are my options?
Voilà qui m'intéresses fortement. J'ai fait quelques essais moi même ce week end dans ce sens mais ça mettais simplement la panique dans mes matrices caméras sans résultats probants. Je vais étudier ça avec grande attention, merci beaucoup.
Marrant que j'ai pas trouvé ça, j'ai pourtant pas mal cherché un peu partout y compris sur ce site.
-- Pierre-Alain Dorange
Vidéo, DV et QuickTime <http://alcazar.xbecom.com/videogarage/> Clarus, the DogCow <http://clarus.chez.tiscali.fr/>
Luc Heinrich <lucsky@mac.com> wrote:
J'ai aussi regardé de plus près et je me suis aperçut que le Z-Buffer
utilisé par défaut est de 16 bits. Alors que ma carte (pourtant vieille)
supporte le 24 ou 32 bits : mais je ne trouve aucune informations sur
les moyens d'accéder a des Z-Buffer 24 ou 32 bits.
Des pistes ?
La précision du Depth Buffer peut être choisie à la creation du contexte
OpenGL, qui varient selon l'API utilisée.
Il suffit en général de spécifier l'attribut kivabien dans les
spécifications du pixel format:
- NSOpenGLPFADepthSize pour le NSOpenGLPixelFormat de Cocoa.
- kCGLPFADepthSize pour le CGLChoosePixelFormat de CoreGraphics.
- AGL_DEPTH_SIZE pour le aglChoosePixelFormat d'AGL.
- etc...
OK, pour le moment je me sers juste de base d'un exemple GLU basique
fournit avec XCode, je vais étudier ça car va falloir de toute façon que
j'intégre tout ça proprement dans une interface.
[...]
Et si 32 bits ne suffisent toujours pas, la FAQ OpenGL indique qu'un
rendu multipass est une solution "courante":
"There is no way that a standard-sized depth buffer will have enough
precision for my astronomically large scene. What are my options?
Voilà qui m'intéresses fortement. J'ai fait quelques essais moi même ce
week end dans ce sens mais ça mettais simplement la panique dans mes
matrices caméras sans résultats probants.
Je vais étudier ça avec grande attention, merci beaucoup.
Marrant que j'ai pas trouvé ça, j'ai pourtant pas mal cherché un peu
partout y compris sur ce site.
--
Pierre-Alain Dorange
Vidéo, DV et QuickTime <http://alcazar.xbecom.com/videogarage/>
Clarus, the DogCow <http://clarus.chez.tiscali.fr/>
J'ai aussi regardé de plus près et je me suis aperçut que le Z-Buffer utilisé par défaut est de 16 bits. Alors que ma carte (pourtant vieille) supporte le 24 ou 32 bits : mais je ne trouve aucune informations sur les moyens d'accéder a des Z-Buffer 24 ou 32 bits.
Des pistes ?
La précision du Depth Buffer peut être choisie à la creation du contexte OpenGL, qui varient selon l'API utilisée.
Il suffit en général de spécifier l'attribut kivabien dans les spécifications du pixel format: - NSOpenGLPFADepthSize pour le NSOpenGLPixelFormat de Cocoa. - kCGLPFADepthSize pour le CGLChoosePixelFormat de CoreGraphics. - AGL_DEPTH_SIZE pour le aglChoosePixelFormat d'AGL. - etc...
OK, pour le moment je me sers juste de base d'un exemple GLU basique fournit avec XCode, je vais étudier ça car va falloir de toute façon que j'intégre tout ça proprement dans une interface.
[...] Et si 32 bits ne suffisent toujours pas, la FAQ OpenGL indique qu'un rendu multipass est une solution "courante":
"There is no way that a standard-sized depth buffer will have enough precision for my astronomically large scene. What are my options?
Voilà qui m'intéresses fortement. J'ai fait quelques essais moi même ce week end dans ce sens mais ça mettais simplement la panique dans mes matrices caméras sans résultats probants. Je vais étudier ça avec grande attention, merci beaucoup.
Marrant que j'ai pas trouvé ça, j'ai pourtant pas mal cherché un peu partout y compris sur ce site.
-- Pierre-Alain Dorange
Vidéo, DV et QuickTime <http://alcazar.xbecom.com/videogarage/> Clarus, the DogCow <http://clarus.chez.tiscali.fr/>
pdorange
Pierre-Alain Dorange wrote:
Je vais étudier ça avec grande attention, merci beaucoup.
OK j'ai consulté la FAQ et particulièrement cet article; mais il me reste une interrogation.
Pour régler le problème de valeur très différente en Z, il conseill e de travailler par région, ce qui dans mon cas ne posera pas de problème puisque j'ai 3 régions distinctes : le fond étoilé à "l'infini", le système solaire (planête, satellites, soleil...) et éventuellement des objets volants très proche. Pour cela la FAQ précise qu'il faut dessiner région par région en commençant par le plus éloigné et en faisant un Clear Depth Buffer entre chacune d'elle. OK mais je vois pas bien en quoi cela va suffir pour améliorer la précision si zNear et zFar en change pas. Or d'après mes essais on ne peut pas les changer.
Bon plus d'infos quand j'aurai fait des essais.
-- Pierre-Alain Dorange
Vidéo, DV et QuickTime <http://alcazar.xbecom.com/videogarage/> Clarus, the DogCow <http://clarus.chez.tiscali.fr/>
Je vais étudier ça avec grande attention, merci beaucoup.
OK j'ai consulté la FAQ et particulièrement cet article; mais il me
reste une interrogation.
Pour régler le problème de valeur très différente en Z, il conseill e de
travailler par région, ce qui dans mon cas ne posera pas de problème
puisque j'ai 3 régions distinctes : le fond étoilé à "l'infini", le
système solaire (planête, satellites, soleil...) et éventuellement des
objets volants très proche.
Pour cela la FAQ précise qu'il faut dessiner région par région en
commençant par le plus éloigné et en faisant un Clear Depth Buffer entre
chacune d'elle. OK mais je vois pas bien en quoi cela va suffir pour
améliorer la précision si zNear et zFar en change pas.
Or d'après mes essais on ne peut pas les changer.
Bon plus d'infos quand j'aurai fait des essais.
--
Pierre-Alain Dorange
Vidéo, DV et QuickTime <http://alcazar.xbecom.com/videogarage/>
Clarus, the DogCow <http://clarus.chez.tiscali.fr/>
Je vais étudier ça avec grande attention, merci beaucoup.
OK j'ai consulté la FAQ et particulièrement cet article; mais il me reste une interrogation.
Pour régler le problème de valeur très différente en Z, il conseill e de travailler par région, ce qui dans mon cas ne posera pas de problème puisque j'ai 3 régions distinctes : le fond étoilé à "l'infini", le système solaire (planête, satellites, soleil...) et éventuellement des objets volants très proche. Pour cela la FAQ précise qu'il faut dessiner région par région en commençant par le plus éloigné et en faisant un Clear Depth Buffer entre chacune d'elle. OK mais je vois pas bien en quoi cela va suffir pour améliorer la précision si zNear et zFar en change pas. Or d'après mes essais on ne peut pas les changer.
Bon plus d'infos quand j'aurai fait des essais.
-- Pierre-Alain Dorange
Vidéo, DV et QuickTime <http://alcazar.xbecom.com/videogarage/> Clarus, the DogCow <http://clarus.chez.tiscali.fr/>
