I've had a lot of trouble with WebGL shader code working on my Windows
machine and failing on a Macbook Pro and Ubuntu, all with NVIDIA
graphics and drivers.

I did a lot of work to ensure that I send to each of the many shaders
only that data that is actually referenced and used by that particular
shader, and this change made mouse picking and transparency work again
on all platforms. Moral of the tale: don't send anything from CPU to
shaders that the shaders aren't going to use, even though this works
okay on Windows. It seems to me that the shader compilers in the Mac
and Ubuntu drivers are wrong, but at least now I know what to do to
preserve cross-platform compatibility.

In other news, over the last couple of weeks I had intensive
discussions with David Scherer about the GlowScript API for creating
your own models out of triangles or quads and dynamically modifying
them to change the shape of the object. I'm working toward a major
release, 1.0. Some time ago I posted an example of a pulse moving
along a rug, which has been rewritten with the new API:

http://www.glowscript.org/#/user/Bruce_Sherwood/folder/Pub/program/Rug

To take the rug as a specific example, I create a set of vertices
covering the rug in a rectangular pattern. I then create quad objects
for each group of 4 vertices, with vertices internal to the rug shared
among 4 adjacent quads. The animation of the pulse running along the
rug is then done simply by modifying the vertices, with no need to
think about the quads that make the display. Take a look at the
CoffeeScript source code for the rug; it's now quite simple.

Bruce

David Scherer made this interesting comment about shader compilers:

"If I had to guess, on Windows you are using Angle
(http://code.google.com/p/angleproject/issues/list), a library that
maps opengl to directx that is being developed at least largely for
webgl, and thus has a big focus on correctness, robustness, security.
On the other platforms you are probably using the hardware opengl
drivers, which have a big focus on running the latest games really
fast.

If you ask me, the OpenGL design decision to make the shader compiler
part of the driver was insane."

It is true that some of the Windows implementations are coverting everything to Direct X, a strategy that is typical MS and as insane as anything anyone else might try.

The supposed downside of having the drivers compile the shaders is the time it takes compared to downloading compiled code but that is less of a problem these days and makes portability much easier. Nvidia made a big deal of the fact that Cg used compiled shader code but it's not clear it matters to many people.

With all the issues you've had pushing the boundaries with WebGL, it's not been clear where the problem really lies. Is it drivers or something in the browsers or the memory architecture of particular GPUs. Fortunately, the future should be a lot better since WebGL is taking off.

Ed
__________

Ed Angel

Founding Director, Art, Research, Technology and Science Laboratory (ARTS Lab)
Professor Emeritus of Computer Science, University of New Mexico

1017 Sierra Pinon
Santa Fe, NM 87501
505-984-0136 (home)                     an...@cs.unm.edu
505-453-4944 (cell)                             http://www.cs.unm.edu/~angel

On May 17, 2012, at 9:46 AM, Bruce Sherwood wrote:

Fascinating!

I looked at the CS code and it made a lot of sense.  What wasn't clear is
the GPU interactions.

So in terms of data sent to the shader, I'm guessing you send just the
vertices to your vertex attribute buffer, so you don't have to store
multiple copies of the same vertex in the GPU.  You then have a pretty
sophisticated binding of these vertices to the image for texture drawing.
 Is that right?  .. or do you have to replicate the vertices to keep the
shaders simple?

Just as a point of interest, where *are* the shaders?  My guess is that
GlowScript has a set of standard shaders and separate program objects for
standard use.

CS/GS certainly are very readable.

   -- Owen

On Thu, May 17, 2012 at 9:33 AM, Bruce Sherwood <bruce.sherw...@gmail.com>wrote:

I should add that I'm working toward an imminent "1.0" release that
will include the vertex machinery and some other significant
enhancements, including a "compound' object originally designed by
Scherer: You give a list of (existing) objects and all of the
triangles are merged into one list to be rendered very efficiently as
one object (and with the same position/color/axis/size/up attributes
of the built-in objects).

Bruce

The evidence strongly suggests that it is the compiler in the drivers.
The problems I saw on Mac and Ubuntu were present on multiple browsers
on those platforms, and they went away when (as of yesterday) I
stopped sending to a shader data that the particular shader didn't
use. Also, the architecture of the three NVIDIA cards on my three
machines is presumably similar.

Bruce

I see that I didn't really address your question about "where are the
shaders". Currently to build a new version of GlowScript, which runs
in the Google App Engine, I run a short Python program which reads up
all the shader programs from the shader folder and puts them into one
minimized file, from which they are read at execution time.

I'll mention that for an official (non-dev) release, we package up all
the files, in minimized form, with a version number. You may have
noticed a header line "GlowScript 0.7" or some such for each user
program. If you specify an older version, it should still run, because
we keep the old libraries by version number.

Bruce