blender
/
blender
136
425
Fork 609
Code Issues 6.3k Pull Requests 783 Projects 19 Wiki Activity

Add Fractal Voronoi Noise V.2 #106827

Merged
Jacques Lucke merged 77 commits from Hoshinova/blender:add-fractal-voronoi into main 2023-06-13 09:18:18 +02:00
Conversation 77 Commits 77 Files Changed 20 +647 -247
4 changed files with 647 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 326fb1c28e - Show all commits

193
intern/cycles/kernel/osl/shaders/node_fractal_voronoi.h
View File

@ -1,6 +1,9 @@
/* SPDX-License-Identifier: Apache-2.0
* Copyright 2011-2022 Blender Foundation */
#pragma once
#define NODE_FRACTAL_VORONOI_H
#include "node_voronoi.h"
#include "stdcycles.h"
#include "vector2.h"
@ -8,9 +11,68 @@
#define vector3 point
/* **** 1D Fractal Voronoi **** */
/* **** 1D Fractal Voronoi **** */
/* **** 2D Fractal Voronoi **** */
void fractal_voronoi_f1(float w,
float detail,
float roughness,
float lacunarity,
float exponent,
float randomness,
string metric,
output float max_amplitude,
output float outDistance,
output color outColor,
output float outW)
{
voronoi_f1(w, exponent, randomness, metric, outDistance, outColor, outW);
max_amplitude = 1.0;
}
void fractal_voronoi_smooth_f1(float w,
float detail,
float roughness,
float lacunarity,
float smoothness,
float exponent,
float randomness,
string metric,
output float max_amplitude,
output float outDistance,
output color outColor,
output float outW)
{
voronoi_smooth_f1(w, smoothness, exponent, randomness, metric, outDistance, outColor, outW);
max_amplitude = 1.0;
}
void fractal_voronoi_f2(float w,
float detail,
float roughness,
float lacunarity,
float exponent,
float randomness,
string metric,
output float max_amplitude,
output float outDistance,
output color outColor,
output float outW)
{
voronoi_f2(w, exponent, randomness, metric, outDistance, outColor, outW);
max_amplitude = 1.0;
}
void fractal_voronoi_distance_to_edge(float w,
float detail,
float lacunarity,
float randomness,
float normalize,
output float outDistance)
{
voronoi_distance_to_edge(w, randomness, outDistance);
}
/* **** 2D Fractal Voronoi **** */
void fractal_voronoi_f1(vector2 coord,
float detail,
@ -29,7 +91,53 @@ void fractal_voronoi_f1(vector2 coord,
max_amplitude = max_distance;
}
/* **** 3D Fractal Voronoi **** */
void fractal_voronoi_smooth_f1(vector2 coord,
float detail,
float roughness,
float lacunarity,
float smoothness,
float exponent,
float randomness,
string metric,
float max_distance,
output float max_amplitude,
output float outDistance,
output color outColor,
output vector2 outPosition)
{
voronoi_smooth_f1(
coord, smoothness, exponent, randomness, metric, outDistance, outColor, outPosition);
max_amplitude = max_distance;
}
void fractal_voronoi_f2(vector2 coord,
float detail,
float roughness,
float lacunarity,
float exponent,
float randomness,
string metric,
float max_distance,
output float max_amplitude,
output float outDistance,
output color outColor,
output vector2 outPosition)
{
voronoi_f2(coord, exponent, randomness, metric, outDistance, outColor, outPosition);
max_amplitude = max_distance;
}
void fractal_voronoi_distance_to_edge(vector2 coord,
float detail,
float lacunarity,
float randomness,
float normalize,
output float outDistance)
{
voronoi_distance_to_edge(coord, randomness, outDistance);
}
/* **** 3D Fractal Voronoi **** */
void fractal_voronoi_f1(vector3 coord,
float detail,
@ -44,8 +152,36 @@ void fractal_voronoi_f1(vector3 coord,
output color outColor,
output vector3 outPosition)
{
float octave_scale = 1.0;
float octave_amplitude = 1.0;
float octave_distance = 0.0;
max_amplitude = 0.0;
outDistance = 0.0;
for (float i = 0; i <= ceil(detail); ++i) {
voronoi_f1(coord, exponent, randomness, metric, outDistance, outColor, outPosition);
if (detail == 0.0 || roughness == 0.0 || lacunarity == 0.0) {
max_amplitude = max_distance;
outDistance = octave_distance;
return;
}
else if (i <= detail) {
max_amplitude += max_distance * octave_amplitude;
outDistance += octave_distance * octave_amplitude;
outPosition /= octave_scale;
octave_scale *= lacunarity;
octave_amplitude *= roughness;
}
else {
float remainder = detail - floor(detail);
if (remainder != 0.0) {
max_amplitude += max_distance * octave_amplitude;
float lerp_distance = outDistance + octave_distance * octave_amplitude;
outDistance = (1.0 - remainder) * outDistance + remainder * lerp_distance;
outPosition /= octave_scale;
}
}
}
}
void fractal_voronoi_smooth_f1(vector3 coord,
@ -62,7 +198,8 @@ void fractal_voronoi_smooth_f1(vector3 coord,
output color outColor,
output vector3 outPosition)
{
voronoi_smooth_f1(coord, smoothness, exponent, randomness, metric, outDistance, outColor, outPosition);
voronoi_smooth_f1(
coord, smoothness, exponent, randomness, metric, outDistance, outColor, outPosition);
max_amplitude = max_distance;
}
@ -93,7 +230,7 @@ void fractal_voronoi_distance_to_edge(vector3 coord,
voronoi_distance_to_edge(coord, randomness, outDistance);
}
/* **** 4D Fractal Voronoi **** */
/* **** 4D Fractal Voronoi **** */
void fractal_voronoi_f1(vector4 coord,
float detail,
@ -111,3 +248,49 @@ void fractal_voronoi_f1(vector4 coord,
voronoi_f1(coord, exponent, randomness, metric, outDistance, outColor, outPosition);
max_amplitude = max_distance;
}
void fractal_voronoi_smooth_f1(vector4 coord,
float detail,
float roughness,
float lacunarity,
float smoothness,
float exponent,
float randomness,
string metric,
float max_distance,
output float max_amplitude,
output float outDistance,
output color outColor,
output vector4 outPosition)
{
voronoi_smooth_f1(
coord, smoothness, exponent, randomness, metric, outDistance, outColor, outPosition);
max_amplitude = max_distance;
}
void fractal_voronoi_f2(vector4 coord,
float detail,
float roughness,
float lacunarity,
float exponent,
float randomness,
string metric,
float max_distance,
output float max_amplitude,
output float outDistance,
output color outColor,
output vector4 outPosition)
{
voronoi_f2(coord, exponent, randomness, metric, outDistance, outColor, outPosition);
max_amplitude = max_distance;
}
void fractal_voronoi_distance_to_edge(vector4 coord,
float detail,
float lacunarity,
float randomness,
float normalize,
output float outDistance)
{
voronoi_distance_to_edge(coord, randomness, outDistance);
}

7
intern/cycles/kernel/osl/shaders/node_voronoi.h
View File

@ -1,6 +1,9 @@
/* SPDX-License-Identifier: Apache-2.0
* Copyright 2011-2022 Blender Foundation */
#pragma once
#define NODE_VORONOI_H
#include "node_hash.h"
#include "stdcycles.h"
#include "vector2.h"
@ -8,7 +11,7 @@
#define vector3 point
/* **** Distance Functions **** */
/* **** Distance Functions **** */
float distance(float a, float b)
{
@ -56,7 +59,7 @@ vector4 safe_divide(vector4 a, float b)
* as explained in https://www.shadertoy.com/view/llG3zy.
*/
/* **** 1D Voronoi **** */
/* **** 1D Voronoi **** */
float voronoi_distance(float a, float b, string metric, float exponent)
{

201
intern/cycles/kernel/osl/shaders/node_voronoi_texture.osl
View File

@ -1,6 +1,7 @@
/* SPDX-License-Identifier: Apache-2.0
* Copyright 2011-2022 Blender Foundation */
#include "node_voronoi.h"
#include "node_fractal_voronoi.h"
#include "stdcycles.h"
#include "vector2.h"
@ -44,12 +45,72 @@ shader node_voronoi_texture(
if (dimensions == "1D") {
if (feature == "f1") {
float max_amplitude = 1.0;
fractal_voronoi_f1(WIn,
detail,
roughness,
Lacunarity,
Exponent,
randomness,
metric,
max_amplitude,
Distance,
Color,
WOut);
if (normalize != 0.0) {
/* Optimized lerp(max_amplitude*0.5, max_amplitude, randomness) */
Distance /= (0.5 + 0.5 * randomness) * max_amplitude;
}
}
else if (feature == "smooth_f1") {
float max_amplitude = 1.0;
fractal_voronoi_smooth_f1(WIn,
detail,
roughness,
Lacunarity,
smoothness,
Exponent,
randomness,
metric,
max_amplitude,
Distance,
Color,
WOut);
if (normalize != 0.0) {
/* Optimized lerp(max_amplitude*0.5, max_amplitude, randomness) */
Distance /= (0.5 + 0.5 * randomness) * max_amplitude;
}
}
else if (feature == "f2") {
float max_amplitude = 1.0;
fractal_voronoi_f2(WIn,
detail,
roughness,
Lacunarity,
Exponent,
randomness,
metric,
max_amplitude,
Distance,
Color,
WOut);
if (normalize != 0.0) {
if (detail == 0.0 || roughness == 0.0 || Lacunarity == 0.0) {
Distance /= (1.0 - randomness) + randomness * max_amplitude;
}
else {
Distance /= (1.0 - randomness) * ceil(detail + 1.0) + randomness * max_amplitude;
}
}
}
else if (feature == "distance_to_edge") {
fractal_voronoi_distance_to_edge(WIn, detail, Lacunarity, randomness, normalize, Distance);
}
else if (feature == "n_sphere_radius") {
voronoi_n_sphere_radius(w, randomness, Radius);
@ -63,12 +124,81 @@ shader node_voronoi_texture(
vector2 coord2D = vector2(coord[0], coord[1]);
vector2 outPosition2D;
if (feature == "f1") {
float max_distance = voronoi_distance(
vector2(1.0, 1.0), vector2(0.0, 0.0), metric, Exponent);
float max_amplitude = max_distance;
fractal_voronoi_f1(coord2D,
detail,
roughness,
Lacunarity,
Exponent,
randomness,
metric,
max_distance,
max_amplitude,
Distance,
Color,
outPosition2D);
if (normalize != 0.0) {
/* Optimized lerp(max_amplitude*0.5, max_amplitude, randomness) */
Distance /= (0.5 + 0.5 * randomness) * max_amplitude;
}
}
else if (feature == "smooth_f1") {
float max_distance = voronoi_distance(
vector2(1.0, 1.0), vector2(0.0, 0.0), metric, Exponent);
float max_amplitude = max_distance;
fractal_voronoi_smooth_f1(coord2D,
detail,
roughness,
Lacunarity,
smoothness,
Exponent,
randomness,
metric,
max_distance,
max_amplitude,
Distance,
Color,
outPosition2D);
if (normalize != 0.0) {
/* Optimized lerp(max_amplitude*0.5, max_amplitude, randomness) */
Distance /= (0.5 + 0.5 * randomness) * max_amplitude;
}
}
else if (feature == "f2") {
float max_distance = voronoi_distance(
vector2(1.0, 1.0), vector2(0.0, 0.0), metric, Exponent);
float max_amplitude = max_distance;
fractal_voronoi_f2(coord2D,
detail,
roughness,
Lacunarity,
Exponent,
randomness,
metric,
max_distance,
max_amplitude,
Distance,
Color,
outPosition2D);
if (normalize != 0.0) {
if (detail == 0.0 || roughness == 0.0 || Lacunarity == 0.0) {
Distance /= (1.0 - randomness) + randomness * max_amplitude;
}
else {
Distance /= (1.0 - randomness) * ceil(detail + 1.0) + randomness * max_amplitude;
}
}
}
else if (feature == "distance_to_edge") {
fractal_voronoi_distance_to_edge(coord2D, detail, Lacunarity, randomness, normalize, Distance);
}
else if (feature == "n_sphere_radius") {
voronoi_n_sphere_radius(coord2D, randomness, Radius);
@ -155,7 +285,7 @@ shader node_voronoi_texture(
}
}
else if (feature == "distance_to_edge") {
fractal_voronoi_distance_to_edge(coord, detail, Lacunarity,randomness,normalize,Distance);
fractal_voronoi_distance_to_edge(coord, detail, Lacunarity, randomness, normalize, Distance);
}
else if (feature == "n_sphere_radius") {
voronoi_n_sphere_radius(coord, randomness, Radius);
@ -169,12 +299,81 @@ shader node_voronoi_texture(
vector4 coord4D = vector4(coord[0], coord[1], coord[2], w);
vector4 outPosition4D;
if (feature == "f1") {
float max_distance = voronoi_distance(
vector4(1.0, 1.0, 1.0, 1.0), vector4(0.0, 0.0, 0.0, 0.0), metric, Exponent);
float max_amplitude = max_distance;
fractal_voronoi_f1(coord4D,
detail,
roughness,
Lacunarity,
Exponent,
randomness,
metric,
max_distance,
max_amplitude,
Distance,
Color,
outPosition4D);
if (normalize != 0.0) {
/* Optimized lerp(max_amplitude*0.5, max_amplitude, randomness) */
Distance /= (0.5 + 0.5 * randomness) * max_amplitude;
}
}
else if (feature == "smooth_f1") {
float max_distance = voronoi_distance(
vector4(1.0, 1.0, 1.0, 1.0), vector4(0.0, 0.0, 0.0, 0.0), metric, Exponent);
float max_amplitude = max_distance;
fractal_voronoi_smooth_f1(coord4D,
detail,
roughness,
Lacunarity,
smoothness,
Exponent,
randomness,
metric,
max_distance,
max_amplitude,
Distance,
Color,
outPosition4D);
if (normalize != 0.0) {
/* Optimized lerp(max_amplitude*0.5, max_amplitude, randomness) */
Distance /= (0.5 + 0.5 * randomness) * max_amplitude;
}
}
else if (feature == "f2") {
float max_distance = voronoi_distance(
vector4(1.0, 1.0, 1.0, 1.0), vector4(0.0, 0.0, 0.0, 0.0), metric, Exponent);
float max_amplitude = max_distance;
fractal_voronoi_f2(coord4D,
detail,
roughness,
Lacunarity,
Exponent,
randomness,
metric,
max_distance,
max_amplitude,
Distance,
Color,
outPosition4D);
if (normalize != 0.0) {
if (detail == 0.0 || roughness == 0.0 || Lacunarity == 0.0) {
Distance /= (1.0 - randomness) + randomness * max_amplitude;
}
else {
Distance /= (1.0 - randomness) * ceil(detail + 1.0) + randomness * max_amplitude;
}
}
}
else if (feature == "distance_to_edge") {
fractal_voronoi_distance_to_edge(coord4D, detail, Lacunarity, randomness, normalize, Distance);
}
else if (feature == "n_sphere_radius") {
voronoi_n_sphere_radius(coord4D, randomness, Radius);

15
intern/cycles/kernel/svm/voronoi.h
View File

@ -2,7 +2,22 @@
* Copyright 2011-2022 Blender Foundation */
#pragma once
#include "device/device.h"
#include "scene/background.h"
#include "scene/light.h"
#include "scene/mesh.h"
#include "scene/scene.h"
#include "scene/shader.h"
#include "scene/shader_graph.h"
#include "scene/shader_nodes.h"
#include "scene/stats.h"
#include "scene/svm.h"
#include "util/foreach.h"
#include "util/log.h"
#include "util/progress.h"
#include "util/task.h"
CCL_NAMESPACE_BEGIN
/*