source/blender/blenkernel/intern/fluidsim.c

   1 /**
   2  * fluidsim.c
   3  *
   4  *
   5  * ***** BEGIN GPL LICENSE BLOCK *****
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software Foundation,
  19  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  *
  21  * The Original Code is Copyright (C) Blender Foundation
  22  * All rights reserved.
  23  *
  24  * The Original Code is: all of this file.
  25  *
  26  * Contributor(s): none yet.
  27  *
  28  * ***** END GPL LICENSE BLOCK *****
  29  */
  30
  31 #include "MEM_guardedalloc.h"
  32
  33 #include "DNA_mesh_types.h"
  34 #include "DNA_meshdata_types.h"
  35 #include "DNA_object_force.h" // for pointcache
  36 #include "DNA_particle_types.h"
  37 #include "DNA_scene_types.h" // N_T
  38
  39 #include "BLI_arithb.h"
  40 #include "BLI_blenlib.h"
  41
  42 #include "BKE_cdderivedmesh.h"
  43 #include "BKE_customdata.h"
  44 #include "BKE_DerivedMesh.h"
  45 #include "BKE_fluidsim.h"
  46 #include "BKE_global.h"
  47 #include "BKE_modifier.h"
  48 #include "BKE_mesh.h"
  49 #include "BKE_pointcache.h"
  50 #include "BKE_utildefines.h"
  51
  52 // headers for fluidsim bobj meshes
  53 #include <stdlib.h>
  54 #include "LBM_fluidsim.h"
  55 #include "elbeem.h"
  56 #include <zlib.h>
  57 #include <string.h>
  58 #include <stdio.h>
  59
  60 /* ************************* fluidsim bobj file handling **************************** */
  61
  62 #ifndef DISABLE_ELBEEM
  63
  64 // -----------------------------------------
  65 // forward decleration
  66 // -----------------------------------------
  67
  68 // -----------------------------------------
  69
  70 void fluidsim_init(FluidsimModifierData *fluidmd)
  71 {
  72         if(fluidmd)
  73         {
  74                 FluidsimSettings *fss = MEM_callocN(sizeof(FluidsimSettings), "fluidsimsettings");
  75
  76                 fluidmd->fss = fss;
  77
  78                 if(!fss)
  79                         return;
  80
  81                 fss->type = 0;
  82                 fss->show_advancedoptions = 0;
  83
  84                 fss->resolutionxyz = 50;
  85                 fss->previewresxyz = 25;
  86                 fss->realsize = 0.03;
  87                 fss->guiDisplayMode = 2; // preview
  88                 fss->renderDisplayMode = 3; // render
  89
  90                 fss->viscosityMode = 2; // default to water
  91                 fss->viscosityValue = 1.0;
  92                 fss->viscosityExponent = 6;
  93
  94                 // dg TODO: change this to []
  95                 fss->gravx = 0.0;
  96                 fss->gravy = 0.0;
  97                 fss->gravz = -9.81;
  98                 fss->animStart = 0.0;
  99                 fss->animEnd = 0.30;
 100                 fss->gstar = 0.005; // used as normgstar
 101                 fss->maxRefine = -1;
 102                 // maxRefine is set according to resolutionxyz during bake
 103
 104                 // fluid/inflow settings
 105                 // fss->iniVel --> automatically set to 0
 106
 107                 /*  elubie: changed this to default to the same dir as the render output
 108                 to prevent saving to C:\ on Windows */
 109                 BLI_strncpy(fss->surfdataPath, btempdir, FILE_MAX);
 110
 111                 // first init of bounding box
 112                 // no bounding box needed
 113
 114                 // todo - reuse default init from elbeem!
 115                 fss->typeFlags = 0;
 116                 fss->domainNovecgen = 0;
 117                 fss->volumeInitType = 1; // volume
 118                 fss->partSlipValue = 0.0;
 119
 120                 fss->generateTracers = 0;
 121                 fss->generateParticles = 0.0;
 122                 fss->surfaceSmoothing = 1.0;
 123                 fss->surfaceSubdivs = 1.0;
 124                 fss->particleInfSize = 0.0;
 125                 fss->particleInfAlpha = 0.0;
 126
 127                 // init fluid control settings
 128                 fss->attractforceStrength = 0.2;
 129                 fss->attractforceRadius = 0.75;
 130                 fss->velocityforceStrength = 0.2;
 131                 fss->velocityforceRadius = 0.75;
 132                 fss->cpsTimeStart = fss->animStart;
 133                 fss->cpsTimeEnd = fss->animEnd;
 134                 fss->cpsQuality = 10.0; // 1.0 / 10.0 => means 0.1 width
 135
 136                 /*
 137                 BAD TODO: this is done in buttons_object.c in the moment
 138                 Mesh *mesh = ob->data;
 139                 // calculate bounding box
 140                 fluid_get_bb(mesh->mvert, mesh->totvert, ob->obmat, fss->bbStart, fss->bbSize);
 141                 */
 142
 143                 fss->lastgoodframe = -1;
 144
 145         }
 146
 147         return;
 148 }
 149
 150 void fluidsim_free(FluidsimModifierData *fluidmd)
 151 {
 152         if(fluidmd)
 153         {
 154                 MEM_freeN(fluidmd->fss);
 155         }
 156
 157         return;
 158 }
 159
 160 DerivedMesh *fluidsimModifier_do(FluidsimModifierData *fluidmd, Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc)
 161 {
 162         DerivedMesh *result = NULL;
 163         int framenr;
 164         FluidsimSettings *fss = NULL;
 165
 166         framenr= (int)G.scene->r.cfra;
 167
 168         // only handle fluidsim domains
 169         if(fluidmd && fluidmd->fss && (fluidmd->fss->type != OB_FLUIDSIM_DOMAIN))
 170                 return dm;
 171
 172         // sanity check
 173         if(!fluidmd || (fluidmd && !fluidmd->fss))
 174                 return dm;
 175
 176         fss = fluidmd->fss;
 177
 178         // timescale not supported yet
 179         // clmd->sim_parms->timescale= timescale;
 180
 181         /* try to read from cache */
 182         if((result = fluidsim_read_cache(ob, fluidmd, framenr, useRenderParams)))
 183         {
 184                 fss->lastgoodframe = framenr;
 185                 return result;
 186         }
 187         else
 188         {
 189                 // display last known good frame
 190                 if(fss->lastgoodframe >= 0)
 191                 {
 192                         if((result = fluidsim_read_cache(ob, fluidmd, fss->lastgoodframe, useRenderParams)))
 193                         {
 194                                 return result;
 195                         }
 196                 }
 197
 198                 result = CDDM_copy(dm);
 199
 200                 if(result)
 201                 {
 202                         return result;
 203                 }
 204         }
 205
 206         return dm;
 207 }
 208
 209 /* read .bobj.gz file into a fluidsimDerivedMesh struct */
 210 static DerivedMesh *fluidsim_read_obj(char *filename)
 211 {
 212         int wri,i,j;
 213         float wrf;
 214         int gotBytes;
 215         gzFile gzf;
 216         int numverts = 0, numfaces = 0, numedges = 0;
 217         DerivedMesh *dm = NULL;
 218         MFace *mface;
 219         MVert *mvert;
 220         short *normals;
 221
 222         // ------------------------------------------------
 223         // get numverts + numfaces first
 224         // ------------------------------------------------
 225         gzf = gzopen(filename, "rb");
 226         if (!gzf)
 227         {
 228                 return NULL;
 229         }
 230
 231         // read numverts
 232         gotBytes = gzread(gzf, &wri, sizeof(wri));
 233         numverts = wri;
 234
 235         // skip verts
 236         for(i=0; i<numverts*3; i++)
 237         {
 238                 gotBytes = gzread(gzf, &wrf, sizeof( wrf ));
 239         }
 240
 241         // read number of normals
 242         gotBytes = gzread(gzf, &wri, sizeof(wri));
 243
 244         // skip normals
 245         for(i=0; i<numverts*3; i++)
 246         {
 247                 gotBytes = gzread(gzf, &wrf, sizeof( wrf ));
 248         }
 249
 250         /* get no. of triangles */
 251         gotBytes = gzread(gzf, &wri, sizeof(wri));
 252         numfaces = wri;
 253
 254         gzclose( gzf );
 255         // ------------------------------------------------
 256
 257         if(!numfaces || !numverts)
 258                 return NULL;
 259
 260         gzf = gzopen(filename, "rb");
 261         if (!gzf)
 262         {
 263                 return NULL;
 264         }
 265
 266         dm = CDDM_new(numverts, 0, numfaces);
 267
 268         if(!dm)
 269         {
 270                 gzclose( gzf );
 271                 return NULL;
 272         }
 273
 274         // read numverts
 275         gotBytes = gzread(gzf, &wri, sizeof(wri));
 276
 277         // read vertex position from file
 278         mvert = CDDM_get_verts(dm);
 279         for(i=0; i<numverts; i++)
 280         {
 281                 MVert *mv = &mvert[i];
 282
 283                 for(j=0; j<3; j++)
 284                 {
 285                         gotBytes = gzread(gzf, &wrf, sizeof( wrf ));
 286                         mv->co[j] = wrf;
 287                 }
 288         }
 289
 290         // should be the same as numverts
 291         gotBytes = gzread(gzf, &wri, sizeof(wri));
 292         if(wri != numverts)
 293         {
 294                 if(dm)
 295                         dm->release(dm);
 296                 gzclose( gzf );
 297                 return NULL;
 298         }
 299
 300         normals = MEM_callocN(sizeof(short) * numverts * 3, "fluid_tmp_normals" );
 301         if(!normals)
 302         {
 303                 if(dm)
 304                         dm->release(dm);
 305                 gzclose( gzf );
 306                 return NULL;
 307         }
 308
 309         // read normals from file (but don't save them yet)
 310         for(i=0; i<numverts*3; i++)
 311         {
 312                 gotBytes = gzread(gzf, &wrf, sizeof( wrf ));
 313                 normals[i] = (short)(wrf*32767.0f);
 314         }
 315
 316         /* read no. of triangles */
 317         gotBytes = gzread(gzf, &wri, sizeof(wri));
 318
 319         if(wri!=numfaces)
 320                 printf("Fluidsim: error in reading data from file.\n");
 321
 322         // read triangles from file
 323         mface = CDDM_get_faces(dm);
 324         for(i=0; i<numfaces; i++)
 325         {
 326                 int face[4];
 327                 MFace *mf = &mface[i];
 328
 329                 gotBytes = gzread(gzf, &(face[0]), sizeof( face[0] ));
 330                 gotBytes = gzread(gzf, &(face[1]), sizeof( face[1] ));
 331                 gotBytes = gzread(gzf, &(face[2]), sizeof( face[2] ));
 332                 face[3] = 0;
 333
 334                 // check if 3rd vertex has index 0 (not allowed in blender)
 335                 if(face[2])
 336                 {
 337                         mf->v1 = face[0];
 338                         mf->v2 = face[1];
 339                         mf->v3 = face[2];
 340                 }
 341                 else
 342                 {
 343                         mf->v1 = face[1];
 344                         mf->v2 = face[2];
 345                         mf->v3 = face[0];
 346                 }
 347                 mf->v4 = face[3];
 348
 349                 test_index_face(mf, NULL, 0, 3);
 350         }
 351
 352         gzclose( gzf );
 353
 354         CDDM_calc_edges(dm);
 355
 356         CDDM_apply_vert_normals(dm, (short (*)[3])normals);
 357         MEM_freeN(normals);
 358
 359         // CDDM_calc_normals(result);
 360
 361         return dm;
 362 }
 363
 364 DerivedMesh *fluidsim_read_cache(Object *ob, FluidsimModifierData *fluidmd, int framenr, int useRenderParams)
 365 {
 366         int displaymode = 0;
 367         int curFrame = framenr - 1 /*G.scene->r.sfra*/; /* start with 0 at start frame */
 368         char targetDir[FILE_MAXFILE+FILE_MAXDIR], targetFile[FILE_MAXFILE+FILE_MAXDIR];
 369         FluidsimSettings *fss = fluidmd->fss;
 370         DerivedMesh *dm = NULL;
 371
 372         if(!useRenderParams) {
 373                 displaymode = fss->guiDisplayMode;
 374         } else {
 375                 displaymode = fss->renderDisplayMode;
 376         }
 377
 378         strncpy(targetDir, fss->surfdataPath, FILE_MAXDIR);
 379
 380         // use preview or final mesh?
 381         if(displaymode==1)
 382         {
 383                 // just display original object
 384                 return NULL;
 385         }
 386         else if(displaymode==2)
 387         {
 388                 strcat(targetDir,"fluidsurface_preview_####");
 389         }
 390         else
 391         { // 3
 392                 strcat(targetDir,"fluidsurface_final_####");
 393         }
 394
 395         BLI_convertstringcode(targetDir, G.sce);
 396         BLI_convertstringframe(targetDir, curFrame); // fixed #frame-no
 397
 398         strcpy(targetFile,targetDir);
 399         strcat(targetFile, ".bobj.gz");
 400
 401         dm = fluidsim_read_obj(targetFile);
 402
 403         if(!dm)
 404         {
 405                 // switch, abort background rendering when fluidsim mesh is missing
 406                 const char *strEnvName2 = "BLENDER_ELBEEMBOBJABORT"; // from blendercall.cpp
 407
 408                 if(G.background==1) {
 409                         if(getenv(strEnvName2)) {
 410                                 int elevel = atoi(getenv(strEnvName2));
 411                                 if(elevel>0) {
 412                                         printf("Env. var %s set, fluid sim mesh '%s' not found, aborting render...\n",strEnvName2, targetFile);
 413                                         exit(1);
 414                                 }
 415                         }
 416                 }
 417
 418                 // display org. object upon failure which is in dm
 419                 return NULL;
 420         }
 421
 422         // load vertex velocities, if they exist...
 423         // TODO? use generate flag as loading flag as well?
 424         // warning, needs original .bobj.gz mesh loading filename
 425         /*
 426         if(displaymode==3)
 427         {
 428                 readVelgz(targetFile, srcob);
 429         }
 430         else
 431         {
 432                 // no data for preview, only clear...
 433                 int i,j;
 434                 for(i=0; i<mesh->totvert;i++) { for(j=0; j<3; j++) { srcob->fluidsimSettings->meshSurfNormals[i].co[j] = 0.; }}
 435         }*/
 436
 437         return dm;
 438 }
 439
 440 void fluid_get_bb(MVert *mvert, int totvert, float obmat[][4],
 441                  /*RET*/ float start[3], /*RET*/ float size[3] )
 442 {
 443         float bbsx=0.0, bbsy=0.0, bbsz=0.0;
 444         float bbex=1.0, bbey=1.0, bbez=1.0;
 445         int i;
 446         float vec[3];
 447
 448         VECCOPY(vec, mvert[0].co);
 449         Mat4MulVecfl(obmat, vec);
 450         bbsx = vec[0]; bbsy = vec[1]; bbsz = vec[2];
 451         bbex = vec[0]; bbey = vec[1]; bbez = vec[2];
 452
 453         for(i = 1; i < totvert; i++) {
 454                 VECCOPY(vec, mvert[i].co);
 455                 Mat4MulVecfl(obmat, vec);
 456
 457                 if(vec[0] < bbsx){ bbsx= vec[0]; }
 458                 if(vec[1] < bbsy){ bbsy= vec[1]; }
 459                 if(vec[2] < bbsz){ bbsz= vec[2]; }
 460                 if(vec[0] > bbex){ bbex= vec[0]; }
 461                 if(vec[1] > bbey){ bbey= vec[1]; }
 462                 if(vec[2] > bbez){ bbez= vec[2]; }
 463         }
 464
 465         // return values...
 466         if(start) {
 467                 start[0] = bbsx;
 468                 start[1] = bbsy;
 469                 start[2] = bbsz;
 470         }
 471         if(size) {
 472                 size[0] = bbex-bbsx;
 473                 size[1] = bbey-bbsy;
 474                 size[2] = bbez-bbsz;
 475         }
 476 }
 477
 478 //-------------------------------------------------------------------------------
 479 // old interface
 480 //-------------------------------------------------------------------------------
 481
 482
 483
 484 //-------------------------------------------------------------------------------
 485 // file handling
 486 //-------------------------------------------------------------------------------
 487
 488
 489 /* write .bobj.gz file for a mesh object */
 490 void writeBobjgz(char *filename, struct Object *ob, int useGlobalCoords, int append, float time)
 491 {
 492         int wri,i,j,totvert,totface;
 493         float wrf;
 494         gzFile gzf;
 495         DerivedMesh *dm;
 496         float vec[3];
 497         float rotmat[3][3];
 498         MVert *mvert;
 499         MFace *mface;
 500         //if(append)return; // DEBUG
 501
 502         if(!ob->data || (ob->type!=OB_MESH))
 503         {
 504                 return;
 505         }
 506         if((ob->size[0]<0.0) || (ob->size[0]<0.0) || (ob->size[0]<0.0) )
 507         {
 508                 return;
 509         }
 510
 511         if(append) gzf = gzopen(filename, "a+b9");
 512         else       gzf = gzopen(filename, "wb9");
 513
 514         if (!gzf)
 515                 return;
 516
 517         dm = mesh_create_derived_render(ob, CD_MASK_BAREMESH);
 518         //dm = mesh_create_derived_no_deform(ob,NULL);
 519
 520         mvert = dm->getVertArray(dm);
 521         mface = dm->getFaceArray(dm);
 522         totvert = dm->getNumVerts(dm);
 523         totface = dm->getNumFaces(dm);
 524
 525         // write time value for appended anim mesh
 526         if(append)
 527         {
 528                 gzwrite(gzf, &time, sizeof(time));
 529         }
 530
 531         // continue with verts/norms
 532         if(sizeof(wri)!=4) { return; } // paranoia check
 533         wri = dm->getNumVerts(dm);
 534         mvert = dm->getVertArray(dm);
 535         gzwrite(gzf, &wri, sizeof(wri));
 536         for(i=0; i<wri;i++)
 537         {
 538                 VECCOPY(vec, mvert[i].co);
 539                 if(useGlobalCoords) { Mat4MulVecfl(ob->obmat, vec); }
 540                 for(j=0; j<3; j++) {
 541                         wrf = vec[j];
 542                         gzwrite(gzf, &wrf, sizeof( wrf ));
 543                 }
 544         }
 545
 546         // should be the same as Vertices.size
 547         wri = totvert;
 548         gzwrite(gzf, &wri, sizeof(wri));
 549         EulToMat3(ob->rot, rotmat);
 550         for(i=0; i<wri;i++)
 551         {
 552                 VECCOPY(vec, mvert[i].no);
 553                 Normalize(vec);
 554                 if(useGlobalCoords) { Mat3MulVecfl(rotmat, vec); }
 555                 for(j=0; j<3; j++) {
 556                         wrf = vec[j];
 557                         gzwrite(gzf, &wrf, sizeof( wrf ));
 558                 }
 559         }
 560
 561         // append only writes verts&norms
 562         if(!append) {
 563                 // compute no. of triangles
 564                 wri = 0;
 565                 for(i=0; i<totface; i++)
 566                 {
 567                         wri++;
 568                         if(mface[i].v4) { wri++; }
 569                 }
 570                 gzwrite(gzf, &wri, sizeof(wri));
 571                 for(i=0; i<totface; i++)
 572                 {
 573
 574                         int face[4];
 575                         face[0] = mface[i].v1;
 576                         face[1] = mface[i].v2;
 577                         face[2] = mface[i].v3;
 578                         face[3] = mface[i].v4;
 579
 580                         gzwrite(gzf, &(face[0]), sizeof( face[0] ));
 581                         gzwrite(gzf, &(face[1]), sizeof( face[1] ));
 582                         gzwrite(gzf, &(face[2]), sizeof( face[2] ));
 583                         if(face[3])
 584                         {
 585                                 gzwrite(gzf, &(face[0]), sizeof( face[0] ));
 586                                 gzwrite(gzf, &(face[2]), sizeof( face[2] ));
 587                                 gzwrite(gzf, &(face[3]), sizeof( face[3] ));
 588                         } // quad
 589                 }
 590         }
 591
 592         gzclose( gzf );
 593         dm->release(dm);
 594 }
 595
 596 void initElbeemMesh(struct Object *ob,
 597                     int *numVertices, float **vertices,
 598       int *numTriangles, int **triangles,
 599       int useGlobalCoords)
 600 {
 601         DerivedMesh *dm = NULL;
 602         MVert *mvert;
 603         MFace *mface;
 604         int countTris=0, i, totvert, totface;
 605         float *verts;
 606         int *tris;
 607
 608         dm = mesh_create_derived_render(ob, CD_MASK_BAREMESH);
 609         //dm = mesh_create_derived_no_deform(ob,NULL);
 610
 611         mvert = dm->getVertArray(dm);
 612         mface = dm->getFaceArray(dm);
 613         totvert = dm->getNumVerts(dm);
 614         totface = dm->getNumFaces(dm);
 615
 616         *numVertices = totvert;
 617         verts = MEM_callocN( totvert*3*sizeof(float), "elbeemmesh_vertices");
 618         for(i=0; i<totvert; i++) {
 619                 VECCOPY( &verts[i*3], mvert[i].co);
 620                 if(useGlobalCoords) { Mat4MulVecfl(ob->obmat, &verts[i*3]); }
 621         }
 622         *vertices = verts;
 623
 624         for(i=0; i<totface; i++) {
 625                 countTris++;
 626                 if(mface[i].v4) { countTris++; }
 627         }
 628         *numTriangles = countTris;
 629         tris = MEM_callocN( countTris*3*sizeof(int), "elbeemmesh_triangles");
 630         countTris = 0;
 631         for(i=0; i<totface; i++) {
 632                 int face[4];
 633                 face[0] = mface[i].v1;
 634                 face[1] = mface[i].v2;
 635                 face[2] = mface[i].v3;
 636                 face[3] = mface[i].v4;
 637
 638                 tris[countTris*3+0] = face[0];
 639                 tris[countTris*3+1] = face[1];
 640                 tris[countTris*3+2] = face[2];
 641                 countTris++;
 642                 if(face[3]) {
 643                         tris[countTris*3+0] = face[0];
 644                         tris[countTris*3+1] = face[2];
 645                         tris[countTris*3+2] = face[3];
 646                         countTris++;
 647                 }
 648         }
 649         *triangles = tris;
 650
 651         dm->release(dm);
 652 }
 653
 654 /* read zipped fluidsim velocities into the co's of the fluidsimsettings normals struct */
 655 void readVelgz(char *filename, Object *srcob)
 656 {
 657         int wri, i, j;
 658         float wrf;
 659         gzFile gzf;
 660         MVert *vverts = srcob->fluidsimSettings->meshSurfNormals;
 661         int len = strlen(filename);
 662         Mesh *mesh = srcob->data;
 663         // mesh and vverts have to be valid from loading...
 664
 665         // clean up in any case
 666         for(i=0; i<mesh->totvert;i++)
 667         {
 668                 for(j=0; j<3; j++)
 669                 {
 670                         vverts[i].co[j] = 0.;
 671                 }
 672         }
 673         if(srcob->fluidsimSettings->domainNovecgen>0) return;
 674
 675         if(len<7)
 676         {
 677                 return;
 678         }
 679
 680         // .bobj.gz , correct filename
 681         // 87654321
 682         filename[len-6] = 'v';
 683         filename[len-5] = 'e';
 684         filename[len-4] = 'l';
 685
 686         gzf = gzopen(filename, "rb");
 687         if (!gzf)
 688                 return;
 689
 690         gzread(gzf, &wri, sizeof( wri ));
 691         if(wri != mesh->totvert)
 692         {
 693                 return;
 694         }
 695
 696         for(i=0; i<mesh->totvert;i++)
 697         {
 698                 for(j=0; j<3; j++)
 699                 {
 700                         gzread(gzf, &wrf, sizeof( wrf ));
 701                         vverts[i].co[j] = wrf;
 702                 }
 703         }
 704
 705         gzclose(gzf);
 706 }
 707
 708
 709 #endif // DISABLE_ELBEEM
 710