忍者ブログ

Memeplexes

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

C#でDirectX11 SlimDXチュートリアルその09 深度バッファ

 前回のプログラムはとんだ欠陥プログラムでした。
近くのものが遠くのものの影に隠れて見えないのです。

withoutDepthBuffer.jpg

ここに表示されている２つの三角形は、元は同じ大きさの三角形でした。
右の三角形は遠くにあり、左の三角形は近くにあるので、大きさが違ってみえるのです。
普通このような状況では、右の三角形が左の三角形に隠れます。
近くにあるものが遠くのものを隠す。
当然です。

しかしここでは逆になっています。
遠くのもののせいで近くのものが見れなくなっているのです。
これはおかしいですね。

なぜこうなったのかというと、深度バッファというものを使っていないからです。
深度バッファを使わなければ、物体は単に描かれた順番によって前後関係が決まります。
後から描いたものが、すでに描かれていたものを隠すのです。
ふつうの2Dの描画と同じです。
だから上の図のようなおかしなことになっていたのですね。

今回は、深度バッファを使ってこの問題を解決します。

深度バッファ

深度バッファは、画面に存在するピクセルごとにfloat値がひとつ存在していて、このピクセルに描くべきかそうでないかを判定してくれます。
もしそのピクセルに、すでに手前の物が描かれている場合、そこには何も描きません。
逆にそのピクセルにまだ、これから描こうとしているピクセルよりも奥にしか物が描かれていないのなら、ピクセルを描き、深度バッファのfloatを更新します。
この仕組によって物の前後関係を正しく描くのです。

深度バッファを扱うには、SlimDX.Direct3D11.DepthStencilViewクラスを使います。

public class DepthStencilView : ResourceView

以前説明したとおり、~~Viewというのはリソースの使われ方を表すクラスです。
リソース自体は別に作る必要があります。
そしてそのリソースをコンストラクタ引数に取るのです。

public DepthStencilView(Device device, Resource resource);

deviceはViewをつくるデバイス。
resourceは作成するViewがその役割を指定するリソースです。このリソースは深度ステンシルバッファとして扱われます。（ここではステンシルという言葉は無視してください。ステンシルもピクセルごとに存在し、そのピクセルに描画するか否かを判定するのですが、今回は使いません）

resourceにはTexture2Dのインスタンスを使いましょう。
Texture2Dのインスタンスはここではコンストラクタから得ます。

public Texture2D(Device device, Texture2DDescription description);

deviceはテクスチャを作るデバイス。
descriptionはTexture2Dの設定を表すオブジェクトで、このメンバが真のコンストラクタ引数です。

SlimDX.Direct3D11.Texture2DDescription構造体には１０個の設定可能なプロパティが存在します。
このテクスチャのサイズはウィンドウのクライアント領域と同じで、BindFlagsにはBindFlags.DepthStencilを設定します。

DepthStencilViewをデバイスにセットするには、OutputMergerWrapper.SetTargetsメソッドを使います。
これはレンダーターゲットと同時にセットします。

public void SetTargets(DepthStencilView depthStencilView, RenderTargetView renderTargetView);

depthStencilViewはセットする深度ステンシルのビューです。
renderTargetViewはセットするレンダーターゲットのビューです。

今回は深度バッファを使うので、Viewport.MaxZプロパティを設定する必要があります。
これは普通１です。

コード

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

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

    protected override void Draw()
    {
        GraphicsDevice.ImmediateContext.ClearRenderTargetView(
            RenderTarget,
            new SlimDX.Color4(1, 0.39f, 0.58f, 0.93f)
            );
        GraphicsDevice.ImmediateContext.ClearDepthStencilView(
            DepthStencil,
            DepthStencilClearFlags.Depth,
            1,
            0
            );

        updateCamera();
        initTriangleInputAssembler();
        drawMovingTriangles();

        SwapChain.Present(0, PresentFlags.None);
    }

    private void updateCamera()
    {
        Matrix view = Matrix.LookAtRH(
            new Vector3(0, 0, 1),
            new Vector3(),
            new Vector3(0, 1, 0)
            );
        Matrix projection = Matrix.PerspectiveFovRH(
            (float)System.Math.PI / 2,
            ClientSize.Width / ClientSize.Height,
            0.1f, 1000
            );
        effect.GetVariableByName("ViewProjection")
            .AsMatrix().SetMatrix(view * projection);

    }

    private void initTriangleInputAssembler()
    {
        GraphicsDevice.ImmediateContext.InputAssembler.InputLayout = vertexLayout;
        GraphicsDevice.ImmediateContext.InputAssembler.SetVertexBuffers(
            0,
            new VertexBufferBinding(vertexBuffer, VertexPositionColor.SizeInBytes, 0)
            );
        GraphicsDevice.ImmediateContext.InputAssembler.PrimitiveTopology
            = PrimitiveTopology.TriangleList;
    }

    private void drawMovingTriangles()
    {
        double time = System.Environment.TickCount / 500d;

        effect.GetVariableByName("World").AsMatrix().SetMatrix(
            Matrix.Translation(
            (float)System.Math.Cos(time), 0, -1 + (float)System.Math.Sin(time)
            ));
        drawTriangle();

        effect.GetVariableByName("World").AsMatrix().SetMatrix(
            Matrix.Translation(
            -(float)System.Math.Cos(time), 0, -1 + -(float)System.Math.Sin(time)
            ));
        drawTriangle();
    }

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

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

    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,
            VertexPositionColor.VertexElements
            );
    }

    private void initVertexBuffer()
    {
        vertexBuffer = MyDirectXHelper.CreateVertexBuffer(
            GraphicsDevice,
            new[] {
                new VertexPositionColor
                {
                    Position = new Vector3(0, 0.5f, 0),
                    Color = new Vector3(1, 1, 1) 
                },
                new VertexPositionColor
                {
                    Position = new Vector3(0.5f, 0, 0),
                    Color = new Vector3(0, 0, 1)
                },
                new VertexPositionColor
                {
                    Position = new Vector3(-0.5f, 0, 0),
                    Color = new Vector3(1, 0, 0)
                },
            });
    }

    protected override void UnloadContent()
    {
        effect.Dispose();
        vertexLayout.Dispose();
        vertexBuffer.Dispose();
    }
}

