環境

Unity2022.2.14f1

概要

NaiveSurfaceNetsを使用して、SDFの3DTextureのポリゴン化を行ってみました。

参考のqiitaのコードをComputeShaderで行ってみた感じです。

マイフレーム実行しても、実用的な速度で処理されているようです。

SDFは参考のGithubにある「SignedDistance.vf」を使用させていただきました。

.vfファイルはVisualEffectGraphにインポータが付属しています。

VectorFieldImporter.csの中のtexture.Apply()の2番目の引数をfalseにしてCPUで読み取れるようにしています。

※ComputeShaderで直接3DTextureを参照するなら必要ない。

また設定でOutput Formatをfloatにしています。

コード

using UnityEngine;

public unsafe class TestGpuNaiveSurfaceNets : MonoBehaviour
{
    [SerializeField] private Texture3D _sdfTexture = null;
    [SerializeField] private ComputeShader _computeShader = null;
    [SerializeField] private Material _material = null;
    private GraphicsBuffer _sdfVoxelBuffer = null;
    private GraphicsBuffer _vertexIdBuffer = null;
    private GraphicsBuffer _vertexBuffer = null;
    private GraphicsBuffer _indexBuffer = null;
    private GraphicsBuffer _neighborBuffer = null;
    private GraphicsBuffer _edgeBuffer = null;
    private GraphicsBuffer _indirectArgBuffer = null;
    private Bounds _bounds;
    private int _klVertices = -1;
    private int _klIndices = -1;
    private int _klIndirectArgs = -1;
    private Vector3Int _tgVertices;
    private Vector3Int _tgIndices;
    private static int _spSdfVoxelSize = Shader.PropertyToID("SdfVoxelSize");
    private static int _spSdfVoxels = Shader.PropertyToID("SdfVoxels");
    private static int _spVertexIds = Shader.PropertyToID("VertexIds");
    private static int _spVertices = Shader.PropertyToID("Vertices");
    private static int _spIndices = Shader.PropertyToID("Indices");
    private static int _spNeighbors = Shader.PropertyToID("Neighbors");
    private static int _spEdges = Shader.PropertyToID("Edges");
    private static int _spIndirectArgs = Shader.PropertyToID("IndirectArgs");
    private void Start()
    {
        if(_sdfTexture.width != _sdfTexture.height || _sdfTexture.width != _sdfTexture.depth)
        {
            Debug.LogError("sdfTexture Size");
            return;
        }
        var size = _sdfTexture.width;
        var texels = _sdfTexture.GetPixelData<float>(0);

        _sdfVoxelBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, size * size * size, sizeof(float));
        _sdfVoxelBuffer.SetData(texels);
        _vertexIdBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, size * size * size, sizeof(int));
        _vertexBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured | GraphicsBuffer.Target.Counter, size * size * size, sizeof(Vector3));
        _vertexBuffer.SetCounterValue(0);
        _indexBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured /*| GraphicsBuffer.Target.Index*/ | GraphicsBuffer.Target.Counter, size * size * size * 18, sizeof(int));
        _indexBuffer.SetCounterValue(0);
        _indirectArgBuffer = new GraphicsBuffer(GraphicsBuffer.Target.IndirectArguments, 4, sizeof(uint));
        _indirectArgBuffer.SetData(new uint[4]{0, 1, 0, 0});

        // 立方体上の頂点の番号の決め方
        var Neighbors = new Vector3Int[]
        {
            new Vector3Int( 0, 0, 0 ),
            new Vector3Int( 1, 0, 0 ),
            new Vector3Int( 1, 0, 1 ),
            new Vector3Int( 0, 0, 1 ),
            new Vector3Int( 0, 1, 0 ),
            new Vector3Int( 1, 1, 0 ),
            new Vector3Int( 1, 1, 1 ),
            new Vector3Int( 0, 1, 1 ),
        };
        _neighborBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, Neighbors.Length, sizeof(Vector3Int));
        _neighborBuffer.SetData(Neighbors);
        // 辺のつながり方
        var Edges = new Vector2Int[]
        {
            new Vector2Int( 0, 1 ),
            new Vector2Int( 1, 2 ),
            new Vector2Int( 2, 3 ),
            new Vector2Int( 3, 0 ),
            new Vector2Int( 4, 5 ),
            new Vector2Int( 5, 6 ),
            new Vector2Int( 6, 7 ),
            new Vector2Int( 7, 4 ),
            new Vector2Int( 0, 4 ),
            new Vector2Int( 1, 5 ),
            new Vector2Int( 2, 6 ),
            new Vector2Int( 3, 7 ),
        };
        _edgeBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, Edges.Length, sizeof(Vector2Int));
        _edgeBuffer.SetData(Edges);

        float bsize = size;// * 10.0f;
        _bounds = new Bounds(new Vector3(bsize * 0.5f, bsize * 0.5f, bsize * 0.5f), new Vector3(bsize, bsize, bsize));
        _material.SetBuffer(_spVertices, _vertexBuffer);
        _material.SetBuffer(_spIndices, _indexBuffer);

        uint numThreadX, numThreadY, numThreadZ;
        _computeShader.SetInt(_spSdfVoxelSize, size);

        // Vertices
        _klVertices = _computeShader.FindKernel("GenerateVertices");
        _computeShader.SetBuffer(_klVertices, _spSdfVoxels, _sdfVoxelBuffer);
        _computeShader.SetBuffer(_klVertices, _spVertexIds, _vertexIdBuffer);
        _computeShader.SetBuffer(_klVertices, _spVertices, _vertexBuffer);
        _computeShader.SetBuffer(_klVertices, _spEdges, _edgeBuffer);
        _computeShader.SetBuffer(_klVertices, _spNeighbors, _neighborBuffer);

        _computeShader.GetKernelThreadGroupSizes(_klVertices, out numThreadX, out numThreadY, out numThreadZ);
        _tgVertices.x = ((size - 1) + (int)(numThreadX - 1)) / (int)numThreadX;
        _tgVertices.y = ((size - 1) + (int)(numThreadY - 1)) / (int)numThreadY;
        _tgVertices.z = ((size - 1) + (int)(numThreadZ - 1)) / (int)numThreadZ;

        // Indices
        _klIndices = _computeShader.FindKernel("GenerateIndices");
        _computeShader.SetBuffer(_klIndices, _spSdfVoxels, _sdfVoxelBuffer);
        _computeShader.SetBuffer(_klIndices, _spVertexIds, _vertexIdBuffer);
        _computeShader.SetBuffer(_klIndices, _spVertices, _vertexBuffer);
        _computeShader.SetBuffer(_klIndices, _spIndices, _indexBuffer);
        _computeShader.SetBuffer(_klIndices, _spNeighbors, _neighborBuffer);

        _computeShader.GetKernelThreadGroupSizes(_klIndices, out numThreadX, out numThreadY, out numThreadZ);
        _tgIndices.x = ((size - 2) + (int)(numThreadX - 1)) / (int)numThreadX;
        _tgIndices.y = ((size - 2) + (int)(numThreadY - 1)) / (int)numThreadY;
        _tgIndices.z = ((size - 2) + (int)(numThreadZ - 1)) / (int)numThreadZ;

        // IndirectArgs
        _klIndirectArgs = _computeShader.FindKernel("UpdateIndirectArgs");
        _computeShader.SetBuffer(_klIndirectArgs, _spIndices, _indexBuffer);
        _computeShader.SetBuffer(_klIndirectArgs, _spIndirectArgs, _indirectArgBuffer);
    }

    private void OnDestroy()
    {
        if(_sdfVoxelBuffer != null)
            _sdfVoxelBuffer.Dispose();
        if(_vertexIdBuffer != null)
            _vertexIdBuffer.Dispose();
        if(_vertexBuffer != null)
            _vertexBuffer.Dispose();
        if(_indexBuffer != null)
            _indexBuffer.Dispose();
        if(_neighborBuffer != null)
            _neighborBuffer.Dispose();
        if(_edgeBuffer != null)
            _edgeBuffer.Dispose();
        if(_indirectArgBuffer != null)
            _indirectArgBuffer.Dispose();
    }

    private void LateUpdate()
    {
        // Dispatch
        _vertexBuffer.SetCounterValue(0);
        _indexBuffer.SetCounterValue(0);
        _computeShader.Dispatch(_klVertices, _tgVertices.x, _tgVertices.y, _tgVertices.z);
        _computeShader.Dispatch(_klIndices, _tgIndices.x, _tgIndices.y, _tgIndices.z);
        _computeShader.Dispatch(_klIndirectArgs, 1,1,1);
        GL.Flush();

        if(_indexBuffer != null)
            Graphics.DrawProceduralIndirect(_material, _bounds, MeshTopology.Triangles, _indirectArgBuffer);
    }

    void OnDrawGizmos()
    {
        Gizmos.color = Color.blue;
        Gizmos.DrawWireCube(_bounds.center, _bounds.size);
    }
}

