C#でDirectX11 SlimDXチュートリアルその13 ジオメトリシェーダー

 今回のテーマはジオメトリシェーダーです。
ジオメトリシェーダーはポリゴンを分割します。



↓




上はジオメトリシェーダーなし、下はジオメトリシェーダー有りです。
上と下の頂点バッファは同じです。
違うのはHLSLのエフェクトファイルだけ。
頂点バッファの中には三角形１つ分の頂点しか入っていないのですが、ジオメトリシェーダーで分割されて２つになるのです。

こう言うことをして何が嬉しいかというと、例えば荒い3Dモデルを面の細やかなモデルに変換することが出来ます。
だったら最初から細かいモデルを用意しておけという感じですが、実際には遠くから見たときに細かいモデルを用意するのは無駄です。
近くにあるときは細かいモデル、遠くにあるときには荒いモデル、その中間ならそこそこのモデルが欲しいのです。
これら全部を用意するという方法もありますが（面倒な上容量をけっこう食いそうです）、一度に全部の距離に柔軟に対応できればそれに越したことはありません。

そういうニーズにジオメトリシェーダーは答えることが出来ます。
最初に荒いモデルを用意しておいて、必要に応じて適切な細かさのモデルを作ればいいのです。
ジオメトリシェーダーでポリゴンを分割すればそれだけ細かいモデルになります。
もちろんただ分割するだけでは意味が無いので、予めテクスチャに描いた細かい凹凸情報でポリゴンの高低を変えればいいというわけです。

---

ジオメトリシェーダー（HLSL）

今回ジオメトリシェーダーを使う上で必要なのはHLSL側の変更だけです。
C#側は前回のワイヤーフレームを描くコードから変える必要はありません。
今回、HLSLのジオメトリシェーダーは次のような構文となります：

[maxvertexcount(VertexCount)]
void ShaderName(
    triangle DataType vertices[3],
    inout TriangleStream<DataType> resultStream
    )

maxvertexcountはC#の属性のようなものですね。
ジオメトリシェーダーによって造られる頂点の最大数を指定します。
作られるというと語弊がありそうです。
３の頂点から６つの頂点を作るとき（１つの三角形を分割して２つの三角形にするとき）、VertexCountは６です。

 DataTypeは頂点の構造体です。

TriangleStream<T>はジオメトリシェーダーで作成される三角形を格納します。
今回は三角形なのでTriangleStreamなのですが、他にもPointStreamやLineStreamなどの仲間もあります。
TriangleStreamには、ジオメトリシェーダーで作成する三角形を格納するためのメソッドが付いています。

class TriangleStream<T>
{
      void Append(T vertex);
      void RestartStrip();
}

TriangleStream<T>.Append()メソッドは頂点を追加します。
TriangleStream<T>.RestartStrip()メソッドは、Appendで３つの頂点を追加した後に呼びます。

---

コード

Program.cs

using SlimDX.Direct3D11;
using SlimDX.DXGI;
using SlimDX.D3DCompiler;
 
class Program
{
    static void Main()
    {
        using (Game game = new MyGame())
        {
            game.Run();
        }
    }
}
 
class MyGame : Game
{
    Effect effect;
    InputLayout vertexLayout;
    Buffer vertexBuffer;
 
    protected override void Draw()
    {
        GraphicsDevice.ImmediateContext.ClearRenderTargetView(
            RenderTarget,
            new SlimDX.Color4(1, 0, 0, 1)
            );
 
        initTriangleInputAssembler();
        drawTriangle();
        
        SwapChain.Present(0, PresentFlags.None);
    }
 
    private void drawTriangle()
    {
        effect.GetTechniqueByIndex(0).GetPassByIndex(0).Apply(GraphicsDevice.ImmediateContext);
        GraphicsDevice.ImmediateContext.Draw(3, 0);
    }
 
    private void initTriangleInputAssembler()
    {
        GraphicsDevice.ImmediateContext.InputAssembler.InputLayout = vertexLayout;
        GraphicsDevice.ImmediateContext.InputAssembler.SetVertexBuffers(
            0,
            new VertexBufferBinding(vertexBuffer, sizeof(float) * 3, 0)
            );
        GraphicsDevice.ImmediateContext.InputAssembler.PrimitiveTopology
            = PrimitiveTopology.TriangleList;
    }
 
    protected override void LoadContent()
    {
        initEffect();
        initVertexLayout();
        initVertexBuffer();
        initWireframeRasterizerState();
    }
 
    private void initEffect()
    {
        using (ShaderBytecode shaderBytecode = ShaderBytecode.CompileFromFile(
            "myEffect.fx", "fx_5_0",
            ShaderFlags.None,
            EffectFlags.None
            ))
        {
            effect = new Effect(GraphicsDevice, shaderBytecode);
        }
    }
 
    private void initVertexLayout()
    {
        vertexLayout = new InputLayout(
            GraphicsDevice,
            effect.GetTechniqueByIndex(0).GetPassByIndex(0).Description.Signature,
            new[] { 
                    new InputElement
                    {
                        SemanticName = "SV_Position",
                        Format = Format.R32G32B32_Float
                    }
                }
            );
    }
 
    private void initVertexBuffer()
    {
        vertexBuffer = MyDirectXHelper.CreateVertexBuffer(
            GraphicsDevice,
            new[] {
                new SlimDX.Vector3(0, 0.5f, 0),
                new SlimDX.Vector3(0.5f, 0, 0),
                new SlimDX.Vector3(-0.5f, 0, 0),
            });
    }
 
