yair reshef

I'm looking to rotate a mesh based quad(s). idle with a changeable center of

rotation. a patch would be lovely but the expression used or a link to

i wish i could combine mesh based rendering with glrotate...

I'm looking to rotate a mesh based quad(s). idle with a changeable center of
rotation. a patch would be lovely but the expression used or a link to
further info would help. much.
i wish i could combine mesh based rendering with glrotate...
yair

how-to-rotate-a-quad-math-pls

attachment, rotation equation taken from an opengl book

> I'm looking to rotate a mesh based quad(s). idle with a changeable center

> of rotation. a patch would be lovely but the expression used or a link to

> i wish i could combine mesh based rendering with glrotate...

On 9/25/07, yair reshef  wrote:
>
> I'm looking to rotate a mesh based quad(s). idle with a changeable center
> of rotation. a patch would be lovely but the expression used or a link to
> further info would help. much.
> i wish i could combine mesh based rendering with glrotate...
> yair
>

Here are some jit.expr objects that will do x, y, z rotations with an 

anchor at 0. I had this lying around, so I can't tell you what is what.

I don't have the time to work it out right now, but you could probably 

use a vertex shader to rotate the geometry in a much more efficient way 

by passing in vertex attributes or by using one of the jit.gl.mesh 

inputs for the rotation amount for each quad and doing the matrix 

transformation in the vertex program. See the recent thread called 

"Setting GLSL attribute variables per vertex with Jitter" for more info 

> attachment, rotation equation taken from an opengl book

> I'm looking to rotate a mesh based quad(s). idle with a changeable

> center of rotation. a patch would be lovely but the expression used

> or a link to further info would help. much.

> ------------------------------------------------------------------------

Hello,
Here are some jit.expr objects that will do x, y, z rotations with an 
anchor at 0.   I had this lying around, so I can't tell you what is what.

I don't have the time to work it out right now, but you could probably 
use a vertex shader to rotate the geometry in a much more efficient way 
by passing in vertex attributes or by using one of the jit.gl.mesh 
inputs for the rotation amount for each quad and doing the matrix 
transformation in the vertex program.  See the recent thread called 
"Setting GLSL attribute variables per vertex with Jitter" for more info 
on using vertex attributes in a shader.

yair reshef wrote:
> attachment, rotation equation taken from an opengl book
>
> On 9/25/07, *yair reshef* >
> wrote:
>
>     I'm looking to rotate a mesh based quad(s). idle with a changeable
>     center of rotation. a patch would be lovely but the expression used
>     or a link to further info would help. much.
>     i wish i could combine mesh based rendering with glrotate...
>     yair
>
>
>
> ------------------------------------------------------------------------
>
>
> ------------------------------------------------------------------------
>


On that note, I checked in the 1.6 docs, and did not see anything 

Also, this is one thing that GEM does quite quite well, using nested 

translation and rotation objects to geometry for transforms. 2.0 PLZ?

On Sep 25, 2007, at 5:29 PM, andrew benson wrote:

> Here are some jit.expr objects that will do x, y, z rotations with 

> an anchor at 0. I had this lying around, so I can't tell you what 

> #P newex 188 205 310 196617 jit.expr @expr in[0] "in[0].p[1]*cos(in 

