• Advertisement
Sign in to follow this  

OpenGL OpenGL3.0.. I mean 2.2

This topic is 3409 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

This is an unbelievable letdown. I kind of saw it coming, but I never expected the ARB to fail on such an immense scale. I find it astonishing how far some people can be removed from reality, and yet not be immediately fired due to overwhelming incompetence. This is the death of modern OpenGL. Thank you very much ARB. What Microsoft never managed, you did. You should be ashamed of yourselves.

After hearing these news, we will be starting the end-of-life plan for our OpenGL renderer in the very near future (XP compatibility and quad buffered stereo are the only features holding it back), and will be focusing on D3D10 exclusively from now on.

Oh, and we are a CAD software manufacturer...

I really wonder if there is some remote possibility to take legal action against the ARB / Khronos after this total fiasco.

Quote:

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.

Haha, good one. At least they haven't lost their (very strange) sense of humour...

Share this post


Link to post
Share on other sites
Advertisement
Not that it matters much, but I'm sure the Comparison of OpenGL and Direct3D wikipage slants a certain way.

I wonder then, as Macs are becoming more popular these days... and more people play games - will Apple / Linux community implement and extend to keep up with DX? Or do something new?

I'd imagine implement + extend would fragment the platform though, potentially taking away some of the cross-platform-ness.

Share this post


Link to post
Share on other sites
Quote:
Original post by rbarris

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


Thanks for that. Though TBH I think you may be one of the few game developers with the resources to carry on using GL. It's not that anything has gotten signifantly worse, it's that not enough things have gotten better to counter the long-standing lack of freely available tools and support (compared to D3D). A fresh new API would have gone some way to countering the problem, but would still have only been a stop-gap.

For example; the company I work for refuses to consider OpenGL simply because of the percieved lack of support. OpenGL 3 wasn't going to change that, but the impression given by the recent problems is that support is getting worse not better.

I realise these aren't technical issues, sorry. Overall I think the problem here is that for a while it seemed Khronos would make OpenGL as easy to work with as Direct3D, and the long wait and shiny new version number made people hope for something bigger even than what was promised.

Share this post


Link to post
Share on other sites
Less than 12 months.

Deprecation model, eh? I have a much simpler deprecation model, rbarris - FREEZE GL 2.1, and design GL3 from scratch. This was promised to us. It was a lie. OpenGL died today.

Share this post


Link to post
Share on other sites
I wrote the gamedev@khronos.org asking where's the API that was promised and what the hell were they doing for the last year that they couldn't talk with the community about. I doubt I'll get a sincere response, but I want to know how they could catastrophically fail in moving this standard forward. I understand legacy code bases probably better than then next guy (anybody play with DIS And HLA simulations?), but this is ridiculous. Where is the progress they promised?

Bob

Share this post


Link to post
Share on other sites
I guess the OpenGL vs Direct3D question has finally been answered. It's Direct3D unless you need cross platform compatibility.

Very sad.

Regards
elFarto

Share this post


Link to post
Share on other sites
Although I can understand some of the frustration around here, I think you may be a bit too pessimistic there.

I've only skimmed over that specification for about 5 minutes, but so far it really doesn't look that grim.
Yes, there are no objects. Yes, there is still fixed functionality around. No, there has been no complete API rewrite. But hey, so what.
Look at the positive side. A good number of extensions with valuable features has been promoted to core, even some features that weren't initially announced at all. So, some stuff will be a bit less messy, which is good already.
Maybe "version 3.0" is a bit far fetched for what's in the spec, I'd rather have called it 2.2 or 2.3, but hey... what do numbers really mean. Remember when Netscape jumped from 4 to 6 in one go? :)

To be honest, this spec is a lot more than what I had expected to happen, and I see it as a very positive thing. In fact, I had expected that nothing happens at all, and I am very happy that we got at least half of what was promised, and a few goodies to comfort for the other half.
If you consider how many people/companies inside and outside of Khronos have excellent economic reasons against supporting and extending OpenGL, and how few people have a reason to support it at all, it's a miracle.

