Noise - TilingSimplex.osl

// TilingSimplex Shader
// TilingSimplex by Philippe Groarke
// Copyright 2022 Philippe Groarke, All rights reserved. This file is licensed under Apache 2.0 license
// https://github.com/ADN-DevTech/3dsMax-OSL-Shaders/blob/master/LICENSE.txt

#include "C:\Users\groarkp\code\3dsmax-plugins\OSL\FeaOSL\include\fea_constants.osl"
#include "C:\Users\groarkp\code\3dsmax-plugins\OSL\FeaOSL\include\fea_tsimplex.osl"
#include "C:\Users\groarkp\code\3dsmax-plugins\OSL\FeaOSL\include\fea_widget_phase.osl"
#include "C:\Users\groarkp\code\3dsmax-plugins\OSL\FeaOSL\include\fea_widget_uvw.osl"
#include "C:\Users\groarkp\code\3dsmax-plugins\OSL\FeaOSL\include\fea_shape.osl"
#include "C:\Users\groarkp\code\3dsmax-plugins\OSL\FeaOSL\include\fea_interpolate.osl"

// TODO : Debug why gradient is so far out-of-range of expected magnitude
// of 2 (for -1,1) and 1 (for 0,1).


shader TilingSimplex
[[
	string label = "Noise - Tiling Simplex",
	string help	=
		"<h3>Tiling Simplex</h3>"
		"A spacially and temporally tiling simplex noise.<br>"
		"Port of Stefan Gustavson's and Ian McEwan's GLSL implementation."
		,
]]
(
	int in_fbm_octaves = 3
	[[
		string label = "Octaves",
		string help = "How many octaves used for the fractal brownian motion (clouds).",
		int min = 1,
		int max = 20,
		int connectable = 0,
		// string packName = "Octaves / Lacunarity",
	]],

	float in_lacunarity = 1.8
	[[
		string label = "Lacunarity",
		string help = "The frequency growth factor used by the fractalization.",
		float min = 0.01,
		int connectable = 0,
		// string packName = "Octaves / Lacunarity",
	]],

	vector in_tiling = 0.0
	[[
		string label = "Tile Size",
		string help = "These are the x, y, z periods, used to tile the noise. [0, 0, 0] disables tiling (infinite noise).",
		float max = 289.0,
		int connectable = 0,
	]],

	FEA_SPACER(0),

	float in_low_clamp = 0.0
	[[
		string label = "Low Value",
		string help = "The minimum value of the noise. Hard clamped.",
		float min = 0.0,
		float max = 1.0,
		// string packName = "High / Low Clamp",
	]],

	float in_high_clamp = 1.0
	[[
		string label = "High Value",
		string help = "The maximum value of the noise. Hard clamped.",
		float min = 0.0,
		float max = 1.0,
		// string packName = "High / Low Clamp",
	]],

	color in_low_color = 0
	[[
		string label = "Low Color",
		string help = "The dark color (noise == 0).",
	]],

	color in_high_color = 1
	[[
		string label = "High Color",
		string help = "The light color (noise == 1).",
	]],

	FEA_WGT_PHASE_INPUTS,
	FEA_WGT_UVW_INPUTS,

	output color out_col = 0
	[[
		string label = "Out (color)"
	]],
	output float out_float = 0
	[[
		string label = "Out (float)"
	]],
	output color out_normal = 0
	[[
		string label = "Normal (color)"
	]],
	output vector out_gradient = 0
	[[
		string label = "Gradient (vector)"
	]],
	output vector out_second_deriv = 0
	[[
		string label = "2nd Derivative (vector)"
	]],
	output vector out_second_deriv2 = 0
	[[
		string label = "2nd Derivative 2 (vector)"
	]]
)
{
	fea_wgt_uvw_ret uvw_data = FEA_WGT_GET_UVW;
	point coord = uvw_data.coord;
	float phase = FEA_WGT_GET_PHASE;

	// fea_tsimplex_ret ret = fea_utsimplex_fbm(coord, in_fbm_octaves, in_lacunarity, in_tiling, phase);
	fea_tsimplex_ret ret = fea_utsimplex(coord, in_tiling, phase);
	ret.value = fea_lerp(ret.value, 0.0, 1.0, in_low_clamp, in_high_clamp);

	out_col = mix(in_low_color, in_high_color, ret.value);
	out_float = ret.value;
	out_gradient = ret.gradient;
	out_second_deriv = ret.dg;
	out_second_deriv2 = ret.dg2;

	vector m_tsimplex_normal(string input_space, vector scale, vector gradient) {
		vector zz = normalize(N); // Fix shader imprecision.
		vector xx = normalize(gradient);
		vector yy = cross(zz, xx);
		zz = cross(xx, yy);

		matrix m = matrix(
			xx[0], xx[1], xx[2], 0,
			yy[0], yy[1], yy[2], 0,
			zz[0], zz[1], zz[2], 0,
			0, 0, 0, 1
		);

		return transform(m, normal(0,0,1));

		// // vector up = fea_transform("world", "tangent", N);
		// vector up = N;

		// vector grad = gradient * scale;
		// grad = fea_transform(input_space, "world", grad);
		// vector surf_grad = grad - up * dot(grad, up);
		// return fea_transform("world", "tangent", normalize(up + surf_grad));
	}


	// Compute normal using surface gradient method.
	vector n = m_tsimplex_normal(uvw_data.coord_space, uvw_data.scale,
			ret.gradient);
	// Normalize to expected rgb color map [-1,1] -> [0,1].
	out_normal = n * 0.5 + 0.5;

#if 0
	float mag = length(ret.gradient * uvw_data.scale);
	if (mag >= 1.0) {
		out_col = FEA_GREEN;
	}
	if (mag >= 2.0) {
		out_col = FEA_BLUE;
	}
	if (mag >= 4.0) {
		out_col = FEA_RED;
	}
	if (mag >= 5.0) {
		out_col = color(0);
	}
	if (mag >= 6.9) {
		out_col = color(1);
	}
#endif

}