    private void initWireframeRasterizerState()
    {
        var desc = new RasterizerStateDescription
        {
            CullMode = CullMode.Back,
            FillMode = FillMode.Wireframe,
        };
 
        GraphicsDevice.ImmediateContext.Rasterizer.State
            = RasterizerState.FromDescription(
                GraphicsDevice,
                desc
            );
    }
 
    protected override void UnloadContent()
    {
        GraphicsDevice.ImmediateContext.Rasterizer.State.Dispose();
        effect.Dispose();
        vertexLayout.Dispose();
        vertexBuffer.Dispose();
    }
}
 
class Game : System.Windows.Forms.Form
{
    public SlimDX.Direct3D11.Device GraphicsDevice;
    public SwapChain SwapChain;
    public RenderTargetView RenderTarget;
 
 
    public void Run()
    {
        initDevice();
        SlimDX.Windows.MessagePump.Run(this, Draw);
        disposeDevice();
    }
 
    private void initDevice()
    {
        MyDirectXHelper.CreateDeviceAndSwapChain(
            this, out GraphicsDevice, out SwapChain
            );
 
        initRenderTarget();
        initViewport();
 
        LoadContent();
    }
 
    private void initRenderTarget()
    {
        using (Texture2D backBuffer
            = SlimDX.Direct3D11.Resource.FromSwapChain<Texture2D>(SwapChain, 0)
            )
        {
            RenderTarget = new RenderTargetView(GraphicsDevice, backBuffer);
            GraphicsDevice.ImmediateContext.OutputMerger.SetTargets(RenderTarget);
        }
    }
 
    private void initViewport()
    {
        GraphicsDevice.ImmediateContext.Rasterizer.SetViewports(
            new Viewport
            {
                Width = ClientSize.Width,
                Height = ClientSize.Height,
            }
            );
    }
 
    private void disposeDevice()
    {
        UnloadContent();
        RenderTarget.Dispose();
        GraphicsDevice.Dispose();
        SwapChain.Dispose();
    }
 
    protected virtual void Draw() { }
    protected virtual void LoadContent() { }
    protected virtual void UnloadContent() { }
}
 
class MyDirectXHelper
{
    public static void CreateDeviceAndSwapChain(
        System.Windows.Forms.Form form,
        out SlimDX.Direct3D11.Device device,
        out SlimDX.DXGI.SwapChain swapChain
        )
    {
        SlimDX.Direct3D11.Device.CreateWithSwapChain(
            DriverType.Hardware,
            DeviceCreationFlags.None,
            new SwapChainDescription
            {
                BufferCount = 1,
                OutputHandle = form.Handle,
                IsWindowed = true,
                SampleDescription = new SampleDescription
                {
                    Count = 1,
                    Quality = 0
                },
                ModeDescription = new ModeDescription
                {
                    Width = form.ClientSize.Width,
                    Height = form.ClientSize.Height,
                    RefreshRate = new SlimDX.Rational(60, 1),
                    Format = Format.R8G8B8A8_UNorm
                },
                Usage = Usage.RenderTargetOutput
            },
            out device,
            out swapChain
            );
    }
 
    public static Buffer CreateVertexBuffer(
        SlimDX.Direct3D11.Device graphicsDevice,
        System.Array vertices
        )
    {
        using (SlimDX.DataStream vertexStream 
            = new SlimDX.DataStream(vertices, true, true))
        {
            return new Buffer(
                graphicsDevice,
                vertexStream,
                new BufferDescription
                {
                    SizeInBytes= (int)vertexStream.Length,
                    BindFlags = BindFlags.VertexBuffer,
                }
                );
        }
    }
}
 
 

myEffect.fx

struct VertexPosition
{
	float4 Position : SV_Position;
};

VertexPosition MyVertexShader(VertexPosition position)
{
    return position;
}

VertexPosition Average(VertexPosition a, VertexPosition b)
{
	VertexPosition result = { (a.Position + b.Position) / 2};
	return result;
}

[maxvertexcount(6)]
void MyGeometryShader(
	triangle VertexPosition vertices[3],
	inout TriangleStream<VertexPosition> resultStream
	)
{
	resultStream.Append(vertices[0]);
	resultStream.Append(vertices[1]);
	resultStream.Append(Average(vertices[1], vertices[2]));
	resultStream.RestartStrip();

	resultStream.Append(vertices[0]);
	resultStream.Append(Average(vertices[1], vertices[2]));
	resultStream.Append(vertices[2]);
	resultStream.RestartStrip();
}

float4 MyPixelShader() : SV_Target
{
    return float4(1, 1, 1, 1);
}

technique10 MyTechnique
{
	pass MyPass
	{
		SetVertexShader( CompileShader( vs_5_0, MyVertexShader() ) );
		SetGeometryShader(CompileShader(gs_5_0, MyGeometryShader()));
		SetPixelShader( CompileShader( ps_5_0, MyPixelShader() ) );
	}
}

実行結果はこうなります。



このプログラムはまず三角形を一つだけ用意しています。

 

それを真ん中で２等分しているのです。

 

今回は単純化のため縦に２等分しましたが、実際には

　△
△▽△
というような分割方法を使うべきでしょう。