instantiateによるボール連結にメッシュの割り当て

Question

前提・実現したいこと

　以前こちらのサイトでご教示いただいた『instantiateを使ったボールの連結』
ですが、たびたび恐縮ですが、これに円筒状のメッシュをバインド（変形）させて、ロープ状にする方法をご教示いただけないでしょうか。

試したこと

　別の質問でご教示いただいた
円筒状メッシュに曲げ形状を追従させたい
のスクリプトを参考にしながらロープ生成を試みたのですが、ボーンバインドする際、オブジェクトが4つ以上（？）ないと生成できないのかなと思い、行き詰ってしまいました。
今回、一つずつのボール発生になるため、こういった場合、どのように円筒状のメッシュをバインドさせればいいか、ご教示いただけると幸いです。

どなたかご存じの方、いらっしゃいましたら、よろしくお願いいたします。

###追記（2021年8月17日）
Shaderに以下のエラー表示が出ました。

cgincファイルですが、パート2でご教示いただいたコードをメモ帳にコピペして、拡張子をcgincファイルにして
RopeShaderと同じフォルダに入れています。

現在、実行すると、マジェンタ色の線がボールと結びついている状態です。

Answer 1

##スクリプト側で円筒メッシュを構築する案

こちらの場合はスクリプト上で円筒の形にしてしまいますので、ロープのマテリアルには一般的な3Dモデル用マテリアルを使うことができるかと思います。

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Rendering;

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class MeshGenerator2 : MonoBehaviour
{
	private const int InitialNumberedBallCapacity = 16;

	[SerializeField] private ChainGenerator2 generator;
	[SerializeField][Min(0.0f)] private float radius = 0.5f;
	[SerializeField][Range(3, 12)] private int divisions = 8;
	[SerializeField][Min(1.0f)] private float segmentLength = 2.0f;
	[SerializeField][Min(0.0f)] private float verticalTextureLength = 8.0f;

	// メッシュの頂点の構造を定義
	// 今度はわりと一般的な構造になっている
	private readonly VertexAttributeDescriptor[] vertexLayout =
	{
		new VertexAttributeDescriptor(VertexAttribute.Position),
		new VertexAttributeDescriptor(VertexAttribute.Normal),
		new VertexAttributeDescriptor(VertexAttribute.Tangent, VertexAttributeFormat.Float32, 4),
		new VertexAttributeDescriptor(VertexAttribute.TexCoord0, VertexAttributeFormat.Float32, 2)
	};

	[StructLayout(LayoutKind.Sequential)]
	private struct Vertex
	{
		public float3 position;
		public float3 normal;
		public float4 tangent;
		public float2 uv;
	}

	[StructLayout(LayoutKind.Sequential)]
	private struct ControlPoint
	{
		public float3 position;
		public float3 forward;
		public float3 right;
		public float distance;
	}
	
	private Mesh mesh;
	private NativeArray<Vertex> vertices;
	private NativeArray<ControlPoint> controlPoints;
	private NativeArray<float3> segmentNormalPrimitive;
	private readonly List<int> indices = new List<int>();
	private int[] segmentIndexPrimitive;
	private JobHandle vertexConstructionJob;
	private int vertexCountPerBall;
	private int tessellation;

	private IEnumerator Start()
	{
		// コントロールポイント1つ当たりの頂点数
		// 円筒の断面が8分割なら、45°ずつ9頂点を配置することになる
		this.vertexCountPerBall = this.divisions + 1;

		// 断面、および円筒側面の原型を構築しておく
		this.segmentNormalPrimitive = new NativeArray<float3>(
			Enumerable.Range(0, this.vertexCountPerBall).Select(
				i =>
				{
					math.sincos((2.0f * math.PI * i) / this.divisions, out var sine, out var cosine);
					return new float3(cosine, sine, 0.0f);
				}).ToArray(),
			Allocator.Persistent);
		var facePrimitive = new[] { 0, 1, -this.vertexCountPerBall, 1 - this.vertexCountPerBall, -this.vertexCountPerBall, 1 };
		this.segmentIndexPrimitive = Enumerable.Range(0, this.divisions).SelectMany(i => facePrimitive.Select(j => i + j)).ToArray();

		// 根元ボールが取得できるようになるまで待機する
		yield return new WaitUntil(() => this.generator && this.generator.RootBall);

		// 節の分割数を決める
		this.tessellation = Mathf.CeilToInt(this.generator.interval / this.segmentLength);

		// 計算を単純化するため、MeshGeneratorはワールド原点に配置する
		this.transform.SetParent(null);
		this.transform.localScale = Vector3.one;
		this.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);

		// メッシュを作成し、初期サイズに拡張する
		this.mesh = new Mesh { name = "Rope" };
		this.mesh.MarkDynamic();
		this.vertices = new NativeArray<Vertex>(this.vertexCountPerBall, Allocator.Persistent);
		this.ExtendMesh(InitialNumberedBallCapacity);
		this.GetComponent<MeshFilter>().mesh = this.mesh;

		// 毎フレームメッシュを更新する
		while (true)
		{
			yield return null;

			this.UpdateMesh();
		}
	}

	private void OnDestroy()
	{
		this.segmentNormalPrimitive.Dispose(this.vertexConstructionJob);
		this.vertices.Dispose(this.vertexConstructionJob);
		if (this.controlPoints.IsCreated)
		{
			this.controlPoints.Dispose(this.vertexConstructionJob);
		}
		Destroy(this.mesh);
	}

	private void ExtendMesh(int size)
	{
		var indexOrigin = this.vertices.Length;
		var oldVertices = this.vertices;
		this.vertices = new NativeArray<Vertex>(indexOrigin + (size * this.vertexCountPerBall), Allocator.Persistent);
		var oldSlice = new NativeSlice<Vertex>(oldVertices);
		var newSlice = new NativeSlice<Vertex>(this.vertices, 0, oldVertices.Length);
		newSlice.CopyFrom(oldSlice);
		var lastVertex = oldVertices[oldVertices.Length - 1];
		for (var i = oldVertices.Length; i < this.vertices.Length; i++)
		{
			this.vertices[i] = lastVertex;
		}
		oldVertices.Dispose(this.vertexConstructionJob);
		for (var i = 0; i < size; i++)
		{
			this.indices.AddRange(this.segmentIndexPrimitive.Select(j => indexOrigin + (i * this.vertexCountPerBall) + j));
		}
		this.mesh.SetVertexBufferParams(this.vertices.Length, this.vertexLayout);
		this.mesh.SetVertexBufferData(this.vertices, 0, 0, this.vertices.Length);
		this.mesh.SetIndices(this.indices, MeshTopology.Triangles, 0, false);
	}

	private void UpdateMesh()
	{
		// まず、前フレームに開始したメッシュ構築処理が完了するのを
		// 待ってから、メッシュに頂点データをセットする
		// 処理効率化のためにこのようにしたが、現フレームの描画は
		// 前フレームのボール位置に基づいているため、1フレームだけ
		// 描画が遅れてしまう欠点がある
		this.vertexConstructionJob.Complete();
		this.mesh.SetVertexBufferData(this.vertices, 0, 0, this.vertices.Length);
		this.mesh.RecalculateBounds();

		// 引き続き、次フレームのためのメッシュ構築を始める
		// まず現在のボールの数に合わせてメッシュを拡張する
		var currentNodeCapacity = this.vertices.Length / this.vertexCountPerBall;
		var currentBallCount = this.generator.BallCount;
		var currentNodeCount = ((currentBallCount - 1) * this.tessellation) + 1;
		if (currentNodeCount > currentNodeCapacity)
		{
			this.ExtendMesh(currentNodeCapacity - 1);
		}

		// 現在の各ボールの位置と姿勢を取得し...
		if (this.controlPoints.IsCreated)
		{
			this.controlPoints.Dispose();
		}
		this.controlPoints = new NativeArray<ControlPoint>(currentNodeCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
		var i = 0;
		foreach (var (position, forward, right, distance) in this.generator.BallPositions)
		{
			this.controlPoints[i] = new ControlPoint
			{
				position = position,
				forward = forward,
				right = right,
				distance = distance
			};
			i += this.tessellation;
		}

		// 軸に沿った折れ線の分割と...
		var tessellationJob = new TessellationJob
		{
			Tessellation = this.tessellation,
			Nodes = this.controlPoints
		}.Schedule(currentBallCount - 1, 0);

		// 円筒断面の配置を予約し...
		this.vertexConstructionJob = new FacingJob
		{
			Divisions = this.divisions,
			Radius = this.radius,
			TextureLength = this.verticalTextureLength,
			NormalPrimitive = this.segmentNormalPrimitive,
			ControlPoints = this.controlPoints,
			Vertices = this.vertices
		}.Schedule(this.vertices.Length / this.vertexCountPerBall, 0, tessellationJob);
		
		// 予約したジョブを始動する
		// このまま裏方でメッシュデータ作りを続けてもらい、
		// 次フレームの頭で結果を受け取ることになる
		JobHandle.ScheduleBatchedJobs();
	}

	// 折れ線分割処理
	private struct TessellationJob : IJobParallelFor
	{
		public int Tessellation;
		[NativeDisableParallelForRestriction] public NativeArray<ControlPoint> Nodes;

		public void Execute(int index)
		{
			var index0 = index * this.Tessellation;
			var index1 = index0 + this.Tessellation;
			var node0 = this.Nodes[index0];
			var node1 = this.Nodes[index1];
			var p0 = node0.position;
			var p1 = node1.position;
			var f0 = node0.forward;
			var f1 = node1.forward;
			var l = math.distance(p0, p1) / 3.0f;
			var cp0 = p0 - (f0 * l);
			var cp1 = p1 + (f1 * l);
			for (var i = 1; i < this.Tessellation; i++)
			{
				var t = new float2((float)i / this.Tessellation, 0.0f);
				t.y = 1.0f - t.x;
				var t2 = t * t;
				this.Nodes[index0 + i] = new ControlPoint
				{
					position = (t.y * t2.y * p0) + (3.0f * t.x * t2.y * cp0) + (3.0f * t.y * t2.x * cp1) + (t.x * t2.x * p1),
					forward = math.normalize(math.lerp(node0.forward, node1.forward, t.x)),
					right = math.normalize(math.lerp(node0.right, node1.right, t.x)),
					distance = math.lerp(node0.distance, node1.distance, t.x)
				};
			}
		}
	}

	// 円筒断面配置処理
	private struct FacingJob : IJobParallelFor
	{
		public int Divisions;
		public float Radius;
		public float TextureLength;
		[ReadOnly] public NativeArray<float3> NormalPrimitive;
		[ReadOnly] public NativeArray<ControlPoint> ControlPoints;
		[NativeDisableParallelForRestriction][WriteOnly] public NativeArray<Vertex> Vertices;

		public void Execute(int index)
		{
			var o = index * (this.Divisions + 1);
			var controlPoint = this.ControlPoints[math.min(index, this.ControlPoints.Length - 1)];
			var center = controlPoint.position;
			var rotation = new float3x3(controlPoint.right, math.cross(controlPoint.forward, controlPoint.right), controlPoint.forward);
			var v = controlPoint.distance / this.TextureLength;
			for (var i = 0; i <= this.Divisions; i++)
			{
				var localNormal = this.NormalPrimitive[i];
				var localTangent = new float3(-localNormal.y, localNormal.x, 0.0f);
				var worldNormal = math.mul(rotation, localNormal);
				var worldTangent = new float4(math.mul(rotation, localTangent), -1.0f);
				this.Vertices[o + i] = new Vertex
				{
					position = (worldNormal * this.Radius) + center,
					normal = worldNormal,
					tangent = worldTangent,
					uv = new float2((float)i / this.Divisions, v)
				};
			}
		}
	}
}

