forked from bartvdbraak/blender
e3784a27d6
* Fix for r53689, there are two noise types, signed and unsigned. Caused Musgrave Texture to render differently compared to SVM backend.
230 lines
5.9 KiB
Plaintext
230 lines
5.9 KiB
Plaintext
/*
|
|
* Copyright 2011, Blender Foundation.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "stdosl.h"
|
|
#include "node_texture.h"
|
|
|
|
/* Musgrave fBm
|
|
*
|
|
* H: fractal increment parameter
|
|
* lacunarity: gap between successive frequencies
|
|
* octaves: number of frequencies in the fBm
|
|
*
|
|
* from "Texturing and Modelling: A procedural approach"
|
|
*/
|
|
|
|
float noise_musgrave_fBm(point p, string basis, float H, float lacunarity, float octaves)
|
|
{
|
|
float rmd;
|
|
float value = 0.0;
|
|
float pwr = 1.0;
|
|
float pwHL = pow(lacunarity, -H);
|
|
int i;
|
|
|
|
for (i = 0; i < (int)octaves; i++) {
|
|
value += safe_noise(p, 0) * pwr;
|
|
pwr *= pwHL;
|
|
p *= lacunarity;
|
|
}
|
|
|
|
rmd = octaves - floor(octaves);
|
|
if (rmd != 0.0)
|
|
value += rmd * safe_noise(p, 0) * pwr;
|
|
|
|
return value;
|
|
}
|
|
|
|
/* Musgrave Multifractal
|
|
*
|
|
* H: highest fractal dimension
|
|
* lacunarity: gap between successive frequencies
|
|
* octaves: number of frequencies in the fBm
|
|
*/
|
|
|
|
float noise_musgrave_multi_fractal(point p, string basis, float H, float lacunarity, float octaves)
|
|
{
|
|
float rmd;
|
|
float value = 1.0;
|
|
float pwr = 1.0;
|
|
float pwHL = pow(lacunarity, -H);
|
|
int i;
|
|
|
|
for (i = 0; i < (int)octaves; i++) {
|
|
value *= (pwr * safe_noise(p, 0) + 1.0);
|
|
pwr *= pwHL;
|
|
p *= lacunarity;
|
|
}
|
|
|
|
rmd = octaves - floor(octaves);
|
|
if (rmd != 0.0)
|
|
value *= (rmd * pwr * safe_noise(p, 0) + 1.0); /* correct? */
|
|
|
|
return value;
|
|
}
|
|
|
|
/* Musgrave Heterogeneous Terrain
|
|
*
|
|
* H: fractal dimension of the roughest area
|
|
* lacunarity: gap between successive frequencies
|
|
* octaves: number of frequencies in the fBm
|
|
* offset: raises the terrain from `sea level'
|
|
*/
|
|
|
|
float noise_musgrave_hetero_terrain(point p, string basis, float H, float lacunarity, float octaves, float offset)
|
|
{
|
|
float value, increment, rmd;
|
|
float pwHL = pow(lacunarity, -H);
|
|
float pwr = pwHL;
|
|
int i;
|
|
|
|
/* first unscaled octave of function; later octaves are scaled */
|
|
value = offset + safe_noise(p, 0);
|
|
p *= lacunarity;
|
|
|
|
for (i = 1; i < (int)octaves; i++) {
|
|
increment = (safe_noise(p, 0) + offset) * pwr * value;
|
|
value += increment;
|
|
pwr *= pwHL;
|
|
p *= lacunarity;
|
|
}
|
|
|
|
rmd = octaves - floor(octaves);
|
|
if (rmd != 0.0) {
|
|
increment = (safe_noise(p, 0) + offset) * pwr * value;
|
|
value += rmd * increment;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/* Hybrid Additive/Multiplicative Multifractal Terrain
|
|
*
|
|
* H: fractal dimension of the roughest area
|
|
* lacunarity: gap between successive frequencies
|
|
* octaves: number of frequencies in the fBm
|
|
* offset: raises the terrain from `sea level'
|
|
*/
|
|
|
|
float noise_musgrave_hybrid_multi_fractal(point p, string basis, float H,
|
|
float lacunarity, float octaves, float offset, float gain)
|
|
{
|
|
float result, signal, weight, rmd;
|
|
float pwHL = pow(lacunarity, -H);
|
|
float pwr = pwHL;
|
|
int i;
|
|
|
|
result = safe_noise(p, 0) + offset;
|
|
weight = gain * result;
|
|
p *= lacunarity;
|
|
|
|
for (i = 1; (weight > 0.001) && (i < (int)octaves); i++) {
|
|
if (weight > 1.0)
|
|
weight = 1.0;
|
|
|
|
signal = (safe_noise(p, 0) + offset) * pwr;
|
|
pwr *= pwHL;
|
|
result += weight * signal;
|
|
weight *= gain * signal;
|
|
p *= lacunarity;
|
|
}
|
|
|
|
rmd = octaves - floor(octaves);
|
|
if (rmd != 0.0)
|
|
result += rmd * ((safe_noise(p, 0) + offset) * pwr);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Ridged Multifractal Terrain
|
|
*
|
|
* H: fractal dimension of the roughest area
|
|
* lacunarity: gap between successive frequencies
|
|
* octaves: number of frequencies in the fBm
|
|
* offset: raises the terrain from `sea level'
|
|
*/
|
|
|
|
float noise_musgrave_ridged_multi_fractal(point p, string basis, float H,
|
|
float lacunarity, float octaves, float offset, float gain)
|
|
{
|
|
float result, signal, weight;
|
|
float pwHL = pow(lacunarity, -H);
|
|
float pwr = pwHL;
|
|
int i;
|
|
|
|
signal = offset - fabs(safe_noise(p, 0));
|
|
signal *= signal;
|
|
result = signal;
|
|
weight = 1.0;
|
|
|
|
for (i = 1; i < (int)octaves; i++) {
|
|
p *= lacunarity;
|
|
weight = clamp(signal * gain, 0.0, 1.0);
|
|
signal = offset - fabs(safe_noise(p, 0));
|
|
signal *= signal;
|
|
signal *= weight;
|
|
result += signal * pwr;
|
|
pwr *= pwHL;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Shader */
|
|
|
|
shader node_musgrave_texture(
|
|
int use_mapping = 0,
|
|
matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
|
|
string Type = "fBM",
|
|
float Dimension = 2.0,
|
|
float Lacunarity = 1.0,
|
|
float Detail = 2.0,
|
|
float Offset = 0.0,
|
|
float Gain = 1.0,
|
|
float Scale = 5.0,
|
|
point Vector = P,
|
|
output float Fac = 0.0,
|
|
output color Color = 0.0)
|
|
{
|
|
float dimension = max(Dimension, 1e-5);
|
|
float octaves = clamp(Detail, 0.0, 16.0);
|
|
float lacunarity = max(Lacunarity, 1e-5);
|
|
string Basis = "Perlin";
|
|
float intensity = 1.0;
|
|
|
|
point p = Vector;
|
|
|
|
if (use_mapping)
|
|
p = transform(mapping, p);
|
|
|
|
p = p * Scale;
|
|
|
|
if (Type == "Multifractal")
|
|
Fac = intensity * noise_musgrave_multi_fractal(p, Basis, dimension, lacunarity, octaves);
|
|
else if (Type == "fBM")
|
|
Fac = intensity * noise_musgrave_fBm(p, Basis, dimension, lacunarity, octaves);
|
|
else if (Type == "Hybrid Multifractal")
|
|
Fac = intensity * noise_musgrave_hybrid_multi_fractal(p, Basis, dimension, lacunarity, octaves, Offset, Gain);
|
|
else if (Type == "Ridged Multifractal")
|
|
Fac = intensity * noise_musgrave_ridged_multi_fractal(p, Basis, dimension, lacunarity, octaves, Offset, Gain);
|
|
else if (Type == "Hetero Terrain")
|
|
Fac = intensity * noise_musgrave_hetero_terrain(p, Basis, dimension, lacunarity, octaves, Offset);
|
|
|
|
Color = color(Fac, Fac, Fac);
|
|
}
|
|
|