Tutorial on making fireworks effect with HTML5

Time:2021-12-25

It’s new year’s day. All I think about is setting off fireworks…. So canvas wrote what is too laggy, and the clicks will also produce fireworks. But don’t create too much pyrotechnics. A fireworks particle is 30 to 200. When the number of particles on the page reaches a certain level, the page will be stuck. I have no intention to optimize the Shenma. Let’s talk about it later.

Go directly to demo:Set off fireworks 

The principle is simple… Write a pyrotechnic class and debris class, instantiate it and let it fly. Then, after reaching a certain point, set the dead attribute of the pyrotechnic object to true, then instantiate a certain number of debris objects, give the debris objects a random target point to reach, and then let all debris objects fly past.

[fireworks]

XML/HTML CodeCopy contents to clipboard
  1. var Boom = function(x, R, C, boomarea, shape) {/ / fireworks object
  2.             this.booms = [];   
  3.             this.x = x;   
  4.             this.y = (canvas.height+r);   
  5.             this.r = r;   
  6.             this.c = c;   
  7.             this.shape = shape || false;   
  8.             this.boomArea = boomArea;   
  9.             this.theta = 0;   
  10.             this.dead = false;   
  11.             this.ba = parseInt(getRandom(80 , 200));   
  12.         }   
  13.         Boom.prototype = {   
  14.             _paint:function(){     
  15.                 ctx.save();   
  16.                 ctx.beginPath();   
  17.                 ctx.arc(this.x,this.y,this.r,0,2*Math.PI);   
  18.                 ctx.fillStyle = this.c;   
  19.                 ctx.fill();   
  20.                 ctx.restore();   
  21.             },   
  22.             _move:function(){   
  23.                 var dx = this.boomArea.x – this.x , dy = this.boomArea.y – this.y;   
  24.                 thisthis.x = this.x+dx*0.01;   
  25.                 thisthis.y = this.y+dy*0.01;   
  26.   
  27.                 if(Math.abs(dx)<=this.ba && Math.abs(dy)<=this.ba){   
  28.                     if(this.shape){   
  29.                         this._shapBoom();   
  30.                     }   
  31.                     else this._boom();   
  32.                     this.dead = true;   
  33.                 }   
  34.                 else {   
  35.                     this._paint();   
  36.                 }   
  37.             },   
  38.             _drawLight:function(){   
  39.                 ctx.save();   
  40.                 ctx.fillStyle = “rgba(255,228,150,0.3)”;   
  41.                 ctx.beginPath();   
  42.                 ctx.arc(this.x , this.y , this.r+3*Math.random()+1 , 0 , 2*Math.PI);   
  43.                 ctx.fill();   
  44.                 ctx.restore();   
  45.             },   
  46. _ Boom: function() {/ / normal explosion
  47.                 var fragNum = getRandom(30 , 200);   
  48.                 var style = getRandom(0,10)>=5? 1 : 2;   
  49.                 var color;   
  50.                 if(style===1){   
  51.                     color = {   
  52.                         a:parseInt(getRandom(128,255)),   
  53.                         b:parseInt(getRandom(128,255)),   
  54.                         c:parseInt(getRandom(128,255))   
  55.                     }   
  56.                 }   
  57.   
  58.                 var fanwei = parseInt(getRandom(300, 400));   
  59.                 for(var i=0;i<fragNum;i++){   
  60.                     if(style===2){   
  61.                         color = {   
  62.                             a:parseInt(getRandom(128,255)),   
  63.                             b:parseInt(getRandom(128,255)),   
  64.                             c:parseInt(getRandom(128,255))   
  65.                         }   
  66.                     }   
  67.                     var a = getRandom(-Math.PI, Math.PI);   
  68.                     var x = getRandom(0, fanwei) * Math.cos(a) + this.x;   
  69.                     var y = getRandom(0, fanwei) * Math.sin(a) + this.y;    
  70.                     var radius = getRandom(0 , 2)   
  71.                     var frag = new Frag(this.x , this.y , radius , color , x , y );   
  72.                     this.booms.push(frag);   
  73.                 }   
  74.             },   
  75. _ Shapboom: function() {/ / explosion with shape
  76.                 var that = this;   
  77.                 putValue(ocas , octx , this.shape , 5, function(dots){   
  78.                     var dx = canvas.width/2-that.x;   
  79.                     var dy = canvas.height/2-that.y;   
  80.                     for(var i=0;i<dots.length;i++){   
  81.                         color = {a:dots[i].a,b:dots[i].b,c:dots[i].c}   
  82.                         var x = dots[i].x;   
  83.                         var y = dots[i].y;   
  84.                         var radius = 1;   
  85.                         var frag = new Frag(that.x , that.y , radius , color , x-dx , y-dy);   
  86.                         that.booms.push(frag);   
  87.                     }   
  88.                 })   
  89.             }   
  90.         }   