Answer 2

パート3

本体の「Rope.shader」で構成されています。

Shader "Custom/Rope"
{
	Properties
	{
		_Color ("Color", Color) = (1.0, 1.0, 1.0, 1.0)
		_MainTex ("Albedo", 2D) = "white" {}
		[Space(16)]
		_Glossiness ("Smoothness", Range(0.0, 1.0)) = 0.5
		[Gamma] _Metallic ("Metallic", Range(0.0, 1.0)) = 0.0
		[Space(16)]
		[Toggle(_METALLICGLOSSMAP)] _UseMetallicGlossMap ("Use Metallic / Smoothness Map", Float) = 0.0
		_GlossMapScale ("Smoothness Map Scale", Range(0.0, 1.0)) = 1.0
		[NoScaleOffset] _MetallicGlossMap ("Metallic / Smoothness Map", 2D) = "white" {}
		[Space(16)]
		[ToggleOff] _SpecularHighlights ("Specular Highlights", Float) = 1.0
		[ToggleOff] _GlossyReflections ("Glossy Reflections", Float) = 1.0
		[Space(16)]
		_BumpScale ("Normal Scale", Float) = 1.0
		[NoScaleOffset][Normal] _BumpMap ("Normal Map", 2D) = "bump" {}
		[Space(16)]
		_OcclusionStrength ("Occlusion Strength", Range(0.0, 1.0)) = 1.0
		[NoScaleOffset] _OcclusionMap ("Occlusion Map", 2D) = "white" {}
		[Space(16)]
		[Toggle(_EMISSION)] _UseEmission ("Use Emission", Float) = 0.0 
		_EmissionColor ("Color", Color) = (0.0, 0.0, 0.0)
		[NoScaleOffset] _EmissionMap ("Emission", 2D) = "white" {}
	}

	CGINCLUDE
	#define UNITY_SETUP_BRDF_INPUT MetallicSetup
	ENDCG

	SubShader
	{
		Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
		Pass
		{
			Name "FORWARD"
			Tags { "LightMode" = "ForwardBase" }
			Blend One Zero
			ZWrite On
			CGPROGRAM
			#define _NORMALMAP 1
			#pragma shader_feature_fragment _EMISSION
			#pragma shader_feature_local _METALLICGLOSSMAP
			#pragma shader_feature_local_fragment _SPECULARHIGHLIGHTS_OFF
			#pragma shader_feature_local_fragment _GLOSSYREFLECTIONS_OFF
			#pragma multi_compile_fwdbase
			#pragma multi_compile_fog
			#pragma skip_variants DYNAMICLIGHTMAP_ON
			#pragma skip_variants DIRLIGHTMAP_COMBINED
			#pragma require tessellation tessHW
			#pragma require geometry
			#pragma vertex vert
			#pragma hull hull
			#pragma domain domain
			#pragma geometry geom
			#pragma fragment fragBase
			#include "UnityStandardCoreForward.cginc"
			#include "Rope.cginc"
			[maxvertexcount((MAX_DIVISIONS + 1) * 2)]
			void geom(line controlPoint ic[2], inout
			#if UNITY_STANDARD_SIMPLE
			TriangleStream<VertexOutputBaseSimple>
			#else
			TriangleStream<VertexOutputForwardBase>
			#endif
			stream)
			{
				VertexInput v0, v1;
				for (int i = 0; i <= _Divisions; i++)
				{
					composeVertexInput(i, ic, v0, v1);
					stream.Append(vertBase(v0));
					stream.Append(vertBase(v1));
				}
			}
			ENDCG
		}
		Pass
		{
			Name "FORWARD_DELTA"
			Tags { "LightMode" = "ForwardAdd" }
			Blend One One
			Fog { Color (0,0,0,0) }
			ZWrite Off
			ZTest LEqual
			CGPROGRAM
			#define _NORMALMAP 1
			#pragma shader_feature_local _METALLICGLOSSMAP
			#pragma shader_feature_local_fragment _SPECULARHIGHLIGHTS_OFF
			#pragma multi_compile_fwdadd_fullshadows
			#pragma multi_compile_fog
			#pragma skip_variants DYNAMICLIGHTMAP_ON
			#pragma skip_variants DIRLIGHTMAP_COMBINED
			#pragma require tessellation tessHW
			#pragma require geometry
			#pragma vertex vert
			#pragma hull hull
			#pragma domain domain
			#pragma geometry geom
			#pragma fragment fragAdd
			#include "UnityStandardCoreForward.cginc"
			#include "Rope.cginc"
			[maxvertexcount((MAX_DIVISIONS + 1) * 2)]
			void geom(line controlPoint ic[2], inout
			#if UNITY_STANDARD_SIMPLE
			TriangleStream<VertexOutputForwardAddSimple>
			#else
			TriangleStream<VertexOutputForwardAdd>
			#endif
			stream)
			{
				VertexInput v0, v1;
				for (int i = 0; i <= _Divisions; i++)
				{
					composeVertexInput(i, ic, v0, v1);
					stream.Append(vertAdd(v0));
					stream.Append(vertAdd(v1));
				}
			}
			ENDCG
		}
		Pass
		{
			Name "ShadowCaster"
			Tags { "LightMode" = "ShadowCaster" }
			ZWrite On ZTest LEqual
			CGPROGRAM
			#pragma shader_feature_local _METALLICGLOSSMAP
			#pragma multi_compile_shadowcaster
			#pragma require tessellation tessHW
			#pragma require geometry
			#pragma vertex vert
			#pragma hull hull
			#pragma domain domain
			#pragma geometry geom
			#pragma fragment fragShadowCaster
			#include "UnityStandardShadow.cginc"
			#include "Rope.cginc"
			struct shadowOutput
			{
				float4 opos : SV_POSITION;
				V2F_SHADOW_CASTER_NOPOS
				float2 tex : TEXCOORD1;
				UNITY_VERTEX_OUTPUT_STEREO
			};
			[maxvertexcount((MAX_DIVISIONS + 1) * 2)]
			void geom(line controlPoint ic[2], inout TriangleStream<shadowOutput> stream)
			{
				VertexInput v0, v1;
				shadowOutput so;
				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(so);
				for (int i = 0; i <= _Divisions; i++)
				{
					composeVertexInput(i, ic, v0, v1);
					#if defined(SHADOWS_CUBE) && !defined(SHADOWS_CUBE_IN_DEPTH_TEX)
						so.vec = v0.vertex.xyz - _LightPositionRange.xyz;
						so.opos = UnityObjectToClipPos(v0.vertex.xyz);
						so.tex = TRANSFORM_TEX(v0.uv0, _MainTex);
						stream.Append(so);
						so.vec = v1.vertex.xyz - _LightPositionRange.xyz;
						so.opos = UnityObjectToClipPos(v1.vertex.xyz);
						so.tex = TRANSFORM_TEX(v1.uv0, _MainTex);
						stream.Append(so);
					#else
						so.opos = UnityClipSpaceShadowCasterPos(v0.vertex, v0.normal);
						so.opos = UnityApplyLinearShadowBias(so.opos);
						so.tex = TRANSFORM_TEX(v0.uv0, _MainTex);
						stream.Append(so);
						so.opos = UnityClipSpaceShadowCasterPos(v1.vertex, v1.normal);
						so.opos = UnityApplyLinearShadowBias(so.opos);
						so.tex = TRANSFORM_TEX(v1.uv0, _MainTex);
						stream.Append(so);
					#endif
				}
			}
			ENDCG
		}
	}
}

