Visual Studio プロジェクトを開始できたので、セルの矩形グリッドを作成するカスタム ノードのビルド方法について説明します。矩形グリッドは複数の標準ノードを使用して作成できますが、このカスタム ノードは Zero-Touch ノードに簡単に含めることができる便利なツールです。通芯とは異なり、セルは、中心点を基点にスケールを変更したり、コーナーの頂点がクエリーされたり、面を構成することができます。

この例では、Zero-Touch ノードを作成する際に注意するべき機能と概念を紹介します。カスタム ノードをビルドして Dynamo に追加した後は、「Zero-Touch の詳細を確認する」ページの、「既定の入力値」、「複数の値を返す」、「ドキュメント」、「オブジェクト」、「Dynamo のジオメトリ タイプを使用する」、および「マイグレーション」セクションで詳細を確認してください。

カスタムの矩形グリッド ノード

グリッド ノードのビルドを開始するには、新しい Visual Studio クラス ライブラリ プロジェクトを作成します。プロジェクトの設定方法の詳細な説明については、「スタートアップ」ページを参照してください。

1. プロジェクト タイプとして Class Library を選択します

2. プロジェクトに CustomNodes という名前を付けます

ジオメトリを作成するため、適切な NuGet パッケージを参照する必要があります。NuGet パッケージ マネージャから ZeroTouchLibrary パッケージをインストールします。このパッケージは、using Autodesk.DesignScript.Geometry; ステートメントに必要です。

1. ZeroTouchLibrary パッケージを参照します。

2. このノードを Dynamo Studio の現在のビルド(1.3)で使用します。これに一致するパッケージ バージョンを選択します。

3. クラス ファイルの名前を Grids.cs に変更しています。

次に、RectangularGrid メソッドを配置する名前空間とクラスを設定する必要があります。Dynamo では、メソッド名とクラス名に基づいてノードに名前が付けられます。これを Visual Studio にコピーする必要はまだありません。

using Autodesk.DesignScript.Geometry;
using System.Collections.Generic;

namespace CustomNodes
{
    public class Grids
    {
        public static List<Rectangle> RectangularGrid(int xCount, int yCount)
        {
        //The method for creating a rectangular grid will live in here
        }
    }
}

Autodesk.DesignScript.Geometry; で、ZeroTouchLibrary パッケージにある ProtoGeometry.dll を参照します。System.Collections.Generic はリストの作成に必要です。

これで、矩形を描画するためのメソッドを追加できます。クラス ファイルを次のようにして、Visual Studio にコピーします。

using Autodesk.DesignScript.Geometry;
using System.Collections.Generic;

namespace CustomNodes
{
    public class Grids
    {
        public static List<Rectangle> RectangularGrid(int xCount, int yCount)
        {
            double x = 0;
            double y = 0;

            var pList = new List<Rectangle>();

            for (int i = 0; i < xCount; i++)
            {
                y++;
                x = 0;
                for (int j = 0; j < yCount; j++)
                {
                    x++;
                    Point pt = Point.ByCoordinates(x, y);
                    Vector vec = Vector.ZAxis();
                    Plane bP = Plane.ByOriginNormal(pt, vec);
                    Rectangle rect = Rectangle.ByWidthLength(bP, 1, 1);
                    pList.Add(rect);
                }
            }
            return pList;
        }
    }
}

プロジェクトが次のように表示されている場合は、先に進んで .dll をビルドしてみます。

1. Build > Build Solution を選択します。

プロジェクトの bin フォルダに .dll があるか確認します。正常にビルドされている場合は、Dynamo に .dll を追加できます。

1. Dynamo ライブラリ内のカスタム RectangularGrids ノード。

2. キャンバス上のカスタム ノード。

3. Dynamo に .dll を追加するための[追加]ボタン。

カスタム ノードの修正

上記の例では、RectangularGrids メソッド以外の定義があまりないかなり単純なノードを作成しました。しかし、入力ポートのツールチップを作成したり、標準の Dynamo ノードと同様にノードの概要を設定することができます。これらの機能をカスタム ノードに追加すると、特にライブラリで検索する場合に、そのカスタム ノードを簡単に使用できるようになります。

1. 既定の入力値

2. xCount 入力のツールチップ

RectangularGrid ノードには、このような基本的な機能が必要です。次のコードでは、入力と出力ポートの説明、概要、および既定の入力値を追加します。

using Autodesk.DesignScript.Geometry;
using System.Collections.Generic;

namespace CustomNodes
{
    public class Grids
    {
        /// <summary>
        /// This method creates a rectangular grid from an X and Y count.
        /// </summary>
        /// <param name="xCount">Number of grid cells in the X direction</param>
        /// <param name="yCount">Number of grid cells in the Y direction</param>
        /// <returns>A list of rectangles</returns>
        /// <search>grid, rectangle</search>
        public static List<Rectangle> RectangularGrid(int xCount = 10, int yCount = 10)
        {
            double x = 0;
            double y = 0;

            var pList = new List<Rectangle>();

            for (int i = 0; i < xCount; i++)
            {
                y++;
                x = 0;
                for (int j = 0; j < yCount; j++)
                {
                    x++;
                    Point pt = Point.ByCoordinates(x, y);
                    Vector vec = Vector.ZAxis();
                    Plane bP = Plane.ByOriginNormal(pt, vec);
                    Rectangle rect = Rectangle.ByWidthLength(bP, 1, 1);
                    pList.Add(rect);
                    Point cPt = rect.Center();
                }
            }
            return pList;
        }
    }
}

• メソッドのパラメータに値を割り当てて、入力の既定値を指定します。RectangularGrid(int xCount = 10, int yCount = 10)

• XML ドキュメントの先頭に /// を付けて、入力および出力のツールチップ、検索キーワード、および概要を作成します。

ツールチップを追加するには、プロジェクト フォルダに xml ファイルが必要です。オプションを有効にすると、Visual Studio で .xml が自動的に生成されます。

1. ここで XML ドキュメント ファイルを有効にして、ファイル パスを指定します。これにより、XML ファイルが生成されます。

以上で完了です。いくつかの標準機能を含む新しいノードを作成しました。次の章「Zero-Touch の基本」では、Zero-Touch ノードの開発、および注意すべき問題について詳しく説明します。

はじめに

このセクションでは、グラフ、パッケージ、ライブラリを Dynamo 3.x に移行する際、発生する可能性のある問題について説明します。

Dynamo 3.0 は主要なリリースであり、いくつかの API が変更または削除されました。Dynamo 3.x の開発者やユーザーに影響する可能性のある最も大きな変更は、.NET8 への移行です。

Dotnet/.NET は、Dynamo の記述言語である C# 言語をサポートするランタイムです。このランタイムが、オートデスクのエコシステムの他の部分とともに最新バージョンに更新されました。

詳細については、ブログの投稿を参照してください。

パッケージの互換性

Dynamo 3.x で Dynamo 2.x パッケージを使用する

Dynamo 3.x は .NET8 ランタイムで実行されるようになったため、Dynamo 2.x 用に作成されたパッケージ(.NET48 を使用)の Dynamo 3.x での動作は保証されていません。3.0 より前の Dynamo バージョンからパブリッシュされたパッケージを Dynamo 3.x でダウンロードしようとすると、パッケージが旧バージョンの Dynamo からパブリッシュされたという警告が表示されます。

これは、パッケージが機能しないということではありません。 単に互換性の問題が発生する可能性があるという警告です。通常は、Dynamo 3.x 専用に作成された新しいバージョンがあるかどうかを確認することをお勧めします。

パッケージを読み込む際にも Dynamo ログ ファイルでこのような警告が表示されることがあります。すべてが正しく動作している場合は、警告を無視することができます。

Dynamo 2.x で Dynamo 3.x パッケージを使用する

Dynamo 3.x 用に作成されたパッケージ(.Net8 を使用)が Dynamo 2.x で動作することはほとんどありません。また、旧バージョンを使用しているときに Dynamo の新しいバージョン用に作成されたパッケージをダウンロードする際にも警告が表示されます。

NodeModel ベースのノードは、Zero-Touch ノードよりも大幅に柔軟性に優れ強力です。この例では、矩形のサイズをランダム化する統合されたスライダを追加して、Zero-Touch グリッド ノードのレベルを高めます。

スライダでセルのスケールをそのサイズに対して相対的に変更するため、スライダで正確な範囲を設定する必要はありません。

モデル - ビュー - ビューモデル パターン

Dynamo は、UI をバックエンドから分離しておくためのモデル - ビュー - ビューモデル(MVVM)ソフトウェア アーキテクチャ パターンに基づいています。ZeroTouch ノードを作成する場合は、Dynamo はノードのデータとその UI の間でデータ バインドを実行します。カスタム UI を作成するには、データバインド ロジックを追加する必要があります。

大まかには、Dynamo では次の 2 つのパーツでモデルとビューの関係を確立します。

• ノードのコア ロジック(「モデル」)を確立する NodeModel クラス

• NodeModel の表示方法(「ビュー」)をカスタマイズする INodeViewCustomization クラス

NodeModel オブジェクトには既にビューとモデルの関連付け(NodeViewModel)があるため、検討するのはカスタム UI のモデルとビューのみです。

NodeModel を実装する方法

NodeModel ノードには Zero-Touch ノードと大きく異なる点がいくつかあり、この例でそれを説明します。UI のカスタマイズに進む前に、まず NodeModel ロジックをビルドします。

1.プロジェクト構造を作成する。

NodeModel ノードは関数のみを呼び出すことができるため、NodeModel と関数を別のライブラリに分割する必要があります。Dynamo パッケージでこの操作を行う標準的な方法として、それぞれ別のプロジェクトを作成します。まず、プロジェクトを包含する新しいソリューションを作成します。

1. File > New > Project を選択します。

2. Other Project Types を選択して Solution オプションを表示します。

3. Blank Solution を選択します。

4. ソリューションに CustomNodeModel という名前を付けます。

