Sign in to follow this  
_the_phantom_

OpenGL OpenGL3.0.. I mean 2.2

Recommended Posts

_the_phantom_    11250
Well, someone has linked to the following on OpenGL.org; http://opengl.org/registry/doc/glspec30.20080811.pdf And, well, thanks but no thanks. All those glorious changes? Gone. The rewritten API? Gone. What we are left with is OpenGL2.2. To quote Eddy Luten from the Opengl.org forum;
Quote:
For those who don't feel like digging through the spec, OpenGL 3.0 Equals:
  • API support for the new texture lookup, texture format, and integer and unsigned integer capabilities of the OpenGL Shading Language 1.30 specification (GL EXT gpu shader4).
  • Conditional rendering (GL NV conditional render).
  • Fine control over mapping buffer subranges into client space and flushing modified data.
  • Floating-point color and depth internal formats for textures and renderbuffers (GL ARB color buffer float, GL NV depth buffer float, 455 N.2. DEPRECATION MODEL 456 GL ARB texture float, GL EXT packed float, and GL EXT texture shared exponent).
  • Framebuffer objects (GL EXT framebuffer object).
  • Half-float (16-bit) vertex array and pixel data formats (GL NV half float and GL ARB half float pixel).
  • Multisample stretch blit functionality (GL EXT framebuffer multisample and GL EXT framebuffer blit).
  • Non-normalized integer color internal formats for textures and renderbuffers (GL EXT texture integer).
  • One- and two-dimensional layered texture targets (GL EXT texture array).
  • Packed depth/stencil internal formats for combined depth+stencil textures and renderbuffers (GL EXT packed depth stencil).
  • Per-color-attachment blend enables and color writemasks (GL EXT draw buffers2).
  • RGTC specific internal compressed formats (GL EXT texture compression rgtc).
  • Single- and double-channel (R and RG) internal formats for textures and renderbuffers.
  • Transform feedback (GL EXT transform feedback).
  • Vertex array objects (GL APPLE vertex array object).
  • sRGB framebuffer mode (GL EXT framebuffer sRGB) Plus deprecation of older features.
As he said, where the hell are the objects? Frankly, this is crap. I said it was a sink or swim moment for the ARB and it's just sunk without a trace. It appears the reason is they don't want to break the API because of all the CAD apps out there (J. Carmack, QuakeCon2008), and in doing so have finally put the nail into the coffin games wise. I'd like to congratulate MS for winning the 3D API 'war' on Windows, turns out they didn't need to sink the goodship OpenGL, the captains ran it into an iceberg for them.

Share this post


Link to post
Share on other sites
hlsl    100
Uhm..I was looking forward to new API. Anyway, I'm just happy with D3D. Seems like Microsoft actually know how to do the things.

Share this post


Link to post
Share on other sites
My God. What would have been the problem saying, "This is the way it's going to be, let's REFINE it"? Makes me loose a LOT of respect for the ARB.

Of course, being on Linux, I sort of have to go with OpenGL (mesa, whatever) instead of DirectX. After this little blow though, I'm looking forward to somebody cracking DirectX.

FlyingIsFun1217

Share this post


Link to post
Share on other sites
Spoonbender    1258
So let me get this straight... In order to allow what, a small handful of old CAD apps to compile against 3.0, they're willing to practically kill off all *new* applications developed against the API?

That makes sense. One customer a year ago is better than ten next week... [grin]

Or maybe they've just realized that a) they've lost everything on Windows to DirectX so it doesn't really matter what they do there, and b) since they don't have a single competing API on other platforms, they don't actually need to make an effort there either.

End result, they can screw over developers as much as they like, and it won't actually hurt them. Windows developers wouldn't have used OGL in the first place, and everyone else will keep using them because there are no alternatives.

Share this post


Link to post
Share on other sites
_the_phantom_    11250
Quote:
Original post by Spoonbender
That makes sense. One customer a year ago is better than ten next week... [grin]


Yes, apprently the ARB has a passing familarity with 'sense'; I'm starting to suspect that as a rule of thumb they find out what makes sense and then go in the other direction...

Share this post


Link to post
Share on other sites
Ravuya    135
So it took them a year of no updates, no news to unroll their existing changes and go back to an unassuming, useless API?

I thought Khronos was on the clue train here. People bank their livelihoods on this stuff.

