Symptoms are that first unilluminated geometry appears coloured and textured momentarily, then disappears when the second illuminated geometry appears. Works OK in Firefox Minefield 3.7a1pre.

Unilluminated geometry's fragment shader

varying vec4 vViewVertex;
varying vec3 vNormal;
varying vec3 vEyeVec;
varying vec2 vTextureCoord;
uniform sampler2D uSampler0;
uniform vec3 uMaterialEmission;
uniform vec3 uAmbient;
uniform vec3 uMaterialAmbient;
void main(void) {
vec3 emissionValue=uMaterialEmission;
vec3 ambientValue=uAmbient;
float alpha = 1.0;
float mask=1.0;
vec4 texturePos;
vec2 textureCoord=vec2(0.0,0.0);
texturePos = vec4(vTextureCoord.s, vTextureCoord.t, 1.0, 1.0);
textureCoord=texturePos.xy;
emissionValue = emissionValue * texture2D(uSampler0, vec2(textureCoord.x, 1.0 - textureCoord.y)).rgb;
vec4 colourValue = vec4(emissionValue + (ambientValue * uMaterialAmbient), 1);
gl_FragColor = colourValue;
}

Illuminated geometry's fragment shader

varying vec4 vViewVertex;
varying vec3 vNormal;
varying vec3 vEyeVec;
uniform vec3 uMaterialEmission;
uniform vec3 uAmbient;
uniform vec3 uMaterialAmbient;
uniform vec3 uMaterialDiffuse;
uniform vec3 uMaterialSpecular;
uniform float uMaterialShininess;
uniform vec3 uLightAmbient0;
uniform vec3 uLightDiffuse0;
uniform vec3 uLightSpecular0;
uniform vec4 uLightPos0;
uniform vec3 uLightSpotDir0;
uniform vec3 uLightAttenuation0;
varying vec3 vLightVec0;
varying float vLightDist0;
uniform vec3 uLightAmbient1;
uniform vec3 uLightDiffuse1;
uniform vec3 uLightSpecular1;
uniform vec4 uLightPos1;
uniform vec3 uLightSpotDir1;
uniform vec3 uLightAttenuation1;
varying vec3 vLightVec1;
varying float vLightDist1;
uniform vec3 uLightAmbient2;
uniform vec3 uLightDiffuse2;
uniform vec3 uLightSpecular2;
uniform vec4 uLightPos2;
uniform vec3 uLightSpotDir2;
uniform vec3 uLightAttenuation2;
varying vec3 vLightVec2;
varying float vLightDist2;
uniform vec3 uFogColor;
uniform float uFogDensity;
uniform float uFogStart;
uniform float uFogEnd;
void main(void) {
vec3 emissionValue=uMaterialEmission;
vec3 ambientValue=uAmbient;
float attenuation = 1.0;
vec3 diffuseValue=uMaterialDiffuse;
vec3 specularValue=uMaterialSpecular;
float shininessValue=uMaterialShininess;
float alpha = 1.0;
float mask=1.0;
vec4 texturePos;
vec2 textureCoord=vec2(0.0,0.0);
vec3 lightVec;
float dotN;
float spotFactor;
float pf;
vec3 diffuseWeighting = 0.0;
vec3 specularWeighting = 0.0;
lightVec = normalize(vLightVec0);
dotN = max(dot(vNormal, -lightVec), 0.0);
if (dotN > 0.0) {
attenuation = 1.0 / (uLightAttenuation0[0] + uLightAttenuation0[1] * vLightDist0 + uLightAttenuation0[2] * vLightDist0 * vLightDist0);
diffuseWeighting += dotN * uLightDiffuse0 * attenuation;
}
ambientValue += uLightAmbient0;
lightVec = normalize(vLightVec1);
dotN = max(dot(vNormal, -lightVec), 0.0);
if (dotN > 0.0) {
attenuation = 1.0 / (uLightAttenuation1[0] + uLightAttenuation1[1] * vLightDist1 + uLightAttenuation1[2] * vLightDist1 * vLightDist1);
diffuseWeighting += dotN * uLightDiffuse1 * attenuation;
}
ambientValue += uLightAmbient1;
lightVec = normalize(vLightVec2);
dotN = max(dot(vNormal, -lightVec), 0.0);
if (dotN > 0.0) {
attenuation = 1.0 / (uLightAttenuation2[0] + uLightAttenuation2[1] * vLightDist2 + uLightAttenuation2[2] * vLightDist2 * vLightDist2);
diffuseWeighting += dotN * uLightDiffuse2 * attenuation;
}
ambientValue += uLightAmbient2;
ambientValue /= 3;
vec4 colourValue =vec4(emissionValue + (ambientValue * uMaterialAmbient) + (diffuseWeighting * diffuseValue) + (specularWeighting * specularValue), 1);
float fogFact=1.0;
fogFact=clamp((uFogEnd - length(-vViewVertex.xyz)) / (uFogEnd - uFogStart), 0.0, 1.0);
gl_FragColor = colourValue * fogFact + vec4(uFogColor, 1) * (1.0 - fogFact);
}