5. Ok を選択します。

ソリューションで 2 つの C# クラス ライブラリ プロジェクトを作成します。関数用のプロジェクトと、NodeModel インタフェースを実装するためのプロジェクトです。

1. ソリューションを右クリックして、Add > New Project を選択します。

2. クラス ライブラリを選びます。

3. CustomNodeModel という名前を付けます。

4. [Ok]をクリックします。

5. このプロセスを繰り返して、CustomNodeModelFunctions という名前の別のプロジェクトを追加します。

次に、自動的に作成されたクラス ライブラリの名前を変更し、CustomNodeModel プロジェクトに追加する必要があります。クラス GridNodeModel は抽象クラス NodeModel を実装し、ビューのカスタマイズには GridNodeView が使用され、GridFunction には呼び出す必要のある関数が含まれています。

1. CustomNodeModel プロジェクトを右クリックして Add > New Item... を選択し、Class を選んで別のクラスを追加します。

2. CustomNodeModel プロジェクトには GridNodeModel.cs クラスと GridNodeView.cs クラスが必要です

3. CustomNodeModelFunction プロジェクトには GridFunctions.cs クラスが必要です

クラスにコードを追加する前に、このプロジェクトに必要なパッケージを追加します。CustomNodeModel には ZeroTouchLibrary と WpfUILibrary が必要で、CustomNodeModelFunction には ZeroTouchLibrary のみが必要です。WpfUILibrary は、後で説明する UI のカスタマイズに使用し、ZeroTouchLibrary はジオメトリの作成に使用します。パッケージは、プロジェクトに個別に追加できます。これらのパッケージには依存関係があるため、Core および DynamoServices が自動的にインストールされます。

1. プロジェクトを右クリックして、Manage NuGet Packages を選択します。

2. そのプロジェクトに必要なパッケージのみをインストールします。

Visual Studio は、参照した NuGet パッケージをビルド フォルダにコピーします。これを false に設定できるため、パッケージ内に不要なファイルはありません。

1. Dynamo NuGet パッケージを選択します。

2. Copy Local を false に設定します。

2.NodeModel クラスを継承する

前述のとおり、NodeModel ノードが ZeroTouch ノードと異なるのは、主に NodeModel クラスを実装するという点です。NodeModel ノードにはこのクラスのいくつかの関数が必要です。クラス名の後に :NodeModel を追加すると、これらの関数を取得できます。

次のコードを GridNodeModel.cs にコピーします。

using System;
using System.Collections.Generic;
using Dynamo.Graph.Nodes;
using CustomNodeModel.CustomNodeModelFunction;
using ProtoCore.AST.AssociativeAST;
using Autodesk.DesignScript.Geometry;

namespace CustomNodeModel.CustomNodeModel
{
    [NodeName("RectangularGrid")]
    [NodeDescription("An example NodeModel node that creates a rectangular grid. The slider randomly scales the cells.")]
    [NodeCategory("CustomNodeModel")]
    [InPortNames("xCount", "yCount")]
    [InPortTypes("double", "double")]
    [InPortDescriptions("Number of cells in the X direction", "Number of cells in the Y direction")]
    [OutPortNames("Rectangles")]
    [OutPortTypes("Autodesk.DesignScript.Geometry.Rectangle[]")]
    [OutPortDescriptions("A list of rectangles")]
    [IsDesignScriptCompatible]
    public class GridNodeModel : NodeModel
    {
        private double _sliderValue;
        public double SliderValue
        {
            get { return _sliderValue; }
            set
            {
                _sliderValue = value;
                RaisePropertyChanged("SliderValue");
                OnNodeModified(false);
            }
        }
        public GridNodeModel()
        {
            RegisterAllPorts();
        }
        public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
        {
            if (!HasConnectedInput(0) || !HasConnectedInput(1))
            {
                return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) };
            }
            var sliderValue = AstFactory.BuildDoubleNode(SliderValue);
            var functionCall =
              AstFactory.BuildFunctionCall(
                new Func<int, int, double, List<Rectangle>>(GridFunction.RectangularGrid),
                new List<AssociativeNode> { inputAstNodes[0], inputAstNodes[1], sliderValue });

            return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), functionCall) };
        }
    }
}

これが、Zero-Touch ノードとは異なるところです。それぞれの機能について説明します。

• Name、Category、InPort/OutPort の名前、InPort/OutPort のタイプ、説明などの、Node 属性を指定します。

• public class GridNodeModel : NodeModel は、NodeModel クラスを Dynamo.Graph.Nodes から継承するクラスです。

• public GridNodeModel() { RegisterAllPorts(); } は、ノードの入力と出力を登録するコンストラクタです。

• BuildOutputAst() は、AST (抽象構文ツリー)を返します。これは、NodeModel ノードからデータを返すために必要な構造です。

• AstFactory.BuildFunctionCall() は、GridFunctions.cs から RectangularGrid 関数を呼び出します。

• new Func<int, int, double, List<Rectangle>>(GridFunction.RectangularGrid) は、関数とそのパラメータを指定します。

• new List<AssociativeNode> { inputAstNodes[0], inputAstNodes[1], sliderValue }); は、ノードの入力を関数パラメータにマッピングします。

• AstFactory.BuildNullNode() は、入力ポートが接続されていない場合に、null ノードを作成します。これは、ノードに警告が表示されないようにするためです。

• RaisePropertyChanged("SliderValue") は、スライダの値が変化したときに UI に通知します。

• var sliderValue = AstFactory.BuildDoubleNode(SliderValue) は、スライダ値を表すノードを AST で作成します。

• functionCall 変数 new List<AssociativeNode> { inputAstNodes[0], sliderValue }); にある変数 sliderValue への入力を変更します。

3.関数を呼び出す

CustomNodeModelFunction プロジェクトは、呼び出すことができるように、CustomNodeModel とは別のアセンブリにビルドされます。

次のコードを GridFunction.cs にコピーします。

using Autodesk.DesignScript.Geometry;
using Autodesk.DesignScript.Runtime;
using System;
using System.Collections.Generic;

namespace CustomNodeModel.CustomNodeModelFunction
{
    [IsVisibleInDynamoLibrary(false)]
    public class GridFunction
    {
        [IsVisibleInDynamoLibrary(false)]
        public static List<Rectangle> RectangularGrid(int xCount = 10, int yCount = 10, double rand = 1)
        {
            double x = 0;
            double y = 0;

            Point pt = null;
            Vector vec = null;
            Plane bP = null;

            Random rnd = new Random(2);

            var pList = new List<Rectangle>();
            for (int i = 0; i < xCount; i++)
            {
                y++;
                x = 0;
                for (int j = 0; j < yCount; j++)
                {
                    double rNum = rnd.NextDouble();
                    double scale = rNum * (1 - rand) + rand;
                    x++;
                    pt = Point.ByCoordinates(x, y);
                    vec = Vector.ZAxis();
                    bP = Plane.ByOriginNormal(pt, vec);
                    Rectangle rect = Rectangle.ByWidthLength(bP, scale, scale);
                    pList.Add(rect);
                }
            }
            pt.Dispose();
            vec.Dispose();
            bP.Dispose();
            return pList;
        }
    }
}

この関数クラスは、Zero-Touch グリッドのケース スタディに非常に似ていますが、次の点のみ異なります。

• [IsVisibleInDynamoLibrary(false)] によって Dynamo には後に続くメソッドとクラスが「見えなく」なります。これは、関数が既に CustomNodeModel から呼び出されているためです。

NuGet パッケージの参照の追加と同様に、CustomNodeModel は関数を呼び出すために CustomNodeModelFunction を参照する必要があります。

CustomNodeModel の using ステートメントは、関数を参照するまで非アクティブになります。

1. CustomNodeModel を右クリックして、Add > Reference を選択します。

2. Projects > Solution を選びます。

3. CustomNodeModelFunction をオンにします。

4. [Ok]をクリックします。

4.ビューをカスタマイズする

スライダを作成するには、INodeViewCustomization インタフェースを実装して UI をカスタマイズする必要があります。

次のコードを GridNodeView.cs にコピーします。

using Dynamo.Controls;
using Dynamo.Wpf;

namespace CustomNodeModel.CustomNodeModel
{
    public class CustomNodeModelView : INodeViewCustomization<GridNodeModel>
    {
        public void CustomizeView(GridNodeModel model, NodeView nodeView)
        {
            var slider = new Slider();
            nodeView.inputGrid.Children.Add(slider);
            slider.DataContext = model;
        }

        public void Dispose()
        {
        }
    }
}

• public class CustomNodeModelView : INodeViewCustomization<GridNodeModel> で、UI をカスタマイズするために必要な関数を定義します。

プロジェクトの構造を設定したら、Visual Studio の設計環境を使用してユーザ コントロールを作成し、.xaml ファイルでそのパラメータを定義します。ツール ボックスから、<Grid>...</Grid> にスライダを追加します。

1. CustomNodeModel を右クリックして、Add > New Item を選択します。

2. WPF を選択します。

3. ユーザ コントロールに Slider という名前を付けます。

4. [Add]をクリックします。

次のコードを Slider.xaml にコピーします。

<UserControl x:Class="CustomNodeModel.CustomNodeModel.Slider"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:CustomNodeModel.CustomNodeModel"
             mc:Ignorable="d" 
             d:DesignHeight="75" d:DesignWidth="100">
    <Grid Margin="10">
        <Slider Grid.Row="0" Width="80" Minimum="0" Maximum="1" IsSnapToTickEnabled="True" TickFrequency="0.01" Value="{Binding SliderValue}"/>
    </Grid>
</UserControl>

• スライダ コントロールのパラメータは、.xaml ファイルの In で定義されています。Minimum および Maximum__ の属性は、このスライダの数値範囲を定義します。

• <Grid>...</Grid> 内に、Visual Studio ツールボックスからさまざまなユーザ コントロールを配置できます。

