u010019717
u010019717

在Unity中创建基于Node节点的编辑器 （一）

孙广东   2018.5.13

Unity  AssetStore中关于Node节点 编辑器相关的插件可是数不胜数， 状态机，行为树，Shader 可视化等等。

Unity自己也有 Animator的窗口使用， 还有新的Shader Graph。

         现在Unity的编辑器代码已经开源了，还没有时间看。


第一部分， 创建界面 功能
在这篇博文中，我们将在Unity中创建我们自己的基于节点的编辑器。 是一个简单的节点编辑器，您可以进行改进。
在Unity中创建基于Node节点的编辑器 （一）_第1张图片
我们将在这篇文章中创建这个窗口（点击查看gif的动作）

创建窗口
我们先创建一个简单的编辑器窗口。 代码的结构与我们在之前的文章中开发的控制台克隆类似：首先绘制元素，然后处理输入，并且如果由于输入事件而改变GUI，则强制窗口重绘。
using UnityEngine ;
using UnityEditor ;
using System . Collections . Generic ;
 
public class NodeBasedEditor : EditorWindow
{
     [ MenuItem ( "Window/Node Based Editor" )]
     private static void OpenWindow ()
     {
         NodeBasedEditor window = GetWindow < NodeBasedEditor > ();
         window . titleContent = new GUIContent ( "Node Based Editor" );
     }
 
     private void OnGUI ()
     {
         DrawNodes ();
 
         ProcessEvents ( Event . current );
 
         if ( GUI . changed ) Repaint ();
     }
 
     private void DrawNodes ()
     {
     }
 
     private void ProcessEvents ( Event e )
     {
     }
}
绘制节点
那么，因为这是一个节点编辑器，它应该包含一个节点列表，这就要求我们定义一个 List。 但首先我们应该定义Node类。 节点将负责绘制自己并处理自己的事件。 与 NodeBasedEditor中的 ProcessEvents(Event e)  不同，Node中的 ProcessEvents(Event e)  将返回一个布尔值，以便我们检查是否应该重新绘制GUI。

using System ;
using UnityEditor ;
using UnityEngine ;
 
public class Node
{
     public Rect rect ;
     public string title ;
 
     public GUIStyle style ;
 
     public Node ( Vector2 position , float width , float height , GUIStyle nodeStyle )
     {
         rect = new Rect ( position . x , position . y , width , height );
         style = nodeStyle ;
     }
 
     public void Drag ( Vector2 delta )
     {
         rect . position += delta ;
     }
 
     public void Draw ()
     {
         GUI . Box ( rect , title , style );
     }
 
     public bool ProcessEvents ( Event e )
     {
         return false ;
     }
}

using UnityEngine ;
using UnityEditor ;
using System . Collections . Generic ;
 
public class NodeBasedEditor : EditorWindow
{
     private List < Node > nodes ;
 
     [ MenuItem ( "Window/Node Based Editor" )]
     private static void OpenWindow ()
     {
         NodeBasedEditor window = GetWindow < NodeBasedEditor > ();
         window . titleContent = new GUIContent ( "Node Based Editor" );
     }
 
     private void OnGUI ()
     {
         DrawNodes ();
 
         ProcessEvents ( Event . current );
 
         if ( GUI . changed ) Repaint ();
     }
 
     private void DrawNodes ()
     {
         if ( nodes != null )
         {
             for ( int i = 0 ; i < nodes . Count ; i ++ )
             {
                 nodes [ i ]. Draw ();
             }
         }
     }
 
     private void ProcessEvents ( Event e )
     {
     }
}

创建节点
节点现在在编辑器中绘制，但如果我们不创建节点，则无法看到它们。 当用户在编辑器中点击右键时，我们应该显示一个带有“ Add node”项的上下文菜单。 当用户点击“ Add node”时，我们将创建一个节点并将其添加到节点列表中，以便绘制它。 节点需要位置，宽度，高度和样式; 位置将是鼠标的当前位置，宽度将是200，高度将是50（是的，我不喜欢在代码中使用 magic numbers，但这将是一个简单的编辑器），我们将复制Animator窗口的节点样式进行造型。

using UnityEngine ;
using UnityEditor ;
using System . Collections . Generic ;
 
public class NodeBasedEditor : EditorWindow
{
     private List < Node > nodes ;
 
     private GUIStyle nodeStyle ;
 
     [ MenuItem ( "Window/Node Based Editor" )]
     private static void OpenWindow ()
     {
         NodeBasedEditor window = GetWindow < NodeBasedEditor > ();
         window . titleContent = new GUIContent ( "Node Based Editor" );
     }
 
     private void OnEnable ()
     {
         nodeStyle = new GUIStyle ();
         nodeStyle . normal . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/node1.png" ) as Texture2D ;
         nodeStyle . border = new RectOffset ( 12 , 12 , 12 , 12 );
     }
 
     private void OnGUI ()
     {
         DrawNodes ();
 
         ProcessEvents ( Event . current );
 
         if ( GUI . changed ) Repaint ();
     }
 
     private void DrawNodes ()
     {
         if ( nodes != null )
         {
             for ( int i = 0 ; i < nodes . Count ; i ++ )
             {
                 nodes [ i ]. Draw ();
             }
         }
     }
 
     private void ProcessEvents ( Event e )
     {
         switch ( e . type )
         {
             case EventType . MouseDown :
                 if ( e . button == 1 )
                 {
                     ProcessContextMenu ( e . mousePosition );
                 }
                 break ;
         }
     }
 
     private void ProcessContextMenu ( Vector2 mousePosition )
     {
         GenericMenu genericMenu = new GenericMenu ();
         genericMenu . AddItem ( new GUIContent ( "Add node" ), false , () => OnClickAddNode ( mousePosition ));
         genericMenu . ShowAsContext ();
     }
 
     private void OnClickAddNode ( Vector2 mousePosition )
     {
         if ( nodes == null )
         {
             nodes = new List < Node > ();
         }
 
         nodes . Add ( new Node ( mousePosition , 200 , 50 , nodeStyle ));
     }
}

使节点可拖动
好的，现在我们可以添加节点了，但是我们不能拖动它们。 正如我前面提到的，节点将处理它们自己的事件，因此我们将在 Node类中处理拖动事件。 这里需要注意的一点是，我们应该使用 Use() 方法“ using”拖动事件。 稍后，我们将添加画布拖动，并且我们不希望同时拖动节点和整个画布（“ using”一个事件阻止它被其他过程使用，即停止事件冒泡）。 另请注意，   ProcessNodeEvents(Event e)中的for循环向后遍历节点列表，因为最后一个节点位于顶部，所以它应该首先处理事件。

using System ;
using UnityEditor ;
using UnityEngine ;
 
public class Node
{
     public Rect rect ;
     public string title ;
     public bool isDragged ;
 
     public GUIStyle style ;
 
     public Node ( Vector2 position , float width , float height , GUIStyle nodeStyle )
     {
         rect = new Rect ( position . x , position . y , width , height );
         style = nodeStyle ;
     }
 
     public void Drag ( Vector2 delta )
     {
         rect . position += delta ;
     }
 
     public void Draw ()
     {
         GUI . Box ( rect , title , style );
     }
 
     public bool ProcessEvents ( Event e )
     {
         switch ( e . type )
         {
             case EventType . MouseDown :
                 if ( e . button == 0 )
                 {
                     if ( rect . Contains ( e . mousePosition ))
                     {
                         isDragged = true ;
                         GUI . changed = true ;
                     }
                     else
                     {
                         GUI . changed = true ;
                     }
                 }
                 break ;
 
             case EventType . MouseUp :
                 isDragged = false ;
                 break ;
 
             case EventType . MouseDrag :
                 if ( e . button == 0 && isDragged )
                 {
                     Drag ( e . delta );
                     e . Use ();
                     return true ;
                 }
                 break ;
         }
 
         return false ;
     }
}
NodeBaseEditor.cs
     private void OnGUI ()
     {
         DrawNodes ();
 
         ProcessNodeEvents ( Event . current );
         ProcessEvents ( Event . current );
 
         if ( GUI . changed ) Repaint ();
     }
 
     private void DrawNodes ()
     {
         if ( nodes != null )
         {
             for ( int i = 0 ; i < nodes . Count ; i ++ )
             {
                 nodes [ i ]. Draw ();
             }
         }
     }
 
     private void ProcessEvents ( Event e )
     {
         switch ( e . type )
         {
             case EventType . MouseDown :
                 if ( e . button == 1 )
                 {
                     ProcessContextMenu ( e . mousePosition );
                 }
                 break ;
         }
     }
 
     private void ProcessNodeEvents ( Event e )
     {
         if ( nodes != null )
         {
             for ( int i = nodes . Count - 1 ; i >= 0 ; i -- )
             {
                 bool guiChanged = nodes [ i ]. ProcessEvents ( e );
 
                 if ( guiChanged )
                 {
                     GUI . changed = true ;
                 }
             }
         }
     }
     private void ProcessContextMenu ( Vector2 mousePosition )
     {
         GenericMenu genericMenu = new GenericMenu ();
         genericMenu . AddItem ( new GUIContent ( "Add node" ), false , () => OnClickAddNode ( mousePosition ));
         genericMenu . ShowAsContext ();
     }