struct VertexPositionColor
{
    public Vector3 Position;
    public Vector3 Color;

    public static readonly InputElement[] VertexElements = new[]
    {
        new InputElement
        {
            SemanticName = "SV_Position",
            Format = Format.R32G32B32_Float
        },
        new InputElement
        {
            SemanticName = "COLOR",
            Format = Format.R32G32B32_Float,
            AlignedByteOffset = InputElement.AppendAligned//自動的にオフセット決定
        }
    };

    public static int SizeInBytes
    {
        get
        {
            return System.Runtime.InteropServices.
                Marshal.SizeOf(typeof(VertexPositionColor));
        }
    }
}

class Game : System.Windows.Forms.Form
{
    public SlimDX.Direct3D11.Device GraphicsDevice;
    public SwapChain SwapChain;
    public RenderTargetView RenderTarget;
    public DepthStencilView DepthStencil;

    public void Run()
    {
        initDevice();
        SlimDX.Windows.MessagePump.Run(this, Draw);
        disposeDevice();
    }

    private void initDevice()
    {
        MyDirectXHelper.CreateDeviceAndSwapChain(
            this, out GraphicsDevice, out SwapChain
            );

        initRenderTarget();
        initDepthStencil();
        GraphicsDevice.ImmediateContext.
            OutputMerger.SetTargets(DepthStencil, RenderTarget);
        initViewport();

        LoadContent();
    }

    private void initRenderTarget()
    {
        using (Texture2D backBuffer
            = SlimDX.Direct3D11.Resource.FromSwapChain<Texture2D>(SwapChain, 0)
            )
        {
            RenderTarget = new RenderTargetView(GraphicsDevice, backBuffer);
        }
    }

    private void initDepthStencil()
    {
        Texture2DDescription depthBufferDesc = new Texture2DDescription
        {
            ArraySize = 1,
            BindFlags = BindFlags.DepthStencil,
            Format = Format.D32_Float,
            Width = ClientSize.Width,
            Height = ClientSize.Height,
            MipLevels = 1,
            SampleDescription = new SampleDescription(1, 0)
        };

        using (Texture2D depthBuffer = new Texture2D(GraphicsDevice, depthBufferDesc))
        {
            DepthStencil = new DepthStencilView(GraphicsDevice, depthBuffer);
        }
    }

    private void initViewport()
    {
        GraphicsDevice.ImmediateContext.Rasterizer.SetViewports(
            new Viewport
            {
                Width = ClientSize.Width,
                Height = ClientSize.Height,
                MaxZ = 1
            }
            );
    }

    private void disposeDevice()
    {
        UnloadContent();
        DepthStencil.Dispose();
        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
matrix World;
matrix ViewProjection;
 
struct VertexPositionColor
{
	float4 Position : SV_Position;
	float4 Color : COLOR;
};
 
VertexPositionColor MyVertexShader(VertexPositionColor input)
{
    VertexPositionColor output = input;
    output.Position = mul(output.Position, World);
    output.Position = mul(output.Position, ViewProjection);
    return output;
}
 
float4 MyPixelShader(VertexPositionColor input) : SV_Target
{
    return input.Color;
}
 
 
technique10 MyTechnique
{
	pass MyPass
	{
		SetVertexShader( CompileShader( vs_5_0, MyVertexShader() ) );
		SetPixelShader( CompileShader( ps_5_0, MyPixelShader() ) );
	}
}

このプログラムは前回のプログラムに加え、深度ステンシルバッファをデバイスにセットしています。
前回は２つの連星のような三角形を描いていたのですが、前後関係正しく描画されない時がありました。
今回は深度バッファのおかげでそのようなことはありません。
描かれる三角形の前後関係が常に正しくなります。
冒頭のようなおかしな事にはならなくなるのです。






拍手[0回]

PR