精华内容
下载资源
问答
  • SVGA

    2010-07-28 14:08:00
    概述定义  SVGA即高级视频图形阵列(Super Video Graphics Array或Super VGA或SVGA),由VESA为IBM兼容机推出的标准。分辨率为800x600(每像素4比特,16种颜色可选)。 特性  SVGA,属于VGA屏幕的替代品...

    概述

    定义

      SVGA即高级视频图形阵列(Super Video Graphics Array或Super VGA或SVGA),由VESA为IBM兼容机推出的标准。分辨率为800x600(每像素4比特,16种颜色可选)。

    特性

      SVGA,属于VGA屏幕的替代品,最大支持800×600分辨率,屏幕大小为12.1英寸,由于像素较低所以目前采用这一屏幕的笔记本也很少了。

      肉眼对颜色的敏感远大于分辨率,所以即使分辨率较低图像依然生动鲜明。VGA由于良好的性能迅速开始流行,厂商们纷纷在VGA基础上加以扩充,如将显存提高至1M并使其支持更高分辨率如800X600或1024X768,这些扩充的模式就称之为VESA(Video Electronics Standards Association,视频电子标准协会)的Super VGA模式,简称SVGA,现在的显卡和显示器都支持SVGA模式。不管是VGA还是SVGA,使用的连线都是15针的梯形插头,传输模拟信号。

      SVGA、XGA和SXGA是主要的几种分辨率(或解析度)标准。是计算机和投影仪上用以描述常见的几种分辨率的术语。

    显示模式

      彩色显示器又分为CGA,EGA,VGA,SVGA,TVGA,XGA等VGA的英文全称是Video Graphic Array,即显示绘图阵列。VGA支持在640X480的较高分辨率下同时显示16种色彩或256种灰度,同时在320X240分辨率下可以同时显示256种颜色.肉眼对颜色的敏感远大于分辨率,所以即使分辨率较低图像依然生动鲜明。VGA由于良好的性能迅速开始流行,厂商们纷纷在VGA基础上加以扩充,如将显存提高至1M并使其支持更高分辨率如800X600或1024X768,这些扩充的模式就称之为VESA(Video Electronics Standards Association,视频电子标准协会)的Super VGA模式,简称SVGA,现在的显卡和显示器都支持SVGA模式。不管是VGA还是SVGA,使用的连线都是15针的梯形插头,传输模拟信号。典型的 IBM指标是:CGA为320×200和8色,EGA为640×350和16色,VGA为640×480,SVGA为800×600、1024×768、 1280×1024和1600×1200等。目前的显示都采用VGA以上的显示模式,它们的同屏彩色数可在16、256、16K、32K、64K、16M (所谓真彩色)直到4G中选择。

    展开全文
  • svga插件_SVGA实例讲解

    2020-12-23 04:06:19
    趁现在时间上比较富裕的时候写一篇关于SVGA的实例使用SVGA实现上图效果使用AE中的SVGA的插件,插件的下载与安装就不做多余的描述了,官方都有详细的方法文章下方有官方地址在窗口中找到SVGA插件并打开,选择输出路径...

    从发了一篇《使用SVGA优化礼物动画》之后,

    很多小伙伴一直在问我相关实现的问题、以及碰到了一些问题怎么解决?

    趁现在时间上比较富裕的时候写一篇关于SVGA的实例

    使用SVGA实现上图效果

    使用AE中的SVGA的插件,插件的下载

    与安装就不做多余的描述了,官方都有详细的方法

    文章下方有官方地址

    在窗口中找到SVGA插件并打开,选择输出路径之后就可以开始转换

    SVGA导出后发现与想要的效果有比较大的差别

    ·开启车头灯的效果与实际效果不一致

    ·礼物跑动时加速度的模糊效果与实际效果不一致

    车头灯的效果,我在制作过程中使用了AE效果中的描边的效果(按照路径逐渐点亮)。

    发现导出的SVGA不没有想要的这种想要的效果了

    车身移动的效果,我在制作过程中使用了AE效果中的高斯模糊的效果和调整了一下位移的曲率(会显得车在移动中的速度感)。

    发现导出的SVGA中也不支持这种效果

    如果是碰到这种问题怎么去解决呢?

    之前在交流过程中也提到过可以使用png序列帧的方式进行反向制作(当然这只是我个人建议,如果您那边有更好的实现方式可以大家相互学习一下)。

    这次我准备在车头灯的制作中使用序列帧反向导入。

    但是车身的移动加速度动画我准备用其他的方式来进行制作。

    首先我想要的SVGA肯定不能太大,这样的话就不能使用太多的序列帧来实现动画,位图越少对于文件的体积肯定有一定的优化。

    因此我在加速度移动时使用了模糊,于是我就直接做一张模糊的位图通过明度的变换,是否就满足了需求?

    首先使用PS或者Sketch对图片进行处理(模糊处理)

    把图片叠加到原有的图片上,在移动的过程中把已经模糊的图片做一个透明度的变化

    上图是两个SVGA的对比

    当然这种实现的方法肯定会比直接使用AE效果的更加麻烦。不过最终还是为了达到理想的效果就需要花更多的时间

    其实对于礼物特效个人的感觉,主要的思考点是在于礼物想要实现什么样的效果。

    如果不能使用AE自带效果时,能不能用其他的方式去做代替达到预期的效果。同时需要考虑到文件的大小。

    毕竟SVGA可以直接走服务器下发,文件太大的话有点得不偿失。使用SVGA主要就是想更加的便捷。

    推荐一个图片压缩网站:https://tinypng.com/

    希望本文作为抛砖引玉,可以给您带来更多灵感与思路。如果您有更好的解决方案可以互相探讨。

    附件中包含这个动画的.aep文件

    展开全文
  • <div><p>Can you provide a way to turn off SVGA music 可否提供一个关闭SVGA音乐的方法</p><p>该提问来源于开源项目:svga/SVGAPlayer-Android</p></div>
  • SVGA礼物特效新平台专用测试
  • svga_shaking

    2018-04-01 20:35:33
    svga 资源shaking,svga 资源shakingsvga 资源shakingsvga 资源shakingsvga 资源shakingsvga 资源shakingsvga 资源shakingsvga 资源shakingsvga 资源shakingsvga 资源shakingsvga 资源shaking
  • SVGA动画消失

    2020-12-08 18:45:01
    svga动画离开屏幕再回到屏幕时,svga动画控件消失。 问题复现:在viewpager中,第一个页面有svga动画正在播放,但是当切到第三个页面再回来,动画就消失不见了;或者在一个...
  • zdd_runboy.svga

    2019-11-26 19:48:56
    svga animsvga
  • SVGA源码

    千次阅读 2018-06-21 00:35:50
    SVG 概念 原文地址:https://jfson.github.io/2018/06/21/49-svga/ * SVG 实际上指的是设计软件中的概念:SVG图片格式,一种矢量图形。 * 另一个角度来讲一张图或者一个动画,...SVGA成本 * SVGA目不支持种类: ...


      SVG 概念

    原文地址:https://jfson.github.io/2018/06/21/49-svga/

    * SVG 实际上指的是设计软件中的概念:SVG图片格式,一种矢量图形。


    * 另一个角度来讲一张图或者一个动画,是由很多上下层级的图层构成。
    比如当前的简单的图,看到的是一张图,但在设计工具中是三个图层构成,有着不同的上下层级顺序。



    SVGA成本


    * SVGA目不支持种类:
        * 不支持复杂的矢量形状图层
        * AE自带的渐变、生成、描边、擦除…
        * 对设计工具原生动画不友好,对图片动画友好(适合映客礼物场景)
    * 导出工具[开源](https://github.com/yyued/SVGA-FLConverter)

    开发成本


    * 1.优点
        * 资源包小
        * 测试工具齐全
        * 三端可用
        * 回调完整
        * Protobuf 序列化结构数据格式,序列化的数据体更小,传递效率比xml,json 更高。
    * 2.缺点
        * 每个礼物播放时都去重新解压,需要改一套缓存策略
        * svga 用zlib打包(字节流数据压缩程序库),不方便解压和追踪包内容。


    * 4.插入动画头像功能
        * 支持,需定义一套专属的头像配置的协议。



    SVGA 动画库源码思路


    * 通过设置帧率,来生成一个配置文件,使得每一帧都有一个配置,每一帧都是关键帧,
    * 通过帧率去刷每一帧的画面,这个思路跟gif很像,但是通过配置使得动画过程中图片都可以得到复用。性能就提升上来了。并且不用解析高阶插值(二次线性方程,贝塞尔曲线方程)

     

    源码类图

    ![image](https://github.com/jfson/ImgResource/blob/master/35.png?raw=true)
    * 版本2.1.2(应该是这个版本...)
    * 小解

     

    SVGAImageView imageView = new SVGAImageView(this);
    parser = new SVGAParser(this);
    parser.parse(new URL("http://legox.yy.com/svga/svga-me/angel.svga"), new SVGAParser.ParseCompletion() { // -----> 下文 1
        @Override
        public void onComplete(@NotNull SVGAVideoEntity videoItem) {
            SVGADrawable drawable = new SVGADrawable(videoItem);
            imageView.setImageDrawable(drawable); // -----> 下文 2
            imageView.startAnimation();// -----> 下文 3
        }
        @Override
        public void onError() {
    
    
        }
    });

     



    * 1.解析 SVGAParser
        * a. AE导出动画文件,在解析出的SVGAVideoEntity为动画数据源,在使用时调用 SVGAParser(this).parse(url) 最后返回SVGAVideoEntity。
        * b.parse中是一整套的网络下载,根据下载url作为缓存KEY值,缓存动画文件,如果已经下载过的文件,直接去读取文件流并解析。可以看到关键源码如下。PS:这里引申出一个问题,数据源SVGAVideoEntity并没有做缓存,所以每次播放之时,即便是动画文件已经download下来,还是要重新去解析,这是可以跟需要改进的地方。
        

     

     

    open fun parse(url: URL, callback: ParseCompletion) {
            if (cacheDir(cacheKey(url)).exists()) {
                parseWithCacheKey(cacheKey(url))?.let {
                    Handler(context.mainLooper).post {
                        callback.onComplete(it)
                    }
                    return
                }
            }
            fileDownloader.resume(url, {
                val videoItem = parse(it, cacheKey(url)) ?: return@resume (Handler(context.mainLooper).post { callback.onError() } as? Unit ?: Unit)
                Handler(context.mainLooper).post {
                    callback.onComplete(videoItem)
                }
            }, {
                Handler(context.mainLooper).post {
                    callback.onError()
                }
            })
        }
        
    open fun parseWithCacheKey(cacheKey: String): SVGAVideoEntity? {
            synchronized(sharedLock, {
                try {
                    val cacheDir = File(context.cacheDir.absolutePath + File.separator + SVGA_RESOURCE + "/" + cacheKey + "/")
                    File(cacheDir, "movie.binary").takeIf { it.isFile }?.let { binaryFile ->
                        try {
                            FileInputStream(binaryFile).let {
                                val videoItem = SVGAVideoEntity(MovieEntity.ADAPTER.decode(it), cacheDir)
                                it.close()
                                return videoItem
                            }
                        } catch (e: Exception) {
                            cacheDir.delete()
                            binaryFile.delete()
                            throw e
                        }
                    }
                    File(cacheDir, "movie.spec").takeIf { it.isFile }?.let { jsonFile ->
                        try {
                            FileInputStream(jsonFile).let { fileInputStream ->
                                val byteArrayOutputStream = ByteArrayOutputStream()
                                val buffer = ByteArray(2048)
                                while (true) {
                                    val size = fileInputStream.read(buffer, 0, buffer.size)
                                    if (size == -1) {
                                        break
                                    }
                                    byteArrayOutputStream.write(buffer, 0, size)
                                }
                                byteArrayOutputStream.toString().let {
                                    JSONObject(it).let {
                                        fileInputStream.close()
                                        return SVGAVideoEntity(it, cacheDir)
                                    }
                                }
                            }
                        } catch (e: Exception) {
                            cacheDir.delete()
                            jsonFile.delete()
                            throw e
                        }
                    }
                } catch (e: Exception) {
                    e.printStackTrace()
                }
            })
            return null
        }




        
    * 2. 数据源包装类 SVGADrawable
        * a. 将SVGAVideoEntity数据源 设置到SVGADrawable
    ```
    imageView.setImageDrawable(drawable)
    ```


    * 3.startAnimation()
        * a. 开始播放动画后,拿到已经解析后SVGADrawable的drawable,关键参数动画的时长:animator.duration(根据配置的帧数,时长计算),动画的帧率。数值动画会变更SVGADrawable中的currentFrame,这是重点。
        * b.currentFrame 设置后会触发invalidateSelf()

     

    imageView.startAnimation();
    
    
    fun startAnimation(range: SVGARange?, reverse: Boolean = false) {
            stopAnimation(false)
            val drawable = drawable as? SVGADrawable ?: return
            drawable.cleared = false
            drawable.scaleType = scaleType
            drawable.videoItem?.let {
                var durationScale = 1.0
                val startFrame = Math.max(0, range?.location ?: 0)
                val endFrame = Math.min(it.frames - 1, ((range?.location ?: 0) + (range?.length ?: Int.MAX_VALUE) - 1))
                val animator = ValueAnimator.ofInt(startFrame, endFrame)
                ...
                animator.interpolator = LinearInterpolator()
                animator.duration = ((endFrame - startFrame + 1) * (1000 / it.FPS) / durationScale).toLong()
                animator.repeatCount = if (loops <= 0) 99999 else loops - 1
                animator.addUpdateListener {
                    drawable.currentFrame = animator.animatedValue as Int
                    callback?.onStep(drawable.currentFrame, ((drawable.currentFrame + 1).toDouble() / drawable.videoItem.frames.toDouble()))
                }
                animator.addListener(object : Animator.AnimatorListener {
                   ...
                })
                if (reverse) {
                    animator.reverse()
                }
                else {
                    animator.start()
                }
                this.animator = animator
            }
        }
    ```
    
    
    ```
      var currentFrame = 0
            internal set (value) {
                if (field == value) {
                    return
                }
                field = value
                invalidateSelf()
            }



    * 4.SVGADrawable
        * a.SVGADrawable的invalidateSelf()会触发自身的draw()
        * b. SVGACanvasDrawer(videoItem: SVGAVideoEntity, val dynamicItem: SVGADynamicEntity) 可以看到数据源已经被传到这里
        * 可以理解为不断的通过触发drawFrame() 来刷新,看到这里基本看出来SVGA的原理来了,也是上面总结的:通过帧率去刷每一帧的画面,这个思路跟gif很像,但是通过配置使得动画过程中图片都可以得到复用。性能就提升上来了。并且不用解析高阶插值(二次线性方程,贝塞尔曲线方程)

     

     override fun draw(canvas: Canvas?) {
            if (cleared) {
                return
            }
            canvas?.let {
                //drawer --> SVGACanvasDrawer
                drawer.drawFrame(it,currentFrame, scaleType)
            }
        }
        
     override fun drawFrame(canvas :Canvas, frameIndex: Int, scaleType: ImageView.ScaleType) {
            super.drawFrame(canvas,frameIndex, scaleType)
            resetCachePath(canvas)
            val sprites = requestFrameSprites(frameIndex)
            sprites.forEach {
                drawSprite(it,canvas)
            }
        }




    * 5.分类:矢量元素动画 or 图片动画
        * 看上方总结的类图
        * 如果是矢量动画会取List<SVGADrawerSprite>中的对应每一帧的数据list,而如果有图片的话,会跟图片imageKey进行一一映射,并返回
        

     

     

     

    internal fun requestFrameSprites(frameIndex: Int): List<SVGADrawerSprite> {
            return videoItem.sprites.mapNotNull {
                if (frameIndex < it.frames.size) {
                    if (it.frames[frameIndex].alpha <= 0.0) {
                        return@mapNotNull null
                    }
                    return@mapNotNull SVGADrawerSprite(it.imageKey, it.frames[frameIndex])
                }
                return@mapNotNull null
            }
        }

     


    * 6.draw 
        * 最后.. 图片有了,对应图片显示的参数也有了,剩下的就是canvas.drawBitmap,canvas.drawPath...


    * 7.图挺乱的...已经凌晨了,就这样咯~。。。2333睡觉
    * 最后,贴上绘制的代码,感兴趣的筒子们请看。
     

     

    private fun drawSprite(sprite: SVGADrawerSprite,canvas :Canvas) {
            drawImage(sprite, canvas)
            drawShape(sprite, canvas)
        }
    
    
        private fun drawImage(sprite: SVGADrawerSprite, canvas :Canvas) {
            val imageKey = sprite.imageKey ?: return
            dynamicItem.dynamicHidden[imageKey]?.takeIf { it }?.let { return }
            (dynamicItem.dynamicImage[imageKey] ?: videoItem.images[imageKey])?.let {
                resetShareMatrix(sprite.frameEntity.transform)
                sharedPaint.reset()
                sharedPaint.isAntiAlias = videoItem.antiAlias
                sharedPaint.isFilterBitmap = videoItem.antiAlias
                sharedPaint.alpha = (sprite.frameEntity.alpha * 255).toInt()
                if (sprite.frameEntity.maskPath != null) {
                    val maskPath = sprite.frameEntity.maskPath ?: return@let
                    canvas.save()
                    sharedPath.reset()
                    maskPath.buildPath(sharedPath)
                    sharedPath.transform(sharedFrameMatrix)
                    canvas.clipPath(sharedPath)
                    sharedFrameMatrix.preScale((sprite.frameEntity.layout.width / it.width).toFloat(), (sprite.frameEntity.layout.width / it.width).toFloat())
                    canvas.drawBitmap(it, sharedFrameMatrix, sharedPaint)
                    canvas.restore()
                }
                else {
                    sharedFrameMatrix.preScale((sprite.frameEntity.layout.width / it.width).toFloat(), (sprite.frameEntity.layout.width / it.width).toFloat())
                    canvas.drawBitmap(it, sharedFrameMatrix, sharedPaint)
                }
                drawText(canvas,it, sprite)
            }
        }
    
    
        private fun drawText(canvas :Canvas, drawingBitmap: Bitmap, sprite: SVGADrawerSprite) {
            if (dynamicItem.isTextDirty) {
                this.drawTextCache.clear()
                dynamicItem.isTextDirty = false
            }
            val imageKey = sprite.imageKey ?: return
            var textBitmap: Bitmap? = null
            dynamicItem.dynamicText[imageKey]?.let { drawingText ->
                dynamicItem.dynamicTextPaint[imageKey]?.let { drawingTextPaint ->
                    drawTextCache[imageKey]?.let {
                        textBitmap = it
                    } ?: kotlin.run {
                        textBitmap = Bitmap.createBitmap(drawingBitmap.width, drawingBitmap.height, Bitmap.Config.ARGB_8888)
                        val textCanvas = Canvas(textBitmap)
                        drawingTextPaint.isAntiAlias = true
                        val bounds = Rect()
                        drawingTextPaint.getTextBounds(drawingText, 0, drawingText.length, bounds)
                        val x = (drawingBitmap.width - bounds.width()) / 2.0
                        val targetRectTop = 0
                        val targetRectBottom = drawingBitmap.height
                        val y = (targetRectBottom + targetRectTop - drawingTextPaint.fontMetrics.bottom - drawingTextPaint.fontMetrics.top) / 2
                        textCanvas.drawText(drawingText, x.toFloat(), y, drawingTextPaint)
                        drawTextCache.put(imageKey, textBitmap as Bitmap)
                    }
                }
            }
            dynamicItem.dynamicLayoutText[imageKey]?.let {
                drawTextCache[imageKey]?.let {
                    textBitmap = it
                } ?: kotlin.run {
                    it.paint.isAntiAlias = true
                    var layout = StaticLayout(it.text, 0, it.text.length, it.paint, drawingBitmap.width, it.alignment, it.spacingMultiplier, it.spacingAdd, false)
                    textBitmap = Bitmap.createBitmap(drawingBitmap.width, drawingBitmap.height, Bitmap.Config.ARGB_8888)
                    val textCanvas = Canvas(textBitmap)
                    textCanvas.translate(0f, ((drawingBitmap.height - layout.height) / 2).toFloat())
                    layout.draw(textCanvas)
                    drawTextCache.put(imageKey, textBitmap as Bitmap)
                }
            }
            textBitmap?.let { textBitmap ->
                sharedPaint.reset()
                sharedPaint.isAntiAlias = videoItem.antiAlias
                if (sprite.frameEntity.maskPath != null) {
                    val maskPath = sprite.frameEntity.maskPath ?: return@let
                    canvas.save()
                    canvas.concat(sharedFrameMatrix)
                    canvas.clipRect(0, 0, drawingBitmap.width, drawingBitmap.height)
                    val bitmapShader = BitmapShader(textBitmap, Shader.TileMode.REPEAT, Shader.TileMode.REPEAT)
                    sharedPaint.shader = bitmapShader
                    sharedPath.reset()
                    maskPath.buildPath(sharedPath)
                    canvas.drawPath(sharedPath, sharedPaint)
                    canvas.restore()
                }
                else {
                    sharedPaint.isFilterBitmap = videoItem.antiAlias
                    canvas.drawBitmap(textBitmap, sharedFrameMatrix, sharedPaint)
                }
            }
        }
    
    
        private fun drawShape(sprite: SVGADrawerSprite, canvas :Canvas) {
            resetShareMatrix(sprite.frameEntity.transform)
            sprite.frameEntity.shapes.forEach { shape ->
                shape.buildPath()
                shape.shapePath?.let {
                    sharedPaint.reset()
                    sharedPaint.isAntiAlias = videoItem.antiAlias
                    sharedPaint.alpha = (sprite.frameEntity.alpha * 255).toInt()
                    if(!drawPathCache.containsKey(shape)){
                        sharedShapeMatrix.reset()
                        shape.transform?.let {
                            sharedShapeMatrix.postConcat(it)
                        }
                        sharedShapeMatrix.postConcat(sharedFrameMatrix)
                        val path = Path()
                        path.set(shape.shapePath)
                        path.transform(sharedShapeMatrix)
                        drawPathCache.put(shape,path)
                    }
    
    
                    shape.styles?.fill?.let {
                        if (it != 0x00000000) {
                            sharedPaint.color = it
                            if (sprite.frameEntity.maskPath !== null) canvas.save()
                            sprite.frameEntity.maskPath?.let { maskPath ->
                                sharedPath2.reset()
                                maskPath.buildPath(sharedPath2)
                                sharedPath2.transform(this.sharedFrameMatrix)
                                canvas.clipPath(sharedPath2)
                            }
                            canvas.drawPath(drawPathCache.get(shape), sharedPaint)
                            if (sprite.frameEntity.maskPath !== null) canvas.restore()
                        }
                    }
    
    
                    shape.styles?.strokeWidth?.let {
                        if (it > 0) {
                            resetShapeStrokePaint(shape)
                            if (sprite.frameEntity.maskPath !== null) canvas.save()
                            sprite.frameEntity.maskPath?.let { maskPath ->
                                sharedPath2.reset()
                                maskPath.buildPath(sharedPath2)
                                sharedPath2.transform(this.sharedFrameMatrix)
                                canvas.clipPath(sharedPath2)
                            }
                            canvas.drawPath(drawPathCache.get(shape), sharedPaint)
                            if (sprite.frameEntity.maskPath !== null) canvas.restore()
                        }
                    }
                }
            }
        }


    总结


    * 其实就一句话:通过帧率去刷每一帧的画面,这个思路跟gif很像,但是通过配置使得动画过程中图片都可以得到复用。性能就提升上来了。并且不用解析高阶插值(二次线性方程,贝塞尔曲线方程),这种思路真是清奇呀,赞赞赞。

     

     

    展开全文
  • 兰博基尼!svga动画

    2020-02-21 14:48:00
    兰博基尼svga动画,效果大气!!
  • 这是一篇关于MAC版本如何安装SVGA的教程,如果你也有安装SVGA不是很流畅的问题看到底部,帮你解决问题~文末彩蛋介绍SVGA 是一种同时兼容 iOS / Android / Flutter / Web 多个平台的动画格式。为什么选 SVGA对开发者...
    cbb998061a22df9d3e7395d6a38305ed.png这是一篇关于MAC版本如何安装SVGA的教程,如果你也有安装SVGA不是很流畅的问题看到底部,帮你解决问题~文末彩蛋介绍SVGA 是一种同时兼容 iOS / Android / Flutter / Web 多个平台的动画格式。

    为什么选 SVGA

    对开发者友好

    便捷的 SDK 使得 SVGA 可运行在不同平台上,集成步骤轻松简单。

    对设计师友好

    你可以使用 After Effects 或是 Animate(Flash) 进行动画设计,SVGA 可以支持其中的大部分效果,设计师使用导出工具即可生成动画文件。

    性价比更高

    动画文件体积更小,播放资源占用更优,动画还原效果更好。e9cef439c91fd366069db6e8d341c37d.png第1步首先使用svga官网下载最新的组件。链接:http://svga.io/designer.html7c08348e6f830b48fe20466743e34b88.png第2步下载安装SVGA快捷工具ZXP Installer链接:https://zxpinstaller.com909feba727f8d11747a5ae3089547ca0.png第3步打开ZXP软件,command+o打开zxp文件按照步骤进行下一步完成安装073f382bfb7531c3f0ebf728865476db.png第4步打开AE,在窗口扩展中找到安装的SVGA插件,完成安装。d1afcaf02c48eaea76832ee2f5df775e.png快捷入口关注公众号:后台回复“SVGA”获取安装包,先安装1,安装完成后,打开2完成安装a70757091f54e5755f62ff4c27b31b8e.png37a0a2c35ebda1d7c4dde23452ccb900.png感谢您抽出宝贵时间“在看”86115f80dffa029b616a8744e2ce1d73.gif
    展开全文
  • 最近在直播间礼物动效设计中,用到了SVGA格式作为输出文件,但是这部分内容在网上的资料比较少,而且很多文章里面介绍的并不详细,在实际操作过程中又碰到了很多的麻烦,这也是我把导出SVGA的经验总结并分享给大家的...
  • SVGA,就是Scalable Vector Graphics Animetion,即可伸缩矢量图形动画,理解为就是一种2d位图动画的储存格式,可以很小的容量播放一个带通道的效果,很好的替代png序列(文件容量大)、gif文件格式(不支持透明通道\...
  • svga动画播放

    2021-03-25 11:52:25
    安装参考svga官方github https://github.com/svga/SVGAPlayer-Web html <div id='demoCanvas'></div> js var player = new SVGA.Player('#demoCanvas'); var parser = new SVGA.Parser('#demoCanvas'...
  • SVGA使用心得

    万次阅读 2019-07-17 09:43:04
    1、什么是SVGA SVGA是一种动画格式,可以兼容安卓、ios和web,可以实现很多复杂的动画,这样开发就不用头疼canvas来实现动画时的卡顿优化问题了。 2、引入SVGA 因为博主是前端方向的,所以这里只介绍web页面如何...
  • 在UI动效中广泛用到svga动画,svga动画主要针对的是位图(就是图片)和简单的矢量图形,通过记录每张素材的位移缩放等数据来实现动画它的优点是1、省去开发的时间成本2、对交互动画本身的还原度极高3、导出的包比较小4...
  • SVGA-Vue

    2021-01-28 09:28:04
    vue-svga 这是基于svga.lite封装的一个Vue组件 支持其所有配置,且默认值也保持一致 组件接受参数 属性名 说明 类型 默认值 必须 src 资源链接(需使用require包裹链接) string undefined 是 options 包括...
  • SVGA源码解析

    2020-11-27 17:06:24
    文章目录SVGA源码解析数据解析-SVGAParser动画实体类-SVGAVideoEntity绘制实体-SVGADrawableDrawable绘制者-SVGACanvasDrawerSVAG容器-SVAGImageView SVGA源码解析 数据解析-SVGAParser 主要是decodeFromInputStream...
  • SVGA 出现OOM

    2020-12-01 17:42:48
    我们使用SVGA超过700人的设备出现OOM,出现次数搭4500 出现问题的设备 Nile X 7.0 SM-J701F 8.1.0 SM-J200F 5.1.1 How To Reappear(How to reappear the issue) 不断的使用SVGA动画 Any Attachment(Provide a...
  • SVGA-介绍

    2021-01-26 13:53:33
    SVGA-Format 介绍 SVGA 是一种动画格式 SVGA 类似于 Dragonbones / CreateJS 格式规范 1.x 1.x 使用 JSON 描述动画,JSON 是一种易于扩展的、强大的描述语言,但是,JSON 也有一个致命的缺点,当动画极度复杂时,...
  • svga动态图片展示

    2018-06-27 10:34:40
    svga动态图片展示(YY UED团队制作) 。。。。。。。。。
  • svga-named.zip

    2021-03-26 12:25:30
    提供很多直播特效文件用来测试svga的动画方案,不可用于商业项目!!资源来自于网络,如有侵权立即删除!!
  • 千款礼物 直播平台专属通过集成指南,可以轻松的在 iOS / Android / Web 中引入 SVGA 播放器并播放资源文件 性价比更高
  • SVGA的使用

    2021-02-25 14:29:01
    SVGA使用 #import "SVGA.h" @interface ViewController ()<SVGAPlayerDelegate> @property (weak, nonatomic) IBOutlet SVGAPlayer *aPlayer; @property (weak, nonatomic) IBOutlet UISlider *aSlider; @...
  • <div><p>in chrome 31, svga donot work, it happen error with <pre><code> unknown compression method l.load_viaProto o.onloadend </code></pre> <p>so which version do it can suppot?</p><p>该提问来源于...
  • VMware SVGA 3D.iso

    2020-07-04 09:46:58
    vmware的vmware svga 3d驱动,适用于win8早期预览版、win7、vista、部分longhorn
  • 测试用的SVGA资源.rar

    2021-03-21 20:35:18
    测试用的SVGA资源
  • react-native-svga-源码

    2021-03-15 16:09:53
    react-native-svga 入门 $ npm install react-native-svga --save 大多是自动安装 $ react-native link react-native-svga 用法 import { ISvgaProps , SVGAView } from 'react-native-svga' export function ...
  • svga文件声音问题

    2020-12-01 17:42:46
    <div><p>在svga文件中加入声音后,内存就无法释放,不加声音可以释放,请问是文件问题还是释放需要其它处理</p><p>该提问来源于开源项目:svga/SVGAPlayer-Android</p></div>
  • 一、前言在开发APP的过程中,需要在APP中实现设计同学的UE效果动画,一般都是通过代码实现的,当对于较复杂的动画...为了解决这样的问题,今天来介绍一款实现复杂动画的开源库:SVGA。GIF.gif二、下面介绍用法:1、...
  • SVGA格式的动画

    千次阅读 2018-12-05 15:37:00
    为什么选 SVGA? 对码农友好 对设计师友好 性价比更高 CocoaPods 基础调用方法 为什么选 SVGA? 对码农友好 便捷的 SDK 使得 SVGA 可运行在不同平台上,集成步骤轻松简单。 对设计师友好 你可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 923
精华内容 369
关键字:

svga