レンダリング結果は下図のようになりました。

メッシュ自体はボールの中心をつなぐ折れ線であり、シェーダー上で円筒の形を生成するスタイルにしてみました。また、ボールの間隔を広げると本来はロープの節が長く伸びていきますが...

折れ線を細分割し曲線に沿わせることで、ロープの節を増やしてなめらかに見えるようにしています。

ですが、代償としてシェーダーのターゲットレベルが引き上げられてしまっています。「シェーダーコンパイルターゲットレベル - Unity マニュアル」には...

一般に言う #pragma target ディレクティブは上の要件を簡略にしたものであり、以下に対応します。

• 2.5: derivatives
• 3.0: 2.5 + interpolators10 + samplelod + fragcoord
• 3.5: 3.0 + interpolators15 + mrt4 + integers + 2darray + instancing
• 4.0: 3.5 + geometry
• 5.0: 4.0 + compute + randomwrite + tesshw + tessellation
• 4.5: 3.5 + compute + randomwrite
• 4.6: 4.0 + cubearray + tesshw + tessellation

とあります。
今回のシェーダーでは、メッシュ自体のデータ量をなるべく削減してメッシュ構築処理をシェーダー側に持っていくことで、頻繁なボール増減にかかる負荷を削減することを狙ってみました。ですがシェーダーでtesshw、tessellation、geometryを使用しているため、要求レベルは5.0になってしまうかと思います。
要求レベルを引き下げたい場合は、シェーダー側はもっとシンプルにして、細分割や円筒構築をスクリプト側で行う必要があるでしょう。処理コストは大きくなるだろうと思いますが、そもそも描画できないのでは話にならないでしょうから、もしレベル引き下げが必要でしたらコメントいただければ検討してみようと思います。

