Still speed-coding shorts for youtube these last few months… – move your mouse over the codepen below – click and hold to zoom out 😀
Browse the notebook
Category: color
Updates Shorts and Rbn… snippet.zone zapp.codes etc…
I started making youtube shorts using a monaco-powered micro-editor I created called https://zapp.codes. Check them out here: https://www.youtube.com/@shapevent/shorts
I don’t think I ever mentioned https://snippet.zone here. It’s just another actionsnippet-like site I created a few years ago… I don’t update it all that frequently but it has many snippets mostly written in js.
recent fork of a snippet.zone that I used in a short…
Here’s a short showing something I did for genuary 2022…
QuickShader Micro-Lib
In 2015 I created QuickShader… which just takes the boilerplate out of showing a shader in the browser. Here are a few examples:
https://github.com/ZevanRosser/QuickShader
Interesting Texture #3 (animated)
[SWF(frameRate=60, backgroundColor=0x000000, width=500, height=500)]
var canvas:BitmapData = new BitmapData(500,500,false, 0x000000);
addChild(new Bitmap(canvas));
var clone:BitmapData = new BitmapData(500,500,false, 0x000000);
var canvasRect:Rectangle = canvas.rect;
var w:int = canvas.width;
var w2:Number = 1/w;
var w10:Number = 1/(w * 80);
var convert:Number = Math.PI/180;
var size:int = canvas.width * canvas.height;
var pix:Vector.<uint> = new Vector.<uint>(size, true);
var gray:ColorMatrixFilter = new ColorMatrixFilter([1, 0.55, 0.55, 0,0,0.55, 0.9, 0.55, 0,0,0.55, 0.55, 0.550,0, 0,0,0,1,0]);
var m:Matrix = new Matrix();
m.scale(1,-1);
m.translate(0,canvas.height);
var sin:Number = 0, cos:Number = 0;
var dx:Number = 0, dy:Number = 0;
var pnt:Point = new Point();
var blur:BlurFilter = new BlurFilter(10,10,1);
addEventListener(Event.ENTER_FRAME, onLoop);
function onLoop(evt:Event):void {
canvas.lock();
dx += (mouseX * 10 - 3000 - dx) / 8;
dy += (mouseY * 4 - dy) / 8;
for (var i:int = 0; i<size; i++){
var xp:int = i % w;
var yp:int = int(i * w2);
var xp2:int = xp << 1;
var t:Number = (yp * (xp2 + dx) * w10) % 3.14687;
//compute sine
// technique from http://lab.polygonal.de/2007/07/18/fast-and-accurate-sinecosine-approximation/
// by Michael Baczynski
if (t<0) {
sin=1.27323954*t+.405284735*t*t;
} else {
sin=1.27323954*t-0.405284735*t*t;
}
// compute cosine
t = (xp2 + dy) * convert % 6.28;
t+=1.57079632;
if (t>3.14159265) {
t-=6.28318531;
}
if (t<0) {
cos=1.27323954*t+0.405284735*t*t;
} else {
cos=1.27323954*t-0.405284735*t*t;
}
var c1:int = 31 * (cos - sin);
if (c1 <0) c1 = 256 - c1;
c1 = (c1 <<2 | c1) ;
pix[i] = c1 <<15 | c1 <<9 | c1;
}
canvas.setVector(canvasRect, pix);
clone.copyPixels(canvas, canvasRect, pnt);
canvas.draw(clone, m, null, BlendMode.SUBTRACT);
clone.copyPixels(canvas, canvasRect, pnt);
clone.applyFilter(clone, canvasRect, pnt, blur);
canvas.draw(clone, null, null, BlendMode.ADD);
canvas.applyFilter(canvas, canvas.rect, new Point(0,0), gray);
canvas.unlock();
}
This snippet creates an interactive animated texture. Originally this texture wasn an unoptimized messy code snippet (see the original post here) – I went through and did a few optimizations to get it running in real-time and this is the result:
Check out the swf over at wonderfl.net…

