10.6

Chained Hexagonal Pixellate CoreImage filters with not-quite-synchronized Interpolation behaving in a vaguely-fractal-like manner.

I'm posting this to show how to do "line structure" style drawing with all stock patches.

This has some provisions for color and thickness as well, so you can have lines of differing color and weight on screen at the same time.

A quick example of using GLSL to warp the output of v002 Rutt Etra to a spherical shape.

Based on http://kineme.net/composition/cwright/Fisheye.

This is another porting of OpenCL kernels derived from the seminal noise_kernel.cl file provided by Apple as one of its Developer examples.

Instead of nesting these kernels together, as can be done in the same OpenCL kernel patch, they have been deliberately separated .

Each gradient kernel provides a very responsive, configurable graphical animation well suited to reacting to audio input.

In this current setup, the four kernels are rendered in turn via a demultiplexer.

This post is a companion to the visualizer version but is not set as an iTunes visualizer, being intended as an audio reactive loop, the inputs of which kernel can be further altered 'live'. In this construct, it is being fed audio via an Audio Input patch.

There are a lot of possibilities with this type of gradient & I'm looking forward to creating some different texture / image creation & filtering kernels in the future.

For now, do enjoy & employ these as you see fit.

I'll be interested to see how they do get used.

I shall also be looking forward to creating something very similar in Core Image.

At the present, my Core Image equivalents are only working in grayscale, which puts them about as far advanced as I was month ago with making image transformations using OpenCL. [Soon though :-)]

BTW - a big shout out and thanks to Pascal @ t-linked.com for his beautiful roll out of the gradient_noise kernel.

Provided me with much inspiration and reason to study closely.

Hopefully, these kernels will help to do the same for Kineme forum users.

Thanks to all of you whose postings have inspired and advised [ almost too many to mention ].

This is another porting of OpenCL kernels derived from the seminal noise_kernel.cl file provided by Apple as one of its Developer examples.

Instead of nesting these kernels together, as can be done in the same OpenCL kernel patch, they have been deliberately separated .

Each gradient kernel provides a very responsive, configurable graphical animation well suited to reacting to audio input.

In this current setup, the four kernels are rendered in turn via a demultiplexer.

This post is a companion to the "closed loop" version that is not set as an iTunes visualizer, but is intended to be an audio reactive loop, the inputs of which kernel can be further altered 'live'.

There are a lot of possibilities with this type of gradient & I'm looking forward to creating some different texture / image creation & filtering kernels in the future.

For now, do enjoy & employ this as you see fit.

I'll be interested to see how they get used.

This patch shows how you can take the events inside of an iterator, record to queue, and then spooky them outside of the iterator, so that they can be used.

This principle makes it possible to create "interaction" structures where every vertex can be "grabbed" via the interaction patch, and they are all inherently "hot".

It occurred to me that I could use a queue inside of an iterator to build a structure of the events in an iterator, so that I can grab the current and last index. Then, with two line renderers, I can draw contiguous lines that are shaped like the lfo's I'm powering it with.

This is all hooked to SL's interaction patch, and can also be rejiggered to send a structure "out" with a spooky patch. This amounts to a way to generate interactive structures, where each of the points inherently has interaction abilities.

so my daughter loves this ipad game "angry birds" its a tower defense type of game in 2d. probably made with something like cocos2d or unity3d with no z depth. so i decided to see if i could wip up something in an evening similar but in unity 3d using forces etc...

well i accomplished that task as unity3d makes things like physics very simple. i began thinking how hard would it really be to do something similar in QC. thinking i would start with a box2d approach and track vertex positions of sprite or something. i dug out some 2d fluid texture maya mel scripts and thought it might be possible to calculate a collision by converting UVs to pixels space and evaluating a hit based on texture data in realtime.

i pondered on this idea for a bit and then said to my self why not just check all the vertex points (xyz) for equivalence using the size of a model as a threshold. so using the handy get component mesh tool, i simply iterated through all my vertex's and conditionally checked x,y,z on each vertex until the two models collided. so this was fairly simple could have been done in java script instead of an iterator. unfortunately the frame rate for comparing two models with a vert count of 420 was only giving me around 30 fps on my machine. which is decent and i was happy with the fps as i could check for collisions and then apply forces based on those collisions etc.

still 30fps with only two low poly count models wasn't cutting it as quartz has all this open cl multi-threaded stuff that was built for this type of thing so i decided open cl was going to be the best way to detect if two models collide in QC.

so at first i thought i would just break down and iterate through two sets of vertexes checking for hits like i did before but after looking at the openCL reference guide and noticing all these sweet matrix and math stuff built in. i figured i could just use a distance function and check for when the models where within the threshold of there respective scales to detect a hit. so this was a different approach to the same problem. the results are similar but by doing this in on two different threads in parallel i was able to get my fps up over 100 at times in just a few lines of code.

so both these patches work for hit testing in 3d with rotations etc.. i still need to do some more testing and get a vertex by vertex comparison made in open cl instead of distance function so that eventually i may be able to do some rudimentary physics calculations with inertia and forces etc..

i don't know if this will help anyone but could be used to make a simple shooter type of game or projectile / target type of thing in 3d with your own models.

This composition demonstrates a hit test method that works for rectangles.

It was inspired by a hit test method description that I read about in an interview with Bill Atkinson about the development of QuickDraw that uses logic based on two points to determine if a hit is inside or outside of a rectangular area.

This patch is strictly 2D compatible. Z translation as well as X, Y and Z rotations are not taken into account, and it won't work inside of 3D transforms since it doesn't "know" what happens outside of the patch.

One must hook the outputs of the HitRect patch to the corresponding inputs on a Sprite (or Billboard), for this to work properly.

There IS a more full featured hidden hit test patch (which sometimes provokes oddities in QC). This was done mostly out of curiosity after reading the interview with Bill Atkinson, and to reproduce that particular method by using QC patches.

This composition is a demo that shows how to setup an interactive sculpt method with the Apple Mesh engine in Snow Leopard.

Shoutout to cwright for a question he answered a long time ago (hmm, 2 years? Time flies...) where the resolution was to take a Kineme3D warp and sample the output with a sample and hold before the renderer, so that a gravity warp would freeze on mouse up, and clear on mouse down.

After that lingered in my mind, I realized I could setup a feedback/multiplexer loop that would allow one to do a type of additive sculpting that wouldn't clear the sample and hold data every time a mouse down event occurred, but additionally clear it if I wished with a secondary mouse button.

A recent discussion about pushing around vertices in OpenCL led me to whip this up, since I was pretty sure the routine could be applied to OpenCL just as easily.

So, this uses that kind of sample and hold based feedback loop with multiplexers to allow one to use a mesh filter in a way that adds the results of deformation to the resulting mesh with each push/pull motion. This is very similar to some sculpting and vertex push functions in modeling programs.

Rev History- .01- Slight tweak to improve clearing mesh filter effect.