Maybe with the new depreciation model we can have objects by 2014. I suspect I'd better get cracking on my Core Animation/DirectX interop layer before Apple leaves the ARB.

Share this post


Link to post
Share on other sites
InvalidPointer    1842
I couldn't help but laugh a little bit at the irony-- the ARB gets nailed for NOT dropping some support for older apps, but when Microsoft does the right thing and pushes forward with DX10-- they take a lot of flak themselves. Screwed if you do, screwed if you don't. That's life, I guess.

Share this post


Link to post
Share on other sites
davepermen    1047
Sad sad, I always loved opengl, having started with it. And I like it for being open and all. But they really lost focus completely. What's wrong with drawing a line and put a complete new api for the next version? Dx does it (too often possibly). It's not like it hurts anyone to have opengl1.dll, opengl2.dll and opengl3.dll on it's system.

Bad bad bad direction.

we should create a new one :)

Share this post


Link to post
Share on other sites
Cornstalks    7030
Quote:
Original post by Mike.Popoloski
So I just checked, and it turns out we have plenty of room in DirectX and XNA for you guys. You can all come, nobody needs to get left out. Jack is going to make a batch of cookies for everyone!

I'm totally taking you up on that. I just started C# and XNA (I've been doing C++ and OpenGL in the past) and I'm really enjoying it. Will they be chocolate chip cookies? Those are my favorite.

Share this post


Link to post
Share on other sites
Oluseyi    2103
Quote:
Original post by Spoonbender
So let me get this straight... In order to allow what, a small handful of old CAD apps to compile against 3.0, they're willing to practically kill off all *new* applications developed against the API?

It's not the number of apps that matter; it's the size of the market that these apps cater to. What would you estimate is the annual revenue from this "small handful of old CAD apps" (like AutoCAD 2009, released way back in the dark days of March 2008)? This was a US$ 1 billion market in 1979; in 1997, PDM - just one facet of the PLM approach generally employed by modern CAD solutions - was a $1.1 billion market by itself.

I understand the game developer's frustration - I was just about to start learning OpenGL for the Mac, and I still will - but let's not get ridiculous. CAD is a huge industry: every architecture firm, every electrical firm, every large-scale manufacturer, the automotive industry, product design, industrial design... They are a major client of OpenGL, and their perspective is an important one.

Nor can you argue that they could just continue working against 2.1 while the rest of the world moved on to 3.0. CAD applications develop and compete aggressively, as aggressively as games albeit with a different visual emphasis, and they need to take advantage of technology advances just like everyone else.


No question, this is a disappointment, but it doesn't appear to be so much a case of deliberately "screwing developers over" as it is a case of incompetence and lack of strong vision to plot a future. I mean, I'm only a casual OpenGL observer, but that seems to have been the case ever since the Khronos Group became responsible.

Share this post


Link to post
Share on other sites
V-man    813
The usual will happen. GL drivers are going to get more and more complicated to write -> ATI will lag behind so don't expect GL 3.0 drivers anytime soon, Intel won't release a driver at all and neither will SIS and I don't know who else is making chipsets.

I can see they have "The Deprecation Model" on page 403 but so what??? They are going to make a clean break some day?

Share this post


Link to post
Share on other sites
Promit    13246
Quote:
Original post by Oluseyi
No question, this is a disappointment, but it doesn't appear to be so much a case of deliberately "screwing developers over" as it is a case of incompetence and lack of strong vision to plot a future.
But it's more than just that. Forget the justification for why things ended up the way they did finally. My question is, why was everyone in the graphics world strung along for so many years? Why did the ARB and then Khronos promise pie in the sky goals and then vanish off for a year, promising big news, just to give us this? If that was how any of us behaved at our jobs, we'd be fired.

Regardless of where OpenGL goes from here (which is apparently nowhere), there's no reason to ever trust the people behind it again. This is the second time they've misled us thanks to their incompetent bickering.

Share this post


Link to post
Share on other sites
Matias Goldberg    9573
So... They took so much time (and delayed the launch) just for THIS???

I have a great idea!!! Next OpenGL 4.0 will be an object-oriented API that will actually wrap to Direct3D [lol][lol]