创建节点之间的连接
我们的节点编辑器现在有节点，但我们也应该能够连接它们。为了做到这一点，我们需要一个节点上的两个连接点（in和out）以及它们之间的连接。一个连接点有一个矩形（以便我们可以绘制它），有一个类型（in或out），有一个样式并引用它的父节点。因此，我们的 ConnectionPoint  类将是一个非常简单的类。在特定位置绘制按钮并在点击该按钮时执行操作。

另一方面，连接有两个连接点和一个动作来删除它。 Connection类比 ConnectionPoint简单得多，但它引入了一个新概念： Handles。该类实际上用于在场景视图中绘制3D GUI控件，但它是唯一具有贝塞尔绘图方法的类： Handles.DrawBezier(Vector3, Vector3, Vector3, Vector3, Color, Texture2D, float).  。它需要7个参数，前4个参数是位置控制（起始位置，结束位置，起始切线和终止切线），而其余的则决定贝塞尔的外观。 （ 这个就太方便了， 不需要引入第三方插件或者自己写了）
ConnectionPoint.cs
using System ;
using UnityEngine ;
 
public enum ConnectionPointType { In , Out }
 
public class ConnectionPoint
{
     public Rect rect ;
 
     public ConnectionPointType type ;
 
     public Node node ;
 
     public GUIStyle style ;
 
     public Action < ConnectionPoint > OnClickConnectionPoint ;
    
     public ConnectionPoint ( Node node , ConnectionPointType type , GUIStyle style , Action < ConnectionPoint > OnClickConnectionPoint )
     {
         this . node = node ;
         this . type = type ;
         this . style = style ;
         this . OnClickConnectionPoint = OnClickConnectionPoint ;
         rect = new Rect ( 0 , 0 , 10f , 20f );
     }
 
     public void Draw ()
     {
         rect . y = node . rect . y + ( node . rect . height * 0.5f ) - rect . height * 0.5f ;
 
         switch ( type )
         {
             case ConnectionPointType . In :
                 rect . x = node . rect . x - rect . width + 8f ;
                 break ;
 
             case ConnectionPointType . Out :
                 rect . x = node . rect . x + node . rect . width - 8f ;
                 break ;
         }
        
         if ( GUI . Button ( rect , "" , style ))
         {
             if ( OnClickConnectionPoint != null )
             {
                 OnClickConnectionPoint ( this );
             }
         }
     }
}
Connection.cs
using System ;
using UnityEditor ;
using UnityEngine ;
 
public class Connection
{
     public ConnectionPoint inPoint ;
     public ConnectionPoint outPoint ;
     public Action < Connection > OnClickRemoveConnection ;
 
     public Connection ( ConnectionPoint inPoint , ConnectionPoint outPoint , Action < Connection > OnClickRemoveConnection )
     {
         this . inPoint = inPoint ;
         this . outPoint = outPoint ;
         this . OnClickRemoveConnection = OnClickRemoveConnection ;
     }
 
     public void Draw ()
     {
         Handles . DrawBezier (
             inPoint . rect . center ,
             outPoint . rect . center ,
             inPoint . rect . center + Vector2 . left * 50f ,
             outPoint . rect . center - Vector2 . left * 50f ,
             Color . white ,
             null ,
             2f
         );
 
         if ( Handles . Button (( inPoint . rect . center + outPoint . rect . center ) * 0.5f , Quaternion . identity , 4 , 8 , Handles . RectangleCap ))
         {
             if ( OnClickRemoveConnection != null )
             {
                 OnClickRemoveConnection ( this );
             }
         }
     }
}

绘图连接
由于 Connection  和 ConnectionPoint类已准备就绪，我们所要做的就是在Node类中绘制连接点并在NodeBasedEditor中绘制连接。 Node类中的更改将最小化; 我们将定义两个连接点，修改构造函数，以便我们可以传递样式和动作，并使用 Draw() 方法绘制它们。

但是， NodeBasedEditor   需要进行重大修改。首先，我们需要为连接点定义样式。你可以为它们两个使用单一的样式，但我希望它们看起来不同，所以我将为每个样式使用不同的样式。我们将在 OnEnable()  中初始化这些样式，就像我们初始化节点样式一样。

其次，我们需要跟踪点击的连接点，这样当用户选择一个进出时，我们应该在它们之间建立一个连接。这一步包括大部分增加：

  • OnClickInPoint(ConnectionPoint) 处理点击入点。
  • OnClickOutPoint(ConnectionPoint) 处理点击出点。
  • OnClickRemoveConnection(Connection) 处理单击连接上的删除按钮。
  • CreateConnection()  在选择入点和出点时创建连接。
  • ClearConnectionSelection()  清除选定的点。
最后，我们需要在   OnGUI()  中绘制连接，就像我们绘制节点一样。
using System ;
using UnityEditor ;
using UnityEngine ;
 
public class Node
{
     public Rect rect ;
     public string title ;
     public bool isDragged ;
 
     public ConnectionPoint inPoint ;
     public ConnectionPoint outPoint ;
 
     public GUIStyle style ;
 
     public Node ( Vector2 position , float width , float height , GUIStyle nodeStyle , GUIStyle inPointStyle , GUIStyle outPointStyle , Action < ConnectionPoint > OnClickInPoint , Action < ConnectionPoint > OnClickOutPoint )
     {
         rect = new Rect ( position . x , position . y , width , height );
         style = nodeStyle ;
         inPoint = new ConnectionPoint ( this , ConnectionPointType . In , inPointStyle , OnClickInPoint );
         outPoint = new ConnectionPoint ( this , ConnectionPointType . Out , outPointStyle , OnClickOutPoint );
     }
 
     public void Drag ( Vector2 delta )
     {
         rect . position += delta ;
     }
 
     public void Draw ()
     {
         inPoint . Draw ();
         outPoint . Draw ();
         GUI . Box ( rect , title , style );
     }
 
     public bool ProcessEvents ( Event e )
     {
         switch ( e . type )
         {
             case EventType . MouseDown :
                 if ( e . button == 0 )
                 {
                     if ( rect . Contains ( e . mousePosition ))
                     {
                         isDragged = true ;
                         GUI . changed = true ;
                     }
                     else
                     {
                         GUI . changed = true ;
                     }
                 }
                 break ;
 
             case EventType . MouseUp :
                 isDragged = false ;
                 break ;
 
             case EventType . MouseDrag :
                 if ( e . button == 0 && isDragged )
                 {
                     Drag ( e . delta );
                     e . Use ();
                     return true ;
                 }
                 break ;
         }
 
         return false ;
     }
}

using UnityEngine ;
using UnityEditor ;
using System . Collections . Generic ;
 
public class NodeBasedEditor : EditorWindow
{
     private List < Node > nodes ;
     private List < Connection > connections ;
 
     private GUIStyle nodeStyle ;
     private GUIStyle inPointStyle ;
     private GUIStyle outPointStyle ;
 
     private ConnectionPoint selectedInPoint ;
     private ConnectionPoint selectedOutPoint ;
 
     [ MenuItem ( "Window/Node Based Editor" )]
     private static void OpenWindow ()
     {
         NodeBasedEditor window = GetWindow < NodeBasedEditor > ();
         window . titleContent = new GUIContent ( "Node Based Editor" );
     }
 
     private void OnEnable ()
     {
         nodeStyle = new GUIStyle ();
         nodeStyle . normal . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/node1.png" ) as Texture2D ;
         nodeStyle . border = new RectOffset ( 12 , 12 , 12 , 12 );
         inPointStyle = new GUIStyle ();
         inPointStyle . normal . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/btn left.png" ) as Texture2D ;
         inPointStyle . active . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/btn left on.png" ) as Texture2D ;
         inPointStyle . border = new RectOffset ( 4 , 4 , 12 , 12 );
 
         outPointStyle = new GUIStyle ();
         outPointStyle . normal . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/btn right.png" ) as Texture2D ;
         outPointStyle . active . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/btn right on.png" ) as Texture2D ;
         outPointStyle . border = new RectOffset ( 4 , 4 , 12 , 12 );
     }
 
     private void OnGUI ()
     {
         DrawNodes ();
         DrawConnections ();
 
         ProcessNodeEvents ( Event . current );
         ProcessEvents ( Event . current );
 
         if ( GUI . changed ) Repaint ();
     }
 