HSV Color Type
[SWF(width=560,height=300,backgroundColor=0x000000,frameRate=30)]
var key:Object = new Object();
var alphabet:Array = "abcdefghijklmnopqrstuvwxyz".split("");
var num:Number = alphabet.length;
var step:Number = 360 / num;
var colors:Object = new Object();
for (var i:int = 0; i<num; i++){
var index:String = alphabet[i];
key[index] = 65 + i;
var c:Array = hsv(i * step, 1, 1);
colors[index] = c[0] <<16 | c[1] <<8 | c[2];
}
alphabet.push("32");
num++;
key["32"] = 32;
colors["32"] = 0x333333;
x = y = 10;
var count:int = 0;
var size:int = 20;
stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyPressed);
function onKeyPressed(evt:KeyboardEvent):void{
for (var i:int= 0; i<num; i++){
var index:String = alphabet[i];
if (index == "32"){
trace("hi", evt.keyCode, key[index]);
}
if (evt.keyCode == key[index]){
graphics.beginFill(colors[index]);
var xp:int = count % num * size;
var yp:int = int(count / num) * size;
graphics.drawRect(xp, yp, size, size);
count++;
}
}
}
// ported from here:
//http://www.cs.rit.edu/~ncs/color/t_convert.html
function hsv(h:Number, s:Number, v:Number):Array{
var r:Number, g:Number, b:Number;
var i:int;
var f:Number, p:Number, q:Number, t:Number;
if (s == 0){
r = g = b = v;
return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
}
h /= 60;
i = Math.floor(h);
f = h - i;
p = v * (1 - s);
q = v * (1 - s * f);
t = v * (1 - s * (1 - f));
switch( i ) {
case 0:
r = v, g = t, b = p;
break;
case 1:
r = q, g = v, b = p;
break;
case 2:
r = p, g = v, b = t;
break;
case 3:
r = p, g = q, b = v;
break;
case 4:
r = t, g = p, b = v;
break;
default: // case 5:
r = v, g = p, b = q;
break;
}
return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
}
This snippet is a typing experiment – for every letter, you type a box filled with a specific color is drawn to the stage. The color associated with each letter is determined by moving through hsv color space – so typing an alphabet will end up with something resembling a spectrum.
Distance Render
var verts:Vector.<Number> = new Vector.<Number>();
var pVerts:Vector.<Number> = new Vector.<Number>();
var uvts:Vector.<Number> = new Vector.<Number>();
var hs:Number = 2.3;
var step:Number = 0.04;
var tVerts:Vector.<Number> = new Vector.<Number>();
var rVerts:Vector.<Number> = new Vector.<Number>();
var matrix:Matrix3D = new Matrix3D();
matrix.identity();
matrix.appendRotation(45,Vector3D.Y_AXIS);
matrix.appendRotation(45,Vector3D.X_AXIS);
var inc:int = 0;
var i:Number, j:Number, k:Number;
i = hs;
while( i > -hs){
j = hs;
while(j > -hs){
k = hs;
while(k > -hs){
tVerts[inc] = -i;
inc++
tVerts[inc] = -j;
inc++
tVerts[inc] = -k;
inc++
k -= step;
}
j -= step;
}
i -= step;
}
matrix.transformVectors(tVerts, rVerts);
var vinc:int = 0;
inc = 0
var R:Number = 1.5;
var r:Number = .5;
for (i= -hs; i<hs; i+=step){
for (j = -hs; j<hs; j+=step){
for (k = -hs; k<hs; k+=step){
var vx:Number = rVerts[inc] ;
inc++
var vy:Number = rVerts[inc] ;
inc++
var vz:Number= rVerts[inc] ;
inc++
var s:Number = Math.pow(vx * vx + vy * vy + vz * vz + R*R - r * r, 2) - 4 * (R * R)*(vx * vx + vy * vy);
if (s <0 && s > -.5){
verts[vinc] = (i * 50);
vinc++
verts[vinc] = (j * 50);
vinc++
verts[vinc] = (k * 50);
vinc++
inc += int((hs - k) / step) * 3;
k = hs;
}
}
}
}
var canvas:BitmapData = new BitmapData(400,400,false, 0x000000);
addChild(new Bitmap(canvas));
render();
function render():void{
matrix.identity();
matrix.appendTranslation(200, 200, 0);
Utils3D.projectVectors(matrix, verts, pVerts, uvts);
canvas.lock();
canvas.fillRect(canvas.rect, 0x000000);
var inc:int = 2;
var c:int = 0;
var r:Rectangle = new Rectangle();
r.width = r.height = 2;
for (var i:int = 0; i<pVerts.length; i+=2){
r.x = pVerts[i];
r.y = pVerts[i + 1];
c = Math.max(0,100 - verts[inc]);
canvas.fillRect(r, c << 16 | c << 8 | c);
inc += 3;
}
canvas.unlock();
}
This snippet uses some of the techniques from the last few posts to create a distance render – this renders the implicit equation for a torus.
(HSV HSB) to RGB
[SWF(width=720,height=360,backgroundColor=0x000000,frameRate=30)]
// ported from here:
//http://www.cs.rit.edu/~ncs/color/t_convert.html
function hsv(h:Number, s:Number, v:Number):Array{
var r:Number, g:Number, b:Number;
var i:int;
var f:Number, p:Number, q:Number, t:Number;
if (s == 0){
r = g = b = v;
return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
}
h /= 60;
i = Math.floor(h);
f = h - i;
p = v * (1 - s);
q = v * (1 - s * f);
t = v * (1 - s * (1 - f));
switch( i ) {
case 0:
r = v;
g = t;
b = p;
break;
case 1:
r = q;
g = v;
b = p;
break;
case 2:
r = p;
g = v;
b = t;
break;
case 3:
r = p;
g = q;
b = v;
break;
case 4:
r = t;
g = p;
b = v;
break;
default: // case 5:
r = v;
g = p;
b = q;
break;
}
return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
}
//
// -- test it out by drawing a few things
//
var canvas:BitmapData = new BitmapData(720, 360, false, 0x000000);
addChild(new Bitmap(canvas));
canvas.lock();
var size:int = canvas.width * canvas.height;
var xp:int, yp:int, c:Array, i:int;
for (i = 0; i<size; i++){
xp = i % 360;
yp = i / 360;
c = hsv(xp, 1, yp / 360);
canvas.setPixel(xp, yp, c[0] << 16 | c[1] << 8 | c[2]);
}
var dx:Number, dy:Number, dist:Number, ang:Number;
for (i = 0; i<size; i++){
xp = i % 360;
yp = i / 360;
dx = xp - 180;
dy = yp - 180;
dist = 1 - Math.sqrt((dx * dx) + (dy * dy)) / 360;
ang = Math.atan2(dy, dx) / Math.PI * 180;
if (ang < 0){
ang += 360;
}
c = hsv(ang, 1, dist);
canvas.setPixel(360 + xp, yp, c[0] << 16 | c[1] << 8 | c[2]);
}
canvas.unlock();
This is one of those things I’ve been meaning to play with for awhile. The above demos a function called hsv() which takes 3 arguments: angle (0-360), saturation(0-1) and value(0-1). The function returns an array of rgb values each with a range of (0-255).
There’s some room for optimization here, but for clarity I left as is. Even just playing with HSV (also know as HSB) for a few minutes, I see some interesting potential for dynamically generating color palettes for generative style experiments.
I looked around for the most elegant looking code snippet to port in order to write this… I eventually stumbled upon this great resource.
If you test the above on your timeline it will generate this image:

