模拟液体粒子效果 物理特效

破晓

1. package
   
2. {
   
3.     import flash.display.Bitmap;
   
4.     import flash.display.BitmapData;
   
5.     import flash.display.Graphics;
   
6.     import flash.display.Shape;
   
7.     import flash.display.Sprite;
   
8.     import flash.events.Event;
   
9.     import flash.events.MouseEvent;
   
10.     import flash.filters.BlurFilter;
    
11.     import flash.geom.ColorTransform;
    
12.     import flash.geom.Point;
    
13.     import flash.utils.getTimer;
    
14.    
    
15.     import net.hires.debug.Stats;
    
16. 
    
17.     [SW(width="400", height="400", frameRate="24", backgroundColor="0xFFFFFF")]
    
18.     public class LiquidTest extends Sprite
    
19.     {
    
20.         private var particles:Vector.<Particle> = new Vector.<Particle>();
    
21.         
    
22.         private var gsizeX:int = 100;
    
23.         private var gsizeY:int = 100;
    
24. 
    
25.         private var grid:Vector.<Vector.<Node>>;
    
26.         private var active:Vector.<Node> = new Vector.<Node>();
    
27.         private var g:Graphics;
    
28.         private var water:Material = new Material(1.0, 1.0, 1.0, 1.0, 1.0, 1.0);
    
29.         private var pressed:Boolean;
    
30.         private var pressedprev:Boolean;
    
31. 
    
32.         private var mx:int;
    
33.         private var my:int;
    
34.         private var mxprev:int;
    
35.         private var myprev:int;
    
36. 
    
37.         private var _canvas:BitmapData;
    
38.         private var _blur:BlurFilter = new BlurFilter();
    
39.         private var _color:ColorTransform = new ColorTransform(1.1, 1.1, 1.1);
    
40.         private var _g:Graphics;
    
41.         private var _s:Shape;
    
42.         private var _o:Point = new Point(0, 0);
    
43. 
    
44.         public function LiquidTest()
    
45.         {
    
46.             addEventListener(Event.ADDED_TO_STAGE, init);
    
47.         }
    
48. 
    
49.         public function init(event:Event):void
    
50.         {
    
51.             
    
52.             _canvas = new BitmapData(400, 400, false, 0xFFFFFF);
    
53.             var _bitmap:Bitmap = addChild(new Bitmap(this._canvas)) as Bitmap;
    
54. 
    
55.             _s = new Shape();
    
56.             _g = _s.graphics;
    
57. 
    
58.             var i:int, j:int;
    
59.             grid = new Vector.<Vector.<Node>>(gsizeX, true);
    
60.             for (i = 0; i < gsizeX; i++)
    
61.             {
    
62.                 grid[i] = new Vector.<Node>(gsizeY, true);
    
63.                 for (j = 0; j < gsizeY; j++)
    
64.                 {
    
65.                     grid[i][j] = new Node();
    
66.                 }
    
67.             }
    
68. 
    
69.             stage.addEventListener(Event.ENTER_FRAME, paint);
    
70. 
    
71.             stage.addEventListener(MouseEvent.MOUSE_DOWN, mousePressed);
    
72.             stage.addEventListener(MouseEvent.MOUSE_UP, mouseReleased);
    
73.             stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoved);
    
74. 
    
75.             var p:Particle;
    
76.             for (i = 0; i < 50; i++)
    
77.                 for (j = 0; j < 30; j++)
    
78.                 {
    
79.                     p = new Particle(water, i + 4, j + 4, 0.0, 0.0);
    
80.                     particles.push(p);
    
81.                 }
    
82.             
    
83.             
    
84.             addChild(new Stats());
    
85.         }
    
86. 
    
87.         public function paint(event:Event):void
    
88.         {
    
89.             _canvas.colorTransform(_canvas.rect, _color);
    
90. 
    
91.             simulate();
    
92.             _canvas.lock();
    
93.             for each (var p:Particle in particles)
    
94.             {
    
95.                 _canvas.setPixel32(int(4.0 * p.x), int(4.0 * p.y), 0x22000088);
    
96.                 _canvas.setPixel32(int(4.0 * (p.x - p.u)), int(4.0 * (p.y - p.v)), 0x440000FF);
    
97.             }
    
98. 
    
99.             _canvas.draw(_s);
    
100.             _canvas.applyFilter(_canvas, _canvas.rect, _o, _blur);
     
101.             _canvas.unlock();
     
102.         }
     
103. 
     
104.         public function mouseMoved(event:MouseEvent):void
     
105.         {
     
106.             mx = event.localX;
     
107.             my = event.localY;
     
108.         }
     
109. 
     
110.         public function mousePressed(event:MouseEvent):void
     
111.         {
     
112.             pressed = true;
     
113.         }
     
114. 
     
115.         public function mouseReleased(event:MouseEvent):void
     
116.         {
     
117.             pressed = false;
     
118.         }
     
119. 
     
120.         public function simulate():void
     
121.         {
     
122.             var drag:Boolean = false;
     
123.             var mdx:Number = 0.0, mdy:Number = 0.0;
     
124.             if (pressed && pressedprev)
     
125.             {
     
126.                 drag = true;
     
127.                 mdx = 0.25 * (mx - mxprev);
     
128.                 mdy = 0.25 * (my - myprev);
     
129.             }
     
130. 
     
131.             pressedprev = pressed;
     
132.             mxprev = mx;
     
133.             myprev = my;
     
134. 
     
135.             var n:Node, p:Particle;
     
136.             for each (n in active)
     
137.                 n.clear();
     
138.             active.length = 0;
     
139. 
     
140.             var i:int, j:int;
     
141.             var x:Number, y:Number, phi:Number;
     
142.             var fx:Number = 0.0, fy:Number = 0.0;
     
143.             for each (p in particles)
     
144.             {
     
145.                 p.cx = int(p.x - 0.5);
     
146.                 p.cy = int(p.y - 0.5);
     
147. 
     
148.                 x = p.cx - p.x;
     
149.                 p.px[0] = (0.5 * x * x + 1.5 * x + 1.125);
     
150.                 p.gx[0] = (x + 1.5);
     
151.                 x += 1.0;
     
152.                 p.px[1] = (-x * x + 0.75);
     
153.                 p.gx[1] = (-2.0 * x);
     
154.                 x += 1.0;
     
155.                 p.px[2] = (0.5 * x * x - 1.5 * x + 1.125);
     
156.                 p.gx[2] = (x - 1.5);
     
157. 
     
158.                 y = p.cy - p.y;
     
159.                 p.py[0] = (0.5 * y * y + 1.5 * y + 1.125);
     
160.                 p.gy[0] = (y + 1.5);
     
161.                 y += 1.0;
     
162.                 p.py[1] = (-y * y + 0.75);
     
163.                 p.gy[1] = (-2.0 * y);
     
164.                 y += 1.0;
     
165.                 p.py[2] = (0.5 * y * y - 1.5 * y + 1.125);
     
166.                 p.gy[2] = (y - 1.5);
     
167. 
     
168.                 for (i = 0; i < 3; i++)
     
169.                 {
     
170.                     for (j = 0; j < 3; j++)
     
171.                     {
     
172.                         n = grid[p.cx + i][p.cy + j];
     
173.                         if (!n.active)
     
174.                         {
     
175.                             active.push(n);
     
176.                             n.active = true;
     
177.                         }
     
178.                         phi = p.px[i] * p.py[j];
     
179.                         n.m += phi * p.mat.m;
     
180.                         n.d += phi;
     
181.                         n.gx += p.gx[i] * p.py[j];
     
182.                         n.gy += p.px[i] * p.gy[j];
     
183.                     }
     
184.                 }
     
185.             }
     
186. 
     
187.             var density:Number, pressure:Number, weight:Number;
     
188.             var n01:Node, n02:Node;
     
189.             var n11:Node, n12:Node;
     
190.             var cx:int, cy:int;
     
191.             var cxi:int, cyi:int;
     
192. 
     
193.             var pdx:Number, pdy:Number;
     
194.             var C20:Number, C02:Number, C30:Number, C03:Number;
     
195.             var csum1:Number, csum2:Number;
     
196.             var C21:Number, C31:Number, C12:Number, C13:Number, C11:Number;
     
197. 
     
198.             var u:Number, u2:Number, u3:Number;
     
199.             var v:Number, v2:Number, v3:Number;
     
200. 
     
201.             for each (p in particles)
     
202.             {
     
203.                 cx = int(p.x);
     
204.                 cy = int(p.y);
     
205.                 cxi = cx + 1;
     
206.                 cyi = cy + 1;
     
207. 
     
208.                 n01 = grid[cx][cy];
     
209.                 n02 = grid[cx][cyi];
     
210.                 n11 = grid[cxi][cy];
     
211.                 n12 = grid[cxi][cyi];
     
212. 
     
213.                 pdx = n11.d - n01.d;
     
214.                 pdy = n02.d - n01.d;
     
215.                 C20 = 3.0 * pdx - n11.gx - 2.0 * n01.gx;
     
216.                 C02 = 3.0 * pdy - n02.gy - 2.0 * n01.gy;
     
217.                 C30 = -2.0 * pdx + n11.gx + n01.gx;
     
218.                 C03 = -2.0 * pdy + n02.gy + n01.gy;
     
219.                 csum1 = n01.d + n01.gy + C02 + C03;
     
220.                 csum2 = n01.d + n01.gx + C20 + C30;
     
221.                 C21 = 3.0 * n12.d - 2.0 * n02.gx - n12.gx - 3.0 * csum1 - C20;
     
222.                 C31 = -2.0 * n12.d + n02.gx + n12.gx + 2.0 * csum1 - C30;
     
223.                 C12 = 3.0 * n12.d - 2.0 * n11.gy - n12.gy - 3.0 * csum2 - C02;
     
224.                 C13 = -2.0 * n12.d + n11.gy + n12.gy + 2.0 * csum2 - C03;
     
225.                 C11 = n02.gx - C13 - C12 - n01.gx;
     
226. 
     
227.                 u = p.x - cx;
     
228.                 u2 = u * u;
     
229.                 u3 = u * u2;
     
230.                 v = p.y - cy;
     
231.                 v2 = v * v;
     
232.                 v3 = v * v2;
     
233.                 density = n01.d + n01.gx * u + n01.gy * v + C20 * u2 + C02 * v2 + C30 * u3 + C03 * v3 + C21 * u2 * v + C31 * u3 * v + C12 * u * v2 + C13 * u * v3 + C11 * u * v;
     
234. 
     
235.                 pressure = density - 1.0;
     
236.                 if (pressure > 2.0)
     
237.                     pressure = 2.0;
     
238. 
     
239.                 fx = 0.0;
     
240.                 fy = 0.0;
     
241. 
     
242.                 if (p.x < 4.0)
     
243.                     fx += p.mat.m * (4.0 - p.x);
     
244.                 else if (p.x > gsizeX - 5)
     
245.                     fx += p.mat.m * (gsizeX - 5 - p.x);
     
246. 
     
247.                 if (p.y < 4.0)
     
248.                     fy += p.mat.m * (4.0 - p.y);
     
249.                 else if (p.y > gsizeY - 5)
     
250.                     fy += p.mat.m * (gsizeY - 5 - p.y);
     
251. 
     
252.                 if (drag)
     
253.                 {
     
254.                     var vx:Number = Math.abs(p.x - 0.25 * mx);
     
255.                     var vy:Number = Math.abs(p.y - 0.25 * my);
     
256.                     if ((vx < 10.0) && (vy < 10.0))
     
257.                     {
     
258.                         weight = p.mat.m * (1.0 - vx * 0.10) * (1.0 - vy * 0.10);
     
259.                         fx += weight * (mdx - p.u);
     
260.                         fy += weight * (mdy - p.v);
     
261.                     }
     
262.                 }
     
263. 
     
264.                 for (i = 0; i < 3; i++)
     
265.                 {
     
266.                     for (j = 0; j < 3; j++)
     
267.                     {
     
268.                         n = grid[(p.cx + i)][(p.cy + j)];
     
269.                         phi = p.px[i] * p.py[j];
     
270.                         n.ax += -((p.gx[i] * p.py[j]) * pressure) + fx * phi;
     
271.                         n.ay += -((p.px[i] * p.gy[j]) * pressure) + fy * phi;
     
272.                     }
     
273.                 }
     
274.             }
     
275. 
     
276.             for each (n in active)
     
277.             {
     
278.                 if (n.m > 0.0)
     
279.                 {
     
280.                     n.ax /= n.m;
     
281.                     n.ay /= n.m;
     
282.                     n.ay += 0.03;
     
283.                 }
     
284.             }
     
285. 
     
286.             var mu:Number, mv:Number;
     
287.             for each (p in particles)
     
288.             {
     
289.                 for (i = 0; i < 3; i++)
     
290.                 {
     
291.                     for (j = 0; j < 3; j++)
     
292.                     {
     
293.                         n = grid[(p.cx + i)][(p.cy + j)];
     
294.                         phi = p.px[i] * p.py[j];
     
295.                         p.u += phi * n.ax;
     
296.                         p.v += phi * n.ay;
     
297.                     }
     
298.                 }
     
299.                 mu = p.mat.m * p.u;
     
300.                 mv = p.mat.m * p.v;
     
301.                 for (i = 0; i < 3; i++)
     
302.                 {
     
303.                     for (j = 0; j < 3; j++)
     
304.                     {
     
305.                         n = grid[(p.cx + i)][(p.cy + j)];
     
306.                         phi = p.px[i] * p.py[j];
     
307.                         n.u += phi * mu;
     
308.                         n.v += phi * mv;
     
309.                     }
     
310.                 }
     
311.             }
     
312. 
     
313.             for each (n in active)
     
314.             {
     
315.                 if (n.m > 0.0)
     
316.                 {
     
317.                     n.u /= n.m;
     
318.                     n.v /= n.m;
     
319.                 }
     
320.             }
     
321. 
     
322.             var gu:Number, gv:Number;
     
323.             for each (p in particles)
     
324.             {
     
325.                 gu = 0.0;
     
326.                 gv = 0.0;
     
327.                 for (i = 0; i < 3; i++)
     
328.                 {
     
329.                     for (j = 0; j < 3; j++)
     
330.                     {
     
331.                         n = grid[(p.cx + i)][(p.cy + j)];
     
332.                         phi = p.px[i] * p.py[j];
     
333.                         gu += phi * n.u;
     
334.                         gv += phi * n.v;
     
335.                     }
     
336.                 }
     
337.                 p.x += gu;
     
338.                 p.y += gv;
     
339.                 p.u += 1.0 * (gu - p.u);
     
340.                 p.v += 1.0 * (gv - p.v);
     
341.                 if (p.x < 1.0)
     
342.                 {
     
343.                     p.x = (1.0 + Math.random() * 0.01);
     
344.                     p.u = 0.0;
     
345.                 }
     
346.                 else if (p.x > gsizeX - 2)
     
347.                 {
     
348.                     p.x = (gsizeX - 2 - Math.random() * 0.01);
     
349.                     p.u = 0.0;
     
350.                 }
     
351.                 if (p.y < 1.0)
     
352.                 {
     
353.                     p.y = (1.0 + Math.random() * 0.01);
     
354.                     p.v = 0.0;
     
355.                 }
     
356.                 else if (p.y > gsizeY - 2)
     
357.                 {
     
358.                     p.y = (gsizeY - 2 - Math.random() * 0.01);
     
359.                     p.v = 0.0;
     
360.                 }
     
361.             }
     
362.         }
     
363.     }
     
