複数のキーを利用できるConditionalWeakTableクラス

C#

下記記事にて、2つのキーを利用できるWeakTableを実装してみました。
2つのキーを利用できるConditionalWeakTableクラス - 何でもプログラミング

今回は３，４個と拡張しやすいように、複数個のキーを利用できるWeakTableを実装してみたいと思います。

Keysクラス

前回は2つのWeakReferenceプロパティをもっていましたが、今回はWeakReference配列を扱うよう変更しました。

EqualsとGetHashCodeを、WeakReferenceではなくTargetで行うところは変わっていません。

class Keys
{
    public WeakReference[] WeakKeys { get; }
    int _hash;

    public bool IsAlive()
    {
        return WeakKeys.All(x => x.IsAlive);
    }

    public Keys(object[] keys)
    {
        WeakKeys = keys.Select(x => new WeakReference(x)).ToArray();

        _hash = keys.Aggregate(365011897, (hash, key) => hash * -1521134295 + key.GetHashCode());
    }

    public override bool Equals(object obj)
    {
        var keys = obj as Keys;
        return keys != null
            && WeakKeys.Length == keys.WeakKeys.Length
            && WeakKeys.Zip(keys.WeakKeys, TargetEquals).All(x => x);
    }

    bool TargetEquals(WeakReference weakRef1, WeakReference weakRef2)
    {
        var ref1 = weakRef1.Target;
        var ref2 = weakRef2.Target;
        return ref1 != null
            && ref2 != null
            && Equals(ref1, ref2);
    }

    public override int GetHashCode()
    {
        return _hash;
    }
}


WeakTableクラス

まず、一般的はkey配列に対応したクラスを作成します。

class WeakTable<TValue>
{
    object _lockObj = new object();
    Dictionary<Keys, TValue> _dictionary = new Dictionary<Keys, TValue>();
    public WeakTable()
    {
        WeakEventManager<GCNotifier, EventArgs>.AddHandler(null, nameof(GCNotifier.Collected), 
            (s, e) => CheckReferences());
    }

    public void Add(object[] keys, TValue value)
    {
        lock (_lockObj)
        {
            _dictionary[new Keys(keys)] = value;
        }
    }

    public bool TryGetValue(object[] keys, ref TValue value)
    {
        lock (_lockObj)
        {
            var key = new Keys(keys);
            if (_dictionary.ContainsKey(key) == false)
                return false;
            value = _dictionary[key];
            return true;
        }
    }

    public void CheckReferences()
    {
        lock (_lockObj)
        {
            _dictionary = _dictionary
                .Where(x => x.Key.IsAlive())
                .ToDictionary(x => x.Key, x => x.Value);
        }
    }
}


これを利用して、例えば2つのキーのWeakTableは下記のように定義します。

class WeakTable<TKey1, TKey2, TValue>
    where TKey1 : class
    where TKey2 : class
{
    WeakTable<TValue> _table = new WeakTable<TValue>();

    public void Add(TKey1 key1, TKey2 key2, TValue value) =>
        _table.Add(new object[] { key1, key2 }, value);

    public bool TryGetValue(TKey1 key1, TKey2 key2, ref TValue value) =>
        _table.TryGetValue(new object[] { key1, key2 }, ref value);
}






2つのキーを利用できるConditionalWeakTableクラス

C#

.NETのConditionalWeakTableは、キーを弱参照で保持し、キーがGCされたときに自動でキーと値がRemoveされるようになっています。

しかし、キーとして複数の参照を持ち、参照のうちどれかがGCされたらRemoveを行うといった使い方はできません。

今回は複数の参照キーを指定できるConditionalWeakTableのようなものを実装してみたいと思います。

ConditionalWeakTableの中身

内部的にDependentHandleという構造体で管理しているようですが、privateのため利用できません。

Ephemeronというデータ構造を利用しているらしいですが、詳しくは追及していません。

２つのキーを弱参照で保持するクラス