> [1])-in[0].p[2]*sin(in[1])" "in[0].p[2]*cos(in[1])+in[0].p[1]*sin(in 

> #P newex 188 170 290 196617 jit.expr @expr "in[0].p[0]*cos(in[1])+in 

> [0].p[2]*sin(in[1])" in[0] "in[0].p[2]*cos(in[1])-in[0].p[0]*sin(in 

> #P newex 188 134 297 196617 jit.expr @expr "in[0].p[0]*cos(in[1]) - 

> in[0].p[1]*sin(in[1])" "in[0].p[1]*cos(in[1]) + in[0].p[0]*sin(in 

> I don't have the time to work it out right now, but you could 

> probably use a vertex shader to rotate the geometry in a much more 

> efficient way by passing in vertex attributes or by using one of 

> the jit.gl.mesh inputs for the rotation amount for each quad and 

> doing the matrix transformation in the vertex program. See the 

> recent thread called "Setting GLSL attribute variables per vertex 

> with Jitter" for more info on using vertex attributes in a shader.

>> attachment, rotation equation taken from an opengl book

>> I'm looking to rotate a mesh based quad(s). idle with a 

>> center of rotation. a patch would be lovely but the expression 

>> or a link to further info would help. much.

>> i wish i could combine mesh based rendering with glrotate...

>> --------------------------------------------------------------------- 

On that note, I checked in the 1.6 docs, and did not see anything  
about vertex attributes.

Also, this is one thing that GEM does quite quite well, using nested  
translation and rotation objects to geometry for transforms. 2.0 PLZ?
K THNX BAI!
:)

> Hello,
> Here are some jit.expr objects that will do x, y, z rotations with  
> an anchor at 0.   I had this lying around, so I can't tell you what  
> is what.
>
> #P window setfont "Sans Serif" 9.;
> #P window linecount 2;
> #P newex 188 205 310 196617 jit.expr @expr in[0] "in[0].p[1]*cos(in 
> [1])-in[0].p[2]*sin(in[1])" "in[0].p[2]*cos(in[1])+in[0].p[1]*sin(in 
> [1])" in[0] in[0];
> #P newex 188 170 290 196617 jit.expr @expr "in[0].p[0]*cos(in[1])+in 
> [0].p[2]*sin(in[1])" in[0] "in[0].p[2]*cos(in[1])-in[0].p[0]*sin(in 
> [1])" in[0] in[0];
> #P newex 188 134 297 196617 jit.expr @expr "in[0].p[0]*cos(in[1]) -  
> in[0].p[1]*sin(in[1])" "in[0].p[1]*cos(in[1]) + in[0].p[0]*sin(in 
> [1])" in[0] in[0] in[0];
> #P connect 1 0 2 0;
> #P connect 0 0 1 0;
> #P window clipboard copycount 3;
>
> I don't have the time to work it out right now, but you could  
> probably use a vertex shader to rotate the geometry in a much more  
> efficient way by passing in vertex attributes or by using one of  
> the jit.gl.mesh inputs for the rotation amount for each quad and  
> doing the matrix transformation in the vertex program.  See the  
> recent thread called "Setting GLSL attribute variables per vertex  
> with Jitter" for more info on using vertex attributes in a shader.
>
> Best,
> Andrew B.
>
>
>
> yair reshef wrote:
>> attachment, rotation equation taken from an opengl book
>> On 9/25/07, *yair reshef*
>> > wrote:
>>     I'm looking to rotate a mesh based quad(s). idle with a  
>> changeable
>>     center of rotation. a patch would be lovely but the expression  
>> used
>>     or a link to further info would help. much.
>>     i wish i could combine mesh based rendering with glrotate...
>>     yair
>> --------------------------------------------------------------------- 
>> ---
>> --------------------------------------------------------------------- 
>> ---

thanks Andraw. i have no problem as of yet with mesh vertex performances.

works great. included is a patch implemnting your math for the internet to

> On that note, I checked in the 1.6 docs, and did not see anything about

> Also, this is one thing that GEM does quite quite well, using nested

> translation and rotation objects to geometry for transforms. 2.0 PLZ?

> On Sep 25, 2007, at 5:29 PM, andrew benson wrote:

> Here are some jit.expr objects that will do x, y, z rotations with an

> anchor at 0. I had this lying around, so I can't tell you what is what.

> #P newex 188 205 310 196617 jit.expr @expr in[0]

> "in[0].p[1]*cos(in[1])-in[0].p[2]*sin(in[1])"

> "in[0].p[2]*cos(in[1])+in[0].p[1]*sin(in[1])" in[0] in[0];

> #P newex 188 170 290 196617 jit.expr @expr

> "in[0].p[0]*cos(in[1])+in[0].p[2]*sin(in[1])" in[0]

> "in[0].p[2]*cos(in[1])-in[0].p[0]*sin(in[1])" in[0] in[0];

> #P newex 188 134 297 196617 jit.expr @expr "in[0].p[0]*cos(in[1]) -

> in[0].p[1]*sin(in[1])" "in[0].p[1]*cos(in[1]) + in[0].p[0]*sin(in[1])" in[0]

> I don't have the time to work it out right now, but you could probably use

> a vertex shader to rotate the geometry in a much more efficient way by

> passing in vertex attributes or by using one of the jit.gl.mesh inputs for

> the rotation amount for each quad and doing the matrix transformation in the

> vertex program. See the recent thread called "Setting GLSL attribute

> variables per vertex with Jitter" for more info on using vertex attributes

thanks Andraw. i have no problem as of yet with mesh vertex performances.
works great. included is a patch implemnting your math for the internet to
store.

On 9/25/07, vade  wrote:
>
> On that note, I checked in the 1.6 docs, and did not see anything about
> vertex attributes.
> Also, this is one thing that GEM does quite quite well, using nested
> translation and rotation objects to geometry for transforms. 2.0 PLZ?
> K THNX BAI!
> :)
>
> On Sep 25, 2007, at 5:29 PM, andrew benson wrote:
>
> Hello,
> Here are some jit.expr objects that will do x, y, z rotations with an
> anchor at 0.   I had this lying around, so I can't tell you what is what.
>
> #P window setfont "Sans Serif" 9.;
> #P window linecount 2;
> #P newex 188 205 310 196617 jit.expr @expr in[0]
> "in[0].p[1]*cos(in[1])-in[0].p[2]*sin(in[1])"
> "in[0].p[2]*cos(in[1])+in[0].p[1]*sin(in[1])" in[0] in[0];
> #P newex 188 170 290 196617 jit.expr @expr
> "in[0].p[0]*cos(in[1])+in[0].p[2]*sin(in[1])" in[0]
> "in[0].p[2]*cos(in[1])-in[0].p[0]*sin(in[1])" in[0] in[0];
> #P newex 188 134 297 196617 jit.expr @expr "in[0].p[0]*cos(in[1]) -
> in[0].p[1]*sin(in[1])" "in[0].p[1]*cos(in[1]) + in[0].p[0]*sin(in[1])" in[0]
> in[0] in[0];
> #P connect 1 0 2 0;
> #P connect 0 0 1 0;
> #P window clipboard copycount 3;
>
> I don't have the time to work it out right now, but you could probably use
> a vertex shader to rotate the geometry in a much more efficient way by
> passing in vertex attributes or by using one of the jit.gl.mesh inputs for
> the rotation amount for each quad and doing the matrix transformation in the
> vertex program.  See the recent thread called "Setting GLSL attribute
> variables per vertex with Jitter" for more info on using vertex attributes
> in a shader.
>
> Best,
> Andrew B.
>
>
>
> yair reshef wrote:
>
> attachment, rotation equation taken from an opengl book
> On 9/25/07, *yair reshef* >>
> wrote:
>     I'm looking to rotate a mesh based quad(s). idle with a changeable
>     center of rotation. a patch would be lovely but the expression used
>     or a link to further info would help. much.
>     i wish i could combine mesh based rendering with glrotate...
>     yair
> ------------------------------------------------------------------------
> ------------------------------------------------------------------------
>
>
>
> *v a d e //*
>
> *www.vade.info*
> *abstrakt.vade.info*
>
>
>
>
>
>

