studiorailgun/fluid-sim
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Multiarrays

Browse Source
This commit is contained in:
unknown 2023-07-23 12:20:14 -04:00
parent 426dd88d29
commit ad95b64b88
10 changed files with 716 additions and 1258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
src/main/c/chunkmask.c Normal file
View File

@ -0,0 +1,102 @@
#include <jni.h>
#include <stdint.h>
#include "includes/utilities.h"
#include "includes/chunkmask.h"
uint32_t matrix_transform(JNIEnv * env, jobjectArray jrx);
/**
* Calculates the bitmask for available chunks for the provided chunk's neighbor array
*/
JNIEXPORT jint JNICALL Java_electrosphere_FluidSim_calculateChunkMask(JNIEnv * env, jobject this, jobjectArray jrx){
return matrix_transform(env,jrx);
}
/**
* Calculates a mask that represents all nearby chunks that are actually accessible and exist
*/
uint32_t matrix_transform(JNIEnv * env, jobjectArray jrx){
//The returned value, an availability mask that contains the availability of each neighbor chunk
uint32_t rVal = 0;
//Add to maks for initial chunks
for(int i = 0; i < CENTER_LOC; i++){
if((*env)->GetObjectArrayElement(env,jrx,i)!=NULL){
rVal = rVal + 1;
}
rVal = rVal << 1;
}
//add 1 for center chunk because we already have that
rVal = rVal + 1;
rVal = rVal << 1;
//continue on for remaining chunks
for(int i = CENTER_LOC+1; i < 27; i++){
if((*env)->GetObjectArrayElement(env,jrx,i)!=NULL){
rVal = rVal + 1;
}
if(i < 26){
rVal = rVal << 1;
}
}
return rVal;
}
const uint32_t CHUNK_INDEX_ARR[] = {
CHUNK_000, CHUNK_100, CHUNK_200,
CHUNK_010, CHUNK_110, CHUNK_210,
CHUNK_020, CHUNK_120, CHUNK_220,
CHUNK_001, CHUNK_101, CHUNK_201,
CHUNK_011, CHUNK_111, CHUNK_211,
CHUNK_021, CHUNK_121, CHUNK_221,
CHUNK_002, CHUNK_102, CHUNK_202,
CHUNK_012, CHUNK_112, CHUNK_212,
CHUNK_022, CHUNK_122, CHUNK_222,
};
//control offsetting the advect sampler location if a valid neighbor chunk is hit
const char CHUNK_NORMALIZE_U[] = {
-1, 0, 1,
-1, 0, 1,
-1, 0, 1,
-1, 0, 1,
-1, 0, 1,
-1, 0, 1,
-1, 0, 1,
-1, 0, 1,
-1, 0, 1,
};
const char CHUNK_NORMALIZE_V[] = {
-1, -1, -1,
0, 0, 0,
1, 1, 1,
-1, -1, -1,
0, 0, 0,
1, 1, 1,
-1, -1, -1,
0, 0, 0,
1, 1, 1,
};
const char CHUNK_NORMALIZE_W[] = {
-1, -1, -1,
-1, -1, -1,
-1, -1, -1,
0, 0, 0,
0, 0, 0,
0, 0, 0,
1, 1, 1,
1, 1, 1,
1, 1, 1,
};

100
src/main/c/fluidsim.c
View File

