source/blender/modifiers/intern/MOD_ocean.c

   1 /**
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) Blender Foundation
  19  * All rights reserved.
  20  *
  21  * The Original Code is: all of this file.
  22  *
  23  * Contributor(s): Matt Ebb
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 #include "MEM_guardedalloc.h"
  29
  30 #include "DNA_customdata_types.h"
  31 #include "DNA_object_types.h"
  32 #include "DNA_meshdata_types.h"
  33 #include "DNA_modifier_types.h"
  34 #include "DNA_scene_types.h"
  35
  36 #include "BKE_cdderivedmesh.h"
  37 #include "BKE_global.h"
  38 #include "BKE_modifier.h"
  39 #include "BKE_ocean.h"
  40 #include "BKE_utildefines.h"
  41
  42 #include "BLI_blenlib.h"
  43 #include "BLI_math.h"
  44 #include "BLI_math_inline.h"
  45 #include "BLI_utildefines.h"
  46 #include "BLI_string.h"
  47
  48 #include "MOD_util.h"
  49
  50 #ifdef WITH_OCEANSIM
  51 static void init_cache_data(Object *ob, struct OceanModifierData *omd)
  52 {
  53         const char *relbase= modifier_path_relbase(ob);
  54
  55         omd->oceancache = BKE_init_ocean_cache(omd->cachepath, relbase,
  56                                                omd->bakestart, omd->bakeend, omd->wave_scale,
  57                                                omd->chop_amount, omd->foam_coverage, omd->foam_fade, omd->resolution);
  58 }
  59
  60 static void clear_cache_data(struct OceanModifierData *omd)
  61 {
  62         BKE_free_ocean_cache(omd->oceancache);
  63         omd->oceancache = NULL;
  64         omd->cached = FALSE;
  65 }
  66
  67 /* keep in sync with init_ocean_modifier_bake(), object_modifier.c */
  68 static void init_ocean_modifier(struct OceanModifierData *omd)
  69 {
  70         int do_heightfield, do_chop, do_normals, do_jacobian;
  71
  72         if (!omd || !omd->ocean) return;
  73
  74         do_heightfield = TRUE;
  75         do_chop = (omd->chop_amount > 0);
  76         do_normals = (omd->flag & MOD_OCEAN_GENERATE_NORMALS);
  77         do_jacobian = (omd->flag & MOD_OCEAN_GENERATE_FOAM);
  78
  79         BKE_free_ocean_data(omd->ocean);
  80         BKE_init_ocean(omd->ocean, omd->resolution*omd->resolution, omd->resolution*omd->resolution, omd->spatial_size, omd->spatial_size,
  81                        omd->wind_velocity, omd->smallest_wave, 1.0, omd->wave_direction, omd->damp, omd->wave_alignment,
  82                        omd->depth, omd->time,
  83                        do_heightfield, do_chop, do_normals, do_jacobian,
  84                        omd->seed);
  85 }
  86
  87 static void simulate_ocean_modifier(struct OceanModifierData *omd)
  88 {
  89         if (!omd || !omd->ocean) return;
  90
  91         BKE_simulate_ocean(omd->ocean, omd->time, omd->wave_scale, omd->chop_amount);
  92 }
  93 #endif /* WITH_OCEANSIM */
  94
  95
  96
  97 /* Modifier Code */
  98
  99 static void initData(ModifierData *md)
 100 {
 101 #ifdef WITH_OCEANSIM
 102         OceanModifierData *omd = (OceanModifierData*) md;
 103
 104         omd->resolution = 7;
 105         omd->spatial_size = 50;
 106
 107         omd->wave_alignment = 0.0;
 108         omd->wind_velocity = 30.0;
 109
 110         omd->damp = 0.5;
 111         omd->smallest_wave = 0.01;
 112         omd->wave_direction= 0.0;
 113         omd->depth = 200.0;
 114
 115         omd->wave_scale = 1.0;
 116
 117         omd->chop_amount = 1.0;
 118
 119         omd->foam_coverage = 0.0;
 120
 121         omd->seed = 0;
 122         omd->time = 1.0;
 123
 124         omd->refresh = 0;
 125
 126         omd->size = 1.0;
 127         omd->repeat_x = 1;
 128         omd->repeat_y = 1;
 129
 130         modifier_path_init(omd->cachepath, sizeof(omd->cachepath), "cache_ocean");
 131
 132         omd->cached = 0;
 133         omd->bakestart = 1;
 134         omd->bakeend = 250;
 135         omd->oceancache = NULL;
 136         omd->foam_fade = 0.98;
 137         omd->foamlayername[0] = '\0';   /* layer name empty by default */
 138
 139         omd->ocean = BKE_add_ocean();
 140         init_ocean_modifier(omd);
 141         simulate_ocean_modifier(omd);
 142 #else  // WITH_OCEANSIM
 143         /* unused */
 144         (void)md;
 145 #endif // WITH_OCEANSIM
 146 }
 147
 148 static void freeData(ModifierData *md)
 149 {
 150 #ifdef WITH_OCEANSIM
 151         OceanModifierData *omd = (OceanModifierData*) md;
 152
 153         BKE_free_ocean(omd->ocean);
 154         if (omd->oceancache)
 155                 BKE_free_ocean_cache(omd->oceancache);
 156 #else // WITH_OCEANSIM
 157         /* unused */
 158         (void)md;
 159 #endif // WITH_OCEANSIM
 160 }
 161
 162 static void copyData(ModifierData *md, ModifierData *target)
 163 {
 164 #ifdef WITH_OCEANSIM
 165         OceanModifierData *omd = (OceanModifierData*) md;
 166         OceanModifierData *tomd = (OceanModifierData*) target;
 167
 168         tomd->resolution = omd->resolution;
 169         tomd->spatial_size = omd->spatial_size;
 170
 171         tomd->wind_velocity = omd->wind_velocity;
 172
 173         tomd->damp = omd->damp;
 174         tomd->smallest_wave = omd->smallest_wave;
 175         tomd->depth = omd->depth;
 176
 177         tomd->wave_alignment = omd->wave_alignment;
 178         tomd->wave_direction = omd->wave_direction;
 179         tomd->wave_scale = omd->wave_scale;
 180
 181         tomd->chop_amount = omd->chop_amount;
 182         tomd->foam_coverage = omd->foam_coverage;
 183         tomd->time = omd->time;
 184
 185         tomd->seed = omd->seed;
 186         tomd->flag = omd->flag;
 187
 188         tomd->refresh = 0;
 189
 190
 191         tomd->size = omd->size;
 192         tomd->repeat_x = omd->repeat_x;
 193         tomd->repeat_y = omd->repeat_y;
 194
 195         /* XXX todo: copy cache runtime too */
 196         tomd->cached = 0;
 197         tomd->bakestart = omd->bakestart;
 198         tomd->bakeend = omd->bakeend;
 199         tomd->oceancache = NULL;
 200
 201         tomd->ocean = BKE_add_ocean();
 202         init_ocean_modifier(tomd);
 203         simulate_ocean_modifier(tomd);
 204 #else // WITH_OCEANSIM
 205         /* unused */
 206         (void)md;
 207         (void)target;
 208 #endif // WITH_OCEANSIM
 209 }
 210
 211 #ifdef WITH_OCEANSIM
 212 static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 213 {
 214         OceanModifierData *omd = (OceanModifierData *)md;
 215         CustomDataMask dataMask = 0;
 216
 217         if (omd->flag & MOD_OCEAN_GENERATE_FOAM)
 218                 dataMask |= CD_MASK_MCOL;
 219
 220         return dataMask;
 221 }
 222 #else // WITH_OCEANSIM
 223 static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
 224 {
 225         /* unused */
 226         (void)md;
 227         return 0;
 228 }
 229 #endif // WITH_OCEANSIM
 230
 231 #if 0
 232 static void dm_get_bounds(DerivedMesh *dm, float *sx, float *sy, float *ox, float *oy)
 233 {
 234         /* get bounding box of underlying dm */
 235         int v, totvert=dm->getNumVerts(dm);
 236         float min[3], max[3], delta[3];
 237
 238         MVert *mvert = dm->getVertDataArray(dm,0);
 239
 240         copy_v3_v3(min, mvert->co);
 241         copy_v3_v3(max, mvert->co);
 242
 243         for(v=1; v<totvert; v++, mvert++) {
 244                 min[0]=MIN2(min[0],mvert->co[0]);
 245                 min[1]=MIN2(min[1],mvert->co[1]);
 246                 min[2]=MIN2(min[2],mvert->co[2]);
 247
 248                 max[0]=MAX2(max[0],mvert->co[0]);
 249                 max[1]=MAX2(max[1],mvert->co[1]);
 250                 max[2]=MAX2(max[2],mvert->co[2]);
 251         }
 252
 253         sub_v3_v3v3(delta, max, min);
 254
 255         *sx = delta[0];
 256         *sy = delta[1];
 257
 258         *ox = min[0];
 259         *oy = min[1];
 260 }
 261 #endif
 262
 263 #ifdef WITH_OCEANSIM
 264
 265
 266 #define OMP_MIN_RES     18
 267 static DerivedMesh *generate_ocean_geometry(OceanModifierData *omd)
 268 {
 269         DerivedMesh *result;
 270
 271         MVert *mv;
 272         MFace *mf;
 273         MTFace *tf;
 274         int *origindex;
 275
 276         int cdlayer;
 277
 278         const int rx = omd->resolution*omd->resolution;
 279         const int ry = omd->resolution*omd->resolution;
 280         const int res_x = rx * omd->repeat_x;
 281         const int res_y = ry * omd->repeat_y;
 282
 283         const int num_verts = (res_x + 1) * (res_y + 1);
 284         const int num_edges = (res_x * res_y * 2) + res_x + res_y;
 285         const int num_faces = res_x * res_y;
 286
 287         float sx = omd->size * omd->spatial_size;
 288         float sy = omd->size * omd->spatial_size;
 289         const float ox = -sx / 2.0f;
 290         const float oy = -sy / 2.0f;
 291
 292         float ix, iy;
 293
 294         int x, y;
 295
 296         sx /= rx;
 297         sy /= ry;
 298
 299         result = CDDM_new(num_verts, num_edges, num_faces);
 300
 301         mv = CDDM_get_verts(result);
 302         mf = CDDM_get_faces(result);
 303         origindex= result->getFaceDataArray(result, CD_ORIGINDEX);
 304
 305         /* create vertices */
 306         #pragma omp parallel for private(x, y) if (rx > OMP_MIN_RES)
 307         for (y=0; y < res_y+1; y++) {
 308                 for (x=0; x < res_x+1; x++) {
 309                         const int i = y*(res_x+1) + x;
 310                         mv[i].co[0] = ox + (x * sx);
 311                         mv[i].co[1] = oy + (y * sy);
 312                         mv[i].co[2] = 0;
 313                 }
 314         }
 315
 316         /* create faces */
 317         #pragma omp parallel for private(x, y) if (rx > OMP_MIN_RES)
 318         for (y=0; y < res_y; y++) {
 319                 for (x=0; x < res_x; x++) {
 320                         const int fi = y*res_x + x;
 321                         const int vi = y*(res_x+1) + x;
 322                         mf[fi].v1 = vi;
 323                         mf[fi].v2 = vi + 1;
 324                         mf[fi].v3 = vi + 1 + res_x+1;
 325                         mf[fi].v4 = vi + res_x+1;
 326
 327                         mf[fi].flag |= ME_SMOOTH;
 328
 329                         /* generated geometry does not map to original faces */
 330                         origindex[fi] = ORIGINDEX_NONE;
 331                 }
 332         }
 333
 334         CDDM_calc_edges(result);
 335
 336         /* add uvs */
 337         cdlayer= CustomData_number_of_layers(&result->faceData, CD_MTFACE);
 338         if(cdlayer >= MAX_MTFACE)
 339                 return result;
 340         CustomData_add_layer(&result->faceData, CD_MTFACE, CD_CALLOC, NULL, num_faces);
 341         tf = CustomData_get_layer(&result->faceData, CD_MTFACE);
 342
 343         ix = 1.0 / rx;
 344         iy = 1.0 / ry;
 345         #pragma omp parallel for private(x, y) if (rx > OMP_MIN_RES)
 346         for (y=0; y < res_y; y++) {
 347                 for (x=0; x < res_x; x++) {
 348                         const int i = y*res_x + x;
 349                         tf[i].uv[0][0] = x * ix;
 350                         tf[i].uv[0][1] = y * iy;
 351
 352                         tf[i].uv[1][0] = (x+1) * ix;
 353                         tf[i].uv[1][1] = y * iy;
 354
 355                         tf[i].uv[2][0] = (x+1) * ix;
 356                         tf[i].uv[2][1] = (y+1) * iy;
 357
 358                         tf[i].uv[3][0] = x * ix;
 359                         tf[i].uv[3][1] = (y+1) * iy;
 360                 }
 361         }
 362
 363         return result;
 364 }
 365
 366 static DerivedMesh *doOcean(ModifierData *md, Object *ob,
 367                             DerivedMesh *derivedData,
 368                             int UNUSED(useRenderParams))
 369 {
 370         OceanModifierData *omd = (OceanModifierData*) md;
 371
 372         DerivedMesh *dm=NULL;
 373         OceanResult ocr;
 374
 375         MVert *mverts, *mv;
 376
 377         int i, j;
 378
 379         int num_verts;
 380         int num_faces;
 381
 382         int cfra;
 383
 384         /* use cached & inverted value for speed
 385          * expanded this would read...
 386          *
 387          * (axis / (omd->size * omd->spatial_size)) + 0.5f) */
 388 #define OCEAN_CO(_size_co_inv, _v) ((_v * _size_co_inv) + 0.5f)
 389
 390         const float size_co_inv= 1.0f / (omd->size * omd->spatial_size);
 391
 392         /* update modifier */
 393         if (omd->refresh & MOD_OCEAN_REFRESH_ADD)
 394                 omd->ocean = BKE_add_ocean();
 395         if (omd->refresh & MOD_OCEAN_REFRESH_RESET)
 396                 init_ocean_modifier(omd);
 397         if (omd->refresh & MOD_OCEAN_REFRESH_CLEAR_CACHE)
 398                 clear_cache_data(omd);
 399
 400         omd->refresh = 0;
 401
 402         /* do ocean simulation */
 403         if (omd->cached == TRUE) {
 404                 if (!omd->oceancache) init_cache_data(ob, omd);
 405                 BKE_simulate_ocean_cache(omd->oceancache, md->scene->r.cfra);
 406         }
 407         else {
 408                 simulate_ocean_modifier(omd);
 409         }
 410
 411         if (omd->geometry_mode == MOD_OCEAN_GEOM_GENERATE)
 412                 dm = generate_ocean_geometry(omd);
 413         else if (omd->geometry_mode == MOD_OCEAN_GEOM_DISPLACE) {
 414                 dm = CDDM_copy(derivedData);
 415         }
 416
 417         cfra = md->scene->r.cfra;
 418         CLAMP(cfra, omd->bakestart, omd->bakeend);
 419         cfra -= omd->bakestart; // shift to 0 based
 420
 421         num_verts = dm->getNumVerts(dm);
 422         num_faces = dm->getNumFaces(dm);
 423
 424         mverts = dm->getVertArray(dm);
 425
 426         /* add vcols before displacement - allows lookup based on position */
 427
 428         if (omd->flag & MOD_OCEAN_GENERATE_FOAM) {
 429                 int cdlayer= CustomData_number_of_layers(&dm->faceData, CD_MCOL);
 430
 431                 if(cdlayer < MAX_MCOL) {
 432                         MFace *mfaces= dm->getFaceArray(dm);
 433                         MFace *mf;
 434
 435                         MCol *mcols, *mc;
 436                         float foam;
 437
 438                         CustomData_add_layer_named(&dm->faceData, CD_MCOL, CD_CALLOC, NULL, num_faces, omd->foamlayername);
 439
 440                         mcols = dm->getFaceDataArray(dm, CD_MCOL);
 441
 442                         for (i = 0, mf= mfaces; i < num_faces; i++, mf++) {
 443                                 j= mf->v4 ? 3 : 2;
 444                                 do {
 445                                         const float *co= mverts[*(&mf->v1 + j)].co;
 446                                         const float u = OCEAN_CO(size_co_inv, co[0]);
 447                                         const float v = OCEAN_CO(size_co_inv, co[1]);
 448
 449                                         if (omd->oceancache && omd->cached==TRUE) {
 450                                                 BKE_ocean_cache_eval_uv(omd->oceancache, &ocr, cfra, u, v);
 451                                                 foam = ocr.foam;
 452                                                 CLAMP(foam, 0.0f, 1.0f);
 453                                         }
 454                                         else {
 455                                                 BKE_ocean_eval_uv(omd->ocean, &ocr, u, v);
 456                                                 foam = BKE_ocean_jminus_to_foam(ocr.Jminus, omd->foam_coverage);
 457                                         }
 458
 459                                         mc= &mcols[i*4 + j];
 460                                         mc->r = mc->g = mc->b = (char)(foam * 255);
 461                                         /* mc->a = 255; */ /* no need to set */
 462                                 } while (j--);
 463                         }
 464                 }
 465         }
 466
 467
 468         /* displace the geometry */
 469
 470         //#pragma omp parallel for private(i, ocr) if (omd->resolution > OMP_MIN_RES)
 471         for (i=0, mv= mverts; i< num_verts; i++, mv++) {
 472                 const float u = OCEAN_CO(size_co_inv, mv->co[0]);
 473                 const float v = OCEAN_CO(size_co_inv, mv->co[1]);
 474
 475                 if (omd->oceancache && omd->cached==TRUE)
 476                         BKE_ocean_cache_eval_uv(omd->oceancache, &ocr, cfra, u, v);
 477                 else
 478                         BKE_ocean_eval_uv(omd->ocean, &ocr, u, v);
 479
 480                 mv->co[2] += ocr.disp[1];
 481
 482                 if (omd->chop_amount > 0.0f) {
 483                         mv->co[0] += ocr.disp[0];
 484                         mv->co[1] += ocr.disp[2];
 485                 }
 486         }
 487
 488         #undef OCEAN_CO
 489
 490         return dm;
 491 }
 492 #else  // WITH_OCEANSIM
 493 static DerivedMesh *doOcean(ModifierData *md, Object *UNUSED(ob),
 494                                                           DerivedMesh *derivedData,
 495                                                           int UNUSED(useRenderParams))
 496 {
 497         /* unused */
 498         (void)md;
 499         return derivedData;
 500 }
 501 #endif // WITH_OCEANSIM
 502
 503 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
 504                                                                   DerivedMesh *derivedData,
 505                                                                   int UNUSED(useRenderParams),
 506                                                                   int UNUSED(isFinalCalc))
 507 {
 508         DerivedMesh *result;
 509
 510         result = doOcean(md, ob, derivedData, 0);
 511
 512         if(result != derivedData)
 513                 CDDM_calc_normals(result);
 514
 515         return result;
 516 }
 517
 518 static DerivedMesh *applyModifierEM(ModifierData *md, Object *ob,
 519                                                                         struct BMEditMesh *UNUSED(editData),
 520                                                                         DerivedMesh *derivedData)
 521 {
 522         return applyModifier(md, ob, derivedData, 0, 1);
 523 }
 524
 525
 526
 527 ModifierTypeInfo modifierType_Ocean = {
 528         /* name */              "Ocean",
 529         /* structName */        "OceanModifierData",
 530         /* structSize */        sizeof(OceanModifierData),
 531         /* type */              eModifierTypeType_Constructive,
 532         /* flags */             eModifierTypeFlag_AcceptsMesh
 533                                                         | eModifierTypeFlag_SupportsEditmode
 534                                                         | eModifierTypeFlag_EnableInEditmode,
 535
 536         /* copyData */          copyData,
 537         /* deformMatrices */    NULL,
 538         /* deformVerts */       NULL,
 539         /* deformVertsEM */     NULL,
 540         /* deformMatricesEM */  NULL,
 541         /* applyModifier */     applyModifier,
 542         /* applyModifierEM */   applyModifierEM,
 543         /* initData */          initData,
 544         /* requiredDataMask */  requiredDataMask,
 545         /* freeData */          freeData,
 546         /* isDisabled */        NULL,
 547         /* updateDepgraph */    NULL,
 548         /* dependsOnTime */     NULL,
 549         /* dependsOnNormals */  NULL,
 550         /* foreachObjectLink */ NULL,
 551         /* foreachIDLink */     NULL,
 552 };