# Category Archives: Vector

## Distance Spring

Actionscript:
1. [SWF(backgroundColor=0x222222, width=500, height=500)]
2. var hsw:Number = stage.stageWidth / 2;
3. var hsh:Number = stage.stageHeight / 2;
4. var pointNum:int = 800
5. var points3D:Vector.<Number> = new Vector.<Number>();
6. var points3Dout:Vector.<Number> = new Vector.<Number>();
7. var points2D:Vector.<Number> = new Vector.<Number>();
8. var uvts:Vector.<Number> = new Vector.<Number>();
9. var sorted:Array = [];
10. var pnt:Point = new Point();
11. var m:Matrix3D = new Matrix3D();
12. var v:Vector3D = new Vector3D();
13. for (var i:int = 0; i<pointNum; i++){
14.     v.y = i * 0.7 - 300
15.     var t =Math.random()*6.28;
16.     v.x = 200 * Math.cos(i * 2 * Math.PI / 180);
17.     v.z = 200 * Math.sin(i * 2 * Math.PI / 180);
18.     v = m.transformVector(v);
19.     points3D.push(v.x, v.y, v.z);
20.     points2D.push(0,0);
21.     uvts.push(0,0,0);
22.     sorted.push(new Vector3D());
23. }
24. points3D.fixed = true;
25. points2D.fixed = true;
26. uvts.fixed = true;
27. var p:PerspectiveProjection = new PerspectiveProjection();
28. var proj:Matrix3D = p.toMatrix3D();
29. var dx:Number = 0, dy:Number = 0;
30. addEventListener(Event.ENTER_FRAME, onLoop);
31. function onLoop(evt:Event):void {
32.     var i:int, j:int;
33.     dx += (mouseX - dx) / 4;
34.     dy += (mouseY - dy) / 4;
35.     m.identity();
36.     m.appendRotation(getTimer() / 4, Vector3D.Y_AXIS);
37.     m.transformVectors(points3D, points3Dout);
38.
39.     m.identity();
40.     m.appendRotation(dx, Vector3D.Z_AXIS);
41.     m.appendRotation(dy, Vector3D.X_AXIS);
42.     m.appendTranslation(0, 0, 1000);
43.     m.append(proj);
44.     Utils3D.projectVectors(m, points3Dout, points2D, uvts);
45.     for (i = 0, j = 0; i<points2D.length; i+=2, j++){
46.         sorted[j].x = points2D[i] + hsw;
47.         sorted[j].y = points2D[i + 1] + hsh;
48.         sorted[j].z = uvts[j * 3 + 2];
49.     }
50.     sorted.sortOn("z", Array.NUMERIC);
51.     graphics.clear();
52.     for(i = 0; i<sorted.length; i++){
53.         var zpos:Number = sorted[i].z * 10000;
54.         var c:int = zpos * 14;
55.         graphics.beginFill(c <<16 | c <<8 | c);
56.         graphics.drawCircle(sorted[i].x, sorted[i].y, zpos);
57.         graphics.endFill();
58.     }
59. }

A variation on some recent posts... this snippet draws a rotating spring made up of 800 particles...

Have a look at the swf...

Also posted in 3D, Graphics | Tagged , , | 3 Comments

## Fake Light w/ UV & Quads

