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私人定制)

  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记 爱吃丸子的小樱桃
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
  • (179)时序收敛---＞(29)时序收敛二九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛二九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • (180)时序收敛---＞(30)时序收敛三十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • (158)时序收敛---＞(08)时序收敛八 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛八（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (159)时序收敛---＞(09)时序收敛九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (160)时序收敛---＞(10)时序收敛十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (153)时序收敛---＞(03)时序收敛三 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (121)DAC接口---＞(006)基于FPGA实现DAC8811接口 FPGA系统设计指南针 FPGA接口开发(项目实战)fpga开发FPGAIC
    1目录（a）FPGA简介（b）IC简介（c）Verilog简介（d）基于FPGA实现DAC8811接口（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电
  • FPGA复位专题---（3）上电复位？ FPGA系统设计指南针 FPGA系统设计(内训)fpga开发
    （3）上电复位？1目录（a）FPGA简介（b）Verilog简介（c）复位简介（d）上电复位？（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限
  • (182)时序收敛---＞(32)时序收敛三二 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三二（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • 2024微信红包封面怎么领取免费的？（红包封面序列号获取方法） 帮忙赚赏金
    2024微信红包封面怎么领取免费的？（红包封面序列号获取方法）在中国，微信几乎成为了人们生活中不可或缺的一部分，而微信红包更是成为了人们表达祝福和送礼的一种形式。微信红包不仅方便快捷，还能够增添节日气氛和人与人之间的情感交流。然而，有时候我们想要定制一个特殊的微信红包封面，以更好地展现自己的个性和情感，但又担心定制费用过高。那么，如何才能免费获取2024微信红包封面的序列号呢？下面将为您详细介绍一
  • python实现规则引擎_规则引擎python weixin_39601511 python实现规则引擎
    广告关闭回望2020，你在技术之路上，有什么收获和成长么？对于未来，你有什么期待么？云+社区年度征文，各种定制好礼等你！我正在用python编写日志收集分析应用程序，我需要编写一个“规则引擎”来匹配和处理日志消息。它需要具有以下特点：正则表达式匹配消息本身消息严重性优先级的算术比较布尔运算符我设想一个例子规则可能是这样的：(message~program:messageandseverity>=h
  • 装修日记（三十七） huangluan
    因为没看到实际的颜色，也没有看到样式，老婆也没有参与，久久下不了单。周日下午三四点钟样子，老婆外甥女打来电话，让老婆和我去欧派看看，如果满意可以在欧派订，毕竟欧派是大品牌，品质还是有保障的。说她的朋友老颜比较过，欧派的实际价格可能比其他牌子贵点，但按照其阴影的计算面积，贵不了多少。殴派有两间专卖店，一间是底柜木饰定制，另外一间是厨房定制。我们先在海悦城店观摩，反复比较，老婆在她外甥女的参谋下定下客
  • 98_es生产集群部署之针对集群重启时的shard恢复耗时过长问题定制的重要参数 小山居
    98_es生产集群部署之针对集群重启时的shard恢复耗时过长问题定制的重要参数shardrecovery配置以及集群重启时的无意义shard重分配问题在集群重启的时候，有一些配置会影响shard恢复的过程。首先，我们需要理解默认配置下，shard恢复过程会发生什么事情。如果我们有10个node，每个node都有一个shard，可能是primaryshard或者replicashard，你有一个i
  • Shell脚本中sed使用 jcrhl321 linux
    目录一、sed编辑器1、sed概述2、sed的工作流程3、sed命令的常见格式4、sed命令常用操作二、sed常用命令使用1、sed打印2、sed删除3、sed替换4、sed插入与增加4、sed剪切粘贴与复制粘贴一、sed编辑器sed（StreamEDitor）是一个强大而简单的文本解析转换工具，可以读取文本，并根据指定的条件对文本内容进行编辑（删除、替换、添加、移动等），最后输出所有行或者仅输出
  • 【C语言】- 自定义类型：结构体、枚举、联合 Cavalier_01 C语言
    【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
  • h5小游戏定制开发 红匣子实力推荐
    随着科技的不断发展，移动互联网已经成为人们生活中不可或缺的一部分。在这个背景下，H5小游戏应运而生，为人们带来了丰富的娱乐体验。H5小游戏定制开发作为一种新兴的游戏开发方式，正逐渐受到市场的关注和青睐。那么，什么是H5小游戏定制开发呢？它又具有哪些特点和优势呢？让我们一起来深入了解一下。首先，我们来了解一下H5小游戏的基本概念。H5小游戏是一种基于HTML5技术的游戏，可以在移动端、PC端等多平台
  • 免费像素画绘制软件 | Pixelorama v1.0.3 dntktop 软件运维windows
    Pixelorama是一款开源像素艺术多工具软件，旨在为用户提供一个强大且易于使用的平台来创作各种像素艺术作品，包括精灵、瓷砖和动画。这款软件以其丰富的工具箱、动画支持、像素完美模式、剪裁遮罩、预制及可导入的调色板等特色功能，满足了像素艺术家们的各种需求。用户可以享受到动态工具映射、洋葱皮效果、帧标签、播放动画时绘制等高级功能，以及非破坏性的、完全可定制的图层效果，如轮廓、渐变映射、阴影和调色板化
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台 网顺技术团队 成品程序项目javavue.js汽车课程设计springboot
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
  • 使用游戏盾就可以保证游戏不被攻击吗？ 德迅云安全小李 游戏网络服务器安全网络安全
    游戏服务器不管是个人的还是企业的，被攻击都是，很常见的，在所难免的。特别是游戏新上线时，都要承受的住哪些外来压力，玩家突然猛增，被攻击等等。如果承受不住可能会直接宣布游戏倒闭。这里我们一起来说说怎么用游戏盾防御游戏服务器。首先我们要了解的一点是，什么是"游戏盾"游戏盾是针对游戏行业所推出的高度可定制的网络安全解决方案，除了能针对大型DDoS攻击（T级别）进行有效防御外，还能彻底解决游戏行业特有的T
  • 白嫖Gitee实现远程公告功能和小型文件上传下载 xu-jssy Python自动化脚本gitee
    备注：20240527更新：新增私人令牌下载模式一、准备工作1、打开Gitee网站：Gitee.comhttps://gitee.com/2、获取access_token，用于身份验证登录后点击右上角头像，在下拉菜单中进入个人主页点击左边的个人设置点击左边菜单中的安全设置->私人令牌点击右上角生成新令牌根据提示填写信息，点击提交在弹出的页面复制令牌，注意备份保存3、创建一个仓库用来存放文件可以把远
  • 华为云分布式缓存服务DCS与开源服务差异对比 hcinfo_18 redis使用华为云Redis5.0分布式缓存服务Redis客户端
    分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
  • linux open详解,Linux系统open函数详解 墨剑心 linuxopen详解
    Linux系统中open函数主要作用就是打开和创建文件，可以根据参数来定制我们需要的文件的属性和用户权限等各种参数，下面良许教程网为大家分享一下Linux系统open函数具体使用方法。一、open函数用来干什么open函数在Linux下一般用来打开或者创建一个文件，我们可以根据参数来定制我们需要的文件的属性和用户权限等各种参数。二、open函数的定义和参数我们首先来看下open函数在Linux下的
  • 又要长大一岁了 A媛媛_e2be
    30多岁的我，年龄有些大，还比较宅，作性质又比较特殊，基本接触不到那么多人。就是一个普通的不能再普通的平凡人。唯一觉得还算满意的就是有特别爱我的爸妈，还有一份不错的收入。其实我不知道自己是什么性格的人，有时候特别善谈，有时候又沉默寡言。单身的我经常希望找到一个爱我的男朋友，可是真的有人给我介绍的时候，一想到以后要是有了男朋友就会占用自己很多私人空间，就会拒绝朋友的好心介绍。总是在这样矛盾中生活着…
  • ROM修改进阶教程------如何修改固件 线刷转卡刷 卡刷转线刷 操作中的一些注意事项 安卓机器 ROM修改进阶教程卡刷转换线刷线刷转换卡刷固件转换
    在接待各种rom定制化服务中。有很多客户需要各种各样的需求。包括修改rom默认开启usb调试类默认开启开发者选项。修改不锁屏不休眠跳过开机引导以及一些内置app和可卸载app等等的定制项目。还有很多导出系统导出数据完整恢复类要求。今天给大家解析下如何将固件转换类的相关步骤解析通过博文可以了解;1--------线刷固件转换卡刷固件的注意事项以及步骤2--------卡刷固件转换线刷固件的注意事项以
  • [Unity 3d] VertexPaint （Mesh 顶点画手） - GitHub 雨落随风
    一个Mesh顶点动画绘制工具。GitHub上的工程多如繁星，有些好的仓库，但凡不经意间错过了就很难找回，故稍作采撷，希望能帮助到有心人。简介：笔者今天推荐的仓库叫VertexPaint。-顶点画手ThispackageallowsyoutopaintinformationontotheverticesofameshintheUnityeditoraswellasmodifyanyattribute
  • Unity3D多线程UI之ScrollYExtand 胡强_79a4
    先附上git地址https://github.com/huqiang0204/huqiang.UnitySubThreadUI示例代码请看ScrollExTestPage可以绑定三种模型，头部，尾部，和中间数据部分这里只用到了中间数据模型和头部模型Listdatas=newList();ScrollYExtand.DataTemplatetmp=newScrollYExtand.DataTempl
  • 普及高仿爱马仕女包哪里买,推荐最好的4个渠道 潮奢之家
    全网最低，质量最好，一手货源的原版，广州奢包汇是你的的选择。团队直接和工厂对接，原厂正品定制板开通，支持图纸咨询！主营各种原单:鞋、包、衣服、手表、首饰、皮带等类型的复制品拒绝看一眼，只做顶级品质的复制品！团队整合资源，对接大工厂原版定制开模未达95%不出货，可以任意对比，支持7天包退。经营承诺:同款同版，市面同版，品质同品。更多详情加薇信了解：88195525高仿爱马仕女包哪里买,推荐最好的4个
  • 座舱交互的下一个时代 高工智能汽车 交互物联网人工智能
    为了满足座舱信息娱乐的更高性能要求，几乎所有的一线品牌都在准备“换芯”。去年开始，不少车型开始推动传统的分布式座舱仪表和中控电子架构进入域控制器时代，高通成为大赢家。今年6月，特斯拉也正式官宣，即将推出的新款ModelS将配备能够运行PS5游戏机性能的AMD芯片，包括专门定制的AMDRyzenCPU和独立的Navi23图形处理器。最新消息，特斯拉将率先在中国市场生产的ModelY高性能版车型换装A
  • 集合框架 天子之骄 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其他