精华内容
下载资源
问答
  • canvas动画
    2020-12-30 22:05:52

    vue-canvas-effect

    canvas动画合集Vue组件

    [? online demo](https://chenxuan0000.github.io/vue-canvas-effect/index.html)

    内容

    浏览器兼容

    ie9+

    安装

    NPM

    npm install vue-canvas-effect --save

    使用

    ES6

    按需加载

    推荐

    首先安装babel-plugin-import依赖

    npm install babel-plugin-import --save-dev

    然后修改 .babelrc文件

    // .babelrc

    {

    "plugins": [["import", {

    "libraryName": "vue-canvas-effect",

    "libraryDirectory": "src/components"

    }]]

    }

    然后,如果你需要neon组件,编辑main.js

    import Vue from 'vue'

    import {neon} from 'vue-canvas-effect';

    Vue.component(neon.name, neon);

    `or`

    Vue.component('customName', neon);

    new Vue({

    el: '#app',

    render: h => h(App)

    })

    全部引入

    不推荐

    import Vue from 'vue'

    import vueCanvas from 'vue-canvas-effect';

    Vue.use(vueCanvas)

    new Vue({

    el: '#app',

    render: h => h(App)

    })

    普通模式

    script 标签

    ...

    new Vue({

    el: '#app'

    })

    组件列表

    neon

    name: neonEffect

    // 默认标签名

    //default options

    {

    len: 20, //五边形的单边长度

    count: 50, //多少线重叠

    rate: 20, //速度 越小越快

    dieChance: 0.05, //单次绘画失败进行重绘的几率

    sparkChance: 0.1, //[0,1] 越大画出的五边形越多重

    sparkDist: 10, //闪烁点的距离

    sparkSize: 2,//闪烁点的大小

    contentLight: 60, // [0,100] 色块的亮度

    shadowToTimePropMult: 6, //五边形的内环阴影大小

    bgColorArr: [0, 0, 0] //背景色数组

    }

    bubbles

    name: bubblesEffect

    // 默认标签名

    //default options

    {

    color: 'rgba(225,225,225,0.5)', //气泡颜色

    radius: 15, //气泡半径

    densety: 0.3, // 气泡密度 越大越密集(建议不要大于1)

    clearOffset: 0.2 // 气泡消失距离[0-1] 越大越晚消失

    }

    修改日志

    See the GitHub 查看历史版本.

    贡献

    欢迎给出一些意见和优化,期待你的 Pull Request。

    TKS

    更多相关内容
  • 今天我从html5tricks网站上整理了8款令人惊叹的HTML5Canvas动画教程,大家可以一起来看看。HTML53D动画实现起来非常方便,之前介绍过基于jQuery的3D旋转插件是利用多张多视角图片播放来实现的,而今天分享的这款...
  • 本项目是为一套简单的小程序动画库 整体实现参考的cocos,API设置参考了cocos和laya 目前只支持本地图片和label渲染,后面有空再添加
  • SN-Animation:Canvas动画

    2021-05-18 21:17:23
    snanimation canvas 动画库 一个基于Canvas动画库,主要使用多帧精灵图以及修改精灵显示属性实现动画
  • 主要介绍了Html5 Canvas动画基础碰撞检测的实现的相关资料,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 像素渐变背景Canvas动画是一款基于HTML5 Canvas绘制的全屏渐变颜色背景,自动像素渐变背景颜色切换动画特效。
  • 用户通过上传合适尺寸的图片,选着渲染动画的效果和音乐,可以预览类似幻灯片的效果,最后点击确认生成视频,可以放到头条或者抖音播放。... canvas动画和截图在服务器端运行,后端根据标识获取截图 利用FFmpeg将图片
  • 构建canvas动画框架

    2021-03-02 09:14:19
    最近一直在做canvas动画效果,发现canvas这个东西做动画不是不可以。相对于flash,它太底层。如果有给力的编辑器或者给力的框架的话,它就能发挥出更大的威力。于是决定自己写一个简单一点的动画框架,以便能更方便...
  • Canvas动画

    千次阅读 2019-07-23 14:02:36
    1:Canvas动画原理 快速切换的静态画面。 2:基本步骤 绘制 - 清空 - 绘制 - 清空 - 绘制 … 3:控制函数 setTimeout setInterval requestAnimationFrame 4:四种运动 线性运动 const canvas = document....

    1:Canvas动画原理

    快速切换的静态画面。

    2:基本步骤

    • 绘制 - 清空 - 绘制 - 清空 - 绘制 …

    3:控制函数

    • setTimeout
    • setInterval
    • requestAnimationFrame

    4:四种运动

    线性运动

        const canvas = document.getElementById('canvas');
            /* 获得 2d 上下文对象 */
            const ctx = canvas.getContext('2d');
        
            let radialGradient;
            let distance = -50;
            const speed = 5;
        
            const draw = (axisX) => {
                /* 清空画布(或部分清空) */
                ctx.clearRect(0, 0, 600, 600);
                radialGradient = ctx.createRadialGradient(distance, 300, 10, distance, 300, 50);
                radialGradient.addColorStop(0, "#FFFFFF");
                radialGradient.addColorStop(1, "#EA7F26");
                ctx.fillStyle = radialGradient;
        
                ctx.beginPath();
                ctx.moveTo(distance, 300);
                ctx.arc(distance, 300, 50, 0, 2 * Math.PI, false);
                ctx.fill();
                
                distance = distance + speed;
                
                if (distance > 650) distance = -50;
        
                requestAnimationFrame(draw);
            }
        
            requestAnimationFrame(draw);ctx.clearRect(0, 0, 600, 600);
        
        ctx.beginPath();
        ctx.moveTo(distance, 300);
        ctx.arc(distance, 300, 50, 0, 2 * Math.PI, false);
        ctx.fill();
        
        distance = distance + speed;
    

    从左到右匀速运动
    在这里插入图片描述

    变速运动

        const canvas = document.getElementById('canvas');
            /* 获得 2d 上下文对象 */
            const ctx = canvas.getContext('2d');
        
            let radialGradient;
            let distance = 50;
            const speed = 5;
        
            let count = 1;
        
            /*
            * h = 9.8 * (Math.pow(t, 2)) / 2
            */
        
            const draw = (axisX) => {
                /* 清空画布(或部分清空) */
                ctx.clearRect(0, 0, 600, 600);
                radialGradient = ctx.createRadialGradient(300, distance, 10, 300, distance, 50);
                radialGradient.addColorStop(0, "#FFFFFF");
                radialGradient.addColorStop(1, "#EA7F26");
                ctx.fillStyle = radialGradient;
        
                ctx.beginPath();
                ctx.moveTo(300, distance);
                ctx.arc(300, distance, 50, 0, 2 * Math.PI, false);
                ctx.fill();
        
                count += 1;
        
                distance = 9.8 * (Math.pow(count, 2)) / 100;
                if (distance > 650) {
                    distance = -50;
                    count = 1;
                }
        
                requestAnimationFrame(draw);
            }
        
            requestAnimationFrame(draw);
    

    从上到下模拟自由落体运动
    在这里插入图片描述

    函数运动(正弦)

        const canvas = document.getElementById('canvas');
            /* 获得 2d 上下文对象 */
            const ctx = canvas.getContext('2d');
        
            let radialGradient;
            let distance = 0;
            let axis = 300;
            const speed = 5;
        
            const range = 200;
        
            let angle = 0;
        
            const draw = (axisX) => {
                /* 清空画布(或部分清空) */
                // ctx.clearRect(0, 0, 600, 600);
                radialGradient = ctx.createRadialGradient(distance, axis, 10, distance, axis, 50);
                radialGradient.addColorStop(0, "#FFFFFF");
                radialGradient.addColorStop(1, "#EA7F26");
                ctx.fillStyle = radialGradient;
        
                ctx.beginPath();
                ctx.moveTo(distance, axis);
                ctx.arc(distance, axis, 50, 0, 2 * Math.PI, false);
                ctx.fill();
                
                axis = 300 + Math.sin(angle) * range;
        
                distance = distance + speed;
                if (distance > 650) {
                    distance = 0;
                    angle = -.1;
                }
        
                angle += .1;
                requestAnimationFrame(draw);
            }
        
            requestAnimationFrame(draw);
    

    在这里插入图片描述

    环形运动

        const canvas = document.getElementById('canvas');
            /* 获得 2d 上下文对象 */
            const ctx = canvas.getContext('2d');
            let radialGradient;
        
            let angle = 0.1;
            var scope = 20;
        
            let x = 300;
            let y = 100;
        
        const draw = (axisX) => {
        /* 清空画布(或部分清空) */
            ctx.clearRect(0, 0, 600, 600);
            radialGradient = ctx.createRadialGradient(x, y, 10, x, y, 50);
            radialGradient.addColorStop(0, "#FFFFFF");
            radialGradient.addColorStop(1, "#EA7F26");
            ctx.fillStyle = radialGradient;
            ctx.beginPath();
            ctx.moveTo(x, y);
            ctx.arc(x, y, 50, 0, 2 * Math.PI, false);
            ctx.fill();
        
            x = x + Math.cos(angle) * scope;
            y = y + Math.sin(angle) * scope;
            angle = angle + .1;
        
            requestAnimationFrame(draw);
            ctx.closePath();
        
            ctx.beginPath();
            ctx.arc(300, 300, 200, 0, 2 * Math.PI, false);
            ctx.stroke();
        }
        
        requestAnimationFrame(draw);
    

    在这里插入图片描述

    展开全文
  • 蝴蝶飞舞canvas动画特效是一款基于canvas绘制飞舞的蝴蝶,彩色的蝴蝶,漂亮的蝴蝶元素动画特效。
  • 彩色卡通闪电Canvas动画特效是一款基于HTML5 Canvas绘制的五彩缤纷闪电动画电流发射动画特效。
  • 详解Canvas动画部分

    万次阅读 多人点赞 2020-06-29 14:02:45
    本文包括缩放,平移,旋转、动画等复杂动画

    基础篇: Html5中Canvas绘制、样式详解(不包含动画部分)

    此篇为后续

    目录

    1. 状态的保存和恢复

    2. translate移动

    3. 旋转Rotating

    4. 缩放Scaling

    5. 图形相互交叉显示规则

    6. 裁切路径

    7. 动画基本步骤

    8. canvas相关的动画js框架


    1.状态的保存和恢复

    save()

    保存画布(canvas)的所有状态

    restore()

    save 和 restore 方法是用来保存和恢复 canvas 状态的,都没有参数。Canvas 的状态就是当前画面应用的所有样式和变形的一个快照。

    Canvas状态存储在栈中,每当save()方法被调用后,当前的状态就被推送到栈中保存。一个绘画状态包括:

          当前应用的变形(即移动,旋转和缩放,见下)
           以及下面这些属性:strokeStyle, fillStyle, globalAlpha, lineWidth, lineCap, lineJoin, miterLimit, lineDashOffset, shadowOffsetX, shadowOffsetY, shadowBlur, shadowColor, globalCompositeOperation, font, textAlign, textBaseline, direction, imageSmoothingEnabled
          当前的裁切路径(clipping path)
    你可以调用任意多次 save方法。每一次调用 restore 方法,上一个保存的状态就从栈中弹出,所有设定都恢复。
     

    save 和 restore 的应用例子

    function draw() {
      var ctx = document.getElementById('canvas').getContext('2d');
    
      ctx.fillRect(0,0,150,150);   // 使用默认设置绘制一个矩形
      ctx.save();                  // 保存默认状态
    
      ctx.fillStyle = '#09F'       // 在原有配置基础上对颜色做改变
      ctx.fillRect(15,15,120,120); // 使用新的设置绘制一个矩形
    
      ctx.save();                  // 保存当前状态
      ctx.fillStyle = '#FFF'       // 再次改变颜色配置
      ctx.globalAlpha = 0.5;    
      ctx.fillRect(30,30,90,90);   // 使用新的配置绘制一个矩形
    
      ctx.restore();               // 重新加载之前的颜色状态
      ctx.fillRect(45,45,60,60);   // 使用上一次的配置绘制一个矩形
    
      ctx.restore();               // 加载默认颜色配置
      ctx.fillRect(60,60,30,30);   // 使用加载的配置绘制一个矩形
    }

    第一步是用默认设置画一个大四方形,然后保存一下状态。改变填充颜色画第二个小一点的蓝色四方形,然后再保存一下状态。再次改变填充颜色绘制更小一点的半透明的白色四方形。

    一旦我们调用 restore,状态栈中最后的状态会弹出,并恢复所有设置。如果不是之前用 save 保存了状态,那么我们就需要手动改变设置来回到前一个状态,这个对于两三个属性的时候还是适用的,一旦多了,我们的代码将会猛涨。

    当第二次调用 restore 时,已经恢复到最初的状态,因此最后是再一次绘制出一个黑色的四方形。

    2. translate移动

    translate 方法,它用来移动 canvas 和它的原点到一个不同的位置。

    translate(x, y)

    translate 方法接受两个参数。x 是左右偏移量,y 是上下偏移量

    例子 平移之后画个圆,然后恢复状态,再平移再画个圆,再恢复状态,每次都画在原点上,每次原点都不在一个位置上

    function draw3() {
      var ctx = document.getElementById('canvas').getContext('2d');
      for (var i = 0; i < 3; i++) {
        for (var j = 0; j < 3; j++) {
          ctx.save();
          ctx.fillStyle = 'rgb(' + (51 * i) + ', ' + (255 - 51 * i) + ', 255)';
          ctx.translate(10 + j * 50, 10 + i * 50);
          ctx.beginPath();
          ctx.arc(0, 0, 10, 0, Math.PI*2, true);
          ctx.fill();
          ctx.restore();
        }
      }
    }
    

    效果

    3. 旋转Rotating

     rotate 方法,它用于以原点为中心旋转 canvas

    rotate(angle)

    这个方法只接受一个参数:旋转的角度(angle),它是顺时针方向的,以弧度为单位的值。

    旋转的中心点始终是 canvas 的原点,如果要改变它,我们需要用到 translate 方法。

    来个例子,记住是坐标系旋转,想问题的时候要想清楚  此案例先把中心移到了圆的中心

    function draw() {
      var ctx = document.getElementById('canvas').getContext('2d');
      ctx.translate(75,75);
    
      for (var i=1;i<6;i++){ // Loop through rings (from inside to out)
        ctx.save();
        ctx.fillStyle = 'rgb('+(51*i)+','+(255-51*i)+',255)';
    
        for (var j=0;j<i*6;j++){ // draw individual dots
          ctx.rotate(Math.PI*2/(i*6));
          ctx.beginPath();
          ctx.arc(0,i*12.5,5,0,Math.PI*2,true);
          ctx.fill();
        }
    
        ctx.restore();
      }
    }

    效果:  

    4. 缩放Scaling

    我们用它来增减图形在 canvas 中的像素数目,对形状,位图进行缩小或者放大

    scale(x, y)

    scale  方法可以缩放画布的水平和垂直的单位。两个参数都是实数,可以为负数,x 为水平缩放因子,y 为垂直缩放因子,如果比1小,会比缩放图形, 如果比1大会放大图形。默认值为1, 为实际大小。

    画布初始情况下, 是以左上角坐标为原点的第一象限。如果参数为负实数, 相当于以x 或 y轴作为对称轴镜像反转(例如, 使用translate(0,canvas.height); scale(1,-1); 以y轴作为对称轴镜像反转, 就可得到著名的笛卡尔坐标系,左下角为原点)。

    默认情况下,canvas 的 1 个单位为 1 个像素。举例说,如果我们设置缩放因子是 0.5,1 个单位就变成对应 0.5 个像素,这样绘制出来的形状就会是原先的一半。同理,设置为 2.0 时,1 个单位就对应变成了 2 像素,绘制的结果就是图形放大了 2 倍。

    scale 的例子

    function draw6() {
      var ctx = document.getElementById('canvas').getContext('2d');
      ctx.save();
      ctx.scale(10, 3);
      ctx.fillRect(1, 10, 10, 10);
      ctx.restore();
    
      // 镜像x轴
      ctx.scale(-1, 1);
      ctx.font = '48px serif';
      ctx.fillText('海军', -135, 120);
    }
    

    效果图

    5. 图形相互交叉显示规则

    ctx.globalCompositeOperation = type

    这个属性设定了在画新图形时采用的遮盖策略,其值是一个标识12种遮盖方式的字符串。

    source-over

    这是默认设置,并在现有画布上下文之上绘制新图形。

    source-in

    新图形只在新图形和目标画布重叠的地方绘制。其他的都是透明的。

    source-out

    在不与现有画布内容重叠的地方绘制新图形。

    source-atop

    新图形只在与现有画布内容重叠的地方绘制。

    destination-over

    在现有的画布内容后面绘制新的图形。

    destination-in

    现有的画布内容保持在新图形和现有画布内容重叠的位置。其他的都是透明的。

    destination-out

    现有内容保持在新图形不重叠的地方。

    destination-atop

    现有的画布只保留与新图形重叠的部分,新的图形是在画布内容后面绘制的。

    lighter

    两个重叠图形的颜色是通过颜色值相加来确定的。

    copy

    只显示新图形。

    xor

    图像中,那些重叠和正常绘制之外的其他地方是透明的。

    multiply

    将顶层像素与底层相应像素相乘,结果是一幅更黑暗的图片。

    screen

    像素被倒转,相乘,再倒转,结果是一幅更明亮的图片。

    overlay

    multiply和screen的结合,原本暗的地方更暗,原本亮的地方更亮。

    darken

    保留两个图层中最暗的像素。

    lighten

    保留两个图层中最亮的像素。

    color-dodge

    将底层除以顶层的反置。

    color-burn

    将反置的底层除以顶层,然后将结果反过来。

    hard-light

    屏幕相乘(A combination of multiply and screen)类似于叠加,但上下图层互换了。

    soft-light

    用顶层减去底层或者相反来得到一个正值。

    difference

    一个柔和版本的强光(hard-light)。纯黑或纯白不会导致纯黑或纯白。

    exclusion

    和difference相似,但对比度较低。

    hue

    保留了底层的亮度(luma)和色度(chroma),同时采用了顶层的色调(hue)。

    saturation

    保留底层的亮度(luma)和色调(hue),同时采用顶层的色度(chroma)。

    color

    保留了底层的亮度(luma),同时采用了顶层的色调(hue)和色度(chroma)。

    luminosity

    保持底层的色调(hue)和色度(chroma),同时采用顶层的亮度(luma)。

    6. 裁切路径

    裁切路径和普通的 canvas 图形差不多,不同的是它的作用是遮罩,用来隐藏不需要的部分。如上图所示。红边五角星就是裁切路径,所有在路径以外的部分都不会在 canvas 上绘制出来。

    globalCompositeOperation 属性作一比较,它可以实现与 source-in 和 source-atop差不多的效果。最重要的区别是裁切路径不会在 canvas 上绘制东西,而且它永远不受新图形的影响。这些特性使得它在特定区域里绘制图形时相当好用。

     clip()方法

    将当前正在构建的路径转换为当前的裁剪路径。

    看案例

    function draw() {
      var ctx = document.getElementById('canvas').getContext('2d');
      ctx.fillRect(0,0,150,150);
      ctx.translate(75,75);
    
      // Create a circular clipping path
      ctx.beginPath();
      ctx.arc(0,0,60,0,Math.PI*2,true);
      ctx.clip();
    
      // draw background
      var lingrad = ctx.createLinearGradient(0,-75,0,75);
      lingrad.addColorStop(0, '#232256');
      lingrad.addColorStop(1, '#143778');
      
      ctx.fillStyle = lingrad;
      ctx.fillRect(-75,-75,150,150);
    
      // draw stars
      for (var j=1;j<50;j++){
        ctx.save();
        ctx.fillStyle = '#fff';
        ctx.translate(75-Math.floor(Math.random()*150),
                      75-Math.floor(Math.random()*150));
        drawStar(ctx,Math.floor(Math.random()*4)+2);
        ctx.restore();
      }
      
    }
    function drawStar(ctx,r){
      ctx.save();
      ctx.beginPath()
      ctx.moveTo(r,0);
      for (var i=0;i<9;i++){
        ctx.rotate(Math.PI/5);
        if(i%2 == 0) {
          ctx.lineTo((r/0.525731)*0.200811,0);
        } else {
          ctx.lineTo(r,0);
        }
      }
      ctx.closePath();
      ctx.fill();
      ctx.restore();
    }

    用了一个圆形的裁切路径来限制随机星星的绘制区域。

    首先,画了一个与 canvas 一样大小的黑色方形作为背景,然后移动原点至中心点。然后用 clip 方法创建一个弧形的裁切路径。裁切路径也属于 canvas 状态的一部分,可以被保存起来。如果我们在创建新裁切路径时想保留原来的裁切路径,我们需要做的就是保存一下 canvas 的状态。

    裁切路径创建之后所有出现在它里面的东西才会画出来。在画线性渐变时我们就会注意到这点。然后会绘制出50 颗随机位置分布(经过缩放)的星星,当然也只有在裁切路径里面的星星才会绘制出来。

    效果图

    7.动画基本步骤

    你可以通过以下的步骤来画出一帧:

    1. 清空 canvas
      除非接下来要画的内容会完全充满 canvas (例如背景图),否则你需要清空所有。最简单的做法就是用 clearRect 方法。
    2. 保存 canvas 状态
      如果你要改变一些会改变 canvas 状态的设置(样式,变形之类的),又要在每画一帧之时都是原始状态的话,你需要先保存一下。
    3. 绘制动画图形(animated shapes)
      这一步才是重绘动画帧。(重绘是相当费时的,而且性能很依赖于电脑的速度。)
    4. 恢复 canvas 状态
      如果已经保存了 canvas 的状态,可以先恢复它,然后重绘下一帧。

    为了实现动画,我们需要一些可以定时执行重绘的方法。有两种方法可以实现这样的动画操控。首先可以通过 setInterval 和 setTimeout 方法来控制在设定的时间点上执行重绘。

    requestAnimationFrame(draw)

    告诉浏览器你希望执行一个动画,并在重绘之前,请求浏览器执行一个特定的函数来更新动画。

    如果你并不需要与用户互动,你可以使用setInterval()方法,它就可以定期执行指定代码。如果我们需要做一个游戏,我们可以使用键盘或者鼠标事件配合上setTimeout()方法来实现。通过设置事件监听,我们可以捕捉用户的交互,并执行相应的动作。

    简答的案例

    function draw9() {
      var ctx = document.getElementById('canvas').getContext('2d');       
      ctx.globalCompositeOperation = 'destination-over';
      ctx.clearRect(0,0,500,500); // clear canvas
      ctx.fillStyle = 'green';
      ctx.strokeStyle = 'blueviolet';
      ctx.save();
      ctx.translate(180,180);
      ctx.beginPath();
      ctx.arc(0,0,150,0,Math.PI*2,false);
      ctx.stroke();
      var time = new Date();
      ctx.rotate( ((2*Math.PI)/60)*time.getSeconds() + ((2*Math.PI)/60000)*time.getMilliseconds() )
      ctx.beginPath();
      ctx.arc(0,150,20,0,Math.PI*2,false);
      ctx.fill();
      ctx.closePath();
      ctx.restore();
      window.requestAnimationFrame(draw9)
    }
    window.requestAnimationFrame(draw9);

    效果就是一个小圆绕着大圆旋转

    案例2模拟太阳系

    var sun = new Image();
    var moon = new Image();
    var earth = new Image();
    function init(){
      sun.src = 'https://mdn.mozillademos.org/files/1456/Canvas_sun.png';
      moon.src = 'https://mdn.mozillademos.org/files/1443/Canvas_moon.png';
      earth.src = 'https://mdn.mozillademos.org/files/1429/Canvas_earth.png';
      window.requestAnimationFrame(draw);
    }
    
    function draw() {
      var ctx = document.getElementById('canvas').getContext('2d');
    
      ctx.globalCompositeOperation = 'destination-over';
      ctx.clearRect(0,0,300,300); // clear canvas
    
      ctx.fillStyle = 'rgba(0,0,0,0.4)';
      ctx.strokeStyle = 'rgba(0,153,255,0.4)';
      ctx.save();
      ctx.translate(150,150);
    
      // Earth
      var time = new Date();
      ctx.rotate( ((2*Math.PI)/60)*time.getSeconds() + ((2*Math.PI)/60000)*time.getMilliseconds() );
      ctx.translate(105,0);
      ctx.fillRect(0,-12,50,24); // Shadow
      ctx.drawImage(earth,-12,-12);
    
      // Moon
      ctx.save();
      ctx.rotate( ((2*Math.PI)/6)*time.getSeconds() + ((2*Math.PI)/6000)*time.getMilliseconds() );
      ctx.translate(0,28.5);
      ctx.drawImage(moon,-3.5,-3.5);
      ctx.restore();
    
      ctx.restore();
      
      ctx.beginPath();
      ctx.arc(150,150,105,0,Math.PI*2,false); // Earth orbit
      ctx.stroke();
     
      ctx.drawImage(sun,0,0,300,300);
    
      window.requestAnimationFrame(draw);
    }
    
    init();

    案例3动画时钟

    function clock(){
      var now = new Date();
      var ctx = document.getElementById('canvas').getContext('2d');
      ctx.save();
      ctx.clearRect(0,0,150,150);
      ctx.translate(75,75);
      ctx.scale(0.4,0.4);
      ctx.rotate(-Math.PI/2);
      ctx.strokeStyle = "black";
      ctx.fillStyle = "white";
      ctx.lineWidth = 8;
      ctx.lineCap = "round";
    
      // Hour marks
      ctx.save();
      for (var i=0;i<12;i++){
        ctx.beginPath();
        ctx.rotate(Math.PI/6);
        ctx.moveTo(100,0);
        ctx.lineTo(120,0);
        ctx.stroke();
      }
      ctx.restore();
    
      // Minute marks
      ctx.save();
      ctx.lineWidth = 5;
      for (i=0;i<60;i++){
        if (i%5!=0) {
          ctx.beginPath();
          ctx.moveTo(117,0);
          ctx.lineTo(120,0);
          ctx.stroke();
        }
        ctx.rotate(Math.PI/30);
      }
      ctx.restore();
     
      var sec = now.getSeconds();
      var min = now.getMinutes();
      var hr  = now.getHours();
      hr = hr>=12 ? hr-12 : hr;
    
      ctx.fillStyle = "black";
    
      // write Hours
      ctx.save();
      ctx.rotate( hr*(Math.PI/6) + (Math.PI/360)*min + (Math.PI/21600)*sec )
      ctx.lineWidth = 14;
      ctx.beginPath();
      ctx.moveTo(-20,0);
      ctx.lineTo(80,0);
      ctx.stroke();
      ctx.restore();
    
      // write Minutes
      ctx.save();
      ctx.rotate( (Math.PI/30)*min + (Math.PI/1800)*sec )
      ctx.lineWidth = 10;
      ctx.beginPath();
      ctx.moveTo(-28,0);
      ctx.lineTo(112,0);
      ctx.stroke();
      ctx.restore();
     
      // Write seconds
      ctx.save();
      ctx.rotate(sec * Math.PI/30);
      ctx.strokeStyle = "#D40000";
      ctx.fillStyle = "#D40000";
      ctx.lineWidth = 6;
      ctx.beginPath();
      ctx.moveTo(-30,0);
      ctx.lineTo(83,0);
      ctx.stroke();
      ctx.beginPath();
      ctx.arc(0,0,10,0,Math.PI*2,true);
      ctx.fill();
      ctx.beginPath();
      ctx.arc(95,0,10,0,Math.PI*2,true);
      ctx.stroke();
      ctx.fillStyle = "rgba(0,0,0,0)";
      ctx.arc(0,0,3,0,Math.PI*2,true);
      ctx.fill();
      ctx.restore();
    
      ctx.beginPath();
      ctx.lineWidth = 14;
      ctx.strokeStyle = '#325FA2';
      ctx.arc(0,0,142,0,Math.PI*2,true);
      ctx.stroke();
    
      ctx.restore();
    
      window.requestAnimationFrame(clock);
    }
    
    window.requestAnimationFrame(clock);

    关于动画要了解的可不止这些,包括速率,加速度,边界,拖尾效果,鼠标控制等等

    举个栗子

    var canvas = document.getElementById('canvas');
    var ctx = canvas.getContext('2d');
    var raf;
    var running = false;
    
    var ball = {
      x: 100,
      y: 100,
      vx: 5,
      vy: 1,
      radius: 25,
      color: 'blue',
      draw: function() {
        ctx.beginPath();
        ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2, true);
        ctx.closePath();
        ctx.fillStyle = this.color;
        ctx.fill();
      }
    };
    
    function clear() {
      ctx.fillStyle = 'rgba(255,255,255,0.3)';
      ctx.fillRect(0,0,canvas.width,canvas.height);
    }
    
    function draw() {
      clear();
      ball.draw();
      ball.x += ball.vx;
      ball.y += ball.vy;
    
      if (ball.y + ball.vy > canvas.height || ball.y + ball.vy < 0) {
        ball.vy = -ball.vy;
      }
      if (ball.x + ball.vx > canvas.width || ball.x + ball.vx < 0) {
        ball.vx = -ball.vx;
      }
    
      raf = window.requestAnimationFrame(draw);
    }
    
    canvas.addEventListener('mousemove', function(e){
      if (!running) {
        clear();
        ball.x = e.offsetX;
        ball.y = e.offsetY;
        ball.draw();
      }
    });
    
    canvas.addEventListener('click',function(e){
      if (!running) {
        raf = window.requestAnimationFrame(draw);
        running = true;
      }
    });
    
    canvas.addEventListener('mouseout', function(e){
      window.cancelAnimationFrame(raf);
      running = false;
    });
    
    ball.draw();

    用你的鼠标移动小球,点击可以释放。

    8. canvas相关的动画js框架

      

       Three.js

    这个流行的库提供了非常多的3D显示功能,以一种直观的方式使用 WebGL。这个库提供了<canvas>、 <svg>、CSS3D 和 WebGL渲染器,让我们在设备和浏览器之间创建丰富的交互体验。该库于2010年4月首次推出

       pixi.js

    虽然只是个渲染框架而非游戏引擎,但是pixi.js挺适合写游戏的,你可以看下netent上的博彩游戏,上万款游戏全是pixi.js写的。pixi.js刚接触的时候觉得很简陋,文档都是英文的,有时候还需要看源码(源码写的非常的优秀)才能理解怎么回事,这对很多人是个很高的门槛,但是如果你能克服这些,会发现用着真的很舒服。

    周边插件也挺丰富的,动画(spine/dragonbones),粒子系统,物理引擎等等,想用什么就引入什么,和unix设计哲学一样,每个工具只干一件事并把这件事做好,你可以组合很多工具完成复杂的功能。

     

     

     

    展开全文
  • 本网页运用了大量的动画效果,如曲线运动、canvas动画
  • 点和线连接Canvas动画

    2021-07-24 23:17:08
    点和线连接Canvas动画是一款鼠标移动推开粒子,适合当网页文字背景特效。
  • 点和线连接Canvas动画是一款鼠标移动推开粒子,适合当网页文字背景特效。
  • 3D篝火Canvas动画特效

    2021-07-24 23:44:42
    3D篝火Canvas动画特效是一款three基于canvas绘制逼真的3D野外篝火燃烧的火柴动画特效。
  • uniapp开发微信小程序canvas动画入门

    千次阅读 2021-01-05 09:49:01
    uniapp开发微信小程序canvas动画入门前言效果预览页面代码结论 前言 老版的微信小程序canvas接口由于是视图层和逻辑层双线程的关系,动画效果很卡,而且api都是为了标新立异,重新包装H5的,学习起来也要再花时间. 2.9.0...

    uniapp开发微信小程序canvas动画入门

    前言

    老版的微信小程序canvas接口由于是视图层和逻辑层双线程的关系,动画效果很卡,而且api都是为了标新立异,重新包装H5的,学习起来也要再花时间.
    2.9.0版之后终于与H5的接口同步了,并且性能也得到了极大的优化,简单的动画在移动端运行起来还是非常流畅的.
    大家在很多网页上都见过粒子飘来飘去的动画,有点物联网的感觉…
    下面使用uniapp开发环境实现一个微信小程序端的粒子动画背景,app端不支持新版的接口,运行会报错.

    粒子动画参考代码

    效果预览

    在这里插入图片描述
    此截图是在开发者工具上录的,实际上没有那些灰色的块块
    新版的canvas接口支持同层渲染,所以只需要将canvas层的z-index调到下面就行了.
    真机预览下小球球是在其他元素下面的,不会影响主要元素.

    页面代码

    <template>
    	<view>
    		<view class="container">
    			<view class="login-header">
    				<!-- <img src="/static/login.png" alt=""> -->
    				<view>XXXXX系统</view>
    			</view>
    			<view class="uni-form-item uni-column">
    				<input class="uni-input" focus placeholder="用户名" v-model="user" @input="userChange" />
    			</view>
    			<view class="uni-form-item uni-column">
    				<input class="uni-input" password type="text" placeholder="密码" v-model="pass" @input="passChange" />
    			</view>
    			<br>
    			<button class="loginBtn" type="primary" @click="onLogin">登录</button>
    		</view>
    		<canvas type="2d" id="myCanvas"></canvas>
    	</view>
    </template>
    
    <script>
    	
    	import Circle from './circle.js' 
    	
    	export default {
    		data() {
    			return {
    				user: 'xxxxxxx',
    				pass: '123456'
    			}
    		},
    		onReady: function (e) {
    		    const query = uni.createSelectorQuery()
    			query.select('#myCanvas')
    			  .fields({ node: true, size: true })
    			  .exec((res) => {
    				const canvas = res[0].node
    				const ctx = canvas.getContext('2d')
    				const sysInfo = uni.getSystemInfoSync()
    				const dpr = sysInfo.pixelRatio
    				canvas.width = res[0].width * dpr
    				canvas.height = res[0].height * dpr
    				ctx.scale(dpr, dpr)
    		
    				let circles = []
    				let width = sysInfo.windowWidth
    				let height = sysInfo.windowHeight
    				let num = 50
    				
    				for (let i = 0; i < num; i++) {
    				    let circle = new Circle(Math.random() * width, Math.random() * height, width, height)
    				    circles.push(circle)
    				}
    				function draw(num) {
    					ctx.clearRect(0, 0, width, height)
    					for (let i = 0; i < num; i++) {
    						circles[i].drawCircle(ctx)
    						for (let j = i + 1; j < num; j++) {
    							circles[i].drawLine(ctx, circles[j])
    						}
    						circles[i].move()
    					}
    				}
    				setInterval(()=> {
    					draw(num)
    				}, 33)
    			 })
    		},
    		
    		methods: {
    			userChange: function(e) {
    				this.user = e.detail.value
    			},
    			passChange: function(e) {
    				this.pass = e.detail.value
    			},
    			onLogin: function(e) {
    				
    			}
    	},
    	}
    </script>
    
    <style lang="scss" scoped>
    	#myCanvas {
    		position: absolute;
    		left: 0;
    		top: 0;
    		width: 100%;
    		height: 100%;
    		z-index: -1;
    	}
    	.container {
    		padding: 15px;
    		// font-size: 14px;
    		// line-height: 24px;
    	}
    	input {
    		padding: 15px 0;
    		border-bottom: 1px solid #C0C0C0;
    	}
    	.loginBtn {
    		background-color: $my-primary;
    	}
    	/* #ifdef MP-WEIXIN */
    	.loginBtn {
    		margin-top: 25px;
    	}
    	/* #endif */
    	.login-header {
    		text-align: center;
    		font-size: 18px;
    		margin-bottom: 10px;
    		img {
    			width: 100px;
    			height: 41px;
    		}
    	}
    </style>
    

    下面是circle.js的代码

    class Circle {
    	constructor(x, y, width, height) {
    		this.x = x
    		this.y = y
    		this.r = Math.random() * 10
    		this._mx = Math.random()
    		this._my = Math.random()
    		this.width = width
    		this.height = height
    	}
    	drawCircle(ctx) {
    		ctx.beginPath()
    		ctx.arc(this.x, this.y, this.r, 0, 2 * Math.PI)
    		ctx.fillStyle = 'rgba(204, 204, 204, 0.3)'
    		ctx.fill()
    		ctx.closePath()
    	}
    	drawLine(ctx, _circle) {
    		let dx = this.x - _circle.x
    		let dy = this.y - _circle.y
    		let d = Math.sqrt(dx * dx + dy * dy)
    		if (d < 70) {
    			ctx.beginPath()
    			ctx.moveTo(this.x, this.y)
    			ctx.lineTo(_circle.x, _circle.y)
    			ctx.strokeStyle = 'rgba(204, 204, 204, 0.5)'
    			ctx.stroke()
    			ctx.closePath()
    		}
    	}
    	move() {
    		this._mx = (this.x < this.width && this.x > 0) ? this._mx : (-this._mx)
    		this._my = (this.y < this.height && this.y > 0) ? this._my : (-this._my)
    		this.x += this._mx
    		this.y += this._my
    	}
    }
    
    export default Circle
    
    

    移动端没有鼠标,关于鼠标那部分的粒子球代码就去掉了.
    小程序官方文档里是有requestAnimationFrame这个接口的,但我试了一下,用上以后也不报错也不会动…
    所以只能用setInterval了,33毫秒重绘一次,也就是一秒钟30帧,看起来已经很流畅了.
    在这里插入图片描述

    结论

    这个粒子球跑来跑去加连线的动画有点物联网的感觉,有木有?
    把代码放到自己的项目里跑一跑,修修改改试一试,小程序端的canvas开发也就入门了.
    浏览器端的canvas库什么的就别指望了,在小程序里用起来很麻烦.老老实实用原生的接口,做个简单的功能还不算太难.
    写canvas代码的精髓:就把它想象成一张一张的图画,然后把重绘代码放到定时器里.如下图:
    在这里插入图片描述

    展开全文
  • canvas动画案例.html

    2022-03-09 01:29:01
    canvas动画案例.html
  • Canvas动画转视频-前段框架whammy,由于英文比较晦涩难懂,接下来就实践一下体会whammy的用法。
  • 之前我们分享的都是基于CSS3的自定义按钮,今天我们来分享一款基于HTML5 Canvas动画按钮,每一个按钮都是一个canvas画布,这就很灵活,你可以在canvas绘制任意你喜欢的东西作为按钮的背景画面,并且,还可以有动画...
  • canvas动画移动鼠标

    2021-04-09 09:14:53
    画布,canvas,小功能,非常炫酷,有小游戏的思维在里面,可参考,此功能为参考项
  • canvas动画demo

    2013-09-24 10:58:38
    canvas实现的简单的指针小动画
  • 密集气泡组成字母canvas动画是一款基于canvas 2d画布绘制无数个圆点气泡形成的英文字母动画特效。
  • canvas动画-会舞动的树是一款左右摇摆的树 颜色会随摇摆变化
  • Canvas动画案例演示,含动画猫、变幻线、代码雨等

    千次阅读 热门讨论 2021-04-09 10:29:25
    Canvas API 提供了一个通过JavaScript...它可以用于动画、游戏画面、数据可视化、图片编辑以及实时视频处理等方面。 Canvas API主要聚焦于2D图形。而同样使用<canvas>元素的 WebGL API 则用于绘制硬件加速的2D和3D图形

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,512
精华内容 31,004
关键字:

canvas动画