Actionscript:
1. [SWF(width = 500, height=500, backgroundColor = 0x000000)]
2. x = stage.stageWidth / 2;
3. y = stage.stageHeight / 2;
4. var quadNum:int = 2200;
5. // standard Vectors for using drawTriangles
6. var verts:Vector.<Number> = new Vector.<Number>();
7. var pVerts:Vector.<Number>;
8. var uvts:Vector.<Number> = new Vector.<Number>();
9. var indices:Vector.<int> = new Vector.<int>();
10. // needed for z-sorting
11. var sortedIndices:Vector.<int>;
12. var faces:Array = [];
13. // we'll use this for tranforming points
14. // and as the transformation matrix for our render
15. var m:Matrix3D = new Matrix3D();
16. // plot a quad
17. var quad:Vector.<Number>;
18. quad = Vector.<Number>([-10, -10, 0,
19.                         10, -10, 0,
20.                         -10, 10, 0,
21.                         10, 10, 0]);
22. // temp vect for any transformed quads
23. var transQuad:Vector.<Number> = new Vector.<Number>();
24. var i:int;
25. var inc:int = 0;
26. for (i = 0; i<quadNum; i++){
27.     m.identity();
28.     var s:Number = (int(Math.random()*50) == 1) ? 2 + Math.random()*2 : .1 + Math.random() * 2;
29.     m.appendScale(s, s, 1);
30.     m.appendRotation(90, Vector3D.Y_AXIS);
31.     var mult:Number = 100 + Math.random()*200;
32.     m.appendTranslation(mult, 0, 0);
33.     m.appendRotation(Math.random()*360, Vector3D.X_AXIS);
34.     m.appendRotation(Math.random()*360, Vector3D.Y_AXIS);
35.     m.appendRotation(Math.random()*360, Vector3D.Z_AXIS);
36.     m.transformVectors(quad, transQuad);
37.     verts = verts.concat(transQuad);
38.     faces.push(new Vector3D());
39.     faces.push(new Vector3D());
40.     var i4:int = i * 4;
41.     indices.push(0 + i4, 1 + i4, 2 + i4,
42.                  1 + i4, 3 + i4, 2 + i4);
43.     mult /= 300;
44.     uvts.push(mult,mult,0,
45.               mult+.1,mult,0,
46.               mult,mult - .1,0,
47.               mult + .1,mult + .1,0);
48. }
49. sortedIndices = new Vector.<int>(indices.length, true);
50. // create texture
51. var tex:BitmapData = new BitmapData(400,400,false, 0x000000);
52. var grad:Shape = new Shape();
53. var mat:Matrix = new Matrix();
54. mat.createGradientBox(400,400,0,0,0);
55. with (grad.graphics){
56.     beginGradientFill(GradientType.LINEAR, [0xFFFFFF,0x002244], [1, 1], [100, 255], mat);
57.     drawRect(0,0,400,400);
58. }
59. tex.draw(grad);
60. // create background
61. mat.createGradientBox(1600,1200,0,-550, 0);
62. with (grad.graphics){
63.     beginGradientFill(GradientType.RADIAL, [0x000000, 0x001133], [1, 1], [0, 255], mat);
64.     drawRect(0,0,500,500);
65. }
66. grad.x = -stage.stageWidth/2
67. grad.y = -stage.stageHeight/2;
68. addChild(grad);
69. // triangles will be drawn to this
70. var render:Shape = Shape(addChild(new Shape()));
71. // fix all vector lengths
72. verts.fixed = true, uvts.fixed = true, indices.fixed = true
73. pVerts = new Vector.<Number>(verts.length/3 * 2, true);
74. // we need these if we want perspective
75. var persp:PerspectiveProjection = new PerspectiveProjection();
76. persp.fieldOfView = 45;
77. // projection matrix
78. var proj:Matrix3D = persp.toMatrix3D();
79. var dx:Number = 0, dy:Number = 0;
80. addEventListener(Event.ENTER_FRAME, onLoop);
81. function onLoop(evt:Event):void {
82.     dx += (mouseX - dx) / 4;
83.     dy += (mouseY - dy) / 4;
84.     m.identity();
85.     m.appendRotation(dy, Vector3D.X_AXIS);
86.     m.appendRotation(dx, Vector3D.Y_AXIS);
87.     m.appendTranslation(0,0,800);
88.     m.append(proj);
89.     Utils3D.projectVectors(m, verts, pVerts, uvts);
90.     var face:Vector3D;
91.     inc = 0;
92.     for (var i:int = 0; i<indices.length; i+=3){
93.         face = faces[inc];
94.         face.x = indices[i];
95.         face.y = indices[int(i + 1)];
96.         face.z = indices[int(i + 2)];
97.         var i3:int = i * 3;
98.         face.w = (uvts[int(face.x*3 + 2)] + uvts[int(face.y*3 + 2)] + uvts[int(face.z*3 + 2)]) * 0.333333;
99.         inc++;
100.     }
101.     faces.sortOn("w", Array.NUMERIC);
102.     inc = 0;
103.     for each (face in faces){
104.         sortedIndices[inc++] = face.x;
105.         sortedIndices[inc++] = face.y;
106.         sortedIndices[inc++] = face.z;
107.     }
108.     render.graphics.clear();
109.     render.graphics.beginBitmapFill(tex, null, false, false);
110.     render.graphics.drawTriangles(pVerts, sortedIndices, uvts, TriangleCulling.NEGATIVE);
111. }

Expanding again on the z-sorting demos from the last few days - this snippet uses UV coords and a gradient to create something that vaguely resembles a light. Unlike the previous demos, the 3D cluster in this snippet is made up of quads - requiring a slight adjustment to the depth calculation.

Have a look at the swf...