Text node in bitmap mode displays nothing. Texture image is created, but texture appears to not be applied.

Program activation listeners will lazy-load their defaults.

What to do with user-defined vars?

Maybe something along the lines of:

vectorInterpolator({
type:"linear",
input:"alpha",
output:"position",
keys: [0.0, 0.2, 0.5, 0.7, 0.9, 1.0],
values: [
{ x: 0.0, y: 0.0, z: 0.0 },
{ x: 0.3, y: 0.0, z: 0.6 },
{ x: 3.0, y: 4.0, z: 5.5 },
{ x: 5.0, y: 0.5, z: 6.0 },
{ x: 0.4, y: 0.0, z: 0.3 }],
}

..wherever they occur

IDE:
http://tinyurl.com/ylz948a

Log:
http://img163.imageshack.us/img163/8651/screenshot20100330at223.png

I coudn't select the text. OSX + chromium (30:th mars build)

The super transform's matrix is reinserted into the shader every time a modelling transform node is exited during traversal. We could save on this by just lazy-inserting the current matrix held on the backend before geometry node processing, if it is not currently inserted.

Good for deeply nested transform hierarchies!

Same way as for assets. Need to optimise geometry data, ie. no flattening maybe

For some reason the end output value in the interpolator is set to null instead of the last value. This means that when interpolating the last key value is never reached. This makes the end result inconsistent as it is currently implemented.

https://github.com/xeolabs/scenejs/blob/master/src/scenejs/interpolation/interpolator.js#L189
I can see that it was there previously but it's commented out. Was this causing issues with some other part of the interpolator?

The with operator seems to be the problem

It's going to be hard to get everyone to stop using setInterval but could you consider not using it in your SceneJS? setInterval is bad because it runs regardless of whether your app is visible. That means even in a hidden tab your WebGL app is running full speed, taking up CPU and eating battery.

Firefox, Chrome and Webkit have implemented requestAnimationFrame to solve this problem. You can use it in a cross browser way with this small snippet of JavaScript.

https://cvs.khronos.org/svn/repos/registry/trunk/public/webgl/sdk/demos/common/webgl-utils.js

You don't have to use that snippet. you could write your own. It just seems like it would be a good idea to not propagate bad practices if possible.

Useful for throttling to conserve CPU while loading content.

SceneJS.withNode("my-scene").set("fps", 20);

In the latest v8.0 source, scenes that have lines and non-line primitives break if the lines don't have normals -- the non-line primitives appear not to be shaded.

Add the following to basic-scene.js (in the hello-teapot example), just before the example translation node:
{ type: "material", baseColor: { r:1 }, emit: 1,
nodes: [
{ type: "geometry", primitive:"lines",
positions: [ 0,0,0, 0,0,15, 0,15,0, 15,0,0],
normals: [ 1,0,0, 1,0,0, 1,0,0, 1,0,0 ],
indices: [0,1, 0,2, 0,3, ]
}
]
},

This works as intended: Draws the axes in red.

Remove the normals, and it breaks: The teapot is black.

Tried in both the "transparency" example and the "basic-picking" example. If every group of objects is set to have transparent flag set to true then all objects in the scene lose their transparency and become opaque.

Here's the basic-picking.js example: https://gist.github.com/775448

On this page
http://scenejs.wikispaces.com/geometry#x-Vertex%20Colors
I think the first line of the color code should be
1.0, 0.0, 0.0, 1.0, [...]
and not
1.0, 0.0, 0.0, 1.5, [...]

In SceneJS._rendererModule, we create a pick buffer for each pick, unbind it afterwards, but never actually delete it. This creates an increasing use of memory for each pick!

Should ideally re-use the buffer.

Implement a post-processing node of some sort, to specify how the rendered subgraph image is processed to add blur effects etc.

When you remove a node as in the example from the wiki:

SceneJS.withNode("my-node")
.remove({
nodes: ["my-rotate"] // Remove from the "nodes" attribute
});

It deletes all the nodes under "my-node".

Note that the resource attributes of both of these geometries share the same value, which is illegal because the inner one inherits the positions and normals of the outer. It should not try to reuse them, just inherit.

[
{
type: "geometry"
resource: "my-vbo",
positions: p
normals: normals
nodes: [
{
type: "geometry"
resource: "my-vbo",
primitive: "triangles"
indices: i[0]
}
]
}
]

Automatically generate GLSL shaders depending on what;s in scene graph?

http://hacksoflife.blogspot.com/2008/12/fun-with-bershaders.html

V0.3.0 - nested material nodes cause nothing to be visible

Reproducible in basic teapot example.

Koji Ligura reports:

At this page: http://scenejs.wikispaces.com/geometry, on the front face, v0's normal vector is (x,y,z)=(0, 0, -1).

Why it is not (0,0,+1)?

In SceneJS, should normal vector towards inside?

To fix:

• reverse normals on built-in primitives
• reverse normals in GLSL shading calculations

Ie.

SceneJs.boundary({
xmin: -10.0, ymin: -10.0, zmin: -10.0,
xmax: 10.0, ymax: 10.0, zmax: 10.0
},
SceneJs.asset({
uri: "http://wherever.com/assets/myAsset.js"
})
)

In chrome (both the beta and latest unstable 10.0.648.11 dev) the console gives this error:

scenejs.js:3863 gl.disable(gl.BLEND);
scenejs.js:3863 gl.blendFunc(gl.SRC_ALPHA, gl.LESS);
scenejs.js:6715 s0: WebGL error calling blendFunc on WebGL canvas context - see console log for details

Happens with both master v0.7.9 and v0.8 branches

This is a long shot, but perhaps gl.blendFunc(gl.SRC_ALPHA, gl.LESS); is illegal after gl.disable(gl.BLEND);

It looks like interpolator nodes only work properly if there is at least 1 such node that has a first key time as 0. If no interpolator with an initial key time of 0 is seen then the interpolator nodes will not switch out of the STATE_BEFORE state, never getting to the STATE_RUNNING.

An easy way to see this behaviour is to take the pouring-teapot example and remove all but 2 of the interpolator nodes. Leave only these 2 nodes, and no animation will play

{
  type: "interpolator",
  mode:"linear",
  target: "stretch",
  targetProperty: "y",
  keys: [2.0, 3.0, 4.0, 5.0],
  values: [1.0, 2.0, .3, 1.0],
  once: true
},
{
   type: "interpolator",
   mode:"linear",
   target: "stretch",
   targetProperty: "x",
   keys: [2.5, 3.5, 4.5, 5.5],
   values: [1.0, 3.0, .1, 1.0],
   once: true
}

If you change the first key from 2.0 to 0.0, then both animations will play.

Implement the destroy method on the morphGeometry node

In firefox 4 beta 10 with the "master" branch (0.7.9) and the v0.8 branch:

Error: uncaught exception: SceneJS.errors.WebGLNotSupportedException: Canvas document element with ID 'gameCanvas' failed to provide a supported WebGL context
Warning: WebGL: Can't get a usable WebGL context 
Source File: file:///home/snow/projects/active/web/erased/scenejs.js Line: 6971

webgl.enabled_for_all_sites is enabled in about:config

Candidate frameworks so far are:
ActiveJS,
JavaScriptMVC
...

Observer lazy-loaders only use program when they hear of its activation - no need to check

If we have thin objects, they are very difficult to pick, requiring pixel perfect mouse precision. So we could define some kind of pick area, maybe a new node type, that encompasses the thin object.

Right now setting the transparent flag to true and having the alpha 0 of a material makes my object invisible but it also makes it unpickable.

From Terrance:

Once the text support is improved, that somehow features of the canvas text be available through the SceneJS text node.

For example, https://developer.mozilla.org/en/Drawing_text_using_a_canvas has textAlign and textBaseline listed. It would be nice when creating a text node to be able to set all those options in the config. Similar to how font and size are handle now.

Half-baked idea - instead of binding only the VBOs for the pair of targets enclosing the current morph factor, why not attempt to bind all targets? The shader would have attributes for say, ten targets, to use as many of those as required.

From ethos - Using Firefox 4, my JavaScript error console is filling up with the
following error message using 0.8:

blendFunc: dfactor: invalid enum value 0x201 Line: 11685

For example, triangle with RGB vertices:

{
type: "geometry",
vertices: [ .. three verts ... ],
colors: [
1, 0,0, 1
0, 1, 0, 1,
0, 0, 1, 1
],
indices: [... ]
}

See comment: 2465ffe#src/scenejs/transformation/modelView/rotate.js-P163

The condition in rotate node _render to determine if the rotation axis is non-zero incorrectly deals with rotation axes that have negative components.

http://scenejs.org/dist/curr/extr/examples/basic-picking/index.html

The names for left-right blue and green spheres look to be swapped.

I think the camera eye Z used to be negative which would make sense for the names.

After adding:

SceneJS.withNode("root").bind("picked", function(event) {
var params = event.params;
alert("Picked 'root' at coords " + params.canvasX + ", " + params.canvasY);
});

We know the coordinates of the mouse, but would like to know the node ID of the picked node.

Can e.g. 'params.nodeID' be added to the event?

When the event has the node ID, you only need to bind a function to the 'root' of the scene, instead of to each node you're interested in.

The select-teapot example shows this uncaught exception being thrown for the textures created for the text nodes being rendered. Looks like somehow the texture nodes _scene fields are set to point back to themselves rather than the actual scene.

Everything else in the framework tests OK.
The previous version of SceneJS works fine.
The only area unverified in this version is the matrix transforms, so that's where the problem must lie.

Support query of the boundary of a subtree, ie. containing all the geometries within a subtree after they have been instanced by their modelling transforms.

Eg. SceneJS.withNode("my-node").getBoundary()

• requires that boundary be cached on the query node,
• which in requires that boundary be uncached after updates to transforms or graph topology within the subtree

Maybe like this:

SceneJS.replaceNode({
"some-node",
node: {
type: "node",
//..
}
});

Taking a look at the pouring-teapot example and the teapot doesn't move. No nodes are getting added to the compilation queue so no compilation is done.

Maybe sunrise and sunset, or a light moving between objects

I made the old change to use Number.MAX_VALUE and Number.MIN_VALUE what I didn't realize that Number.MIN_VALUE is actually the smallest non-zero positive number available in JavaScript (why that is useful I don't know) and not actually the smallest number available in JavaScript.

The proper MAX/MIN to use for comparison are Number.POSITIVE_INFINITY and Number.NEGATIVE_INFINITY.

Looks like this:

/** @private */
SceneJS._math_MAX_DOUBLE = Number.POSITIVE_INFINITY;
/** @private */
SceneJS._math_MIN_DOUBLE = Number.NEGATIVE_INFINITY;

Did some testing and those seem to work properly in comparisons.

Live example in IDE: http://tinyurl.com/yj6rsbb

Works OK in Minefield 3.7a1pre

Backends that cache things (such as geometry's VBOs, asset node etc) can have an evict() method, so that SceneJS can periodically call that across all such backends, or whenever VRAM gets full (on a GL out-of-memory error). Each backend will manage its own eviction policy.

With sections for live examples, developer's, downloads.

Using JQuery, but with no MVC framework yet.

The recompilation trigger rules are not fully tested yet - so when using v0.8, the trick is to start with compilation off, then switch it on and see if everythings still behaving right in your scene.

This actually needs to be switched off by default.

More info: http://scenejs.wikispaces.com/Scene+Graph+Compilation