uint SdfVoxelSize;
StructuredBuffer<float> SdfVoxels;
StructuredBuffer<uint2> Edges;        // 辺のつながり方
StructuredBuffer<uint3> Neighbors;    // 立方体上の頂点の番号の決め方

RWStructuredBuffer<uint> VertexIds;
RWStructuredBuffer<float3> Vertices;
RWStructuredBuffer<uint> Indices;
RWStructuredBuffer<uint> IndirectArgs;

// v0, v1, v2, v3から構築される面を追加する
void MakeFace(uint v0, uint v1, uint v2, uint v3, bool outside)
{
    uint indexOffset = Indices.IncrementCounter() * 6;

    if (outside)
    {
        Indices[indexOffset    ] = v0;
        Indices[indexOffset + 1] = v3;
        Indices[indexOffset + 2] = v2;
        Indices[indexOffset + 3] = v2;
        Indices[indexOffset + 4] = v1;
        Indices[indexOffset + 5] = v0;
    }
    else
    {
        Indices[indexOffset    ] = v0;
        Indices[indexOffset + 1] = v1;
        Indices[indexOffset + 2] = v2;
        Indices[indexOffset + 3] = v2;
        Indices[indexOffset + 4] = v3;
        Indices[indexOffset + 5] = v0;
    }
}

