public ComputeSession(ComputeShader meshSampleComputeShader, ComputeShader tesselationComputeShader, int size, float padding, bool sampleUVs, Matrix4x4 transform)
{
MeshSampleComputeShader = Instantiate(meshSampleComputeShader);
TessellationComputeShader = Instantiate(tesselationComputeShader);
GetTextureWholeKernel = MeshSampleComputeShader.FindKernel(GetTextureWholeKernelName);
ComputeBoundsKernel = MeshSampleComputeShader.FindKernel(ComputeBoundsKernelName);
TessellateKernel = TessellationComputeShader.FindKernel(TessellateKernelName);
PreprocessMeshKernel = TessellationComputeShader.FindKernel(PreprocessMeshKernelName);
m_sampleUVs = sampleUVs;
m_size = size;
m_padding = padding;
m_transform = transform;
m_samples = new float[Dimensions];
m_packedUVs = new float[Dimensions];
BoundsBuffer = new ComputeBuffer(6, sizeof(int));
MeshSampleComputeShader.SetBuffer(ComputeBoundsKernel, Properties.MeshBounds_RWStructuredBuffer, BoundsBuffer);
SamplesBuffer = new ComputeBuffer(Dimensions, sizeof(float));
MeshSampleComputeShader.SetBuffer(GetTextureWholeKernel, Properties.Samples_RWStructuredBuffer, SamplesBuffer);
PackedUVsBuffer = new ComputeBuffer(Dimensions, sizeof(float));
MeshSampleComputeShader.SetBuffer(GetTextureWholeKernel, Properties.PackedUVs_RWStructuredBuffer, PackedUVsBuffer);
MeshSampleComputeShader.SetInt(Properties.Size_Int, m_size);
MeshSampleComputeShader.SetFloat(Properties.Padding_Float, m_padding);
MeshSampleComputeShader.SetMatrix(Properties.ModelTransformMatrix_Matrix, m_transform);
}
private void RunBoundsPhase(Mesh mesh, out Vector3 minBounds, out Vector3 maxBounds)
{
int[] meshBounds = new int[6];
BoundsBuffer.SetData(meshBounds);
MeshSampleComputeShader.Dispatch(ComputeBoundsKernel, Mathf.CeilToInt(mesh.triangles.Length / 64f), 1, 1);
BoundsBuffer.GetData(meshBounds);
const float packingMultiplier = 1000f;
minBounds = new Vector3(meshBounds[0] / packingMultiplier, meshBounds[1] / packingMultiplier, meshBounds[2] / packingMultiplier);
maxBounds = new Vector3(meshBounds[3] / packingMultiplier, meshBounds[4] / packingMultiplier, meshBounds[5] / packingMultiplier);
minBounds -= m_padding * Vector3.one;
maxBounds += m_padding * Vector3.one;
}
public void Dispatch(Mesh mesh, out float[] samples, out float[] packedUVs, out Vector3 minBounds, out Vector3 maxBounds)
{
m_triangles = mesh.triangles;
m_vertices = mesh.vertices;
m_normals = mesh.normals;
m_uvs = mesh.uv;
InputTrianglesBuffer = new ComputeBuffer(m_triangles.Length, sizeof(int), ComputeBufferType.Structured);
InputVerticesBuffer = new ComputeBuffer(m_vertices.Length, sizeof(float) * 3, ComputeBufferType.Structured);
InputNormalsBuffer = new ComputeBuffer(m_normals.Length, sizeof(float) * 3, ComputeBufferType.Structured);
InputTrianglesBuffer.SetData(m_triangles);
InputNormalsBuffer.SetData(m_normals);
InputVerticesBuffer.SetData(m_vertices);
MeshSampleComputeShader.SetBuffer(ComputeBoundsKernel, Properties.InputTriangles_StructuredBuffer, InputTrianglesBuffer);
MeshSampleComputeShader.SetBuffer(ComputeBoundsKernel, Properties.InputVertices_StructuredBuffer, InputVerticesBuffer);
MeshSampleComputeShader.SetBuffer(GetTextureWholeKernel, Properties.InputTriangles_StructuredBuffer, InputTrianglesBuffer);
MeshSampleComputeShader.SetBuffer(GetTextureWholeKernel, Properties.InputNormals_StructuredBuffer, InputNormalsBuffer);
MeshSampleComputeShader.SetBuffer(GetTextureWholeKernel, Properties.InputVertices_StructuredBuffer, InputVerticesBuffer);
bool hasUVs = !m_uvs.IsNullOrEmpty();
if (m_sampleUVs && hasUVs)
{
MeshSampleComputeShader.EnableKeyword(WriteUVsKeyword);
InputUVsBuffer = new ComputeBuffer(m_uvs.Length, sizeof(float) * 2, ComputeBufferType.Structured);
InputUVsBuffer.SetData(m_uvs);
MeshSampleComputeShader.SetBuffer(GetTextureWholeKernel, Properties.InputUVs_StructuredBuffer, InputUVsBuffer);
}
else
{
MeshSampleComputeShader.DisableKeyword(WriteUVsKeyword);
}
MeshSampleComputeShader.SetInt(Properties.TriangleCount_Int, m_triangles.Length);
MeshSampleComputeShader.SetInt(Properties.VertexCount_Int, m_vertices.Length);
RunBoundsPhase(mesh, out minBounds, out maxBounds);
RunSamplePhase(hasUVs, out samples, out packedUVs, minBounds, maxBounds);
}
/// <summary>
/// Note: I chose to use buffers instead of writing to texture 3ds directly on the GPU because for some reason it's
/// stupidly complicated to write to a texture3d on the gpu and then get that data back to the cpu for serialization.
/// </summary>
private void RunSamplePhase(bool hasUVs, out float[] samples, out float[] packedUVs, Vector3 minBounds, Vector3 maxBounds)
{
MeshSampleComputeShader.SetVector(Properties.MinBounds_Vector3, minBounds);
MeshSampleComputeShader.SetVector(Properties.MaxBounds_Vector3, maxBounds);
int threadGroups = Mathf.CeilToInt(m_size / 8f);
MeshSampleComputeShader.Dispatch(GetTextureWholeKernel, threadGroups, threadGroups, threadGroups);
SamplesBuffer.GetData(m_samples);
samples = m_samples;
if (hasUVs)
{
PackedUVsBuffer.GetData(m_packedUVs);
packedUVs = m_packedUVs;
}
else
{
packedUVs = null;
}
}