Also posted in 3D, Graphics, matrix, misc, sortOn | Tagged , , , | 2 Comments

## More z-sorting

Actionscript:
1. [SWF(width = 500, height=500, backgroundColor = 0x333333)]
2. x = stage.stageWidth / 2;
3. y = stage.stageHeight / 2;
4.
5.
6. var polyNum:int = 3000;
7. // standard Vectors for using drawTriangles
8. var verts:Vector.<Number> = new Vector.<Number>();
9. var pVerts:Vector.<Number>;
10. var uvts:Vector.<Number> = new Vector.<Number>();
11. var indices:Vector.<int> = new Vector.<int>();
12. // needed for z-sorting
13. var sortedIndices:Vector.<int>;
14. var faces:Array = [];
15.
16. // we'll use this for tranforming points
17. // and as the transormation matrix for our render
18. var m:Matrix3D = new Matrix3D();
19.
20. // plot a poly
21. var poly:Vector.<Number>;
22. poly = Vector.<Number>([ 0, 0, 0,
23.                         10, 0, 0,
24.                         0,10, 0]);
25.
26. // temp vect for any transformed polygons
27. var transPoly:Vector.<Number> = new Vector.<Number>();
28.
29. var i:int;
30. var inc:int = 0;
31. for (i = 0; i<polyNum; i++){
32.     m.identity();
33.     var s:Number = (int(Math.random()*50) == 1) ? 4 + Math.random()*2 : 1 + Math.random() * 2;
34.     m.appendScale(s, s, 1);
35.     m.appendRotation(Math.random()*360, Vector3D.X_AXIS);
36.     m.appendRotation(Math.random()*360, Vector3D.Y_AXIS);
37.     m.appendRotation(Math.random()*360, Vector3D.Z_AXIS);
38.     m.appendTranslation(200,0,0);
39.
40.     m.appendRotation(Math.random()*360, Vector3D.X_AXIS);
41.     m.appendRotation(Math.random()*360, Vector3D.Y_AXIS);
42.     m.appendRotation(Math.random()*360, Vector3D.Z_AXIS);
43.
44.     m.transformVectors(poly, transPoly);
45.
46.     verts = verts.concat(transPoly);
47.     faces.push(new Vector3D());
48.     indices.push(inc++, inc++, inc++);
49.     uvts.push(Math.random(), Math.random(), 0, Math.random(), Math.random(), 0, Math.random(), Math.random(), 0);
50. }
51.
52. sortedIndices = new Vector.<int>(indices.length, true);
53.
54. // create texture
55. var tex:BitmapData = new BitmapData(400,400,false, 0x000000);
56. var grad:Shape = new Shape();
57. var mat:Matrix = new Matrix();
58. mat.createGradientBox(400,400,0,0,0);
59. with (grad.graphics){
60.     beginGradientFill(GradientType.LINEAR, [0x000000, 0xAA0000, 0xFFFF00], [1, 1, 1], [20, 200, 255], mat);
61.     drawRect(0,0,400,400);
62. }
63. tex.draw(grad);
64.
65. // create background
66. mat.createGradientBox(1600,1000,0,-550, -100);
67. with (grad.graphics){
68.     beginGradientFill(GradientType.RADIAL, [0x333333, 0xffffff], [1, 1], [0, 255], mat);
69.     drawRect(0,0,500,500);
70. }
71. grad.x = -stage.stageWidth/2
72. grad.y = -stage.stageHeight/2;
73. addChild(grad);
74.
75. // triangles will be drawn to this
76. var render:Shape = Shape(addChild(new Shape()));
77.
78. // fix all vector lengths
79. verts.fixed = true, uvts.fixed = true, indices.fixed = true
80. pVerts = new Vector.<Number>(verts.length/3 * 2, true);
81.
82. // we need these if we want perspective
83. var persp:PerspectiveProjection = new PerspectiveProjection();
84. persp.fieldOfView = 45;
85. // projection matrix
86. var proj:Matrix3D = persp.toMatrix3D();
87.
88. var dx:Number = 0, dy:Number = 0;
89. addEventListener(Event.ENTER_FRAME, onLoop);
90. function onLoop(evt:Event):void {
91.     dx += (mouseX - dx) / 4;
92.     dy += (mouseY - dy) / 4;
93.     m.identity();
94.     m.appendRotation(dy, Vector3D.X_AXIS);
95.     m.appendRotation(dx, Vector3D.Y_AXIS);
96.     // push everything back so its not to close
97.     m.appendTranslation(0,0,800);
98.     // append the projection matrix at the end
99.     m.append(proj);
100.
101.     Utils3D.projectVectors(m, verts, pVerts, uvts);
102.
103.     var face:Vector3D;
104.     inc = 0;
105.     for (var i:int = 0; i<indices.length; i+=3){
106.         face = faces[inc];
107.         face.x = indices[i];
108.         // it may look odd, but casting to an int
109.         // when doing operations inside array sytnax
110.         // adds a big speed boost
111.         face.y = indices[int(i + 1)];
112.         face.z = indices[int(i + 2)];
113.         var i3:int = i * 3;
114.         // get the average z position (t value) and store it in the Vector3D w property
115.         // depending on your model, you may not need to do an average of all 3 values
116.         face.w = (uvts[int(i3 + 2)] + uvts[int(i3 + 5)] + uvts[int(i3 + 8)]) * 0.333333;
117.         inc++;
118.     }
119.
120.     // sort on w, so far this beats all other sorting methods for speed,
121.     // faster than Vector.sort(), faster than any custom sort method I could find
122.     faces.sortOn("w", Array.NUMERIC);
123.
124.     // re-order indices so that faces are drawn in the correct order (back to front);
125.     inc = 0;
126.     for each (face in faces){
127.         sortedIndices[inc++] = face.x;
128.         sortedIndices[inc++] = face.y;
129.         sortedIndices[inc++] = face.z;
130.     }
131.
132.     render.graphics.clear();
133.     render.graphics.beginBitmapFill(tex, null, false, false);
134.     render.graphics.drawTriangles(pVerts, sortedIndices, uvts, TriangleCulling.NONE);
135. }

