1

Description

"> [!NOTE]\r\n> Big thanks to [Pomax's page](https:\/\/pomax.github.io\/bezierinfo\/) about B\u00e9zier curves for the normal twisting correction algorithm.\r\n\r\nGiven a mesh which vertices are comprised in an interval on the Y-Axis, we will use a cubic B\u00e9zier curve to deform it.\r\n\r\nA [cubic B\u00e9zier curve](https:\/\/en.wikipedia.org\/wiki\/B%C3%A9zier_curve) is a parametric curve defined by four control points, meaning that, given a parameter `t` in \u211d, a point belonging to the curve can be computed using the four control points.\r\n\r\nThe present vertex shader uses the Y component of the mesh vertices coordinates to determine this parameter `t` and compute the corresponding position in the cubic B\u00e9zier curve specified by the shader inputs (which includes those infamous four control points). The tangent, normal and binormal to the curve at the computed position are also determined to project the original vertex and associated normals into the new referential.\r\n\r\n\r\n\r\n## How to use\r\n\r\nThe shader code presented here is a set of function that can be included in any vertex shader willing to perform such transformation. It should be save in a shader include (`bezier_transform.gdshaderinc` for example) and then included in your shader using:\r\n\r\n`#include \"path\/to\/bezier_transform.gdshaderinc`.\r\n\r\nThere's two version of the functions available by defining (or not) the preprocessing variable `USE_CURVE_ROTATION`. To activate this feature, you shall define this variable before including the previous file.\r\n\r\n```\r\n#define USE_CURVE_ROTATION\r\n#include \"path\/to\/bezier_transform.gdshaderinc\"\r\n```\r\n\r\nThe _curve rotation_ feature consists in using the curve orientation to rotate the mesh. If not set, the mesh won't rotate as the curve makes inflexion and will remain oriented as the original mesh.\r\n\r\nA minimal shader using this function could be the following:\r\n\r\n```glsl\r\nshader_type spatial\r\n\r\n#include \"bezier_transform.gdshaderinc\"\r\n\r\ngroup_uniforms curve;\r\n\r\nuniform vec3 p0 = vec3(0.);\r\nuniform vec3 p1 = vec3(0., 0.333333, 0.);\r\nuniform vec3 p2 = vec3(0., 0.66666, 0.);\r\nuniform vec3 p3 = vec3(0., 1., 0.);\r\n\r\ngroup_uniforms geometry_hint;\r\n\r\nuniform float y_min = 0.;\r\nuniform float y_max = 1.;\r\n\r\nvoid vertex() {\r\n\ttransform(VERTEX, NORMAL, p0, p1, p2, p3, y_min, y_max);\r\n}\r\n```\r\n\r\nThe API for the function `transform` is detailed [later in this article](#function_api).\r\n\r\n> [!NOTE]\r\n> The uniforms here match the input of the `transform` function. You can see that the default values consider that the mesh is comprised between the Y coordinates 0 and 1. The control points are set so that the mesh will not be deformed. This configuration is called _degenerate curve_. It is obtained by placing the control points at the beginning, the third, the two third and the end of the segment along the Y axis, between the minimum and maximum value of Y.\r\n\r\n### Mesh with curve rotation activated\r\n\r\n\r\n\r\n### Mesh without curve rotation activated\r\n\r\nThe mesh remains in its original orientation.\r\n\r\n\r\n\r\n{#function_api}\r\n## API\r\n\r\nThe function `bezier_interpolate` is a utility function that perform an interpolation on the cubic B\u00e9zier curve and won't be detailed here as it is not meant to be called directly.\r\n\r\nThe function of interest is `transform`, which takes the following parameters:\r\n\r\n* **vertex** in\/out parameter providing the vertex to project on the B\u00e9zier curve vincinity.\r\n* **normal** in\/out parameter providing the normal to transform into the new referential.\r\n* **a0, a1, a2, a3** The four control points defining the curve.\r\n* **mn** The Y coordinate that will be considered as `t = 0`.\r\n* **mx** The Y coordinate that will be considered as `t = 1`.\r\n\r\nIf your mesh is comprised between Y coordinate `a` and `b` , the `mn` and `mx` should be filled accordingly.\r\n\r\n> [!TIP]\r\n> But ! It's not mandatory. You can flip the boundaries to obtain a flipped version of the mesh and even set the boundaries larger or smaller to achieve various effects.\r\n\r\n> [!CAUTION]\r\n> The control points coordinates are relative to the mesh referential. They don't take `Node3D` transforms into account.\r\n\r\n> [!NOTE]\r\n> The example illustration depicts a simple mesh, but this deformation can be applied to any kind of (more or less) complex meshes. Take into consideration that extreme deformations might produce unfortunate results including crushing\/inverting faces and other funny artifacts."

