Procedural triangle fan

Question

Result so far:

Breakdown:

Single line:

Two Gradient textures with Constant ColorRamps added by Math node, one is rotated by 180 degrees. I can control line width by changing position of second color input in ColorRamps (they must be the same value in both).

This is wrapped in a Node Group called "Line".

Triangle Fan:

Four copies of above Node Group, each of them with different Z axis rotation (0, 90, 45, -45).

Question:

It seems to be complete solution but first of all it's kind a over complicated for my taste. It's working only with Texture Coordinates > Object and controlling width and line smoothness isn't to easy.

As much as I want to ask only one question they are too dependable of each other and answering one will eliminate the need for others.

1. How to make line width control easier? (I've tried with Wave but lines are crossing after scaling.) - Partially solved thanks to @kilbee.

2. How to control line smoothness?

Blend file:

Edit 1:

Thanks to @kilbee I have managed to pack node setup and control width but I have lost ability to smooth lines. I was wrong saying that one question will solve the other one:)

Blend file with @killbee setup:

I have also edited question a little bit to be more specific.

Edit 2:

@kilbee has done it. Amazing. Here is his version packed in Node Groups with little modifications (just Multiply nodes as Values):

Answer 1

I don't know if you'd find it easier, but I often use split vector values for this and (greater/less than) math node:

As you can see, this way you can easily control position on the object. Creating a line from this is simply a matter of offsetting the value in both directions and adding the results:

You can easily make it more compact, but I'll leave it as simple as possible to experiment with.

EDIT: Well ok then, I'd use gradient texture indeed and then just apply different formulas for color interpolation or/and scale the texture coordinates. If you think about Gradient texture (Linear), it's actually a simple interpolation between black and white (0 to 1). Using right mathematical formula should give you any interpolation you want. So I'd approach this first by scaling the mapping vector from Object output (multiplying by value higher than 1 would squash the values inside, while using values between 0 and 1 would extend the interpolation beyond the object). So, if you think about that, you could say that with default values you have a soft line of the width of your object:

The 'greater than' node explains it enough, I hope:

So to control the interpolation - the first thing that comes to my mind would be use power math node:

Then simply scale the mapping vector:

Simply multiplying vector values inside that group:

If you'd like to shift the lines, you just add a value to each axis, just like I did multiplying there. If you experiment with different math formulas and Gradient texture interpolations (Quadratic, Ease) i think you will find the best way to control the line smoothness this way:

EDIT2: To debug transition you can literally draw it like a function: use Displacement Input for your Material Output (in this example I used simple box scaled in Z to 0.01, with adaptive subdivision). This is how values for Quadratic interpolation look like originally:

...and powered by 2:

Answer 2

A solution which can be animated:

The principle:

• From generated coordinates we have co between 0 and 1
• Shift and scale it to have each co between -1 and 1
• Calculate the angle in 0-2xPI of this co (around z)
• Calculate the slice size angle (2xPI / slice amount)
• Calculate the rounded angle of the co (corresponds to the slice position)
• Rotate the coordinate with this rounded angle
• The Y value of this rotated co is the distance to the slice

That allows to introduce some variations.

For instance:

Or:

Falloff/gradient:

The main node is the following:

Inputs:

• Vector coordinates (typically generated)
• Amount of slices
• A size notion (resulting size will be a mix between this input and the amount of slices)

Outputs:

• Value the distance from the slice tuned by amount of slices and size
• XCorrected and YCorrected: rotated coordinates of the co along X axis
• XNormalized and YNormalized: normalized vector around a sphere corresponding to the co
• XCentered, YCentered: centered coordinates (between -1 and 1)
• Angle: the angle of the co (between 0 and 2xPI)
• RoundedAngle: the rounded value corresponding to the slice

Answer 3

As an alternative to @kilbee's excellent answer, you could manipulate the Object coordinates directly (rather than using Gradient Textures) :

Here the Absolute mirrors around the centre, the Multiply value can be used to adjust the scaling (line width) and the Power node adjusted to affect the 'hardness' of the line (eg, 50 would be a very hard edge, lower values would be softer). Note that the Power node has 'Clamp' set to ensure the resulting value is clipped to between 0.0 and 1.0.

Combined, value nodes can be used to drive each of the variables (scale and hardness) and the result multiplied together.

For ease of manipulation of the transition you could replace the Power node with a Color Ramp :

Again, use the Multiply node to scale the overall effect. Adjust the Color Ramp to affect the transition, adding/moving color points or changing the Interpolation (Constant, Linear, Ease, B-Spline, etc.) as desired.

A further method is to use an RGB Curves node by adjusting the 'Combined' channel (the 'C' rather than 'R', 'G' or 'B'). This provides full visual control of the profile of the transition.