インスペクターの様子

シーン上のオブジェクト

ロープマテリアル

ロープシェーダー

Comments

[DY2peace]

いつもありがとうございます。お手数をおかけいたします。
現在、実装を試みているのですが、MeshGeneratorの「SetInteger」のところでエラーが出てしまいました。

「'Material' に 'SetInteger' の定義が含まれておらず、型 'Material' の最初の引数を受け付けるアクセス可能な拡張メソッド 'SetInteger' が見つかりませんでした。using ディレクティブまたはアセンブリ参照が不足していないことを確認してください [Assembly-CSharp]」

先にMaterialに割り当てておく、もしくはまだShaderを作ってないのですが、これが原因でしょうか。

ご迷惑をおかけいたしますがよろしくお願いいたします。

[Bongo]

すみません、先ほどリリースノート（https://unity3d.com/jp/unity/whats-new/2021.1.0 ）を確認したところ...

Shaders: Deprecated: Material, MaterialPropertyBlock and Shader API for working with "Int" properties is deprecated. Use "Integer" or "Float" properties and the corresponding API instead.

との記述がありました。SetIntegerは2021以降からのようですね。機能面では従来のSetIntと違いはないように見えますので、SetIntegerをSetIntに書き換えていただけますでしょうか。

[DY2peace]

ご回答ありがとうございます。
お恥ずかしながら、Shaderに関しては、使ったことがなく、アタッチの仕方など勉強しながら今取り組んでおります。
少々お時間いただけると幸いです。

[DY2peace]

申し訳ございません。色々と調べてみてもわからなかったので、
大変お手数ですが、各C＃スクリプト、Shaderがどこに配置されているか、Unity画面のヒエラルキーを見せていただいてご教示いただけないでしょうか。

[Bongo]

私の場合のシーンの様子を追記いたしました。シェーダーのたぐいに不慣れだそうですが、使うこと自体については特別な点はないと思うんですがね...
今のところ気になりますのは、やはり回答中で申し上げましたようにシェーダー自体が動作しない可能性ですかね。プロジェクト内にあるシェーダーファイルを選択した時のインスペクターの表示（追記した図のうち一番最後）に、何かエラーメッセージが出ていたりはしませんでしょうか?

[DY2peace]

動画のご提示いただきありがとうございました。MeshGeneratorの部分が誤解していたので、無事修正できました。
　上述の「本日分の追記」にて、記載しましたが、作成したRopeShaderに『Couldn’t　open include file 'Rope.cginc'』というエラーが3行ほど出てしまいます。
　Assetsフォルダーに直接cgincファイルを置いてしまっているのですが、適切な置き場などがあるのでしょうか。
的外れなご質問していたら申し訳ございません。

[DY2peace]

たびたび申し訳ございません。やはりcgincのファイルの置き場の問題でした。
Rope.Shaderのスクリプトを　#include "../Assets/Rope.cginc"　と記載したら、3つのエラーは表示されませんでした。
現状では、テクスチャが反映されず、真っ白なロープが出てきてしまってますので、もう少し条件を確認してみます。（エラーは今のところ何も出てないです）