// 整数座標から配列に入るときの順序を取得
// +X+Y+Z方向に広がる立方体上のi番目の頂点として順序を取得
uint ToIdx(uint x, uint y, uint z, uint i, uint size)
{
    x += Neighbors[i].x;
    y += Neighbors[i].y;
    z += Neighbors[i].z;
    return x + y * size + z * size * size;
}

// 整数座標から配列に入るときの順序を取得
// -X-Y-Z方向に広がる立方体上のi番目の頂点として順序を取得
uint ToIdxNeg(uint x, uint y, uint z, uint i, uint size)
{
    x -= Neighbors[i].x;
    y -= Neighbors[i].y;
    z -= Neighbors[i].z;
    return x + y * size + z * size * size;
}

// 整数座標から実数座標を取得
// +X+Y+Z方向に広がる立方体上のi番目の頂点として実数座標を取得
float3 ToVec(uint i, uint j, uint k, uint neighbor)
{
    i += Neighbors[neighbor].x;
    j += Neighbors[neighbor].y;
    k += Neighbors[neighbor].z;
    return float3(i, j, k);
}

uint GetKind(uint x, uint y, uint z)
{
    // ビットマスクで8つの点の状態を記憶
    // iの位置の点が内側ならばi + 1番目のビットを立てる
    // 頂点の位置と番号の対応は次のように決める        
    //          7----6
    //         /|   /|
    //        4----5 |
    //        | 3--|-2
    //        |/   |/
    // (x,y,z)0----1
    uint kind = 0;
    if (0 > SdfVoxels[ToIdx(x, y, z, 0, SdfVoxelSize)]) kind |= 1 << 0;
    if (0 > SdfVoxels[ToIdx(x, y, z, 1, SdfVoxelSize)]) kind |= 1 << 1;
    if (0 > SdfVoxels[ToIdx(x, y, z, 2, SdfVoxelSize)]) kind |= 1 << 2;
    if (0 > SdfVoxels[ToIdx(x, y, z, 3, SdfVoxelSize)]) kind |= 1 << 3;
    if (0 > SdfVoxels[ToIdx(x, y, z, 4, SdfVoxelSize)]) kind |= 1 << 4;
    if (0 > SdfVoxels[ToIdx(x, y, z, 5, SdfVoxelSize)]) kind |= 1 << 5;
    if (0 > SdfVoxels[ToIdx(x, y, z, 6, SdfVoxelSize)]) kind |= 1 << 6;
    if (0 > SdfVoxels[ToIdx(x, y, z, 7, SdfVoxelSize)]) kind |= 1 << 7;
    return kind;
}

void GenerateVertex(uint x, uint y, uint z)
{
    uint kind = GetKind(x, y, z);
    // 8つの点がすべて内側またはすべて外側の場合はスキップ
    if (kind == 0 || kind == 255)
        return;

    // 頂点の位置を算出
    float3 vertex;
    uint crossCount = 0;

    // 現在焦点を当てている立方体上の辺をすべて列挙
    for (uint i = 0; i < 12; i++) {
        uint2 p = Edges[i];
        uint p0 = p.x;
        uint p1 = p.y;
            
        // 異なる側同士の点でつながってない場合はスキップ
        // ビットマスクからp0 + 1とp1 + 1ビット目(p0とp1の位置の点の状態)を取り出す
        if ((kind >> p0 & 1) == (kind >> p1 & 1))
            continue;

        // 両端の点のボクセルデータ上の値を取り出す
        float val0 = SdfVoxels[ToIdx(x, y, z, p0, SdfVoxelSize)];
        float val1 = SdfVoxels[ToIdx(x, y, z, p1, SdfVoxelSize)];

        // 線形補間によって値が0となる辺上の位置を算出して加算
        vertex += lerp(ToVec(x, y, z, p0), ToVec(x, y, z, p1), (0 - val0) / (val1 - val0));
        crossCount++;
    }
    vertex /= crossCount;

    uint vertexOffset = Vertices.IncrementCounter();
    Vertices[vertexOffset] = vertex;
    VertexIds[ToIdx(x, y, z, 0, SdfVoxelSize)] = vertexOffset;
}