Keyを弱参照で保持し、EqualsやGetHashCodeをもともとのKeyから算出するクラスを作成します。

class Keys
{
    public WeakReference<TKey1> Key1 { get; }
    public WeakReference<TKey2> Key2 { get; }
    int _hash;

    public bool IsAlive()
    {
        return Key1.TryGetTarget(out var key1)
            && Key2.TryGetTarget(out var key2);
    }

    public Keys(TKey1 key1, TKey2 key2)
    {
        Key1 = new WeakReference<TKey1>(key1);
        Key2 = new WeakReference<TKey2>(key2);

        // WeakReferenceではなく、もとのkeyからhash作成
        _hash = 365011897;
        _hash = _hash * -1521134295 + key1.GetHashCode();
        _hash = _hash * -1521134295 + key2.GetHashCode();
    }

    public override bool Equals(object obj)
    {
        // WeakReferenceの比較ではなく、中身の参照の比較
        var keys = obj as Keys;
        return keys != null
            && TargetEquals(Key1, keys.Key1)
            && TargetEquals(Key2, keys.Key2);
    }

    bool TargetEquals<T>(WeakReference<T> weakRef1, WeakReference<T> weakRef2)
        where T : class
    {
        return weakRef1.TryGetTarget(out var ref1)
            && weakRef2.TryGetTarget(out var ref2)
            && Equals(ref1, ref2);
    }

    public override int GetHashCode()
    {
        return _hash;
    }
}


WeakTableクラス

上記のKeysクラスを利用して、WeakTable本体を実装していきます。

class WeakTable<TKey1, TKey2, TValue>
    where TKey1 : class
    where TKey2 : class
{
    Dictionary<Keys, TValue> _dictionary = new Dictionary<Keys, TValue>();

    public void Add(TKey1 key1, TKey2 key2, TValue value)
    {
        _dictionary[new Keys(key1, key2)] = value;
    }

    public bool TryGetValue(TKey1 key1, TKey2 key2, ref TValue value)
    {
        var key = new Keys(key1, key2);
        if (_dictionary.ContainsKey(key) == false)
            return false;
        value = _dictionary[key];
        return true;
    }

    public void CheckReferences()
    {
        // 不必要なレコードを削除
        _dictionary = _dictionary
            .Where(x => x.Key.IsAlive())
            .ToDictionary(x => x.Key, x => x.Value);
    }
}


GCが行われたときにCheckReferencesを呼ぶ

現状のままでは、利用者がCheckReferencesを呼ばないと不必要なレコードが解放されないので、GC時に呼ばれるよう実装してみます。

GCの検知の詳細は下記記事を参照してみてください。
Garbage Collectionを検知する（C#） - 何でもプログラミング

今回はこのようなクラスを用意しました。

class GCNotifier
{
    public static event EventHandler Collected;

    static GCNotifier()
    {
        new DummyObject();
    }

    class DummyObject
    {
        ~DummyObject()
        {
            if (!AppDomain.CurrentDomain.IsFinalizingForUnload()
            && !Environment.HasShutdownStarted)
            {
                Collected?.Invoke(null, EventArgs.Empty);
                new DummyObject();
            }
        }
    }
}


GCNotifierを利用して、WeakTableに実装を追加します。

WeakEventManagerでCollectedにアタッチし、lock機構を追加しています。

class WeakTable<TKey1, TKey2, TValue>
    where TKey1 : class
    where TKey2 : class
{
    object _lockObj = new object();
    Dictionary<Keys, TValue> _dictionary = new Dictionary<Keys, TValue>();

    public WeakTable()
    {
        WeakEventManager<GCNotifier, EventArgs>.AddHandler(null, nameof(GCNotifier.Collected), 
            (s, e) => CheckReferences());
    }

    public void Add(TKey1 key1, TKey2 key2, TValue value)
    {
        lock (_lockObj)
        {
            _dictionary[new Keys(key1, key2)] = value;
        }
    }

    public bool TryGetValue(TKey1 key1, TKey2 key2, ref TValue value)
    {
        lock (_lockObj)
        {
            var key = new Keys(key1, key2);
            if (_dictionary.ContainsKey(key) == false)
                return false;
            value = _dictionary[key];
            return true;
        }
    }

    public void CheckReferences()
    {
        lock (_lockObj)
        {
            _dictionary = _dictionary
                .Where(x => x.Key.IsAlive())
                .ToDictionary(x => x.Key, x => x.Value);
        }
    }
}






