async Task InitTransformOperationAssist(EngineNS.CRenderContext rc)
        {
            for (int i = 0; i < (int)enTransformOPHandleType.Count; i++)
            {
                var imgInit = new EngineNS.UISystem.Controls.ImageInitializer();
                imgInit.ImageBrush.ImageName = EngineNS.RName.GetRName("uieditor/uva_op_pin.uvanim", EngineNS.RName.enRNameType.Editor);
                imgInit.ImageBrush.TileMode  = EngineNS.UISystem.Brush.enTileMode.None;
                var img = new EngineNS.UISystem.Controls.Image();
                await img.Initialize(rc, imgInit);

                img.Visibility = EngineNS.UISystem.Visibility.Collapsed;

                var rect   = new EngineNS.RectangleF(0, 0, 16, 16);
                var uvAnim = await EngineNS.CEngine.Instance.UVAnimManager.GetUVAnimAsync(rc, imgInit.ImageBrush.ImageName);

                if (uvAnim != null && uvAnim.Frames.Count > 0)
                {
                    await uvAnim.WaitTextureValid(rc);

                    var width  = uvAnim.PixelWidth * uvAnim.Frames[0].SizeU;
                    var height = uvAnim.PixelHeight * uvAnim.Frames[0].SizeV;
                    rect = new EngineNS.RectangleF(0, 0, width, height);
                }

                mTransformHandles[i] = new TransformHandleData()
                {
                    Show    = img,
                    SrcRect = rect,
                };
            }
        }
        void Viewport_TickLogic(EditorCommon.ViewPort.ViewPortControl vpc)
        {
            var rc = EngineNS.CEngine.Instance.RenderContext;

            if (vpc.World != null)
            {
                vpc.World.CheckVisible(rc.ImmCommandList, vpc.Camera);
                vpc.World.Tick();
            }
            vpc.RPolicy.TickLogic(null, rc);

            var designRect   = new EngineNS.RectangleF(0, 0, Viewport.GetViewPortWidth(), Viewport.GetViewPortHeight());
            var tempClipRect = designRect;

            if (mUVAnim != null && mImage2D != null)
            {
                mUVAnim.CheckAndAutoReferenceFromTemplateUVAnim();
                bool frameChanged;
                var  frame = mUVAnim.GetUVFrame(EngineNS.Support.Time.GetTickCount(), out frameChanged);
                if (frameChanged || mForceUpdateFrame)
                {
                    using (var posData = EngineNS.Support.NativeListProxy <EngineNS.Vector3> .CreateNativeList())
                        using (var uvData = EngineNS.Support.NativeListProxy <EngineNS.Vector2> .CreateNativeList())
                        {
                            frame.UpdateVertexes(posData, ref designRect, ref tempClipRect);
                            frame.UpdateUVs(uvData, ref designRect, ref tempClipRect);
                            mImage2D.RenderMatrix = EngineNS.Matrix.Scaling(tempClipRect.Width, tempClipRect.Height, 1) * EngineNS.Matrix.Translate(tempClipRect.Left, tempClipRect.Top, 0.0f);
                            mImage2D.SetUV(uvData, rc.ImmCommandList);
                            mImage2D.SetVertexBuffer(posData, rc.ImmCommandList);

                            mForceUpdateFrame = false;
                        }
                }
            }
        }
        void UpdateSelectedRectShow()
        {
            if (mSelectedUIDatas.Count == 0)
            {
                //UpdateTransformOperationAssistShow();
                mSlotOperator?.UpdateShow(null, ref mWindowDesignSize, ref mWindowDrawSize);
                //UpdateCanvasAnchorsHandlesShow();
                return;
            }
            foreach (var data in mSelectedUIDatas.Values)
            {
                var uiElement = data.UI;
                var show      = data.ShowRect;

                var leftDelta   = uiElement.DesignRect.X / mWindowDesignSize.Width;
                var topDelta    = uiElement.DesignRect.Y / mWindowDesignSize.Height;
                var widthDelta  = uiElement.DesignRect.Width / mWindowDesignSize.Width;
                var heightDelta = uiElement.DesignRect.Height / mWindowDesignSize.Height;
                var dRect       = new EngineNS.RectangleF(mWindowDrawSize.Width * leftDelta + mWindowDrawSize.Left - 1,
                                                          mWindowDrawSize.Height * topDelta + mWindowDrawSize.Top - 1,
                                                          mWindowDrawSize.Width * widthDelta + 2,
                                                          mWindowDrawSize.Height * heightDelta + 2);
                if (!show.DesignRect.Equals(ref dRect))
                {
                    show.SetDesignRect(ref dRect, true);
                }
            }
            //UpdateTransformOperationAssistShow();
            if (mSelectedUIDatas.Count == 1)
            {
                mSlotOperator?.UpdateShow(mSelectedUIDatas.First().Value, ref mWindowDesignSize, ref mWindowDrawSize);
            }
            //UpdateCanvasAnchorsHandlesShow();
        }
        void UpdatePanelRectsShow()
        {
            if (mPanelRectsShow.Count == 0)
            {
                return;
            }

            foreach (var rect in mPanelRectsShow)
            {
                var uiElement = rect.Key;
                var show      = rect.Value;

                var leftDelta   = uiElement.DesignRect.X / mWindowDesignSize.Width;
                var topDelta    = uiElement.DesignRect.Y / mWindowDesignSize.Height;
                var widthDelta  = uiElement.DesignRect.Width / mWindowDesignSize.Width;
                var heightDelta = uiElement.DesignRect.Height / mWindowDesignSize.Height;
                var dRect       = new EngineNS.RectangleF(mWindowDrawSize.Width * leftDelta + mWindowDrawSize.Left - 1,
                                                          mWindowDrawSize.Height * topDelta + mWindowDrawSize.Top - 1,
                                                          mWindowDrawSize.Width * widthDelta + 2,
                                                          mWindowDrawSize.Height * heightDelta + 2);
                if (!show.DesignRect.Equals(ref dRect))
                {
                    show.SetDesignRect(ref dRect, true);
                }
            }
        }
        async Task InitCanvasAnchorsHandles(EngineNS.CRenderContext rc)
        {
            string[] pinNames = new string[] { "uieditor/uva_op_center.uvanim",
                                               "uieditor/uva_op_topleft.uvanim",
                                               "uieditor/uva_op_topright.uvanim",
                                               "uieditor/uva_op_bottomright.uvanim",
                                               "uieditor/uva_op_bottomleft.uvanim",
                                               "uieditor/uva_op_left.uvanim",
                                               "uieditor/uva_op_top.uvanim",
                                               "uieditor/uva_op_right.uvanim",
                                               "uieditor/uva_op_bottom.uvanim" };

            for (int i = 0; i < (int)enCanvasAnchors.Count; i++)
            {
                var imgInit = new EngineNS.UISystem.Controls.ImageInitializer();
                imgInit.ImageBrush.ImageName = EngineNS.RName.GetRName(pinNames[i], EngineNS.RName.enRNameType.Editor);
                imgInit.ImageBrush.TileMode  = EngineNS.UISystem.Brush.enTileMode.None;
                var img = new EngineNS.UISystem.Controls.Image();
                await img.Initialize(rc, imgInit);

                img.Visibility = EngineNS.UISystem.Visibility.Collapsed;

                var rect   = new EngineNS.RectangleF(0, 0, 16, 16);
                var uvAnim = await EngineNS.CEngine.Instance.UVAnimManager.GetUVAnimAsync(rc, imgInit.ImageBrush.ImageName);

                if (uvAnim != null && uvAnim.Frames.Count > 0)
                {
                    await uvAnim.WaitTextureValid(rc);

                    var width  = uvAnim.PixelWidth * uvAnim.Frames[0].SizeU;
                    var height = uvAnim.PixelHeight * uvAnim.Frames[0].SizeV;
                    rect = new EngineNS.RectangleF(0, 0, width, height);
                }

                mCanvasAnchorsHandles[i] = new AnchorsHandleData()
                {
                    Show    = img,
                    SrcRect = rect,
                };
            }
        }
        // 更新鼠标指向框显示
        void UpdatePointAtShow()
        {
            if (mMousePointAtUIRectShow == null)
            {
                return;
            }
            if (mMousePointAtUIElement == null)
            {
                mMousePointAtUIRectShow.Visibility = EngineNS.UISystem.Visibility.Collapsed;
                return;
            }

            var leftDelta   = mMousePointAtUIElement.DesignRect.X / mWindowDesignSize.Width;
            var topDelta    = mMousePointAtUIElement.DesignRect.Y / mWindowDesignSize.Height;
            var widthDelta  = mMousePointAtUIElement.DesignRect.Width / mWindowDesignSize.Width;
            var heightDelta = mMousePointAtUIElement.DesignRect.Height / mWindowDesignSize.Height;
            var dRect       = new EngineNS.RectangleF(mWindowDrawSize.Width * leftDelta + mWindowDrawSize.Left - 2,
                                                      mWindowDrawSize.Height * topDelta + mWindowDrawSize.Top - 2,
                                                      mWindowDrawSize.Width * widthDelta + 4,
                                                      mWindowDrawSize.Height * heightDelta + 4);

            mMousePointAtUIRectShow.SetDesignRect(ref dRect, true);
            mMousePointAtUIRectShow.Visibility = EngineNS.UISystem.Visibility.Visible;
        }