void GenerateIndex(uint x, uint y, uint z)
{
    // 面の追加は0 < x, y, z < size - 1で行う
    //if (x == 0 || y == 0 || z == 0)
    //  return;

    uint kind = GetKind(x, y, z);
    // 8つの点がすべて内側またはすべて外側の場合はスキップ
    if (kind == 0 || kind == 255)
        return;

    // ビットマスクから1ビット目(0の位置の点の状態)を取り出す
    bool outside = (kind & 1) != 0;

    // 面を構築する頂点を取り出す
    // 頂点の位置と番号の対応は次のように決める   
    //    1----0(x, y, z)
    //   /|   /|
    //  2----3 |
    //  | 5--|-4
    //  |/   |/
    //  6----7
    uint v0 = VertexIds[ToIdxNeg(x, y, z, 0, SdfVoxelSize)];
    uint v1 = VertexIds[ToIdxNeg(x, y, z, 1, SdfVoxelSize)];
    uint v2 = VertexIds[ToIdxNeg(x, y, z, 2, SdfVoxelSize)];
    uint v3 = VertexIds[ToIdxNeg(x, y, z, 3, SdfVoxelSize)];
    uint v4 = VertexIds[ToIdxNeg(x, y, z, 4, SdfVoxelSize)];
    uint v5 = VertexIds[ToIdxNeg(x, y, z, 5, SdfVoxelSize)];
    // var v6 = VertexIds[ToIdxNeg(x, y, z, 6, SdfVoxelSize)]; // 使われない
    uint v7 = VertexIds[ToIdxNeg(x, y, z, 7, SdfVoxelSize)];

    // ビットマスクから2ビット目(1の位置の点の状態)を取り出す。異なる側同士の点からなる辺ならば交わるような面を追加
    bool isBit;
    isBit = (kind >> 1 & 1) != 0;
    if ( isBit != outside)
        MakeFace(v0, v3, v7, v4, outside);
    // ビットマスクから4ビット目(3の位置の点の状態)を取り出す
    isBit = (kind >> 3 & 1) != 0;
    if (isBit != outside)
        MakeFace(v0, v4, v5, v1, outside);
    // ビットマスクから5ビット目(4の位置の点の状態)を取り出す
    isBit = (kind >> 4 & 1) != 0;
    if (isBit != outside)
        MakeFace(v0, v1, v2, v3, outside);
}

#pragma kernel GenerateVertices
[numthreads(32, 32, 1)]
void GenerateVertices(uint3 id : SV_DispatchThreadID)
{
    if(id.x >= SdfVoxelSize - 1 || id.y >= SdfVoxelSize - 1 || id.z >= SdfVoxelSize - 1)
        return;

    uint x = id.x;
    uint y = id.y;
    uint z = id.z;
    GenerateVertex(x, y, z);
}

#pragma kernel GenerateIndices
[numthreads(32, 32, 1)]
void GenerateIndices(uint3 id : SV_DispatchThreadID)
{
    if(id.x >= SdfVoxelSize - 2 || id.y >= SdfVoxelSize - 2 || id.z >= SdfVoxelSize - 2)
        return;

    uint x = id.x + 1;
    uint y = id.y + 1;
    uint z = id.z + 1;
    GenerateIndex(x, y, z);
}

#pragma kernel UpdateIndirectArgs
[numthreads(1, 1, 1)]
void UpdateIndirectArgs(uint3 id : SV_DispatchThreadID)
{
    IndirectArgs[0] = Indices.IncrementCounter() * 6;
}

Shader "Unlit/GpuNaiveSurfaceNets"
{
    Properties
    {
    }

    CGINCLUDE
    StructuredBuffer<float3> Vertices;
    StructuredBuffer<uint> Indices;

    ENDCG

    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                uint vertexId : SV_VertexID;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(float4(Vertices[Indices[v.vertexId]], 1.0));
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return fixed4(1,0,0,1);
            }
            ENDCG
        }
    }
}