This is a slightly more advanced version of the z-sorting demo from yesterday. Here 3000 polygons are randomly arranged in a sphere formation...

Have a look at the swf...

Also posted in 3D, Graphics, matrix, misc | | 6 Comments

## drawTriangles() & z-sorting

Actionscript:
1. [SWF(width = 500, height=500, backgroundColor = 0x000000)]
2. x = stage.stageWidth / 2;
3. y = stage.stageHeight / 2;
4.
5. // standard Vectors for using drawTriangles and projectVectors
6. var verts:Vector.<Number> = new Vector.<Number>();
7. var pVerts:Vector.<Number>;
8. var uvts:Vector.<Number>;
9. var indices:Vector.<int>;
10. // needed for z-sorting
11. var sortedIndices:Vector.<int>;
12. var faces:Array = [];
13.
14. // we'll use this for transforming points
15. // and as the transformation matrix for our render
16. var m:Matrix3D = new Matrix3D();
17.
18. // plot a poly
19. var poly:Vector.<Number>;
20. poly = Vector.<Number>([ 0, 0, 0,
21.                         10, 0, 0,
22.                         0,10, 0]);
23.
24. verts = verts.concat(poly);
25. faces.push(new Vector3D());
26.
27. // add two more polygons by transorming the poly Vector
28. // and concatenating it to the verts Vector
29. // Vector3D instances are added to the faces
30. // Array for z-sorting
31.
32. // temp vect for any transformed polygons
33. var transPoly:Vector.<Number> = new Vector.<Number>();
34.
35. m.appendRotation(10, Vector3D.Z_AXIS);
36. m.appendTranslation(0,-2,5);
37. m.transformVectors(poly, transPoly);
38.
39. verts = verts.concat(transPoly);
40. faces.push(new Vector3D());
41.
42. m.appendRotation(10, Vector3D.Z_AXIS);
43. m.appendTranslation(0,-2,5);
44. m.transformVectors(poly, transPoly);
45. verts = verts.concat(transPoly);
46. faces.push(new Vector3D());
47.
48. // hard coded indices
49. indices = Vector.<int>([0, 1, 2, 3, 4, 5, 6, 7, 8]);
50. sortedIndices = new Vector.<int>(indices.length, true);
51.
52. // create texture
53. var tex:BitmapData = new BitmapData(100,100,false, 0x000000);
54. tex.fillRect(new Rectangle(0,0,50,50), 0xFF0000);
55. tex.fillRect(new Rectangle(50,0,50,50), 0x0000FF);
56. tex.fillRect(new Rectangle(0,50,50,50), 0x00FF00);
57.
58. // hard coded uvts
59. uvts = Vector.<Number>([0,0,0, .5,0,0, 0,.5,0,
60.                         .53, 0, 0, 1, 0, 0, .53, .5, 0,
61.                          0,.6,.5, 0,.6,0, 0,1, 0]);
62.
63. // fix all vector lengths
64. verts.fixed = true, uvts.fixed = true, indices.fixed = true
65. pVerts = new Vector.<Number>(verts.length/3 * 2, true);
66.
67. // we need these if we want perspective
68. var persp:PerspectiveProjection = new PerspectiveProjection();
69. // projection matrix
70. var proj:Matrix3D = persp.toMatrix3D();
71.
72. addEventListener(Event.ENTER_FRAME, onLoop);
73. function onLoop(evt:Event):void {
74.     m.identity();
75.     m.appendRotation(mouseY * 2, Vector3D.X_AXIS);
76.     m.appendRotation(mouseX * 2, Vector3D.Y_AXIS);
77.     // push everything back so its not too close
78.     m.appendTranslation(0,0,40);
79.     // append the projection matrix at the end
80.     m.append(proj);
81.
82.     Utils3D.projectVectors(m, verts, pVerts, uvts);
83.
84.     var face:Vector3D;
85.     var inc:int = 0;
86.     for (var i:int = 0; i<indices.length; i+=3){
87.         face = faces[inc];
88.         face.x = indices[i];
89.         // it may look odd, but casting to an int
90.         // when doing operations inside array sytnax
91.         // adds a big speed boost
92.         face.y = indices[int(i + 1)];
93.         face.z = indices[int(i + 2)];
94.         var i3:int = i * 3;
95.         // get the average z position (t value) and store it in the Vector3D w property
96.         // depending on your model, you may not need to do an average of all 3 values
97.                 // (t is the distance from the eye to the texture)
98.         face.w = (uvts[int(i3 + 2)] + uvts[int(i3 + 5)] + uvts[int(i3 + 8)]) * 0.333333;
99.         inc++;
100.     }
101.
102.     // sort on w, so far this beats all other sorting methods for speed,
103.     // faster than Vector.sort(), faster than any custom sort method I could find
104.     faces.sortOn("w", Array.NUMERIC);
105.
106.     // re-order indices so that faces are drawn in the correct order (back to front);
107.     inc = 0;
108.     for each (face in faces){
109.         sortedIndices[inc++] = face.x;
110.         sortedIndices[inc++] = face.y;
111.         sortedIndices[inc++] = face.z;
112.     }
113.
114.     graphics.clear();
115.     graphics.beginBitmapFill(tex, null, false, false);
116.     graphics.drawTriangles(pVerts, sortedIndices, uvts, TriangleCulling.NONE);
117. }

