Revoxelisation of stop-motion STL sequence

[SLGY]

Hi there, As requested here are the STL's and setup code for the Ornithopter sequence in this Youtube video. You mentioned you'd like to have a look for the purposes of improving the revoxelisation.

Here is the STL sequence in a zip file.

This is the code I used in my setup below. I'm sure anyone who knows C++ can write some much simpler code to reference 125+ meshes instead of the way I've done it, haha. Note that this positioning and rotation etc for this code is for a different STL sequence of a helicopter, so you'll need to adjust the centre point and rotation for the Orni. _lbm.update_movingboundaries() may also be called at the incorrect position in the loop...?

td::atomic_bool revoxelizing = false;
void revoxelize(LBM* lbm, Mesh* mesh) { // voxelize new frames in detached thread in parallel while LBM is running
    for (uint n = 0u; n < lbm->get_N(); n++) lbm->flags[n] &= ~TYPE_S; // clear flags
    voxelize_mesh_hull(*lbm, mesh, TYPE_S); // voxelize rotated mesh in lbm.flags
    revoxelizing = false; // indicate new voxelizer thread has finished
}
void main_setup() { // ORNITHOPTER SETUP
    // ######################################################### define simulation box size, viscosity and volume force ####################################
    const uint L = 512+128u;
    const float knots = 120.0f; // Initial speed of fluid?
    const float AoA = -2.0f; // Negative is nose down
    const float kmh = knots * 1.852f;
    const float si_u = kmh / 3.6f;
    const float si_x = 20.0f; //Characteristic Length
    const float si_rho = 1.15f; //Air Density
    const float si_nu = 1.48E-5f;
    const float Re = units.si_Re(si_x, si_u, si_nu); //Reynolds Number
    print_info("Re = " + to_string(Re));
    const float u = 0.08f;
    LBM lbm(L, L*3u/2u , L / 2u, units.nu_from_Re(Re, (float)L, u)); // Proportions of containing box
    // #####################################################################################################################################################
    const float size = 1.0f * (float)L;
    const float3 center = float3(lbm.center().x+0.0f*size, lbm.center().y+(-0.2f)*size, lbm.center().z+0.09f*size);
    const float3x3 rotation = float3x3(float3(1, 0, 0), -radians(AoA)); //Set initial orientation of object (CHECK AXIS SET CORRECTLY: x, y, z)
    float modelSize = size * 1.0f; //set relative model size here
    // *************Allocate ALL of the meshes*************
    Mesh* mesh1 = read_stl(get_exe_path() + "../stl/Sequence/1.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh2 = read_stl(get_exe_path() + "../stl/Sequence/2.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh3 = read_stl(get_exe_path() + "../stl/Sequence/3.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh4 = read_stl(get_exe_path() + "../stl/Sequence/4.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh5 = read_stl(get_exe_path() + "../stl/Sequence/5.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh6 = read_stl(get_exe_path() + "../stl/Sequence/6.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh7 = read_stl(get_exe_path() + "../stl/Sequence/7.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh8 = read_stl(get_exe_path() + "../stl/Sequence/8.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh9 = read_stl(get_exe_path() + "../stl/Sequence/9.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh10 = read_stl(get_exe_path() + "../stl/Sequence/10.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh11 = read_stl(get_exe_path() + "../stl/Sequence/11.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh12 = read_stl(get_exe_path() + "../stl/Sequence/12.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh13 = read_stl(get_exe_path() + "../stl/Sequence/13.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh14 = read_stl(get_exe_path() + "../stl/Sequence/14.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh15 = read_stl(get_exe_path() + "../stl/Sequence/15.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh16 = read_stl(get_exe_path() + "../stl/Sequence/16.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh17 = read_stl(get_exe_path() + "../stl/Sequence/17.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh18 = read_stl(get_exe_path() + "../stl/Sequence/18.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh19 = read_stl(get_exe_path() + "../stl/Sequence/19.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh20 = read_stl(get_exe_path() + "../stl/Sequence/20.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh21 = read_stl(get_exe_path() + "../stl/Sequence/21.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh22 = read_stl(get_exe_path() + "../stl/Sequence/22.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh23 = read_stl(get_exe_path() + "../stl/Sequence/23.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh24 = read_stl(get_exe_path() + "../stl/Sequence/24.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh25 = read_stl(get_exe_path() + "../stl/Sequence/25.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh26 = read_stl(get_exe_path() + "../stl/Sequence/26.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh27 = read_stl(get_exe_path() + "../stl/Sequence/27.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh28 = read_stl(get_exe_path() + "../stl/Sequence/28.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh29 = read_stl(get_exe_path() + "../stl/Sequence/29.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh30 = read_stl(get_exe_path() + "../stl/Sequence/30.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh31 = read_stl(get_exe_path() + "../stl/Sequence/31.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh32 = read_stl(get_exe_path() + "../stl/Sequence/32.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh33 = read_stl(get_exe_path() + "../stl/Sequence/33.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh34 = read_stl(get_exe_path() + "../stl/Sequence/34.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh35 = read_stl(get_exe_path() + "../stl/Sequence/35.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh36 = read_stl(get_exe_path() + "../stl/Sequence/36.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh37 = read_stl(get_exe_path() + "../stl/Sequence/37.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh38 = read_stl(get_exe_path() + "../stl/Sequence/38.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh39 = read_stl(get_exe_path() + "../stl/Sequence/39.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh40 = read_stl(get_exe_path() + "../stl/Sequence/40.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh41 = read_stl(get_exe_path() + "../stl/Sequence/41.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh42 = read_stl(get_exe_path() + "../stl/Sequence/42.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh43 = read_stl(get_exe_path() + "../stl/Sequence/43.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh44 = read_stl(get_exe_path() + "../stl/Sequence/44.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh45 = read_stl(get_exe_path() + "../stl/Sequence/45.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh46 = read_stl(get_exe_path() + "../stl/Sequence/46.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh47 = read_stl(get_exe_path() + "../stl/Sequence/47.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh48 = read_stl(get_exe_path() + "../stl/Sequence/48.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh49 = read_stl(get_exe_path() + "../stl/Sequence/49.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh50 = read_stl(get_exe_path() + "../stl/Sequence/50.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh51 = read_stl(get_exe_path() + "../stl/Sequence/51.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh52 = read_stl(get_exe_path() + "../stl/Sequence/52.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh53 = read_stl(get_exe_path() + "../stl/Sequence/53.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh54 = read_stl(get_exe_path() + "../stl/Sequence/54.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh55 = read_stl(get_exe_path() + "../stl/Sequence/55.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh56 = read_stl(get_exe_path() + "../stl/Sequence/56.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh57 = read_stl(get_exe_path() + "../stl/Sequence/57.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh58 = read_stl(get_exe_path() + "../stl/Sequence/58.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh59 = read_stl(get_exe_path() + "../stl/Sequence/59.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh60 = read_stl(get_exe_path() + "../stl/Sequence/60.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh61 = read_stl(get_exe_path() + "../stl/Sequence/61.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh62 = read_stl(get_exe_path() + "../stl/Sequence/62.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh63 = read_stl(get_exe_path() + "../stl/Sequence/63.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh64 = read_stl(get_exe_path() + "../stl/Sequence/64.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh65 = read_stl(get_exe_path() + "../stl/Sequence/65.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh66 = read_stl(get_exe_path() + "../stl/Sequence/66.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh67 = read_stl(get_exe_path() + "../stl/Sequence/67.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh68 = read_stl(get_exe_path() + "../stl/Sequence/68.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh69 = read_stl(get_exe_path() + "../stl/Sequence/69.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh70 = read_stl(get_exe_path() + "../stl/Sequence/70.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh71 = read_stl(get_exe_path() + "../stl/Sequence/71.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh72 = read_stl(get_exe_path() + "../stl/Sequence/72.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh73 = read_stl(get_exe_path() + "../stl/Sequence/73.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh74 = read_stl(get_exe_path() + "../stl/Sequence/74.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh75 = read_stl(get_exe_path() + "../stl/Sequence/75.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh76 = read_stl(get_exe_path() + "../stl/Sequence/76.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh77 = read_stl(get_exe_path() + "../stl/Sequence/77.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh78 = read_stl(get_exe_path() + "../stl/Sequence/78.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh79 = read_stl(get_exe_path() + "../stl/Sequence/79.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh80 = read_stl(get_exe_path() + "../stl/Sequence/80.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh81 = read_stl(get_exe_path() + "../stl/Sequence/81.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh82 = read_stl(get_exe_path() + "../stl/Sequence/82.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh83 = read_stl(get_exe_path() + "../stl/Sequence/83.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh84 = read_stl(get_exe_path() + "../stl/Sequence/84.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh85 = read_stl(get_exe_path() + "../stl/Sequence/85.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh86 = read_stl(get_exe_path() + "../stl/Sequence/86.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh87 = read_stl(get_exe_path() + "../stl/Sequence/87.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh88 = read_stl(get_exe_path() + "../stl/Sequence/88.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh89 = read_stl(get_exe_path() + "../stl/Sequence/89.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh90 = read_stl(get_exe_path() + "../stl/Sequence/90.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh91 = read_stl(get_exe_path() + "../stl/Sequence/91.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh92 = read_stl(get_exe_path() + "../stl/Sequence/92.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh93 = read_stl(get_exe_path() + "../stl/Sequence/93.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh94 = read_stl(get_exe_path() + "../stl/Sequence/94.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh95 = read_stl(get_exe_path() + "../stl/Sequence/95.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh96 = read_stl(get_exe_path() + "../stl/Sequence/96.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh97 = read_stl(get_exe_path() + "../stl/Sequence/97.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh98 = read_stl(get_exe_path() + "../stl/Sequence/98.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh99 = read_stl(get_exe_path() + "../stl/Sequence/99.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh100 = read_stl(get_exe_path() + "../stl/Sequence/100.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh101 = read_stl(get_exe_path() + "../stl/Sequence/101.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh102 = read_stl(get_exe_path() + "../stl/Sequence/102.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh103 = read_stl(get_exe_path() + "../stl/Sequence/103.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh104 = read_stl(get_exe_path() + "../stl/Sequence/104.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh105 = read_stl(get_exe_path() + "../stl/Sequence/105.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh106 = read_stl(get_exe_path() + "../stl/Sequence/106.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh107 = read_stl(get_exe_path() + "../stl/Sequence/107.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh108 = read_stl(get_exe_path() + "../stl/Sequence/108.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh109 = read_stl(get_exe_path() + "../stl/Sequence/109.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh110 = read_stl(get_exe_path() + "../stl/Sequence/110.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh111 = read_stl(get_exe_path() + "../stl/Sequence/111.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh112 = read_stl(get_exe_path() + "../stl/Sequence/112.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh113 = read_stl(get_exe_path() + "../stl/Sequence/113.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh114 = read_stl(get_exe_path() + "../stl/Sequence/114.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh115 = read_stl(get_exe_path() + "../stl/Sequence/115.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh116 = read_stl(get_exe_path() + "../stl/Sequence/116.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh117 = read_stl(get_exe_path() + "../stl/Sequence/117.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh118 = read_stl(get_exe_path() + "../stl/Sequence/118.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh119 = read_stl(get_exe_path() + "../stl/Sequence/119.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh120 = read_stl(get_exe_path() + "../stl/Sequence/120.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh121 = read_stl(get_exe_path() + "../stl/Sequence/121.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh122 = read_stl(get_exe_path() + "../stl/Sequence/122.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh123 = read_stl(get_exe_path() + "../stl/Sequence/123.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh124 = read_stl(get_exe_path() + "../stl/Sequence/124.stl", lbm.size(), center, rotation, modelSize);
    Mesh* mesh125 = read_stl(get_exe_path() + "../stl/Sequence/125.stl", lbm.size(), center, rotation, modelSize);
    int currentMesh = 1u;
    voxelize_mesh_hull(lbm, mesh1, TYPE_S);
    const uint N = lbm.get_N(), Nx = lbm.get_Nx(), Ny = lbm.get_Ny(), Nz = lbm.get_Nz(); for (uint n = 0u, x = 0u, y = 0u, z = 0u; n < N; n++, lbm.coordinates(n, x, y, z)) {
        // ############################################################## ############# define geometry #############################################################################################
        if (lbm.flags[n] != TYPE_S) lbm.u.y[n] = u;
        if (x == 0u || x == Nx - 1u || y == 0u || y == Ny - 1u || z == 0u || z == Nz - 1u) lbm.flags[n] = TYPE_E; // all non periodic
    }   // #########################################################################################################################################################################################
    key_4 = true;
    Clock clock;
    lbm.run(0u);
    while (lbm.get_t() < 120000u) {
        lbm.update_moving_boundaries(); // This TYPE_S flag update may be in the wrong position
        lbm.graphics.write_frame_png(get_exe_path() + "export/images/"); // Take screenshot
        //  *********** REVOXELISING / ROTATING SECTION ***********
        while (revoxelizing.load()) sleep(0.01f); // wait for voxelizer thread to finish (ORIGINAL WAS 0.01f)
        lbm.flags.write_to_device(); // lbm.flags on host is finished, write to device now
        //Set the STL selection value (0-60) for the Ornithopter
        if (currentMesh > 125) currentMesh = 1;
        // Select which mesh in the sequence to use - OMG THIS NEEDS TO BE MORE ELEGANT
        if (lbm.get_t() > 0u && lbm.get_t() < 80000) { //Set period of time which the revoxeliser is rotating object
            revoxelizing = true; // indicate new voxelizer thread is starting
            if (currentMesh == 1) {
                thread voxelizer(revoxelize, &lbm, mesh1); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 2) {
                thread voxelizer(revoxelize, &lbm, mesh2); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 3) {
                thread voxelizer(revoxelize, &lbm, mesh3); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 4) {
                thread voxelizer(revoxelize, &lbm, mesh4); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 5) {
                thread voxelizer(revoxelize, &lbm, mesh5); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 6) {
                thread voxelizer(revoxelize, &lbm, mesh6); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 7) {
                thread voxelizer(revoxelize, &lbm, mesh7); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 8) {
                thread voxelizer(revoxelize, &lbm, mesh8); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 9) {
                thread voxelizer(revoxelize, &lbm, mesh9); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 10) {
                thread voxelizer(revoxelize, &lbm, mesh10); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 11) {
                thread voxelizer(revoxelize, &lbm, mesh11); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 12) {
                thread voxelizer(revoxelize, &lbm, mesh12); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 13) {
                thread voxelizer(revoxelize, &lbm, mesh13); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 14) {
                thread voxelizer(revoxelize, &lbm, mesh14); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 15) {
                thread voxelizer(revoxelize, &lbm, mesh15); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 16) {
                thread voxelizer(revoxelize, &lbm, mesh16); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 17) {
                thread voxelizer(revoxelize, &lbm, mesh17); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 18) {
                thread voxelizer(revoxelize, &lbm, mesh18); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 19) {
                thread voxelizer(revoxelize, &lbm, mesh19); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 20) {
                thread voxelizer(revoxelize, &lbm, mesh20); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 21) {
                thread voxelizer(revoxelize, &lbm, mesh21); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 22) {
                thread voxelizer(revoxelize, &lbm, mesh22); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 23) {
                thread voxelizer(revoxelize, &lbm, mesh23); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 24) {
                thread voxelizer(revoxelize, &lbm, mesh24); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 24) {
                thread voxelizer(revoxelize, &lbm, mesh24); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 25) {
                thread voxelizer(revoxelize, &lbm, mesh25); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 26) {
                thread voxelizer(revoxelize, &lbm, mesh26); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 27) {
                thread voxelizer(revoxelize, &lbm, mesh27); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 28) {
                thread voxelizer(revoxelize, &lbm, mesh28); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 29) {
                thread voxelizer(revoxelize, &lbm, mesh29); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 30) {
                thread voxelizer(revoxelize, &lbm, mesh30); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 31) {
                thread voxelizer(revoxelize, &lbm, mesh31); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 32) {
                thread voxelizer(revoxelize, &lbm, mesh32); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 33) {
                thread voxelizer(revoxelize, &lbm, mesh33); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 34) {
                thread voxelizer(revoxelize, &lbm, mesh34); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 35) {
                thread voxelizer(revoxelize, &lbm, mesh35); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 36) {
                thread voxelizer(revoxelize, &lbm, mesh36); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 37) {
                thread voxelizer(revoxelize, &lbm, mesh37); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 38) {
                thread voxelizer(revoxelize, &lbm, mesh38); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 39) {
                thread voxelizer(revoxelize, &lbm, mesh39); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 40) {
                thread voxelizer(revoxelize, &lbm, mesh40); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 41) {
                thread voxelizer(revoxelize, &lbm, mesh41); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 42) {
                thread voxelizer(revoxelize, &lbm, mesh42); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 43) {
                thread voxelizer(revoxelize, &lbm, mesh43); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 44) {
                thread voxelizer(revoxelize, &lbm, mesh44); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 45) {
                thread voxelizer(revoxelize, &lbm, mesh45); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 46) {
                thread voxelizer(revoxelize, &lbm, mesh46); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 47) {
                thread voxelizer(revoxelize, &lbm, mesh47); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 48) {
                thread voxelizer(revoxelize, &lbm, mesh48); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 49) {
                thread voxelizer(revoxelize, &lbm, mesh49); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 50) {
                thread voxelizer(revoxelize, &lbm, mesh50); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 51) {
                thread voxelizer(revoxelize, &lbm, mesh51); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 52) {
                thread voxelizer(revoxelize, &lbm, mesh52); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 53) {
                thread voxelizer(revoxelize, &lbm, mesh53); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 54) {
                thread voxelizer(revoxelize, &lbm, mesh54); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 55) {
                thread voxelizer(revoxelize, &lbm, mesh55); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 56) {
                thread voxelizer(revoxelize, &lbm, mesh56); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 57) {
                thread voxelizer(revoxelize, &lbm, mesh57); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 58) {
                thread voxelizer(revoxelize, &lbm, mesh58); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 59) {
                thread voxelizer(revoxelize, &lbm, mesh59); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 60) {
                thread voxelizer(revoxelize, &lbm, mesh60); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 61) {
                thread voxelizer(revoxelize, &lbm, mesh61); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 62) {
                thread voxelizer(revoxelize, &lbm, mesh62); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 63) {
                thread voxelizer(revoxelize, &lbm, mesh63); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 64) {
                thread voxelizer(revoxelize, &lbm, mesh64); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            //Split IF function into two for error "Blocks nested too deeply"
            if (currentMesh == 65) {
                thread voxelizer(revoxelize, &lbm, mesh65); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 66) {
                thread voxelizer(revoxelize, &lbm, mesh66); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 67) {
                thread voxelizer(revoxelize, &lbm, mesh67); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 68) {
                thread voxelizer(revoxelize, &lbm, mesh68); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 69) {
                thread voxelizer(revoxelize, &lbm, mesh69); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 70) {
                thread voxelizer(revoxelize, &lbm, mesh70); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 71) {
                thread voxelizer(revoxelize, &lbm, mesh71); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 72) {
                thread voxelizer(revoxelize, &lbm, mesh72); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 73) {
                thread voxelizer(revoxelize, &lbm, mesh73); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 74) {
                thread voxelizer(revoxelize, &lbm, mesh74); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 75) {
                thread voxelizer(revoxelize, &lbm, mesh75); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 76) {
                thread voxelizer(revoxelize, &lbm, mesh76); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 77) {
                thread voxelizer(revoxelize, &lbm, mesh77); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 78) {
                thread voxelizer(revoxelize, &lbm, mesh78); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 79) {
                thread voxelizer(revoxelize, &lbm, mesh79); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 80) {
                thread voxelizer(revoxelize, &lbm, mesh80); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 81) {
                thread voxelizer(revoxelize, &lbm, mesh81); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 82) {
                thread voxelizer(revoxelize, &lbm, mesh82); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 83) {
                thread voxelizer(revoxelize, &lbm, mesh83); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 84) {
                thread voxelizer(revoxelize, &lbm, mesh84); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 85) {
                thread voxelizer(revoxelize, &lbm, mesh85); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 86) {
                thread voxelizer(revoxelize, &lbm, mesh86); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 87) {
                thread voxelizer(revoxelize, &lbm, mesh87); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 88) {
                thread voxelizer(revoxelize, &lbm, mesh88); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 89) {
                thread voxelizer(revoxelize, &lbm, mesh89); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 90) {
                thread voxelizer(revoxelize, &lbm, mesh90); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 91) {
                thread voxelizer(revoxelize, &lbm, mesh91); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 92) {
                thread voxelizer(revoxelize, &lbm, mesh92); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 93) {
                thread voxelizer(revoxelize, &lbm, mesh93); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 94) {
                thread voxelizer(revoxelize, &lbm, mesh94); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 95) {
                thread voxelizer(revoxelize, &lbm, mesh95); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 96) {
                thread voxelizer(revoxelize, &lbm, mesh96); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 97) {
                thread voxelizer(revoxelize, &lbm, mesh97); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 98) {
                thread voxelizer(revoxelize, &lbm, mesh98); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 99) {
                thread voxelizer(revoxelize, &lbm, mesh99); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 100) {
                thread voxelizer(revoxelize, &lbm, mesh100); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 101) {
                thread voxelizer(revoxelize, &lbm, mesh101); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 102) {
                thread voxelizer(revoxelize, &lbm, mesh102); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 103) {
                thread voxelizer(revoxelize, &lbm, mesh103); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 104) {
                thread voxelizer(revoxelize, &lbm, mesh104); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 105) {
                thread voxelizer(revoxelize, &lbm, mesh105); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 106) {
                thread voxelizer(revoxelize, &lbm, mesh106); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 107) {
                thread voxelizer(revoxelize, &lbm, mesh107); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 108) {
                thread voxelizer(revoxelize, &lbm, mesh108); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 109) {
                thread voxelizer(revoxelize, &lbm, mesh109); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 110) {
                thread voxelizer(revoxelize, &lbm, mesh110); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 111) {
                thread voxelizer(revoxelize, &lbm, mesh111); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 112) {
                thread voxelizer(revoxelize, &lbm, mesh112); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 113) {
                thread voxelizer(revoxelize, &lbm, mesh113); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 114) {
                thread voxelizer(revoxelize, &lbm, mesh114); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 115) {
                thread voxelizer(revoxelize, &lbm, mesh115); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 116) {
                thread voxelizer(revoxelize, &lbm, mesh116); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 117) {
                thread voxelizer(revoxelize, &lbm, mesh117); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 118) {
                thread voxelizer(revoxelize, &lbm, mesh118); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 119) {
                thread voxelizer(revoxelize, &lbm, mesh118); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 120) {
                thread voxelizer(revoxelize, &lbm, mesh120); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 121) {
                thread voxelizer(revoxelize, &lbm, mesh121); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 122) {
                thread voxelizer(revoxelize, &lbm, mesh122); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 123) {
                thread voxelizer(revoxelize, &lbm, mesh123); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 124) {
                thread voxelizer(revoxelize, &lbm, mesh124); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            else if (currentMesh == 125) {
                thread voxelizer(revoxelize, &lbm, mesh125); // start new voxelizer thread
                voxelizer.detach(); // detatch voxelizer thread so LBM can run in parallel
            }
            currentMesh++;
        }
        lbm.run(14u); // run LBM in parallel while CPU is voxelizing the next frame;
    }
    write_file(get_exe_path() + "time.txt", print_time(clock.stop()));
}

[trparry]

Wow nice! Regarding lbm.update_moving_boundaries() this is actually quite similar to what I'm trying to do at #39, where the velocity of the fluid nodes near the boundary need to be repeatedly set to the instantaneous velocity of the solid. I think it needs to look something like:

//once revoxelization is complete
lbm.u.read_from_device(); //read velocity field from GPU

//do stuff like modify boundary node velocity, using the velocity of the solid (still working on what to put here)
//for rotating body v = omega*r see issue #39

lbm.u.write_to_device(); //write the new instantaneous velocity of the boundary nodes to the GPU
lbm.update_moving_boundaries(); //update the moving boundary
lbm.run(14u);

[ProjectPhysX]

@SirWixy thank you so much! I will experiment with moving boundaries + revoxelization further, and I'll try to find a faster voxelization algorithm. This setup seems a very nice test case!

[SLGY]

Wow nice! Regarding lbm.update_moving_boundaries() this is actually quite similar to what I'm trying to do at #39, where the velocity of the fluid nodes near the boundary need to be repeatedly set to the instantaneous velocity of the solid. I think it needs to look something like:

//once revoxelization is complete
lbm.u.read_from_device(); //read velocity field from GPU

//do stuff like modify boundary node velocity, using the velocity of the solid (still working on what to put here)
//for rotating body v = omega*r see issue #39

lbm.u.write_to_device(); //write the new instantaneous velocity of the boundary nodes to the GPU
lbm.update_moving_boundaries(); //update the moving boundary
lbm.run(14u);

This is a bit of a delayed reply, I've been hitting a few complexity barriers with this project and I'm only now coming back to reattack the issue.

I don't think I'll be able to easily recalculate the instantaneous velocity of the boundary nodes using the stop-motion method I mentioned in this issue above. Each revoxelisation essentially involves the previous mesh disappearing and a new mesh appearing (not just a rotated mesh) and it is well beyond my ability to know if that's even something I can create an algorithm for.

Thanks for the help though. I'll continue making projects that rotate but hope that it doesn't happen fast enough to affect the resulting airflow too much (so I'll need to stay away from rotor blades and Ornithopters for now) 👍