364. }
     
365. 
     
366. class Node
     
367. {
     
368.     public var m:Number = 0;
     
369.     public var d:Number = 0;
     
370.     public var gx:Number = 0;
     
371.     public var gy:Number = 0;
     
372.     public var u:Number = 0;
     
373.     public var v:Number = 0;
     
374.     public var ax:Number = 0;
     
375.     public var ay:Number = 0;
     
376.     public var active:Boolean;
     
377.    
     
378.     public function clear():void
     
379.     {
     
380.         m = d = gx = gy = u = v = ax = ay = 0.0;
     
381.         active = false;
     
382.     }
     
383. }
     
384. 
     
385. class Particle
     
386. {
     
387.     public var mat:Material;
     
388.     public var x:Number;
     
389.     public var y:Number;
     
390.     public var u:Number;
     
391.     public var v:Number;
     
392.     public var dudx:Number = 0;
     
393.     public var dudy:Number = 0;
     
394.     public var dvdx:Number = 0;
     
395.     public var dvdy:Number = 0;
     
396.     public var cx:int;
     
397.     public var cy:int;
     
398.     public var px:Vector.<Number> = new Vector.<Number>(3, true);
     
399.     public var py:Vector.<Number> = new Vector.<Number>(3, true);
     
400.     public var gx:Vector.<Number> = new Vector.<Number>(3, true);
     
401.     public var gy:Vector.<Number> = new Vector.<Number>(3, true);
     
402.    
     
403.     public function Particle(mat:Material, x:Number, y:Number, u:Number, v:Number)
     
404.     {
     
405.         this.mat = mat;
     
406.         this.x = x;
     
407.         this.y = y;
     
408.         this.u = u;
     
409.         this.v = v;
     
410.     }
     
411. }
     
412. 
     
413. class Material
     
414. {
     
415.     public var m:Number;
     
416.     public var rd:Number;
     
417.     public var k:Number;
     
418.     public var v:Number;
     
419.     public var d:Number;
     
420.     public var g:Number;
     
421.    
     
422.     public function Material(m:Number, rd:Number, k:Number, v:Number, d:Number, g:Number)
     
423.     {
     
424.         this.m = m;
     
425.         this.rd = rd;
     
426.         this.k = k;
     
427.         this.v = v;
     
428.         this.d = d;
     
429.         this.g = g;
     
430.     }
     
431. }

复制代码

本文来自：http://wonderfl.net/c/yxe9