PDA

View Full Version : GL4 Drivers?



glfreak
03-16-2010, 11:22 AM
Any is any "major" IHV going to release GL4 drivers soon?

With more robust features being added, how stable the drivers will be?

Ilian Dinev
03-16-2010, 11:45 AM
Wait for 26th March :)

glfreak
03-16-2010, 01:35 PM
2010? Just kidding...

dorbie
03-16-2010, 04:12 PM
Where's this information from?

Groovounet
03-16-2010, 04:25 PM
nVidia announced OpenGL 4.0 drivers at GTX 480 launch... yes seriously.

Probably super beta drivers but that already something.

Alfonse Reinheart
03-16-2010, 04:31 PM
nVidia announced OpenGL 4.0 drivers at GTX 480 launch... yes seriously.

That's not surprising. They're usually pretty fast with GL implementations.

Then again, they did just recall a driver that destroys people's GPUs. So maybe they have more important things to worry about ;)

glfreak
03-17-2010, 08:12 AM
Any news from ATI? Intel? ppl working there on drivers?

Pierre Boudier
03-17-2010, 10:49 AM
keep posted for the official anouncement and availability for AMD, but it will happen quickly.

barthold
03-18-2010, 12:14 PM
OpenGL 3.3 drivers are available now for download.

http://developer.nvidia.com/object/opengl_driver.html

OpenGL 4.0 will be supported with Fermi GPUs once available.

Barthold
(with my NVIDIA hat on)

skynet
03-18-2010, 05:06 PM
Thanks, Barthold!

Do you know the differences to 196.21 regarding UBOs?

I installed 197.15 an hour ago and already get into trouble with my UBO code. It seems, the new driver is now handling unreferenced uniform blocks (or unused single uniforms inside a block) in a different way.

I'm using a "fake shader" just to be able to retrieve all uniform offsets within my two "built in" blocks at the startup of the program.



// these are the two uniform blocks I prefix to all shaders in my system
uniform Model {
mat4 ModelViewProjectionMatrix;
mat4 ModelViewMatrix;
mat4 ModelMatrix;
mat3 NormalMatrix;
};
uniform View {
mat4 ProjectionMatrix;
mat4 ViewMatrix;
};

// this is the code that fails for uniforms which are not referenced by a shader:

// I indeed get a valid indices for all the uniforms!
GLuint uniformindex=-1;
glGetUniformIndices(program, 1, &uniformname, &uniformindex);

// now passing the valid index into glGetActiveUniformsiv fails with GL_INVALID_VALUE???
// (for referenced uniforms, the call works as expected and retrieves the offset)
GLint offset=-1;
glGetActiveUniformsiv(program, 1, &uniformindex, GL_UNIFORM_OFFSET, &offset);



Does this mean, I should try to change the fake shader in a way it somehow references _all_ uniforms?

barthold
03-18-2010, 11:33 PM
Skynet, we'll take a look.

Alfonse Reinheart
03-18-2010, 11:36 PM
I'm using a "fake shader" just to be able to retrieve all uniform offsets within my two "built in" blocks at the startup of the program.

You're doing it wrong if you're expecting it to work based on the spec.

Only with "shared" or "std140" are you given the guarantee that the offsets from one uniform block in one program will be the same as another. You didn't specify one, so the default is "packed".

skynet
03-19-2010, 03:15 AM
This is what GLSL 1.5 specs say:


The initial state of compilation is as if the following were declared:
layout(shared, column_major) uniform;
Explicitly declaring this in a shader will return defaults back to their initial state.

So, how did I get that wrong?
But just to be sure, I'll include the layout specifier.

Alfonse Reinheart
03-19-2010, 11:39 AM
Oh, sorry. My mistake.

barthold
03-19-2010, 12:43 PM
Skynet, bug was found and fixed. The fix will be in the upcoming driver release. Sorry about that.

Barthold
(with my NVIDIA hat on)

skynet
03-19-2010, 02:19 PM
One word: Cool!
:-D

oscarbg
03-20-2010, 04:49 PM
Questions to nvidia:
*Is Nvidia going to expose ext_gpu_shader_fp64 on GT2xx hardware with double precision or is for d3d11 hardware?
For example gtx275
AMD seems to support double precision on GLSL via doublepAMD even on 4850 cards..
Also is Nvidia with initial GL 4.0 drivers going to finally expose documentation for wgl_nv_dx_interop and have the shown at gtc texture writting and random access support?
via ext_image_load_store?

Dark Photon
03-20-2010, 08:32 PM
Questions to nvidia:
*Is Nvidia going to expose ext_gpu_shader_fp64 on GT2xx hardware with double precision or is for d3d11 hardware?
Hope so, since CUDA has been supporting on-GPU doubles for Geforce 8+ cards for a long while now IIRC, on the last two generations of cards at least (both pre-DX11):

* https://visualization.hpc.mil/wiki/Enabling_Double_Precision_Support

If they don't, blame Marketing/Sales.

Eosie
03-25-2010, 03:55 PM
AMD is the first to have released a GL4 driver:

http://support.amd.com/us/kbarticles/Pages/Catalyst-OpenGL-preview-driver.aspx

Ilian Dinev
03-26-2010, 10:50 AM
Thanks for the heads-up!
And kudos to the ATi driver-team for the timing.
Things are looking up!

Eosie
03-26-2010, 11:22 AM
According to Geeks3D, there are 20 new extensions. (http://www.geeks3d.com/20100326/ati-catalyst-10-3-opengl-4-0-driver-20-new-opengl-extensions/?utm_source=feedburner&utm_medium=feed&utm_campaig n=Feed%3A+TheGeeksOf3d+%28The+Geeks+Of+3D%29)

oscarbg
04-06-2010, 11:23 AM
Any hope of having "precise" qualifier outside of GPU_EXT_shader5 extension? it's not a gpu feature only a compiler fature..
i.e. for not only fermi and cypress gpus I want in gt200 for example..
it's not good since double precision emulation on d3d10 gpus using
float-float approaches gets optimized by Nvidia compiler!
Example code optimized:

vec2 dblsgl_add (vec2 x, vec2 y)
{
precise vec2 z;
float t1, t2, e;

t1 = x.y + y.y;
e = t1 - x.y;
t2 = ((y.y - e) + (x.y - (t1 - e))) + x.x + y.x;
z.y = e = t1 + t2;
z.x = t2 - (e - t1);
return z;
}

vec2 dblsgl_mul (vec2 x, vec2 y)
{
precise vec2 z;
float up, vp, u1, u2, v1, v2, mh, ml;

up = x.y * 4097.0;
u1 = (x.y - up) + up;
u2 = x.y - u1;
vp = y.y * 4097.0;
v1 = (y.y - vp) + vp;
v2 = y.y - v1;
//mh = __fmul_rn(x.y,y.y);
mh = x.y*y.y;
ml = (((u1 * v1 - mh) + u1 * v2) + u2 * v1) + u2 * v2;
//ml = (fmul_rn(x.y,y.x) + __fmul_rn(x.x,y.y)) + ml;

ml = (x.y*y.x + x.x*y.y) + ml;

mh=mh;
z.y = up = mh + ml;
z.x = (mh - up) + ml;
return z;
}