[DY2peace]

色々とお手数をおかけして申し訳ございませんでした。またご対応いただきありがとうございます。
上述のテクスチャの件も含めて、スケール調整などを実施して、無事反映することができました。
いったんここで、ベストアンサーと高評価押させていただいてもよろしいでしょうか。

[Bongo]

うまくいきましたか、気がかりだったもので安心しました。特に問題がなさそうでしたら本トピックはクローズしてしまってかまわないかと思います。クローズ後でも、teratailの場合は必要に応じて回答投稿・追記修正が可能ですので、気になる点などありましたらコメントいただければ返信いたします。
実は、以前のコメントで申し上げたように環境の違いのせいでシェーダーが動作していないのでは...と気になっていまして、代替案の構想も練っているところでした。結局使わずに済んでけっこうなことではありますが、せっかくですので追記いたしました。もしシェーダー方式で新しい問題が起こったり、あるいはマテリアルをもっと自由に選びたいといったことがありましたら、あちらの方式を試してみてもいいかもしれません。

Answer 3

パート2

シーン上にもう一つ空のオブジェクトを用意して、それに下記スクリプトをアタッチしレンダリング担当としました。

using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.Rendering;

// シーン上に空のオブジェクトを作ってMeshGeneratorをアタッチすると、自動的にMeshFilterと
// MeshRendererも付いてくるはずなので、MeshRendererに後述のロープ用マテリアルをセットしておく
[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class MeshGenerator : MonoBehaviour
{
	private const int InitialNumberedBallCapacity = 16;

	private static readonly int RadiusProperty = Shader.PropertyToID("_Radius");
	private static readonly int DivisionsProperty = Shader.PropertyToID("_Divisions");
	private static readonly int SegmentLengthProperty = Shader.PropertyToID("_SegmentLength");
	private static readonly int VerticalTextureLengthProperty = Shader.PropertyToID("_VerticalTextureLength");
	private static readonly int BallCountProperty = Shader.PropertyToID("_BallCount");
	private static readonly int RootPositionProperty = Shader.PropertyToID("_RootPosition");
	private static readonly int RootForwardProperty = Shader.PropertyToID("_RootForward");
	private static readonly int RootRightProperty = Shader.PropertyToID("_RootRight");

	[SerializeField] private ChainGenerator2 generator; // 前述のボール生成スクリプト（インスペクター上でセットしておく）
	[SerializeField][Min(0.0f)] private float radius = 0.5f; // ロープの断面の半径
	[SerializeField][Range(3, 12)] private int divisions = 8; // ロープの断面の分割数
	[SerializeField][Min(1.0f)] private float segmentLength = 2.0f; // ロープの方向に沿ったメッシュの節の最大の長さ
	[SerializeField][Min(0.0f)] private float verticalTextureLength = 8.0f; // ロープの方向に沿ったテクスチャの1周期の長さ

	// メッシュの頂点の構造を定義
	// 1つのfloat4と2つのfloat3で構成されており、それらにPOSITION、TEXCOORD0、TEXCOORD1セマンティクスを割り当てる
	private readonly VertexAttributeDescriptor[] vertexLayout =
	{
		new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, 4),
		new VertexAttributeDescriptor(VertexAttribute.TexCoord0),
		new VertexAttributeDescriptor(VertexAttribute.TexCoord1)
	};

	// MeshGenerator側から見た頂点の構造を定義
	[StructLayout(LayoutKind.Sequential)]
	private struct Vertex
	{
		public Vector3 position; // ボールの位置（つまり断面の円の中心のワールド座標）
		public float axialPosition; // 先端からのロープに沿った位置
		public Vector3 forward; // ボールのtransform.forward
		public Vector3 right; // ボールのtransform.right
	}

	private readonly List<Vertex> vertices = new List<Vertex>();
	private readonly List<int> indices = new List<int>();
	private Mesh mesh;
	private Material material;

	private IEnumerator Start()
	{
		// 根元ボールが取得できるようになるまで待機する
		yield return new WaitUntil(() => this.generator && this.generator.RootBall);

		// 計算を単純化するため、MeshGeneratorはワールド原点に配置する
		this.transform.SetParent(null);
		this.transform.localScale = Vector3.one;
		this.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);

		// レンダラーからマテリアルを取得し、恒常的な設定項目をセットする
		this.material = this.GetComponent<MeshRenderer>().material;
		this.material.SetFloat(RadiusProperty, this.radius);
		this.material.SetInteger(DivisionsProperty, this.divisions);
		this.material.SetFloat(SegmentLengthProperty, this.segmentLength);
		this.material.SetFloat(VerticalTextureLengthProperty, this.verticalTextureLength);
		this.material.SetVector(RootPositionProperty, this.generator.RootBall.position);
		this.material.SetVector(RootForwardProperty, this.generator.RootBall.transform.forward);
		this.material.SetVector(RootRightProperty, this.generator.RootBall.transform.right);

		// メッシュを作成し、初期サイズに拡張する
		this.mesh = new Mesh { name = "Rope" };
		this.mesh.MarkDynamic();
		this.vertices.Add(new Vertex());
		this.ExtendMesh(InitialNumberedBallCapacity);
		this.GetComponent<MeshFilter>().mesh = this.mesh;

		// 毎フレームメッシュを更新する
		while (true)
		{
			yield return null;

			this.UpdateMesh();
		}
	}

	private void OnDestroy()
	{
		Destroy(this.mesh);
		Destroy(this.material);
	}

	private void ExtendMesh(int size)
	{
		var indexOrigin = this.vertices.Count;
		var newVertexCount = indexOrigin + size;
		for (var i = indexOrigin; i < newVertexCount; i++)
		{
			this.vertices.Add(new Vertex());
			this.indices.Add(i - 1);
			this.indices.Add(i);
		}

		this.mesh.SetVertexBufferParams(this.vertices.Count, this.vertexLayout);
		this.mesh.SetVertexBufferData(this.vertices, 0, 0, this.vertices.Count);

		// 1本の折れ線なので、通常はトポロジーとしてLineStripが使えるはずだが
		// テッセレーション機能を持つシェーダーとの併用ではなぜかレンダリングできず
		// Linesを使用している
		this.mesh.SetIndices(this.indices, MeshTopology.Lines, 0, false);
	}

	private void UpdateMesh()
	{
		// 現在のボールの数に合わせてメッシュを拡張する
		var currentBallCapacity = this.vertices.Count;
		var currentBallCount = this.generator.BallCount;
		if (currentBallCount > currentBallCapacity)
		{
			this.ExtendMesh(currentBallCapacity - 1);
		}

		// 現在の各ボールの位置と姿勢を取得し...
		var i = 0;
		foreach (var (position, forward, right, distance) in this.generator.BallPositions)
		{
			var v = this.vertices[i];
			v.position = position;
			v.axialPosition = distance;
			v.forward = forward;
			v.right = right;
			this.vertices[i] = v;
			i++;
		}

		// メッシュにセットして、マテリアルのボール個数プロパティも更新する
		this.mesh.SetVertexBufferData(this.vertices, 0, 0, this.vertices.Count);
		this.mesh.RecalculateBounds();
		this.material.SetInteger(BallCountProperty, currentBallCount);
	}
}