I usually only post one snippet a day… not sure why I decided to post two today.
E4X and ActionScript Variables
var backgroundColor:uint = 0xEFEFEF;
var borderColor:uint = 0xFF0000;
var buttonOverColor:uint = 0x0000FF;
var buttonOutColor:uint = 0x00CCCC;
var uiColors:XML = <ui>
<default color="0xCCCCCC" />
<background color = { backgroundColor } />
<!-- note hexidecimal formatting code -->
<border color={ ("0x" + borderColor.toString(16)) } />
<button overColor={ buttonOverColor} outColor={ buttonOutColor } />
</ui>
trace(uiColors.toXMLString());
/*outputs:
<ui>
<default color="0xCCCCCC"/>
<background color="15724527"/>
<border color="0xff0000"/>
<button overColor="255" outColor="52428"/>
</ui>
*/
The first time I needed to use an ActionScript variable within inline XML I was stumped. I couldn’t figure it out and I wasn’t able to easily find it on google. I eventually found it somewhere (don’t remember where… possibly hidden away in the docs).
Now a search for “insert actionscript variables into e4x” on google gives plenty of results. But I figure it’s worth a post.
I use actionscript to generate XML all the time so this comes in handy. I also store color values in automatically generated XML all the time. If I’m feeling organized I’ll use something like what you see on line 10:
<border color={ ("0x" + borderColor.toString(16)) } />
If you look at the output you’ll see this formats the uint so that it’s readable as a hex number. By default (as you can see in the output) uints will show up in decimal notation. This really doesn’t make any difference if you don’t care about XML readability … or if you just don’t care about the readability of the colors stored in your XML…..
Isometric Voxels
// isometric conversion
var centerX:Number=stage.stageWidth/2;
var centerY:Number=stage.stageHeight/2;
var theta:Number=Math.PI/4;// 45 degrees;
var cosX:Number=Math.cos(theta);
var sinX:Number=Math.sin(theta);
var pnt:Point = new Point();
function iso3D(x:Number, y:Number, z:Number):Point {
pnt.x = centerX + (x-z) * cosX
pnt.y = centerY - (x+z) * 0.5 * sinX - y;
return pnt;
}
// example:
var canvas:BitmapData=new BitmapData(stage.stageWidth,stage.stageHeight,true,0xFF000000);
addChild(new Bitmap(canvas,"auto",true));
var size:int=100;
var hs:int=size / 2;
var pen:Point = new Point();
var vect:Vector3D = new Vector3D();
// draw a few shapes with offset:
for (var dist:int = 10; dist <= 80; dist *= 2) {
// voxel space:
for (var i:int = 0; i<size; i++) {
for (var j:int = 0; j<size; j++) {
for (var k:int = 0; k<size; k++) {
vect.x=j-hs;
vect.y=i-hs;
vect.z=k-hs;
pen = iso3D(vect.x,vect.y,vect.z);
if (Math.sqrt((vect.x * vect.x) + (vect.y * vect.y) + (vect.z * vect.z)) <dist) {
// using Vector3D.distance() is very slow compared to above
// a few types of coloring:
var xp:Number = pen.x + (dist <<2) - 200;
canvas.setPixel(xp, pen.y-100, (i <<16 | j <<8 | k) <<1);
canvas.setPixel(xp, pen.y+100, (k <<16 | k <<8 | k+j) );
}
}
}
}
}
The above will draw this:

You can read more about voxels here.
This isn’t the speediest way to do voxels (especially if you want to animate). This was just the first thing that came to mind.
MovieClip.prototype
MovieClip.prototype.tint = function(col:uint):void {
var ct:ColorTransform = transform.colorTransform;
ct.color = col;
this.transform.colorTransform = ct;
}
var circle:MovieClip = MovieClip(addChild(new MovieClip()));
with (circle.graphics) {
beginFill(0x123455);
drawCircle(0,0,50);
x = 100;
y = 100;
}
circle.tint(0xFF0000);
When AS3 first came out I didn’t realize that prototype was still around…. This adds a function called tint() to all MovieClips. You should extend MovieClip instead of using this method…. but it’s interesting to see that it’s still around. There’s an explanation of prototype and the AS3 namespace here.