Slider.xaml ファイルを作成すると、Visual Studio によって自動的に Slider.xaml.cs という C# ファイルが作成され、スライダが初期化されます。このファイルの名前空間を変更します。

using System.Windows.Controls;

namespace CustomNodeModel.CustomNodeModel
{
    /// <summary>
    /// Interaction logic for Slider.xaml
    /// </summary>
    public partial class Slider : UserControl
    {
        public Slider()
        {
            InitializeComponent();
        }
    }
}

• 名前空間は CustomNodeModel.CustomNodeModel にする必要があります

GridNodeModel.cs で、スライダの計算ロジックを定義します。

5.パッケージとして構成する

プロジェクトをビルドする前に、最後の手順として、pkg.json ファイルを追加して Dynamo でパッケージの読み込みができるようにします。

1. CustomNodeModel を右クリックして、Add > New Item を選択します。

2. Web を選択します。

3. JSON File を選択します。

4. ファイルに pkg.json という名前を付けます。

5. [Add]をクリックします。

• 次のコードを pkg.json にコピーします。

{
  "license": "MIT",
  "file_hash": null,
  "name": "CustomNodeModel",
  "version": "1.0.0",
  "description": "Sample node",
  "group": "CustomNodes",
  "keywords": [ "grid", "random" ],
  "dependencies": [],
  "contents": "Sample node",
  "engine_version": "1.3.0",
  "engine": "dynamo",
  "engine_metadata": "",
  "site_url": "",
  "repository_url": "",
  "contains_binaries": true,
  "node_libraries": [
    "CustomNodeModel, Version=1.0.0, Culture=neutral, PublicKeyToken=null",
    "CustomNodeModelFunction, Version=1.0.0, Culture=neutral, PublicKeyToken=null"
  ]
}

• "name": で、Dynamo ライブラリでのパッケージとそのグループの名前を決定します。

• "keywords": で、Dynamo ライブラリを検索するための検索語を指定します。

• "node_libraries": [] は、パッケージに関連付けられているライブラリです。

  最後に、ソリューションをビルドし、Dynamo パッケージとしてパブリッシュします。オンラインでパブリッシュする前にローカル パッケージを作成する方法と、Visual Studio から直接パッケージをビルドする方法については、「パッケージの配置」の章を参照してください。

開発に取り組む前に、新しいプロジェクトのための強固な基盤を築くことが重要です。Dynamo 開発者のコミュニティには複数のプロジェクト テンプレートがあり、ここから始めると便利ですが、プロジェクトをゼロから開始する方法を理解することはさらに重要です。プロジェクトをゼロから構築すると、開発プロセスをより深く理解できます。

Visual Studio プロジェクトを作成する

Visual Studio は、プロジェクトの作成、参照の追加、.dlls のビルド、デバッグを行うことができる強力な IDE です。新しいプロジェクトを作成する際に、Visual Studio ではプロジェクトを編成するための構造であるソリューションも作成します。複数のプロジェクトを、単一のソリューション内に配置し、まとめてビルドできます。ZeroTouch ノードを作成するには、C# クラス ライブラリを記述して .dll をビルドする新しい Visual Studio プロジェクトを開始する必要があります。

Visual Studio の新しいプロジェクトのウィンドウ

1. まず、Visual Studio を開いて、File > New > Project で新しいプロジェクトを作成します。

2. Class Library プロジェクト テンプレートを選択します。

3. プロジェクトに名前を付けます(この例ではプロジェクトに MyCustomNode という名前を付けています)。

4. プロジェクトのファイル パスを設定します。この例では、既定の場所のままにします。

5. Ok を選択します。

Visual Studio では自動的に C# ファイルを作成して開きます。適切な名前を付け、ワークスペースを設定し、既定のコードを次の乗算方法で置き換える必要があります。

 namespace MyCustomNode
 {
     public class SampleFunctions
     {
         public static double MultiplyByTwo(double inputNumber)
         {
             return inputNumber * 2.0;
         }
     }
 }

1. [View]からソリューション エクスプローラ ウィンドウと出力ウィンドウを開きます。

2. 右側のソリューション エクスプローラで、ファイル Class1.cs の名前を SampleFunctions.cs に変更します。

3. 乗算関数として上記のコードを追加します。Dynamo での C# クラスの読み込み方法については、後で詳しく説明します。

4. ソリューション エクスプローラ: ここでプロジェクト内のすべてにアクセスできます。

5. 出力ウィンドウ: ビルドが成功したかどうかを後で確認する場合に必要になります。

次の手順ではプロジェクトをビルドしますが、その前に設定をいくつか確認する必要があります。まず、プロジェクトのプロパティで、[Platform target]に Any CPU または x64 が選択され、Prefer 32-bit がオフになっていることを確認します。

1. Project > "ProjectName" Properties を選択して、プロジェクトのプロパティを開きます。

2. Build ページを選択します。

3. ドロップダウン メニューから Any CPU または x64 を選択します。

4. Prefer 32-bit がオフになっていることを確認します。

これで、.dll を作成するためにプロジェクトをビルドできるようになりました。これを行うには、[Build]メニューから[Build Solution]を選択するか、ショートカット CTRL+SHIFT+B を使用します。

1. Build > Build Solution を選択します。

2. 出力ウィンドウを確認すると、プロジェクトが正常にビルドされたかどうかを判断できます。

プロジェクトが正常にビルドされた場合、プロジェクトの bin フォルダに MyCustomNode という名前の .dll が作成されます。この例では、プロジェクトのファイル パスを Visual Studio の既定である c:\users\username\documents\visual studio 2015\Projects のままにしました。プロジェクトのファイル構造を確認します。

1. bin フォルダには、Visual Studio でビルドされた .dll が含まれています。

2. Visual Studio プロジェクト ファイル。

3. クラス ファイル。

4. ソリューション構成を Debug に設定したため、.dll は bin\Debug に作成されます。

これで、Dynamo を開いて .dll を読み込むことができるようになりました。追加機能を使用して、プロジェクトの bin の場所にナビゲートし、.dll を選択して開きます。

1. .dll を読み込むため、[追加]ボタンを選択します。

2. プロジェクトの場所にナビゲートします。プロジェクトは、Visual Studio の既定のファイル パス C:\Users\username\Documents\Visual Studio 2015\Projects\MyCustomNode にあります。

3. 読み込む MyCustomNode.dll を選択します。

4. [Open]をクリックして .dll をロードします。

ライブラリに MyCustomNode という名前のカテゴリが作成されている場合は、.dll が正常に読み込まれています。しかし、単一のノードを作成しようとしたところ、Dynamo で 2 つのノードが作成されました。次のセクションでは、このようになる理由と、Dynamo による .dll の読み込みについて説明します。

1. Dynamo ライブラリ内の MyCustomNode。ライブラリのカテゴリは、.dll の名前によって決まります。

2. キャンバス上の SampleFunctions.MultiplyByTwo。

Dynamo によるクラスとメソッドを読み込む仕組み

Dynamo は .dll をロードする際、すべてのパブリック静的メソッドをノードとして公開します。コンストラクタ、メソッド、およびプロパティは、それぞれ Create ノード、Action ノード、および Query ノードに変換されます。この乗算の例では、MultiplyByTwo() メソッドが Dynamo で Action ノードになります。これは、ノードの名前がそのメソッドとクラスに基づいて付けられているためです。

1. 入力には、メソッドのパラメータ名に基づいて inputNumber という名前が付けられています。

2. 出力に既定で double という名前が付けられているのは、これが返されるデータ タイプであるためです。

3. ノードに SampleFunctions.MultiplyByTwo という名前が付けられているのは、クラス名とメソッド名であるためです。

上記の例では、さらに SampleFunctions という Create ノードが作成されました。これは、明示的にコンストラクタを指定しなかったために自動的に作成されたことが原因です。これを回避するには、SampleFunctions クラスに空のプライベート コンストラクタを作成します。

namespace MyCustomNode
{
    public class SampleFunctions
    {
        //The empty private constructor.
        //This will be not imported into Dynamo.
        private SampleFunctions() { }

        //The public multiplication method. 
        //This will be imported into Dynamo.
        public static double MultiplyByTwo(double inputNumber)
        {
            return inputNumber * 2.0;
        }
    }
}

1. Dynamo が Create ノードとしてメソッドを読み込みました。

Dynamo NuGet パッケージの参照設定を追加する

乗算ノードは非常に単純なため、Dynamo への参照設定は必要ありません。たとえば、ジオメトリを作成するために Dynamo の機能にアクセスする場合は、Dynamo NuGet パッケージを参照する必要があります。

• ZeroTouchLibrary - Dynamo の Zero Touch ノード ライブラリをビルドするためのパッケージであり、DynamoUnits.dll、ProtoGeometry.dll というライブラリが含まれています。

• WpfUILibrary - WPF のカスタム UI を含む Dynamo のノード ライブラリをビルドするためのパッケージであり、DynamoCoreWpf.dll、CoreNodeModels.dll、CoreNodeModelWpf.dll というライブラリが含まれています。

• DynamoServices - Dynamo の DynamoServices ライブラリ。

• Core - Dynamo の単位およびシステムのテスト インフラストラクチャであり、DSIronPython.dll、DynamoApplications.dll、DynamoCore.dll、DynamoInstallDetective.dll、DynamoShapeManager.dll、DynamoUtilities.dll、ProtoCore.dll、VMDataBridge.dll というライブラリが含まれています。

• Tests - Dynamo の単位およびシステムのテスト インフラストラクチャであり、DynamoCoreTests.dll、SystemTestServices.dll、TestServices.dll というライブラリが含まれています。

• DynamoCoreNodes - Dynamo のコア ノードをビルドするためのパッケージであり、Analysis.dll、GeometryColor.dll、DSCoreNodes.dll というライブラリが含まれています。

Visual Studio プロジェクトでこれらのパッケージを参照するには、上記のリンクで NuGet からパッケージをダウンロードして .dll を手動で参照するか、Visual Studio の NuGet パッケージ マネージャ を使用します。まず、Visual Studio で NuGet を使用してインストールする方法について説明します。

