48static float nextfr(
RNG *rng,
float min,
float max)
53static float gaussRand(
RNG *rng)
63 x = nextfr(rng, -1, 1);
64 y = nextfr(rng, -1, 1);
74MINLINE float catrom(
float p0,
float p1,
float p2,
float p3,
float f)
76 return 0.5f * ((2.0f * p1) + (-p0 + p2) * f + (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * f * f +
77 (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * f * f * f);
80MINLINE float omega(
float k,
float depth)
86static float Ph(
Ocean *o,
float kx,
float kz)
89 float k2 = kx * kx + kz * kz;
96 tmp = (o->_wx * kx + o->_wz * kz) /
sqrtf(k2);
98 tmp *= o->_damp_reflections;
101 return o->_A *
expf(-1.0f / (k2 * (o->_L * o->_L))) *
expf(-k2 * (o->_l * o->_l)) *
102 powf(
fabsf(tmp), o->_wind_alignment) / (k2 * k2);
105static void compute_eigenstuff(
OceanResult *ocr,
float jxx,
float jzz,
float jxz)
107 float a,
b, qplus, qminus;
109 b =
sqrt((jxx - jzz) * (jxx - jzz) + 4 * jxz * jxz);
111 ocr->Jminus = 0.5f * (a -
b);
112 ocr->Jplus = 0.5f * (a +
b);
114 qplus = (ocr->Jplus - jxx) / jxz;
115 qminus = (ocr->Jminus - jxx) / jxz;
117 a =
sqrt(1 + qplus * qplus);
118 b =
sqrt(1 + qminus * qminus);
120 ocr->Eplus[0] = 1.0f / a;
121 ocr->Eplus[1] = 0.0f;
122 ocr->Eplus[2] = qplus / a;
124 ocr->Eminus[0] = 1.0f /
b;
125 ocr->Eminus[1] = 0.0f;
126 ocr->Eminus[2] = qminus /
b;
134static void init_complex(fftw_complex cmpl,
float real,
float image)
140static void add_comlex_c(fftw_complex res,
const fftw_complex cmpl1,
const fftw_complex cmpl2)
142 res[0] = cmpl1[0] + cmpl2[0];
143 res[1] = cmpl1[1] + cmpl2[1];
146static void mul_complex_f(fftw_complex res,
const fftw_complex cmpl,
float f)
148 res[0] = cmpl[0] * double(f);
149 res[1] = cmpl[1] * double(f);
152static void mul_complex_c(fftw_complex res,
const fftw_complex cmpl1,
const fftw_complex cmpl2)
155 temp[0] = cmpl1[0] * cmpl2[0] - cmpl1[1] * cmpl2[1];
156 temp[1] = cmpl1[0] * cmpl2[1] + cmpl1[1] * cmpl2[0];
161static float real_c(fftw_complex cmpl)
166static float image_c(fftw_complex cmpl)
171static void conj_complex(fftw_complex res,
const fftw_complex cmpl1)
177static void exp_complex(fftw_complex res, fftw_complex cmpl)
179 float r =
expf(cmpl[0]);
181 res[0] =
cosf(cmpl[1]) * r;
182 res[1] =
sinf(cmpl[1]) * r;
187 float foam = jminus * -0.005f + coverage;
188 CLAMP(foam, 0.0f, 1.0f);
195 float frac_x, frac_z;
230 interpf(interpf(m[i1 * oc->_N + j1], m[i0 * oc->_N + j1], frac_x), \
231 interpf(m[i1 * oc->_N + j0], m[i0 * oc->_N + j0], frac_x), \
235 if (oc->_do_disp_y) {
236 ocr->disp[1] = BILERP(oc->_disp_y);
239 if (oc->_do_normals) {
240 ocr->normal[0] = BILERP(oc->_N_x);
241 ocr->normal[1] = oc->_N_y ;
242 ocr->normal[2] = BILERP(oc->_N_z);
246 ocr->disp[0] = BILERP(oc->_disp_x);
247 ocr->disp[2] = BILERP(oc->_disp_z);
254 if (oc->_do_jacobian) {
255 compute_eigenstuff(ocr, BILERP(oc->_Jxx), BILERP(oc->_Jzz), BILERP(oc->_Jxz));
265 int i0, i1, i2, i3, j0, j1, j2, j3;
266 float frac_x, frac_z;
302 i0 = i0 < 0 ? i0 + oc->_M : i0;
303 i3 = i3 >= oc->_M ? i3 - oc->_M : i3;
307 j0 = j0 < 0 ? j0 + oc->_N : j0;
308 j3 = j3 >= oc->_N ? j3 - oc->_N : j3;
311 catrom(catrom(m[i0 * oc->_N + j0], \
312 m[i1 * oc->_N + j0], \
313 m[i2 * oc->_N + j0], \
314 m[i3 * oc->_N + j0], \
316 catrom(m[i0 * oc->_N + j1], \
317 m[i1 * oc->_N + j1], \
318 m[i2 * oc->_N + j1], \
319 m[i3 * oc->_N + j1], \
321 catrom(m[i0 * oc->_N + j2], \
322 m[i1 * oc->_N + j2], \
323 m[i2 * oc->_N + j2], \
324 m[i3 * oc->_N + j2], \
326 catrom(m[i0 * oc->_N + j3], \
327 m[i1 * oc->_N + j3], \
328 m[i2 * oc->_N + j3], \
329 m[i3 * oc->_N + j3], \
334 if (oc->_do_disp_y) {
335 ocr->disp[1] = INTERP(oc->_disp_y);
337 if (oc->_do_normals) {
338 ocr->normal[0] = INTERP(oc->_N_x);
339 ocr->normal[1] = oc->_N_y ;
340 ocr->normal[2] = INTERP(oc->_N_z);
343 ocr->disp[0] = INTERP(oc->_disp_x);
344 ocr->disp[2] = INTERP(oc->_disp_z);
351 if (oc->_do_jacobian) {
352 compute_eigenstuff(ocr, INTERP(oc->_Jxx), INTERP(oc->_Jzz), INTERP(oc->_Jxz));
377 ocr->disp[1] = oc->_do_disp_y ?
float(oc->_disp_y[i * oc->_N + j]) : 0.0f;
380 ocr->disp[0] = oc->_disp_x[i * oc->_N + j];
381 ocr->disp[2] = oc->_disp_z[i * oc->_N + j];
388 if (oc->_do_normals) {
389 ocr->normal[0] = oc->_N_x[i * oc->_N + j];
390 ocr->normal[1] = oc->_N_y ;
391 ocr->normal[2] = oc->_N_z[i * oc->_N + j];
396 if (oc->_do_jacobian) {
398 ocr, oc->_Jxx[i * oc->_N + j], oc->_Jzz[i * oc->_N + j], oc->_Jxz[i * oc->_N + j]);
404struct OceanSimulateData {
411static void ocean_compute_htilda(
void *__restrict userdata,
415 OceanSimulateData *osd =
static_cast<OceanSimulateData *
>(userdata);
416 const Ocean *o = osd->o;
417 const float scale = osd->scale;
418 const float t = osd->t;
424 for (j = 0; j <= o->_N / 2; j++) {
425 fftw_complex exp_param1;
426 fftw_complex exp_param2;
427 fftw_complex conj_param;
429 init_complex(exp_param1, 0.0, omega(o->_k[i * (1 + o->_N / 2) + j], o->_depth) * t);
430 init_complex(exp_param2, 0.0, -omega(o->_k[i * (1 + o->_N / 2) + j], o->_depth) * t);
431 exp_complex(exp_param1, exp_param1);
432 exp_complex(exp_param2, exp_param2);
433 conj_complex(conj_param, o->_h0_minus[i * o->_N + j]);
435 mul_complex_c(exp_param1, o->_h0[i * o->_N + j], exp_param1);
436 mul_complex_c(exp_param2, conj_param, exp_param2);
438 add_comlex_c(o->_htilda[i * (1 + o->_N / 2) + j], exp_param1, exp_param2);
439 mul_complex_f(o->_fft_in[i * (1 + o->_N / 2) + j], o->_htilda[i * (1 + o->_N / 2) + j],
scale);
443static void ocean_compute_displacement_y(
TaskPool *__restrict pool,
void * )
446 const Ocean *o = osd->o;
448 fftw_execute(o->_disp_y_plan);
451static void ocean_compute_displacement_x(
TaskPool *__restrict pool,
void * )
454 const Ocean *o = osd->o;
455 const float scale = osd->scale;
456 const float chop_amount = osd->chop_amount;
459 for (i = 0; i < o->_M; i++) {
460 for (j = 0; j <= o->_N / 2; j++) {
461 fftw_complex mul_param;
462 fftw_complex minus_i;
464 init_complex(minus_i, 0.0, -1.0);
465 init_complex(mul_param, -
scale, 0);
466 mul_complex_f(mul_param, mul_param, chop_amount);
467 mul_complex_c(mul_param, mul_param, minus_i);
468 mul_complex_c(mul_param, mul_param, o->_htilda[i * (1 + o->_N / 2) + j]);
469 mul_complex_f(mul_param,
471 ((o->_k[i * (1 + o->_N / 2) + j] == 0.0f) ?
473 o->_kx[i] / o->_k[i * (1 + o->_N / 2) + j]));
474 init_complex(o->_fft_in_x[i * (1 + o->_N / 2) + j], real_c(mul_param), image_c(mul_param));
477 fftw_execute(o->_disp_x_plan);
480static void ocean_compute_displacement_z(
TaskPool *__restrict pool,
void * )
483 const Ocean *o = osd->o;
484 const float scale = osd->scale;
485 const float chop_amount = osd->chop_amount;
488 for (i = 0; i < o->_M; i++) {
489 for (j = 0; j <= o->_N / 2; j++) {
490 fftw_complex mul_param;
491 fftw_complex minus_i;
493 init_complex(minus_i, 0.0, -1.0);
494 init_complex(mul_param, -
scale, 0);
495 mul_complex_f(mul_param, mul_param, chop_amount);
496 mul_complex_c(mul_param, mul_param, minus_i);
497 mul_complex_c(mul_param, mul_param, o->_htilda[i * (1 + o->_N / 2) + j]);
498 mul_complex_f(mul_param,
500 ((o->_k[i * (1 + o->_N / 2) + j] == 0.0f) ?
502 o->_kz[j] / o->_k[i * (1 + o->_N / 2) + j]));
503 init_complex(o->_fft_in_z[i * (1 + o->_N / 2) + j], real_c(mul_param), image_c(mul_param));
506 fftw_execute(o->_disp_z_plan);
509static void ocean_compute_jacobian_jxx(
TaskPool *__restrict pool,
void * )
512 const Ocean *o = osd->o;
513 const float chop_amount = osd->chop_amount;
516 for (i = 0; i < o->_M; i++) {
517 for (j = 0; j <= o->_N / 2; j++) {
518 fftw_complex mul_param;
521 init_complex(mul_param, -1, 0);
523 mul_complex_f(mul_param, mul_param, chop_amount);
524 mul_complex_c(mul_param, mul_param, o->_htilda[i * (1 + o->_N / 2) + j]);
525 mul_complex_f(mul_param,
527 ((o->_k[i * (1 + o->_N / 2) + j] == 0.0f) ?
529 o->_kx[i] * o->_kx[i] / o->_k[i * (1 + o->_N / 2) + j]));
530 init_complex(o->_fft_in_jxx[i * (1 + o->_N / 2) + j], real_c(mul_param), image_c(mul_param));
533 fftw_execute(o->_Jxx_plan);
535 for (i = 0; i < o->_M; i++) {
536 for (j = 0; j < o->_N; j++) {
537 o->_Jxx[i * o->_N + j] += 1.0;
542static void ocean_compute_jacobian_jzz(
TaskPool *__restrict pool,
void * )
545 const Ocean *o = osd->o;
546 const float chop_amount = osd->chop_amount;
549 for (i = 0; i < o->_M; i++) {
550 for (j = 0; j <= o->_N / 2; j++) {
551 fftw_complex mul_param;
554 init_complex(mul_param, -1, 0);
556 mul_complex_f(mul_param, mul_param, chop_amount);
557 mul_complex_c(mul_param, mul_param, o->_htilda[i * (1 + o->_N / 2) + j]);
558 mul_complex_f(mul_param,
560 ((o->_k[i * (1 + o->_N / 2) + j] == 0.0f) ?
562 o->_kz[j] * o->_kz[j] / o->_k[i * (1 + o->_N / 2) + j]));
563 init_complex(o->_fft_in_jzz[i * (1 + o->_N / 2) + j], real_c(mul_param), image_c(mul_param));
566 fftw_execute(o->_Jzz_plan);
568 for (i = 0; i < o->_M; i++) {
569 for (j = 0; j < o->_N; j++) {
570 o->_Jzz[i * o->_N + j] += 1.0;
575static void ocean_compute_jacobian_jxz(
TaskPool *__restrict pool,
void * )
578 const Ocean *o = osd->o;
579 const float chop_amount = osd->chop_amount;
582 for (i = 0; i < o->_M; i++) {
583 for (j = 0; j <= o->_N / 2; j++) {
584 fftw_complex mul_param;
587 init_complex(mul_param, -1, 0);
589 mul_complex_f(mul_param, mul_param, chop_amount);
590 mul_complex_c(mul_param, mul_param, o->_htilda[i * (1 + o->_N / 2) + j]);
591 mul_complex_f(mul_param,
593 ((o->_k[i * (1 + o->_N / 2) + j] == 0.0f) ?
595 o->_kx[i] * o->_kz[j] / o->_k[i * (1 + o->_N / 2) + j]));
596 init_complex(o->_fft_in_jxz[i * (1 + o->_N / 2) + j], real_c(mul_param), image_c(mul_param));
599 fftw_execute(o->_Jxz_plan);
602static void ocean_compute_normal_x(
TaskPool *__restrict pool,
void * )
605 const Ocean *o = osd->o;
608 for (i = 0; i < o->_M; i++) {
609 for (j = 0; j <= o->_N / 2; j++) {
610 fftw_complex mul_param;
612 init_complex(mul_param, 0.0, -1.0);
613 mul_complex_c(mul_param, mul_param, o->_htilda[i * (1 + o->_N / 2) + j]);
614 mul_complex_f(mul_param, mul_param, o->_kx[i]);
615 init_complex(o->_fft_in_nx[i * (1 + o->_N / 2) + j], real_c(mul_param), image_c(mul_param));
618 fftw_execute(o->_N_x_plan);
621static void ocean_compute_normal_z(
TaskPool *__restrict pool,
void * )
624 const Ocean *o = osd->o;
627 for (i = 0; i < o->_M; i++) {
628 for (j = 0; j <= o->_N / 2; j++) {
629 fftw_complex mul_param;
631 init_complex(mul_param, 0.0, -1.0);
632 mul_complex_c(mul_param, mul_param, o->_htilda[i * (1 + o->_N / 2) + j]);
633 mul_complex_f(mul_param, mul_param, o->_kz[i]);
634 init_complex(o->_fft_in_nz[i * (1 + o->_N / 2) + j], real_c(mul_param), image_c(mul_param));
637 fftw_execute(o->_N_z_plan);
642 return o->_k !=
nullptr;
649 OceanSimulateData osd;
651 scale *= o->normalize_factor;
656 osd.chop_amount = chop_amount;
672 settings.use_threading = (o->_M > 16);
684 if (o->_do_jacobian) {
690 if (o->_do_normals) {
693 o->_N_y = 1.0f /
scale;
703static void set_height_normalize_factor(
Ocean *oc)
710 if (!oc->_do_disp_y) {
714 oc->normalize_factor = 1.0;
720 for (i = 0; i < oc->_M; i++) {
721 for (j = 0; j < oc->_N; j++) {
722 max_h = std::max<double>(max_h,
fabs(oc->_disp_y[i * oc->_N + j]));
732 res = 1.0f / (max_h);
734 oc->normalize_factor = res;
750 if (omd->ocean->_M == resolution * resolution) {
764 short do_heightfield, do_chop, do_normals, do_jacobian, do_spray;
766 do_heightfield =
true;
767 do_chop = (omd->chop_amount > 0);
775 resolution * resolution,
776 resolution * resolution,
789 omd->sharpen_peak_jonswap,
813 float sharpen_peak_jonswap,
814 short do_height_field,
831 o->_damp_reflections = 1.0f - damp;
832 o->_wind_alignment = alignment * 10.0f;
838 o->_L =
V *
V / GRAVITY;
842 o->_spectrum = spectrum;
845 o->_fetch_jonswap = fetch_jonswap;
846 o->_sharpen_peak_jonswap = sharpen_peak_jonswap * 10.0f;
854 "ocean_h0_minus")) &&
861 MEM_SAFE_DELETE(o->_k);
862 MEM_SAFE_DELETE(o->_h0);
863 MEM_SAFE_DELETE(o->_h0_minus);
864 MEM_SAFE_DELETE(o->_kx);
865 MEM_SAFE_DELETE(o->_kz);
871 o->_do_disp_y = do_height_field;
872 o->_do_normals = do_normals;
873 o->_do_spray = do_spray;
874 o->_do_chop = do_chop;
875 o->_do_jacobian = do_jacobian;
878 if (o->_Lx == 0.0f) {
882 if (o->_Lz == 0.0f) {
887 for (i = 0; i <= o->_M / 2; i++) {
888 o->_kx[i] = 2.0f *
float(
M_PI) * i / o->_Lx;
892 for (i = o->_M - 1, ii = 0; i > o->_M / 2; i--, ii++) {
893 o->_kx[i] = -2.0f *
float(
M_PI) * ii / o->_Lx;
897 for (i = 0; i <= o->_N / 2; i++) {
898 o->_kz[i] = 2.0f *
float(
M_PI) * i / o->_Lz;
902 for (i = o->_N - 1, ii = 0; i > o->_N / 2; i--, ii++) {
903 o->_kz[i] = -2.0f *
float(
M_PI) * ii / o->_Lz;
907 for (i = 0; i < o->_M; i++) {
908 for (j = 0; j <= o->_N / 2; j++) {
909 o->_k[size_t(i) * (1 + o->_N / 2) + j] =
sqrt(o->_kx[i] * o->_kx[i] + o->_kz[j] * o->_kz[j]);
915 for (i = 0; i < o->_M; i++) {
916 for (j = 0; j < o->_N; j++) {
921 const int hash_x = o->_kx[i] * 360.0f;
922 const int hash_z = o->_kz[j] * 360.0f;
926 float r1 = gaussRand(rng);
927 float r2 = gaussRand(rng);
930 init_complex(r1r2, r1, r2);
931 switch (o->_spectrum) {
933 mul_complex_f(o->_h0[i * o->_N + j],
936 mul_complex_f(o->_h0_minus[i * o->_N + j],
942 o->_h0[i * o->_N + j],
946 o->_h0_minus[i * o->_N + j],
951 mul_complex_f(o->_h0[i * o->_N + j],
955 o->_h0_minus[i * o->_N + j],
960 mul_complex_f(o->_h0[i * o->_N + j], r1r2,
sqrt(Ph(o, o->_kx[i], o->_kz[j]) / 2.0f));
962 o->_h0_minus[i * o->_N + j], r1r2,
sqrt(Ph(o, -o->_kx[i], -o->_kz[j]) / 2.0f));
978 o->_disp_y_plan = fftw_plan_dft_c2r_2d(o->_M, o->_N, o->_fft_in, o->_disp_y, FFTW_ESTIMATE);
981 if (o->_do_normals) {
983 size_t(o->_M) * (1 +
size_t(o->_N) / 2),
"ocean_fft_in_nx");
985 size_t(o->_M) * (1 +
size_t(o->_N) / 2),
"ocean_fft_in_nz");
991 o->_N_x_plan = fftw_plan_dft_c2r_2d(o->_M, o->_N, o->_fft_in_nx, o->_N_x, FFTW_ESTIMATE);
992 o->_N_z_plan = fftw_plan_dft_c2r_2d(o->_M, o->_N, o->_fft_in_nz, o->_N_z, FFTW_ESTIMATE);
997 size_t(o->_M) * (1 +
size_t(o->_N) / 2),
"ocean_fft_in_x");
999 size_t(o->_M) * (1 +
size_t(o->_N) / 2),
"ocean_fft_in_z");
1006 o->_disp_x_plan = fftw_plan_dft_c2r_2d(o->_M, o->_N, o->_fft_in_x, o->_disp_x, FFTW_ESTIMATE);
1007 o->_disp_z_plan = fftw_plan_dft_c2r_2d(o->_M, o->_N, o->_fft_in_z, o->_disp_z, FFTW_ESTIMATE);
1009 if (o->_do_jacobian) {
1011 size_t(o->_M) * (1 +
size_t(o->_N) / 2),
"ocean_fft_in_jxx");
1013 size_t(o->_M) * (1 +
size_t(o->_N) / 2),
"ocean_fft_in_jzz");
1015 size_t(o->_M) * (1 +
size_t(o->_N) / 2),
"ocean_fft_in_jxz");
1021 o->_Jxx_plan = fftw_plan_dft_c2r_2d(o->_M, o->_N, o->_fft_in_jxx, o->_Jxx, FFTW_ESTIMATE);
1022 o->_Jzz_plan = fftw_plan_dft_c2r_2d(o->_M, o->_N, o->_fft_in_jzz, o->_Jzz, FFTW_ESTIMATE);
1023 o->_Jxz_plan = fftw_plan_dft_c2r_2d(o->_M, o->_N, o->_fft_in_jxz, o->_Jxz, FFTW_ESTIMATE);
1030 set_height_normalize_factor(o);
1047 if (oc->_do_disp_y) {
1048 fftw_destroy_plan(oc->_disp_y_plan);
1049 MEM_delete(oc->_disp_y);
1052 if (oc->_do_normals) {
1053 MEM_delete(oc->_fft_in_nx);
1054 MEM_delete(oc->_fft_in_nz);
1055 fftw_destroy_plan(oc->_N_x_plan);
1056 fftw_destroy_plan(oc->_N_z_plan);
1057 MEM_delete(oc->_N_x);
1059 MEM_delete(oc->_N_z);
1063 MEM_delete(oc->_fft_in_x);
1064 MEM_delete(oc->_fft_in_z);
1065 fftw_destroy_plan(oc->_disp_x_plan);
1066 fftw_destroy_plan(oc->_disp_z_plan);
1067 MEM_delete(oc->_disp_x);
1068 MEM_delete(oc->_disp_z);
1071 if (oc->_do_jacobian) {
1072 MEM_delete(oc->_fft_in_jxx);
1073 MEM_delete(oc->_fft_in_jzz);
1074 MEM_delete(oc->_fft_in_jxz);
1075 fftw_destroy_plan(oc->_Jxx_plan);
1076 fftw_destroy_plan(oc->_Jzz_plan);
1077 fftw_destroy_plan(oc->_Jxz_plan);
1078 MEM_delete(oc->_Jxx);
1079 MEM_delete(oc->_Jzz);
1080 MEM_delete(oc->_Jxz);
1086 MEM_delete(oc->_fft_in);
1091 MEM_delete(oc->_htilda);
1093 MEM_delete(oc->_h0);
1094 MEM_delete(oc->_h0_minus);
1095 MEM_delete(oc->_kx);
1096 MEM_delete(oc->_kz);
1118# define CACHE_TYPE_DISPLACE 1
1119# define CACHE_TYPE_FOAM 2
1120# define CACHE_TYPE_NORMAL 3
1121# define CACHE_TYPE_SPRAY 4
1122# define CACHE_TYPE_SPRAY_INVERSE 5
1124static void cache_filepath(
1125 char *filepath,
const char *
dirname,
const char *relbase,
int frame,
int type)
1131 case CACHE_TYPE_FOAM:
1134 case CACHE_TYPE_NORMAL:
1137 case CACHE_TYPE_SPRAY:
1140 case CACHE_TYPE_SPRAY_INVERSE:
1143 case CACHE_TYPE_DISPLACE:
1154 "Path parsing errors should only occur when a variable map is provided.");
1159MINLINE void rgb_to_rgba_unit_alpha(
float r_rgba[4],
const float rgb[3])
1166MINLINE void value_to_rgba_unit_alpha(
float r_rgba[4],
const float value)
1182 if (och->ibufs_disp) {
1183 for (i = och->start, f = 0; i <= och->end; i++, f++) {
1184 if (och->ibufs_disp[f]) {
1188 MEM_delete(och->ibufs_disp);
1191 if (och->ibufs_foam) {
1192 for (i = och->start, f = 0; i <= och->end; i++, f++) {
1193 if (och->ibufs_foam[f]) {
1197 MEM_delete(och->ibufs_foam);
1200 if (och->ibufs_spray) {
1201 for (i = och->start, f = 0; i <= och->end; i++, f++) {
1202 if (och->ibufs_spray[f]) {
1206 MEM_delete(och->ibufs_spray);
1209 if (och->ibufs_spray_inverse) {
1210 for (i = och->start, f = 0; i <= och->end; i++, f++) {
1211 if (och->ibufs_spray_inverse[f]) {
1215 MEM_delete(och->ibufs_spray_inverse);
1218 if (och->ibufs_norm) {
1219 for (i = och->start, f = 0; i <= och->end; i++, f++) {
1220 if (och->ibufs_norm[f]) {
1224 MEM_delete(och->ibufs_norm);
1228 MEM_delete(och->time);
1235 int res_x = och->resolution_x;
1236 int res_y = och->resolution_y;
1249 const float texel_x = u * res_x - 0.5f;
1250 const float texel_y =
v * res_y - 0.5f;
1251 if (och->ibufs_disp[f]) {
1256 if (och->ibufs_foam[f]) {
1261 if (och->ibufs_spray[f]) {
1266 if (och->ibufs_spray_inverse[f]) {
1271 if (och->ibufs_norm[f]) {
1279 const int res_x = och->resolution_x;
1280 const int res_y = och->resolution_y;
1292 if (och->ibufs_disp[f]) {
1293 copy_v3_v3(ocr->disp, &och->ibufs_disp[f]->float_data()[4 * (res_x * j + i)]);
1296 if (och->ibufs_foam[f]) {
1297 ocr->foam = och->ibufs_foam[f]->float_data()[4 * (res_x * j + i)];
1300 if (och->ibufs_spray[f]) {
1301 copy_v3_v3(ocr->Eplus, &och->ibufs_spray[f]->float_data()[4 * (res_x * j + i)]);
1304 if (och->ibufs_spray_inverse[f]) {
1305 copy_v3_v3(ocr->Eminus, &och->ibufs_spray_inverse[f]->float_data()[4 * (res_x * j + i)]);
1308 if (och->ibufs_norm[f]) {
1309 copy_v3_v3(ocr->normal, &och->ibufs_norm[f]->float_data()[4 * (res_x * j + i)]);
1314 const char *relbase,
1319 float foam_coverage,
1325 och->bakepath = bakepath;
1326 och->relbase = relbase;
1330 och->duration = (end - start) + 1;
1331 och->wave_scale = wave_scale;
1332 och->chop_amount = chop_amount;
1333 och->foam_coverage = foam_coverage;
1334 och->foam_fade = foam_fade;
1335 och->resolution_x = resolution * resolution;
1336 och->resolution_y = resolution * resolution;
1339 "displacement imbuf pointer array");
1343 "spray_inverse imbuf pointer array");
1346 och->time =
nullptr;
1357 CLAMP(frame, och->start, och->end);
1358 const int f = frame - och->start;
1361 if (och->ibufs_disp[f] !=
nullptr) {
1368 cache_filepath(filepath, och->bakepath, och->relbase, frame, CACHE_TYPE_DISPLACE);
1371 cache_filepath(filepath, och->bakepath, och->relbase, frame, CACHE_TYPE_FOAM);
1374 cache_filepath(filepath, och->bakepath, och->relbase, frame, CACHE_TYPE_SPRAY);
1377 cache_filepath(filepath, och->bakepath, och->relbase, frame, CACHE_TYPE_SPRAY_INVERSE);
1380 cache_filepath(filepath, och->bakepath, och->relbase, frame, CACHE_TYPE_NORMAL);
1386 void (*update_cb)(
void *,
float progress,
int *cancel),
1387 void *update_cb_data)
1395 int f, i = 0,
x,
y, cancel = 0;
1398 ImBuf *ibuf_foam, *ibuf_disp, *ibuf_normal, *ibuf_spray, *ibuf_spray_inverse;
1400 int res_x = och->resolution_x;
1401 int res_y = och->resolution_y;
1409 if (o->_do_jacobian) {
1411 "previous frame foam bake data");
1414 prev_foam =
nullptr;
1424 for (f = och->start, i = 0; f <= och->end; f++, i++) {
1436 float *ibuf_disp_data = ibuf_disp->float_data_for_write();
1437 float *ibuf_foam_data = ibuf_foam->float_data_for_write();
1438 float *ibuf_spray_data = ibuf_spray->float_data_for_write();
1439 float *ibuf_spray_inverse_data = ibuf_spray_inverse->float_data_for_write();
1440 float *ibuf_normal_data = ibuf_normal->float_data_for_write();
1441 for (
y = 0;
y < res_y;
y++) {
1442 for (
x = 0;
x < res_x;
x++) {
1447 rgb_to_rgba_unit_alpha(&ibuf_disp_data[4 * (res_x *
y +
x)], ocr.disp);
1449 if (o->_do_jacobian) {
1452 float pr = 0.0f, foam_result;
1453 float neg_disp, neg_eplus;
1459 pr = prev_foam[res_x *
y +
x];
1470 neg_disp = ocr.disp[1] < 0.0f ? 1.0f + ocr.disp[1] : 1.0f;
1471 neg_disp = neg_disp < 0.0f ? 0.0f : neg_disp;
1474 neg_eplus = ocr.Eplus[2] < 0.0f ? 1.0f + ocr.Eplus[2] : 1.0f;
1475 neg_eplus = neg_eplus < 0.0f ? 0.0f : neg_eplus;
1481 pr *= och->foam_fade * (0.75f + neg_eplus * 0.25f);
1484 foam_result =
min_ff(pr + ocr.foam, 1.0f);
1486 prev_foam[res_x *
y +
x] = foam_result;
1490 value_to_rgba_unit_alpha(&ibuf_foam_data[4 * (res_x *
y +
x)], foam_result);
1494 rgb_to_rgba_unit_alpha(&ibuf_spray_data[4 * (res_x *
y +
x)], ocr.Eplus);
1495 rgb_to_rgba_unit_alpha(&ibuf_spray_inverse_data[4 * (res_x *
y +
x)], ocr.Eminus);
1499 if (o->_do_normals) {
1500 rgb_to_rgba_unit_alpha(&ibuf_normal_data[4 * (res_x *
y +
x)], ocr.normal);
1506 cache_filepath(filepath, och->bakepath, och->relbase, f, CACHE_TYPE_DISPLACE);
1508 printf(
"Cannot save Displacement File Output to %s\n", filepath);
1511 if (o->_do_jacobian) {
1512 cache_filepath(filepath, och->bakepath, och->relbase, f, CACHE_TYPE_FOAM);
1514 printf(
"Cannot save Foam File Output to %s\n", filepath);
1518 cache_filepath(filepath, och->bakepath, och->relbase, f, CACHE_TYPE_SPRAY);
1520 printf(
"Cannot save Spray File Output to %s\n", filepath);
1523 cache_filepath(filepath, och->bakepath, och->relbase, f, CACHE_TYPE_SPRAY_INVERSE);
1525 printf(
"Cannot save Spray Inverse File Output to %s\n", filepath);
1530 if (o->_do_normals) {
1531 cache_filepath(filepath, och->bakepath, och->relbase, f, CACHE_TYPE_NORMAL);
1533 printf(
"Cannot save Normal File Output to %s\n", filepath);
1543 progress = (f - och->start) /
float(och->duration);
1545 update_cb(update_cb_data, progress, &cancel);
1549 MEM_delete(prev_foam);
1558 MEM_delete(prev_foam);
1666 void (*update_cb)(
void *,
float progress,
int *cancel),
#define BLI_path_join(...)
#define THREAD_LOCK_WRITE
const char * dirname(char *path)
Read Blender memory allocation and freeing.
#define UNUSED_VARS_NDEBUG(...)
#define BLI_assert_msg(a, msg)
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
SIMD_FORCE_INLINE btScalar length2() const
Return the length of the vector squared.
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
ccl_device_inline float2 fmod(const float2 a, const float b)
std::string time(const std::tm &date_time, TimeFormat format=TimeFormat::H24)
std::string filename(const std::string_view &str, size_t pos)
float4 interpolate_bilinear_fl(const ImBuf *in, float u, float v)
MINLINE float min_ff(float a, float b)
@ MOD_OCEAN_SPECTRUM_PIERSON_MOSKOWITZ
@ MOD_OCEAN_SPECTRUM_JONSWAP
@ MOD_OCEAN_SPECTRUM_TEXEL_MARSEN_ARSLOE
void BKE_ocean_eval_uv_catrom(struct Ocean *oc, struct OceanResult *ocr, float u, float v)
float BKE_ocean_jminus_to_foam(float jminus, float coverage)
BLI_INLINE void BLI_parallel_range_settings_defaults(TaskParallelSettings *settings)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void BKE_ocean_eval_uv(struct Ocean *oc, struct OceanResult *ocr, float u, float v)
BLI_INLINE unsigned int BLI_hash_int_2d(unsigned int kx, unsigned int ky)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void BKE_ocean_free_modifier_cache(struct OceanModifierData *omd)
void BKE_ocean_free(struct Ocean *oc)
void BKE_ocean_eval_xz(struct Ocean *oc, struct OceanResult *ocr, float x, float z)
void BKE_ocean_bake(struct Ocean *o, struct OceanCache *och, void(*update_cb)(void *, float progress, int *cancel), void *update_cb_data)
void BLI_task_parallel_range(int start, int stop, void *userdata, TaskParallelRangeFunc func, const TaskParallelSettings *settings)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void BLI_rw_mutex_lock(ThreadRWMutex *mutex, int mode)
void BKE_ocean_free_data(struct Ocean *oc)
struct RNG * BLI_rng_new(unsigned int seed)
struct OceanCache * BKE_ocean_init_cache(const char *bakepath, const char *relbase, int start, int end, float wave_scale, float chop_amount, float foam_coverage, float foam_fade, int resolution)
void BLI_rw_mutex_init(ThreadRWMutex *mutex)
void BLI_task_pool_work_and_wait(TaskPool *pool)
void * BLI_task_pool_user_data(TaskPool *pool)
void BKE_ocean_eval_ij(struct Ocean *oc, struct OceanResult *ocr, int i, int j)
ImBuf * IMB_load_image_from_filepath(const char *filepath, ImBufFlags flags, ColorManagedColorspaceSettings *colorspace_settings=nullptr)
void IMB_freeImBuf(ImBuf *ibuf)
float BLI_ocean_spectrum_texelmarsenarsloe(const struct Ocean *oc, float kx, float kz)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BLI_rw_mutex_unlock(ThreadRWMutex *mutex)
void BLI_rng_seed(struct RNG *rng, unsigned int seed) ATTR_NONNULL(1)
float BLI_ocean_spectrum_piersonmoskowitz(const struct Ocean *oc, float kx, float kz)
float BLI_ocean_spectrum_jonswap(const struct Ocean *oc, float kx, float kz)
void BKE_ocean_eval_xz_catrom(struct Ocean *oc, struct OceanResult *ocr, float x, float z)
void BLI_rng_free(struct RNG *rng) ATTR_NONNULL(1)
bool BKE_ocean_init_from_modifier(struct Ocean *ocean, struct OceanModifierData const *omd, int resolution)
void BLI_task_pool_free(TaskPool *pool)
float BLI_rng_get_float(struct RNG *rng) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BLI_rw_mutex_end(ThreadRWMutex *mutex)
void BKE_ocean_cache_eval_uv(struct OceanCache *och, struct OceanResult *ocr, int f, float u, float v)
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
TaskPool * BLI_task_pool_create(void *userdata, eTaskPriority priority)
MINLINE float normalize_v3(float n[3])
bool BKE_ocean_is_valid(const struct Ocean *o)
void BKE_ocean_free_cache(struct OceanCache *och)
void BKE_ocean_cache_eval_ij(struct OceanCache *och, struct OceanResult *ocr, int f, int i, int j)
void BKE_ocean_simulate_cache(struct OceanCache *och, int frame)
@ MOD_OCEAN_GENERATE_FOAM
@ MOD_OCEAN_GENERATE_NORMALS
@ MOD_OCEAN_GENERATE_SPRAY
Vector< bke::path_templates::Error > BKE_image_path_from_imtype(char *filepath, const char *base, const char *relbase, const bke::path_templates::VariableMap *template_variables, int frame, char imtype, bool use_ext, bool use_frames, const char *suffix)
void BLI_thread_unlock(int type)
void BLI_task_pool_push(TaskPool *pool, TaskRunFunction run, void *taskdata, bool free_taskdata, TaskFreeFunction freedata)
bool BKE_ocean_ensure(struct OceanModifierData *omd, int resolution)
bool BKE_imbuf_write(ImBuf *ibuf, const char *filepath, const ImageFormatData *imf)
void BLI_thread_lock(int type)
void BKE_ocean_simulate(struct Ocean *o, float t, float scale, float chop_amount)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
struct Ocean * BKE_ocean_add()
bool BKE_ocean_init(struct Ocean *o, int M, int N, float Lx, float Lz, float V, float l, float A, float w, float damp, float alignment, float depth, float time, int spectrum, float fetch_jonswap, float sharpen_peak_jonswap, short do_height_field, short do_chop, short do_spray, short do_normals, short do_jacobian, int seed)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct OceanCache * oceancache
CCL_NAMESPACE_BEGIN struct Window V