     private void DrawNodes ()
     {
         if ( nodes != null )
         {
             for ( int i = 0 ; i < nodes . Count ; i ++ )
             {
                 nodes [ i ]. Draw ();
             }
         }
     }
 
     private void DrawConnections ()
     {
         if ( connections != null )
         {
             for ( int i = 0 ; i < connections . Count ; i ++ )
             {
                 connections [ i ]. Draw ();
             }
         }
     }
 
     private void ProcessEvents ( Event e )
     {
         switch ( e . type )
         {
             case EventType . MouseDown :
                 if ( e . button == 0 )
                 {
                     ClearConnectionSelection ();
                 }
 
                 if ( e . button == 1 )
                 {
                     ProcessContextMenu ( e . mousePosition );
                 }
                 break ;
         }
     }
 
     private void ProcessNodeEvents ( Event e )
     {
         if ( nodes != null )
         {
             for ( int i = nodes . Count - 1 ; i >= 0 ; i -- )
             {
                 bool guiChanged = nodes [ i ]. ProcessEvents ( e );
 
                 if ( guiChanged )
                 {
                     GUI . changed = true ;
                 }
             }
         }
     }
     private void ProcessContextMenu ( Vector2 mousePosition )
     {
         GenericMenu genericMenu = new GenericMenu ();
         genericMenu . AddItem ( new GUIContent ( "Add node" ), false , () => OnClickAddNode ( mousePosition ));
         genericMenu . ShowAsContext ();
     }
 
     private void OnClickAddNode ( Vector2 mousePosition )
     {
         if ( nodes == null )
         {
             nodes = new List < Node > ();
         }
 
         nodes . Add ( new Node ( mousePosition , 200 , 50 , nodeStyle , inPointStyle , outPointStyle , OnClickInPoint , OnClickOutPoint ));
     }
 
     private void OnClickInPoint ( ConnectionPoint inPoint )
     {
         selectedInPoint = inPoint ;
 
         if ( selectedOutPoint != null )
         {
             if ( selectedOutPoint . node != selectedInPoint . node )
             {
                 CreateConnection ();
                 ClearConnectionSelection ();
             }
             else
             {
                 ClearConnectionSelection ();
             }
         }
     }
 
     private void OnClickOutPoint ( ConnectionPoint outPoint )
     {
         selectedOutPoint = outPoint ;
 
         if ( selectedInPoint != null )
         {
             if ( selectedOutPoint . node != selectedInPoint . node )
             {
                 CreateConnection ();
                 ClearConnectionSelection ();
             }
             else
             {
                 ClearConnectionSelection ();
             }
         }
     }
 
     private void OnClickRemoveConnection ( Connection connection )
     {
         connections . Remove ( connection );
     }
 
     private void CreateConnection ()
     {
         if ( connections == null )
         {
             connections = new List < Connection > ();
         }
 
         connections . Add ( new Connection ( selectedInPoint , selectedOutPoint , OnClickRemoveConnection ));
     }
 
     private void ClearConnectionSelection ()
     {
         selectedInPoint = null ;
         selectedOutPoint = null ;
     }
}


选择节点
当用户点击一个节点时，我们应该提供反馈，以便他们知道他们选择了哪个节点（或者是否有节点被选中）。 这在用户想要删除节点时很有用。

using System ;
using UnityEditor ;
using UnityEngine ;
 
public class Node
{
     public Rect rect ;
     public string title ;
     public bool isDragged ;
     public bool isSelected ;
 
     public ConnectionPoint inPoint ;
     public ConnectionPoint outPoint ;
 
     public GUIStyle style ;
     public GUIStyle defaultNodeStyle ;
     public GUIStyle selectedNodeStyle ;
 
     public Node ( Vector2 position , float width , float height , GUIStyle nodeStyle , GUIStyle selectedStyle , GUIStyle inPointStyle , GUIStyle outPointStyle , Action < ConnectionPoint > OnClickInPoint , Action < ConnectionPoint > OnClickOutPoint )
     {
         rect = new Rect ( position . x , position . y , width , height );
         style = nodeStyle ;
         inPoint = new ConnectionPoint ( this , ConnectionPointType . In , inPointStyle , OnClickInPoint );
         outPoint = new ConnectionPoint ( this , ConnectionPointType . Out , outPointStyle , OnClickOutPoint );
         defaultNodeStyle = nodeStyle ;
         selectedNodeStyle = selectedStyle ;
     }
 
     public void Drag ( Vector2 delta )
     {
         rect . position += delta ;
     }
 
     public void Draw ()
     {
         inPoint . Draw ();
         outPoint . Draw ();
         GUI . Box ( rect , title , style );
     }
 
     public bool ProcessEvents ( Event e )
     {
         switch ( e . type )
         {
             case EventType . MouseDown :
                 if ( e . button == 0 )
                 {
                     if ( rect . Contains ( e . mousePosition ))
                     {
                         isDragged = true ;
                         GUI . changed = true ;
                         isSelected = true ;
                         style = selectedNodeStyle ;
                     }
                     else
                     {
                         GUI . changed = true ;
                         isSelected = false ;
                         style = defaultNodeStyle ;
                     }
                 }
                 break ;
 
             case EventType . MouseUp :
                 isDragged = false ;
                 break ;
 
             case EventType . MouseDrag :
                 if ( e . button == 0 && isDragged )
                 {
                     Drag ( e . delta );
                     e . Use ();
                     return true ;
                 }
                 break ;
         }
 
         return false ;
     }
}

using UnityEngine ;
using UnityEditor ;
using System . Collections . Generic ;
 
public class NodeBasedEditor : EditorWindow
{
     private List < Node > nodes ;
     private List < Connection > connections ;
 
     private GUIStyle nodeStyle ;
     private GUIStyle selectedNodeStyle ;
     private GUIStyle inPointStyle ;
     private GUIStyle outPointStyle ;
 
     private ConnectionPoint selectedInPoint ;
     private ConnectionPoint selectedOutPoint ;
 
     [ MenuItem ( "Window/Node Based Editor" )]
     private static void OpenWindow ()
     {
         NodeBasedEditor window = GetWindow < NodeBasedEditor > ();
         window . titleContent = new GUIContent ( "Node Based Editor" );
     }
 
     private void OnEnable ()
     {
         nodeStyle = new GUIStyle ();
         nodeStyle . normal . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/node1.png" ) as Texture2D ;
         nodeStyle . border = new RectOffset ( 12 , 12 , 12 , 12 );
 
         selectedNodeStyle = new GUIStyle ();
         selectedNodeStyle . normal . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/node1 on.png" ) as Texture2D ;
         selectedNodeStyle . border = new RectOffset ( 12 , 12 , 12 , 12 );
 
         inPointStyle = new GUIStyle ();
         inPointStyle . normal . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/btn left.png" ) as Texture2D ;
         inPointStyle . active . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/btn left on.png" ) as Texture2D ;
         inPointStyle . border = new RectOffset ( 4 , 4 , 12 , 12 );
 
         outPointStyle = new GUIStyle ();
         outPointStyle . normal . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/btn right.png" ) as Texture2D ;
         outPointStyle . active . background = EditorGUIUtility . Load ( "builtin skins/darkskin/images/btn right on.png" ) as Texture2D ;
         outPointStyle . border = new RectOffset ( 4 , 4 , 12 , 12 );
     }
 
     ...
NodeBasedEditor.cs

     private void OnClickAddNode ( Vector2 mousePosition )
     {
         if ( nodes == null )
         {
             nodes = new List < Node > ();
         }
 
         nodes . Add ( new Node ( mousePosition , 200 , 50 , nodeStyle , selectedNodeStyle , inPointStyle , outPointStyle , OnClickInPoint , OnClickOutPoint ));
     }

删除节点
一些节点编辑喜欢将节点按钮放在节点本身上，但在我们的情况下，这可能是危险的：用户可能会意外地删除节点。 所以，我们要做下一件最好的事情：将该按钮放在上下文菜单上。 用户应该首先选择节点，然后右键单击它以访问删除节点按钮。 当用户点击删除节点时，我们将从节点列表中删除该节点。 但是，该节点可能会连接到其他节点，所以我们应该首先删除这些连接。

using System ;
using UnityEditor ;
using UnityEngine ;
 
public class Node
{
     public Rect rect ;
     public string title ;
     public bool isDragged ;
     public bool isSelected ;
 
     public ConnectionPoint inPoint ;
     public ConnectionPoint outPoint ;
 
     public GUIStyle style ;
     public GUIStyle defaultNodeStyle ;
     public GUIStyle selectedNodeStyle ;
 
     public Action < Node > OnRemoveNode ;
 