(oh... and if that doesn't work will just stick with OGL 2.3 and name it 4.0)

Seriously, If things keep going this way, we should make up a team that will be in charge of a new cross-plattform API. Not easy to do, as that would need support from Driver developers (aka NVIDIA, ATI, Intel); plus we need experienced people, and a lot of time to just design (not to mention coding). After that, it should have success into adoption.
But at least we could try.

Well.... [sigh]

Dark Sylinc

Share this post


Link to post
Share on other sites
Lord_Evil    680
Quote:
Original post by Mike.Popoloski
So I just checked, and it turns out we have plenty of room in DirectX and XNA for you guys. You can all come, nobody needs to get left out. Jack is going to make a batch of cookies for everyone!

Yep, I'm also considering coming back to DirectX. Shame on Khronos for making us rely on M$ [crying]

Share this post


Link to post
Share on other sites
mrbastard    1577
TBH I take this as a message from the hardware vendors saying "Nobody except hobbyists are interested in cutting edge cross-platform graphics - OpenGLES is fine for everyone else. Use the well supported windows API you fools!"

Which, to be fair, people have been telling us for years.

It's not that bad though, nothing has been lost. It's just a shame the ARB managed expectations of their work so poorly.

Share this post


Link to post
Share on other sites
EmptyVoid    102
Didn't want to be the odd one in the bunch and I'm all for bashing OpenGL but what exactly is the problem? Has it lost hardware features? Does it run slower? Is it less compatible? I'm a noob with OpenGL I just started like 2 weeks ago and I can't understand why all of you are complaining?

Share this post


Link to post
Share on other sites
Daaark    3553
OpenGL hasn't been cutting edge since before DX8 came out. Now they are just cross platform and playing catch up. They had one foot in the grave when D3D8 came out, and then Ms left the ARB and released D3D9 and they were officially dead in the water.

OpenGL became redundant for a few reasons.

- They keep adding messy extensions onto an old, outdated base API. D3D is like a sports car, and OpenGL is like a scooter that keeps getting side cars attached to it.

- The company that has the most installed graphics chips on home machines has the crappiest drivers. It really sucks to write perfectly legal code and have the horrible intel implementation completely botch your whole program. Even worse when one of the driver versions reported supporting OpenGL 1.2 but didn't actually support most 1.2 extensions.

Have you ever hung out on the user forums for 3D software written in OpenGL? Every time the program gets patched there is a flood of intel users reporting that the program is broken or crashes with strange errors, and the devs have to write workarounds for everything they added.

What good is a standard when no one follows it? Especially when the company that has the biggest share of the GPU market doesn't have a working implementation on most of their models of GPU and has no intention of fixing it. People think it's all about ATI and nVidia, when they are really only competing for second and third place.

When I wanted to write a polished game and publish it, I gave up on OpenGL because of all those problems. All my target audience was going to have those GPUs. I can't be dealing with all that crap. I want to write something that just works. Instead of being creative, I had to look over my code and keep blindly recompiling to try and prevent my friend's intel gpu from rendering my game with a wireframe overlay, and random faces being culled, when I had no calls for wireframe drawing mode in my whole app, and culling disabled. [lol]

The ARB just takes years to try and agree on a header file, and they have to make everyone happy and cater to every possible interest at the same time. And then, they just give us that header and they leave it at that. Everyone else has to do all the work. Even to the point where a member of this forum has to write a library to easily access the extensions. Why couldn't the ARB get off their asses and make their own GLEE like header for everyone to use??

---

I think it's time to let this horse die and let another company step forward and create a cross platform 3D games API. Why hasn't apple been spending money to develop their own DirectX like technology? Maybe even license Direct3D?

Share this post


Link to post
Share on other sites
rbarris    635

3.0 could be looked at as the last fully upward compatible revision of OpenGL; since it introduces a deprecation model allowing for the phased elimination of obsolete API's (a set of which are already defined in the spec). The intent there is to provide for an orderly simplification of the specification and drivers for upcoming releases, the next of which is scheduled for less than 12 months from now.

http://www.marketwatch.com/news/story/khronos-releases-opengl-30-specifications/story.aspx?guid=%7BC2A3B5D7-CB9A-4898-BAF9-178DD8CFD695%7D&dist=hppr

BTW we have set up a mail reflector specifically for questions and suggestions specifically relating to game development using OpenGL 3.0 - if there is some piece of hardware functionality not addressed by the current 3.0 spec, now is exactly the right time to let us hear about it.

gamedev@khronos.org

Share this post


Link to post
Share on other sites
_the_phantom_    11250
Quote:
Original post by EmptyVoid
Didn't want to be the odd one in the bunch and I'm all for bashing OpenGL but what exactly is the problem? Has it lost hardware features? Does it run slower? Is it less compatible? I'm a noob with OpenGL I just started like 2 weeks ago and I can't understand why all of you are complaining?


Because this ISNT what was talked about a year ago when they were 'close' to having a spec.

The point of OpenGL3.0, as originally talked about, was to;
- make the 'fast path' easy to find
- make the life of driver developers easier
- change the API to better reflect the hardware

The OpenGL API is.. well, probably over 15 years old by now, if not a little bit more, and while it matched the hardware for a while it is now drifting from it (see D3D10 for a better idea of how to talk to the hardware) and the point of the breaking refresh was to better match that hardware.

However, by simply bolting things onto the OpenGL2.1 spec they have;
- failed to make the fast path easy to find
- failed to make the driver developers lives easier
- failed to change the API to better reflect the hardware

Same old, same old really... on reflection it was dumb of us to give them another chance to 'fix' the problem.. as they say; fool me once, shame on you, fool me twice, shame on me.

I won't be fooled again.

Share this post


Link to post
Share on other sites
_the_phantom_    11250
Quote:
Original post by Oluseyi
I mean, I'm only a casual OpenGL observer, but that seems to have been the case ever since the Khronos Group became responsible.


It's been the case since long before then, we had hoped that being part of Khronos would help... apprently not.

Share this post


Link to post
Share on other sites
DumpAlien    127
Quote:
Original post by phantom

- failed to make the fast path easy to find
- failed to make the driver developers lives easier
- failed to change the API to better reflect the hardware



Sorry for asking again... but how u come to a conclusion that openGL failed on these three above? I am a little confuzed..

Thanks again!

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

  • Similar Content

    • By Kjell Andersson
      I'm trying to get some legacy OpenGL code to run with a shader pipeline,
      The legacy code uses glVertexPointer(), glColorPointer(), glNormalPointer() and glTexCoordPointer() to supply the vertex information.
      I know that it should be using setVertexAttribPointer() etc to clearly define the layout but that is not an option right now since the legacy code can't be modified to that extent.
      I've got a version 330 vertex shader to somewhat work:
      #version 330 uniform mat4 osg_ModelViewProjectionMatrix; uniform mat4 osg_ModelViewMatrix; layout(location = 0) in vec4 Vertex; layout(location = 2) in vec4 Normal; // Velocity layout(location = 3) in vec3 TexCoord; // TODO: is this the right layout location? out VertexData { vec4 color; vec3 velocity; float size; } VertexOut; void main(void) { vec4 p0 = Vertex; vec4 p1 = Vertex + vec4(Normal.x, Normal.y, Normal.z, 0.0f); vec3 velocity = (osg_ModelViewProjectionMatrix * p1 - osg_ModelViewProjectionMatrix * p0).xyz; VertexOut.velocity = velocity; VertexOut.size = TexCoord.y; gl_Position = osg_ModelViewMatrix * Vertex; } What works is the Vertex and Normal information that the legacy C++ OpenGL code seem to provide in layout location 0 and 2. This is fine.
      What I'm not getting to work is the TexCoord information that is supplied by a glTexCoordPointer() call in C++.
      Question:
      What layout location is the old standard pipeline using for glTexCoordPointer()? Or is this undefined?
       
      Side note: I'm trying to get an OpenSceneGraph 3.4.0 particle system to use custom vertex, geometry and fragment shaders for rendering the particles.
    • By markshaw001
      Hi i am new to this forum  i wanted to ask for help from all of you i want to generate real time terrain using a 32 bit heightmap i am good at c++ and have started learning Opengl as i am very interested in making landscapes in opengl i have looked around the internet for help about this topic but i am not getting the hang of the concepts and what they are doing can some here suggests me some good resources for making terrain engine please for example like tutorials,books etc so that i can understand the whole concept of terrain generation.
       
    • By KarimIO
      Hey guys. I'm trying to get my application to work on my Nvidia GTX 970 desktop. It currently works on my Intel HD 3000 laptop, but on the desktop, every bind textures specifically from framebuffers, I get half a second of lag. This is done 4 times as I have three RGBA textures and one depth 32F buffer. I tried to use debugging software for the first time - RenderDoc only shows SwapBuffers() and no OGL calls, while Nvidia Nsight crashes upon execution, so neither are helpful. Without binding it runs regularly. This does not happen with non-framebuffer binds.
      GLFramebuffer::GLFramebuffer(FramebufferCreateInfo createInfo) { glGenFramebuffers(1, &fbo); glBindFramebuffer(GL_FRAMEBUFFER, fbo); textures = new GLuint[createInfo.numColorTargets]; glGenTextures(createInfo.numColorTargets, textures); GLenum *DrawBuffers = new GLenum[createInfo.numColorTargets]; for (uint32_t i = 0; i < createInfo.numColorTargets; i++) { glBindTexture(GL_TEXTURE_2D, textures[i]); GLint internalFormat; GLenum format; TranslateFormats(createInfo.colorFormats[i], format, internalFormat); // returns GL_RGBA and GL_RGBA glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, createInfo.width, createInfo.height, 0, format, GL_FLOAT, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); DrawBuffers[i] = GL_COLOR_ATTACHMENT0 + i; glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, textures[i], 0); } if (createInfo.depthFormat != FORMAT_DEPTH_NONE) { GLenum depthFormat; switch (createInfo.depthFormat) { case FORMAT_DEPTH_16: depthFormat = GL_DEPTH_COMPONENT16; break; case FORMAT_DEPTH_24: depthFormat = GL_DEPTH_COMPONENT24; break; case FORMAT_DEPTH_32: depthFormat = GL_DEPTH_COMPONENT32; break; case FORMAT_DEPTH_24_STENCIL_8: depthFormat = GL_DEPTH24_STENCIL8; break; case FORMAT_DEPTH_32_STENCIL_8: depthFormat = GL_DEPTH32F_STENCIL8; break; } glGenTextures(1, &depthrenderbuffer); glBindTexture(GL_TEXTURE_2D, depthrenderbuffer); glTexImage2D(GL_TEXTURE_2D, 0, depthFormat, createInfo.width, createInfo.height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glBindTexture(GL_TEXTURE_2D, 0); glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthrenderbuffer, 0); } if (createInfo.numColorTargets > 0) glDrawBuffers(createInfo.numColorTargets, DrawBuffers); else glDrawBuffer(GL_NONE); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) std::cout << "Framebuffer Incomplete\n"; glBindFramebuffer(GL_FRAMEBUFFER, 0); width = createInfo.width; height = createInfo.height; } // ... // FBO Creation FramebufferCreateInfo gbufferCI; gbufferCI.colorFormats = gbufferCFs.data(); gbufferCI.depthFormat = FORMAT_DEPTH_32; gbufferCI.numColorTargets = gbufferCFs.size(); gbufferCI.width = engine.settings.resolutionX; gbufferCI.height = engine.settings.resolutionY; gbufferCI.renderPass = nullptr; gbuffer = graphicsWrapper->CreateFramebuffer(gbufferCI); // Bind glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); // Draw here... // Bind to textures glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, textures[0]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, textures[1]); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, textures[2]); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, depthrenderbuffer); Here is an extract of my code. I can't think of anything else to include. I've really been butting my head into a wall trying to think of a reason but I can think of none and all my research yields nothing. Thanks in advance!
    • By Adrianensis
      Hi everyone, I've shared my 2D Game Engine source code. It's the result of 4 years working on it (and I still continue improving features ) and I want to share with the community. You can see some videos on youtube and some demo gifs on my twitter account.
      This Engine has been developed as End-of-Degree Project and it is coded in Javascript, WebGL and GLSL. The engine is written from scratch.
      This is not a professional engine but it's for learning purposes, so anyone can review the code an learn basis about graphics, physics or game engine architecture. Source code on this GitHub repository.
      I'm available for a good conversation about Game Engine / Graphics Programming
    • By C0dR
      I would like to introduce the first version of my physically based camera rendering library, written in C++, called PhysiCam.
      Physicam is an open source OpenGL C++ library, which provides physically based camera rendering and parameters. It is based on OpenGL and designed to be used as either static library or dynamic library and can be integrated in existing applications.
       
      The following features are implemented:
      Physically based sensor and focal length calculation Autoexposure Manual exposure Lense distortion Bloom (influenced by ISO, Shutter Speed, Sensor type etc.) Bokeh (influenced by Aperture, Sensor type and focal length) Tonemapping  
      You can find the repository at https://github.com/0x2A/physicam
       
      I would be happy about feedback, suggestions or contributions.

  • Popular Now