1. Tools > NuGet Package Manager > Manage NuGet Packages for Solution... を選択して NuGet パッケージ マネージャを開きます。

次の図が NuGet パッケージ マネージャです。このウィンドウには、プロジェクトにインストールされているパッケージが表示され、ユーザは他のパッケージを参照できます。DynamoServices パッケージの新しいバージョンがリリースされた場合は、ここからパッケージを更新できます。前のバージョンに戻すこともできます。

1. [参照]を選択し、DynamoVisualProgramming を検索して Dynamo パッケージを表示します。

2. Dynamo パッケージです。いずれかを選択すると、そのパッケージの現在のバージョンと内容の説明が表示されます。

3. 必要なパッケージのバージョンを選択し、[インストール]をクリックします。これにより、作業中の特定のプロジェクトにパッケージがインストールされます。Dynamo の最新の公式リリースであるバージョン 1.3 を使用しているため、対応するパッケージのバージョンを選択します。

ブラウザからダウンロードしたパッケージを手動で追加するには、ソリューション エクスプローラから Reference Manager を開いてパッケージを参照します。

1. [References]を右クリックして、[Add Reference]を選択します。

2. [Browse]を選択して、パッケージの場所にナビゲートします。

Visual Studio が適切に構成され、Dynamo に .dll が正常に追加されたため、今後、コンセプトの強固な基盤となります。これは第一歩にすぎないため、引き続きカスタム ノードの作成方法の詳細について確認してください。

Zero-Touch ノードで Python スクリプトを実行する(C#)

Python でのスクリプトの記述に慣れているユーザが、Dynamo の標準的な Python ノード以外の機能を必要とする場合は、Zero-Touch を使用して独自のノードを作成できます。最初に紹介する簡単な例では、Python スクリプトを文字列として Zero-Touch ノードに渡すと、スクリプトが実行されて結果が返されます。このケース スタディは、「スタートアップ」セクションの説明と例に基づいているため、Zero-Touch ノードを初めて作成する場合はそちらを参照してください。

Python スクリプトの文字列を実行する Zero-Touch ノード

Python エンジン

このノードは、IronPython スクリプト エンジンのインスタンスに依存します。これを行うには、いくつかの追加のアセンブリを参照する必要があります。Visual Studio で基本的なテンプレートを設定するには、次の手順を実行します。

• 新しい Visual Studio クラス プロジェクトを作成します。

• C:\Program Files (x86)\IronPython 2.7\IronPython.dll にある IronPython.dll への参照を追加します。

• C:\Program Files (x86)\IronPython 2.7\Platforms\Net40\Microsoft.Scripting.dll にある Microsoft.Scripting.dll への参照を追加します。

• クラスに IronPython.Hosting および Microsoft.Scripting.Hosting の using ステートメントを含めます。

• パッケージを含む Dynamo ライブラリに追加のノードが作成されないように、空のプライベート コンストラクタを追加します。

• 単一の文字列を入力パラメータとして受け取る新しいメソッドを作成します。

• このメソッド内で、新しい Python エンジンをインスタンス化し、スクリプトの空のスコープを作成します。このスコープは、Python インタプリタのインスタンス内のグローバル変数と考えることができます。

• 次に、エンジンで Execute を呼び出して入力文字列とスコープをパラメータとして渡します。

• 最後に、スコープで GetVariable を呼び出し、返そうとしている値を含む変数の名前を Python スクリプトから渡して、スクリプトの結果を取得して返します。(詳細については、下の例を参照してください)

次のコードは、上記の手順の例を示しています。ソリューションをビルドすると、プロジェクトの bin フォルダに新しい .dll が作成されます。この .dll をパッケージの一部として、または File < Import Library... にナビゲートして Dynamo に読み込むことができます。

using IronPython.Hosting;
using Microsoft.Scripting.Hosting;

namespace PythonLibrary
{
    public class PythonZT
    {
        // Unless a constructor is provided, Dynamo will automatically create one and add it to the library
        // To avoid this, create a private constructor
        private PythonZT() { }

        // The method that executes the Python string
        public static string executePyString(string pyString)
        {
            ScriptEngine engine = Python.CreateEngine();
            ScriptScope scope = engine.CreateScope();
            engine.Execute(pyString, scope);
            // Return the value of the 'output' variable from the Python script below
            var output = scope.GetVariable("output");
            return (output);
        }
    }
}

Python スクリプトが変数 output を返すため、Python スクリプトには output という変数が必要です。このサンプル スクリプトを使用して、Dynamo でノードをテストします。Dynamo で Python ノードを使用したことがある場合は、同じように操作できます。詳細については、Primer の「Python」のセクションを確認してください。

import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

cube = Cuboid.ByLengths(10,10,10);
volume = cube.Volume
output = str(volume)

複数の出力

標準の Python ノードの制限事項として、出力ポートは 1 つしかありません。そのため、複数のオブジェクトを返す場合は、リストを作成してその中で各オブジェクトを取得する必要があります。ディクショナリを返すように上記の例を変更すると、必要な数だけ出力ポートを追加できます。ディクショナリの詳細については、「Zero-Touch の詳細を確認する」の「複数の値を返す」セクションを参照してください。

このノードを使用すると、直方体の体積と図心の両方を返すことができます。

次の手順で前の例を変更します。

• NuGet パッケージ マネージャから DynamoServices.dll への参照を追加します。

• 以前のアセンブリに加えて、System.Collections.Generic および Autodesk.DesignScript.Runtime を含めます。

• 出力を含むディクショナリを返すように、メソッドの戻り値のタイプを変更します。

• 各出力は、スコープから個別に取得する必要があります(大きな出力セットに対して単純なループを設定することを検討してください)。

using IronPython.Hosting;
using Microsoft.Scripting.Hosting;
using System.Collections.Generic;
using Autodesk.DesignScript.Runtime;

namespace PythonLibrary
{
    public class PythonZT
    {
        private PythonZT() { }

        [MultiReturn(new[] { "output1", "output2" })]
        public static Dictionary<string, object> executePyString(string pyString)
        {
            ScriptEngine engine = Python.CreateEngine();
            ScriptScope scope = engine.CreateScope();
            engine.Execute(pyString, scope);
            // Return the value of 'output1' from script
            var output1 = scope.GetVariable("output1");
            // Return the value of 'output2' from script
            var output2 = scope.GetVariable("output2");
            // Define the names of outputs and the objects to return
            return new Dictionary<string, object> {
                { "output1", (output1) },
                { "output2", (output2) }
            };
        }
    }
}

また、サンプルの Python スクリプトに出力変数(output2)を追加しています。これらの変数では任意の Python 命名規則を使用することができ、この例ではわかりやすくするために、厳密に output を使用しました。

import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

cube = Cuboid.ByLengths(10,10,10);
centroid = Cuboid.Centroid(cube);
volume = cube.Volume
output1 = str(volume)
output2 = str(centroid)

Zero-Touch プロジェクトの作成方法を理解できたので、Dynamo GitHub にあるサンプル ZeroTouchEssentials を使用して、ノードの作成について詳しく説明します。

Dynamo の標準ノードの多くは基本的な Zero-Touch ノードです。上記のほとんどの Math、Color、DateTime ノードと同様です。

まず、https://github.com/DynamoDS/ZeroTouchEssentials から ZeroTouchEssentials プロジェクトをダウンロードします。

Visual Studio で、ソリューション ファイル ZeroTouchEssentials.sln を開いてソリューションをビルドします。

ZeroTouchEssentials.cs ファイルには、Dynamo に読み込むメソッドがすべて含まれています。

Dynamo を開いて ZeroTouchEssentials.dll を読み込み、次の例で参照するノードを取得します。

コード サンプルは ZeroTouchEssentials.cs から取得され、通常は一致します。XML ドキュメントは簡潔にするために削除されています。各コード サンプルは上のイメージのノードを作成します。

既定の入力値

Dynamo では、ノードの入力ポートに対する既定値の定義がサポートされています。これらの既定値は、ポートに接続がない場合にノードに渡されます。既定では、「C# プログラミング ガイド」のオプションの引数を指定する C# メカニズムを使用して表します。既定では次のように指定します。

• メソッドのパラメータを既定値 inputNumber = 2.0 に設定します

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        // Set the method parameter to a default value
        public static double MultiplyByTwo(double inputNumber = 2.0) 
        {
            return inputNumber * 2.0;
        }
    }
}

1. ノードの入力ポートにカーソルを合わせると、既定値が表示されます。

複数の値を返す

複数の値を返すのは、複数の入力を作成するよりも少し複雑で、ディクショナリを使用して返す必要があります。ディクショナリのエントリはノードの出力側のポートになります。戻り値の複数のポートは次のように作成します。

• using System.Collections.Generic; を追加して Dictionary<> を使用します。

• using Autodesk.DesignScript.Runtime; を追加して、MultiReturn 属性を使用します。これは、DynamoServices NuGet パッケージから「DynamoServices.dll」を参照します。

• [MultiReturn(new[] { "string1", "string2", ... more strings here })] 属性をメソッドに追加します。文字列はディクショナリ内のキーを参照して、出力ポート名になります。

• 属性のパラメータ名に一致するキーを使用して関数から Dictionary<> を返します。return new Dictionary<string, object>

using System.Collections.Generic;
using Autodesk.DesignScript.Runtime;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        [MultiReturn(new[] { "add", "mult" })]
        public static Dictionary<string, object> ReturnMultiExample(double a, double b)
        {
            return new Dictionary<string, object>

                { "add", (a + b) },
                { "mult", (a * b) }
            };
        }
    }
}

ZeroTouchEssentials.cs でこのコード サンプルを参照してください。

複数の出力を返すノードです。

1. ディクショナリのキーに入力した文字列に従って、2 つの出力ポートに名前が付けられています。