     public Node ( Vector2 position , float width , float height , GUIStyle nodeStyle , GUIStyle selectedStyle , GUIStyle inPointStyle , GUIStyle outPointStyle , Action < ConnectionPoint > OnClickInPoint , Action < ConnectionPoint > OnClickOutPoint , Action < Node > OnClickRemoveNode )
     {
         rect = new Rect ( position . x , position . y , width , height );
         style = nodeStyle ;
         inPoint = new ConnectionPoint ( this , ConnectionPointType . In , inPointStyle , OnClickInPoint );
         outPoint = new ConnectionPoint ( this , ConnectionPointType . Out , outPointStyle , OnClickOutPoint );
         defaultNodeStyle = nodeStyle ;
         selectedNodeStyle = selectedStyle ;
         OnRemoveNode = OnClickRemoveNode ;
     }
 
     public void Drag ( Vector2 delta )
     {
         rect . position += delta ;
     }
 
     public void Draw ()
     {
         inPoint . Draw ();
         outPoint . Draw ();
         GUI . Box ( rect , title , style );
     }
 
     public bool ProcessEvents ( Event e )
     {
         switch ( e . type )
         {
             case EventType . MouseDown :
                 if ( e . button == 0 )
                 {
                     if ( rect . Contains ( e . mousePosition ))
                     {
                         isDragged = true ;
                         GUI . changed = true ;
                         isSelected = true ;
                         style = selectedNodeStyle ;
                     }
                     else
                     {
                         GUI . changed = true ;
                         isSelected = false ;
                         style = defaultNodeStyle ;
                     }
                 }
 
                 if ( e . button == 1 && isSelected && rect . Contains ( e . mousePosition ))
                 {
                     ProcessContextMenu ();
                     e . Use ();
                 }
                 break ;
 
             case EventType . MouseUp :
                 isDragged = false ;
                 break ;
 
             case EventType . MouseDrag :
                 if ( e . button == 0 && isDragged )
                 {
                     Drag ( e . delta );
                     e . Use ();
                     return true ;
                 }
                 break ;
         }
 
         return false ;
     }
 
     private void ProcessContextMenu ()
     {
         GenericMenu genericMenu = new GenericMenu ();
         genericMenu . AddItem ( new GUIContent ( "Remove node" ), false , OnClickRemoveNode );
         genericMenu . ShowAsContext ();
     }
 
     private void OnClickRemoveNode ()
     {
         if ( OnRemoveNode != null )
         {
             OnRemoveNode ( this );
         }
     }
}
NodeBasedEditor.cs
     private void OnClickAddNode ( Vector2 mousePosition )
     {
         if ( nodes == null )
         {
             nodes = new List < Node > ();
         }
 
         nodes . Add ( new Node ( mousePosition , 200 , 50 , nodeStyle , selectedNodeStyle , inPointStyle , outPointStyle , OnClickInPoint , OnClickOutPoint , OnClickRemoveNode ));
     }


     private void OnClickRemoveNode ( Node node )
     {
         if ( connections != null )
         {
             List < Connection > connectionsToRemove = new List < Connection > ();
 
             for ( int i = 0 ; i < connections . Count ; i ++ )
             {
                 if ( connections [ i ]. inPoint == node . inPoint || connections [ i ]. outPoint == node . outPoint )
                 {
                     connectionsToRemove . Add ( connections [ i ]);
                 }
             }
 
             for ( int i = 0 ; i < connectionsToRemove . Count ; i ++ )
             {
                 connections . Remove ( connectionsToRemove [ i ]);
             }
 
             connectionsToRemove = null ;
         }
 
         nodes . Remove ( node );
     }

最后的接触
节点编辑器在这一点上是完整的，但它缺少一些可以提升用户体验的重要功能：

  • 可拖动的画布，
  • 从所选连接点到鼠标位置的贝塞尔曲线，
  • 背景中的网格。
  • 让我们的画布可以拖动是最简单的，所以让我们从这个开始。 我们所要做的只是将鼠标拖放到节点列表中的每个节点。

NodeBasedEditor.cs
public class NodeBasedEditor : EditorWindow
{
     private List < Node > nodes ;
     private List < Connection > connections ;
 
     private GUIStyle nodeStyle ;
     private GUIStyle selectedNodeStyle ;
     private GUIStyle inPointStyle ;
     private GUIStyle outPointStyle ;
 
     private ConnectionPoint selectedInPoint ;
     private ConnectionPoint selectedOutPoint ;
    
     private Vector2 drag ;
 
     ...

     private void ProcessEvents ( Event e )
     {
         drag = Vector2 . zero ;
 
         switch ( e . type )
         {
             case EventType . MouseDown :
                 if ( e . button == 0 )
                 {
                     ClearConnectionSelection ();
                 }
 
                 if ( e . button == 1 )
                 {
                     ProcessContextMenu ( e . mousePosition );
                 }
             break ;
 
             case EventType . MouseDrag :
                 if ( e . button == 0 )
                 {
                     OnDrag ( e . delta );
                 }
             break ;
         }
     }

     private void OnDrag ( Vector2 delta )
     {
         drag = delta ;
 
         if ( nodes != null )
         {
             for ( int i = 0 ; i < nodes . Count ; i ++ )
             {
                 nodes [ i ]. Drag ( delta );
             }
         }
 
         GUI . changed = true ;
     }
接下来，从所选连接点绘制贝塞尔到鼠标位置。 通过绘制这个贝塞尔曲线，我们将让用户知道选择了哪个连接点以及它们的连接将如何。
NodeBasedEditor.cs
     private void OnGUI ()
     {
         DrawNodes ();
         DrawConnections ();
 
         DrawConnectionLine ( Event . current );
 
         ProcessNodeEvents ( Event . current );
         ProcessEvents ( Event . current );
 
         if ( GUI . changed ) Repaint ();
     }

     private void DrawConnectionLine ( Event e )
     {
         if ( selectedInPoint != null && selectedOutPoint == null )
         {
             Handles . DrawBezier (
                 selectedInPoint . rect . center ,
                 e . mousePosition ,
                 selectedInPoint . rect . center + Vector2 . left * 50f ,
                 e . mousePosition - Vector2 . left * 50f ,
                 Color . white ,
                 null ,
                 2f
             );
 
             GUI . changed = true ;
         }
 
         if ( selectedOutPoint != null && selectedInPoint == null )
         {
             Handles . DrawBezier (
                 selectedOutPoint . rect . center ,
                 e . mousePosition ,
                 selectedOutPoint . rect . center - Vector2 . left * 50f ,
                 e . mousePosition + Vector2 . left * 50f ,
                 Color . white ,
                 null ,
                 2f
             );
 
             GUI . changed = true ;
         }
     }

最后，绘制网格：
public class NodeBasedEditor : EditorWindow
{
     private List < Node > nodes ;
     private List < Connection > connections ;
 
     private GUIStyle nodeStyle ;
     private GUIStyle selectedNodeStyle ;
     private GUIStyle inPointStyle ;
     private GUIStyle outPointStyle ;
 
     private ConnectionPoint selectedInPoint ;
     private ConnectionPoint selectedOutPoint ;
 
     private Vector2 offset ;
     private Vector2 drag ;
 
     ...

     private void OnGUI ()
     {
         DrawGrid ( 20 , 0.2f , Color . gray );
         DrawGrid ( 100 , 0.4f , Color . gray );
 
         DrawNodes ();
         DrawConnections ();
 
         DrawConnectionLine ( Event . current );
 
         ProcessNodeEvents ( Event . current );
         ProcessEvents ( Event . current );
 
         if ( GUI . changed ) Repaint ();
     }
 
