忍者ブログ

Memeplexes

プログラミング、3DCGとその他いろいろについて

[PR]

×

[PR]上記の広告は3ヶ月以上新規記事投稿のないブログに表示されています。新しい記事を書く事で広告が消えます。

C#でDirectX11 SlimDXチュートリアルその14 定数バッファー

定数バッファー

ずいぶん前回と間があきましたが、SlimDXについてメモしておこうと思います。
今回は、定数バッファーです。

定数バッファーとは、CPUからGPUへのデータ転送をまとめるデータの固まりです。
どういうことでしょう？
3DCGを描くときのことを考えてください。
CPUからGPUへ、モデルの回転やライトの位置など、情報を転送しなければいけません。
そしてその転送にはオーバーヘッドがかかります。
これをいちいち別々に転送していては、オーバーヘッドが膨らむばかり。
そこでこれらを一つにまとめて一気にGPUへ転送しようということです。
そのひとつにまとめられたものを、コンスタントバッファーといいます。

定数バッファーの生成

定数バッファーは、Bufferクラスのインスタンスです。
頂点バッファやインデックスバッファと同じですね。
ただ使い方が違うのです。
そして初期化の方法も。
初期化するときには、BindFlagsにBindFlags.ConstantBufferを指定します。

    private void initConstantBuffer()
    {
        constantBuffer = new Buffer(
            GraphicsDevice,
            new BufferDescription
            {   
                //なぜかsizeof(float) * 4以上でないと例外をスローする。
                SizeInBytes = sizeof(float) * 4,  
                BindFlags = BindFlags.ConstantBuffer,
            }
            ); 
    }

ここで気をつけて欲しいのは、SizeInBytesにsizeof(float) * 4より小さな値を代入するとマズイ事になるかもしれないということです。
大してデータを使わないからと言って、もし小さな値を代入すれば、Direct3D11Exceptionをスローすることがあるので注意してください。
少なくとも私の環境ではそうでした。
すべての環境でそうであるかはわかりません。
しかし、Vector4より小さな値が禁止されているというのはおかしな話ではないでしょう。

定数バッファーの更新（CPUからGPUへのデータ転送）

定数バッファーはCPUからGPUへのデータ転送をまとめるためのバッファです。
するとデータ転送をする方法があるはずなのですが、Bufferそのものにはそんなメソッドはありません。
データ転送には、DeviceContext.UpdateSubresourceメソッドを使います。

public void UpdateSubresource(DataBox source, Resource resource, int subresource);

sourceは、GPUに転送するデータです。
resourceは転送先のGPUに存在するリソース。
subresourceはサブリソース番号です。

定数バッファをエフェクトにセット

更新した定数バッファも、少なくとも一度はエフェクトにセットしなければ描画に反映されません。
定数バッファのエフェクトへのセットには次のようにします：
 
        effect.GetConstantBufferByName("myConstantBuffer").ConstantBuffer = constantBuffer;

effectはセットするエフェクト。
"myConstantbuffer"は、HLSLファイル中の定数バッファの名前です。
constantBufferはセットする定数バッファです。

サンプルコード

Program.cs
using SlimDX;
using SlimDX.Direct3D11;
using SlimDX.DXGI;
using SlimDX.D3DCompiler;

class Program
{
    static void Main()
    {
        using (Game game = new MyGame())
        {
            game.Run();
        }
    }
}

struct MyConstantBuffer
{
    public float OffsetX;
    public float OffsetY;
}

class MyGame : Game
{
    Effect effect;
    InputLayout vertexLayout;
    Buffer vertexBuffer;
    Buffer constantBuffer;

    protected override void Draw()
    {
        GraphicsDevice.ImmediateContext.ClearRenderTargetView(
            RenderTarget,
            new Color4(1, 0, 0, 1)
            );

        updateConstantBuffer();
        initTriangleInputAssembler();
        drawTriangle();
        
        SwapChain.Present(0, PresentFlags.None);
    }

    private void updateConstantBuffer()
    {
        double time = System.Environment.TickCount / 500d;
        MyConstantBuffer myConstantBuffer = new MyConstantBuffer
        {
            OffsetX = (float)System.Math.Sin(time) * 0.4f,
            OffsetY = (float)System.Math.Sin(time) * 0.8f
        };
        GraphicsDevice.ImmediateContext.UpdateSubresource(
            new DataBox(0, 0, new DataStream(new[] { myConstantBuffer }, true, true)),
            constantBuffer,
            0
            );
        effect.GetConstantBufferByName("myConstantBuffer").ConstantBuffer = constantBuffer;
    }

    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;
    }

    private void drawTriangle()
    {
        effect.GetTechniqueByIndex(0).GetPassByIndex(0).Apply(GraphicsDevice.ImmediateContext);
        GraphicsDevice.ImmediateContext.Draw(3, 0);
    }


    protected override void LoadContent()
    {
        initEffect();
        initVertexLayout();
        initVertexBuffer();
        initConstantBuffer();
    }

    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 initConstantBuffer()
    {
        constantBuffer = new Buffer(
            GraphicsDevice,
            new BufferDescription
            {   
                //なぜかsizeof(float) * 4以上でないと例外をスローする。
                SizeInBytes = sizeof(float) * 4,  
                BindFlags = BindFlags.ConstantBuffer,
            }
            ); 
    }

    protected override void UnloadContent()
    {
        effect.Dispose();
        vertexLayout.Dispose();
        vertexBuffer.Dispose();
        constantBuffer.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
cbuffer myConstantBuffer
{
	float OffsetX;
	float OffsetY;
}

float4 MyVertexShader(float4 position : SV_Position) : SV_Position
{
    return position + float4(OffsetX, OffsetY, 0, 0);
}

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

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

このプログラムは、三角形を斜めに平行移動します。
 
Tutorial14ConstantBufferTranslatingTriangle01.png
Tutorial14ConstantBufferTranslatingTriangle02.png

つまり定数バッファなど使わなくても出来るプログラムです。
というか大抵のことは定数バッファなど使わなくても出来るのです。

大切なのはパフォーマンスです。
変更点があるとすれば内部です。

このプログラムでは、三角形の平行移動に使うパラメーターを、定数バッファでまとめているのです。
平行移動に使うパラメーターは２つ有ります。
X方向のオフセットを表すOffsetX(float)と、Y方向のオフセットを表すOffsetY(float)です。
もし定数バッファを使わなければ、２回、CPUからGPUにデータを転送することになります。
しかしここでは定数バッファを使ってこの２つを一つにまとめているので、CPUからGPUへのデータ転送は、毎フレーム一回だけですんでいます。









拍手[1回]

PR