Extension importance?

Hello,

i learned opengl 1.2 from the old official programming guide, 3rd edition.

now i know that i’m not that up-to date and i want to get to a state-of-the-art level.

I already learnd GLSL and am willing to go from 1.2 to 2.0 by reading the changelog for 1.3 and learning to use everything that changed, then 1.4 and so on until 2.0. afterwards i’ll take on the extensions.

But i don’t know which of the over 300 extensions i should learn and in which order?

Could someone a bit more experienced recommend me a list of ordered steps of what i should learn?

(B.t.w.: I’m doing it in OCaml, Haskell and Java. So i could get problems when someone will come up with hardcore c+±stuff.

When you have learned OpenGL 2.0, you’ll implicitly have learned many extensions that were promoted to core and just remained for backwards compatibility. Other extensions will no longer be useful because their behaviour can be done much easier with newer, more general extensions.

Have a look at the Appendix J of the OpenGL 2.0 specification. There is a list of ARB extensions. You can forget everything that was promoted to core in some version. If you’re later confronted with a lower OpenGL version, you can still quickly look up the differences between extension and core and then use the extension, there’s not much to learn there.

A few comments on the remaining extensions (perhaps a bit subjective, and I propably forgot something):
ARB_vertex_program
ARB_fragment_program
ARB_fragment_program_shadow
Assembly level shaders. That’s perhaps not that important, as this functionality is already covered by GLSL (core since 2.0). But as the GLSL compilers are not so good yet, they are still useful.

ARB/EXT_texture_rectangle
These two are somewhat legacy, but still important because there’s not much hardware that supports NPOT-textures (a more general extension, is included in core 2.0), so they’ll still be around for a while.

EXT_framebuffer_object
Definitely useful. That’s one of the latest extensions, basically it allows to render to textures.

I’d treat the rest of the extensions on an as-needed basis, that is, don’t learn them just because they are there, learn them only when/if you need them. The same is true for many core features, there’s much in the core that’s used rather seldom…

As for a kind of “priority list”: Don’t sort the things you learn by version number of OpenGL. For example, multitexture and texture combiners were introduced in 1.3, and then in 1.4 some restrictions of them were removed, so there’s no point in learning the restrictions.

In your place I’d jump straight to OpenGL 1.5, but don’t bother with the ARB_…_shader stuff. Make sure you really understand the whole multitexturing stuff, including texture combiners. Then learn OpenGL 2.0 (the most important change being programmable shaders).

Okay. So 'ill learn all the changes from 1.2 to 2.0 in one step because some stuff was added in 1.3 and then changed even more in 1.4 and so on and it would make no sense to learn the restrictions frist and then forget them later, right?

But this poses a problem: Where do i find a changelog from 1.2 to 2.0 that is useful for this?
Somthing including all changes from 1.2 until 2.0. The reason i want to know the complete new functionality is that i want to know that it exists in case i need it. This does not mean i want to learn everything even if it’s quite useless for me.

The only changelogs i find that are that complete are the ones from one version to the next. Not from one to two versions later…
I hope i’m wrong with this and you can point me to the place i did not find…

For the programmable shaders: I already wrote some of them. They were not really useful, because i’m not into all that new texture stuff, but i guess with a bit of training it would be not that hard.

So i can focus on the most advanced technique for creating photo-realitic textures with realtime shading and bump/normal/whatever-mapping. But i definitely want to know the options i could use in case i’m in trouble vecause i just need that functionality i did not learn.

I guess you understand me… i’m a bit of a perfectionist in this things…
My target is a bit hard because i’m going to develop a pretty hardcore hardware physics card for usage with my own engine. the physics stuff goes pretty well. But there’s not much use if you can’t show the pretty textures and models it creates or if you have to do stuff in the physics card that you be left to the graphics card…

I don’t know any “combined” changelog either, sorry.

The best method is to look at the individual changelogs in the appendix of the 2.0 spec. There you see some change mentioned. Then, instead of reading in detail what has changed, you just look at the 2.0 spec itself how the result of this change looks like. Even though the point in the changelog may not have been the last change to this particular feature, what’s written in the 2.0 spec is the final version, so that’s what’s important to know.

In implementing all the GL2 function calls and lookups, I found many help in glext.h. Most prototypes are just here.
I don’t remember the exact token now but it was something like
#if(def?) GL_VERSION_2_0
<various prototypes here>
…
…
#<guess?>

I believe it’s enough to get all the pointers running fine but you obviously need to read the various promoted extensions specs to understand their meanings. ARB_multitexture is the only one which is no more available but I understand this is not going to be a problem for you.