void ParticleMesh::release()
{
if (!par_list)
delete[] par_list;
if (!sdf_list)
delete[] sdf_list;
if (!mp_vertexXYZ)
delete[] mp_vertexXYZ;
if (!Relative_Vertex)
delete[] Relative_Vertex;
if (!FaceVerInd)
delete[] FaceVerInd;
if (!mp_vertexRGB)
delete[] mp_vertexRGB;
if (!mp_vertexNorm)
delete[] mp_vertexNorm;
if (!dRelative_Vertex)
freeArray(dRelative_Vertex);
unregisterGLBufferObject(m_cuda_indexvbo_resource);
glDeleteBuffers(1, (const GLuint *)&m_indexVBO);
unregisterGLBufferObject(m_cuda_normalvbo_resource);
glDeleteBuffers(1, (const GLuint *)&m_NorVBO);
unregisterGLBufferObject(m_cuda_colorvbo_resource);
glDeleteBuffers(1, (const GLuint *)&m_colorVBO);
unregisterGLBufferObject(m_cuda_vertexvbo_resource);
glDeleteBuffers(1, (const GLuint *)&m_vertexVbo);
}
void
ParticleSystem::_finalize()
{
assert(m_bInitialized);
delete [] m_hPos;
delete [] m_hVel;
delete [] m_hCellStart;
delete [] m_hCellEnd;
freeArray(m_dVel);
freeArray(m_dSortedPos);
freeArray(m_dSortedVel);
freeArray(m_dGridParticleHash);
freeArray(m_dGridParticleIndex);
freeArray(m_dCellStart);
freeArray(m_dCellEnd);
if (m_bUseOpenGL)
{
unregisterGLBufferObject(m_cuda_colorvbo_resource);
unregisterGLBufferObject(m_cuda_posvbo_resource);
glDeleteBuffers(1, (const GLuint *)&m_posVbo);
glDeleteBuffers(1, (const GLuint *)&m_colorVBO);
}
else
{
checkCudaErrors(cudaFree(m_cudaPosVBO));
checkCudaErrors(cudaFree(m_cudaColorVBO));
}
}
void
ParticleSystem::setArray(ParticleArray array, const float *data, int start, int count)
{
assert(m_bInitialized);
switch (array)
{
default:
case POSITION:
{
if (m_bUseOpenGL)
{
unregisterGLBufferObject(m_cuda_posvbo_resource);
glBindBuffer(GL_ARRAY_BUFFER, m_posVbo);
glBufferSubData(GL_ARRAY_BUFFER, start*4*sizeof(float), count*4*sizeof(float), data);
glBindBuffer(GL_ARRAY_BUFFER, 0);
registerGLBufferObject(m_posVbo, &m_cuda_posvbo_resource);
}
}
break;
case VELOCITY:
copyArrayToDevice(m_dVel, data, start*4*sizeof(float), count*4*sizeof(float));
break;
}
}
void PoiseuilleFlowSystem::setArray(ParticleArray array, const float* data, int start, int count){
assert(IsInitialized);
switch (array)
{
default:
case POSITION:
{
if (IsOpenGL) {
unregisterGLBufferObject(cuda_posvbo_resource);
glBindBuffer(GL_ARRAY_BUFFER, posVbo);
glBufferSubData(GL_ARRAY_BUFFER, start*4*sizeof(float), count*4*sizeof(float), data);
glBindBuffer(GL_ARRAY_BUFFER, 0);
registerGLBufferObject(posVbo, &cuda_posvbo_resource);
}else
{
copyArrayToDevice(cudaPosVBO, data, start*4*sizeof(float), count*4*sizeof(float));
}
}
break;
case VELOCITY:
copyArrayToDevice(dVel, data, start*4*sizeof(float), count*4*sizeof(float));
break;
case MEASURES:
copyArrayToDevice(dMeasures, data, start*4*sizeof(float), count*4*sizeof(float));
break;
case ACCELERATION:
copyArrayToDevice(dAcceleration, data, start*4*sizeof(float), count*4*sizeof(float));
break;
case VELOCITYLEAPFROG:
copyArrayToDevice(dVelLeapFrog, data, start*4*sizeof(float), count*4*sizeof(float));
break;
}
}
void PoiseuilleFlowSystem::_finalize(){
assert(IsInitialized);
delete [] hPos;
delete [] hVel;
delete [] hVelLeapFrog;
delete [] hMeasures;
delete [] hAcceleration;
freeArray(dVel);
freeArray(dVelLeapFrog);
freeArray(dMeasures);
freeArray(dAcceleration);
freeArray(dSortedPos);
freeArray(dSortedVel);
freeArray(dHash);
freeArray(dIndex);
freeArray(dCellStart);
freeArray(dCellEnd);
if (IsOpenGL) {
unregisterGLBufferObject(cuda_posvbo_resource);
glDeleteBuffers(1, (const GLuint*)&posVbo);
glDeleteBuffers(1, (const GLuint*)&colorVBO);
} else {
checkCudaErrors( cudaFree(cudaPosVBO) );
checkCudaErrors( cudaFree(cudaColorVBO) );
}
}
void ParticleSystem::_finalize(){
assert(m_bInitialized);
free(m_hPos);
free(m_hVel);
free(m_hCellStart);
free(m_hCellEnd);
free(m_hReorderedVel);
free(m_hReorderedPos);
free(m_hIndex);
free(m_hHash);
freeArray(m_dPos);
freeArray(m_dVel);
freeArray(m_dReorderedPos);
freeArray(m_dReorderedVel);
freeArray(m_dHash);
freeArray(m_dIndex);
freeArray(m_dCellStart);
freeArray(m_dCellEnd);
if (!m_bQATest)
{
unregisterGLBufferObject(m_posVbo);
glDeleteBuffers(1, (const GLuint*)&m_posVbo);
glDeleteBuffers(1, (const GLuint*)&m_colorVBO);
}
}
void FluidSystem::setArray(FluidArray array, const float *data, int start, int count) //重新设置particle的速度和位置数组
{
assert(m_bInitialized);
switch (array)
{
default:
case POSITION:
{
if (m_bUseOpenGL)
{
unregisterGLBufferObject(m_cuda_posvbo_resource);
glBindBuffer(GL_ARRAY_BUFFER, m_posVbo);
glBufferSubData(GL_ARRAY_BUFFER, start*4*sizeof(float), count*4*sizeof(float), data);
glBindBuffer(GL_ARRAY_BUFFER, 0);
registerGLBufferObject(m_posVbo, &m_cuda_posvbo_resource);
}
}
break;
case VELOCITY:
unregisterGLBufferObject(m_cuda_velvbo_resource);
glBindBuffer(GL_ARRAY_BUFFER, m_velVBO);
glBufferSubData(GL_ARRAY_BUFFER, start * 4 * sizeof(float), count * 4 * sizeof(float), data);
glBindBuffer(GL_ARRAY_BUFFER, 0);
registerGLBufferObject(m_velVBO, &m_cuda_velvbo_resource);
break;
case DENSITY:
copyArrayToDevice(m_dDen, data, start * sizeof(float), count * sizeof(float));
break;
case PRESSURE:
copyArrayToDevice(m_dPre, data, start * sizeof(float), count * sizeof(float));
break;
case COLORFIELD:
copyArrayToDevice(m_dColorf, data, start * sizeof(float), count * sizeof(float));
break;
}
}
Particles::~Particles()
{
assert(initFlag);
delete[] pos;
delete[] vel;
freeArray(velGpu);
freeArray(sortedPos);
freeArray(sortedVel);
freeArray(gridParticleHash);
freeArray(gridParticleIndex);
freeArray(cellStart);
freeArray(cellEnd);
freeArray(solidPos);
unregisterGLBufferObject(m_cuda_colorvbo_resource);
unregisterGLBufferObject(m_cuda_posvbo_resource);
glDeleteBuffersARB(1, (const GLuint *)&posVbo);
glDeleteBuffersARB(1, (const GLuint *)&colorVbo);
glDeleteVertexArrays(1, &arrayObject);
}
void Particles::SetArray(ParticleArray array, const float *data, int start, int count)
{
assert(initFlag);
switch (array)
{
default:
case POSITION:
{
unregisterGLBufferObject(m_cuda_posvbo_resource);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, posVbo);
glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, start * 4 * sizeof(float), count * 4 * sizeof(float), data);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
registerGLBufferObject(posVbo, &m_cuda_posvbo_resource);
}
break;
case VELOCITY:
copyArrayToDevice(velGpu, data, start * 4 * sizeof(float), count * 4 * sizeof(float));
break;
}
}
void ParticleMesh::calculate(LevelsetCollider &LC, int size, float r, float mass)
{
float scale = 2 * r / (LC.gridStep*(LC.gridSize.x - 4) / size);
vec3<double> center = vec3<double>(0, 0, 0);
vec3<double> MaxB = LC.MaxBoundary;
vec3<double> MinB = LC.MinBoundary;
scale = CalScale(MaxB, MinB, r, size);
int index_par = 0;
par_list = new triple[20000];
sdf_list = new SDF[20000];
float step = r * 2 / scale;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k <size; k++)
{
vec3<int> gridPos = vec3<int>(i, j, k);
vec3<double> pos = vec3<double>(i + 0.5, j + 0.5, k + 0.5) * (2 * r / scale) + MinB;
int gridInd = dot(gridPos, LC.gridSizeOffset);
double sdf = 0;
LC.getGridDist(pos, sdf);
if (sdf < 0 && sdf > -r * 2 / scale * 2)
{
vec3<double> pos_par = pos - MinB;// -vec3<double>(0.5, 0.5, 0.5) * (2 * r / scale);
center += mass*pos_par * scale;
par_list[index_par].x[0] = pos_par.x * scale;
par_list[index_par].x[1] = pos_par.y * scale;
par_list[index_par].x[2] = pos_par.z * scale;
sdf_list[index_par].sdf = sdf * scale;
vec3<double> gradient;
LC.checkCollision(pos, sdf, gradient, -1);
sdf_list[index_par].gradient[0] = gradient.x;
sdf_list[index_par].gradient[1] = gradient.y;
sdf_list[index_par].gradient[2] = gradient.z;
index_par++;
}
}
}
}
center /= index_par*mass;
float3 center_f3 = make_float3(center[0], center[1], center[2]);
m_totalParticles = index_par;
m_totalConnectedPoints = LC.meshModel->m_totalConnectedPoints;
m_totalFaces = LC.meshModel->m_totalFaces;
float3 vertex,relative;
mp_vertexXYZ = new float[m_totalConnectedPoints * 3];
Relative_Vertex = new float3[m_totalConnectedPoints];
mp_vertexNorm = new float[m_totalConnectedPoints * 3];
mp_vertexRGB = new float[m_totalConnectedPoints * 3];
for (int i = 0; i < m_totalConnectedPoints; i++)
{
vertex.x = LC.meshModel->mp_vertexXYZ[i * 3];
vertex.y = LC.meshModel->mp_vertexXYZ[i * 3 + 1];
vertex.z = LC.meshModel->mp_vertexXYZ[i * 3 + 2];
//vertex *= scale;
vertex -= make_float3(MinB[0], MinB[1], MinB[2]);// +make_float3(0.5, 0.5, 0.5) * (2 * r / scale);
vertex *= scale;
relative = vertex - center_f3;
*(float3*)(mp_vertexXYZ + i * 3) = vertex;
mp_vertexRGB[i * 3] = LC.meshModel->mp_vertexRGB[i * 3];
mp_vertexRGB[i * 3 + 1] = LC.meshModel->mp_vertexRGB[i * 3 + 1];
mp_vertexRGB[i * 3 + 2] = LC.meshModel->mp_vertexRGB[i * 3 + 2];
mp_vertexNorm[i * 3] = 0; //LC.meshModel->mp_vertexNorm[i * 3];
mp_vertexNorm[i * 3 + 1] = 0; //LC.meshModel->mp_vertexNorm[i * 3 + 1];
mp_vertexNorm[i * 3 + 2] = 0;// LC.meshModel->mp_vertexNorm[i * 3 + 2];
Relative_Vertex[i] = relative;
}
FaceVerInd = new uint[3 * m_totalFaces];
//memcpy(FaceVerInd, LC.meshModel->mp_face, 9 * m_totalFaces * sizeof(uint));
float3 n;
for (int i = 0; i < m_totalFaces; i++)
{
uint i_1 = FaceVerInd[3 * i] = LC.meshModel->mp_face[3 * i];
uint i_2 = FaceVerInd[3 * i + 1] = LC.meshModel->mp_face[3 * i + 1];
uint i_3 = FaceVerInd[3 * i + 2] = LC.meshModel->mp_face[3 * i + 2];
float3 v1 = make_float3(mp_vertexXYZ[i_1 * 3], mp_vertexXYZ[i_1 * 3 + 1], mp_vertexXYZ[i_1 * 3 + 2]);
float3 v2 = make_float3(mp_vertexXYZ[i_2 * 3], mp_vertexXYZ[i_2 * 3 + 1], mp_vertexXYZ[i_2 * 3 + 2]);
float3 v3 = make_float3(mp_vertexXYZ[i_3 * 3], mp_vertexXYZ[i_3 * 3 + 1], mp_vertexXYZ[i_3 * 3 + 2]);
float3 e12 = v2 - v1;
float3 e13 = v3 - v1;
n = cross(e12, e13);
n /= length(n);
mp_vertexNorm[i_1 * 3] += n.x;
mp_vertexNorm[i_1 * 3 + 1] += n.y;
mp_vertexNorm[i_1 * 3 + 2] += n.z;
//atomicAdd(&num_tri_per_point[i_1], 1);
float3 e21 = -e12;
float3 e23 = v3 - v2;
n = cross(e23, e21);
n /= length(n);
mp_vertexNorm[i_2 * 3] += n.x;
mp_vertexNorm[i_2 * 3 + 1] += n.y;
mp_vertexNorm[i_2 * 3 + 2] += n.z;
//atomicAdd(&num_tri_per_point[i_2], 1);
float3 e31 = -e13;
float3 e32 = -e23;
n = cross(e31, e32);
n /= length(n);
mp_vertexNorm[i_3 * 3] += n.x;
mp_vertexNorm[i_3 * 3 + 1] += n.y;
mp_vertexNorm[i_3 * 3 + 2] += n.z;
}
for (int i = 0; i < m_totalConnectedPoints; i++)
{
float3 n = make_float3(mp_vertexNorm[i * 3], mp_vertexNorm[i * 3 + 1], mp_vertexNorm[i * 3 + 2]);
mp_vertexNorm[i * 3] /= length(n);
mp_vertexNorm[i * 3 + 1] /= length(n);
mp_vertexNorm[i * 3 + 2] /= length(n);
}
m_vertexVbo = createVBO(m_totalConnectedPoints * 3 * sizeof(float));
registerGLBufferObject(m_vertexVbo, &m_cuda_vertexvbo_resource);
m_indexVBO = createVBO(3 * m_totalFaces * sizeof(uint));
registerGLBufferObject(m_indexVBO, &m_cuda_indexvbo_resource);
m_colorVBO = createVBO(m_totalConnectedPoints * 3 * sizeof(float));
registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource);
m_NorVBO = createVBO(m_totalConnectedPoints * 3 * sizeof(float));
registerGLBufferObject(m_NorVBO, &m_cuda_normalvbo_resource);
unregisterGLBufferObject(m_cuda_vertexvbo_resource);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexVbo);
glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexXYZ);
glBindBuffer(GL_ARRAY_BUFFER, 0);
registerGLBufferObject(m_vertexVbo, &m_cuda_vertexvbo_resource);
unregisterGLBufferObject(m_cuda_indexvbo_resource);
glBindBuffer(GL_ARRAY_BUFFER, m_indexVBO);
glBufferSubData(GL_ARRAY_BUFFER, 0, 3 * m_totalFaces * sizeof(uint), FaceVerInd);
glBindBuffer(GL_ARRAY_BUFFER, 0);
registerGLBufferObject(m_indexVBO, &m_cuda_indexvbo_resource);
unregisterGLBufferObject(m_cuda_colorvbo_resource);
glBindBuffer(GL_ARRAY_BUFFER, m_colorVBO);
glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexRGB);
glBindBuffer(GL_ARRAY_BUFFER, 0);
registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource);
unregisterGLBufferObject(m_cuda_normalvbo_resource);
glBindBuffer(GL_ARRAY_BUFFER, m_NorVBO);
glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexNorm);
glBindBuffer(GL_ARRAY_BUFFER, 0);
registerGLBufferObject(m_NorVBO, &m_cuda_normalvbo_resource);
allocateArray((void**)&dRelative_Vertex, m_totalConnectedPoints * 3 * sizeof(float));
copyArrayToDevice(dRelative_Vertex, Relative_Vertex, 0, m_totalConnectedPoints * 3 * sizeof(float));
hasMesh = true;
}