Share this post


Link to post
Share on other sites
WHY HAVE YOU GUY BEEN DEBATING THIS FOR SO LONG?!?! After DirectX8 came out it was clear that DirectX was the better API and anyone that thought it was not didn't use it. OpenGL is for cross platform support and not easy use.

Share this post


Link to post
Share on other sites
Hmmm, I must admit I was looking forward to a new streamlined OpenGL, but I don't find this new version that bad. You can see some of what they were aiming for in the new deprecation model. It does away with a lot of the cruft in OpenGL, including pretty much everything fixed-function. They've been quite brutal with what they've culled as listed in Appendix E.

I suspect this'll actually make life easier for driver writers as they'll write new drivers to support the new deprecation model with an OpenGL 2.1 emulator sitting on top of that. If the ARB is wise they'll provide the code for that emulation layer to help things along.

It's not the re-write they had promised us, but after that strange year of dead silence we kinda all knew something was up. But this just doesn't seem that bad to me. It's not a huge leap but it is a step in the right direction.

BTB, I've had the misfortune to create renderers for the Intel i915 in both GL and D3D, and their drivers stink on both. :-/

Share this post


Link to post
Share on other sites
LOL, problem solved. Some cad guy told everyone in the thread @ OpenGL's site to calm down, and that games are small, unimportant apps.

Share this post


Link to post
Share on other sites
Sounds like lots of 'The sky falling' talk but I thought the sky had fallen years ago. I am using OGL/GLSL and it has everything I need. The trick is not to read the DX SDK :)

I don't think a clean slate would help drivers out since it would likely mean a new driver from scratch plus maintaining their old one. Honestly, do you think people would just run over to the oven for the freshly baked OGL 3.0 and say 'Finally, we can all stop sitting on our hands and start witting our OGL 3.0 driver'?

I learned roughly OS/2 years ago not to take sides. Just use OGL for what it's good for and leave it at that.

Share this post


Link to post
Share on other sites
Wow, that is in fact a massive letdown.

Though, I interpret this as an artifact of the upcoming paradigm shift in graphics, introduced by Larrabee et al. ... Makes me think that the DirectX story is far from being told with Microsoft adding Compute Shaders to it either.

Part of the problem seems to be that there is no sufficiently good API to that future architecture yet, not even conceptually, let alone one that traditional things such as OpenGL/DX could easily be consistent with. So that no really future-proof way of evolving these is in sight atm.

[Edited by - pro_optimizer on August 11, 2008 1:47:17 PM]

Share this post


Link to post
Share on other sites
Extremely unprofessional job by Kronos, they took an extra year to basically just add a couple of NV extensions as ARB extensions. If they were going to go back on their original intentions they should have made it clear much earlier. Don't even see Geometry shaders mentioned either so sub sm4 levels. I'm done with OGL asap.

Share this post


Link to post
Share on other sites
Quote:
Original post by Tesshu
I don't think a clean slate would help drivers out since it would likely mean a new driver from scratch plus maintaining their old one. Honestly, do you think people would just run over to the oven for the freshly baked OGL 3.0 and say 'Finally, we can all stop sitting on our hands and start witting our OGL 3.0 driver'?


Given that the original re-write from scratch plans were from ATI and NV I have to call that into question. Yes, they would still have to do some mantainence on the old drivers, however for the new they have a clean slate.

Right now when functionality is added into the core they have to check how it interacts with EVERYTHING down to glVertex() and the like. Stripping all this out would have given them a clean slate to start again and not have to worry about these old, outdated methods and how they interact with the newer functionality.

As for the 'deprecation model' someone mentioned; yes because deprecation has worked so well in other cases. People keep using it (see Java) even when there is a big 'do no use!' warning slapped on it, which means it has to stay in because as soon as you remove it it breaks something and BAM! loads of complaints.