ドキュメント、ツールチップ、検索

ノードの関数、入力、出力、検索タグなどを記述したドキュメントを Dynamo ノードに追加することをお勧めします。追加するには、XML ドキュメント タグを使用します。XML ドキュメントは次のように作成されます。

• 3 つのスラッシュが先頭に付いたすべてのコメント テキストは、ドキュメントとみなされます

  • 例: /// Documentation text and XML goes here

• 3 つのスラッシュの後に、.dll の読み込み時に Dynamo が読み込むメソッドの上に XML タグを作成します。

  • 例: /// <summary>...</summary>

• Project > Project Properties > Build を選択して XML documentation file をオンにすることで、Visual Studio で XML ドキュメントを有効にします。

1. Visual Studio は、指定された場所に XML ファイルを生成します。

タグのタイプは次のとおりです。

• /// <summary>...</summary> は、ノードのメインのドキュメントであり、左側の検索サイド バーでノードの上にツールチップとして表示されます

• /// <param name="inputName">...</param> は、特定の入力パラメータのドキュメントを作成します。

• /// <returns>...</returns> は、出力パラメータのドキュメントを作成します。

• /// <returns name = "outputName">...</returns> は、複数の出力パラメータのドキュメントを作成します。

• /// <search>...</search> は、カンマ区切りのリストに基づいて、ノードを検索結果と一致させます。たとえば、メッシュを再分割するノードを作成する場合は、「mesh」、「subdivision」、「catmull-clark」などのタグを追加します。

入力と出力の説明と、ライブラリに表示される概要を含むサンプル ノードを次に示します。

using Autodesk.DesignScript.Geometry;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        /// <summary>
        /// This method demonstrates how to use a native geometry object from Dynamo
        /// in a custom method
        /// </summary>
        /// <param name="curve">Input Curve. This can be of any type deriving from Curve, such as NurbsCurve, Arc, Circle, etc</param>
        /// <returns>The twice the length of the Curve </returns>
        /// <search>example,curve</search>
        public static double DoubleLength(Curve curve)
        {
            return curve.Length * 2.0;
        }
    }
}

ZeroTouchEssentials.cs でこのコード サンプルを参照してください。

このサンプル ノードのコードには次が含まれています。

1. ノードの概要。

2. 入力の説明。

3. 出力の説明。

オブジェクト

Dynamo には new キーワードがないため、静的な作成メソッドを使用してオブジェクトを作成する必要があります。オブジェクトは次のように作成されます。

• 他に必要のない限り、コンストラクタの内部を internal ZeroTouchEssentials() にします。

• public static ZeroTouchEssentials ByTwoDoubles(a, b) のような静的メソッドを使用してオブジェクトを作成します。

注: Dynamo では、静的メソッドがコンストラクタであることを示すために接頭辞「By」が使用されます。これは省略可能ですが、「By」を使用すると、ライブラリを Dynamo の既存のスタイルに合わせることができます。

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        private double _a;
        private double _b;

        // Make the constructor internal
        internal ZeroTouchEssentials(double a, double b)
        {
            _a = a;
            _b = b;
        }

        // The static method that Dynamo will convert into a Create node
        public static ZeroTouchEssentials ByTwoDoubles(double a, double b)
        {
            return new ZeroTouchEssentials(a, b);
        }
    }
}

ZeroTouchEssentials.cs でこのコード サンプルを参照してください。

ZeroTouchEssentials dll が読み込まれると、ライブラリに ZeroTouchEssentials ノードが追加されます。このオブジェクトは、ByTwoDoubles ノードを使用して作成できます。

Dynamo のジオメトリ タイプを使用する

Dynamo ライブラリでは、ネイティブの Dynamo ジオメトリ タイプを入力として使用し、新しいジオメトリを出力として作成できます。ジオメトリ タイプは次のように作成されます。

• C# ファイルの先頭に using Autodesk.DesignScript.Geometry; を追加し、プロジェクトに ZeroTouchLibrary NuGet パッケージを追加して、プロジェクトで「ProtoGeometry.dll」を参照します。

• 重要: 関数から返されないジオメトリ リソースを管理するには、下の「Dispose/using ステートメント」セクションを参照してください。

注: Dynamo ジオメトリ オブジェクトは、関数に渡されるその他のオブジェクトと同様に使用されます。

using Autodesk.DesignScript.Geometry;

namespace ZeroTouchEssentials
{
    public class ZeroTouchEssentials
    {
        // "Autodesk.DesignScript.Geometry.Curve" is specifying the type of geometry input, 
        // just as you would specify a double, string, or integer 
        public static double DoubleLength(Autodesk.DesignScript.Geometry.Curve curve)
        {
            return curve.Length * 2.0;
        }
    }
}

ZeroTouchEssentials.cs でこのコード サンプルを参照してください。

曲線の長さを取得し、その値を倍にするノード。

1. このノードは、入力として Curve ジオメトリタイプを受け取ります。

Dispose/using ステートメント

関数から返されないジオメトリ リソースは、Dynamo バージョン 2.5 以降を使用していない限り、手動で管理する必要があります。Dynamo 2.5 以降のバージョンでは、ジオメトリ リソースはシステムによって内部で処理されますが、複雑な使用事例がある場合や決まった時間にメモリの使用を削減する必要がある場合には、ジオメトリを手動で破棄する必要があります。Dynamo エンジンは、関数から返されるすべてのジオメトリ リソースを処理します。返されないジオメトリ リソースは、次のように手動で処理できます。

• using ステートメントを使用する場合は次のようになります。

  Copy

  using (Point p1 = Point.ByCoordinates(0, 0, 0))
  {
    using (Point p2 = Point.ByCoordinates(10, 10, 0))
    {
        return Line.ByStartPointEndPoint(p1, p2);
    }
  }

  using ステートメントについては、こちらで説明しています。

  Dynamo 2.5 で導入された安定性に関する新機能の詳細については、「Dynamo ジオメトリの安定性の向上」を参照してください

• 手動の Dispose の呼び出しを使用する場合は次のようになります。

  Copy

  Point p1 = Point.ByCoordinates(0, 0, 0);
  Point p2 = Point.ByCoordinates(10, 10, 0);
  Line l = Line.ByStartPointEndPoint(p1, p2);
  p1.Dispose();
  p2.Dispose();
  return l;

マイグレーション

新しいバージョンのライブラリをパブリッシュすると、ノード名が変更される場合があります。名前の変更をマイグレーション ファイルで指定できるため、旧バージョンのライブラリで作成されたグラフが更新されても正しく動作し続けます。マイグレーションは次のように実装されます。

• .dll と同じフォルダに、「BaseDLLName」.Migrations.xml という形式で .xml ファイルを作成します。

• .xml で、単一の <migrations>...</migrations> 要素を作成します。

• マイグレーション要素内で、名前の変更ごとに <priorNameHint>...</priorNameHint> 要素を作成します。

• 名前の変更ごとに、<oldName>...</oldName> および <newName>...</newName> 要素を指定します。

1. 右クリックして、Add > New Item を選択します。

2. XML File を選びます。

3. このプロジェクトでは、マイグレーション ファイルに ZeroTouchEssentials.Migrations.xml という名前を付けます。

このサンプル コードでは、GetClosestPoint という名前のノードが ClosestPointTo に変更されたことを Dynamo に伝えています。

<?xml version="1.0"?>
<migrations>
  <priorNameHint>
    <oldName>Autodesk.DesignScript.Geometry.Geometry.GetClosestPoint</oldName>
    <newName>Autodesk.DesignScript.Geometry.Geometry.ClosestPointTo</newName>
  </priorNameHint>
</migrations>

ProtoGeometry.Migrations.xml でこのコード サンプルを参照してください。

ジェネリクス

Zero-Touch は現在、ジェネリクスの使用をサポートしていません。使用できますが、タイプが設定されていない場合には直接読み込まれるコードで使用できません。汎用的でタイプが設定されていないメソッド、プロパティ、またはクラスは公開できません。

下の例では、タイプ T の Zero-Touch ノードは読み込まれません。ライブラリの残りの部分を Dynamo に読み込むと、タイプの例外が失われます。

public class SomeGenericClass<T>
{
    public SomeGenericClass()
    {
        Console.WriteLine(typeof(T).ToString());
    }  
}

次の例では、タイプを設定して汎用的なタイプを使用すると、Dynamo に読み込まれます。

public class SomeWrapper
{
    public object wrapped;
    public SomeWrapper(SomeGenericClass<double> someConstrainedType)
    {
        Console.WriteLine(this.wrapped.GetType().ToString());
    }
}

経験のレベルに関係なく、Dynamo プラットフォームはすべてのユーザが開発に参加できるように設計されています。さまざまな能力やスキル レベルを対象とする開発オプションがあり、それぞれの目的によって利点と欠点があります。ここでは開発オプションの概要と、その選び方について説明します。

次の 3 つの開発環境があります: Visual Studio、Python Editor、Code Block DesignScript

オプションの選び方について

Dynamo の開発オプションは、主に Dynamo 向け_の_開発と、Dynamo で の開発の 2 つに分類されます。この 2 つのカテゴリは、Dynamo IDE を使用して作成されたコンテンツを Dynamo で使用する「Dynamo での開発」と、外部ツールを使用して作成されたコンテンツを Dynamo に読み込んで使用する「Dynamo 向けの開発」を意味します。このガイドでは、Dynamo 向け の開発に焦点を当てていますが、すべてのプロセスのリソースについて以下で説明します。

Dynamo 向けの開発

これらのノードを使用することにより、最高レベルのカスタマイズが可能になります。多くのパッケージがこの方法を使用して構築されており、Dynamo のソースに貢献するために必要な手法です。このガイドでは、これらの構築プロセスについて説明します。

• Zero-Touch ノード

• NodeModel 派生ノード

• 拡張機能

Primer には、Zero-Touch ライブラリをインポートするための手順が記載されています。

