Phase 1: a) Fluidsim is a modifier now which allows apply'ing now. b) Fluid control...
[blender-staging.git] / 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