これにインスペクター上でシーン上のChainGenerator2をセットし、MeshRendererにはロープ用マテリアルをセットします。
ロープ用シェーダーは2つのファイルに分かれており、各パス共通の部分を記述した「Rope.cginc」と...

#ifndef ROPE_INCLUDED
#define ROPE_INCLUDED

#define MAX_DIVISIONS 12

#include "UnityCG.cginc"
#include "Tessellation.cginc"

float _TessellationEdgeLength;
float _Radius;
int _Divisions;
float _SegmentLength;
float _VerticalTextureLength;
uint _BallCount;
float3 _RootPosition;
float3 _RootForward;
float3 _RootRight;

struct appdata
{
	float4 vertex : POSITION;
	float3 forward : TEXCOORD0;
	float3 right : TEXCOORD1;
};

struct controlPoint
{
	float4 position : WORLDPOS;
	float3 forward : TEXCOORD0;
	float3 right : TEXCOORD1;
};

controlPoint vert(appdata v, uint i : SV_VertexID)
{
	controlPoint oc;
	if (i >= _BallCount)
	{
		oc.position = float4(_RootPosition, 0.0);
		oc.forward = _RootForward;
		oc.right = _RootRight;
	}
	else
	{
		oc.position = v.vertex;
		oc.forward = v.forward;
		oc.right = v.right;
	}
	return oc;
}

[domain("isoline")]
[partitioning("fractional_odd")]
[outputtopology("line")]
[patchconstantfunc("patchConst")]
[outputcontrolpoints(2)]
controlPoint hull(InputPatch<controlPoint, 2> ic, uint i : SV_OutputcontrolPointID)
{
	return ic[i];
}

void patchConst(InputPatch<controlPoint, 2> ic, out float f[2] : SV_TessFactor)
{
	f[0] = 1.0;
	f[1] = max(distance(ic[0].position.xyz, ic[1].position.xyz) / _SegmentLength, 1.0);
}

[domain("isoline")]
controlPoint domain(float f[2] : SV_TessFactor, const OutputPatch<controlPoint, 2> ic, float2 loc : SV_DomainLocation)
{
	controlPoint oc;
	float3 p0 = ic[0].position.xyz;
	float3 p1 = ic[1].position.xyz;
	float3 f0 = ic[0].forward;
	float3 f1 = ic[1].forward;
	float l = distance(p0, p1) / 3.0;
	float3 cp0 = p0 - f0 * l;
	float3 cp1 = p1 + f1 * l;
	float2 t = float2(loc.x, 1.0 - loc.x);
	float2 t2 = t * t;
	oc.position = float4(t.y * t2.y * p0 + 3.0 * t.x * t2.y * cp0 + 3.0 * t.y * t2.x * cp1 + t.x * t2.x * p1, lerp(ic[0].position.w, ic[1].position.w, t.x));
	oc.forward = normalize(lerp(f0, f1, t.x));
	oc.right = normalize(lerp(ic[0].right, ic[1].right, t.x));
	return oc;
}

void composeVertexInput(int i, controlPoint ic[2], out VertexInput o0, out VertexInput o1)
{
	float3 p0 = ic[0].position.xyz;
	float3 p1 = ic[1].position.xyz;
	float3x3 r0 = float3x3(ic[0].right, cross(ic[0].forward, ic[0].right), ic[0].forward);
	float3x3 r1 = float3x3(ic[1].right, cross(ic[1].forward, ic[1].right), ic[1].forward);
	float2 v = float2(ic[0].position.w, ic[1].position.w) / _VerticalTextureLength;
	VertexInput o;
	float u = float(i) / _Divisions;
	float3 localNormal = 0.0;
	sincos(2.0 * UNITY_PI * u, localNormal.y, localNormal.x);
	float3 localTangent = float3(-localNormal.y, localNormal.x, 0.0);
	float3 localPosition = localNormal * _Radius;
	o.vertex = float4(mul(localPosition, r0) + p0, 1.0);
	o.normal = mul(localNormal, r0);
	o.uv0 = float2(u, v.x);
	#ifdef UNITY_STANDARD_INPUT_INCLUDED
		o.uv1 = o.uv0;
		o.tangent = float4(mul(localTangent, r0), -1.0);
	#endif
	o0 = o;
	o.vertex = float4(mul(localPosition, r1) + p1, 1.0);
	o.normal = mul(localNormal, r1);
	o.uv0 = float2(u, v.y);
	#ifdef UNITY_STANDARD_INPUT_INCLUDED
		o.uv1 = o.uv0;
		o.tangent = float4(mul(localTangent, r1), -1.0);
	#endif
	o1 = o;
}

#endif // ROPE_INCLUDED

（パート3に続く...）

Answer 4

