Blender  V3.3
musgrave.h
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0
2  * Copyright 2011-2022 Blender Foundation */
3 
4 #pragma once
5 
6 #include "kernel/svm/noise.h"
7 
9 
10 /* 1D Musgrave fBm
11  *
12  * H: fractal increment parameter
13  * lacunarity: gap between successive frequencies
14  * octaves: number of frequencies in the fBm
15  *
16  * from "Texturing and Modelling: A procedural approach"
17  */
18 
20  float H,
21  float lacunarity,
22  float octaves)
23 {
24  float p = co;
25  float value = 0.0f;
26  float pwr = 1.0f;
27  float pwHL = powf(lacunarity, -H);
28 
29  for (int i = 0; i < float_to_int(octaves); i++) {
30  value += snoise_1d(p) * pwr;
31  pwr *= pwHL;
32  p *= lacunarity;
33  }
34 
35  float rmd = octaves - floorf(octaves);
36  if (rmd != 0.0f) {
37  value += rmd * snoise_1d(p) * pwr;
38  }
39 
40  return value;
41 }
42 
43 /* 1D Musgrave Multifractal
44  *
45  * H: highest fractal dimension
46  * lacunarity: gap between successive frequencies
47  * octaves: number of frequencies in the fBm
48  */
49 
51  float H,
52  float lacunarity,
53  float octaves)
54 {
55  float p = co;
56  float value = 1.0f;
57  float pwr = 1.0f;
58  float pwHL = powf(lacunarity, -H);
59 
60  for (int i = 0; i < float_to_int(octaves); i++) {
61  value *= (pwr * snoise_1d(p) + 1.0f);
62  pwr *= pwHL;
63  p *= lacunarity;
64  }
65 
66  float rmd = octaves - floorf(octaves);
67  if (rmd != 0.0f) {
68  value *= (rmd * pwr * snoise_1d(p) + 1.0f); /* correct? */
69  }
70 
71  return value;
72 }
73 
74 /* 1D Musgrave Heterogeneous Terrain
75  *
76  * H: fractal dimension of the roughest area
77  * lacunarity: gap between successive frequencies
78  * octaves: number of frequencies in the fBm
79  * offset: raises the terrain from `sea level'
80  */
81 
83  float co, float H, float lacunarity, float octaves, float offset)
84 {
85  float p = co;
86  float pwHL = powf(lacunarity, -H);
87  float pwr = pwHL;
88 
89  /* first unscaled octave of function; later octaves are scaled */
90  float value = offset + snoise_1d(p);
91  p *= lacunarity;
92 
93  for (int i = 1; i < float_to_int(octaves); i++) {
94  float increment = (snoise_1d(p) + offset) * pwr * value;
95  value += increment;
96  pwr *= pwHL;
97  p *= lacunarity;
98  }
99 
100  float rmd = octaves - floorf(octaves);
101  if (rmd != 0.0f) {
102  float increment = (snoise_1d(p) + offset) * pwr * value;
103  value += rmd * increment;
104  }
105 
106  return value;
107 }
108 
109 /* 1D Hybrid Additive/Multiplicative Multifractal Terrain
110  *
111  * H: fractal dimension of the roughest area
112  * lacunarity: gap between successive frequencies
113  * octaves: number of frequencies in the fBm
114  * offset: raises the terrain from `sea level'
115  */
116 
118  float co, float H, float lacunarity, float octaves, float offset, float gain)
119 {
120  float p = co;
121  float pwHL = powf(lacunarity, -H);
122 
123  float pwr = 1.0f;
124  float value = 0.0f;
125  float weight = 1.0f;
126 
127  for (int i = 0; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
128  if (weight > 1.0f) {
129  weight = 1.0f;
130  }
131 
132  float signal = (snoise_1d(p) + offset) * pwr;
133  pwr *= pwHL;
134  value += weight * signal;
135  weight *= gain * signal;
136  p *= lacunarity;
137  }
138 
139  float rmd = octaves - floorf(octaves);
140  if ((rmd != 0.0f) && (weight > 0.001f)) {
141  if (weight > 1.0f) {
142  weight = 1.0f;
143  }
144  float signal = (snoise_1d(p) + offset) * pwr;
145  value += rmd * weight * signal;
146  }
147 
148  return value;
149 }
150 
151 /* 1D Ridged Multifractal Terrain
152  *
153  * H: fractal dimension of the roughest area
154  * lacunarity: gap between successive frequencies
155  * octaves: number of frequencies in the fBm
156  * offset: raises the terrain from `sea level'
157  */
158 
160  float co, float H, float lacunarity, float octaves, float offset, float gain)
161 {
162  float p = co;
163  float pwHL = powf(lacunarity, -H);
164  float pwr = pwHL;
165 
166  float signal = offset - fabsf(snoise_1d(p));
167  signal *= signal;
168  float value = signal;
169  float weight = 1.0f;
170 
171  for (int i = 1; i < float_to_int(octaves); i++) {
172  p *= lacunarity;
173  weight = saturatef(signal * gain);
174  signal = offset - fabsf(snoise_1d(p));
175  signal *= signal;
176  signal *= weight;
177  value += signal * pwr;
178  pwr *= pwHL;
179  }
180 
181  return value;
182 }
183 
184 /* 2D Musgrave fBm
185  *
186  * H: fractal increment parameter
187  * lacunarity: gap between successive frequencies
188  * octaves: number of frequencies in the fBm
189  *
190  * from "Texturing and Modelling: A procedural approach"
191  */
192 
194  float H,
195  float lacunarity,
196  float octaves)
197 {
198  float2 p = co;
199  float value = 0.0f;
200  float pwr = 1.0f;
201  float pwHL = powf(lacunarity, -H);
202 
203  for (int i = 0; i < float_to_int(octaves); i++) {
204  value += snoise_2d(p) * pwr;
205  pwr *= pwHL;
206  p *= lacunarity;
207  }
208 
209  float rmd = octaves - floorf(octaves);
210  if (rmd != 0.0f) {
211  value += rmd * snoise_2d(p) * pwr;
212  }
213 
214  return value;
215 }
216 
217 /* 2D Musgrave Multifractal
218  *
219  * H: highest fractal dimension
220  * lacunarity: gap between successive frequencies
221  * octaves: number of frequencies in the fBm
222  */
223 
225  float H,
226  float lacunarity,
227  float octaves)
228 {
229  float2 p = co;
230  float value = 1.0f;
231  float pwr = 1.0f;
232  float pwHL = powf(lacunarity, -H);
233 
234  for (int i = 0; i < float_to_int(octaves); i++) {
235  value *= (pwr * snoise_2d(p) + 1.0f);
236  pwr *= pwHL;
237  p *= lacunarity;
238  }
239 
240  float rmd = octaves - floorf(octaves);
241  if (rmd != 0.0f) {
242  value *= (rmd * pwr * snoise_2d(p) + 1.0f); /* correct? */
243  }
244 
245  return value;
246 }
247 
248 /* 2D Musgrave Heterogeneous Terrain
249  *
250  * H: fractal dimension of the roughest area
251  * lacunarity: gap between successive frequencies
252  * octaves: number of frequencies in the fBm
253  * offset: raises the terrain from `sea level'
254  */
255 
257  float2 co, float H, float lacunarity, float octaves, float offset)
258 {
259  float2 p = co;
260  float pwHL = powf(lacunarity, -H);
261  float pwr = pwHL;
262 
263  /* first unscaled octave of function; later octaves are scaled */
264  float value = offset + snoise_2d(p);
265  p *= lacunarity;
266 
267  for (int i = 1; i < float_to_int(octaves); i++) {
268  float increment = (snoise_2d(p) + offset) * pwr * value;
269  value += increment;
270  pwr *= pwHL;
271  p *= lacunarity;
272  }
273 
274  float rmd = octaves - floorf(octaves);
275  if (rmd != 0.0f) {
276  float increment = (snoise_2d(p) + offset) * pwr * value;
277  value += rmd * increment;
278  }
279 
280  return value;
281 }
282 
283 /* 2D Hybrid Additive/Multiplicative Multifractal Terrain
284  *
285  * H: fractal dimension of the roughest area
286  * lacunarity: gap between successive frequencies
287  * octaves: number of frequencies in the fBm
288  * offset: raises the terrain from `sea level'
289  */
290 
292  float2 co, float H, float lacunarity, float octaves, float offset, float gain)
293 {
294  float2 p = co;
295  float pwHL = powf(lacunarity, -H);
296 
297  float pwr = 1.0f;
298  float value = 0.0f;
299  float weight = 1.0f;
300 
301  for (int i = 0; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
302  if (weight > 1.0f) {
303  weight = 1.0f;
304  }
305 
306  float signal = (snoise_2d(p) + offset) * pwr;
307  pwr *= pwHL;
308  value += weight * signal;
309  weight *= gain * signal;
310  p *= lacunarity;
311  }
312 
313  float rmd = octaves - floorf(octaves);
314  if ((rmd != 0.0f) && (weight > 0.001f)) {
315  if (weight > 1.0f) {
316  weight = 1.0f;
317  }
318  float signal = (snoise_2d(p) + offset) * pwr;
319  value += rmd * weight * signal;
320  }
321 
322  return value;
323 }
324 
325 /* 2D Ridged Multifractal Terrain
326  *
327  * H: fractal dimension of the roughest area
328  * lacunarity: gap between successive frequencies
329  * octaves: number of frequencies in the fBm
330  * offset: raises the terrain from `sea level'
331  */
332 
334  float2 co, float H, float lacunarity, float octaves, float offset, float gain)
335 {
336  float2 p = co;
337  float pwHL = powf(lacunarity, -H);
338  float pwr = pwHL;
339 
340  float signal = offset - fabsf(snoise_2d(p));
341  signal *= signal;
342  float value = signal;
343  float weight = 1.0f;
344 
345  for (int i = 1; i < float_to_int(octaves); i++) {
346  p *= lacunarity;
347  weight = saturatef(signal * gain);
348  signal = offset - fabsf(snoise_2d(p));
349  signal *= signal;
350  signal *= weight;
351  value += signal * pwr;
352  pwr *= pwHL;
353  }
354 
355  return value;
356 }
357 
358 /* 3D Musgrave fBm
359  *
360  * H: fractal increment parameter
361  * lacunarity: gap between successive frequencies
362  * octaves: number of frequencies in the fBm
363  *
364  * from "Texturing and Modelling: A procedural approach"
365  */
366 
368  float H,
369  float lacunarity,
370  float octaves)
371 {
372  float3 p = co;
373  float value = 0.0f;
374  float pwr = 1.0f;
375  float pwHL = powf(lacunarity, -H);
376 
377  for (int i = 0; i < float_to_int(octaves); i++) {
378  value += snoise_3d(p) * pwr;
379  pwr *= pwHL;
380  p *= lacunarity;
381  }
382 
383  float rmd = octaves - floorf(octaves);
384  if (rmd != 0.0f) {
385  value += rmd * snoise_3d(p) * pwr;
386  }
387 
388  return value;
389 }
390 
391 /* 3D Musgrave Multifractal
392  *
393  * H: highest fractal dimension
394  * lacunarity: gap between successive frequencies
395  * octaves: number of frequencies in the fBm
396  */
397 
399  float H,
400  float lacunarity,
401  float octaves)
402 {
403  float3 p = co;
404  float value = 1.0f;
405  float pwr = 1.0f;
406  float pwHL = powf(lacunarity, -H);
407 
408  for (int i = 0; i < float_to_int(octaves); i++) {
409  value *= (pwr * snoise_3d(p) + 1.0f);
410  pwr *= pwHL;
411  p *= lacunarity;
412  }
413 
414  float rmd = octaves - floorf(octaves);
415  if (rmd != 0.0f) {
416  value *= (rmd * pwr * snoise_3d(p) + 1.0f); /* correct? */
417  }
418 
419  return value;
420 }
421 
422 /* 3D Musgrave Heterogeneous Terrain
423  *
424  * H: fractal dimension of the roughest area
425  * lacunarity: gap between successive frequencies
426  * octaves: number of frequencies in the fBm
427  * offset: raises the terrain from `sea level'
428  */
429 
431  float3 co, float H, float lacunarity, float octaves, float offset)
432 {
433  float3 p = co;
434  float pwHL = powf(lacunarity, -H);
435  float pwr = pwHL;
436 
437  /* first unscaled octave of function; later octaves are scaled */
438  float value = offset + snoise_3d(p);
439  p *= lacunarity;
440 
441  for (int i = 1; i < float_to_int(octaves); i++) {
442  float increment = (snoise_3d(p) + offset) * pwr * value;
443  value += increment;
444  pwr *= pwHL;
445  p *= lacunarity;
446  }
447 
448  float rmd = octaves - floorf(octaves);
449  if (rmd != 0.0f) {
450  float increment = (snoise_3d(p) + offset) * pwr * value;
451  value += rmd * increment;
452  }
453 
454  return value;
455 }
456 
457 /* 3D Hybrid Additive/Multiplicative Multifractal Terrain
458  *
459  * H: fractal dimension of the roughest area
460  * lacunarity: gap between successive frequencies
461  * octaves: number of frequencies in the fBm
462  * offset: raises the terrain from `sea level'
463  */
464 
466  float3 co, float H, float lacunarity, float octaves, float offset, float gain)
467 {
468  float3 p = co;
469  float pwHL = powf(lacunarity, -H);
470 
471  float pwr = 1.0f;
472  float value = 0.0f;
473  float weight = 1.0f;
474 
475  for (int i = 0; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
476  if (weight > 1.0f) {
477  weight = 1.0f;
478  }
479 
480  float signal = (snoise_3d(p) + offset) * pwr;
481  pwr *= pwHL;
482  value += weight * signal;
483  weight *= gain * signal;
484  p *= lacunarity;
485  }
486 
487  float rmd = octaves - floorf(octaves);
488  if ((rmd != 0.0f) && (weight > 0.001f)) {
489  if (weight > 1.0f) {
490  weight = 1.0f;
491  }
492  float signal = (snoise_3d(p) + offset) * pwr;
493  value += rmd * weight * signal;
494  }
495 
496  return value;
497 }
498 
499 /* 3D Ridged Multifractal Terrain
500  *
501  * H: fractal dimension of the roughest area
502  * lacunarity: gap between successive frequencies
503  * octaves: number of frequencies in the fBm
504  * offset: raises the terrain from `sea level'
505  */
506 
508  float3 co, float H, float lacunarity, float octaves, float offset, float gain)
509 {
510  float3 p = co;
511  float pwHL = powf(lacunarity, -H);
512  float pwr = pwHL;
513 
514  float signal = offset - fabsf(snoise_3d(p));
515  signal *= signal;
516  float value = signal;
517  float weight = 1.0f;
518 
519  for (int i = 1; i < float_to_int(octaves); i++) {
520  p *= lacunarity;
521  weight = saturatef(signal * gain);
522  signal = offset - fabsf(snoise_3d(p));
523  signal *= signal;
524  signal *= weight;
525  value += signal * pwr;
526  pwr *= pwHL;
527  }
528 
529  return value;
530 }
531 
532 /* 4D Musgrave fBm
533  *
534  * H: fractal increment parameter
535  * lacunarity: gap between successive frequencies
536  * octaves: number of frequencies in the fBm
537  *
538  * from "Texturing and Modelling: A procedural approach"
539  */
540 
542  float H,
543  float lacunarity,
544  float octaves)
545 {
546  float4 p = co;
547  float value = 0.0f;
548  float pwr = 1.0f;
549  float pwHL = powf(lacunarity, -H);
550 
551  for (int i = 0; i < float_to_int(octaves); i++) {
552  value += snoise_4d(p) * pwr;
553  pwr *= pwHL;
554  p *= lacunarity;
555  }
556 
557  float rmd = octaves - floorf(octaves);
558  if (rmd != 0.0f) {
559  value += rmd * snoise_4d(p) * pwr;
560  }
561 
562  return value;
563 }
564 
565 /* 4D Musgrave Multifractal
566  *
567  * H: highest fractal dimension
568  * lacunarity: gap between successive frequencies
569  * octaves: number of frequencies in the fBm
570  */
571 
573  float H,
574  float lacunarity,
575  float octaves)
576 {
577  float4 p = co;
578  float value = 1.0f;
579  float pwr = 1.0f;
580  float pwHL = powf(lacunarity, -H);
581 
582  for (int i = 0; i < float_to_int(octaves); i++) {
583  value *= (pwr * snoise_4d(p) + 1.0f);
584  pwr *= pwHL;
585  p *= lacunarity;
586  }
587 
588  float rmd = octaves - floorf(octaves);
589  if (rmd != 0.0f) {
590  value *= (rmd * pwr * snoise_4d(p) + 1.0f); /* correct? */
591  }
592 
593  return value;
594 }
595 
596 /* 4D Musgrave Heterogeneous Terrain
597  *
598  * H: fractal dimension of the roughest area
599  * lacunarity: gap between successive frequencies
600  * octaves: number of frequencies in the fBm
601  * offset: raises the terrain from `sea level'
602  */
603 
605  float4 co, float H, float lacunarity, float octaves, float offset)
606 {
607  float4 p = co;
608  float pwHL = powf(lacunarity, -H);
609  float pwr = pwHL;
610 
611  /* first unscaled octave of function; later octaves are scaled */
612  float value = offset + snoise_4d(p);
613  p *= lacunarity;
614 
615  for (int i = 1; i < float_to_int(octaves); i++) {
616  float increment = (snoise_4d(p) + offset) * pwr * value;
617  value += increment;
618  pwr *= pwHL;
619  p *= lacunarity;
620  }
621 
622  float rmd = octaves - floorf(octaves);
623  if (rmd != 0.0f) {
624  float increment = (snoise_4d(p) + offset) * pwr * value;
625  value += rmd * increment;
626  }
627 
628  return value;
629 }
630 
631 /* 4D Hybrid Additive/Multiplicative Multifractal Terrain
632  *
633  * H: fractal dimension of the roughest area
634  * lacunarity: gap between successive frequencies
635  * octaves: number of frequencies in the fBm
636  * offset: raises the terrain from `sea level'
637  */
638 
640  float4 co, float H, float lacunarity, float octaves, float offset, float gain)
641 {
642  float4 p = co;
643  float pwHL = powf(lacunarity, -H);
644 
645  float pwr = 1.0f;
646  float value = 0.0f;
647  float weight = 1.0f;
648 
649  for (int i = 0; (weight > 0.001f) && (i < float_to_int(octaves)); i++) {
650  if (weight > 1.0f) {
651  weight = 1.0f;
652  }
653 
654  float signal = (snoise_4d(p) + offset) * pwr;
655  pwr *= pwHL;
656  value += weight * signal;
657  weight *= gain * signal;
658  p *= lacunarity;
659  }
660 
661  float rmd = octaves - floorf(octaves);
662  if ((rmd != 0.0f) && (weight > 0.001f)) {
663  if (weight > 1.0f) {
664  weight = 1.0f;
665  }
666  float signal = (snoise_4d(p) + offset) * pwr;
667  value += rmd * weight * signal;
668  }
669 
670  return value;
671 }
672 
673 /* 4D Ridged Multifractal Terrain
674  *
675  * H: fractal dimension of the roughest area
676  * lacunarity: gap between successive frequencies
677  * octaves: number of frequencies in the fBm
678  * offset: raises the terrain from `sea level'
679  */
680 
682  float4 co, float H, float lacunarity, float octaves, float offset, float gain)
683 {
684  float4 p = co;
685  float pwHL = powf(lacunarity, -H);
686  float pwr = pwHL;
687 
688  float signal = offset - fabsf(snoise_4d(p));
689  signal *= signal;
690  float value = signal;
691  float weight = 1.0f;
692 
693  for (int i = 1; i < float_to_int(octaves); i++) {
694  p *= lacunarity;
695  weight = saturatef(signal * gain);
696  signal = offset - fabsf(snoise_4d(p));
697  signal *= signal;
698  signal *= weight;
699  value += signal * pwr;
700  pwr *= pwHL;
701  }
702 
703  return value;
704 }
705 
708  ccl_private float *stack,
709  uint offsets1,
710  uint offsets2,
711  uint offsets3,
712  int offset)
713 {
714  uint type, dimensions, co_stack_offset, w_stack_offset;
715  uint scale_stack_offset, detail_stack_offset, dimension_stack_offset, lacunarity_stack_offset;
716  uint offset_stack_offset, gain_stack_offset, fac_stack_offset;
717 
718  svm_unpack_node_uchar4(offsets1, &type, &dimensions, &co_stack_offset, &w_stack_offset);
719  svm_unpack_node_uchar4(offsets2,
720  &scale_stack_offset,
721  &detail_stack_offset,
722  &dimension_stack_offset,
723  &lacunarity_stack_offset);
724  svm_unpack_node_uchar3(offsets3, &offset_stack_offset, &gain_stack_offset, &fac_stack_offset);
725 
726  uint4 defaults1 = read_node(kg, &offset);
727  uint4 defaults2 = read_node(kg, &offset);
728 
729  float3 co = stack_load_float3(stack, co_stack_offset);
730  float w = stack_load_float_default(stack, w_stack_offset, defaults1.x);
731  float scale = stack_load_float_default(stack, scale_stack_offset, defaults1.y);
732  float detail = stack_load_float_default(stack, detail_stack_offset, defaults1.z);
733  float dimension = stack_load_float_default(stack, dimension_stack_offset, defaults1.w);
734  float lacunarity = stack_load_float_default(stack, lacunarity_stack_offset, defaults2.x);
735  float foffset = stack_load_float_default(stack, offset_stack_offset, defaults2.y);
736  float gain = stack_load_float_default(stack, gain_stack_offset, defaults2.z);
737 
738  dimension = fmaxf(dimension, 1e-5f);
739  detail = clamp(detail, 0.0f, 15.0f);
740  lacunarity = fmaxf(lacunarity, 1e-5f);
741 
742  float fac;
743 
744  switch (dimensions) {
745  case 1: {
746  float p = w * scale;
747  switch ((NodeMusgraveType)type) {
749  fac = noise_musgrave_multi_fractal_1d(p, dimension, lacunarity, detail);
750  break;
751  case NODE_MUSGRAVE_FBM:
752  fac = noise_musgrave_fBm_1d(p, dimension, lacunarity, detail);
753  break;
756  p, dimension, lacunarity, detail, foffset, gain);
757  break;
760  p, dimension, lacunarity, detail, foffset, gain);
761  break;
763  fac = noise_musgrave_hetero_terrain_1d(p, dimension, lacunarity, detail, foffset);
764  break;
765  default:
766  fac = 0.0f;
767  }
768  break;
769  }
770  case 2: {
771  float2 p = make_float2(co.x, co.y) * scale;
772  switch ((NodeMusgraveType)type) {
774  fac = noise_musgrave_multi_fractal_2d(p, dimension, lacunarity, detail);
775  break;
776  case NODE_MUSGRAVE_FBM:
777  fac = noise_musgrave_fBm_2d(p, dimension, lacunarity, detail);
778  break;
781  p, dimension, lacunarity, detail, foffset, gain);
782  break;
785  p, dimension, lacunarity, detail, foffset, gain);
786  break;
788  fac = noise_musgrave_hetero_terrain_2d(p, dimension, lacunarity, detail, foffset);
789  break;
790  default:
791  fac = 0.0f;
792  }
793  break;
794  }
795  case 3: {
796  float3 p = co * scale;
797  switch ((NodeMusgraveType)type) {
799  fac = noise_musgrave_multi_fractal_3d(p, dimension, lacunarity, detail);
800  break;
801  case NODE_MUSGRAVE_FBM:
802  fac = noise_musgrave_fBm_3d(p, dimension, lacunarity, detail);
803  break;
806  p, dimension, lacunarity, detail, foffset, gain);
807  break;
810  p, dimension, lacunarity, detail, foffset, gain);
811  break;
813  fac = noise_musgrave_hetero_terrain_3d(p, dimension, lacunarity, detail, foffset);
814  break;
815  default:
816  fac = 0.0f;
817  }
818  break;
819  }
820  case 4: {
821  float4 p = make_float4(co.x, co.y, co.z, w) * scale;
822  switch ((NodeMusgraveType)type) {
824  fac = noise_musgrave_multi_fractal_4d(p, dimension, lacunarity, detail);
825  break;
826  case NODE_MUSGRAVE_FBM:
827  fac = noise_musgrave_fBm_4d(p, dimension, lacunarity, detail);
828  break;
831  p, dimension, lacunarity, detail, foffset, gain);
832  break;
835  p, dimension, lacunarity, detail, foffset, gain);
836  break;
838  fac = noise_musgrave_hetero_terrain_4d(p, dimension, lacunarity, detail, foffset);
839  break;
840  default:
841  fac = 0.0f;
842  }
843  break;
844  }
845  default:
846  fac = 0.0f;
847  }
848 
849  stack_store_float(stack, fac_stack_offset, fac);
850  return offset;
851 }
852 
unsigned int uint
Definition: BLI_sys_types.h:67
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
float float4[4]
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition: btQuadWord.h:119
#define ccl_private
Definition: cuda/compat.h:48
#define ccl_device_noinline_cpu
Definition: cuda/compat.h:41
#define powf(x, y)
Definition: cuda/compat.h:103
#define ccl_device_noinline
Definition: cuda/compat.h:40
#define CCL_NAMESPACE_END
Definition: cuda/compat.h:9
const KernelGlobalsCPU *ccl_restrict KernelGlobals
ccl_gpu_kernel_postfix ccl_global float int int int int float bool int offset
CCL_NAMESPACE_BEGIN ccl_device_inline float3 stack_load_float3(ccl_private float *stack, uint a)
ccl_device_inline uint4 read_node(KernelGlobals kg, ccl_private int *offset)
ccl_device_forceinline void svm_unpack_node_uchar3(uint i, ccl_private uint *x, ccl_private uint *y, ccl_private uint *z)
ccl_device_inline float stack_load_float_default(ccl_private float *stack, uint a, uint value)
ccl_device_inline void stack_store_float(ccl_private float *stack, uint a, float f)
ccl_device_forceinline void svm_unpack_node_uchar4(uint i, ccl_private uint *x, ccl_private uint *y, ccl_private uint *z, ccl_private uint *w)
NodeMusgraveType
@ NODE_MUSGRAVE_MULTIFRACTAL
@ NODE_MUSGRAVE_RIDGED_MULTIFRACTAL
@ NODE_MUSGRAVE_HYBRID_MULTIFRACTAL
@ NODE_MUSGRAVE_HETERO_TERRAIN
@ NODE_MUSGRAVE_FBM
ShaderData
Definition: kernel/types.h:925
#define H(x, y, z)
#define fmaxf(x, y)
Definition: metal/compat.h:228
#define make_float2(x, y)
Definition: metal/compat.h:203
#define floorf(x)
Definition: metal/compat.h:224
#define make_float4(x, y, z, w)
Definition: metal/compat.h:205
#define fabsf(x)
Definition: metal/compat.h:219
ccl_device_noinline_cpu float noise_musgrave_hetero_terrain_4d(float4 co, float H, float lacunarity, float octaves, float offset)
Definition: musgrave.h:604
ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_1d(float co, float H, float lacunarity, float octaves, float offset, float gain)
Definition: musgrave.h:159
ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_4d(float4 co, float H, float lacunarity, float octaves, float offset, float gain)
Definition: musgrave.h:681
ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_2d(float2 co, float H, float lacunarity, float octaves, float offset, float gain)
Definition: musgrave.h:333
ccl_device_noinline_cpu float noise_musgrave_multi_fractal_2d(float2 co, float H, float lacunarity, float octaves)
Definition: musgrave.h:224
ccl_device_noinline_cpu float noise_musgrave_fBm_3d(float3 co, float H, float lacunarity, float octaves)
Definition: musgrave.h:367
ccl_device_noinline_cpu float noise_musgrave_multi_fractal_1d(float co, float H, float lacunarity, float octaves)
Definition: musgrave.h:50
ccl_device_noinline_cpu float noise_musgrave_multi_fractal_3d(float3 co, float H, float lacunarity, float octaves)
Definition: musgrave.h:398
ccl_device_noinline_cpu float noise_musgrave_hetero_terrain_3d(float3 co, float H, float lacunarity, float octaves, float offset)
Definition: musgrave.h:430
ccl_device_noinline_cpu float noise_musgrave_fBm_2d(float2 co, float H, float lacunarity, float octaves)
Definition: musgrave.h:193
ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal_2d(float2 co, float H, float lacunarity, float octaves, float offset, float gain)
Definition: musgrave.h:291
ccl_device_noinline_cpu float noise_musgrave_multi_fractal_4d(float4 co, float H, float lacunarity, float octaves)
Definition: musgrave.h:572
ccl_device_noinline_cpu float noise_musgrave_ridged_multi_fractal_3d(float3 co, float H, float lacunarity, float octaves, float offset, float gain)
Definition: musgrave.h:507
ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal_1d(float co, float H, float lacunarity, float octaves, float offset, float gain)
Definition: musgrave.h:117
ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal_3d(float3 co, float H, float lacunarity, float octaves, float offset, float gain)
Definition: musgrave.h:465
ccl_device_noinline_cpu float noise_musgrave_hetero_terrain_1d(float co, float H, float lacunarity, float octaves, float offset)
Definition: musgrave.h:82
ccl_device_noinline_cpu float noise_musgrave_hetero_terrain_2d(float2 co, float H, float lacunarity, float octaves, float offset)
Definition: musgrave.h:256
ccl_device_noinline_cpu float noise_musgrave_fBm_4d(float4 co, float H, float lacunarity, float octaves)
Definition: musgrave.h:541
ccl_device_noinline int svm_node_tex_musgrave(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint offsets1, uint offsets2, uint offsets3, int offset)
Definition: musgrave.h:706
CCL_NAMESPACE_BEGIN ccl_device_noinline_cpu float noise_musgrave_fBm_1d(float co, float H, float lacunarity, float octaves)
Definition: musgrave.h:19
ccl_device_noinline_cpu float noise_musgrave_hybrid_multi_fractal_4d(float4 co, float H, float lacunarity, float octaves, float offset, float gain)
Definition: musgrave.h:639
T clamp(const T &a, const T &min, const T &max)
ccl_device_inline float snoise_1d(float p)
Definition: noise.h:680
ccl_device_inline float snoise_2d(float2 p)
Definition: noise.h:690
ccl_device_inline float snoise_3d(float3 p)
Definition: noise.h:700
ccl_device_inline float snoise_4d(float4 p)
Definition: noise.h:710
float z
float y
float x
uint x
Definition: types_uint4.h:15
uint y
Definition: types_uint4.h:15
uint z
Definition: types_uint4.h:15
uint w
Definition: types_uint4.h:15
ccl_device_inline int float_to_int(float f)
Definition: util/math.h:410
ccl_device_inline float saturatef(float a)
Definition: util/math.h:404