Garbage Collectionを検知する（C#）

C#

通常のプログラミングにおいて、いつGCされたか気にする必要はありませんが、極まれにGCのタイミングで処理をしたい時があります（設計で回避するべきではありますが…）

今回はGCを検知する方法を調べてみました。

GC.WaitForFullGCComplete

GCクラスの関数を利用する方法です。

これを利用するには、App.configで下記が指定されている必要があります。（コンカレントGCを無効化）

<configuration>
  <runtime>
    <gcConcurrent enabled="false" />
  </runtime>
</configuration>


GCNotifierクラスを定義してみます。

GC.RegisterForFullGCNotificationで通知を有効化し、GC.WaitForFullGCApproachとGC.WaitForFullGCCompleteで通知を待ちます。

GC.RegisterForFullGCNotificationの引数は、大きいほど通知を受け取りやすくなるそうです。

static class GCNotifier
{
    public static event Action Collected;
    public static void Start()
    {
        GC.RegisterForFullGCNotification(10, 10);
        Task.Run(() =>
        {
            while (true)
            {
                GC.WaitForFullGCApproach();
                if (GC.WaitForFullGCComplete() == GCNotificationStatus.Succeeded)
                    Collected?.Invoke();
            }
        });
    }
}


利用は下記のようになります。

GCNotifier.Collected += () => Console.WriteLine("collected");
GCNotifier.Start();


Finalizeを利用

下記のものを簡略化してみます。
Jeffrey Richter: Receiving notifications when garbage collections occur – Microsoft Press blog

DummyクラスのFinalizeでコールバックを呼び、さらに新しいDummyオブジェクトを生成しています。

GCNotifierクラスは下記のようになり、利用方法はGC.WaitForFullGCCompleteの時と同じです。

static class GCNotifier
{
    public static event Action Collected;
    public static void Start()
    {
        new DummyObject();
    }
    class DummyObject
    {
        ~DummyObject()
        {
            if (!AppDomain.CurrentDomain.IsFinalizingForUnload()
            &&  !Environment.HasShutdownStarted)
            {
                Collected?.Invoke();
                new DummyObject();
            }
        }
    }
}


比較

GC.WaitForFullGCCompleteは、GCの後と前で処理を追加できるのが利点ですが、コンカレントGCが使えないのと、全てのGCで通知が来るわけではないのが欠点です。

Finalize利用は、全てのGCを検知できるのが利点ですが、GC前に処理が追加できないのが欠点です。





F#でメモ化（ConditionalWeakTable）

F#

プログラムの高速化のため、一度計算した値を再利用することはしばしばあります。

しかし結果を状態として保存する必要があるため、F#では少し扱いにくいです。

そこで、ある関数を結果を再利用する関数に変換する、memoize関数を定義してみたいと思います。

memoize関数

入力と結果をDictionaryに保存しておく関数に変換しています。

またConditionalWeakTableを利用することにより、selectKeyで寿命を共にするオブジェクトを指定できるようになっています。

