예제 #1
0
 static int InvalidUpdate(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 1);
         DragonBones.Bone obj = (DragonBones.Bone)ToLua.CheckObject(L, 1, typeof(DragonBones.Bone));
         obj.InvalidUpdate();
         return(0);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
예제 #2
0
        /// <summary>
        /// - Forces a specific bone or its owning slot to update the transform or display property in the next frame.
        /// </summary>
        /// <param name="boneName">- The bone name. (If not set, all bones will be update)</param>
        /// <param name="updateSlot">- Whether to update the bone's slots. (Default: false)</param>
        /// <see cref="DragonBones.Bone.InvalidUpdate()"/>
        /// <see cref="DragonBones.Slot.InvalidUpdate()"/>
        /// <version>DragonBones 3.0</version>
        /// <language>en_US</language>

        /// <summary>
        /// - 强制特定骨骼或其拥有的插槽在下一帧更新变换或显示属性。
        /// </summary>
        /// <param name="boneName">- 骨骼名称。 (如果未设置,将更新所有骨骼)</param>
        /// <param name="updateSlot">- 是否更新骨骼的插槽。 (默认: false)</param>
        /// <see cref="DragonBones.Bone.InvalidUpdate()"/>
        /// <see cref="DragonBones.Slot.InvalidUpdate()"/>
        /// <version>DragonBones 3.0</version>
        /// <language>zh_CN</language>
        public void InvalidUpdate(string boneName = null, bool updateSlot = false)
        {
            if (!string.IsNullOrEmpty(boneName))
            {
                Bone bone = this.GetBone(boneName);
                if (bone != null)
                {
                    bone.InvalidUpdate();

                    if (updateSlot)
                    {
                        foreach (var slot in this._slots)
                        {
                            if (slot.parent == bone)
                            {
                                slot.InvalidUpdate();
                            }
                        }
                    }
                }
            }
            else
            {
                foreach (var bone in this._bones)
                {
                    bone.InvalidUpdate();
                }

                if (updateSlot)
                {
                    foreach (var slot in this._slots)
                    {
                        slot.InvalidUpdate();
                    }
                }
            }
        }
예제 #3
0
        override public void Update(float passedTime)
        {
            // Blend animation state.
            var animationLayer = _animationState._layer;
            var weight         = _animationState._weightResult;

            if (bone._updateState <= 0)
            {
                base.Update(passedTime);

                bone._blendLayer       = animationLayer;
                bone._blendLeftWeight  = 1.0f;
                bone._blendTotalWeight = weight;

                _boneTransform.x      = _transform.x * weight;
                _boneTransform.y      = _transform.y * weight;
                _boneTransform.skewX  = _transform.skewX * weight;
                _boneTransform.skewY  = _transform.skewY * weight;
                _boneTransform.scaleX = (_transform.scaleX - 1) * weight + 1.0f;
                _boneTransform.scaleY = (_transform.scaleY - 1) * weight + 1.0f;

                bone._updateState = 1;
            }
            else if (bone._blendLeftWeight > 0.0f)
            {
                if (bone._blendLayer != animationLayer)
                {
                    if (bone._blendTotalWeight >= bone._blendLeftWeight)
                    {
                        bone._blendLeftWeight = 0.0f;
                    }
                    else
                    {
                        bone._blendLayer       = animationLayer;
                        bone._blendLeftWeight -= bone._blendTotalWeight;
                        bone._blendTotalWeight = 0.0f;
                    }
                }

                weight *= bone._blendLeftWeight;
                if (weight > 0.0f)
                {
                    base.Update(passedTime);

                    bone._blendTotalWeight += weight;

                    _boneTransform.x      += _transform.x * weight;
                    _boneTransform.y      += _transform.y * weight;
                    _boneTransform.skewX  += _transform.skewX * weight;
                    _boneTransform.skewY  += _transform.skewY * weight;
                    _boneTransform.scaleX += (_transform.scaleX - 1.0f) * weight;
                    _boneTransform.scaleY += (_transform.scaleY - 1.0f) * weight;

                    bone._updateState++;
                }
            }

            if (bone._updateState > 0)
            {
                if (_transformDirty || _animationState._fadeState != 0 || _animationState._subFadeState != 0)
                {
                    _transformDirty = false;

                    bone.InvalidUpdate();
                }
            }
        }
예제 #4
0
        override protected void _onUpdateFrame(bool isUpdate)
        {
            if (_tweenTransform != TweenType.None || _tweenRotate != TweenType.None || _tweenScale != TweenType.None)
            {
                base._onUpdateFrame(isUpdate);

                var tweenProgress = 0.0f;

                if (_tweenTransform != TweenType.None)
                {
                    if (_tweenTransform == TweenType.Once)
                    {
                        _tweenTransform = TweenType.None;
                        tweenProgress   = 0.0f;
                    }
                    else
                    {
                        tweenProgress = _tweenProgress;
                    }

                    if (_animationState.additiveBlending) // Additive blending.
                    {
                        _transform.x = _currentTransform.x + _durationTransform.x * tweenProgress;
                        _transform.y = _currentTransform.y + _durationTransform.y * tweenProgress;
                    }
                    else // Normal blending.
                    {
                        _transform.x = _originTransform.x + _currentTransform.x + _durationTransform.x * tweenProgress;
                        _transform.y = _originTransform.y + _currentTransform.y + _durationTransform.y * tweenProgress;
                    }
                }

                if (_tweenRotate != TweenType.None)
                {
                    if (_tweenRotate == TweenType.Once)
                    {
                        _tweenRotate  = TweenType.None;
                        tweenProgress = 0.0f;
                    }
                    else
                    {
                        tweenProgress = _tweenProgress;
                    }

                    if (_animationState.additiveBlending) // Additive blending.
                    {
                        _transform.skewX = _currentTransform.skewX + _durationTransform.skewX * tweenProgress;
                        _transform.skewY = _currentTransform.skewY + _durationTransform.skewY * tweenProgress;
                    }
                    else // Normal blending.
                    {
                        _transform.skewX = _originTransform.skewX + _currentTransform.skewX + _durationTransform.skewX * tweenProgress;
                        _transform.skewY = _originTransform.skewY + _currentTransform.skewY + _durationTransform.skewY * tweenProgress;
                    }
                }

                if (_tweenScale != TweenType.None)
                {
                    if (_tweenScale == TweenType.Once)
                    {
                        _tweenScale   = TweenType.None;
                        tweenProgress = 0.0f;
                    }
                    else
                    {
                        tweenProgress = _tweenProgress;
                    }

                    if (_animationState.additiveBlending) // Additive blending.
                    {
                        _transform.scaleX = _currentTransform.scaleX + _durationTransform.scaleX * tweenProgress;
                        _transform.scaleY = _currentTransform.scaleY + _durationTransform.scaleY * tweenProgress;
                    }
                    else // Normal blending.
                    {
                        _transform.scaleX = _originTransform.scaleX * (_currentTransform.scaleX + _durationTransform.scaleX * tweenProgress);
                        _transform.scaleY = _originTransform.scaleY * (_currentTransform.scaleY + _durationTransform.scaleY * tweenProgress);
                    }
                }

                bone.InvalidUpdate();
            }
        }