[debris]

XML/HTML CodeCopy contents to clipboard
  1. var Frag = function(centerx, centery, radius, color, TX, ty) {/ / pyrotechnic debris object
  2.             this.tx = tx;   
  3.             this.ty = ty;   
  4.             this.x = centerX;   
  5.             this.y = centerY;   
  6.             this.dead = false;   
  7.             this.centerX = centerX;   
  8.             this.centerY = centerY;   
  9.             this.radius = radius;   
  10.             this.color = color;   
  11.         }   
  12.   
  13.         Frag.prototype = {   
  14.             paint:function(){   
  15.                 ctx.save();   
  16.                 ctx.beginPath();   
  17.                 ctx.arc(this.x , this.y , this.radius , 0 , 2*Math.PI);   
  18.                 ctx.fillStyle = “rgba(“+this.color.a+”,”+this.color.b+”,”+this.color.c+”,1)”;   
  19.                 ctx.fill()   
  20.                 ctx.restore();   
  21.             },   
  22.             moveTo:function(index){   
  23.                 thisthis.ty = this.ty+0.3;   
  24.                 var dx = this.tx – this.x , dy = this.ty – this.y;   
  25.                 this.x = Math.abs(dx)<0.1 ? this.tx : (this.x+dx*0.1);   
  26.                 this.y = Math.abs(dy)<0.1 ? this.ty : (this.y+dy*0.1);   
  27.                 if(dx===0 && Math.abs(dy)<=80){   
  28.                     this.dead = true;   
  29.                 }   
  30.                 this.paint();   
  31.             }   
  32.         }  

It is also very simple to make the debris produce virtual shadow. Each time you refresh the canvas, instead of erasing and redrawing, you draw the background color with a transparency of 0.1 (if you want to make the virtual shadow longer, you can make this value smaller). Then the virtual shadow can be made. That is:

           

XML/HTML CodeCopy contents to clipboard
  1. ctx.save();   
  2.             ctx.fillStyle = “rgba(0,5,24,0.1)”;   
  3.             ctx.fillRect(0,0,canvas.width,canvas.height);   
  4.             ctx.restore();  

It’s also very simple to make fireworks form the shape you want, such as fonts, pictures, etc. you can do it through off screen canvas and getimagedata of canvas. Off screen canvas, as the name suggests, is off screen, that is, invisible canvas. Use document directly in JS CreateElement (“canvas”) can generate a canvas DOM object. As long as the DOM object is not assigned to the body, the canvas object is equivalent to an off screen object. We can get the context object of the off screen canvas, and then do anything we want to do where the user can’t see it.

To make the fireworks form the shape we want, first draw the text or picture on the off screen canvas, then use getimagedata to obtain the pixel array on the canvas, and then traverse the array to obtain the colored pixels, that is, the content we want, save them, and then display them in the main canvas object.

The pixel processing of getimagedata has been mentioned in my previous blog. If it won’t be used, please stamp: just talk about using canvas to realize text and image granulation

Source address:https://github.com/whxaxes/canvas-test/tree/gh-pages/src/Funny-demo/shotFire