「円筒状メッシュに曲げ形状を追従させたい」で例示したようなSkinnedMeshRendererを使う方法もあり得るかもしれませんが、今回のようにボーンの数が頻繁に増減する状況では、増減のたびに再バインドを行う必要がありそうです。
それだとさすがに高負荷なんじゃないかと思い、方針を変えて「メッシュの動的生成・更新」でいくことにしました。さいわいメッシュの形状は単純な円筒で済ませられそうですので、メッシュの構築も比較的シンプルに行えそうだと考えました。

まず、「instantiateを使ったボールの連結」の時に例示しましたスクリプトでは、末端の一部のボールだけを覚えておいてジョイントのつなぎ替えを行っていましたが、下記のようにちょっと書き足してすべてのボールの位置と姿勢を取得できるようにしました。書き足した部分に+記号を付けて表示しています。

+using System.Collections.Generic;
+using System.Linq;
using UnityEngine;

public class ChainGenerator2 : MonoBehaviour
{
	public GameObject jyakanBall; // ボールのプレハブ...すでにRigidbodyを持っていると想定
	public GameObject firstBall; // FirstBallはあらかじめシーン上に存在していると想定
	public Transform firstPosiBase; // ボール発射初期位置
	public float speed = 10; // ボールの速度
	public float interval = 2.0f; // ボールを設置する間隔
	public float angularLimit = 6.0f; // ジョイントの曲がる角度の上限
	public float spring = 100.0f;
	public float damper = 10.0f;

	private Rigidbody rootRigidbody;
	private Rigidbody firstChildRigidbody;
	private Rigidbody firstRigidbody;
	private ConfigurableJoint primaryJoint;
	private ConfigurableJoint secondaryJoint;
	private Vector3 connectedAnchor;
	private SoftJointLimit highLimit;
	private SoftJointLimit lowLimit;
	private JointDrive drive;
	private bool isWinding;

+	 // 根元以外のボールを覚えておくためのスタック
+	 private readonly Stack<Rigidbody> numberedBalls = new Stack<Rigidbody>();

+	 // 根元のボールを得るプロパティ
+	 public Rigidbody RootBall => this.rootRigidbody;

+	 // 現在のボールの数を得るプロパティ
+	 public int BallCount => this.numberedBalls.Count + 1;

+	 // 現在のボールの位置、前方向、右方向、firstChildRigidbodyを起点にした鎖上の位置を得るプロパティ
+	 // firstRigidbodyが先頭、rootRigidbodyが末尾
+	 public IEnumerable<(Vector3, Vector3, Vector3, float)> BallPositions => this.numberedBalls.Reverse()
+		 .Select(ball => ball.transform).Select((t, i) => (t.position, t.forward, t.right, i * this.interval))
+		 .Concat(Enumerable.Repeat((this.rootRigidbody.position, this.rootRigidbody.transform.forward, this.rootRigidbody.transform.right, ((this.numberedBalls.Count - 1) * this.interval) + Vector3.Distance(this.rootRigidbody.position, this.firstChildRigidbody.position)), 1));

	// primaryJointを巻き取りモードに切り替えるプロパティ
	private bool IsWinding
	{
		get => this.isWinding;
		set
		{
			this.isWinding = value;
			var joint = this.primaryJoint;
			if (value)
			{
				joint.connectedAnchor = joint.connectedBody.transform.InverseTransformPoint(this.rootRigidbody.position);
				joint.zMotion = ConfigurableJointMotion.Locked;
			}
			else
			{
				joint.zMotion = ConfigurableJointMotion.Free;
			}
		}
	}

	private void Start()
	{
		this.firstRigidbody = this.firstBall.GetComponent<Rigidbody>();
		var firstPosition = this.firstPosiBase.transform.position; //ボールの発生する位置の設定
		this.firstBall.transform.position = firstPosition; //初期位置に初期ボールを移動させる

		// 初期位置に根元のボールを設置
		this.rootRigidbody = Instantiate(this.jyakanBall, firstPosition, Quaternion.identity).GetComponent<Rigidbody>();

		// 「firstChildRigidbody」はrootRigidbodyと直結している直接の子を表す
		// まずはfirstBallをfirstChildRigidbodyとする
		this.firstChildRigidbody = this.firstRigidbody;

		// ヒエラルキー上での確認を容易にするため、ボールには「プレハブ名 連番」の形の名前を付ける
		// rootRigidbodyは特別扱いで連番は付けず（さしあたり「プレハブ名 Root」とする）、firstBallを0番とする
		this.rootRigidbody.name = $"{this.jyakanBall.name} Root";
		this.firstChildRigidbody.name = $"{this.jyakanBall.name} 0";

+		 // firstChildRigidbodyを覚えておく
+		 this.numberedBalls.Push(this.firstChildRigidbody);

		// 根元は初期位置に固定することにする
		this.rootRigidbody.gameObject.AddComponent<FixedJoint>();

		// rootRigidbodyとfirstChildRigidbodyを接続する
		this.connectedAnchor = Vector3.back * this.interval;
		this.highLimit = new SoftJointLimit {limit = this.angularLimit};
		this.lowLimit = this.highLimit;
		this.lowLimit.limit *= -1.0f;
		this.drive = new JointDrive
		{
			maximumForce = float.MaxValue,
			positionSpring = this.spring,
			positionDamper = this.damper
		};
		this.primaryJoint = this.rootRigidbody.gameObject.AddComponent<ConfigurableJoint>();
		{
			var joint = this.primaryJoint;
			joint.rotationDriveMode = RotationDriveMode.XYAndZ;
			joint.angularXDrive = joint.angularYZDrive = this.drive;
			joint.xMotion = joint.yMotion = ConfigurableJointMotion.Locked;
			joint.zMotion = ConfigurableJointMotion.Free;
			joint.angularXMotion = joint.angularYMotion = ConfigurableJointMotion.Limited;
			joint.angularZMotion = ConfigurableJointMotion.Locked;
			joint.highAngularXLimit = joint.angularYLimit = this.highLimit;
			joint.lowAngularXLimit = this.lowLimit;
			joint.anchor = Vector3.zero;
			joint.autoConfigureConnectedAnchor = false;
			joint.connectedAnchor = Vector3.zero;
			joint.connectedBody = this.firstChildRigidbody;
		}
	}

