pseudostereo

According to the list of messages for jit.gl.sketch, it understands the messages "screentoworld" and "worldtoscreen". Using these messages with jit.gl.render in a javascript is fairly straightforward, but I'd like to be able to use them with jit.gl.sketch, so that I can simultaneously make use of all the opengl goodies contained therein.

However, I can't figure out how this might work.

Below are two javascripts. The first is a working example using jit.gl.render. The second is my pathetic best shot at trying to get the same thing to work with jit.gl.sketch.

mouseidle = check for intersection with object

The jit.gl.render example works fine. Not even close with jit.gl.sketch.

I'll hazard a guess that the screentoworld message only keeps track of sketch attributes, not opengl commands. But if that's right, how can it be used with jit.gl.sketch at all?

var myObject = new JitterObject("jit.gl.gridshape","myContext");

myObject.position = [Math.random()-0.5,Math.random()-0.5,Math.random()-0.5];

var myHandle = new JitterObject("jit.gl.handle","myContext");

var myRender = new JitterObject("jit.gl.render","myContext");

var myWindow = new JitterObject("jit.window","myContext");

var listener = new JitterListener("myContext",callback);

    myRender.position = myHandle.position;

    myRender.rotate = myHandle.rotate;

    var intersectpoint = new Array();

    var raystart = myRender.screentoworld(x,y);        

    var rayend = myRender.screentoworld(x,y,1.);

    if (event.eventname=="mouseidle") {

        if (Jitter3DUtils.intersect_line_sphere(raystart, rayend, myObject.position, myObject.scale[0], intersectpoint)) {    

            post ("intersect object1: "+ intersectpoint,"n");

            myObject.color = [1,0,0];

            myObject.color = [0.5,0.5,0.5];

var mySketch = new JitterObject("jit.gl.sketch","myContext");

var myPosition = [Math.random()-0.5,Math.random()-0.5,-0.5];

    mySketch.glmatrixmode("projection");

    mySketch.glmatrixmode("modelview");

    mySketch.gltranslate(myHandle.position);

    mySketch.glrotate(myHandle.rotate);

    mySketch.drawobject(myObject.name,1);

    var raystart = mySketch.screentoworld(x,y);        

    var rayend = mySketch.screentoworld(x,y,1.);

        if (Jitter3DUtils.intersect_line_sphere(raystart, rayend, mySketch.position, mySketch.scale[0], intersectpoint)) {    

            myColor = [1,0,0];

            myColor = [0.5,0.5,0.5];

According to the list of messages for jit.gl.sketch, it understands the messages "screentoworld" and "worldtoscreen".  Using these messages with jit.gl.render in a javascript is fairly straightforward, but I'd like to be able to use them with jit.gl.sketch, so that I can simultaneously make use of all the opengl goodies contained therein. 

However, I can't figure out how this might work. 

Below are two javascripts. The first is a working example using jit.gl.render. The second is my pathetic best shot at trying to get the same thing to work with jit.gl.sketch. 

In both scripts, the idea is
mousedown = manipulate jit.gl.handle
mouseidle = check for intersection with object

I'll hazard a guess that the screentoworld message only keeps track of sketch attributes, not opengl commands. But if that's right, how can it be used with jit.gl.sketch at all? 

//begin renderHitTest.js
var myObject = new JitterObject("jit.gl.gridshape","myContext");
myObject.shape = "torus";
myObject.scale = [0.25,0.25,0.25];
myObject.position = [Math.random()-0.5,Math.random()-0.5,Math.random()-0.5];
myObject.lighting_enable = 1;
myObject.automatic = 1;
var myHandle = new JitterObject("jit.gl.handle","myContext");
myHandle.inherit_transform = 1;
var myRender = new JitterObject("jit.gl.render","myContext");
var myWindow = new JitterObject("jit.window","myContext");
myWindow.depthbuffer = 1;
var listener = new JitterListener("myContext",callback);

function bang() {
	myRender.position = myHandle.position;
	myRender.rotate = myHandle.rotate;
	myRender.erase();
	myRender.drawswap();	
}

//begin sketchHitTest.js
var myObject = new JitterObject("jit.gl.gridshape","myContext");
myObject.shape = "torus";
myObject.scale = [0.25,0.25,0.25];
myObject.position = [Math.random()-0.5,Math.random()-0.5,Math.random()-0.5];
myObject.automatic = 0;
myObject.name = "roundy"
var mySketch = new JitterObject("jit.gl.sketch","myContext");
mySketch.lighting_enable = 1;
var frust = [-1.33,1.33,-1,1,1.5,120];
var look = [0,0,3,0,0,0,0,1,0];
var myPosition = [Math.random()-0.5,Math.random()-0.5,-0.5];
var myScale = [0.5,0.5,0.5];
var myColor = [0.5,0.5,0.5];
var myHandle = new JitterObject("jit.gl.handle","myContext");
var myRender = new JitterObject("jit.gl.render","myContext");
var myWindow = new JitterObject("jit.window","myContext");
myWindow.depthbuffer = 1;
var listener = new JitterListener("myContext",callback);

function bang() {
	mySketch.reset();
	mySketch.glclear();
	mySketch.glmatrixmode("projection");
	mySketch.glloadidentity();
	mySketch.glfrustum(frust);
	mySketch.glmatrixmode("modelview");
	mySketch.glloadidentity();
	mySketch.glulookat(look);
	mySketch.gltranslate(myHandle.position);
	mySketch.glrotate(myHandle.rotate);
	mySketch.moveto(myPosition);
	mySketch.glscale(myScale);
	mySketch.color = myColor;
	mySketch.drawobject(myObject.name,1);
	myRender.erase();
	myRender.drawswap();	
}

using-screentoworld-with-jit-gl-sketch-in-js

On Mar 13, 2007, at 1:50 PM, Perry Hoberman wrote:

> I'll hazard a guess that the screentoworld message only keeps track 

> of sketch attributes, not opengl commands. But if that's right, how 

> can it be used with jit.gl.sketch at all?

Use underdocumented "immediate" attribute for jit.gl.sketch (set to 

1). Otherwise, jit.gl.sketch uses a cached commandlist, and such 

screentoworld calls can't exist and be used within the cached list.

> I'll hazard a guess that the screentoworld message only keeps track  
> of sketch attributes, not opengl commands. But if that's right, how  
> can it be used with jit.gl.sketch at all?

Use underdocumented "immediate" attribute for jit.gl.sketch (set to  
1). Otherwise, jit.gl.sketch uses a cached commandlist, and such  
screentoworld calls can't exist and be used within the cached list.

Thanks Joshua, but I'm not managing to get 'immediate' to work.

In the js below, when 'immediate' is set to 1, the torus disappears; when it's set back to 0 it reappears.

var myObject = new JitterObject("jit.gl.gridshape","myContext");
myObject.shape = "torus";
myObject.scale = [0.25,0.25,0.25];
myObject.position = [Math.random()-0.5,Math.random()-0.5,Math.random()-0.5];
myObject.automatic = 0;
myObject.name = "roundy"
var mySketch = new JitterObject("jit.gl.sketch","myContext");
mySketch.lighting_enable = 1;
mySketch.immediate = 1;
var myPosition = [Math.random()-0.5,Math.random()-0.5,-0.5];
var myScale = [0.5,0.5,0.5];
var myColor = [0.5,0.5,0.5];
var myHandle = new JitterObject("jit.gl.handle","myContext");
var myRender = new JitterObject("jit.gl.render","myContext");
var myWindow = new JitterObject("jit.window","myContext");
myWindow.depthbuffer = 1;

function bang() {
	mySketch.reset();
	mySketch.glclear();
	mySketch.gltranslate(myHandle.position);
	mySketch.glrotate(myHandle.rotate);
	mySketch.moveto(myPosition);
	mySketch.glscale(myScale);
	mySketch.color = myColor;
	mySketch.drawobject(myObject.name,1);
	myRender.erase();
	myRender.drawswap(); 
}

function immediate(a) {
	mySketch.immediate = a;
}


On Mar 13, 2007, at 3:42 PM, Perry Hoberman wrote:

> Thanks Joshua, but I'm not managing to get 'immediate' to work.

> In the js below, when 'immediate' is set to 1, the torus 

> disappears; when it's set back to 0 it reappears.

Since there is no cached command list, immediate work as follows:

- makes the drawing calls immediately when called

So you want to change your routine to the following (removed 

I'm not 100% sure that mySketch.color will update properly, but with 

immediate you can now intersperse object attr setting between draw 

commands. You can also query information OpenGL state information 

    mySketch.drawobject(myObject.name);

Let me know which one works w/r/t color, since I've got my head in 

>
> Thanks Joshua, but I'm not managing to get 'immediate' to work.
>
> In the js below, when 'immediate' is set to 1, the torus  
> disappears; when it's set back to 0 it reappears.

- no need to reset
- makes the drawing calls immediately when called
- is not drawn in the drawswap

So you want to change your routine to the following (removed  
redundant glclear call):

function bang() {
	myRender.erase();
	mySketch.gltranslate(myHandle.position);
	mySketch.glrotate(myHandle.rotate);
	mySketch.moveto(myPosition);
	mySketch.glscale(myScale);
	mySketch.color = myColor;
	mySketch.drawobject(myObject.name,1);
	myRender.swap();
}

I'm not 100% sure that mySketch.color will update properly, but with  
immediate you can now intersperse object attr setting between draw  
commands. You can also query information OpenGL state information  
with glget.

	myobject.color = myColor;
	mySketch.drawobject(myObject.name);

Let me know which one works w/r/t color, since I've got my head in  
the sand at the moment.

OK, 'immediate' doesn't seem to pay much attention to attributes -- 'mySketch.lighting_enable = 1' and 'mySketch.smooth_shading = 1' don't have any effect. Everything's fine when I use the equivalent gl commands, though.

On the other hand, mySketch.glcolor() doesn't have any effect, but mySketch.color = works fine.

'myRender.swap' does not work however (nothing ever draws) - anyway I'm not sure what you mean by 'is not drawn in the drawswap' - does it mean it's not buffered offscreen?

Also, what can you get with glget - I realize that it can retrieve the projection and modelview matrices, but is there other state information that it can retrieve?

to sum up, here's what's currently working for me:

    mySketch.gltranslate(myPosition);

although I still can't get screentoworld to report accurately where the object is - I guess I'm not sure what to put in the call to Jitter3DUtils.intersect_line_sphere - I've been using mySketch.position and mySketch.scale[0], but that doesn't seems to work.

function bang() {
	myRender.erase();
	mySketch.glenable("lighting");
	mySketch.glenable("light0");
	mySketch.glshademodel("smooth");
	mySketch.gltranslate(myHandle.position);
	mySketch.glrotate(myHandle.rotate);
	mySketch.gltranslate(myPosition);
	mySketch.glscale(myScale);
	mySketch.color = myColor;
	mySketch.drawobject(myObject.name,1);
	myRender.drawswap(); 
}

On Mar 13, 2007, at 5:05 PM, Perry Hoberman wrote:

> OK, 'immediate' doesn't seem to pay much attention to attributes -- 

> 'mySketch.lighting_enable = 1' and 'mySketch.smooth_shading = 1' 

> don't have any effect. Everything's fine when I use the equivalent 

Yes. You need to do these sorts of things with immediate mode, which 

is nothing more than direct calling of the commands. We could add 

some useful "drawsetup" type command I suppose, but we won't get to 

far on this any time soon, since it's a low priority feature as 

> On the other hand, mySketch.glcolor() doesn't have any effect, but 

Hmmm. That sounds odd. glcolor should have an effect at least for 

primitives, but perhaps not for drawing objects.

> 'myRender.swap' does not work however (nothing ever draws) - anyway 

> I'm not sure what you mean by 'is not drawn in the drawswap' - does 

The draw method draws all clients, but this isn't necessary since the 

calls are being made directly through jit.gl.sketch. However, in the 

abscence of a "draw" call, you need an "updateclients" call for 

jit.gl.render to do some important setup for each jit.gl.object. 

Sorry this isn't very well documented, but it's something of an 

> Also, what can you get with glget - I realize that it can retrieve 

> the projection and modelview matrices, but is there other state 

Most things documented in the Blue Book, but not quite everything. At 

the bottom of this file is what's supported as defined from the 

jit.gl.sketch source. The syntax follows the basic mapping of convert 

> although I still can't get screentoworld to report accurately where 

> the object is - I guess I'm not sure what to put in the call to 

> Jitter3DUtils.intersect_line_sphere - I've been using 

> mySketch.position and mySketch.scale[0], but that doesn't seems to 

You need to concatenate your transformations to actually know where 

the resultant object's going to be in world space if you want to call 

at any other point besides inside of your draw calls. However in this 

mode, at the appropriate point in your code (after your sequence of 

gltranslate/sclae/rotate calls), it should probably be at 0,0,0 with 

a radius of 1. All dependent on the current modelview transformation.

Hope this points you in the right direction. Gotta get back to coding.

// params returns one value, the number of alpha bitplanes in each 

jit_gl_cmd_glget_define("alpha_bits",GL_ALPHA_BITS,GLGET_LONG,1,0);

// params returns a single Boolean value indicating whether alpha 

testing of fragments is enabled. See glAlphaFunc.

jit_gl_cmd_glget_define("alpha_test",GL_ALPHA_TEST,GLGET_BOOL,1,0);

// params returns one value, the symbolic name of the alpha test 

("alpha_test_func",GL_ALPHA_TEST_FUNC,GLGET_SYM,1,0);

jit_gl_cmd_glget_symid_define("never",GL_NEVER);

jit_gl_cmd_glget_symid_define("less",GL_LESS);

jit_gl_cmd_glget_symid_define("equal",GL_EQUAL);

jit_gl_cmd_glget_symid_define("lequal",GL_LEQUAL);

jit_gl_cmd_glget_symid_define("greater",GL_GREATER);

jit_gl_cmd_glget_symid_define("notequal",GL_NOTEQUAL);

jit_gl_cmd_glget_symid_define("gequal",GL_GEQUAL);

jit_gl_cmd_glget_symid_define("always",GL_ALWAYS);

// params returns one value, the reference value for the alpha test. 

See glAlphaFunc. An integer value, if requested, is linearly mapped 

from the internal floating-point representation such that 1.0 returns 

the most positive representable integer value, and -1.0 returns the 

most negative representable integer value.

("alpha_test_ref",GL_ALPHA_TEST_REF,GLGET_FLOAT,1,0);

// params returns one value, the depth of the attribute stack. If the 

stack is empty, zero is returned. See glPushAttrib.

("attrib_stack_depth",GL_ATTRIB_STACK_DEPTH,GLGET_LONG,1,0);

// params returns a single Boolean value indicating whether 2D map 

evaluation automatically generates surface normals. See glMap2.

jit_gl_cmd_glget_define("auto_normal",GL_AUTO_NORMAL,GLGET_BOOL,1,0);

// params returns one value, the number of auxiliary color buffers.

jit_gl_cmd_glget_define("aux_bufers",GL_AUX_BUFFERS,GLGET_LONG,1,0);

// params returns a single Boolean value indicating whether blending 

jit_gl_cmd_glget_define("blend",GL_BLEND,GLGET_BOOL,1,0);

// params returns four values, the red, green, blue, and alpha values 

which are the components of the blend color. See glBlendColorEXT.

jit_gl_cmd_glget_define("blend_color",GL_BLEND_COLOR_EXT,GLGET_FLOAT, 

// params returns one value, the symbolic constant identifying the 

destination blend function. See glBlendFunc.

jit_gl_cmd_glget_define("blend_dst",GL_BLEND_DST,GLGET_SYM,1,0);

jit_gl_cmd_glget_symid_define("zero",GL_ZERO);

jit_gl_cmd_glget_symid_define("one",GL_ONE);

jit_gl_cmd_glget_symid_define("dst_color",GL_DST_COLOR);

jit_gl_cmd_glget_symid_define("src_color",GL_SRC_COLOR);

jit_gl_cmd_glget_symid_define("dst_alpha",GL_DST_ALPHA);

jit_gl_cmd_glget_symid_define("src_alpha",GL_SRC_ALPHA);

("one_minus_dst_color",GL_ONE_MINUS_DST_COLOR);

("one_minus_src_color",GL_ONE_MINUS_SRC_COLOR);

("one_minus_dst_alpha",GL_ONE_MINUS_DST_ALPHA);

("src_alpha_saturate",GL_SRC_ALPHA_SATURATE);

jit_gl_cmd_glget_symid_define("constant_color",GL_CONSTANT_COLOR_EXT);

("one_minus_constant_color",GL_ONE_MINUS_CONSTANT_COLOR_EXT);

jit_gl_cmd_glget_symid_define("constant_alpha",GL_CONSTANT_ALPHA_EXT);

("one_minus_alpha_color",GL_ONE_MINUS_CONSTANT_ALPHA_EXT);

destination blend function for alpha. See glBlendFuncSeparateEXT.

("blend_dst_alpha_ext",GL_BLEND_DST_ALPHA_EXT,GLGET_SYM,1,0);

("blend_dst_alpha",GL_BLEND_DST_ALPHA_EXT,GLGET_SYM,1,0);

destination blend function for red, green, and blue. See 

("blend_dst_rgb_ext",GL_BLEND_DST_RGB_EXT,GLGET_SYM,1,0);

("blend_dst_rgb",GL_BLEND_DST_RGB_EXT,GLGET_SYM,1,0);

// params returns one value, a symbolic constant identifying the 

("blend_dst_equation",GL_BLEND_EQUATION_EXT,GLGET_SYM,1,0);

jit_gl_cmd_glget_symid_define("min",GL_MIN_EXT);

jit_gl_cmd_glget_symid_define("max",GL_MAX_EXT);

jit_gl_cmd_glget_symid_define("subtract",GL_FUNC_SUBTRACT_EXT);

("reverse_subtract",GL_FUNC_REVERSE_SUBTRACT_EXT);

jit_gl_cmd_glget_symid_define("add",GL_FUNC_ADD_EXT);

jit_gl_cmd_glget_define("blend_src",GL_BLEND_SRC,GLGET_SYM,1,0);

source blend function for alpha. See glBlendFuncSeparateEXT.

("blend_src_alpha_ext",GL_BLEND_SRC_ALPHA_EXT,GLGET_SYM,1,0);

("blend_src_alpha",GL_BLEND_SRC_ALPHA_EXT,GLGET_SYM,1,0);

source blend function for red, green, and blue. See 

("blend_src_rgb_ext",GL_BLEND_SRC_RGB_EXT,GLGET_SYM,1,0);

("blend_src_rgb",GL_BLEND_SRC_RGB_EXT,GLGET_SYM,1,0);

// params returns one value, the number of blue bitplanes in each 

jit_gl_cmd_glget_define("blue_bits",GL_BLUE_BITS,GLGET_LONG,1,0);

// params returns a single Boolean value indicating whether the 

specified clipping plane is enabled. See glClipPlane.

jit_gl_cmd_glget_define("clip_plane0",GL_CLIP_PLANE0,GLGET_BOOL,1,0);

jit_gl_cmd_glget_define("clip_plane1",GL_CLIP_PLANE1,GLGET_BOOL,1,0);

jit_gl_cmd_glget_define("clip_plane2",GL_CLIP_PLANE2,GLGET_BOOL,1,0);

jit_gl_cmd_glget_define("clip_plane3",GL_CLIP_PLANE3,GLGET_BOOL,1,0);

using screentoworld with jit.gl.sketch in js