     private void DrawGrid ( float gridSpacing , float gridOpacity , Color gridColor )
     {
         int widthDivs = Mathf . CeilToInt ( position . width / gridSpacing );
         int heightDivs = Mathf . CeilToInt ( position . height / gridSpacing );
 
         Handles . BeginGUI ();
         Handles . color = new Color ( gridColor . r , gridColor . g , gridColor . b , gridOpacity );
 
         offset += drag * 0.5f ;
         Vector3 newOffset = new Vector3 ( offset . x % gridSpacing , offset . y % gridSpacing , 0 );
 
         for ( int i = 0 ; i < widthDivs ; i ++ )
         {
             Handles . DrawLine ( new Vector3 ( gridSpacing * i , - gridSpacing , 0 ) + newOffset , new Vector3 ( gridSpacing * i , position . height , 0f ) + newOffset );
         }
 
         for ( int j = 0 ; j < heightDivs ; j ++ )
         {
             Handles . DrawLine ( new Vector3 ( - gridSpacing , gridSpacing * j , 0 ) + newOffset , new Vector3 ( position . width , gridSpacing * j , 0f ) + newOffset );
         }
 
         Handles . color = Color . white ;
         Handles . EndGUI ();
     }

结论
结束。 您可以开发它并创建自己的自定义节点编辑器。 这是我在制作原型时编写的任务编辑器：
在Unity中创建基于Node节点的编辑器 （一）_第2张图片
和往常一样，下面是完整的脚本。 直到下一次。
using UnityEngine;
using UnityEditor;
using System.Collections.Generic;

public class NodeBasedEditor : EditorWindow
{
private List nodes;
private List connections;

private GUIStyle nodeStyle;
private GUIStyle selectedNodeStyle;
private GUIStyle inPointStyle;
private GUIStyle outPointStyle;

private ConnectionPoint selectedInPoint;
private ConnectionPoint selectedOutPoint;

private Vector2 offset;
private Vector2 drag;

[MenuItem("Window/Node Based Editor")]
private static void OpenWindow()
{
NodeBasedEditor window = GetWindow();
window.titleContent = new GUIContent("Node Based Editor");
}

private void OnEnable()
{
nodeStyle = new GUIStyle();
nodeStyle.normal.background = EditorGUIUtility.Load("builtin skins/darkskin/images/node1.png") as Texture2D;
nodeStyle.border = new RectOffset(12, 12, 12, 12);

selectedNodeStyle = new GUIStyle();
selectedNodeStyle.normal.background = EditorGUIUtility.Load("builtin skins/darkskin/images/node1 on.png") as Texture2D;
selectedNodeStyle.border = new RectOffset(12, 12, 12, 12);

inPointStyle = new GUIStyle();
inPointStyle.normal.background = EditorGUIUtility.Load("builtin skins/darkskin/images/btn left.png") as Texture2D;
inPointStyle.active.background = EditorGUIUtility.Load("builtin skins/darkskin/images/btn left on.png") as Texture2D;
inPointStyle.border = new RectOffset(4, 4, 12, 12);

outPointStyle = new GUIStyle();
outPointStyle.normal.background = EditorGUIUtility.Load("builtin skins/darkskin/images/btn right.png") as Texture2D;
outPointStyle.active.background = EditorGUIUtility.Load("builtin skins/darkskin/images/btn right on.png") as Texture2D;
outPointStyle.border = new RectOffset(4, 4, 12, 12);
}

private void OnGUI()
{
DrawGrid(20, 0.2f, Color.gray);
DrawGrid(100, 0.4f, Color.gray);

DrawNodes();
DrawConnections();

DrawConnectionLine(Event.current);

ProcessNodeEvents(Event.current);
ProcessEvents(Event.current);

if (GUI.changed) Repaint();
}

private void DrawGrid(float gridSpacing, float gridOpacity, Color gridColor)
{
int widthDivs = Mathf.CeilToInt(position.width / gridSpacing);
int heightDivs = Mathf.CeilToInt(position.height / gridSpacing);

Handles.BeginGUI();
Handles.color = new Color(gridColor.r, gridColor.g, gridColor.b, gridOpacity);

offset += drag * 0.5f;
Vector3 newOffset = new Vector3(offset.x % gridSpacing, offset.y % gridSpacing, 0);

for (int i = 0; i < widthDivs; i++)
{
Handles.DrawLine(new Vector3(gridSpacing * i, -gridSpacing, 0) + newOffset, new Vector3(gridSpacing * i, position.height, 0f) + newOffset);
}

for (int j = 0; j < heightDivs; j++)
{
Handles.DrawLine(new Vector3(-gridSpacing, gridSpacing * j, 0) + newOffset, new Vector3(position.width, gridSpacing * j, 0f) + newOffset);
}

Handles.color = Color.white;
Handles.EndGUI();
}

private void DrawNodes()
{
if (nodes != null)
{
for (int i = 0; i < nodes.Count; i++)
{
nodes[i].Draw();
}
}
}

private void DrawConnections()
{
if (connections != null)
{
for (int i = 0; i < connections.Count; i++)
{
connections[i].Draw();
}
}
}

private void ProcessEvents(Event e)
{
drag = Vector2.zero;

switch (e.type)
{
case EventType.MouseDown:
if (e.button == 0)
{
ClearConnectionSelection();
}

if (e.button == 1)
{
ProcessContextMenu(e.mousePosition);
}
break;

case EventType.MouseDrag:
if (e.button == 0)
{
OnDrag(e.delta);
}
break;
}
}

private void ProcessNodeEvents(Event e)
{
if (nodes != null)
{
for (int i = nodes.Count - 1; i >= 0; i--)
{
bool guiChanged = nodes[i].ProcessEvents(e);

if (guiChanged)
{
GUI.changed = true;
}
}
}
}

private void DrawConnectionLine(Event e)
{
if (selectedInPoint != null && selectedOutPoint == null)
{
Handles.DrawBezier(
selectedInPoint.rect.center,
e.mousePosition,
selectedInPoint.rect.center + Vector2.left * 50f,
e.mousePosition - Vector2.left * 50f,
Color.white,
null,
2f
);

GUI.changed = true;
}

if (selectedOutPoint != null && selectedInPoint == null)
{
Handles.DrawBezier(
selectedOutPoint.rect.center,
e.mousePosition,
selectedOutPoint.rect.center - Vector2.left * 50f,
e.mousePosition + Vector2.left * 50f,
Color.white,
null,
2f
);

GUI.changed = true;
}
}

private void ProcessContextMenu(Vector2 mousePosition)
{
GenericMenu genericMenu = new GenericMenu();
genericMenu.AddItem(new GUIContent("Add node"), false, () => OnClickAddNode(mousePosition));
genericMenu.ShowAsContext();
}

private void OnDrag(Vector2 delta)
{
drag = delta;

if (nodes != null)
{
for (int i = 0; i < nodes.Count; i++)
{
nodes[i].Drag(delta);
}
}

GUI.changed = true;
}

private void OnClickAddNode(Vector2 mousePosition)
{
if (nodes == null)
{
nodes = new List();
}

nodes.Add(new Node(mousePosition, 200, 50, nodeStyle, selectedNodeStyle, inPointStyle, outPointStyle, OnClickInPoint, OnClickOutPoint, OnClickRemoveNode));
}

private void OnClickInPoint(ConnectionPoint inPoint)
{
selectedInPoint = inPoint;

if (selectedOutPoint != null)
{
if (selectedOutPoint.node != selectedInPoint.node)
{
CreateConnection();
ClearConnectionSelection();
}
else
{
ClearConnectionSelection();
}
}
}

private void OnClickOutPoint(ConnectionPoint outPoint)
{
selectedOutPoint = outPoint;

if (selectedInPoint != null)
{
if (selectedOutPoint.node != selectedInPoint.node)
{
CreateConnection();
ClearConnectionSelection();
}
else
{
ClearConnectionSelection();
}
}
}

private void OnClickRemoveNode(Node node)
{
if (connections != null)
{
List connectionsToRemove = new List();

for (int i = 0; i < connections.Count; i++)
{
if (connections[i].inPoint == node.inPoint || connections[i].outPoint == node.outPoint)
{
connectionsToRemove.Add(connections[i]);
}
}

for (int i = 0; i < connectionsToRemove.Count; i++)
{
connections.Remove(connectionsToRemove[i]);
}

connectionsToRemove = null;
}

nodes.Remove(node);
}

private void OnClickRemoveConnection(Connection connection)
{
connections.Remove(connection);
}

private void CreateConnection()
{
if (connections == null)
{
connections = new List();
}

connections.Add(new Connection(selectedInPoint, selectedOutPoint, OnClickRemoveConnection));
}

private void ClearConnectionSelection()
{
selectedInPoint = null;
selectedOutPoint = null;
}
}

using System;
using UnityEditor;
using UnityEngine;

public class Node
{
public Rect rect;
public string title;
public bool isDragged;
public bool isSelected;

public ConnectionPoint inPoint;
public ConnectionPoint outPoint;

public GUIStyle style;
public GUIStyle defaultNodeStyle;
public GUIStyle selectedNodeStyle;

public Action OnRemoveNode;

public Node(Vector2 position, float width, float height, GUIStyle nodeStyle, GUIStyle selectedStyle, GUIStyle inPointStyle, GUIStyle outPointStyle, Action OnClickInPoint, Action OnClickOutPoint, Action OnClickRemoveNode)
{
rect = new Rect(position.x, position.y, width, height);
style = nodeStyle;
inPoint = new ConnectionPoint(this, ConnectionPointType.In, inPointStyle, OnClickInPoint);
outPoint = new ConnectionPoint(this, ConnectionPointType.Out, outPointStyle, OnClickOutPoint);
defaultNodeStyle = nodeStyle;
selectedNodeStyle = selectedStyle;
OnRemoveNode = OnClickRemoveNode;
}

public void Drag(Vector2 delta)
{
rect.position += delta;
}

public void Draw()
{
inPoint.Draw();
outPoint.Draw();
GUI.Box(rect, title, style);
}

public bool ProcessEvents(Event e)
{
switch (e.type)
{
case EventType.MouseDown:
if (e.button == 0)
{
if (rect.Contains(e.mousePosition))
{
isDragged = true;
GUI.changed = true;
isSelected = true;
style = selectedNodeStyle;
}
else
{
GUI.changed = true;
isSelected = false;
style = defaultNodeStyle;
}
}

if (e.button == 1 && isSelected && rect.Contains(e.mousePosition))
{
ProcessContextMenu();
e.Use();
}
break;

case EventType.MouseUp:
isDragged = false;
break;

case EventType.MouseDrag:
if (e.button == 0 && isDragged)
{
Drag(e.delta);
e.Use();
return true;
}
break;
}

return false;
}

private void ProcessContextMenu()
{
GenericMenu genericMenu = new GenericMenu();
genericMenu.AddItem(new GUIContent("Remove node"), false, OnClickRemoveNode);
genericMenu.ShowAsContext();
}

private void OnClickRemoveNode()
{
if (OnRemoveNode != null)
{
OnRemoveNode(this);
}
}
}

using System;
using UnityEditor;
using UnityEngine;

public class Connection
{
public ConnectionPoint inPoint;
public ConnectionPoint outPoint;
public Action OnClickRemoveConnection;

public Connection(ConnectionPoint inPoint, ConnectionPoint outPoint, Action OnClickRemoveConnection)
{
this.inPoint = inPoint;
this.outPoint = outPoint;
this.OnClickRemoveConnection = OnClickRemoveConnection;
}

public void Draw()
{
Handles.DrawBezier(
inPoint.rect.center,
outPoint.rect.center,
inPoint.rect.center + Vector2.left * 50f,
outPoint.rect.center - Vector2.left * 50f,
Color.white,
null,
2f
);

if (Handles.Button((inPoint.rect.center + outPoint.rect.center) * 0.5f, Quaternion.identity, 4, 8, Handles.RectangleCap))
{
if (OnClickRemoveConnection != null)
{
OnClickRemoveConnection(this);
}
}
}
}

using System;
using UnityEngine;

public enum ConnectionPointType { In, Out }

public class ConnectionPoint
{
public Rect rect;

public ConnectionPointType type;

public Node node;

public GUIStyle style;

public Action OnClickConnectionPoint;

public ConnectionPoint(Node node, ConnectionPointType type, GUIStyle style, Action OnClickConnectionPoint)
{
this.node = node;
this.type = type;
this.style = style;
this.OnClickConnectionPoint = OnClickConnectionPoint;
rect = new Rect(0, 0, 10f, 20f);
}

public void Draw()
{
rect.y = node.rect.y + (node.rect.height * 0.5f) - rect.height * 0.5f;

switch (type)
{
case ConnectionPointType.In:
rect.x = node.rect.x - rect.width + 8f;
break;

case ConnectionPointType.Out:
rect.x = node.rect.x + node.rect.width - 8f;
break;
}

if (GUI.Button(rect, "", style))
{
if (OnClickConnectionPoint != null)
{
OnClickConnectionPoint(this);
}
}
}
}

你可能感兴趣的:(unity3d,Editor私人定制)