The amusing thing, from what I recall there was always plans for a backwards compatible system, with contexts being shared between GL2.x and Longs Peaks so both could operate at once. Guess that wasn't enough...

Share this post


Link to post
Share on other sites
Quote:
Original post by DumpAlien
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!


Having worked very closely with OpenGL drivers at AMD/ATI and Qualcomm, I'll take this one.

1) Because of its long evolution, OpenGL provides many different ways to do the same thing. Typically, one of those ways is very good for performance, and the other ways are bad. In order to access the fast path as things now stand, you have to be familiar with the underlying hardware and usually write multiple paths to fully take advantage of all the hardware out there.

2) Supporting 15+ years of legacy functionality by itself significantly complicates the driver. The expectation that the driver should not just support it, but make it fast, further complicates the drivers.

3) Hardware has changed drastically since OpenGL was first introduced. Because of this, OpenGL is no longer "close to the metal" - which is what you'd expect from a low-level, high performance graphics API. This gets back to the first two points: because the API doesn't really reflect how the hardware actually works, a significant amount of optimization needs to to be done both in the driver and in applications.

As originally described, 3.0 would have fixed these things. Unfortunately, just like 2.0, it seems that 3.0 fell far short of what was initially envisioned.

Share this post


Link to post
Share on other sites
Quote:
Original post by Myopic Rhino
Quote:
Original post by DumpAlien
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!


Having worked very closely with OpenGL drivers at AMD/ATI and Qualcomm, I'll take this one.

1) Because of its long evolution, OpenGL provides many different ways to do the same thing. Typically, one of those ways is very good for performance, and the other ways are bad. In order to access the fast path as things now stand, you have to be familiar with the underlying hardware and usually write multiple paths to fully take advantage of all the hardware out there.

2) Supporting 15+ years of legacy functionality by itself significantly complicates the driver. The expectation that the driver should not just support it, but make it fast, further complicates the drivers.

3) Hardware has changed drastically since OpenGL was first introduced. Because of this, OpenGL is no longer "close to the metal" - which is what you'd expect from a low-level, high performance graphics API. This gets back to the first two points: because the API doesn't really reflect how the hardware actually works, a significant amount of optimization needs to to be done both in the driver and in applications.

As originally described, 3.0 would have fixed these things. Unfortunately, just like 2.0, it seems that 3.0 fell far short of what was initially envisioned.


Its nice to know why, but what concerns me is what do we do next? The only alternatives to windows PC's for gaming, without a more up to date OpenGL, is Cider on apple machines, or consoles. For indie game developers, this means XNA, therefore the Xbox. Either way, MS now get a further increased share of the video game market, to the point where the effect of free market competition is non existant.

I fear that no competator to D3D means poorer quality from MS in the future. OpenGl thrived when it was a viable alternative to DX, but now it seems this is no longer the case. What other alternatives are there?

Share this post


Link to post
Share on other sites
Quote:
Original post by speciesUnknown
I fear that no competator to D3D means poorer quality from MS in the future. OpenGl thrived when it was a viable alternative to DX, but now it seems this is no longer the case. What other alternatives are there?


Larrabee or Larrabee-esque architectures where people don't need an API to render at high frame rates maybe?

Sigh.. are we going to have dozens of different API's now?

Share this post


Link to post
Share on other sites
Quote:
Original post by speciesUnknown
I fear that no competator to D3D means poorer quality from MS in the future. OpenGl thrived when it was a viable alternative to DX, but now it seems this is no longer the case. What other alternatives are there?


To be fair, OpenGL hasn't really been a viable alternative to D3D in the commerical game space for some years now. Also, MS have already been throwing more resources at XB360 as the recent GameFest showed in the presentation bias towards the 360.

For hobby developers, well, you've still got OpenGL, just not the new shiney API that was planned for.