> thanks Andraw. i have no problem as of yet with mesh vertex performances.

> works great. included is a patch implemnting your math for the internet to

> > On that note, I checked in the 1.6 docs, and did not see anything about

> > Also, this is one thing that GEM does quite quite well, using nested

> > translation and rotation objects to geometry for transforms. 2.0 PLZ?

> > On Sep 25, 2007, at 5:29 PM, andrew benson wrote:

> > Here are some jit.expr objects that will do x, y, z rotations with an

> > anchor at 0. I had this lying around, so I can't tell you what is

> > #P newex 188 205 310 196617 jit.expr @expr in[0]

> > "in[0].p[1]*cos(in[1])-in[0].p[2]*sin(in[1])"

> > "in[0].p[2]*cos(in[1])+in[0].p[1]*sin(in[1])" in[0] in[0];

> > #P newex 188 170 290 196617 jit.expr @expr

> > "in[0].p[0]*cos(in[1])+in[0].p[2]*sin(in[1])" in[0]

> > "in[0].p[2]*cos(in[1])-in[0].p[0]*sin(in[1])" in[0] in[0];

> > #P newex 188 134 297 196617 jit.expr @expr "in[0].p[0]*cos(in[1]) -

> > in[0].p[1]*sin(in[1])" "in[0].p[1]*cos(in[1]) + in[0].p[0]*sin(in[1])" in[0]