  • Solon Cloud Gateway 开发：Route 的匹配检测器及定制 组合缺一 SolonJavaFrameworkgatewaysolonjavareactor
    RoutePredicateFactory是一组专为路由匹配检测设计的接口，以完成匹配检测处理。对应predicates配置。1、内置的匹配检测器匹配检测器工厂本置前缀说明与示例AfterPredicateFactoryAfter=After时间检测器，ZonedDateTime格式(After=2017-01-20T17:42:47.789-07:00[America/Denver])Befor
  • 本地部署 DeepSeek-R1 大模型 网络安全我来了 人工智能AI人工智能
    本地部署DeepSeek-R1大模型指南1.引言1.1DeepSeek-R1模型简介在人工智能的世界里，大型语言模型（LLM）正如一座巨大的宝库，里面储存着丰富的信息和无限的潜力。而DeepSeek-R1，就像那扇打开智慧之门的钥匙。它是一款专注于数学、代码和自然语言推理任务的高性能AI推理模型。许多用户希望能在本地环境中自由操作这些强大的模型，因为这不仅关乎数据隐私，还能满足定制化部署的需求。这
  • Mybatis（Day 18） m0_73629914 数据库
    数据持久化是将内存中的数据模型转换为存储模型，以及将存储模型转换为内存中数据模型的统称。MyBatis支持定制化SQL、存储过程以及高级映射，可以在实体类和SQL语句之间建立映射关系，是一种半自动化的ORM实现。ORM（ObjectRelationalMapping，对象关系映射）是一种数据持久化技术，它在对象模型和关系型数据库之间建立起对应关系，并且提供了一种机制，通过JavaBean对象去操作
  • Python 开发者：如何养成良好编码习惯？ 很酷的站长 Pythonpython开发语言
    当你已经是一名Python开发人员时，可能养成了一些习惯：有好的，也有坏的。编码本质是一种艺术形式。我们鼓励灵活性与可定制性。我们可以在编程语言的上下文中按照自己想要的方式编码。而现在需要面对的问题是，实际你正在公开与计算机通信，因此需要以一种其他人可以理解的方式编写代码。另外，使用不正确的语法或没有有效编写代码也会导致编程错误。混乱的代码使得以后很难发现这些错误。而可读、整洁的编码才是王道，这意
  • 屏幕色温护眼调节工具：Iris for mac 2301_82122052 macos
    Irismac版是Macos上一款屏幕色温护眼调节工具，会将您的屏幕亮度与您周围的光线相匹配。能够减少屏幕发出的蓝光量，调整k指，在高度工作的同时Irismac下载能够为您提供眼睛视力保护去选择不同的模式来提升整体的工作效率，打开Iris护眼软件能够选择适合你的屏幕颜色从而让疲劳感降低,你的睡眠质量即可轻松得到改善,多样化的参数定制即可快乐工作。小编提供Irismac版本下载资源，有需要的朋友们不
  • unity3d tilemap hewei+ unity3d
    2019的unity3d需要进入packageManager添加tilemap。不然找不到tilepalette瓦片碰撞器compositecollider2d是将多个碰撞器融合提高性能的。自动添加的刚体改成static，勾选tilemapcollider2d的usedBycomposite不添加碰撞器的瓦片设置为none;图片有间隙。改为能被图片像素除断的值，也不能太小
  • UE(UltraEdit) 配置简易C/C++编译运行环境 怜渠客 Windows开发技巧c++ACM
    该类型其他帖子EmEditor配置简易C/C++编译运行环境_emeditor代码运行-CSDN博客RJTextEd配置简易C/C++编译运行环境-CSDN博客这种配置适合ACM竞赛，即要求不使用现代IDE，又想用一个比较好用、至少支持代码高亮的编辑器。前提条件1.MingwGCC已经按照且配置环境变量2.UltraEdit已安装配置1、选择配置工具2、插入3、填写参数，如图4、配置运行我们一共要
  • FPGA实现带阻滤波器：代码与技术要点详解 weixin_42601702
    本文还有配套的精品资源，点击获取简介：在电子工程领域，FPGA技术被广泛应用于数字信号处理中，能够实现高度定制化和高效的带阻滤波器。本资料将通过实例代码深入讲解带阻滤波器在FPGA上的设计与实现，涵盖滤波器结构、设计、系数计算、编程语言选择、IP核封装、时序优化、仿真验证和硬件调试等多个关键知识点。1.FPGA与数字信号处理数字信号处理(DSP)是现代通信和电子系统的核心，而现场可编程门阵列(FP
  • 智能码二维码的成本效益分析 zhongtianhulian 软件工程
    以下是智能码二维码的成本效益分析：成本方面硬件成本标签成本：二维码标签本身价格低廉，即使进行大规模应用，成本也相对较低。如在智能仓储中，塑料托盘加二维码方案的标签成本几乎可以忽略不计4。扫描设备成本：扫描设备种类繁多，从智能手机到专业扫描枪，价格差异大，可根据实际需求灵活选择。如果企业已有智能手机等设备，仅需配备少量专业扫描枪，硬件投入成本不高1。软件成本开发成本：若企业需要定制与二维码相关的管理
  • vim的介绍 silver687 vim
    Vim简介Vim（全称ViIMproved）是一款功能强大的文本编辑器，最初由BramMoolenaar在1991年基于Vi编辑器开发而成。它是一款开源软件，广泛应用于各种操作系统（如Linux、Unix、Windows等），尤其在程序员和系统管理员中非常受欢迎。1.主要特点•高度可定制化：Vim支持通过配置文件（.vimrc）和插件来扩展功能，用户可以根据自己的需求调整编辑器的行为。•多模式编辑
  • 最全的ADB命令合集 启航风起时 安卓adblinux命令Android
    ADB命令大全转载于此GitHub仓库。注：有部分命令的支持情况可能与Android系统版本及定制ROM的实现有关。基本用法命令语法为命令指定目标设备启动/停止查看adb版本以root权限运行adbd指定adbserver的网络端口设备连接管理查询已连接设备/模拟器USB连接无线连接（需要借助USB线）无线连接（无需借助USB线）应用管理查看应用列表所有应用系统应用第三方应用包名包含某字符串的应用
  • SAP S/4HANA Public Cloud 的 Development Tenant 深度解析 汪子熙 ABAP百科全书运维sapabapNetWeaver
    SAPS/4HANAPublicCloud是SAP在云时代推出的SaaS（SoftwareasaService）版本，旨在提供高效、灵活、可扩展的企业管理解决方案。其中，DevelopmentTenant（开发租户）是其扩展和定制的重要组成部分。本文将从概念、技术架构、应用场景、开发方式等方面深入解析SAPS/4HANAPublicCloud的DevelopmentTenant，帮助读者全面理解其
  • 鸿蒙OpenHarmony【创建应用静态快捷方式】 场景开发 郁闷的黄米鸡 hmharmonyos华为鸿蒙鸿蒙系统
    静态快捷方式是一种在系统中创建的可以快速访问应用程序或特定功能的链接。它通常可以在长按应用图标，以图标和相应的文字出现在应用图标的上方，用户可以迅速启动对应应用程序的组件。使用快捷方式，可以提高效率，节省了查找和打开对应的组件时间；也可以实现个性化定制的需求，创建多个快捷方式，以满足个性化的工作流程和操作偏好。应用配置静态快捷方式，在桌面上展示的效果如下图：安装该应用后，在桌面上长按该应用图标，在
  • 如何使用Python快速建立一个http.server文件共享服务器并实现远程访问 秋说 内网穿透pythonhttp服务器
    文章目录前言1.本地文件服务器搭建1.1.Python的安装和设置1.2.cpolar的安装和注册2.本地文件服务器的发布2.1.Cpolar云端设置2.2.Cpolar本地设置3.公网访问测试4.结语前言本文主要介绍如何在Windows系统电脑上使用python这样的简单程序语言，在自己的电脑上搭建一个共享文件服务器，并通过cpolar创建的公网地址，打造一个可以随时随地远程访问的私人云盘。数据
  • UE5C++编译遇到MSB3073报错 爆米花煮鸡蛋 ue5c++ue4
    编译C++时遇到报错：错误MSB3073命令“"C:\ProgramFiles\EpicGames\UE_5.1\Engine\Build\BatchFiles\Build.bat"CSQFreewayEditorWin64Development-Project="D:\UE5_Project\SQGaoSu\CSQFreeway.uproject"-WaitMutex-FromMsBuild”已
  • Tailwind CSS - Tailwind CSS 引入（安装、初始化、配置、引入、构建、使用 Tailwind CSS） 我命由我12345 前端工程化css前端javascriptjsnode.jsnpm
    一、TailwindCSS概述TailwindCSS是一个功能优先的CSS框架，它提供了大量的实用类（utilityclasses），允许开发者通过组合这些类来快速构建用户界面TailwindCSS与传统的CSS框架不同（例如，Bootstrap），Tailwind不提供预定义的组件，而是通过细粒度的类来控制样式，从而实现高度定制化的设计二、TailwindCSS体验案例1、安装TailwindC
  • 原型模式、装饰者模式、建造者模式原理及实例 pox21s 原型模式建造者模式java装饰者模式设计模式
    原型模式基本介绍原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象实例原型模式是一种创建型设计模式，允许一个对象在创建另外一个可定制的对象时，无需知道如何创建的细节工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone()通过克隆的方式创建需要实现原型模式那么就要在
  • uniapp - [全端兼容] 实现精美Editor富文本编辑器功能，uniApp全平台兼容的富文本插件组件用户可上传图片及对接服务器存储文件等，手机移动端H5网页富文本/小程序富文本/App富文本！ 王二红 +UniAppuni-app富文本使用富文本编辑器插入图片图像uni-app微信小程序富文本uniapp网页h5端富文本uniap安卓苹果app富文本富文本上传图片及服务器保存
    前言网上的教程乱七八糟且兼容性太差，本文提供优质示例。在uni-app全平台兼容（H5网页网站、支付宝/微信小程序、安卓App、苹果App、nvue）开发中，详解引入使用富文本编辑器及图片上传显示等功能，用户可上传图片显示和服务器保存回显效果（插入图片），uniApp各平台都兼容的富文本editor插件，自定义富文本按钮功能及自由排版样式布局，uniapp富文本组件插件用于发布文章/发布资讯公告/
  • Python数据可视化 Pyecharts 制作 Sankey 桑基图 Mr数据杨 Python数据可视化python数据可视化pyecharts数据分析
    桑基图作为一种强大的数据可视化工具，常用于展现不同节点之间的流动关系及其数量分布。其通过直观的连线展示，帮助用户理解复杂系统中各个部分的连接和交互。Python的pyecharts库提供了Sankey类，支持用户灵活创建各种桑基图，不仅能够展示流动数据，还能根据节点层级及连线样式进行高度定制，使得桑基图在信息传达和视觉表现上更具表现力。文章目录Sankey：桑基图Demo总结Sankey：桑基图桑
  • Solon2 接口开发: 熟悉 Gateway 组合缺一 SolonJavaFrameworkgatewayjavasolon
    Gateway是Solon框架的特殊控制器（也是Handler的一个实现类）。它通过注册收集之后，在局部范围内提供：二级路由、拦截、过滤、融断、异常处理等功能，并统一到网关处理。另一个作用：可以为同一批接口安排多个网关，进而定制不同的协议效果。1、定义2个组件API_0@Component(tag="api")publicclassAPI_0{@MappingpublicResultexec(){
  • MyBatis技术详解与实战 小码快撩 mybatisjava开发语言
    引言MyBatis是一款优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集的工作，使开发者能更专注于对业务逻辑的实现。本文将详细介绍MyBatis的核心概念，并通过示例代码进行深入讲解。一、配置文件MyBatis配置文件（通常命名为mybatis-config.xml）是MyBatis框架的核心配置文件，它定义
  • 为Linux aarch64架构量身定制的JDK 8 Update 321：高效开发的首选 黄弛纯Nathania
    为Linuxaarch64架构量身定制的JDK8Update321：高效开发的首选【下载地址】JDK8Update321forLinuxaarch64下载仓库JDK8Update321forLinux(aarch64)下载仓库项目地址:https://gitcode.com/open-source-toolkit/0d9e1项目介绍在Linux操作系统上进行Java开发时，选择合适的JDK版本至关
  • Ollama 可以设置的环境变量 刘贤松 工具服务器运维
    在Ollama的世界里，环境变量如同神秘的符文，它们是控制和定制这个强大工具的关键。通过精心设置这些环境变量，我们可以让Ollama更好地适应我们的需求，就像调整一把精密的乐器，使其奏出最和谐的旋律。以下是一些可以设置的环境变量，它们将帮助我们驾驭Ollama，让它成为我们探索数据海洋的得力助手。Llama3.1是Meta（Facebook的母公司）发布的一系列最先进的开源大语言模型。Llama3
  • wangeditor的一些使用设置字体、字号、背景色等 米粒宝的爸爸 前端前端javascripthtml
    pc项目使用wangeditor的富文本，但是发现在设置：defaultConfig的时候，里面的MENU_CONF设置不起效果。然后设置defaultConfig里面的值editorConfig:{placeholder:'默认初始化值',backColor:'red',//背景颜色MENU_CONF:{colors:['#000','#333','#666'],fontSizeList:[{n
  • 【自己动手开发Webpack插件：开启前端构建工具的个性化定制之旅】 Orange301511 大前端前端webpacknode.jsjavascripttypescript
    在前端开发的世界里，Webpack无疑是构建工具中的“明星”。它强大的功能可以帮助我们高效地打包和管理前端资源。然而，有时候默认的Webpack功能可能无法完全满足我们的特定需求，这时候就需要自定义Webpack插件来大展身手啦！今天，我们就来一起探索如何开发自己的Webpack插件。一、什么是Webpack插件？Webpack插件就像是一个神奇的小助手，在Webpack打包的过程中，在特定的时刻
  • VMware ESXi 8.0U3c macOS Unlocker & OEM BIOS Dell (戴尔) 定制版 sysinside VMwareDellOEMESXimacOS
    VMwareESXi8.0U3cmacOSUnlocker&OEMBIOSDell(戴尔)定制版ESXi8.0U3c标准版，Dell(戴尔)、HPE(慧与)、Lenovo(联想)、Inspur(浪潮)、Cisco(思科)、Hitachi(日立)、Fujitsu(富士通)、NEC(日电)、Huawei(华为)、xFusion(超聚变)OEM定制版请访问原文链接：https://sysin.org/b
  • SQLAlchemy 使用(一)创建单一model dehaili6776 数据库运维python
    前言最近项目等待前端接接口,比较空闲.就想学习一些新东西.学啥呢?考虑到ORM的易用性,还是学习一下ORM.那么与Flask搭配的ORM有flask-sqlalchemy但是该组件专为Flask定制.如JWT与Flask-JWT,考虑到适用性,还是觉得学SQLAlchemy好一些.正文安装要想使用SQLAlchemy,首当其冲的当然是安装啦pipinstallsqlalchemy建立model文件
  • 使用R语言绘制日历热图 CyberXZ r语言开发语言R语言
    使用R语言绘制日历热图日历热图是一种可视化工具，用于显示时间序列数据的模式和趋势。这种图表通常使用颜色编码来表示数据值的大小，从而使我们能够快速识别出高值和低值。在R语言中，我们可以使用ggplot2包来创建漂亮且可定制化的日历热图。首先，确保已经安装了ggplot2包。如果没有安装，可以使用以下命令进行安装：install.packages("ggplot2")接下来，我们将使用一个示例数据集来
  • ＜sa8650＞sa8650 qcxserver-之-摄像头传感器VB56G4A驱动开发＜1＞ waterAdmin 驱动开发linuxxml车载系统视觉检测汽车
    ＜sa8650＞sa8650qcxserver-之-摄像头传感器VB56G4A驱动开发一、前言二、QCX架构三、QCX传感器驱动程序定制开发3.1sensor硬件接口3.2sensor配置文件3.2.1cameraconfig.c3.2.2cameraconfigsa8650_water.c3.2.3新增编译MK3.2.4参数解析3.2.4.1structCameraConfigI2CDevice
  • Vue进阶之Vue无代码可视化项目（六） VillanelleS TypeScriptVue3基础前端vue.js前端javascript
    Vue无代码可视化项目渲染引擎（渲染器）初版TextBlock.vueChartBlock.vueImageBlock.vueLayoutView.vue渲染器BlockRenderer.vueLayoutView.vue进一步typestypes/block.tsmock/blocks.tsstores/editor.tsblocks/BlockRenderer.vueviews/LayoutV
  • 集合框架 天子之骄 java数据结构集合框架
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • Table Driven（表驱动）方法实例 bijian1013 javaenumTable Driven表驱动
    实例一： /** * 驾驶人年龄段 * 保险行业，会对驾驶人的年龄做年龄段的区分判断 * 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞) */ public class AgePeriodTest { //if...el
  • Jquery 总结 cuishikuan javajqueryAjaxWebjquery方法
    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
  • 面向对象概念的提出 麦田的设计者 java面向对象面向过程
            面向对象中，一切都是由对象展开的，组织代码，封装数据。   在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。       下面就结合编程语言的发展史，聊一聊面向过程和面向对象。      c语言由贝尔实
  • linux网口绑定 被触发 linux
    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。 一、环境描述 我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。 二、双网卡绑定步骤： 2.1 修改/etc/sysconfig/network
  • XML基础语法 肆无忌惮_ xml
    一、什么是XML？ XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。   二、为什么学习XML？ 用来解决程序间数据传输的格式问题 做配置文件 充当小型数据库   三、XML与HTM
  • 为网页添加自己喜欢的字体 知了ing 字体 秒表 css
    @font-face { font-family: miaobiao;//定义字体名字 font-style: normal; font-weight: 400; src: url('font/DS-DIGI-e.eot');//字体文件 } 使用： <label style="font-size:18px;font-famil
  • redis范围查询应用-查找IP所在城市 矮蛋蛋 redis
    原文地址： http://www.tuicool.com/articles/BrURbqV 需求 根据IP找到对应的城市 原来的解决方案 oracle表（ip_country）： 查询IP对应的城市： 1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994 2. select city from ip_
  • 输入两个整数， 计算百分比 alleni123 java
    public static String getPercent(int x, int total){ double result=(x*1.0)/(total*1.0); System.out.println(result); DecimalFormat df1=new DecimalFormat("0.0000%");
  • 百合——————>怎么学习计算机语言 百合不是茶 java 移动开发
        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
  • linux下tomcat开机自启动 bijian1013 tomcat
    方法一： 修改Tomcat/bin/startup.sh 为: export JAVA_HOME=/home/java1.6.0_27 export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:. export PATH=$JAVA_HOME/bin:$PATH export CATALINA_H
  • spring aop实例 bijian1013 javaspringAOP
    1.AdviceMethods.java package com.bijian.study.spring.aop.schema; public class AdviceMethods { public void preGreeting() { System.out.println("--how are you!--"); } } 2.beans.x
  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization bit1129 serialization
    enableComplexMapKeySerialization配置项的含义  Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。   GsonBuilder用于
  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题 bit1129 Stream
    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别： 1. At most once，数据最多只能接受一次，有可能接收不到 2. At least once, 数据至少接受一次，有可能重复接收 3. Exactly once  数据保证被处理并且只被处理一次，   具体的多读几遍http://spark.apache.org/docs/lates
  • shell脚本批量检测端口是否被占用脚本 ronin47
    #!/bin/bash cat ports |while read line do#nc -z -w 10 $line nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then echo $line:ok else echo $line:fail fi done 这里的ports 既可以是文件
  • java-2.设计包含min函数的栈 bylijinnan java
    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/ import java.util.ArrayList; import java.util.List; public class MinStack { //maybe we can use origin array rathe
  • Netty源码学习-ChannelHandler bylijinnan javanetty
    一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享” 例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是 因为每一次调用decode方法时，可能数据未接收完全（incomplete）， 它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的 p
  • java生成随机数 cngolon java
    方法一： /** * 生成随机数 * @author [email protected] * @return */ public synchronized static String getChargeSequenceNum(String pre){ StringBuffer sequenceNum = new StringBuffer(); Date dateTime = new D
  • POI读写海量数据 ctrain 海量数据
    import java.io.FileOutputStream; import java.io.OutputStream; import org.apache.poi.xssf.streaming.SXSSFRow; import org.apache.poi.xssf.streaming.SXSSFSheet; import org.apache.poi.xssf.streaming
  • mysql 日期格式化date_format详细使用 daizj mysqldate_format日期格式转换日期格式化
    日期转换函数的详细使用说明  DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
  • 一个程序员分享8年的开发经验 dcj3sjt126com 程序员
      在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。 明确入行的目的 很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
  • android欢迎界面淡入淡出效果 dcj3sjt126com android
    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。 主要代码如下： package com.myaibang.activity; import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
  • linux 复习笔记之常见压缩命令 eksliang tar解压linux系统常见压缩命令linux压缩命令tar压缩
    转载请出自出处:http://eksliang.iteye.com/blog/2109693 linux中常见压缩文件的拓展名 *.gz gzip程序压缩的文件 *.bz2 bzip程序压缩的文件 *.tar tar程序打包的数据，没有经过压缩 *.tar.gz tar程序打包后，并经过gzip程序压缩 *.tar.bz2 tar程序打包后，并经过bzip程序压缩 *.zi
  • Android 应用程序发送shell命令 gqdy365 android
    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！ 发就发吧！ 一、关于shell指令： 我们知道，shell指令是Linux里面带的
  • java 无损读取文本文件 hw1287789687 读取文件无损读取读取文本文件charset
    java 如何无损读取文本文件呢？ 以下是有损的 @Deprecated public static String getFullContent(File file, String charset) { BufferedReader reader = null; if (!file.exists()) { System.out.println("getFull
  • Firebase 相关文章索引 justjavac firebase
    Awesome Firebase 最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。 Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。 开发者只需引用一个 API 库文件就可以使用标准 RE
  • C++学习重点 lx.asymmetric C++笔记
    1.c++面向对象的三个特性：封装性，继承性以及多态性。   2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。   3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。   4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。 &n
  • java bean和xml相互转换 q821424508 javabeanxmlxml和bean转换java bean和xml转换
    这几天在做微信公众号 做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 还是贴出来记录一下      顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。   packag
  • C 语言初级 位运算 1140566087 位运算c
    第十章 位运算   1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节   2、位运算符： 运算符 作用 ~ 按位求反 << 左移 >> 右移 & 按位与 ^ 按位异或 | 按位或 他们的优先级从高到低；   3、位运算符的运算功能： a、按位取反： ~01001101 = 101
  • 14点睛Spring4.1-脚本编程 wiselyman spring4
    14.1 Scripting脚本编程 脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行; 如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦; 如果我们的应用不允许重启,这在现实的情况中也是很常见的; 在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean; spring支持脚本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他