Share this post


Link to post
Share on other sites
Quote:
Original post by speciesUnknown
Quote:
Original post by Myopic Rhino
Quote:
Original post by DumpAlien
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!


Having worked very closely with OpenGL drivers at AMD/ATI and Qualcomm, I'll take this one.

1) Because of its long evolution, OpenGL provides many different ways to do the same thing. Typically, one of those ways is very good for performance, and the other ways are bad. In order to access the fast path as things now stand, you have to be familiar with the underlying hardware and usually write multiple paths to fully take advantage of all the hardware out there.

2) Supporting 15+ years of legacy functionality by itself significantly complicates the driver. The expectation that the driver should not just support it, but make it fast, further complicates the drivers.

3) Hardware has changed drastically since OpenGL was first introduced. Because of this, OpenGL is no longer "close to the metal" - which is what you'd expect from a low-level, high performance graphics API. This gets back to the first two points: because the API doesn't really reflect how the hardware actually works, a significant amount of optimization needs to to be done both in the driver and in applications.

As originally described, 3.0 would have fixed these things. Unfortunately, just like 2.0, it seems that 3.0 fell far short of what was initially envisioned.


Its nice to know why, but what concerns me is what do we do next? The only alternatives to windows PC's for gaming, without a more up to date OpenGL, is Cider on apple machines, or consoles. For indie game developers, this means XNA, therefore the Xbox. Either way, MS now get a further increased share of the video game market, to the point where the effect of free market competition is non existant.

I fear that no competator to D3D means poorer quality from MS in the future. OpenGl thrived when it was a viable alternative to DX, but now it seems this is no longer the case. What other alternatives are there?


Always could make a new API(The graphics API made by GameDev.net targeted at cross platform game development) But you know that would take awhile and we would need some major $$. It also would probably not work out for some reason.

Share this post


Link to post
Share on other sites
Quote:
Original post by phantom
Quote:
Original post by speciesUnknown
I fear that no competator to D3D means poorer quality from MS in the future. OpenGl thrived when it was a viable alternative to DX, but now it seems this is no longer the case. What other alternatives are there?


To be fair, OpenGL hasn't really been a viable alternative to D3D in the commerical game space for some years now. Also, MS have already been throwing more resources at XB360 as the recent GameFest showed in the presentation bias towards the 360.

For hobby developers, well, you've still got OpenGL, just not the new shiney API that was planned for.


Well this does not interfere with my own game concept, but in future, I will likely need to learn DX instead. If that is the case, I may as well continue my hobby on XNA; for the time being, I see little reason not to do so. I know im not the only one who thinks this way.

Share this post


Link to post
Share on other sites
Quote:
Original post by speciesUnknown
I fear that no competator to D3D means poorer quality from MS in the future. OpenGl thrived when it was a viable alternative to DX, but now it seems this is no longer the case. What other alternatives are there?
OpenCL and Larrabee?

... Just some really wild speculation. See also AMD Announces OpenCL Compatible Teraflop Graphics Card.

Share this post


Link to post
Share on other sites
OpenGL 3.0 lol

What is brilliant in the computing industry in general is this ability to first deliver something which is not finished yet ( beta version ...) and let the user try it for us.
The second thing is this ability to give the same deficient product again and again until one day you just need to catch up on the rest of the world, because well nobody is using it any more lol.

Anyway I was really waiting for this one, I'm disappointed they could at least explain why.

Share this post


Link to post
Share on other sites
Quote:
Original post by Myopic Rhino
Having worked very closely with OpenGL drivers at AMD/ATI and Qualcomm, I'll take this one.

1) Because of its long evolution, OpenGL provides many different ways to do the same thing. Typically, one of those ways is very good for performance, and the other ways are bad. In order to access the fast path as things now stand, you have to be familiar with the underlying hardware and usually write multiple paths to fully take advantage of all the hardware out there.