> > I don't have the time to work it out right now, but you could probably

> > use a vertex shader to rotate the geometry in a much more efficient way by

> > passing in vertex attributes or by using one of the jit.gl.mesh inputs

> > for the rotation amount for each quad and doing the matrix transformation in

> > the vertex program. See the recent thread called "Setting GLSL

> > attribute variables per vertex with Jitter" for more info on using vertex

On 9/26/07, yair reshef  wrote:
>
> thanks Andraw. i have no problem as of yet with mesh vertex performances.
> works great. included is a patch implemnting your math for the internet to
> store.
>
>
>
> On 9/25/07, vade  wrote:
> >
> > On that note, I checked in the 1.6 docs, and did not see anything about
> > vertex attributes.
> > Also, this is one thing that GEM does quite quite well, using nested
> > translation and rotation objects to geometry for transforms. 2.0 PLZ?
> > K THNX BAI!
> > :)
> >
> > On Sep 25, 2007, at 5:29 PM, andrew benson wrote:
> >
> > Hello,
> > Here are some jit.expr objects that will do x, y, z rotations with an
> > anchor at 0.   I had this lying around, so I can't tell you what is
> > what.
> >
> > #P window setfont "Sans Serif" 9.;
> > #P window linecount 2;
> > #P newex 188 205 310 196617 jit.expr @expr in[0]
> > "in[0].p[1]*cos(in[1])-in[0].p[2]*sin(in[1])"
> > "in[0].p[2]*cos(in[1])+in[0].p[1]*sin(in[1])" in[0] in[0];
> > #P newex 188 170 290 196617 jit.expr @expr
> > "in[0].p[0]*cos(in[1])+in[0].p[2]*sin(in[1])" in[0]
> > "in[0].p[2]*cos(in[1])-in[0].p[0]*sin(in[1])" in[0] in[0];
> > #P newex 188 134 297 196617 jit.expr @expr "in[0].p[0]*cos(in[1]) -
> > in[0].p[1]*sin(in[1])" "in[0].p[1]*cos(in[1]) + in[0].p[0]*sin(in[1])" in[0]
> > in[0] in[0];
> > #P connect 1 0 2 0;
> > #P connect 0 0 1 0;
> > #P window clipboard copycount 3;
> >
> > I don't have the time to work it out right now, but you could probably
> > use a vertex shader to rotate the geometry in a much more efficient way by
> > passing in vertex attributes or by using one of the jit.gl.mesh inputs
> > for the rotation amount for each quad and doing the matrix transformation in
> > the vertex program.  See the recent thread called "Setting GLSL
> > attribute variables per vertex with Jitter" for more info on using vertex
> > attributes in a shader.
> >
> > Best,
> > Andrew B.
> >
> >
> >
> > yair reshef wrote:
> >
> > attachment, rotation equation taken from an opengl book
> > On 9/25/07, *yair reshef* >>
> > wrote:
> >     I'm looking to rotate a mesh based quad(s). idle with a changeable
> >     center of rotation. a patch would be lovely but the expression used
> >     or a link to further info would help. much.
> >     i wish i could combine mesh based rendering with glrotate...
> >     yair
> > ------------------------------------------------------------------------
> > ------------------------------------------------------------------------
> >
> >
> >
> >
> >  * v a d e //*
> >
> > * www.vade.info*
> > * abstrakt.vade.info*
> >
> >
> >
> >
> >
> >
>

> On that note, I checked in the 1.6 docs, and did not see anything 

Relatively experimental feature at the time of doc writing. Forum for 

> Also, this is one thing that GEM does quite quite well, using 

> nested translation and rotation objects to geometry for transforms. 

These objects are just a bang chain with the gltranslate, glrotate, 

glscale calls. You can easily simulate this stuff in jit.gl.sketch. 

If you need a bang chain, just make a few jit.gl.sketch @immediate 1 

wrappers and use @automatic 0 for the objects. It's *really* simple 

if you want to program procedural bang chains like this. It's just 

not the paradigm we're going to focus our object set on.

> On that note, I checked in the 1.6 docs, and did not see anything  
> about vertex attributes.

Relatively experimental feature at the time of doc writing. Forum for  
vertex attr info is best.

