Christopher Baker

I was able so successfully attach opengl text to particles in a 

opengl context using jit.gl.text2d. It is fairly straight forward to 

attach a single word (such as in the Tannenbaum example) but I need 

to attach different text fragments to a particle and retain that text 

throughout the duration of the particle's life. Right now my text 

fragments are in a text file. Each line in the file represents a 

unique text fragment that should be attached to a particle.

My first attempt was to add a plane of text line indices to the shiva/ 

vishnu particle matrix. During the jit.iter process when the text 

coordinates and other style information is fed into the 

jit.gl.text2d, these line indices were used to grab lines of text 

from a text file in a [text] object. This strategy caused the system 

to grind to a halt. I believe this was because the [text] object has 

a hard time giving up its contents so quickly.

The solution I have landed on for now is to create a sort of text 

string buffer (string array ...) using a 2d-single plane jitter 

matrix to contain the X number of text fragments currently alive in 

the particle system. This presents a complex, but not impossible 

housekeeping (indexing) problem, but my partially built system seems 

Is this single-plane-2d jitter matrix strategy as fast as using the 

"plane" attribute in jit.gl.text2d to access text from a 1D multi- 

plane jitter matrix? That is -- would it be faster to construct my 

string buffer (or string array ...) as a 2d-single plane matrix or a 

All of this aside, does anyone have another strategy for allowing 

unique text fragments to be attached to a given particle for the 

I was able so successfully attach opengl text to particles in a  
opengl context using jit.gl.text2d.  It is fairly straight forward to  
attach a single word (such as in the Tannenbaum example) but I need  
to attach different text fragments to a particle and retain that text  
throughout the duration of the particle's life.  Right now my text  
fragments are in a text file.  Each line in the file represents a  
unique text fragment that should be attached to a particle.

My first attempt was to add a plane of text line indices to the shiva/ 
vishnu particle matrix.  During the jit.iter process when the text  
coordinates and other style information is fed into the  
jit.gl.text2d, these line indices were used to grab lines of text  
from a text file in a [text] object.  This strategy caused the system  
to grind to a halt.  I believe this was because the [text] object has  
a hard time giving up its contents so quickly.

The solution I have landed on for now is to create a sort of text  
string buffer (string array ...) using a 2d-single plane jitter  
matrix to contain the X number of text fragments currently alive in  
the particle system.  This presents a complex, but not impossible  
housekeeping (indexing) problem, but my partially built system seems  
to be running quickly enough.

Is this single-plane-2d jitter matrix strategy as fast as using the  
"plane" attribute in jit.gl.text2d to access text from a 1D multi- 
plane jitter matrix?  That is -- would it be faster to construct my  
string buffer (or string array ...) as a 2d-single plane matrix or a  
1d-multi-plane matrix?

All of this aside, does anyone have another strategy for allowing  
unique text fragments to be attached to a given particle for the  
entire duration of its life?

more-opengl-text-movement-particle-system

> Is this single-plane-2d jitter matrix strategy as fast as using the

> "plane" attribute in jit.gl.text2d to access text from a 1D multi-

> plane jitter matrix? That is -- would it be faster to construct my

> string buffer (or string array ...) as a 2d-single plane matrix or a

Well, matrices have a maximum planecount of 32, so that kind of limits

> All of this aside, does anyone have another strategy for allowing

> unique text fragments to be attached to a given particle for the

I might suggest a JS or JAVA solution. You can probably knock out a

JS solution pretty quickly. Just instantiate you jit.gl.text2d as a

javascript object and send it text to draw in the JS itself. This

will make your system easier to build and more flexible. You can also

share your particle matrix between the patch and the JS file by

accessing a named matrix is the usual fashion. This way, you can can

send a draw command tot he JS file and have it process the particle

matrix and send appropritate commands to jit.gl.text2d.

> Is this single-plane-2d jitter matrix strategy as fast as using the
> "plane" attribute in jit.gl.text2d to access text from a 1D multi-
> plane jitter matrix?  That is -- would it be faster to construct my
> string buffer (or string array ...) as a 2d-single plane matrix or a
> 1d-multi-plane matrix?

Well, matrices have a maximum planecount of 32, so that kind of limits
how many lines you can have.

>
> All of this aside, does anyone have another strategy for allowing
> unique text fragments to be attached to a given particle for the
> entire duration of its life?

I might suggest a JS or JAVA solution.  You can probably knock out a
JS solution pretty quickly.  Just instantiate you jit.gl.text2d as a
javascript object and send it text to draw in the JS itself.  This
will make your system easier to build and more flexible.  You can also
share your particle matrix between the patch and the JS file by
accessing a named matrix is the usual fashion.  This way, you can can
send a draw command tot he JS file and have it process the particle
matrix and send appropritate commands to jit.gl.text2d.

more opengl text movement (particle system)