	// 下矢印キーを押し下げると巻き取りモード、離すと通常モードとする
	private void Update()
	{
		if (Input.GetKeyDown(KeyCode.DownArrow))
		{
			this.IsWinding = true;
		}

		if (Input.GetKeyUp(KeyCode.DownArrow))
		{
			this.IsWinding = false;
		}
	}

	private void FixedUpdate()
	{
		var rootPosition = this.rootRigidbody.position;
		var rootRotation = this.rootRigidbody.rotation;

		// キーボード操作でfirstRigidbodyを移動
		var velocity = this.firstRigidbody.velocity;
		velocity.z = 0.0f;
		if (this.IsWinding)
		{
			// 巻き取りモードの場合、connectedAnchorを縮めることでリールの巻き取りを表現する
			this.primaryJoint.connectedAnchor = Vector3.MoveTowards(
				this.primaryJoint.connectedAnchor,
				Vector3.zero,
				this.speed * Time.deltaTime);

			// secondaryJointが存在するならば、つまりfirstChildRigidbodyの次に1つ以上ボールが
			// 存在するならば、さらにconnectedAnchorがほぼゼロまで縮んだかを調べる
			while ((this.secondaryJoint != null) && (this.primaryJoint.connectedAnchor.sqrMagnitude < 0.01f))
			{
				// connectedAnchorが縮みきっていればジョイントのつなぎ替えを行い、firstChildRigidbodyを削除する
				var newFirstChildRigidbody = this.secondaryJoint.connectedBody;
				var newFirstChildPosition = newFirstChildRigidbody.position;
				var newFirstChildRotation = newFirstChildRigidbody.rotation;
				DestroyImmediate(this.firstChildRigidbody.gameObject);
				this.primaryJoint.connectedAnchor = newFirstChildRigidbody.transform.InverseTransformPoint(rootPosition);
				newFirstChildRigidbody.position = rootPosition;
				newFirstChildRigidbody.rotation = rootRotation;
				this.primaryJoint.connectedBody = newFirstChildRigidbody;
				newFirstChildRigidbody.position = newFirstChildPosition;
				newFirstChildRigidbody.rotation = newFirstChildRotation;

				// primaryJointの接続先を次のfirstChildRigidbodyとし、secondaryJointも更新する
				this.firstChildRigidbody = newFirstChildRigidbody;
				this.secondaryJoint = newFirstChildRigidbody.GetComponent<ConfigurableJoint>();

+				 // 古いfirstChildRigidbodyをスタックから削除する
+				 this.numberedBalls.Pop();
			}
		}
		else
		{
			if (Input.GetKey(KeyCode.UpArrow))
			{
				velocity.z += this.speed;
			}

			// firstChildRigidbodyに対するrootRigidbodyの相対位置をrelativePositionとする
			var ballPosition = this.firstChildRigidbody.position;
			var ballRotation = this.firstChildRigidbody.rotation;
			var relativePosition = rootPosition - ballPosition;

			// その相対位置ベクトルの長さがinterval以上であればボールを追加する
			var distance = relativePosition.magnitude;
			while (distance >= this.interval)
			{
				// firstChildRigidbodyからintervalだけ離れた位置に新規ボールを設置する
				var newFirstChildPosition = ballPosition + Vector3.ClampMagnitude(relativePosition, this.interval);
				var newFirstChildRigidbody = Instantiate(this.jyakanBall, rootPosition, rootRotation).GetComponent<Rigidbody>();
				var previousFirstChildName = this.firstChildRigidbody.name;
				var previousFirstChildIndex = int.Parse(previousFirstChildName.Substring(previousFirstChildName.LastIndexOf(' ') + 1));
				newFirstChildRigidbody.name = $"{this.jyakanBall.name} {previousFirstChildIndex + 1}";

				// ジョイントもアタッチし、既存のジョイントをつなぎ替える
				this.firstChildRigidbody.position = rootPosition;
				this.firstChildRigidbody.rotation = rootRotation;
				this.secondaryJoint = newFirstChildRigidbody.gameObject.AddComponent<ConfigurableJoint>();
				{
					var joint = this.secondaryJoint;
					joint.rotationDriveMode = RotationDriveMode.XYAndZ;
					joint.angularXDrive = joint.angularYZDrive = this.drive;
					joint.xMotion = joint.yMotion = joint.zMotion = ConfigurableJointMotion.Locked;
					joint.angularXMotion = joint.angularYMotion = ConfigurableJointMotion.Limited;
					joint.angularZMotion = ConfigurableJointMotion.Locked;
					joint.highAngularXLimit = joint.angularYLimit = this.highLimit;
					joint.lowAngularXLimit = this.lowLimit;
					joint.anchor = Vector3.zero;
					joint.autoConfigureConnectedAnchor = false;
					joint.connectedAnchor = this.connectedAnchor;
					joint.connectedBody = this.firstChildRigidbody;
				}
				this.primaryJoint.connectedBody = newFirstChildRigidbody;
				newFirstChildRigidbody.position = newFirstChildPosition;
				newFirstChildRigidbody.rotation = Quaternion.Lerp(ballRotation, rootRotation, this.interval / distance);
				this.firstChildRigidbody.position = ballPosition;
				this.firstChildRigidbody.rotation = ballRotation;

				// 新しいボールを次のfirstChildRigidbodyとし、ballPositionとrelativePositionも更新する
				this.firstChildRigidbody = newFirstChildRigidbody;
				ballPosition = this.firstChildRigidbody.position;
				relativePosition = rootPosition - ballPosition;
				distance = relativePosition.magnitude;

+				 // 新しいfirstChildRigidbodyをスタックに追加する
+				 this.numberedBalls.Push(this.firstChildRigidbody);
			}
		}

		this.firstRigidbody.velocity = velocity;
	}
}

（パート2へ続く...）