@ -1,22 +1,24 @@
#include <jni.h>
#include <stdio.h>
#include <immintrin.h>
#include <stdint.h>
#include "includes/utilities.h"
#include "includes/chunkmask.h"
#define SWAP(x0,x) {float *tmp=x0;x0=x;x=tmp;}
#define IX(i,j,k) ((i)+(N)*(j)+(N*N)*(k))
#define LINEARSOLVERTIMES 10
void diffuse(int N, int b, float * x, float * x0, float diff, float dt);
void advect(int N, int b, float * d, float * d0, float * u, float * v, float * w, float dt);
void project(int N, float * u, float * v, float * w, float * p, float * div);
void set_bnd(int N, int b, float * x);
void dens_step(int N, float * x, float * x0, float * u, float * v, float * w, float diff, float dt);
void vel_step(int N, float * u, float * v, float * w, float * u0, float * v0, float * w0, float visc, float dt);
void lin_solve(int N, int b, float* x, float* x0, float a, float c);
void diffuse(JNIEnv * env, uint32_t chunk_mask, int N, int b, float * x, float * x0, float diff, float dt);
void advect(JNIEnv * env, uint32_t chunk_mask, int N, int b, jobjectArray jrd, float * d0, float * u, float * v, float * w, float dt);
void project(JNIEnv * env, uint32_t chunk_mask, int N, jobjectArray jru, jobjectArray jrv, jobjectArray jrw, float * p, float * div);
void set_bnd(JNIEnv * env, uint32_t chunk_mask, int N, int b, float * x);
void dens_step(JNIEnv * env, uint32_t chunk_mask, int N, jobjectArray jrx, float * x0, jobjectArray jru, jobjectArray jrv, jobjectArray jrw, float diff, float dt);
void vel_step(JNIEnv * env, uint32_t chunk_mask, int N, jobjectArray jru, jobjectArray jrv, jobjectArray jrw, float * u0, float * v0, float * w0, float visc, float dt);
void lin_solve(JNIEnv * env, uint32_t chunk_mask, int N, int b, float* x, float* x0, float a, float c);
/**
* The core simulation function
@ -25,8 +27,7 @@ JNIEXPORT void JNICALL Java_electrosphere_FluidSim_simulate(
JNIEnv * env,
jobject this,
jint DIM_X,
jint DIM_Y,
jint DIM_Z,
jint chunk_mask,
jobject jx,
jobject jx0,
jobject ju,
@ -39,18 +40,18 @@ JNIEXPORT void JNICALL Java_electrosphere_FluidSim_simulate(
jfloat VISCOSITY_RATE,
jfloat timestep){
jboolean isCopy;
float * x = (*env)->GetDirectBufferAddress(env,jx);
// float * x = (*env)->GetDirectBufferAddress(env,jx);
float * x0 = (*env)->GetDirectBufferAddress(env,jx0);
float * u = (*env)->GetDirectBufferAddress(env,ju);
float * v = (*env)->GetDirectBufferAddress(env,jv);
float * w = (*env)->GetDirectBufferAddress(env,jw);
// float * u = (*env)->GetDirectBufferAddress(env,ju);
// float * v = (*env)->GetDirectBufferAddress(env,jv);
// float * w = (*env)->GetDirectBufferAddress(env,jw);
float * u0 = (*env)->GetDirectBufferAddress(env,ju0);
float * v0 = (*env)->GetDirectBufferAddress(env,jv0);
float * w0 = (*env)->GetDirectBufferAddress(env,jw0);
int N = DIM_X;
int i,j,k;
vel_step(DIM_X, u, v, w, u0, v0, w0, VISCOSITY_RATE, timestep);
dens_step(DIM_X, x, x0, u, v, w, DIFFUSION_RATE, timestep);
vel_step(env, chunk_mask, DIM_X, ju, jv, jw, u0, v0, w0, VISCOSITY_RATE, timestep);
dens_step(env, chunk_mask, DIM_X, jx, x0, ju, jv, jw, DIFFUSION_RATE, timestep);
}
/**
@ -67,20 +68,22 @@ void add_source(int N, float * x, float * s, float dt){
/**
* Diffuses a given array by a diffusion constant
*/
void diffuse(int N, int b, float * x, float * x0, float diff, float dt){
void diffuse(JNIEnv * env, uint32_t chunk_mask, int N, int b, float * x, float * x0, float diff, float dt){
float a=dt*diff*N*N*N;
lin_solve(N, b, x, x0, a, 1+6*a);
lin_solve(env, chunk_mask, N, b, x, x0, a, 1+6*a);
}
/**
* Advects a given array based on the force vectors in the simulation
*/
void advect(int N, int b, float * d, float * d0, float * u, float * v, float * w, float dt){
void advect(JNIEnv * env, uint32_t chunk_mask, int N, int b, jobjectArray jrd, float * d0, float * u, float * v, float * w, float dt){
int i, j, k, i0, j0, k0, i1, j1, k1;
float x, y, z, s0, t0, s1, t1, u1, u0, dtx,dty,dtz;
dtx=dty=dtz=dt*N;
float * d = GET_ARR(env,jrd,CENTER_LOC);
for(k=1; k<N-1; k++){
for(j=1; j<N-1; j++){
for(i=1; i<N-1; i++){
@ -131,41 +134,48 @@ void advect(int N, int b, float * d, float * d0, float * u, float * v, float * w
}
}
}
set_bnd(N, b, d);
set_bnd(env, chunk_mask, N, b, d);
}
/**
* The main density step function
*/
void dens_step(int N, float * x, float * x0, float * u, float * v, float * w, float diff, float dt){
void dens_step(JNIEnv * env, uint32_t chunk_mask, int N, jobjectArray jrx, float * x0, jobjectArray jru, jobjectArray jrv, jobjectArray jrw, float diff, float dt){
float * x = GET_ARR(env,jrx,CENTER_LOC);
float * u = GET_ARR(env,jru,CENTER_LOC);
float * v = GET_ARR(env,jrv,CENTER_LOC);
float * w = GET_ARR(env,jrw,CENTER_LOC);
add_source(N, x, x0, dt);
SWAP(x0, x);
diffuse(N, 0, x, x0, diff, dt);
diffuse(env, chunk_mask, N, 0, x, x0, diff, dt);
SWAP(x0, x);
advect(N, 0, x, x0, u, v, w, dt);
advect(env, chunk_mask, N, 0, jrx, x0, u, v, w, dt);
}
/**
* The main velocity step function
*/
void vel_step(int N, float * u, float * v, float * w, float * u0, float * v0, float * w0, float visc, float dt){
void vel_step(JNIEnv * env, uint32_t chunk_mask, int N, jobjectArray jru, jobjectArray jrv, jobjectArray jrw, float * u0, float * v0, float * w0, float visc, float dt){
float * u = GET_ARR(env,jru,CENTER_LOC);
float * v = GET_ARR(env,jrv,CENTER_LOC);
float * w = GET_ARR(env,jrw,CENTER_LOC);
add_source(N, u, u0, dt);
add_source(N, v, v0, dt);
add_source(N, w, w0, dt);
SWAP(u0, u);
diffuse(N, 1, u, u0, visc, dt);
diffuse(env, chunk_mask, N, 1, u, u0, visc, dt);
SWAP(v0, v);
diffuse(N, 2, v, v0, visc, dt);
diffuse(env, chunk_mask, N, 2, v, v0, visc, dt);
SWAP(w0, w);
diffuse(N, 3, w, w0, visc, dt);
project(N, u, v, w, u0, v0);
diffuse(env, chunk_mask, N, 3, w, w0, visc, dt);
project(env, chunk_mask, N, jru, jrv, jrw, u0, v0);
SWAP(u0, u);
SWAP(v0, v);
SWAP(w0, w);
advect(N, 1, u, u0, u0, v0, w0, dt);
advect(N, 2, v, v0, u0, v0, w0, dt);
advect(N, 3, w, w0, u0, v0, w0, dt);
project(N, u, v, w, u0, v0);
advect(env, chunk_mask, N, 1, jru, u0, u0, v0, w0, dt);
advect(env, chunk_mask, N, 2, jrv, v0, u0, v0, w0, dt);
advect(env, chunk_mask, N, 3, jrw, w0, u0, v0, w0, dt);
project(env, chunk_mask, N, jru, jrv, jrw, u0, v0);
}
//used for temporary vector storage when appropriate
@ -174,7 +184,7 @@ float container[16];
/**
* Projects a given array based on force vectors
*/
void project(int N, float * u, float * v, float * w, float * p, float * div){
void project(JNIEnv * env, uint32_t chunk_mask, int N, jobjectArray jru, jobjectArray jrv, jobjectArray jrw, float * p, float * div){
int i, j, k;
__m256 nVector = _mm256_set1_ps(N);
@ -182,6 +192,10 @@ void project(int N, float * u, float * v, float * w, float * p, float * div){
__m256 zeroVec = _mm256_set1_ps(0);
__m256 vector, vector2, vector3;
float * u = GET_ARR(env,jru,CENTER_LOC);
float * v = GET_ARR(env,jrv,CENTER_LOC);
float * w = GET_ARR(env,jrw,CENTER_LOC);
for(k=1; k<N-1; k++){
for(j=1; j<N-1; j++){
i = 1;
@ -231,10 +245,10 @@ void project(int N, float * u, float * v, float * w, float * p, float * div){
}
}
set_bnd(N, 0, div);
set_bnd(N, 0, p);
set_bnd(env, chunk_mask, N, 0, div);
set_bnd(env, chunk_mask, N, 0, p);
lin_solve(N, 0, p, div, 1, 6);
lin_solve(env, chunk_mask, N, 0, p, div, 1, 6);
constScalar = _mm256_set1_ps(0.5f*N);
@ -294,15 +308,15 @@ void project(int N, float * u, float * v, float * w, float * p, float * div){
}
}
set_bnd(N, 1, u);
set_bnd(N, 2, v);
set_bnd(N, 3, w);
set_bnd(env, chunk_mask, N, 1, u);
set_bnd(env, chunk_mask, N, 2, v);
set_bnd(env, chunk_mask, N, 3, w);
}
/**
* Solves a linear system of equations in a vectorized manner
*/
void lin_solve(int N, int b, float* x, float* x0, float a, float c){
void lin_solve(JNIEnv * env, uint32_t chunk_mask, int N, int b, float* x, float* x0, float a, float c){
int i, j, k, l, m;
__m256 aScalar = _mm256_set1_ps(a);
__m256 cScalar = _mm256_set1_ps(c);
@ -333,14 +347,14 @@ void lin_solve(int N, int b, float* x, float* x0, float a, float c){
}
}
}
set_bnd(N, b, x);
set_bnd(env, chunk_mask, N, b, x);
}
}
/**
* Sets the bounds of the simulation
*/
void set_bnd(int N, int b, float * target){
void set_bnd(JNIEnv * env, uint32_t chunk_mask, int N, int b, float * target){
int DIM = N;
for(int x=1; x < DIM-1; x++){
for(int y = 1; y < DIM-1; y++){

48
src/main/c/includes/chunkmask.h Normal file
View File

@ -0,0 +1,48 @@
#include <stdint.h>
#ifndef CHUNKMASK_H
#define CHUNKMASK_H
#define CENTER_LOC 13
#define CHUNK_222 1
#define CHUNK_122 2
#define CHUNK_022 4
#define CHUNK_212 8
#define CHUNK_112 16
#define CHUNK_012 32
#define CHUNK_202 64
#define CHUNK_102 128
#define CHUNK_002 256
#define CHUNK_221 512
#define CHUNK_121 1024
#define CHUNK_021 2048
#define CHUNK_211 4096
#define CHUNK_111 8192
#define CHUNK_011 16384
#define CHUNK_201 32768
#define CHUNK_101 65536
#define CHUNK_001 131072
#define CHUNK_220 262144
#define CHUNK_120 524288
#define CHUNK_020 1048576
#define CHUNK_210 2097152
#define CHUNK_110 4194304
#define CHUNK_010 8388608
#define CHUNK_200 16777216
#define CHUNK_100 33554432
#define CHUNK_000 67108864
extern const uint32_t CHUNK_INDEX_ARR[];
//control offsetting the advect sampler location if a valid neighbor chunk is hit
extern const char CHUNK_NORMALIZE_U[];
extern const char CHUNK_NORMALIZE_V[];
extern const char CHUNK_NORMALIZE_W[];
#endif

20
src/main/c/includes/electrosphere_FluidSim.h
View File

@ -20,10 +20,26 @@ extern "C" {
/*
* Class: electrosphere_FluidSim
* Method: simulate
* Signature: (IIILjava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;FFF)V
* Signature: (II[Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;[Ljava/nio/ByteBuffer;[Ljava/nio/ByteBuffer;[Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;FFF)V
*/
JNIEXPORT void JNICALL Java_electrosphere_FluidSim_simulate
(JNIEnv *, jobject, jint, jint, jint, jobject, jobject, jobject, jobject, jobject, jobject, jobject, jobject, jfloat, jfloat, jfloat);
(JNIEnv *, jobject, jint, jint, jobjectArray, jobject, jobjectArray, jobjectArray, jobjectArray, jobject, jobject, jobject, jfloat, jfloat, jfloat);
/*
* Class: electrosphere_FluidSim
* Method: linSolve
* Signature: (IIILjava/nio/ByteBuffer;Ljava/nio/ByteBuffer;FF)V
*/
JNIEXPORT void JNICALL Java_electrosphere_FluidSim_linSolve
(JNIEnv *, jobject, jint, jint, jint, jobject, jobject, jfloat, jfloat);
/*
* Class: electrosphere_FluidSim
* Method: calculateChunkMask
* Signature: ([Ljava/nio/ByteBuffer;)I
*/
JNIEXPORT jint JNICALL Java_electrosphere_FluidSim_calculateChunkMask
(JNIEnv *, jobject, jobjectArray);
#ifdef __cplusplus
}

15
src/main/c/includes/utilities.h Normal file
View File

@ -0,0 +1,15 @@
#include <jni.h>
#include <stdint.h>
#ifndef UTILITIES_H
#define UTILITIES_H
#define SWAP(x0,x) {float *tmp=x0;x0=x;x=tmp;}
#define IX(i,j,k) ((i)+(N)*(j)+(N*N)*(k))
#define CK(m,n,o) ((m)+(n)*(3)+(o)*(3)*(3))
#define GET_ARR(env,src,i) (*env)->GetDirectBufferAddress(env,(*env)->GetObjectArrayElement(env,src,i))
#define ARR_EXISTS(chunk_mask,m,n,o) (chunk_mask & CHUNK_INDEX_ARR[CK(m,n,o)]) > 0
void lin_solve(JNIEnv * env, uint32_t chunk_mask, int N, int b, float* x, float* x0, float a, float c);
#endif

59
src/main/c/linearsolver.c Normal file
View File

@ -0,0 +1,59 @@
#include <jni.h>
#include <immintrin.h>
#include <stdint.h>
#include "includes/utilities.h"
JNIEXPORT void JNICALL Java_electrosphere_FluidSim_linSolve(
JNIEnv * env,
jobject this,
jint chunk_mask_raw,
jint DIM_X,
jint br,
jobject jrx,
jobject jrx0,
jfloat ar,
jfloat cr
){
//adapt object types
float * x = (*env)->GetDirectBufferAddress(env,jrx);
float * x0 = (*env)->GetDirectBufferAddress(env,jrx0);
//solve
lin_solve(env,chunk_mask_raw,DIM_X,br,x,x0,ar,cr);
}
/**
* Solves a linear system of equations in a vectorized manner
*/
void lin_solve(JNIEnv * env, uint32_t chunk_mask, int N, int b, float* x, float* x0, float a, float c){
int i, j, k, l, m;
__m256 aScalar = _mm256_set1_ps(a);
__m256 cScalar = _mm256_set1_ps(c);
// update for each cell
for(k=1; k<N-1; k++){
for(j=1; j<N-1; j++){
int n = 0;
//solve as much as possible vectorized
for(i = 1; i < N-1; i=i+8){
__m256 vector = _mm256_loadu_ps(&x[IX(i-1,j,k)]);
vector = _mm256_add_ps(vector,_mm256_loadu_ps(&x[IX(i+1,j,k)]));
vector = _mm256_add_ps(vector,_mm256_loadu_ps(&x[IX(i,j-1,k)]));
vector = _mm256_add_ps(vector,_mm256_loadu_ps(&x[IX(i,j+1,k)]));
vector = _mm256_add_ps(vector,_mm256_loadu_ps(&x[IX(i,j,k-1)]));
vector = _mm256_add_ps(vector,_mm256_loadu_ps(&x[IX(i,j,k+1)]));
vector = _mm256_mul_ps(vector,aScalar);
vector = _mm256_add_ps(vector,_mm256_loadu_ps(&x0[IX(i,j,k)]));
vector = _mm256_div_ps(vector,cScalar);
_mm256_storeu_ps(&x[IX(i,j,k)],vector);
}
//If there is any leftover, perform manual solving
if(i>N-1){
for(i=i-8; i < N-1; i++){
x[IX(i,j,k)] = (x0[IX(i,j,k)] + a*(x[IX(i-1,j,k)]+x[IX(i+1,j,k)]+x[IX(i,j-1,k)]+x[IX(i,j+1,k)]+x[IX(i,j,k-1)]+x[IX(i,j,k+1)]))/c;
}
}
}
}
}

246
src/main/java/electrosphere/FluidSim.java
View File

@ -12,6 +12,7 @@ import java.util.Random;
import java.util.Set;
import org.joml.Vector2i;
import org.joml.Vector3i;
import org.lwjgl.BufferUtils;
import org.lwjgl.PointerBuffer;
import org.lwjgl.system.MemoryUtil;
@ -28,14 +29,41 @@ public class FluidSim {
public static final int DIM = 18;
ByteBuffer x = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
ByteBuffer x0 = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
ByteBuffer u = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
ByteBuffer v = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
ByteBuffer w = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
ByteBuffer u0 = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
ByteBuffer v0 = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
ByteBuffer w0 = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
//
// +-------------+ ^ Y
// / | / | | _
// / | / | | /\ Z
//(0,2,0) +-----+-------+ | | /
// | +-------+-----+ | /
// | / | / | /
// | / | / |/
// +-------------+ (2,0,0) +---------------> X
//Buffers that contain density for current frame
ByteBuffer[] density = new ByteBuffer[27];
//Buffers that contain new density to add to the simulation
ByteBuffer densityAddition;
//Buffers that contain u vector directions
ByteBuffer[] uVector = new ByteBuffer[27];
//Buffers that contain v vector directions
ByteBuffer[] vVector = new ByteBuffer[27];
//Buffers that contain w vector directions
ByteBuffer[] wVector = new ByteBuffer[27];
//Buffers that contain u vector directions to add to the simulation
ByteBuffer uAdditionVector;
//Buffers that contain v vector directions to add to the simulation
ByteBuffer vAdditionVector;
//Buffers that contain w vector directions to add to the simulation
ByteBuffer wAdditionVector;
// ByteBuffer x = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
// ByteBuffer x0 = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
// ByteBuffer u = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
// ByteBuffer v = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
// ByteBuffer w = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
// ByteBuffer u0 = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
// ByteBuffer v0 = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
// ByteBuffer w0 = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
//The densities for every voxel for the current frame
float[] densityArrayView = new float[DIM * DIM * DIM];
@ -58,19 +86,31 @@ public class FluidSim {
static final float GRAVITY = -1000f;
public void setup(){
x.order(ByteOrder.LITTLE_ENDIAN);
x0.order(ByteOrder.LITTLE_ENDIAN);
u.order(ByteOrder.LITTLE_ENDIAN);
v.order(ByteOrder.LITTLE_ENDIAN);
w.order(ByteOrder.LITTLE_ENDIAN);
u0.order(ByteOrder.LITTLE_ENDIAN);
v0.order(ByteOrder.LITTLE_ENDIAN);
w0.order(ByteOrder.LITTLE_ENDIAN);
FloatBuffer xf = x.asFloatBuffer();
FloatBuffer uf = u.asFloatBuffer();
FloatBuffer vf = v.asFloatBuffer();
FloatBuffer wf = w.asFloatBuffer();
public void setup(Vector3i offset){
//allocate buffers for this chunk
density[13] = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
densityAddition = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
uVector[13] = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
vVector[13] = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
wVector[13] = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
uAdditionVector = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
vAdditionVector = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
wAdditionVector = ByteBuffer.allocateDirect(DIM * DIM * DIM * 4);
//order endian-ness
density[13].order(ByteOrder.LITTLE_ENDIAN);
densityAddition.order(ByteOrder.LITTLE_ENDIAN);
uVector[13].order(ByteOrder.LITTLE_ENDIAN);
vVector[13].order(ByteOrder.LITTLE_ENDIAN);
wVector[13].order(ByteOrder.LITTLE_ENDIAN);
uAdditionVector.order(ByteOrder.LITTLE_ENDIAN);
vAdditionVector.order(ByteOrder.LITTLE_ENDIAN);
wAdditionVector.order(ByteOrder.LITTLE_ENDIAN);
//set initial values for chunk
FloatBuffer xf = density[13].asFloatBuffer();
FloatBuffer uf = uVector[13].asFloatBuffer();
FloatBuffer vf = vVector[13].asFloatBuffer();
FloatBuffer wf = wVector[13].asFloatBuffer();
Random rand = new Random(1);
//make a cube of water in the center
@ -78,12 +118,12 @@ public class FluidSim {
for(int j = 0; j < DIM; j++){
for(int k = 0; k < DIM; k++){
if(
Math.abs(16 - i) < 4 &&
Math.abs(8 - i) < 4 &&
Math.abs(j) < 4 &&
Math.abs(10 - k) < 4
Math.abs(16 - k) < 4
){
xf.put(1);
uf.put(rand.nextFloat() * 0.1f);
uf.put(18);
vf.put(-1f);
wf.put(rand.nextFloat() * 0.1f);
} else {
@ -112,31 +152,45 @@ public class FluidSim {
//
writeNewStateIntoBuffers();
if(x.position() > 0){
x.position(0);
}
if(x0.position() > 0){
x0.position(0);
}
if(u.position() > 0){
u.position(0);
}
if(v.position() > 0){
v.position(0);
}
if(w.position() > 0){
w.position(0);
}
if(u0.position() > 0){
u0.position(0);
}
if(v0.position() > 0){
v0.position(0);
}
if(w0.position() > 0){
w0.position(0);
}
simulate(DIM, DIM, DIM, x, x0, u, v, w, u0, v0, w0, DIFFUSION_CONSTANT, VISCOSITY_CONSTANT, timestep);
// if(x.position() > 0){
// x.position(0);
// }
// if(x0.position() > 0){
// x0.position(0);
// }
// if(u.position() > 0){
// u.position(0);
// }
// if(v.position() > 0){
// v.position(0);
// }
// if(w.position() > 0){
// w.position(0);
// }
// if(u0.position() > 0){
// u0.position(0);
// }
// if(v0.position() > 0){
// v0.position(0);
// }
// if(w0.position() > 0){
// w0.position(0);
// }
simulate(
DIM,
0,
density,
densityAddition,
uVector,
vVector,
wVector,
uAdditionVector,
vAdditionVector,
wAdditionVector,
DIFFUSION_CONSTANT,
VISCOSITY_CONSTANT,
timestep
);
//
//Reads out the results of the fluid sim
@ -153,25 +207,29 @@ public class FluidSim {
//
//Read data back into arrays
//
if(x.position() > 0){
x.position(0);
if(density[13].position() > 0){
density[13].position(0);
}
if(u.position() > 0){
u.position(0);
if(uVector[13].position() > 0){
uVector[13].position(0);
}
if(v.position() > 0){
v.position(0);
if(vVector[13].position() > 0){
vVector[13].position(0);
}
if(w.position() > 0){
w.position(0);
if(wVector[13].position() > 0){
wVector[13].position(0);
}
FloatBuffer xFloatView = density[13].asFloatBuffer();
FloatBuffer uFloatView = uVector[13].asFloatBuffer();
FloatBuffer vFloatView = vVector[13].asFloatBuffer();
FloatBuffer wFloatView = wVector[13].asFloatBuffer();
for(int i = 0; i < DIM; i++){
for(int j = 0; j < DIM; j++){
for(int k = 0; k < DIM; k++){
densityArrayView[IX(i,j,k)] = x.getFloat();
uArrayView[IX(i,j,k)] = u.getFloat();
vArrayView[IX(i,j,k)] = v.getFloat();
wArrayView[IX(i,j,k)] = w.getFloat();
densityArrayView[IX(i,j,k)] = xFloatView.get();
uArrayView[IX(i,j,k)] = uFloatView.get();
vArrayView[IX(i,j,k)] = vFloatView.get();
wArrayView[IX(i,j,k)] = wFloatView.get();
}
}
}
@ -181,22 +239,22 @@ public class FluidSim {
* Writes data from the java-side arrays into buffers that get passed into c-side
*/
private void writeNewStateIntoBuffers(){
if(x0.position() > 0){
x0.position(0);
if(densityAddition.position() > 0){
densityAddition.position(0);
}
if(u0.position() > 0){
u0.position(0);
if(uAdditionVector.position() > 0){
uAdditionVector.position(0);
}
if(v0.position() > 0){
v0.position(0);
if(vAdditionVector.position() > 0){
vAdditionVector.position(0);
}
if(w0.position() > 0){
w0.position(0);
if(wAdditionVector.position() > 0){
wAdditionVector.position(0);
}
FloatBuffer x0FloatView = x0.asFloatBuffer();
FloatBuffer u0FloatView = u0.asFloatBuffer();
FloatBuffer v0FloatView = v0.asFloatBuffer();
FloatBuffer w0FloatView = w0.asFloatBuffer();
FloatBuffer x0FloatView = densityAddition.asFloatBuffer();
FloatBuffer u0FloatView = uAdditionVector.asFloatBuffer();
FloatBuffer v0FloatView = vAdditionVector.asFloatBuffer();
FloatBuffer w0FloatView = wAdditionVector.asFloatBuffer();
for(int i = 0; i < DIM; i++){
for(int j = 0; j < DIM; j++){
for(int k = 0; k < DIM; k++){
@ -241,13 +299,12 @@ public class FluidSim {
*/
private native void simulate(
int DIM_X,
int DIM_Y,
int DIM_Z,
ByteBuffer x,
int chunkMask,
ByteBuffer[] x,
ByteBuffer x0,
ByteBuffer u,
ByteBuffer v,
ByteBuffer w,
ByteBuffer[] u,
ByteBuffer[] v,
ByteBuffer[] w,
ByteBuffer u0,
ByteBuffer v0,
ByteBuffer w0,
@ -256,6 +313,10 @@ public class FluidSim {
float timestep
);
private native void linSolve(int chunk_mask, int N, int b, ByteBuffer x, ByteBuffer x0, float a, float c);
private native int calculateChunkMask(ByteBuffer[] densityBuffers);
public float[] getData(){
return densityArrayView;
}
@ -264,4 +325,31 @@ public class FluidSim {
return ((x)+(DIM)*(y) + (DIM)*(DIM)*(z));
}
public static final int getNeighborIndex(int x, int y, int z){
return x + y * 3 + z * 3 * 3;
}
public ByteBuffer getDensityBuffer(){
return density[getNeighborIndex(1,1,1)];
}
public ByteBuffer getUBuffer(){
return uVector[getNeighborIndex(1,1,1)];
}
public ByteBuffer getVBuffer(){
return vVector[getNeighborIndex(1,1,1)];
}
public ByteBuffer getWBuffer(){
return wVector[getNeighborIndex(1,1,1)];
}
public void setNeighbor(int x, int y, int z, FluidSim neighbor){
density[getNeighborIndex(x,y,z)] = neighbor.getDensityBuffer();
uVector[getNeighborIndex(x,y,z)] = neighbor.getUBuffer();
vVector[getNeighborIndex(x,y,z)] = neighbor.getVBuffer();
wVector[getNeighborIndex(x,y,z)] = neighbor.getWBuffer();
}
}

99
src/main/java/electrosphere/Main.java
View File

@ -4,8 +4,11 @@ import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Scanner;
import java.util.concurrent.TimeUnit;
import org.joml.Vector3i;
import electrosphere.render.GLFWContext;
import electrosphere.render.Mesh;
@ -14,30 +17,114 @@ import electrosphere.render.Mesh;
*/
public class Main {
public static void main(String args[]){
try {
GLFWContext.init();
FluidSim sim = new FluidSim();
sim.setup();
Mesh.meshInitially(sim);
//init shader program
Mesh.initShaderProgram();
int dim = 1;
FluidSim[][][] simArray = new FluidSim[dim][1][1];
for(int x = 0; x < simArray.length; x++){
for(int y = 0; y < simArray[0].length; y++){
for(int z = 0; z < simArray[0][0].length; z++){
simArray[x][y][z] = new FluidSim();
simArray[x][y][z].setup(new Vector3i(x,y,z));
}
}
}
//set sim adjacencies
for(int x = 0; x < simArray.length; x++){
for(int y = 0; y < simArray[0].length; y++){
for(int z = 0; z < simArray[0][0].length; z++){
FluidSim current = simArray[x][y][z];
for(int i = -1; i < 2; i++){
for(int j = -1; j < 2; j++){
for(int k = -1; k < 2; k++){
if(i == j && j == k && k == 0){
continue;
}
if(
0 <= x + i && x + i < simArray.length &&
0 <= y + j && y + j < simArray[0].length &&
0 <= z + k && z + k < simArray[0][0].length
){
current.setNeighbor(i+1,j+1,k+1,simArray[x+i][y+j][z+k]);
}
}
}
}
}
}
}
// FluidSim sim = new FluidSim();
// sim.setup();
Mesh[][][] meshArray = new Mesh[dim][1][1];
for(int x = 0; x < simArray.length; x++){
for(int y = 0; y < simArray[0].length; y++){
for(int z = 0; z < simArray[0][0].length; z++){
meshArray[x][y][z] = new Mesh(simArray[x][y][z], new Vector3i(z * 16, y * 16, x * 16));
meshArray[x][y][z].meshInitially();
}
}
}
// Mesh mesh = new Mesh(sim);
// mesh.meshInitially();
int i = 0;
long time = 0;
long lastTime = 0;
Scanner scan = new Scanner(System.in);
while(true){
try {
TimeUnit.MILLISECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//
//Transfer data
//
lastTime = System.currentTimeMillis();
sim.simulate(i,0.001f);
// for(int x = 0; x < simArray.length; x++){
// for(int y = 0; y < simArray[0].length; y++){
// for(int z = 0; z < simArray[0][0].length; z++){
// simArray[x][y][z].transfer();
// }
// }
// }
//
//Simulate
//
for(int x = 0; x < simArray.length; x++){
for(int y = 0; y < simArray[0].length; y++){
for(int z = 0; z < simArray[0][0].length; z++){
simArray[x][y][z].simulate(i, 0.001f);
}
}
}
time = time + (System.currentTimeMillis() - lastTime);
Mesh.remesh(sim,i);
GLFWContext.redraw();
//
//Remesh
//
for(int x = 0; x < simArray.length; x++){
for(int y = 0; y < simArray[0].length; y++){
for(int z = 0; z < simArray[0][0].length; z++){
meshArray[x][y][z].remesh();
}
}
}
//redraw
GLFWContext.redraw(meshArray);
i++;
if(i == 1000){
System.out.println(time / 1000.0);
}
if(i > 3){
// scan.next();
}
}
} catch(Throwable ex){
ex.printStackTrace(System.err);

10
src/main/java/electrosphere/render/GLFWContext.java
View File

@ -82,13 +82,19 @@ public class GLFWContext {
GLFW.glfwSwapInterval(0);
}
public static void redraw(){
public static void redraw(Mesh[][][] meshes){
//clear screen
GL44.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
GL44.glClear(GL44.GL_COLOR_BUFFER_BIT | GL44.
GL_DEPTH_BUFFER_BIT);
//draw here
Mesh.draw();
for(int x = 0; x < meshes.length; x++){
for(int y = 0; y < meshes[0].length; y++){
for(int z = 0; z < meshes[0][0].length; z++){
meshes[x][y][z].draw();
}
}
}
//ending stuff
GLFW.glfwSwapBuffers(window);
GLFW.glfwPollEvents();

1275
src/main/java/electrosphere/render/Mesh.java
View File

File diff suppressed because it is too large Load Diff