> Also, this is one thing that GEM does quite quite well, using  
> nested translation and rotation objects to geometry for transforms.  
> 2.0 PLZ? K THNX BAI!

These objects are just a bang chain with the gltranslate, glrotate,  
glscale calls. You can easily simulate this stuff in jit.gl.sketch.  
If you need a bang chain, just make a few jit.gl.sketch @immediate 1  
wrappers and use @automatic 0 for the objects. It's *really* simple  
if you want to program procedural bang chains like this. It's just  
not the paradigm we're going to focus our object set on.

Hi, Im either having a brain fart or I am misunderstanding

Thank for the heads up. I had forgotten about immediate mode.

Below is a patch that demonstrates the basics, along with a little 

bit of fun. There are a few important things you were lacking:

2. push/pop the modelview matrix before/after bang chain

3. use the drawraw message to any objects you are drawing. otherwise 

Also, you need to make sure you don't dispose/recreate the window 

while this stuff is happening or else you could crash. immediate mode 

doesn't seem to be 100% safe at the moment for that case. Let me know 

Anyway, this is basically the model GEM uses from what I understand, 

and can be simulated with abstractions, without much overhead. FWIW, 

in Jitter 2.0, we are definitely going to think about issues of 

hierarchy, but not within this procedural bang chain model.

Below is a patch that demonstrates the basics, along with a little  
bit of fun. There are a few important things you were lacking:

1. specify the modelview matrix mode
2. push/pop the modelview matrix before/after bang chain
3. use the drawraw message to any objects you are drawing. otherwise  
a variety of state is reset.

Also, you need to make sure you don't dispose/recreate the window  
while this stuff is happening or else you could crash. immediate mode  
doesn't seem to be 100% safe at the moment for that case. Let me know  
if it still isn't clear.

Anyway, this is basically the model GEM uses from what I understand,  
and can be simulated with abstractions, without much overhead. FWIW,  
in Jitter 2.0, we are definitely going to think about issues of  
hierarchy, but not within this procedural bang chain model.

p.s. jit.gl.mesh will be *oodles* faster for cases like the one Yair 

was actually interested in, and AB's solution would be recommended. 

If using the geometry many times in the sort of iterative 

jit.gl.gridshape case, use @displaylist 1, for performance improvements.

p.s. jit.gl.mesh will be *oodles* faster for cases like the one Yair  
was actually interested in, and AB's solution would be recommended.  
If using the geometry many times in the sort of iterative  
jit.gl.gridshape case, use @displaylist 1, for performance improvements.

revisited the formulas, added rotation origin math and visualization

On Thu, Sep 27, 2007 at 12:48 AM, Joshua Kit Clayton wrote:

> p.s. jit.gl.mesh will be *oodles* faster for cases like the one Yair was

> actually interested in, and AB's solution would be recommended. If using the

> geometry many times in the sort of iterative jit.gl.gridshape case, use

> @displaylist 1, for performance improvements.

On Thu, Sep 27, 2007 at 12:48 AM, Joshua Kit Clayton  wrote:

>
>
> p.s. jit.gl.mesh will be *oodles* faster for cases like the one Yair was
> actually interested in, and AB's solution would be recommended. If using the
> geometry many times in the sort of iterative jit.gl.gridshape case, use
> @displaylist 1, for performance improvements.
>
>
>

Quote: yair r. wrote on Tue, 06 May 2008 10:33

----------------------------------------------------

> revisited the formulas, added rotation origin math and visualization

interested in seeing the patch, but there seems to be some problems with copy + paste... perhaps some forum patch scrambling?

Quote: yair r. wrote on Tue, 06 May 2008 10:33
----------------------------------------------------
> revisited the formulas, added rotation origin math and visualization

thanks, but still cant open.... is it done in max v5?

am going to update sometime this summer, still have projects i need to finish!

thanks, but still cant open.... is it done in max v5?
am going to update sometime this summer, still have projects i need to finish!

Would you mind reposting your patch because there seems to be some problem with the copy / paste ?

This is a jit.gen that does geometry rotation, from Andrew's jit.expr notes.

Standing on the shoulders of giants, as per usual.

Replying to a thirteen year old thread! This is a jit.gen that does geometry rotation, from Andrew's jit.expr notes.

how to rotate a quad, math pls