FlowField::FlowField ( int Nx, int Ny ) :
_size_x ( Nx ), _size_y ( Ny ), _size_z ( 1 ),
_cellsX (Nx+3), _cellsY(Ny+3), _cellsZ(1),
// Pressure field doesn't need to have an extra layer, but this allows to address the same
// positions with the same iterator for both pressures and velocities.
_pressure ( ScalarField ( Nx + 3, Ny + 3 ) ),
_viscosity ( ScalarField ( Nx + 3, Ny + 3 ) ),
_velocity ( VectorField ( Nx + 3, Ny + 3 ) ), _flags ( IntScalarField ( Nx + 3, Ny + 3 ) ),
_nearWallDis ( ScalarField ( Nx + 3, Ny + 3 ) ),
_FGH ( VectorField ( Nx + 3, Ny + 3 ) ), _RHS ( ScalarField (Nx + 3, Ny + 3) ) {
assertion ( Nx > 0 );
assertion ( Ny > 0 );
}
void MyWidget::paintEvent(QPaintEvent * e) {
QPainter paint(this);
memset(_bitsDest, 0, _PIC_MAX);
initFigure();
switch (_func_index) {
case 0: ScalarField();
break;
case 1: MarchingCubes();
break;
}
for (int x = 0; x < fR2; x++) {
for (int y = 0; y < fR2; y++) {
for (int z = 0; z < fR2; z++) {
_figure2D[x][y][z].free();
_figure3D[x][y][z].free();
}
}
}
paint.drawImage(QPoint(0, 0), *_imageDest);
e->accept();
}
FlowField::FlowField ( int Nx, int Ny, int Nz ) :
_size_x ( Nx ), _size_y ( Ny ), _size_z ( Nz ),
_cellsX (Nx+3), _cellsY(Ny+3), _cellsZ(Nz+3),
_pressure ( ScalarField ( Nx + 3, Ny + 3, Nz + 3 ) ),
_viscosity ( ScalarField ( Nx + 3, Ny + 3 , Nz + 3) ),
_velocity ( VectorField ( Nx + 3, Ny + 3, Nz + 3 ) ),
_flags ( IntScalarField ( Nx + 3, Ny + 3, Nz +3 ) ),
_nearWallDis ( ScalarField ( Nx + 3, Ny + 3, Nz +3 ) ),
_FGH ( VectorField ( Nx + 3, Ny + 3, Nz + 3 ) ),
_RHS ( ScalarField ( Nx + 3, Ny + 3, Nz + 3 ) ) {
// Check that the provided data makes sense
assertion ( Nx > 0 );
assertion ( Ny > 0 );
assertion ( Nz > 0 );
}
FlowField::FlowField (const Parameters & parameters):
_size_x(parameters.parallel.localSize[0]),
_size_y(parameters.parallel.localSize[1]),
_size_z(parameters.parallel.localSize[2]),
_cellsX(_size_x+3),
_cellsY(_size_y+3),
_cellsZ(_size_z+3),
// Probably far from the best way to write this
_pressure(parameters.geometry.dim==2?ScalarField(_size_x + 3, _size_y + 3):
ScalarField(_size_x + 3, _size_y + 3, _size_z + 3)),
// added for turbulence cases
_viscosity(parameters.geometry.dim==2?ScalarField(_size_x + 3, _size_y + 3):
ScalarField(_size_x + 3, _size_y + 3, _size_z + 3)),
_velocity(parameters.geometry.dim==2?VectorField(_size_x + 3, _size_y + 3):
VectorField(_size_x + 3, _size_y + 3, _size_z + 3)),
_flags(parameters.geometry.dim==2?IntScalarField(_size_x + 3, _size_y + 3):
IntScalarField(_size_x + 3, _size_y + 3, _size_z + 3)),
_nearWallDis(parameters.geometry.dim==2?ScalarField(_size_x + 3, _size_y + 3):
ScalarField(_size_x + 3, _size_y + 3, _size_z + 3)),
_FGH(parameters.geometry.dim==2?VectorField(_size_x + 3, _size_y + 3):
VectorField(_size_x + 3, _size_y + 3, _size_z + 3)),
_RHS(parameters.geometry.dim==2?ScalarField(_size_x + 3, _size_y + 3):
ScalarField(_size_x + 3, _size_y + 3, _size_z + 3))
{ }
void VoxelTerrain::MarchingCube(float x, float y, float z, float x1, float y1, float z1, float F[8]){
float EdgeX[12], EdgeY[12], EdgeZ[12];
Surface* surf=*surf_list.begin();
unsigned char cubeIndex=0;
if(F[6] < .5)
cubeIndex |= 1;
if(F[7] < .5)
cubeIndex |= 2;
if(F[3] < .5)
cubeIndex |= 4;
if(F[2] < .5)
cubeIndex |= 8;
if(F[4] < .5)
cubeIndex |= 16;
if(F[5] < .5)
cubeIndex |= 32;
if(F[1] < .5)
cubeIndex |= 64;
if(F[0] < .5)
cubeIndex |= 128;
//look this value up in the edge table to see which edges to interpolate along
int usedEdges=edgeTable[cubeIndex];
//if the cube is entirely within/outside surface, no faces
if(usedEdges==0 || usedEdges==255)
return;
if(usedEdges & 1){
float Ratio = ( .5 - F[6] )/( F[7] - F[6] );
EdgeX[0] = x + Ratio*(x1 - x );
EdgeY[0] = y1 + Ratio*(y1 - y1);
EdgeZ[0] = z1 + Ratio*(z1 - z1);
}
if(usedEdges & 2){
float Ratio = ( .5 - F[7] )/( F[3] - F[7] );
EdgeX[1] = x1 + Ratio*(x1 - x1);
EdgeY[1] = y1 + Ratio*(y1 - y1);
EdgeZ[1] = z1 + Ratio*(z - z1);
}
if(usedEdges & 4){
float Ratio = ( .5 - F[3] )/( F[2] - F[3] );
EdgeX[2] = x1 + Ratio*(x - x1);
EdgeY[2] = y1 + Ratio*(y1 - y1);
EdgeZ[2] = z + Ratio*(z - z );
}
if(usedEdges & 8){
float Ratio = ( .5 - F[2] )/( F[6] - F[2] );
EdgeX[3] = x + Ratio*(x - x );
EdgeY[3] = y1 + Ratio*(y1 - y1);
EdgeZ[3] = z + Ratio*(z1 - z );
}
if(usedEdges & 16){
float Ratio = ( .5 - F[4] )/( F[5] - F[4] );
EdgeX[4] = x + Ratio*(x1 - x );
EdgeY[4] = y + Ratio*(y - y );
EdgeZ[4] = z1 + Ratio*(z1 - z1);
}
if(usedEdges & 32){
float Ratio = ( .5 - F[5] )/( F[1] - F[5] );
EdgeX[5] = x1 + Ratio*(x1 - x1);
EdgeY[5] = y + Ratio*(y - y );
EdgeZ[5] = z1 + Ratio*(z - z1);
}
if(usedEdges & 64){
float Ratio = ( .5 - F[1] )/( F[0] - F[1] );
EdgeX[6] = x1 + Ratio*(x - x1);
EdgeY[6] = y + Ratio*(y - y );
EdgeZ[6] = z + Ratio*(z - z );
}
if(usedEdges & 128){
float Ratio = ( .5 - F[0] )/( F[4] - F[0] );
EdgeX[7] = x + Ratio*(x - x );
EdgeY[7] = y + Ratio*(y - y );
EdgeZ[7] = z + Ratio*(z1 - z );
}
if(usedEdges & 256){
float Ratio = ( .5 - F[4] )/( F[6] - F[4] );
EdgeX[8] = x + Ratio*(x - x );
EdgeY[8] = y + Ratio*(y1 - y );
EdgeZ[8] = z1 + Ratio*(z1 - z1);
}
if(usedEdges & 512){
float Ratio = ( .5 - F[5] )/( F[7] - F[5] );
EdgeX[9] = x1 + Ratio*(x1 - x1);
EdgeY[9] = y + Ratio*(y1 - y );
EdgeZ[9] = z1 + Ratio*(z1 - z1);
}
if(usedEdges & 1024){
float Ratio = ( .5 - F[1] )/( F[3] - F[1] );
EdgeX[10] = x1 + Ratio*(x1 - x1);
EdgeY[10] = y + Ratio*(y1 - y );
EdgeZ[10] = z + Ratio*(z - z );
}
if(usedEdges & 2048){
float Ratio = ( .5 - F[0] )/( F[2] - F[0] );
EdgeX[11] = x + Ratio*(x - x );
EdgeY[11] = y + Ratio*(y1 - y );
EdgeZ[11] = z + Ratio*(z - z );
}
for(int k=0; triTable[cubeIndex][k]!=-1; k+=3){
vertices.push_back( EdgeX[triTable[cubeIndex][k+0]]);
vertices.push_back( EdgeY[triTable[cubeIndex][k+0]]);
vertices.push_back(-EdgeZ[triTable[cubeIndex][k+0]]);
vertices.push_back( EdgeX[triTable[cubeIndex][k+1]]);
vertices.push_back( EdgeY[triTable[cubeIndex][k+1]]);
vertices.push_back(-EdgeZ[triTable[cubeIndex][k+1]]);
vertices.push_back( EdgeX[triTable[cubeIndex][k+2]]);
vertices.push_back( EdgeY[triTable[cubeIndex][k+2]]);
vertices.push_back(-EdgeZ[triTable[cubeIndex][k+2]]);
if(brush.fx&4){
float ax,ay,az,bx,by,bz;
float nx,ny,nz;
ax = EdgeX[triTable[cubeIndex][k+1]]-EdgeX[triTable[cubeIndex][k+0]];
ay = EdgeY[triTable[cubeIndex][k+1]]-EdgeY[triTable[cubeIndex][k+0]];
az = EdgeZ[triTable[cubeIndex][k+1]]-EdgeZ[triTable[cubeIndex][k+0]];
bx = EdgeX[triTable[cubeIndex][k+2]]-EdgeX[triTable[cubeIndex][k+1]];
by = EdgeY[triTable[cubeIndex][k+2]]-EdgeY[triTable[cubeIndex][k+1]];
bz = EdgeZ[triTable[cubeIndex][k+2]]-EdgeZ[triTable[cubeIndex][k+1]];
nx = ( ay * bz ) - ( az * by );
ny = ( az * bx ) - ( ax * bz );
nz = ( ax * by ) - ( ay * bx );
surf->vert_norm.push_back(nx); surf->vert_norm.push_back(ny);surf->vert_norm.push_back(nz);
surf->vert_norm.push_back(nx); surf->vert_norm.push_back(ny);surf->vert_norm.push_back(nz);
surf->vert_norm.push_back(nx); surf->vert_norm.push_back(ny);surf->vert_norm.push_back(nz);
}else{
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+0]]+1,EdgeY[triTable[cubeIndex][k+0]],EdgeZ[triTable[cubeIndex][k+0]])-ScalarField(EdgeX[triTable[cubeIndex][k+0]]-1,EdgeY[triTable[cubeIndex][k+0]],EdgeZ[triTable[cubeIndex][k+0]]));
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+0]],EdgeY[triTable[cubeIndex][k+0]]+1,EdgeZ[triTable[cubeIndex][k+0]])-ScalarField(EdgeX[triTable[cubeIndex][k+0]],EdgeY[triTable[cubeIndex][k+0]]-1,EdgeZ[triTable[cubeIndex][k+0]]));
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+0]],EdgeY[triTable[cubeIndex][k+0]],EdgeZ[triTable[cubeIndex][k+0]]+1)-ScalarField(EdgeX[triTable[cubeIndex][k+0]],EdgeY[triTable[cubeIndex][k+0]],EdgeZ[triTable[cubeIndex][k+0]]-1));
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+1]]+1,EdgeY[triTable[cubeIndex][k+1]],EdgeZ[triTable[cubeIndex][k+1]])-ScalarField(EdgeX[triTable[cubeIndex][k+1]]-1,EdgeY[triTable[cubeIndex][k+1]],EdgeZ[triTable[cubeIndex][k+1]]));
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+1]],EdgeY[triTable[cubeIndex][k+1]]+1,EdgeZ[triTable[cubeIndex][k+1]])-ScalarField(EdgeX[triTable[cubeIndex][k+1]],EdgeY[triTable[cubeIndex][k+1]]-1,EdgeZ[triTable[cubeIndex][k+1]]));
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+1]],EdgeY[triTable[cubeIndex][k+1]],EdgeZ[triTable[cubeIndex][k+1]]+1)-ScalarField(EdgeX[triTable[cubeIndex][k+1]],EdgeY[triTable[cubeIndex][k+1]],EdgeZ[triTable[cubeIndex][k+1]]-1));
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+2]]+1,EdgeY[triTable[cubeIndex][k+2]],EdgeZ[triTable[cubeIndex][k+2]])-ScalarField(EdgeX[triTable[cubeIndex][k+2]]-1,EdgeY[triTable[cubeIndex][k+2]],EdgeZ[triTable[cubeIndex][k+2]]));
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+2]],EdgeY[triTable[cubeIndex][k+2]]+1,EdgeZ[triTable[cubeIndex][k+2]])-ScalarField(EdgeX[triTable[cubeIndex][k+2]],EdgeY[triTable[cubeIndex][k+2]]-1,EdgeZ[triTable[cubeIndex][k+2]]));
surf->vert_norm.push_back(ScalarField(EdgeX[triTable[cubeIndex][k+2]],EdgeY[triTable[cubeIndex][k+2]],EdgeZ[triTable[cubeIndex][k+2]]+1)-ScalarField(EdgeX[triTable[cubeIndex][k+2]],EdgeY[triTable[cubeIndex][k+2]],EdgeZ[triTable[cubeIndex][k+2]]-1));
}
/*surf->vert_col.push_back(1.0);
surf->vert_col.push_back(1.0);
surf->vert_col.push_back(1.0);
surf->vert_col.push_back(1.0);
surf->vert_col.push_back(1.0);
surf->vert_col.push_back(1.0);
surf->vert_col.push_back(1.0);
surf->vert_col.push_back(1.0);
surf->vert_col.push_back(1.0);*/
surf->no_verts+=3;
}
}