次の説明では、Zero-Touch ノードおよび NodeModel ノードの開発環境として Visual Studio を使用します。

これから開発するプロジェクトがある Visual Studio インタフェース

Dynamo での開発

これらのプロセスはビジュアル プログラミング ワークスペース内に存在し、比較的単純ですが、すべてが Dynamo をカスタマイズするための有用なオプションです。Primer ではこれらの内容を広範囲にカバーし、「スクリプト作成のガイドライン」の章では、スクリプトのヒントとベスト プラクティスについて説明します。

• Code Block はビジュアル プログラミング環境で DesignScript を公開し、柔軟なテキスト スクリプトとノード ワークフローを可能にします。Code Block の関数は、ワークスペース内の任意の機能から呼び出すことができます。

  Code Block サンプルをダウンロードする(右クリックして名前を付けて保存する)か、Primer で詳細な手順を確認してください。

• カスタム ノードは、ノードの集合体またはグラフ全体のコンテナです。頻繁に使用するルーチンを収集し、コミュニティと共有するための効果的な手段です。

  カスタム ノードのサンプルをダウンロードする(右クリックして名前を付けて保存する)か、Primer で詳細な手順を確認してください。

• Python ノードは、Code Block と同様の働きをするビジュアル プログラミング ワークスペースのスクリプト インタフェースです。Autodesk.DesignScript ライブラリでは、DesignScript と同様のドット表記を使用します。

  Python ノードのサンプルをダウンロードする(右クリックして名前を付けて保存する)か、Primer で詳細な手順を確認してください。

Dynamo ワークスペースでの開発は、即座にフィードバックが得られる強力な手段です。

Python ノードを使用して Dynamo ワークスペースで開発する

それぞれの利点と欠点について

Dynamo の開発オプションは、カスタマイズの必要性に伴う複雑な作業に対応できるように設計されています。目的が Python で再帰スクリプトを記述するのか、完全にカスタム化したノード UI を構築するのかに関わらず、起動と実行に必要なものだけでコードを実装できるオプションがあります。

Dynamo の Code Block 、Python ノード、カスタム ノード

これらは、Dynamo のビジュアル プログラミング環境でコードを書く場合の簡単なオプションです。Dynamo のビジュアル プログラミング ワークスペースから、Python や DesignScript にアクセスでき、カスタム ノード内に複数のノードを含めることができます。

これらの方法を使用すると、次の操作が可能になります。

• セットアップは最小限のまま、Python または DesignScript の作成を開始します。

• Python ライブラリを Dynamo に読み込みます。

• Dynamo コミュニティで、Code Block、Python ノード、カスタム ノードをパッケージの一部として共有します。

Zero-Touch ノード

Zero-Touch とは、C# ライブラリを読み込むための単純なポイント アンド クリック操作のことです。Dynamo は、.dll のパブリック メソッドを読み取って Dynamo ノードに変換します。Zero-Touch ノードを使用して、独自のカスタム ノードおよびパッケージを開発できます。

この方法では、次の操作が可能になります。

• Primer の「A-Forge の例」のように、必ずしも Dynamo 用に開発されたのではないライブラリを読み込み、一連の新しいノードを自動的に作成します。

• C# メソッドを記述し、Dynamo でノードとして簡単に使用することができます。

• パッケージ内の Dynamo コミュニティで C# ライブラリをノードとして共有できます。

NodeModel 派生ノード

これらのノードは、Dynamo の構造をさらに一歩前進させたものです。これらは NodeModel クラスに基づいて C# で記述されます。この方法は最も柔軟で強力ですが、ノードのほとんどの要素を明示的に定義する必要があることと、関数は別のアセンブリに存在する必要があります。

この方法では、次の操作が可能になります。

• スライダ、イメージ、カラーなど、完全にカスタマイズ可能なノード UI を作成します(ColorRange ノードなど)。

• Dynamo キャンバスにアクセスし、そこでの動作に影響を与えることができます。

• レーシングをカスタマイズします。

• Dynamo にパッケージとしてロードします。

Dynamo のバージョン管理と API の変更点について理解する(1.x → 2.x)

Dynamo は定期的に更新されるため、パッケージが使用する API の一部が変更される場合があります。既存のパッケージが正しく動作し続けるようにするためには、これらの変更を追跡することが重要になります。

API の変更は、Dynamo GitHub Wiki で確認できます。ここでは DynamoCore、ライブラリ、ワークスペースの変更点について調べることができます。

今後予定されている重要な変更の例として、バージョン 2.0 でファイル形式が XML から JSON に移行することが挙げられます。NodeModel 派生ノードには、JSON コンストラクタが必要になります。これがない場合、Dynamo 2.0 で開きません。

現在の Dynamo API ドキュメントでは、コアな機能についてカバーしています。http://dynamods.github.io/DynamoAPI

パッケージのバイナリを配布する権限

Package Manager にアップロードされるパッケージに含まれる .dll に注意してください。パッケージの作成者が .dll を作成しなかった場合、それらを共有する権限が必要です。

パッケージにバイナリが含まれている場合、パッケージにバイナリが含まれていることをダウンロード時にユーザに確認する必要があります。

はじめに:

Dynamo 2.0 は主要なリリースであり、いくつかの API が変更または削除されました。中でも、ノードおよびパッケージの作成者に多大な影響をおよぼす変更の 1 つは、ファイル形式が JSON に移行されたことです。

Zero-Touch ノードの作成者が、パッケージを 2.0 で実行するために必要となる作業は、ほとんどないのが一般的です。

UI ノードと、NodeModel から直接派生したノードを 2.x で実行するためには、より多くの作業を必要とします。

また、拡張機能作成者は、拡張機能で使用する Dynamo Core API の数によっては、変更が必要になる可能性があります。

一般的なパッケージ化のルール:

• パッケージに Dynamo または Dynamo Revit の .dll をバンドルしないでください。これらの dll は、Dynamoによってもすでにロードされています。ユーザがロードしているバージョンとは異なるバージョンをバンドルした場合 (つまり、Dynamo Core 1.3 を配布したが、ユーザが Dynamo 2.0 でパッケージを実行している場合)、予期しないランタイム エラーが発生します。これには、DynamoCore.dll、DynamoServices.dll、DSCodeNodes.dll、ProtoGeometry.dll などの dll が該当します 。

• 可能な限り、パッケージに newtonsoft.json.net をバンドルして配布しないでください。この dll は、Dynamo 2.x によってもすでにロードされています。先ほどと同じ問題が発生する可能性があります。

• 可能な限り、パッケージに CEFSharp をバンドルして配布しないでください。この dll は、Dynamo 2.x によってもすでにロードされています。先ほどと同じ問題が発生する可能性があります。

• 一般的に、依存関係のバージョンを制御する必要がある場合は、Dynamo や Revit との依存関係を共有することは避けてください。

一般的な問題:

1) グラフを開くと、一部のノードに同じ名前の複数のポートが存在するが、保存するとグラフは適切に表示される。この問題には、いくつかの原因が考えられます。

一般的な原因は、ポートを再作成するコンストラクタを使用してノードを作成したことによるものです。その場合、ポートをロードしたコンストラクタを使用する必要があります。これらのコンストラクタには通常、[JsonConstructor] マークが付いています。次のサンプルを参照してください。

これは次のような場合に発生します。

• 単に [JsonConstructor] と一致するものがなかったか、JSON .dyn から Inports と Outports が渡されなかった。

• JSON.net の 2 つのバージョンが同時に同じプロセスにロードされ、.net ランタイム エラーが発生したため、コンストラクタをマークするための [JsonConstructor] 属性を正しく使用できなかった。

• 現在の Dynamo バージョンとは異なるバージョンの DynamoServices.dll がパッケージにバンドルされており、.net ランタイムで [MultiReturn] 属性を識別できなくなっているために、さまざまな属性が設定されている Zero-Touch ノードを適用することができない。ノードは複数のポートではなく、単一のディクショナリ出力を返すことがあります。

2) コンソールでいくつかのエラーが発生した状態でグラフをロードすると、ノードが完全に失われる。

• これは、何らかの理由でシリアル化解除に失敗した場合に発生する可能性があります。必要なプロパティのみをシリアル化することをお勧めします。ロードや保存を必要としない複雑なプロパティに対して [JsonIgnore] を使用して、それらを無視することができます。function pointer, delegate, action, や event などのプロパティです。これらはシリアル化できないため、シリアル化解除に失敗し、ランタイム エラーが発生します。

詳細なアップグレード:

カスタム ノード 1.3 > 2.0

librarie.js のカスタム ノードを整理する

既知の問題:

• librarie.js 内の同じレベルで、一致したカスタムノード名とカテゴリ名を使用すると、予期しない動作が発生します。QNTM-3653 - カテゴリとノードに同じ名前を使用しないでください。

• コメントは、行コメントではなくブロック コメントに変換されます。

• ショート タイプ名はフル ネームに置き換えられます。たとえば、カスタム ノードを再ロードするときにタイプを指定しなかった場合、var[]..[] - が既定のタイプとして表示されます。

Zero-Touch ノード 1.3 -> 2.0

• Dynamo 2.0 では、リストとディクショナリのタイプが分割され、リストとディクショナリを作成するための構文が変更されました。リストは [] を使用して初期化され、ディクショナリは {} を使用して初期化されます。 以前に DefaultArgument 属性を使用して Zero-Touch ノードのパラメータをマークし、someFunc([DefaultArgument("{0,1,2}")]) リスト構文を使用して特定のリストを既定として使用していた場合は、これは無効になり、リストに新しい初期化構文を使用するように DesignScript スニペットを変更する必要があります。

• 前述ように、パッケージに Dynamo の dll を含めて配布しないでください。(DynamoCore、DynamoServices など)

ノード モデル ノード 1.3 -> 2.0

