← Back to branch summary

~ubuntu-branches/ubuntu/utopic/blender/utopic-proposed

« back to all changes in this revision

Viewing changes to source/blender/modifiers/intern/MOD_fluidsim_util.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2012-04-28 12:11:12 UTC
  • mto: (14.1.6 experimental) (1.5.1)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: package-import@ubuntu.com-20120428121112-2zi0vp8b6vejda8i
Tags: upstream-2.63
Import upstream version 2.63

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/modifiers/intern/MOD_fluidsim_util.c
66
66
void fluidsim_init(FluidsimModifierData *fluidmd)
67
67
{
68
68
#ifdef WITH_MOD_FLUID
69
 
        if(fluidmd)
 
69
        if (fluidmd)
70
70
        {
71
71
                FluidsimSettings *fss = MEM_callocN(sizeof(FluidsimSettings), "fluidsimsettings");
72
72
 
73
73
                fluidmd->fss = fss;
74
74
                
75
 
                if(!fss)
 
75
                if (!fss)
76
76
                        return;
77
77
                
78
78
                fss->fmd = fluidmd;
85
85
                fss->guiDisplayMode = 2; // preview
86
86
                fss->renderDisplayMode = 3; // render
87
87
 
88
 
                fss->viscosityMode = 2; // default to water
89
88
                fss->viscosityValue = 1.0;
90
89
                fss->viscosityExponent = 6;
91
90
                
131
130
                fss->cpsQuality = 10.0; // 1.0 / 10.0 => means 0.1 width
132
131
                
133
132
                /*
134
 
                BAD TODO: this is done in buttons_object.c in the moment 
135
 
                Mesh *mesh = ob->data;
136
 
                // calculate bounding box
137
 
                fluid_get_bb(mesh->mvert, mesh->totvert, ob->obmat, fss->bbStart, fss->bbSize); 
138
 
                */
 
133
                 * BAD TODO: this is done in buttons_object.c in the moment
 
134
                 * Mesh *mesh = ob->data;
 
135
                 * // calculate bounding box
 
136
                 * fluid_get_bb(mesh->mvert, mesh->totvert, ob->obmat, fss->bbStart, fss->bbSize);
 
137
                 */
139
138
                
140
139
                fss->meshVelocities = NULL;
141
140
                
152
151
 
153
152
void fluidsim_free(FluidsimModifierData *fluidmd)
154
153
{
155
 
        if(fluidmd) {
156
 
                if(fluidmd->fss->meshVelocities)
157
 
                {
 
154
        if (fluidmd && fluidmd->fss) {
 
155
                if (fluidmd->fss->meshVelocities) {
158
156
                        MEM_freeN(fluidmd->fss->meshVelocities);
159
157
                        fluidmd->fss->meshVelocities = NULL;
160
158
                }
166
164
 
167
165
#ifdef WITH_MOD_FLUID
168
166
/* read .bobj.gz file into a fluidsimDerivedMesh struct */
169
 
static DerivedMesh *fluidsim_read_obj(const char *filename, const MFace *mf_example)
 
167
static DerivedMesh *fluidsim_read_obj(const char *filename, const MPoly *mp_example)
170
168
{
171
169
        int wri = 0,i;
172
170
        int gotBytes;
173
171
        gzFile gzf;
174
172
        int numverts = 0, numfaces = 0;
175
173
        DerivedMesh *dm = NULL;
176
 
        MFace *mf;
 
174
        MPoly *mp;
 
175
        MLoop *ml;
177
176
        MVert *mv;
178
177
        short *normals, *no_s;
179
178
        float no[3];
180
179
 
181
 
        const short mf_mat_nr = mf_example->mat_nr;
182
 
        const char  mf_flag =   mf_example->flag;
 
180
        const short mp_mat_nr = mp_example->mat_nr;
 
181
        const char  mp_flag =   mp_example->flag;
183
182
 
184
183
        // ------------------------------------------------
185
184
        // get numverts + numfaces first
186
185
        // ------------------------------------------------
187
 
        gzf = gzopen(filename, "rb");
 
186
        gzf = BLI_gzopen(filename, "rb");
188
187
        if (!gzf)
189
188
        {
190
189
                return NULL;
199
198
 
200
199
 
201
200
        // read number of normals
202
 
        if(gotBytes)
 
201
        if (gotBytes)
203
202
                gotBytes = gzread(gzf, &wri, sizeof(wri));
204
203
 
205
204
        // skip normals
206
205
        gotBytes = gzseek(gzf, numverts * 3 * sizeof(float), SEEK_CUR) != -1;
207
206
 
208
207
        /* get no. of triangles */
209
 
        if(gotBytes)
 
208
        if (gotBytes)
210
209
                gotBytes = gzread(gzf, &wri, sizeof(wri));
211
210
        numfaces = wri;
212
211
 
213
 
        gzclose( gzf );
 
212
        gzclose(gzf);
214
213
        // ------------------------------------------------
215
214
 
216
 
        if(!numfaces || !numverts || !gotBytes)
 
215
        if (!numfaces || !numverts || !gotBytes)
217
216
                return NULL;
218
217
 
219
 
        gzf = gzopen(filename, "rb");
 
218
        gzf = BLI_gzopen(filename, "rb");
220
219
        if (!gzf)
221
220
        {
222
221
                return NULL;
223
222
        }
224
223
 
225
 
        dm = CDDM_new(numverts, 0, numfaces);
 
224
        dm = CDDM_new(numverts, 0, 0, numfaces * 3, numfaces);
226
225
 
227
 
        if(!dm)
 
226
        if (!dm)
228
227
        {
229
 
                gzclose( gzf );
 
228
                gzclose(gzf);
230
229
                return NULL;
231
230
        }
232
231
 
236
235
        // read vertex position from file
237
236
        mv = CDDM_get_verts(dm);
238
237
 
239
 
        for(i=0; i<numverts; i++, mv++)
 
238
        for (i=0; i<numverts; i++, mv++)
240
239
                gotBytes = gzread(gzf, mv->co, sizeof(float) * 3);
241
240
 
242
241
        // should be the same as numverts
243
242
        gotBytes = gzread(gzf, &wri, sizeof(wri));
244
 
        if(wri != numverts)
 
243
        if (wri != numverts)
245
244
        {
246
 
                if(dm)
 
245
                if (dm)
247
246
                        dm->release(dm);
248
 
                gzclose( gzf );
 
247
                gzclose(gzf);
249
248
                return NULL;
250
249
        }
251
250
 
252
251
        normals = MEM_callocN(sizeof(short) * numverts * 3, "fluid_tmp_normals" );
253
 
        if(!normals)
 
252
        if (!normals)
254
253
        {
255
 
                if(dm)
 
254
                if (dm)
256
255
                        dm->release(dm);
257
 
                gzclose( gzf );
 
256
                gzclose(gzf);
258
257
                return NULL;
259
258
        }
260
259
 
261
260
        // read normals from file (but don't save them yet)
262
 
        for(i=numverts, no_s= normals; i>0; i--, no_s += 3)
 
261
        for (i=numverts, no_s= normals; i>0; i--, no_s += 3)
263
262
        {
264
263
                gotBytes = gzread(gzf, no, sizeof(float) * 3);
265
264
                normal_float_to_short_v3(no_s, no);
268
267
        /* read no. of triangles */
269
268
        gotBytes = gzread(gzf, &wri, sizeof(wri));
270
269
 
271
 
        if(wri!=numfaces) {
 
270
        if (wri!=numfaces) {
272
271
                printf("Fluidsim: error in reading data from file.\n");
273
 
                if(dm)
 
272
                if (dm)
274
273
                        dm->release(dm);
275
 
                gzclose( gzf );
 
274
                gzclose(gzf);
276
275
                MEM_freeN(normals);
277
276
                return NULL;
278
277
        }
279
278
 
280
279
        // read triangles from file
281
 
        mf = CDDM_get_faces(dm);
282
 
        for(i=numfaces; i>0; i--, mf++)
 
280
        mp = CDDM_get_polys(dm);
 
281
        ml = CDDM_get_loops(dm);
 
282
        for (i=0; i < numfaces; i++, mp++, ml += 3)
283
283
        {
284
284
                int face[3];
285
285
 
286
286
                gotBytes = gzread(gzf, face, sizeof(int) * 3);
287
287
 
288
288
                /* initialize from existing face */
289
 
                mf->mat_nr = mf_mat_nr;
290
 
                mf->flag =   mf_flag;
291
 
 
292
 
                // check if 3rd vertex has index 0 (not allowed in blender)
293
 
                if(face[2])
294
 
                {
295
 
                        mf->v1 = face[0];
296
 
                        mf->v2 = face[1];
297
 
                        mf->v3 = face[2];
298
 
                }
299
 
                else
300
 
                {
301
 
                        mf->v1 = face[1];
302
 
                        mf->v2 = face[2];
303
 
                        mf->v3 = face[0];
304
 
                }
305
 
                mf->v4 = 0;
306
 
 
307
 
                test_index_face(mf, NULL, 0, 3);
 
289
                mp->mat_nr = mp_mat_nr;
 
290
                mp->flag =   mp_flag;
 
291
 
 
292
                mp->loopstart = i * 3;
 
293
                mp->totloop = 3;
 
294
 
 
295
                ml[0].v = face[0];
 
296
                ml[1].v = face[1];
 
297
                ml[2].v = face[2];
 
298
 
308
299
        }
309
300
 
310
 
        gzclose( gzf );
 
301
        gzclose(gzf);
311
302
 
312
303
        CDDM_calc_edges(dm);
313
304
 
315
306
        MEM_freeN(normals);
316
307
 
317
308
        // CDDM_calc_normals(result);
318
 
 
319
309
        return dm;
320
310
}
321
311
 
328
318
        int i;
329
319
        float vec[3];
330
320
 
331
 
        if(totvert == 0) {
 
321
        if (totvert == 0) {
332
322
                zero_v3(start);
333
323
                zero_v3(size);
334
324
                return;
339
329
        bbsx = vec[0]; bbsy = vec[1]; bbsz = vec[2];
340
330
        bbex = vec[0]; bbey = vec[1]; bbez = vec[2];
341
331
 
342
 
        for(i = 1; i < totvert; i++) {
 
332
        for (i = 1; i < totvert; i++) {
343
333
                copy_v3_v3(vec, mvert[i].co);
344
334
                mul_m4_v3(obmat, vec);
345
335
 
346
 
                if(vec[0] < bbsx){ bbsx= vec[0]; }
347
 
                if(vec[1] < bbsy){ bbsy= vec[1]; }
348
 
                if(vec[2] < bbsz){ bbsz= vec[2]; }
349
 
                if(vec[0] > bbex){ bbex= vec[0]; }
350
 
                if(vec[1] > bbey){ bbey= vec[1]; }
351
 
                if(vec[2] > bbez){ bbez= vec[2]; }
 
336
                if (vec[0] < bbsx) { bbsx= vec[0]; }
 
337
                if (vec[1] < bbsy) { bbsy= vec[1]; }
 
338
                if (vec[2] < bbsz) { bbsz= vec[2]; }
 
339
                if (vec[0] > bbex) { bbex= vec[0]; }
 
340
                if (vec[1] > bbey) { bbey= vec[1]; }
 
341
                if (vec[2] > bbez) { bbez= vec[2]; }
352
342
        }
353
343
 
354
344
        // return values...
355
 
        if(start) {
 
345
        if (start) {
356
346
                start[0] = bbsx;
357
347
                start[1] = bbsy;
358
348
                start[2] = bbsz;
359
349
        }
360
 
        if(size) {
 
350
        if (size) {
361
351
                size[0] = bbex-bbsx;
362
352
                size[1] = bbey-bbsy;
363
353
                size[2] = bbez-bbsz;
374
364
 
375
365
        value[0]= '\0';
376
366
 
377
 
        if(ob->type == OB_MESH) {
 
367
        if (ob->type == OB_MESH) {
378
368
                /* use mesh bounding box and object scaling */
379
369
                mesh= ob->data;
380
370
 
397
387
 
398
388
        // mesh and vverts have to be valid from loading...
399
389
 
400
 
        if(fss->meshVelocities)
 
390
        if (fss->meshVelocities)
401
391
                MEM_freeN(fss->meshVelocities);
402
392
 
403
 
        if(len<7)
 
393
        if (len<7)
404
394
        {
405
395
                return;
406
396
        }
407
397
 
408
 
        if(fss->domainNovecgen>0) return;
 
398
        if (fss->domainNovecgen>0) return;
409
399
 
410
400
        fss->meshVelocities = MEM_callocN(sizeof(FluidVertexVelocity)*dm->getNumVerts(dm), "Fluidsim_velocities");
411
401
        fss->totvert = totvert;
418
408
        filename[len-5] = 'e';
419
409
        filename[len-4] = 'l';
420
410
 
421
 
        gzf = gzopen(filename, "rb");
 
411
        gzf = BLI_gzopen(filename, "rb");
422
412
        if (!gzf)
423
413
        {
424
414
                MEM_freeN(fss->meshVelocities);
427
417
        }
428
418
 
429
419
        gzread(gzf, &wri, sizeof( wri ));
430
 
        if(wri != totvert)
 
420
        if (wri != totvert)
431
421
        {
432
422
                MEM_freeN(fss->meshVelocities);
433
423
                fss->meshVelocities = NULL;
434
424
                return;
435
425
        }
436
426
 
437
 
        for(i=0; i<totvert;i++)
 
427
        for (i=0; i<totvert;i++)
438
428
        {
439
 
                for(j=0; j<3; j++)
 
429
                for (j=0; j<3; j++)
440
430
                {
441
431
                        gzread(gzf, &wrf, sizeof( wrf ));
442
432
                        velarray[i].vel[j] = wrf;
453
443
        char targetFile[FILE_MAX];
454
444
        FluidsimSettings *fss = fluidmd->fss;
455
445
        DerivedMesh *dm = NULL;
456
 
        MFace *mface;
457
 
        MFace mf_example = {0};
458
 
 
459
 
 
460
 
        if(!useRenderParams) {
 
446
        MPoly *mpoly;
 
447
        MPoly mp_example = {0};
 
448
 
 
449
        if (!useRenderParams) {
461
450
                displaymode = fss->guiDisplayMode;
462
 
        } else {
 
451
        }
 
452
        else {
463
453
                displaymode = fss->renderDisplayMode;
464
454
        }
465
455
 
485
475
 
486
476
        // assign material + flags to new dm
487
477
        // if there's no faces in original dm, keep materials and flags unchanged
488
 
        mface = orgdm->getFaceArray(orgdm);
489
 
        if (mface) {
490
 
                mf_example = *mface;
 
478
        mpoly = orgdm->getPolyArray(orgdm);
 
479
        if (mpoly) {
 
480
                mp_example = *mpoly;
491
481
        }
492
482
        /* else leave NULL'd */
493
483
 
494
 
        dm = fluidsim_read_obj(targetFile, &mf_example);
 
484
        dm = fluidsim_read_obj(targetFile, &mp_example);
495
485
 
496
 
        if(!dm)
 
486
        if (!dm)
497
487
        {
498
488
                // switch, abort background rendering when fluidsim mesh is missing
499
489
                const char *strEnvName2 = "BLENDER_ELBEEMBOBJABORT"; // from blendercall.cpp
500
490
 
501
 
                if(G.background==1) {
502
 
                        if(getenv(strEnvName2)) {
 
491
                if (G.background==1) {
 
492
                        if (getenv(strEnvName2)) {
503
493
                                int elevel = atoi(getenv(strEnvName2));
504
 
                                if(elevel>0) {
 
494
                                if (elevel>0) {
505
495
                                        printf("Env. var %s set, fluid sim mesh '%s' not found, aborting render...\n",strEnvName2, targetFile);
506
496
                                        exit(1);
507
497
                                }
515
505
        // load vertex velocities, if they exist...
516
506
        // TODO? use generate flag as loading flag as well?
517
507
        // warning, needs original .bobj.gz mesh loading filename
518
 
        if(displaymode==3)
519
 
        {
 
508
        if (displaymode==3) {
520
509
                fluidsim_read_vel_cache(fluidmd, dm, targetFile);
521
510
        }
522
 
        else
523
 
        {
524
 
                if(fss->meshVelocities)
 
511
        else {
 
512
                if (fss->meshVelocities)
525
513
                        MEM_freeN(fss->meshVelocities);
526
514
 
527
515
                fss->meshVelocities = NULL;
544
532
        framenr= (int)scene->r.cfra;
545
533
        
546
534
        // only handle fluidsim domains
547
 
        if(fluidmd && fluidmd->fss && (fluidmd->fss->type != OB_FLUIDSIM_DOMAIN))
 
535
        if (fluidmd && fluidmd->fss && (fluidmd->fss->type != OB_FLUIDSIM_DOMAIN))
548
536
                return dm;
549
537
        
550
538
        // sanity check
551
 
        if(!fluidmd || (fluidmd && !fluidmd->fss))
 
539
        if (!fluidmd || (fluidmd && !fluidmd->fss))
552
540
                return dm;
553
541
        
554
542
        fss = fluidmd->fss;
557
545
        // clmd->sim_parms->timescale= timescale;
558
546
 
559
547
        // support reversing of baked fluid frames here
560
 
        if((fss->flag & OB_FLUIDSIM_REVERSE) && (fss->lastgoodframe >= 0))
561
 
        {
 
548
        if ((fss->flag & OB_FLUIDSIM_REVERSE) && (fss->lastgoodframe >= 0)) {
562
549
                framenr = fss->lastgoodframe - framenr + 1;
563
550
                CLAMP(framenr, 1, fss->lastgoodframe);
564
551
        }
565
552
        
566
553
        /* try to read from cache */
567
554
        /* if the frame is there, fine, otherwise don't do anything */
568
 
        if((result = fluidsim_read_cache(ob, dm, fluidmd, framenr, useRenderParams)))
 
555
        if ((result = fluidsim_read_cache(ob, dm, fluidmd, framenr, useRenderParams)))
569
556
                return result;
570
557
        
571
558
        return dm;