let memoize (f : 'Args -> 'Result) (selectKey : 'Args -> 'Key) = 
    let table = ConditionalWeakTable<'Key, Dictionary<'Args, 'Result>>()
    fun (args : 'Args) ->
        let key = selectKey args
        let dictionary = table.GetOrCreateValue(key)
        if dictionary.ContainsKey(args) = false then
            dictionary.[args] <- f args
        dictionary.[args]

利用しやすいように、複数入力に対応した関数を用意しておきます。（寿命は第一引数と同じになります。）

let memoize1 (f : 'Arg -> 'Result) =
    memoize f id

let memoize2 (f : 'Arg1 -> 'Arg2 -> 'Result) =
    let tupled = memoize (fun (x1, x2) -> f x1 x2) fst
    fun x1 x2 -> tupled (x1, x2)

let memoize3 (f : 'Arg1 -> 'Arg2 -> 'Arg3 -> 'Result) =
    let tupled = memoize (fun (x1, x2, x3) -> f x1 x2 x3) (fun (x, _, _) -> x)
    fun x1 x2 x3 -> tupled (x1, x2, x3)


実際の利用

下記のようなNameレコードを例にしてみます。

フルネームを作成するfull関数は、二度目以降は結果を再利用しています。

また計算結果はNameオブジェクトと寿命が同じになります。

type Name =
    { First : string
      Last : string
    }
module Name =
    let full = memoize1 (fun name -> 
        printf "called\n" 
        name.First + name.Last)

let name = { First = "John"; Last = "Smith" }
let full = Name.full name // called
let full2 = Name.full name


入力に参照型がない場合

今回はConditionalWeakTableを利用したため、寿命を共にする参照型の入力が必要となります。

寿命がなく、入力と結果が共にサイズが小さいのであれば、Dictionaryで管理してもいいと思われます。





ネストしたレコードの更新（Functional lenses）

F#

下記記事にて、リフレクションを用いてネストしたレコードの更新を実装してみました。
ネストしたレコードの更新 (F#) - 何でもプログラミング

今回はFunctional lensesを利用して同様の内容を実装してみたいと思います。

Lens型定義

Lens型は対象オブジェクトから値を取得するGetと、値を更新した新しいオブジェクトを返すSetからなります。

type Lens<'Type, 'Field> =
    { Get : 'Type -> 'Field
      Set : 'Field -> 'Type -> 'Type
    }


Lens関数群定義

Lensを合成するcomposeが最も重要なものとなります。

module Lens =
    let create get set = 
        { Get = get; Set = set; }

    let set (lens : Lens<'a, 'b>) (value : 'b) (object : 'a) =
        lens.Set value object

    let update (lens : Lens<'a, 'b>) (f : 'b -> 'b) (object : 'a) =
        lens.Set (lens.Get object |> f) object

    let compose (lens1 : Lens<'a, 'b>) (lens2 : Lens<'b, 'c>) =
        { Get = lens1.Get >> lens2.Get
          Set = lens2.Set >> update lens1
        }

// composeを楽にする演算子
let inline (>-) (lens1 : Lens<'a, 'b>) (lens2 : Lens<'b, 'c>) =
    Lens.compose lens1 lens2


実際の利用

下記のレコードが定義されているとします。

type Container = { Value : int }
type Child = { Container : Container }
type Root = { Child : Child }

let record1 = { Child = { Container = { Value = 100 } } }

まずは各レコードのLensを定義します。

module Container =
    let value = Lens.create (fun x -> x.Value) (fun x y -> { y with Value = x })
module Child =
    let container = Lens.create (fun x -> x.Container) (fun x y -> { y with Container = x })
module Root = 
    let child = Lens.create (fun x -> x.Child) (fun x y -> { y with Child = x })

レコードの更新は、下記のように記述します。

現在値を参照する場合はLens.updateを利用します。

let record2 = record1 |> Lens.set (Root.child >- Child.container >- Container.value) 200


リフレクションと比較

リフレクションを利用したほうがLensの定義も必要なく簡潔に記述できます。

一方Lensを利用するとパフォーマンスを期待でき、リフレクションのない言語でも応用可能です。





Direct2D 独自Effectの作成（PixelShader利用）

C++ Direct2D

下記記事にて、独自のEffectを作成しました。
Direct2D 独自Effectの作成 - 何でもプログラミング

Effectの効果自体は、組み込みのID2D1OffsetTransformを利用していたので、今回は独自の効果（PixelShader）を定義してみたいと思います。

下図のように、青と赤を入れ替える効果を作成してみます。

f:id:any-programming:20171027153731p:plain

本記事は上記記事をベースとしていますので、特に説明のない部分は上記記事を参照してみてください。

シェーダコンパイラ

コンパイル済みのcsoを準備するために、今回は動的にコンパイルする関数を用意しました。

#include <d3dcompiler.h>
#pragma comment(lib, "d3dcompiler.lib")

ComPtr<ID3DBlob> Compile(std::string code, std::string target)
{
#ifdef _DEBUG
    UINT flags1 = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS;
#else
    UINT flags1 = D3DCOMPILE_OPTIMIZATION_LEVEL3 | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS;
#endif
    ComPtr<ID3DBlob> compiled, errorMessage;
    D3DCompile(
        code.c_str(),
        code.size(),
        NULL,
        NULL,
        D3D_COMPILE_STANDARD_FILE_INCLUDE,
        "main",
        target.c_str(),
        flags1,
        0,
        &compiled,
        &errorMessage);
    if (errorMessage)
        throw std::exception((char*)errorMessage->GetBufferPointer());
   
    return compiled;
}


独自Transformクラス

ID2D1DrawTransformを継承して独自のTransformを作成します。

関数がたくさんありますが、重要なのはSetDrawInfoでSetPixelShaderを呼んでいるところくらいです。

PixelShaderの作成自体はEffectクラスのInitializeで行います。

DEFINE_GUID(GUID_MyTransformPS, ....); // 独自のGUIDを定義。

class MyTransform : public ID2D1DrawTransform
{
public:
    MyTransform() : m_refCount(1) {}

    //　ここから5つの関数は、ID2D1DrawTransformに必要な関数です。
    IFACEMETHODIMP SetDrawInfo(_In_ ID2D1DrawInfo* pDrawInfo)
    {
        return pDrawInfo->SetPixelShader(GUID_MyTransformPS);
    }
    IFACEMETHODIMP_(UINT32) GetInputCount() const
    {
        return 1;
    }
    IFACEMETHODIMP MapInputRectsToOutputRect(
        _In_reads_(inputRectCount) const D2D1_RECT_L* pInputRects,
        _In_reads_(inputRectCount) const D2D1_RECT_L* pInputOpaqueSubRects,
        UINT32 inputRectCount,
        _Out_ D2D1_RECT_L* pOutputRect,
        _Out_ D2D1_RECT_L* pOutputOpaqueSubRect
    )
    {
        if (inputRectCount != 1)
            return E_INVALIDARG;

        *pOutputRect = pInputRects[0];
        *pOutputOpaqueSubRect = pInputOpaqueSubRects[0];

        return S_OK;
    }
    IFACEMETHODIMP MapOutputRectToInputRects(
        _In_ const D2D1_RECT_L* pOutputRect,
        _Out_writes_(inputRectCount) D2D1_RECT_L* pInputRects,
        UINT32 inputRectCount
    ) const
    {
        if (inputRectCount != 1)
            return E_INVALIDARG;

        pInputRects[0] = *pOutputRect;

        return S_OK;
    }
    IFACEMETHODIMP MapInvalidRect(
        UINT32 inputIndex,
        D2D1_RECT_L invalidInputRect,
        _Out_ D2D1_RECT_L* pInvalidOutputRect
    ) const
    {
        if (inputIndex != 0)
            return E_INVALIDARG;

        *pInvalidOutputRect = invalidInputRect;

        return S_OK;
    }

    // ここからはCOMに必要な関数です。特別な実装はありません。
    IFACEMETHODIMP_(ULONG) AddRef()
    {
        m_refCount++;
        return m_refCount;
    }
    IFACEMETHODIMP_(ULONG) Release()
    {
        m_refCount--;

        if (m_refCount == 0)
            delete this;

        return m_refCount;
    }
    IFACEMETHODIMP QueryInterface(_In_ REFIID riid, _Outptr_ void** ppOutput)
    {
        *ppOutput = nullptr;
        HRESULT hr = S_OK;

        if (riid == __uuidof(ID2D1DrawTransform))
            *ppOutput = (ID2D1DrawTransform*)this;
        else if (riid == __uuidof(ID2D1Transform))
            *ppOutput = (ID2D1Transform*)this;
        else if (riid == __uuidof(ID2D1TransformNode))
            *ppOutput = (ID2D1TransformNode*)this;
        else if (riid == __uuidof(IUnknown))
            *ppOutput = this;
        else
            hr = E_NOINTERFACE;

        if (*ppOutput != nullptr)
            AddRef();

        return hr;
    }
private:
    LONG m_refCount;
};


EffectクラスのInitialize

前回の記事で作成したMyEffectのInitialize関数を、下記で置き換えます。

PixelShaderの入力とTextureは下記の値がDirect2Dから渡されますので、独自の出力を作成します。（VertexShaderを独自で作成した場合は入力を変更できます。）

IFACEMETHODIMP Initialize(_In_ ID2D1EffectContext* pContextInternal, _In_ ID2D1TransformGraph* pTransformGraph)
{
    std::string psCode =
        "Texture2D InputTexture : register(t0);                           \n"
        "SamplerState InputSampler : register(s0);                        \n"
        "                                                                 \n"
        "float4 main(                                                     \n"
        "    float4 clipSpaceOutput : SV_POSITION,                        \n"
        "    float4 sceneSpaceOutput : SCENE_POSITION,                    \n"
        "    float4 texelSpaceInput0 : TEXCOORD0                          \n"
        ") : SV_Target                                                    \n"
        "{                                                                \n"
        "    float4 color = InputTexture.Sample(                          \n"
        "        InputSampler,                                            \n"
        "        texelSpaceInput0.xy                                      \n"
        "    );                                                           \n"
        "    return float4(color.b, color.g, color.r, color.a);           \n"
        "}                                                                \n"
        ;
    auto cso = Compile(psCode, "ps_4_0_level_9_1");
    auto hr = pContextInternal->LoadPixelShader(GUID_MyTransformPS, (BYTE*)cso->GetBufferPointer(), cso->GetBufferSize());
    if (FAILED(hr))
        return hr;

    ComPtr<MyTransform> transform;
    transform.Attach(new MyTransform());
    return pTransformGraph->SetSingleTransformNode(transform.Get());
}






Direct2D 独自Effectの作成

C++ Direct2D

下記の記事にて、Direct2Dの組み込みのEffectを利用してみました。
Direct2D Effectの利用 - 何でもプログラミング

今回は独自のEffectを作成してみたいと思います。

組み込みで用意されているOffset効果を利用して、描画結果をずらしてみます。

f:id:any-programming:20171031114928p:plain

本記事は上記記事をベースとしていますので、特に言及のない関数は上記記事を参照してみてください。

独自Effectクラス

ID2D1EffectImplを実装して独自のEffectクラスを作成します。

基本的にはInitialize関数とRegister関数の実装がメインとなります。

#include <initguid.h>
#include <d2d1effectauthor.h>

DEFINE_GUID(CLSID_MyEffect, ...); // 独自のGUIDを定義してください。

class MyEffect : public ID2D1EffectImpl
{
public:
    // ここから3つの関数は、ID2D1EffectImplに必要な関数です。
    IFACEMETHODIMP Initialize(_In_ ID2D1EffectContext* pContextInternal, _In_ ID2D1TransformGraph* pTransformGraph)
    {
        // Offsetを行う効果（組み込み）の作成＆登録
        ComPtr<ID2D1OffsetTransform> transform;
        auto hr = pContextInternal->CreateOffsetTransform(D2D1::Point2L(10, 10), &transform);
        if (SUCCEEDED(hr))
            hr = pTransformGraph->SetSingleTransformNode(transform.Get());

        return hr;
    }
    IFACEMETHODIMP PrepareForRender(D2D1_CHANGE_TYPE changeType)
    {
        return S_OK;
    }
    IFACEMETHODIMP SetGraph(_In_ ID2D1TransformGraph* pGraph)
    {
        return S_OK;
    }

    // ここから2つのstatic関数は、このクラスをID2D1Factory1に登録するのに利用します。（関数名は何でも大丈夫です。）
    static HRESULT Register(_In_ ID2D1Factory1* pFactory)
    {
        // 1画像を入力とするEffectの登録
        auto xml = 
            L"<?xml version = '1.0'?>                                                       "
            L"<Effect>                                                                      "
            L"    <Property name='DisplayName' type='string' value='MyEffect' />            "
            L"    <Property name='Author' type='string' value='Author' />                   "
            L"    <Property name='Category' type='string' value='Category' />               "
            L"    <Property name='Description' type='string' value='Description' />         "
            L"    <Inputs>                                                                  "
            L"        <Input name='Source' />                                               "
            L"    </Inputs>                                                                 "
            L"</Effect>                                                                     "
            ;
        return pFactory->RegisterEffectFromString(CLSID_MyEffect, xml, nullptr, 0, CreateEffect);
    }
    static HRESULT __stdcall CreateEffect(_Outptr_ IUnknown** ppEffectImpl)
    {
        *ppEffectImpl = (ID2D1EffectImpl*)(new MyEffect());

        if (*ppEffectImpl == nullptr)
            return E_OUTOFMEMORY;

        return S_OK;
    }

    // ここからはCOMに必要な関数です。特別な実装はありません。
    IFACEMETHODIMP_(ULONG) AddRef()
    {
        m_refCount++;
        return m_refCount;
    }
    IFACEMETHODIMP_(ULONG) Release()
    {
        m_refCount--;

        if (m_refCount == 0)
            delete this;

        return m_refCount;
    }
    IFACEMETHODIMP QueryInterface(_In_ REFIID riid, _Outptr_ void** ppOutput)
    {
        *ppOutput = nullptr;
        HRESULT hr = S_OK;

        if (riid == __uuidof(ID2D1EffectImpl))
            *ppOutput = (ID2D1EffectImpl*)this;
        else if (riid == __uuidof(IUnknown))
            *ppOutput = this;
        else
            hr = E_NOINTERFACE;

        if (*ppOutput != nullptr)
            AddRef();

        return hr;
    }
private:
    LONG m_refCount;
    MyEffect() : m_refCount(1) {}
};


Effectの作成

独自のGUIDでCreateEffectします。

ComPtr<ID2D1Effect> CreateEffect(ID2D1DeviceContext* context)
{
    ComPtr<ID2D1Effect> effect;
    AssertHR(context->CreateEffect(CLSID_MyEffect, &effect));

    return effect;
}


main関数

作成したEffectの登録が追記されています。

ID2D1Factory1を作成した時に同時に登録したほうが簡潔だと思われます。

int main()
{
    HWND hwnd = CreateHWND(WndProc);

    auto dxgiDevice = CreateDXGIDevice();
    g_context = CreateD2DContext(dxgiDevice.Get());
    g_swapChain = CreateSwapChain(dxgiDevice.Get(), hwnd);
    g_backBuffer = CreateBackBufferBitmap(g_context.Get(), g_swapChain.Get());
    g_offscreenBuffer = CreateTargetBitmap(g_context.Get(), g_backBuffer->GetPixelSize());

    ComPtr<ID2D1Factory> factory;
    g_context->GetFactory(&factory);
    ComPtr<ID2D1Factory1> factory1;
    AssertHR(factory.As(&factory1));
    AssertHR(MyEffect::Register(factory1.Get()));

    g_effect = CreateEffect(g_context.Get());

    Run(hwnd);

    return 0;
}