ノード モデル ノードは、Dynamo 2.x に更新する際に多くの作業量を必要とするノードです。大まかに言うと、ノード タイプの新しいインスタンスのインスタンス化に使用される通常の nodeMode lコンストラクタに加えて、JSON からノードをロードするためにのみ使用されるコンストラクタを実装する必要があります。これらを区別するには、newtonsoft.Json.net の属性である [JsonConstructor] で、ロード時間コンストラクタをマークします。

コンストラクタのパラメータの名前は、通常 JSON プロパティの名前と一致させる必要があります。ただし、[JsonProperty]属性を使用してシリアル化された名前を上書きすると、このマッピングはより複雑になります。 詳細については、Json.net ドキュメントを参照してください。

JSON コンストラクタ

NodeModel ベース クラス(または、その他の Dynamo のコア ベース クラス DSDropDownBase など)から派生したノードを更新するために必要となる最も一般的な変更は、クラスに JSON コンストラクタを追加する必要があることです。

パラメータを持たない元のコンストラクタは、Dynamoで作成された新しいノードの初期化を引き続き処理します(たとえばライブラリなどを使用)。JSON コンストラクタは、保存した .dyn または .dyf ファイルからシリアル化解除した (ロードした) ノードを初期化するために必要です。

JSON コンストラクタは、JSON ロード ロジックによって提供される inPorts および outPorts 用の PortModel パラメータがあるという点で、基本コンストラクタとは異なります。ノードのポートを登録する呼び出しは、データが .dyn ファイルに存在するためここでは必要ありません。JSON コンストラクタのサンプルは次のようになります。

using Newtonsoft.Json; //New dependency for Json

………

[JsonConstructor] //Attribute required to identity the Json constructor

//Minimum constructor implementation. Note that the base method invocation must also be present.

FooNode(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(inPorts, outPorts) { }

この構文 :base(Inports,outPorts){} は、ベース nodeModel コンストラクタを呼び出し、シリアル化解除されたポートを渡します。

クラス コンストラクタに存在し、.dyn ファイルにシリアル化した特定のデータの初期化を含む特殊なロジック (たとえば、ポート登録、レーシング戦略などの設定) は、このコンストラクタで繰り返す必要はありません。これらの値は JSON から読み取ることができます。

これが nodeModel の JSON コンストラクタと非 JSON コンストラクタの主な違いです。JSON コンストラクタは、ファイルからロードするときに呼び出し、ロードしたデータを渡します。ただし、その他のユーザ ロジックは JSON コンストラクタで複製する必要があります (たとえば、ノードのイベント ハンドラの初期化やアタッチなど)。

サンプルについては、DynamoSamples リポジトリの ButtonCustomNodeModel、DropDown、または SliderCustomNodeModel を参照してください。

パブリック プロパティとシリアル化

これまでは、開発者は SerializeCore および DeserializeCore メソッドを使用して、特定のモデル データを xml ドキュメントにシリアル化およびシリアル化解除できました。これらのメソッドは、API に引き続き存在しますが、Dynamo の将来のリリースでは廃止される予定です(サンプルについては、こちらを参照してください)。現在、JSON.NET が実装されたことで、NodeModel 派生クラスの public プロパティを、.dyn ファイルに直接シリアル化できるようになりました。JSON.Net には、プロパティをシリアル化する方法をコントロールするための複数の属性があります。

PropertyName を指定するサンプルは、Dynamo リポジトリ内のこちらを参照してください。

[JsonProperty(PropertyName = "InputValue")]

public DSColor DsColor {...

コンバータ:

注: 独自の JSON.net コンバータ クラスを作成した場合、現在の Dynamo にはロード メソッドと保存メソッドに挿入するためのメカニズムがないため、クラスを [JsonConverter] 属性でマークしても使用できない可能性があります。その場合は、コンバータをセッターまたはゲッターで直接呼び出すことができます。//TODO この制限を確認する必要があります。これに関するどのようなコメントも歓迎します。

プロパティを文字列に変換するシリアル化メソッドを指定するサンプルは、Dynamo リポジトリのこちらを参照してください。

[JsonProperty("MeasurementType"), JsonConverter(typeof(StringEnumConverter))]

public ConversionMetricUnit SelectedMetricConversion{...

プロパティを無視する

シリアル化を意図していない public プロパティには、[JsonIgnore] 属性を追加する必要があります。ノードを .dyn ファイルに保存すると、そのデータはシリアル化メカニズムによって無視されることが確実となり、グラフを再度開いたときに予期しない結果となることがなくなります。このサンプルについては Dynamo のリポジトリのこちらを参照してください。

元に戻す/やり直し

すでに述べたように、SerializeCore および DeserializeCore メソッドは、以前 xml .dyn ファイルにノードを保存およびロードするために使用されていました。また、元に戻す/やり直し用のノード状態を保存およびロードする場合にも使用されていて、現在も使用可能です。nodeModel UI ノードに対して複雑な元に戻す/やり直し機能を実装する場合は、これらのメソッドを実装し、これらのメソッドのパラメータとして提供されるXML ドキュメント オブジェクトにシリアル化する必要があります。これは、複雑な UI ノードを除いて、まれな使用事例です。

入力および出力ポート API

2.0 API の変更によって影響を受ける nodeModelノードでよく見られるのが、ノード コンストラクタでのポート登録です。Dynamo または DynamoSamples リポジトリ内のサンプルを確認すると、以前は、InPortData.Add() または OutPortData.Add() メソッドを使用していることがわかります。以前は、Dynamo API で InPortData および OutPortData パブリック プロパティが廃止とマークされていました。2.0 では、これらのプロパティは削除されました。開発者は、InPorts.Add() および OutPorts.Add() メソッドを使用する必要があります。また、これら 2 つの Add() メソッドには少し異なる要素があります。

InPortData.Add(new PortData("Port Name", "Port Description")); //Old version valid in 1.3 but now deprecated

vs

InPorts.Add(new PortModel(PortType.Input, this, new PortData("Port Name", "Port Description"))); //Recommended 2.0

変換されたコードのサンプルについては、Dynamo リポジトリの DynamoConvert.cs または FileSystem.cs を参照してください。

2.0 API の変更によって影響を受ける、その他の共通使用例は、ポート コネクタの有無に基づいてノードの動作を決定する手法で一般的に使用されている BuildAst() メソッドに関連するものです。以前は、接続ポートの状態を確認するために HasConnectedInput(index) が使用されていました。今後開発者は、InPorts[0].IsConnected プロパティを使用してポートの接続状態を確認する必要があります。これに関するサンプルは、Dynamo リポジトリの ColorRange.cs を参照してください。

サンプル

1.3 UI ノードを Dynamo 2.x にアップグレードする方法について説明します。

using System;
using System.Collections.Generic;
using Dynamo.Graph.Nodes;
using CustomNodeModel.CustomNodeModelFunction;
using ProtoCore.AST.AssociativeAST;
using Autodesk.DesignScript.Geometry;

namespace CustomNodeModel.CustomNodeModel
{
    [NodeName("RectangularGrid")]
    [NodeDescription("An example NodeModel node that creates a rectangular grid. The slider randomly scales the cells.")]
    [NodeCategory("CustomNodeModel")]
    [InPortNames("xCount", "yCount")]
    [InPortTypes("double", "double")]
    [InPortDescriptions("Number of cells in the X direction", "Number of cells in the Y direction")]
    [OutPortNames("Rectangles")]
    [OutPortTypes("Autodesk.DesignScript.Geometry.Rectangle[]")]
    [OutPortDescriptions("A list of rectangles")]
    [IsDesignScriptCompatible]
    public class GridNodeModel : NodeModel
    {
        private double _sliderValue;
        public double SliderValue
        {
            get { return _sliderValue; }
            set
            {
                _sliderValue = value;
                RaisePropertyChanged("SliderValue");
                OnNodeModified(false);
            }
        }
        public GridNodeModel()
        {
            RegisterAllPorts();
        }
        public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
        {
            if (!HasConnectedInput(0) || !HasConnectedInput(1))
            {
                return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) };
            }
            var sliderValue = AstFactory.BuildDoubleNode(SliderValue);
            var functionCall =
              AstFactory.BuildFunctionCall(
                new Func<int, int, double, List<Rectangle>>(GridFunction.RectangularGrid),
                new List<AssociativeNode> { inputAstNodes[0], inputAstNodes[1], sliderValue });

            return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), functionCall) };
        }
    }
}

この nodeModel クラスをロードして 2.0 で正しく保存するためにやるべきことは、ポートのロードを処理する jsonConstructor の追加です。単純にベース コンストラクタのポートを渡すだけであり、この実装は空です。

[JsonConstructor]
protected GridNodeModel(IEnumerable<PortModel> Inports, IEnumerable<PortModel> Outports ) :
base(Inports,Outports)
{

}

注: JsonConstructor で RegisterPorts() や類似のものを呼び出さないでください。ノード クラスの入力および出力パラメータ属性を使用し、新しいポートを構築します。コンストラクタに渡されたロード済みポートを使用したいため、これは望ましい結果ではありません。

[InPortNames("xCount", "yCount")]
[InPortTypes("double", "double")]

このサンプルでは、可能な限り最小限のロード JSON コンストラクタを追加しています。しかし、コンストラクタ内でのイベント処理のリスナーを設定するなど、より複雑なコンストラクション ロジックを実行する必要がある場合はどうでしょうか。 DynamoSamples リポジトリから取得した次のサンプルは、このドキュメントの JsonConstructors Section にリンクされています。