Shader code

void bezier_interpolate(
	float t,
	vec3 a0, vec3 a1, vec3 a2, vec3 a3,
	out vec3 point,
#ifdef USE_CURVE_ROTATION
	out vec3 acceleration,
#endif
	out vec3 tangent
	) {
	float t2 = t * t;
	float m_t = 1. - t;
	float m_t2 = m_t * m_t;
	vec4 kt = vec4(m_t2 * m_t, 3. * t * m_t2, 3. * t2 * m_t, t2 * t);
	vec3 dt = vec3(3. * m_t2, 6. * t * m_t, 3. * t2);
#ifdef USE_CURVE_ROTATION
	vec4 ddt = vec4(6. * m_t, 18. * t - 12., 6. - 18. * t, 6. * t);
	acceleration = ddt.x * a0 + ddt.y * a1 + ddt.z * a2 + ddt.w * a3;
#endif
	point = kt.x * a0 + kt.y * a1 + kt.z * a2 + kt.w * a3;
	tangent = dt.x * (a1 - a0) + dt.y * (a2 - a1) + dt.z * (a3 - a2);
}

void transform(inout vec3 vertex, inout vec3 normal,
	vec3 a0, vec3 a1, vec3 a2, vec3 a3,
	float mn, float mx) {

	vec3 offset = vec3(0., mn, 0.);
	float t = (vertex.y - mn) / (mx - mn);

	vec3 point,
#ifdef USE_CURVE_ROTATION
	acceleration,
#endif
	tangent;

	bezier_interpolate(
#ifdef USE_CURVE_ROTATION
		0.,
#else
		t,
#endif
		a0, a1, a2, a3, point,
#ifdef USE_CURVE_ROTATION
	acceleration,
#endif
	tangent);

	vec3 a = normalize(tangent);
#ifdef USE_CURVE_ROTATION
	vec3 b = normalize(a + acceleration);
	vec3 r = normalize(cross(b, a));
	if (length(r) < 0.00001) {
		r = vec3(0., 0., 1.);
	}
#else
	vec3 r = vec3(0., 0., 1.);
#endif

	vec3 n = normalize(cross(a, r));
#ifndef USE_CURVE_ROTATION
	r = normalize(cross(n, a));
#else
	if(t > 0.) {
		vec3 n_p, n_t, n_a;
		bezier_interpolate(t, a0, a1, a2, a3, n_p, n_a, n_t);
		vec3 v1 = n_p - a0;
		float c1 = dot(v1, v1);
		float inv_c1 = 2. / c1;
		vec3 cv1 = v1 * inv_c1;
		vec3 riL = r - cv1 * dot(v1, r);
		vec3 tiL = tangent - cv1 * dot(v1, tangent);
		vec3 v2 = n_t - tiL;
		float c2 = dot(v2, v2);
		r = normalize(riL - v2 * (2. / c2) * dot(v2, riL));
		n = normalize(cross(n_t, r));
		a = normalize(n_t);
		point = n_p;
	}
#endif

	vertex = point + n * vertex.x + r * vertex.z;
	normal = a * normal.y + n * normal.x + r * normal.z;
}

Comments