Exemple #7
0
 public abstract void ProcessSetContentDesignRect(ref EngineNS.RectangleF tagRect);
Exemple #8
0
 public abstract void Arrange(ref EngineNS.RectangleF arrangeSize);
        void UpdateTransformOperationAssistShow(EngineNS.UISystem.Editor.SelectedData operationUIData)
        {
            if (operationUIData != null)
            {
                var selectRect = operationUIData.ShowRect.DesignRect;

                for (int i = 0; i < (int)enTransformOPHandleType.Count; i++)
                {
                    var handle = mTransformHandles[i];
                    if (handle == null)
                    {
                        continue;
                    }
                    handle.Show.Visibility = EngineNS.UISystem.Visibility.Visible;
                    var handleRect = handle.SrcRect;
                    var drawWidth  = handleRect.Width;
                    var drawHeight = handleRect.Height;
                    var newRect    = new EngineNS.RectangleF(0, 0, drawWidth, drawHeight);
                    switch ((enTransformOPHandleType)i)
                    {
                    case enTransformOPHandleType.LeftTop:
                        newRect.X = selectRect.X - drawWidth;
                        newRect.Y = selectRect.Y - drawHeight;
                        break;

                    case enTransformOPHandleType.Top:
                        newRect.X = selectRect.X + selectRect.Width * 0.5f - drawWidth * 0.5f;
                        newRect.Y = selectRect.Y - drawHeight;
                        break;

                    case enTransformOPHandleType.RightTop:
                        newRect.X = selectRect.X + selectRect.Width;
                        newRect.Y = selectRect.Y - drawHeight;
                        break;

                    case enTransformOPHandleType.Right:
                        newRect.X = selectRect.X + selectRect.Width;
                        newRect.Y = selectRect.Y + selectRect.Height * 0.5f - drawHeight * 0.5f;
                        break;

                    case enTransformOPHandleType.RightBottom:
                        newRect.X = selectRect.X + selectRect.Width;
                        newRect.Y = selectRect.Y + selectRect.Height;
                        break;

                    case enTransformOPHandleType.Bottom:
                        newRect.X = selectRect.X + selectRect.Width * 0.5f - drawWidth * 0.5f;
                        newRect.Y = selectRect.Y + selectRect.Height;
                        break;

                    case enTransformOPHandleType.LeftBottom:
                        newRect.X = selectRect.X - drawWidth;
                        newRect.Y = selectRect.Y + selectRect.Height;
                        break;

                    case enTransformOPHandleType.Left:
                        newRect.X = selectRect.X - drawWidth;
                        newRect.Y = selectRect.Y + selectRect.Height * 0.5f - drawHeight * 0.5f;
                        break;
                    }
                    handle.Show.SetDesignRect(ref newRect, true);
                }
            }
            else
            {
                for (int i = 0; i < (int)enTransformOPHandleType.Count; i++)
                {
                    if (mTransformHandles[i] == null)
                    {
                        continue;
                    }
                    mTransformHandles[i].Show.Visibility = EngineNS.UISystem.Visibility.Collapsed;
                }
            }
        }
        void UpdateCanvasAnchorsHandlesShow(EngineNS.UISystem.Editor.SelectedData operationUIData, ref EngineNS.RectangleF windowDesignSize, ref EngineNS.RectangleF windowDrawSize)
        {
            foreach (var handle in mCanvasAnchorsHandles)
            {
                if (handle == null)
                {
                    continue;
                }
                handle.Show.Visibility = EngineNS.UISystem.Visibility.Collapsed;
            }
            if (operationUIData != null)
            {
                var anchorOp = operationUIData.UI.Slot as EngineNS.UISystem.Controls.Containers.CanvasSlot;
                if (anchorOp == null)
                {
                    return;
                }
                var canvas = operationUIData.UI.Parent as EngineNS.UISystem.Controls.Containers.CanvasPanel;
                if (canvas == null)
                {
                    return;
                }

                if (anchorOp.Maximum.Equals(anchorOp.Minimum))
                {
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Center].Show.Visibility = EngineNS.UISystem.Visibility.Visible;
                }
                else
                {
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Center].Show.Visibility = EngineNS.UISystem.Visibility.Collapsed;
                }
                if (anchorOp.Maximum.X == anchorOp.Minimum.X)
                {
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Top].Show.Visibility    = EngineNS.UISystem.Visibility.Visible;
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Bottom].Show.Visibility = EngineNS.UISystem.Visibility.Visible;
                }
                else
                {
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Top].Show.Visibility    = EngineNS.UISystem.Visibility.Collapsed;
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Bottom].Show.Visibility = EngineNS.UISystem.Visibility.Collapsed;
                }
                if (anchorOp.Maximum.Y == anchorOp.Minimum.Y)
                {
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Left].Show.Visibility  = EngineNS.UISystem.Visibility.Visible;
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Right].Show.Visibility = EngineNS.UISystem.Visibility.Visible;
                }
                else
                {
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Left].Show.Visibility  = EngineNS.UISystem.Visibility.Collapsed;
                    mCanvasAnchorsHandles[(int)enCanvasAnchors.Right].Show.Visibility = EngineNS.UISystem.Visibility.Collapsed;
                }
                mCanvasAnchorsHandles[(int)enCanvasAnchors.LeftTop].Show.Visibility     = EngineNS.UISystem.Visibility.Visible;
                mCanvasAnchorsHandles[(int)enCanvasAnchors.RightTop].Show.Visibility    = EngineNS.UISystem.Visibility.Visible;
                mCanvasAnchorsHandles[(int)enCanvasAnchors.RightBottom].Show.Visibility = EngineNS.UISystem.Visibility.Visible;
                mCanvasAnchorsHandles[(int)enCanvasAnchors.LeftBottom].Show.Visibility  = EngineNS.UISystem.Visibility.Visible;

                var canvasRect  = canvas.DesignRect;
                var leftDelta   = canvasRect.X / windowDesignSize.Width;
                var topDelta    = canvasRect.Y / windowDesignSize.Height;
                var widthDelta  = canvasRect.Width / windowDesignSize.Width;
                var heightDelta = canvasRect.Height / windowDesignSize.Height;
                canvasRect = new EngineNS.RectangleF(windowDrawSize.Width * leftDelta + windowDrawSize.Left,
                                                     windowDrawSize.Height * topDelta + windowDrawSize.Top,
                                                     windowDrawSize.Width * widthDelta,
                                                     windowDrawSize.Height * heightDelta);

                var showRect = new EngineNS.RectangleF();

                showRect.X      = anchorOp.Minimum.X * canvasRect.Width + canvasRect.Left;
                showRect.Y      = anchorOp.Minimum.Y * canvasRect.Height + canvasRect.Top;
                showRect.Width  = (anchorOp.Maximum.X - anchorOp.Minimum.X) * canvasRect.Width;
                showRect.Height = (anchorOp.Maximum.Y - anchorOp.Minimum.Y) * canvasRect.Height;

                for (int i = 0; i < (int)enCanvasAnchors.Count; i++)
                {
                    var handle = mCanvasAnchorsHandles[i];
                    if (handle == null || handle.Show.Visibility == EngineNS.UISystem.Visibility.Collapsed)
                    {
                        continue;
                    }

                    var handleRect = handle.SrcRect;
                    var drawWidth  = handleRect.Width;
                    var drawHeight = handleRect.Height;
                    var newRect    = new EngineNS.RectangleF(0, 0, drawWidth, drawHeight);
                    switch ((enCanvasAnchors)i)
                    {
                    case enCanvasAnchors.Center:
                        newRect.X = showRect.X - drawWidth * 0.5f;
                        newRect.Y = showRect.Y - drawHeight * 0.5f;
                        break;

                    case enCanvasAnchors.Top:
                        newRect.X = showRect.X + showRect.Width * 0.5f - drawWidth * 0.5f;
                        newRect.Y = showRect.Y - drawHeight;
                        break;

                    case enCanvasAnchors.RightTop:
                        newRect.X = showRect.X + showRect.Width;
                        newRect.Y = showRect.Y - drawHeight;
                        break;

                    case enCanvasAnchors.Right:
                        newRect.X = showRect.X + showRect.Width;
                        newRect.Y = showRect.Y + showRect.Height * 0.5f - drawHeight * 0.5f;
                        break;

                    case enCanvasAnchors.RightBottom:
                        newRect.X = showRect.X + showRect.Width;
                        newRect.Y = showRect.Y + showRect.Height;
                        break;

                    case enCanvasAnchors.Bottom:
                        newRect.X = showRect.X + showRect.Width * 0.5f - drawWidth * 0.5f;
                        newRect.Y = showRect.Y + showRect.Height;
                        break;

                    case enCanvasAnchors.LeftBottom:
                        newRect.X = showRect.X - drawWidth;
                        newRect.Y = showRect.Y + showRect.Height;
                        break;

                    case enCanvasAnchors.Left:
                        newRect.X = showRect.X - drawWidth;
                        newRect.Y = showRect.Y + showRect.Height * 0.5f - drawHeight * 0.5f;
                        break;

                    case enCanvasAnchors.LeftTop:
                        newRect.X = showRect.X - drawWidth;
                        newRect.Y = showRect.Y - drawHeight;
                        break;
                    }
                    handle.Show.SetDesignRect(ref newRect, true);
                }
            }
        }
 // 更新显示
 public void UpdateShow(EngineNS.UISystem.Editor.SelectedData operationUIData, ref EngineNS.RectangleF windowDesignSize, ref EngineNS.RectangleF windowDrawSize)
 {
     if (!mInitialized)
     {
         return;
     }
     UpdateCanvasAnchorsHandlesShow(operationUIData, ref windowDesignSize, ref windowDrawSize);
     UpdateTransformOperationAssistShow(operationUIData);
 }