Mesh BuildPoints(GPUVoxelData data, out int[] vIndices)
{
var voxels = data.GetData();
var vertices = new List <Vector3>();
var indices = new List <int>();
var vIndicesTmp = new List <int>();
var count = 0;
for (int i = 0, n = voxels.Length; i < n; i++)
{
var v = voxels[i];
if (v.flag)
{
vertices.Add(v.position);
indices.Add(count++);
vIndicesTmp.Add(i);
}
}
vIndices = vIndicesTmp.ToArray();
var mesh = new Mesh();
mesh.indexFormat = IndexFormat.UInt32;
mesh.vertices = vertices.ToArray();
mesh.SetIndices(indices.ToArray(), MeshTopology.Points, 0);
mesh.RecalculateBounds();
return(mesh);
}
void ApplyImpulse(float dt, float amount, ComputeBuffer[] buffer)
{
//Set voxels
var impulseKernel = new Kernel(m_applyImpulse, "GaussImpulse");
foreach (Spawn spawn in this.mediator.spawns)
{
GPUVoxelData voxelData = spawn.GetGPUVoxelData();
if (voxelData == null)
{
continue;
}
m_applyImpulse.SetVector("_Size", m_size);
m_applyImpulse.SetFloat("_NoisePercent", m_noisePercent);
m_applyImpulse.SetFloat("_Amount", amount);
m_applyImpulse.SetFloat("_DeltaTime", dt);
m_applyImpulse.SetFloat("_Radius", spawn.GetObjectRadius());
m_applyImpulse.SetVector("_ObjectPosition", spawn.GetObjectCenter());
//m_applyImpulse.SetFloat("_Radius", 0.04f);
//m_applyImpulse.SetVector("_ObjectPosition", new Vector4(0.5f,0.1f,0.5f,0.0f));
m_applyImpulse.SetBuffer(impulseKernel.Index, "_VoxelBuffer", voxelData.Buffer);
m_applyImpulse.SetBuffer(impulseKernel.Index, "_Read", buffer[READ]);
m_applyImpulse.SetBuffer(impulseKernel.Index, "_Write", buffer[WRITE]);
m_applyImpulse.Dispatch(impulseKernel.Index,
(int)m_size.x / NUM_THREADS, (int)m_size.y / NUM_THREADS, (int)m_size.z / NUM_THREADS);
}
Swap(buffer);
}
void ApplyExtinguishmentImpulse(float dt, float amount, ComputeBuffer[] buffer)
{
var extinguishmentKernel = new Kernel(m_applyImpulse, "ExtinguishmentImpluse");
foreach (Spawn spawn in this.mediator.spawns)
{
GPUVoxelData voxelData = spawn.GetGPUVoxelData();
if (voxelData == null)
{
continue;
}
m_applyImpulse.SetVector("_Size", m_size);
m_applyImpulse.SetFloat("_Amount", amount);
m_applyImpulse.SetFloat("_DeltaTime", dt);
m_applyImpulse.SetVector("_ObjectPosition", spawn.GetObjectCenter());
m_applyImpulse.SetFloat("_Radius", spawn.GetObjectRadius());
m_applyImpulse.SetFloat("_Extinguishment", m_reactionExtinguishment);
m_applyImpulse.SetBuffer(extinguishmentKernel.Index, "_Read", buffer[READ]);
m_applyImpulse.SetBuffer(extinguishmentKernel.Index, "_Write", buffer[WRITE]);
m_applyImpulse.SetBuffer(extinguishmentKernel.Index, "_Reaction", m_reaction[READ]);
m_applyImpulse.Dispatch(extinguishmentKernel.Index,
(int)m_size.x / NUM_THREADS, (int)m_size.y / NUM_THREADS, (int)m_size.z / NUM_THREADS);
}
Swap(buffer);
}
void ComputeObstacles()
{
var obstacleResetKernel = new Kernel(m_computeObstacles, "ResetObstacle");
m_computeObstacles.SetBuffer(obstacleResetKernel.Index, "_Write", m_obstacles);
m_computeObstacles.Dispatch(obstacleResetKernel.Index, (int)m_size.x / NUM_THREADS, (int)m_size.y / NUM_THREADS, (int)m_size.z / NUM_THREADS);
var obstacleUpdateKernel = new Kernel(m_computeObstacles, "UpdatObstacle");
foreach (Obstacle obstacle in this.mediator.obstacles)
{
GPUVoxelData voxelData = obstacle.GetGPUVoxelData();
m_computeObstacles.SetVector("_Size", m_size);
m_computeObstacles.SetFloat("_Radius", obstacle.GetObjectRadius());
m_computeObstacles.SetVector("_ObjectPosition", obstacle.GetObjectCenter());
m_computeObstacles.SetBool("_WallLeft", m_wallLeft);
m_computeObstacles.SetBool("_WallRight", m_wallRight);
m_computeObstacles.SetBool("_WallUp", m_wallUp);
m_computeObstacles.SetBool("_WallDown", m_wallDown);
m_computeObstacles.SetBool("_WallFront", m_wallFront);
m_computeObstacles.SetBool("_WallBack", m_wallBack);
m_computeObstacles.SetBuffer(obstacleUpdateKernel.Index, "_VoxelBuffer", voxelData.Buffer);
m_computeObstacles.SetBuffer(obstacleUpdateKernel.Index, "_Write", m_obstacles);
m_computeObstacles.Dispatch(obstacleUpdateKernel.Index, (int)m_size.x / NUM_THREADS, (int)m_size.y / NUM_THREADS, (int)m_size.z / NUM_THREADS);
}
}
protected void ReleaseBuffers()
{
if (data != null)
{
data.Dispose();
data = null;
}
if (particleBuffer != null)
{
particleBuffer.Release();
particleBuffer = null;
}
var filter = GetComponent <MeshFilter>();
if (filter.sharedMesh != null)
{
Destroy(filter.sharedMesh);
}
if (gradient != null)
{
Destroy(gradient);
}
}
public void UpdateVertexBuffer(GPUVoxelData voxels)
{
int kernel;
switch (renderType)
{
case RenderType.Flat:
kernel = marchingCubesShader.FindKernel("MarchingCubesFlat");
break;
case RenderType.Smooth:
kernel = marchingCubesShader.FindKernel("MarchingCubesSmooth");
break;
default:
throw new ArgumentException("Unknown render type");
}
VertexBuffer.SetCounterValue(0);
marchingCubesShader.SetBuffer(kernel, "points", voxels.VoxelBuffer);
marchingCubesShader.SetBuffer(kernel, "colors", voxels.ColorBuffer);
marchingCubesShader.SetBuffer(kernel, "triangles", vertexBuffer);
marchingCubesShader.SetInt("numPointsPerAxis", voxels.Resolution);
marchingCubesShader.SetFloat("isoLevel", isoLevel);
marchingCubesShader.SetFloat("chunkSize", voxels.Size);
marchingCubesShader.Dispatch(kernel, voxels.Resolution / 8, voxels.Resolution / 8, voxels.Resolution / 8);
ComputeBuffer.CopyCount(VertexBuffer, drawArgs, sizeof(int));
}
public void UpdateMeshVoxelizer()
{
if (this.voxelsInBounds == null)
{
return;
}
/*if (type == MeshVisualType.Mesh) {
* //this.spawnObj.GetComponent<MeshFilter>().sharedMesh = defaultMesh;
* } else if (type == MeshVisualType.Voxel) {
* //this.spawnObj.GetComponent<MeshFilter>().sharedMesh = null;
* } else if (type == MeshVisualType.None) {
* //this.spawnObj.GetComponent<MeshFilter>().sharedMesh = null;
* }*/
this.SetObjectCenter();
this.SetObjectRadius();
var mesh = SampleMesh();
if (mesh == null)
{
return;
}
this.voxelsInBounds = gpuVoxelizer.Voxelize(voxelizer, mesh, this.spawnObj.transform, true);
//Debug.LogFormat("Num of triangles: {0}", mesh.triangles.Length);
}
private void CreatePreview()
{
GPUVoxelData data = GPUVoxelizer.Voxelize(shader, selectedMesh, resolution, false, false);
previewMesh = VoxelMesh.Build(data.GetData(), data.UnitLength, true);
selectedVoxelInfo = BuildVoxInfo(data.GetData(), data.UnitLength);
CreatePreviewPalette();
}
void Setup(GPUVoxelData data)
{
particleUpdate.SetBuffer(setupKernel.Index, kVoxelBufferKey, data.Buffer);
particleUpdate.SetBuffer(setupKernel.Index, kParticleBufferKey, particleBuffer);
particleUpdate.SetInt(kParticleCountKey, particleBuffer.count);
particleUpdate.SetFloat(kUnitLengthKey, data.UnitLength);
particleUpdate.Dispatch(setupKernel.Index, particleBuffer.count / (int)setupKernel.ThreadX + 1, (int)setupKernel.ThreadY, (int)setupKernel.ThreadZ);
}
void Compute(Kernel kernel, GPUVoxelData data, float dt)
{
particleUpdate.SetBuffer(kernel.Index, kVoxelBufferKey, data.Buffer);
particleUpdate.SetFloat(kUnitLengthKey, data.UnitLength);
particleUpdate.SetBuffer(kernel.Index, kParticleBufferKey, particleBuffer);
particleUpdate.SetInt(kParticleCountKey, particleBuffer.count);
particleUpdate.Dispatch(kernel.Index, particleBuffer.count / (int)kernel.ThreadX + 1, (int)kernel.ThreadY, (int)kernel.ThreadZ);
}
public void Voxelize(Mesh mesh, Bounds bounds)
{
if (data != null)
{
data.Dispose();
data = null;
}
// data = GPUVoxelizer.Voxelize(voxelizer, mesh, mesh.bounds, resolution, true, false);
data = GPUVoxelizer.Voxelize(voxelizer, mesh, Mathf.Max(10, resolution) >> level, true, false);
}
void Setup(GPUVoxelData data)
{
particleUpdate.SetBuffer(setupKernel.Index, kVoxelBufferKey, data.Buffer);
particleUpdate.SetBuffer(setupKernel.Index, kParticleBufferKey, particleBuffer);
particleUpdate.SetInt(kParticleCountKey, particleBuffer.count);
particleUpdate.SetInt(kWidthKey, data.Width);
particleUpdate.SetInt(kHeightKey, data.Height);
particleUpdate.SetInt(kDepthKey, data.Depth);
particleUpdate.SetVector(kSpeedKey, new Vector2(speedScaleMin, speedScaleMax));
particleUpdate.SetFloat(kUnitLengthKey, data.UnitLength);
particleUpdate.Dispatch(setupKernel.Index, particleBuffer.count / (int)setupKernel.ThreadX + 1, (int)setupKernel.ThreadY, (int)setupKernel.ThreadZ);
}
protected void ReleaseBuffers()
{
if (data != null)
{
data.Dispose();
data = null;
}
if (particleBuffer != null)
{
particleBuffer.Release();
particleBuffer = null;
}
}
void OnDestroy()
{
if (particleBuffer != null)
{
particleBuffer.Release();
particleBuffer = null;
}
if (data != null)
{
data.Dispose();
data = null;
}
}
protected void Sample()
{
skinned.BakeMesh(mesh);
// expand bounds to contain all bounds of animated meshes
bounds.Encapsulate(mesh.bounds.min);
bounds.Encapsulate(mesh.bounds.max);
if (data != null)
{
data.Dispose();
data = null;
}
data = GPUVoxelizer.Voxelize(voxelizer, bounds, mesh, resolution);
}
void Update()
{
if (data == null)
{
return;
}
data.Dispose();
var mesh = Sample();
data = GPUVoxelizer.Voxelize(voxelizer, mesh, count, (type == MeshType.Volume));
Compute(updateKernel, data, Time.deltaTime);
}
Mesh BuildPoints(GPUVoxelData data)
{
var count = data.Width * data.Height * data.Depth;
var mesh = new Mesh();
mesh.indexFormat = IndexFormat.UInt32;
mesh.vertices = new Vector3[count];
var indices = new int[count];
for (int i = 0; i < count; i++)
{
indices[i] = i;
}
mesh.SetIndices(indices, MeshTopology.Points, 0);
mesh.RecalculateBounds();
return(mesh);
}
void Update()
{
if (data == null)
{
return;
}
data.Dispose();
var mesh = Sample();
data = GPUVoxelizer.Voxelize(voxelizer, mesh, count, (type == MeshType.Volume));
Compute(updateKernel, data, Time.deltaTime);
block.SetBuffer(kParticleBufferKey, particleBuffer);
_renderer.SetPropertyBlock(block);
}
// Start is called before the first frame update
public void Voxelize()
{
var mesh = GetComponent <MeshFilter>().mesh;
GPUVoxelData data = GPUVoxelizer.Voxelize(
voxelizer, // ComputeShader (Voxelizer.compute)
mesh, // a target mesh
transform.worldToLocalMatrix,
1.0f
);
gridData = data.VoxeltoGridVoxel(transform.localToWorldMatrix);
WorldDataManager.Instance.ActiveWorld.CreateNewObjectFromGridData(gridData, new Voxel());
// need to release a voxel buffer
data.Dispose();
Destroy(gameObject);
}
void Start()
{
var mesh = Sample();
data = GPUVoxelizer.Voxelize(voxelizer, mesh, count, (type == MeshType.Volume));
var pointMesh = BuildPoints(data);
particleBuffer = new ComputeBuffer(pointMesh.vertexCount, Marshal.SizeOf(typeof(VParticle_t)));
GetComponent <MeshFilter>().sharedMesh = pointMesh;
block = new MaterialPropertyBlock();
_renderer = GetComponent <Renderer>();
_renderer.GetPropertyBlock(block);
setupKernel = new Kernel(particleUpdate, kSetupKernelKey);
updateKernel = new Kernel(particleUpdate, kUpdateKernelKey);
Setup(data);
}
public void InitMeshVoxelizer()
{
var mesh = SampleMesh();
if (mesh == null)
{
return;
}
//defaultMesh = mesh;
//defaultMaterial =this.spawnObj.GetComponent<MeshRenderer>().sharedMaterial;
Bounds fireBounds = this.mediator.bounds;
Bounds spawnBounds = this.spawnObj.GetComponent <Renderer>().bounds;
//Debug.Log("box min: " + this.mediator.bounds.min);
//Debug.Log("box center: " + this.mediator.bounds.center);
//Debug.Log("box size: " + this.mediator.bounds.size);
//Debug.Log("spawn box center: " + spawnBounds.center);
//Debug.Log("spawn box min: " + spawnBounds.min);
//Debug.Log("spawn box max: " + spawnBounds.max);
//Debug.Log("spawn box extends: " + spawnBounds.extents);
//Debug.Log("spawn box size: " + spawnBounds.size);
//Debug.Log("spawn mesh box center: " + mesh.bounds.center);
//Debug.Log("spawn mesh box size: " + mesh.bounds.size);
this.SetObjectCenter();
this.SetObjectRadius();
numOfVoxels = Mathf.ClosestPowerOfTwo(this.mediator.fluidSimulator3D.m_width);
this.gpuVoxelizer = new GPUVoxelizer();
this.gpuVoxelizer.InitVoxelization(mesh, this.mediator.bounds, numOfVoxels);
this.voxelsInBounds = gpuVoxelizer.Voxelize(voxelizer, mesh, this.spawnObj.transform, true);
this.GetComponent <MeshFilter>().sharedMesh = VoxelMesh.Build(this.voxelsInBounds.GetData(), this.voxelsInBounds.UnitLength, true);
//Debug.LogFormat("!!!!!!!!!!!!!!!!!!!!! Num of triangles: {0}", mesh.triangles.Length);
}
void Start()
{
data = GPUVoxelizer.Voxelize(voxelizer, mesh, count);
int[] indices;
var pointMesh = BuildPoints(data, out indices);
particleBuffer = new ComputeBuffer(pointMesh.vertexCount, Marshal.SizeOf(typeof(VParticle_t)));
indexBuffer = new ComputeBuffer(pointMesh.vertexCount, Marshal.SizeOf(typeof(int)));
indexBuffer.SetData(indices);
GetComponent <MeshFilter>().sharedMesh = pointMesh;
block = new MaterialPropertyBlock();
renderer = GetComponent <Renderer>();
renderer.GetPropertyBlock(block);
bounds = mesh.bounds;
setupKernel = new Kernel(particleUpdate, kSetupKernelKey);
updateKernel = new Kernel(particleUpdate, kUpdateKernelKey);
Setup();
}
public void Init()
{
voxels = new GPUVoxelData(resolution, size);
gpuMesh = new GPUMesh(voxels.Volume * 5);
}
