I am currently learning OpenGL 3.3 from here. I am doing this partially to allow me to make games directly in C++ (for the better memory management) but also to allow me to better utilize custom shaders in JME. When I tried to get some of my OpenGL 3.3 programs to run on my laptop (with Intel HD Graphcis 3000), I ran into issues regarding GLSL 3.3 being unavailable. As such, since I have heared that older OpenGL is a very simple APi, I am considering learning OpenGL 1.0 to provide a (near-)universal fallback whenever OpenGL 3.3 isn’t available. When I try to find information on OpenGL 1.0, all I can find are tutorials for OpenGL 3.3 explaining why OpenGL 1.0 is deprecated. I am not interested in how to do fancy effects in old OpenGL, but, rather how to simply get something that is usable to render (basic geometry, textures, and basic lighting).
I know that JMonkeyEngine recently dropped support for OpenGL 1, but, I don’t see that as a reason to not use it in my own games made directly with C++. I also feel like OpenGL 2.x should be similar to 1.0 since major changes were introduced later in 3.x, if this is true and 2.x is as well supported as 1.0, then I would be open to learning 2.x as well. I doubt this is the case because my laptop only supports GLSL 1.x.
NOTE: the target market for the games I am interested in making includes people who have no GPU beyond integrated graphics and people with brand new Titan Xs and 1080s. It is essential that I am both able to support ancient computers and have good-looking games on new computers.
OpenGL 1 has no shaders. It only has a fixed function pipeline. At this point, you might have to see if you can score one of the older red books.
OpenGL 2+ has shaders. That’s basically a completely new architecture.
Also note that newer graphics card drivers may not support the old style non-shader pipeline at all, unless they implement certain compatibility extensions.
Your card supports openGL 3.0. you might want to check a chart of the functions you are calling… you may be doing things that would work fine on 3.0 (or older) but are requesting a 3.3 compatible profile at setup time…
Is it accurate to call it a very simple API? Is it reasonable to learn it in a few days (since, if not, I may need to re-evaluate my decision to not go with something like Ogre3D)? By “red book” do you mean this? This looks to be OpenGL 1, but, I would like to verify that it is what you are talking about before going and spending any significant amount of time on it (assuming that such verification is easy, and to prevent me from wasting time on a bad resource).
I thought the main change was from a “fixed function pipeline” (which would seem to mean you just call a bunch of OpenGL functions – no code that is written by the game developer ever runs on the GPU) to a shader-based system with vertex and fragment shaders in OpenGL 3.x. Saying that shaders were introduced in 2.x invalidates this, but, from what I know OpenGL 3.x is where the idea of changing parts of the graphics pipline via shaders was added. Am I wrong about this? Are shaders something different in 2.x?
I would have a 3.x rendering system capable of both running on new systems and of rendering fancy effects. The OpenGL 1 system would be added only for old computers and I could easily test it on my laptop or even any of the ancient computers I have lying around.
When I change the program to request an older version of GLSL, things break. I am not requesting any specific version outside of #version preprocessor directives in GLSL.
There is basically no real support for opengl1 anymore.
Heck even in my virtual machines opengl 2.X is the minimum.
I was under the impression modern GPUs had a shader-based OpenGL1 implementation. By “real support” do you mean a more native implementation or do you mean that there is no support at all on anything new?
No. Personally, I think the OpenGL 1 API was more complicated because the fixed function pipeline had a different API for everything, fog, env mapped textures, everything had its own functions and some of them could be called efficiently at different times, etc…
I don’t know. By “Red Book” I meant the OpenGL “red book” that most of us old graphics developers have in physical form sitting on a shelf.
Shaders were implemented in OpenGL 2. That’s why JME supports OpenGL 2 and above since JME is a shader-based architecture. Later versions added even more types of shaders but the basic vertex and fragment shaders were in 2… and thus all of those strange APIs in the fixed function pipeline went away because you do all of that in shaders now. In OpenGL 2, it’s (relatively) simple: set some uniforms for the shaders, make a draw call with the vertex data.
Personally, if that’s really your goal then just use one of the fine C++ scene graphs/game engines already out there. I used to use http://www.openscenegraph.org/ “back in the day” and it was very nice and tight.
Bottom line is that OpenGL 1 will never allow this since it doesn’t support shaders at all. Not even a one. Fixed-fiunction only… which is why JME doesn’t support it anymore.