以下に、UI ノードの複雑なコンストラクタを示します。

 public ButtonCustomNodeModel()
        {
            // When you create a UI node, you need to do the
            // work of setting up the ports yourself. To do this,
            // you can populate the InPorts and the OutPorts
            // collections with PortData objects describing your ports.
            InPorts.Add(new PortModel(PortType.Input, this, new PortData("inputString", "a string value displayed on our button")));

            // Nodes can have an arbitrary number of inputs and outputs.
            // If you want more ports, just create more PortData objects.
            OutPorts.Add(new PortModel(PortType.Output, this, new PortData("button value", "returns the string value displayed on our button")));
            OutPorts.Add(new PortModel(PortType.Output, this, new PortData("window value", "returns the string value displayed in our window when button is pressed")));

            // This call is required to ensure that your ports are
            // properly created.
            RegisterAllPorts();

            // Listen for input port disconnection to trigger button UI update
            this.PortDisconnected += ButtonCustomNodeModel_PortDisconnected;

            // The arugment lacing is the way in which Dynamo handles
            // inputs of lists. If you don't want your node to
            // support argument lacing, you can set this to LacingStrategy.Disabled.
            ArgumentLacing = LacingStrategy.Disabled;

            // We create a DelegateCommand object which will be 
            // bound to our button in our custom UI. Clicking the button 
            // will call the ShowMessage method.
            ButtonCommand = new DelegateCommand(ShowMessage, CanShowMessage);

            // Setting our property here will trigger a 
            // property change notification and the UI 
            // will be updated to reflect the new value.
            ButtonText = defaultButtonText;
            WindowText = defaultWindowText;
        }

ファイルからこのノードをロードするための JSON コンストラクタを追加する場合は、このロジックの一部を再作成する必要があります。ただし、ポートの作成、レーシングの設定、またはファイルからロードできるプロパティの既定値を設定するコードは含んでいないことに注意してください。

        // This constructor is called when opening a Json graph.

        [JsonConstructor]
        ButtonCustomNodeModel(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(inPorts, outPorts)
        {
            this.PortDisconnected += ButtonCustomNodeModel_PortDisconnected;
            ButtonCommand = new DelegateCommand(ShowMessage, CanShowMessage);
        }

JSON にシリアル化したその他のパブリック プロパティ(ButtonText、WindowText など)は、コンストラクタに明示的なパラメータとして追加されていないことに注意してください。これらは、それぞれのプロパティのセッターを使用して JSON.net によって自動的に設定されます。

拡張機能は、Dynamo エコシステムの強力な開発ツールです。開発者は、Dynamo の相互作用とロジックに基づいてカスタム機能を実行することができます。拡張機能は、2 つの主なカテゴリ、拡張機能とビュー拡張機能に分けることができます。名前が示すように、ビューの拡張機能フレームワークでは、カスタム メニュー項目を登録することで Dynamo UI を拡張することができます。通常の拡張機能は、UI を除いてビュー拡張機能と非常によく似た動作をします。たとえば、特定の情報を Dynamo コンソールに記録する拡張機能を作成することができます。このシナリオの場合、カスタム UI は必要ないため、通常の拡張機能を使用して実現することができます。

拡張機能のケース スタディ

DynamoSamples GitHub リポジトリの SampleViewExtension のサンプルに従って、グラフ内のアクティブなノードをリアルタイムで表示する、簡易なモードレス ウィンドウを作成するために必要な手順を説明します。ビュー拡張機能には、ウィンドウの UI を作成し、ビュー モデルに値をバインドする必要があります。

1. GitHub リポジトリの SampleViewExtension のサンプルに従って開発された、ビュー拡張機能ウィンドウ。

サンプルを最初から作成しますが、DynamoSamples リポジトリをダウンロードしてビルドすることで、参照として使用することもできます。

この手順では、DynamoSamples/src/ にある SampleViewExtension という名前のプロジェクトを具体的に参照します。

ビュー拡張機能を実装するには

ビュー拡張機能には、次の 3 つの主要な部分があります。

• IViewExtension を実装する、クラスとビュー モデルを作成するクラスを含むアセンブリ

• 実行時に、このアセンブリを検索する場所と拡張子のタイプを Dynamo に通知する .xml ファイル

• グラフィックス表示にデータをバインドして、ウィンドウの外観を決定する .xaml ファイル

1.プロジェクトの構造を作成する

まず、新規の Class Library プロジェクトを SampleViewExtension という名前で作成します。

1. File > New > Project を選択して新しいプロジェクトを作成します。

2. Class Library を選択します。

3. プロジェクトに SampleViewExtension という名前を付けます。

4. Ok を選択します。

このプロジェクトでは、2 つのクラスが必要です。1 つのクラスが IViewExtension を実装し、別のクラスは NotificationObject. IViewExtension を実装して、拡張機能がどのように配置、ロード、参照、および破棄するか、すべての情報を含めます。NotificationObject は、Dynamo と IDisposable での変更に関する通知を提供します。変更が発生すると、それに応じてカウントが更新されます。

1. SampleViewExtension.cs というクラス ファイルは IViewExtension を実装します。

2. SampleWindowViewMode.cs というクラス ファイルは NotificationObject を実装します。

IViewExtension を使用するには WpfUILibrary NuGet パッケージが必要です。このパッケージをインストールすると、Core、Services、および ZeroTouchLibrary パッケージが自動的にインストールされます。

1. WpfUILibrary を選択します。

2. Install を選択して、従属パッケージをすべてインストールします。

2.IViewExtension クラスを実装する

IViewExtension クラスから、Dynamo の起動時、拡張機能のロード時、 Dynamo のシャットダウン時に何が起きるかを決定します。SampleViewExtension.cs クラス ファイルに、次のコードを追加します。

SampleViewExtension クラスは、ウィンドウを開くクリック可能なメニュー項目を作成し、ビュー モデルとウィンドウに接続します。

• public class SampleViewExtension : IViewExtension SampleViewExtension は IViewExtension インタフェースから継承され、メニュー項目の作成に必要なものがすべて提供されます。

• sampleMenuItem = new MenuItem { Header = "Show View Extension Sample Window" }; は MenuItem を作成し、View メニューに追加します。

1. メニュー項目

• sampleMenuItem.Click += (sender, args) は、メニュー項目をクリックしたときに、新しいウィンドウを開くイベントが発生します。

• MainGrid = { DataContext = viewModel } は、これから作成する .xaml ファイル内の Main Grid を参照して、ウィンドウ内のメイン グリッドのためのデータ コンテキストを設定します。

• Owner = p.DynamoWindow は、ポップアウト ウィンドウの所有者を Dynamo に設定します。つまり、新しいウィンドウは Dynamo に依存しているため、Dynamo の最小化、最大化、復元などの操作を行うと、新しいウィンドウでも同じ動作が実行されます。

• window.Show(); は、追加のウィンドウ プロパティが設定されたウィンドウを表示します。

3.ビュー モデルを実装する

ウィンドウの基本パラメータをいくつか設定することができました。次に、さまざまな Dynamo 関連のイベントに応答するためのロジックを追加し、これらのイベントに基づいて UI を更新するように指示します。次のコードを、SampleWindowViewModel.cs クラス ファイルにコピーします。

このビュー モデル クラスの実装は、CurrentWorkspaceModel を確認し、ワークスペースにノードが追加または削除されたときにイベントを発生させます。これにより、データが変更され、更新が必要であることを UI またはバインド要素に通知するプロパティの変更が発生します。ActiveNodeTypes ゲッターを呼び出すことで、内部で追加のヘルパー関数 getNodeTypes() が呼び出されます。この関数は、キャンバス上のすべてのアクティブなノードを反復処理し、これらのノードの名前を含む文字列を生成します。次にこの文字列を、ポップアウト ウィンドウに表示される .xaml ファイル内のバインドに返します。

拡張機能のコア ロジックを定義したため、ウィンドウの外観の詳細を .xaml ファイルで指定できるようになりました。単に必要なのは、TextBlock Text にバインドされている ActiveNodeTypes プロパティを介して文字列を表示する、簡易なウィンドウです。

1. プロジェクトを右クリックして次を選択します: Add > New Item...

2. ウィンドウを作成するために変更するユーザ コントロール テンプレートを選択します。

3. 新しいファイル名を SampleWindow.xaml にします。

4. Add を選択します。

ウィンドウの .xaml コードでは、テキスト ブロックに SelectedNodesText をバインドする必要があります。SampleWindow.xaml に、次のコードを追加します。

• Text="{Binding ActiveNodeTypes}" は、SampleWindowViewModel.cs 内のプロパティ値 ActiveNodeTypes に対して、ウィンドウの TextBlock Text 値をバインドします。

ここで、.xaml C# バッキング ファイル SampleWindow.xaml.cs のサンプル ウィンドウを初期化します。SampleWindow.xaml に、次のコードを追加します。

ビュー拡張機能は、構築して Dynamo に追加する準備が整いました。Dynamo には、xml ファイルが必要です。出力を .dll 拡張子として登録するためのファイルです。

1. プロジェクトを右クリックして次を選択します: Add > New Item...

2. XML ファイルを選択します。

3. ファイル名を SampleViewExtension_ViewExtensionDefinition.xml にします。

4. Add を選択します。

• ファイル名は、Dynamo 標準に従って拡張アセンブリを参照します。 "extensionName"_ViewExtensionDefinition.xml

xml ファイルに次のコードを追加して、Dynamo に拡張アセンブリの検索場所を指示します。

• この例では、アセンブリを既定の Visual Studio プロジェクト フォルダに作成しました。<AssemblyPath>...</AssemblyPath> ターゲットをアセンブリの場所に置き換えます。

最後の手順では、SampleViewExtension_ViewExtensionDefinition.xml ファイルを Dynamo の Core インストール フォルダ C:\Program Files\Dynamo\Dynamo Core\1.3\viewExtensions にある Dynamo のビュー拡張機能フォルダにコピーします。extensions と viewExtensions には別々のフォルダが存在することに注意が必要です。xml ファイルを誤ったフォルダに配置すると、実行時に正しくロードされない可能性があります。

1. Dynamo のビュー拡張機能フォルダにコピーされた .xml ファイル

ここではビュー拡張機能の基本的な概要について紹介しました。より高度なケース スタディについては、GitHub のオープン ソース プロジェクトである DynaShape パッケージを参照してください。このパッケージでは、Dynamo モデル ビューでライブ編集を可能にするビュー拡張機能を使用しています。