So you want to be able to do some z-sorting with drawTriangles()? Well, its extremely unintuitive. Here is what you need to know:

1) Vector.sort() is slow
2) Array.sortOn() is quite fast
3) I couldn't get any custom sorting method to be faster than Array.sortOn
4) You can use the t value from uvts to do z-sorting (like in this demo)
5) If your going for speed, don't forget to use fixed Vectors (I often forget this step)
6) When working with Vectors cast any operations inside brackets to int() (my tests showed this is a huge speed boost up to 3x faster - franky I think it's horrible that you have to do this).

The swf is not very interesting because I wanted to keep it super simple, but here it is anyway...

# Questions

I was told and have read that drawTriangles is slower than using drawGraphicsData and a GraphicsTrianglePath instance. I tested this extensively and found that drawGraphicsData was slower. I'm still not sure which is faster but am up for checking out any simple benchmarks that people have.

drawTriangles is supposed to be faster without adding t values to the uvts Vector. In my benchmark tests there was no real difference in speed. The t value is used to render more accurate textures - which would mean you could potentially use less triangles in your models. One would assume that not using a t value would be faster... but I couldn't confirm this. Again if someone has a good benchmark for this, please let me know.

# Help

I had a great deal of help from a few people on Twitter, Katopz (Away3D contributor) of sleepydesign.com made me aware of the fact that Array.sortOn is the way to go... You can see some great demos over at Katopz's blog. While I didn't end up using a custom sorting method, Inspirit
pointed me to his article about custom Vector sorting methods which proved to be very enlightening. I was able to get some really great results for doing different types of sorting - just sorting 1D Vectors with FlashSort can be very fast (faster than Array.sortOn - but not helpful for sorting a 1D Vector of indices).

I also learned a good deal by looking at this code post by Psyark... I actually optimized that code to run about 2x faster (will post that on wonderfl.net at some point, it just needs to be cleaned up).

kevinSuttle sent me a link to The video

Also posted in 3D, Graphics, matrix | | 3 Comments

• ActionSnippet is on Twitter