2) Supporting 15+ years of legacy functionality by itself significantly complicates the driver. The expectation that the driver should not just support it, but make it fast, further complicates the drivers.

3) Hardware has changed drastically since OpenGL was first introduced. Because of this, OpenGL is no longer "close to the metal" - which is what you'd expect from a low-level, high performance graphics API. This gets back to the first two points: because the API doesn't really reflect how the hardware actually works, a significant amount of optimization needs to to be done both in the driver and in applications.

Do these points also apply to OpenGL ES?

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
  • Advertisement
  • Popular Tags

  • Advertisement
  • Popular Now

  • Similar Content

    • By reenigne
      For those that don't know me. I am the individual who's two videos are listed here under setup for https://wiki.libsdl.org/Tutorials
      I also run grhmedia.com where I host the projects and code for the tutorials I have online.
      Recently, I received a notice from youtube they will be implementing their new policy in protecting video content as of which I won't be monetized till I meat there required number of viewers and views each month.

      Frankly, I'm pretty sick of youtube. I put up a video and someone else learns from it and puts up another video and because of the way youtube does their placement they end up with more views.
      Even guys that clearly post false information such as one individual who said GLEW 2.0 was broken because he didn't know how to compile it. He in short didn't know how to modify the script he used because he didn't understand make files and how the requirements of the compiler and library changes needed some different flags.

      At the end of the month when they implement this I will take down the content and host on my own server purely and it will be a paid system and or patreon. 

      I get my videos may be a bit dry, I generally figure people are there to learn how to do something and I rather not waste their time. 
      I used to also help people for free even those coming from the other videos. That won't be the case any more. I used to just take anyone emails and work with them my email is posted on the site.

      I don't expect to get the required number of subscribers in that time or increased views. Even if I did well it wouldn't take care of each reoccurring month.
      I figure this is simpler and I don't plan on putting some sort of exorbitant fee for a monthly subscription or the like.
      I was thinking on the lines of a few dollars 1,2, and 3 and the larger subscription gets you assistance with the content in the tutorials if needed that month.
      Maybe another fee if it is related but not directly in the content. 
      The fees would serve to cut down on the number of people who ask for help and maybe encourage some of the people to actually pay attention to what is said rather than do their own thing. That actually turns out to be 90% of the issues. I spent 6 hours helping one individual last week I must have asked him 20 times did you do exactly like I said in the video even pointed directly to the section. When he finally sent me a copy of the what he entered I knew then and there he had not. I circled it and I pointed out that wasn't what I said to do in the video. I didn't tell him what was wrong and how I knew that way he would go back and actually follow what it said to do. He then reported it worked. Yea, no kidding following directions works. But hey isn't alone and well its part of the learning process.

      So the point of this isn't to be a gripe session. I'm just looking for a bit of feed back. Do you think the fees are unreasonable?
      Should I keep the youtube channel and do just the fees with patreon or do you think locking the content to my site and require a subscription is an idea.

      I'm just looking at the fact it is unrealistic to think youtube/google will actually get stuff right or that youtube viewers will actually bother to start looking for more accurate videos. 
    • By Balma Alparisi
      i got error 1282 in my code.
      sf::ContextSettings settings; settings.majorVersion = 4; settings.minorVersion = 5; settings.attributeFlags = settings.Core; sf::Window window; window.create(sf::VideoMode(1600, 900), "Texture Unit Rectangle", sf::Style::Close, settings); window.setActive(true); window.setVerticalSyncEnabled(true); glewInit(); GLuint shaderProgram = createShaderProgram("FX/Rectangle.vss", "FX/Rectangle.fss"); float vertex[] = { -0.5f,0.5f,0.0f, 0.0f,0.0f, -0.5f,-0.5f,0.0f, 0.0f,1.0f, 0.5f,0.5f,0.0f, 1.0f,0.0f, 0.5,-0.5f,0.0f, 1.0f,1.0f, }; GLuint indices[] = { 0,1,2, 1,2,3, }; GLuint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW); GLuint ebo; glGenBuffers(1, &ebo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(float) * 5, (void*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 2, GL_FLOAT, false, sizeof(float) * 5, (void*)(sizeof(float) * 3)); glEnableVertexAttribArray(1); GLuint texture[2]; glGenTextures(2, texture); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); sf::Image* imageOne = new sf::Image; bool isImageOneLoaded = imageOne->loadFromFile("Texture/container.jpg"); if (isImageOneLoaded) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageOne->getSize().x, imageOne->getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageOne->getPixelsPtr()); glGenerateMipmap(GL_TEXTURE_2D); } delete imageOne; glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture[1]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); sf::Image* imageTwo = new sf::Image; bool isImageTwoLoaded = imageTwo->loadFromFile("Texture/awesomeface.png"); if (isImageTwoLoaded) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageTwo->getSize().x, imageTwo->getSize().y, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageTwo->getPixelsPtr()); glGenerateMipmap(GL_TEXTURE_2D); } delete imageTwo; glUniform1i(glGetUniformLocation(shaderProgram, "inTextureOne"), 0); glUniform1i(glGetUniformLocation(shaderProgram, "inTextureTwo"), 1); GLenum error = glGetError(); std::cout << error << std::endl; sf::Event event; bool isRunning = true; while (isRunning) { while (window.pollEvent(event)) { if (event.type == event.Closed) { isRunning = false; } } glClear(GL_COLOR_BUFFER_BIT); if (isImageOneLoaded && isImageTwoLoaded) { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture[0]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture[1]); glUseProgram(shaderProgram); } glBindVertexArray(vao); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr); glBindVertexArray(0); window.display(); } glDeleteVertexArrays(1, &vao); glDeleteBuffers(1, &vbo); glDeleteBuffers(1, &ebo); glDeleteProgram(shaderProgram); glDeleteTextures(2,texture); return 0; } and this is the vertex shader
      #version 450 core layout(location=0) in vec3 inPos; layout(location=1) in vec2 inTexCoord; out vec2 TexCoord; void main() { gl_Position=vec4(inPos,1.0); TexCoord=inTexCoord; } and the fragment shader
      #version 450 core in vec2 TexCoord; uniform sampler2D inTextureOne; uniform sampler2D inTextureTwo; out vec4 FragmentColor; void main() { FragmentColor=mix(texture(inTextureOne,TexCoord),texture(inTextureTwo,TexCoord),0.2); } I was expecting awesomeface.png on top of container.jpg

    • By khawk
      We've just released all of the source code for the NeHe OpenGL lessons on our Github page at https://github.com/gamedev-net/nehe-opengl. code - 43 total platforms, configurations, and languages are included.
      Now operated by GameDev.net, NeHe is located at http://nehe.gamedev.net where it has been a valuable resource for developers wanting to learn OpenGL and graphics programming.

      View full story
    • By TheChubu
      The Khronos™ Group, an open consortium of leading hardware and software companies, announces from the SIGGRAPH 2017 Conference the immediate public availability of the OpenGL® 4.6 specification. OpenGL 4.6 integrates the functionality of numerous ARB and EXT extensions created by Khronos members AMD, Intel, and NVIDIA into core, including the capability to ingest SPIR-V™ shaders.
      SPIR-V is a Khronos-defined standard intermediate language for parallel compute and graphics, which enables content creators to simplify their shader authoring and management pipelines while providing significant source shading language flexibility. OpenGL 4.6 adds support for ingesting SPIR-V shaders to the core specification, guaranteeing that SPIR-V shaders will be widely supported by OpenGL implementations.
      OpenGL 4.6 adds the functionality of these ARB extensions to OpenGL’s core specification:
      GL_ARB_gl_spirv and GL_ARB_spirv_extensions to standardize SPIR-V support for OpenGL GL_ARB_indirect_parameters and GL_ARB_shader_draw_parameters for reducing the CPU overhead associated with rendering batches of geometry GL_ARB_pipeline_statistics_query and GL_ARB_transform_feedback_overflow_querystandardize OpenGL support for features available in Direct3D GL_ARB_texture_filter_anisotropic (based on GL_EXT_texture_filter_anisotropic) brings previously IP encumbered functionality into OpenGL to improve the visual quality of textured scenes GL_ARB_polygon_offset_clamp (based on GL_EXT_polygon_offset_clamp) suppresses a common visual artifact known as a “light leak” associated with rendering shadows GL_ARB_shader_atomic_counter_ops and GL_ARB_shader_group_vote add shader intrinsics supported by all desktop vendors to improve functionality and performance GL_KHR_no_error reduces driver overhead by allowing the application to indicate that it expects error-free operation so errors need not be generated In addition to the above features being added to OpenGL 4.6, the following are being released as extensions:
      GL_KHR_parallel_shader_compile allows applications to launch multiple shader compile threads to improve shader compile throughput WGL_ARB_create_context_no_error and GXL_ARB_create_context_no_error allow no error contexts to be created with WGL or GLX that support the GL_KHR_no_error extension “I’m proud to announce OpenGL 4.6 as the most feature-rich version of OpenGL yet. We've brought together the most popular, widely-supported extensions into a new core specification to give OpenGL developers and end users an improved baseline feature set. This includes resolving previous intellectual property roadblocks to bringing anisotropic texture filtering and polygon offset clamping into the core specification to enable widespread implementation and usage,” said Piers Daniell, chair of the OpenGL Working Group at Khronos. “The OpenGL working group will continue to respond to market needs and work with GPU vendors to ensure OpenGL remains a viable and evolving graphics API for all its customers and users across many vital industries.“
      The OpenGL 4.6 specification can be found at https://khronos.org/registry/OpenGL/index_gl.php. The GLSL to SPIR-V compiler glslang has been updated with GLSL 4.60 support, and can be found at https://github.com/KhronosGroup/glslang.
      Sophisticated graphics applications will also benefit from a set of newly released extensions for both OpenGL and OpenGL ES to enable interoperability with Vulkan and Direct3D. These extensions are named:
      GL_EXT_memory_object GL_EXT_memory_object_fd GL_EXT_memory_object_win32 GL_EXT_semaphore GL_EXT_semaphore_fd GL_EXT_semaphore_win32 GL_EXT_win32_keyed_mutex They can be found at: https://khronos.org/registry/OpenGL/index_gl.php
      Industry Support for OpenGL 4.6
      “With OpenGL 4.6 our customers have an improved set of core features available on our full range of OpenGL 4.x capable GPUs. These features provide improved rendering quality, performance and functionality. As the graphics industry’s most popular API, we fully support OpenGL and will continue to work closely with the Khronos Group on the development of new OpenGL specifications and extensions for our customers. NVIDIA has released beta OpenGL 4.6 drivers today at https://developer.nvidia.com/opengl-driver so developers can use these new features right away,” said Bob Pette, vice president, Professional Graphics at NVIDIA.
      "OpenGL 4.6 will be the first OpenGL release where conformant open source implementations based on the Mesa project will be deliverable in a reasonable timeframe after release. The open sourcing of the OpenGL conformance test suite and ongoing work between Khronos and X.org will also allow for non-vendor led open source implementations to achieve conformance in the near future," said David Airlie, senior principal engineer at Red Hat, and developer on Mesa/X.org projects.

      View full story
    • By _OskaR
      Hi,
      I have an OpenGL application but without possibility to wite own shaders.
      I need to perform small VS modification - is possible to do it in an alternative way? Do we have apps or driver modifictions which will catch the shader sent to GPU and override it?
  • Advertisement