shroom_height = 10;
stipe_vSegments = 20;
stipe_rSegments = 20;
stipe_points = [];
stipe_indices = [];

// радиус ножки, как функция угла и позиции на сплайне
function stipe_radius(a, t) {
	return 1;
}

// форма ножки
stipe_shape = new THREE.CatmullRomCurve3( [
  new THREE.Vector3( 0, 0, 0 ),
  new THREE.Vector3( 1, shroom_height * 0.25, 0 ),
  new THREE.Vector3( 2, shroom_height * 0.5, 0),
  new THREE.Vector3( 0, shroom_height * 0.75, 0),
  new THREE.Vector3( 1, shroom_height, 0 ),
], closed=false );

// t - относительное положение среза на stipe_shape, от 0 до 1
for (var t = 0; t < 1; t += 1 / stipe_vSegments) {
  // форма среза ножки
  var curve = new THREE.CatmullRomCurve3( [
    new THREE.Vector3( 0, 0, stipe_radius(0, t)),
    new THREE.Vector3( stipe_radius(Math.PI / 2, t), 0, 0 ),
    new THREE.Vector3( 0, 0, -stipe_radius(Math.PI, t)),
    new THREE.Vector3( -stipe_radius(Math.PI * 1.5, t), 0, 0 ),
	], closed=true, curveType='catmullrom', tension=0.75);

  // вычисляем точки на срезе ножки
  var local_points = curve.getPoints( stipe_rSegments );

  // добавляем точки к мешу
  for (var i = 0; i < local_points.length; i++) {
    var v = local_points[i];
  	stipe_points.push(v.x, v.y, v.z);
  }
}

// задаём индексы точек, образующих грани, по 2 треугольника на грань
for (var i = 0; i < stipe_vSegments - 1; i ++) {
  for (var j = 0; j < stipe_rSegments; j ++) {
    stipe_indices.push(i * (stipe_rSegments + 1) + j,
                       i * (stipe_rSegments + 1) + j + 1,
                       (i + 1) * (stipe_rSegments + 1) + j);

    stipe_indices.push(i * (stipe_rSegments + 1) + j + 1,
                       (i + 1) * (stipe_rSegments + 1) + j + 1,
                       (i + 1) * (stipe_rSegments + 1) + j);
  }
}

// создаём буферную геометрию из точек и индексов граней
var stipe = new THREE.BufferGeometry();
stipe.setAttribute('position', new THREE.BufferAttribute(new Float32Array(stipe_points), 3));
stipe.setIndex(stipe_indices);
stipe.computeVertexNormals();

base_radius = 1;
noise_c = 2;

// радиус ножки, как функция угла и позиции на сплайне
function stipe_radius(a, t) {
	return base_radius + (1 - t)*(1 + Math.random())*noise_c;
}

pileus_points = [];
pileus_indices = [];

// точка поверхности шляпки как функция радиальных координат
function pileus_surface(a0, t0) {
  // вычисляем относительное положение точки 
  // на кривой с учётом возможного радиального шума
  var t = t * (1 + radnoise(a, t));
  // проверка того что мы не вышли за кривую
  if (t > 1) t = 1; if (t < 0) t = 0;

  // вычисляем нормаль, ортогональную поверхности 
  // в данной точке (единичный вектор ортогонального шума)
  var shape_point = pileus_shape.getPointAt(t);
  var tangent = pileus_shape.getTangentAt(t);
  var orth_noise_v = new THREE.Vector3(0,0,0);
  const z1 = new THREE.Vector3(0,0,1);
  orth_noise_v.crossVectors(z1, tangent);

  // вычисляем значение угла с учётом углового шума и 
  // положение точки с учётом обновлённого угла
  var a = angnoise(a0, t);
  var surface_point = new THREE.Vector3(
    Math.cos(a) * shape_point.x,
    shape_point.y,
    Math.sin(a) * shape_point.x
  );

  // вычисляем множитель ортогонального шума
  var surfnoise_val = orthnoise(a, t);

  // финальные координаты точки (a0, t0) с учётом всех шумов
  surface_point.x += orth_noise_v.x * Math.cos(a) * surfnoise_val;
  surface_point.y += orth_noise_v.y * surfnoise_val;
  surface_point.z += orth_noise_v.x * Math.sin(a) * surfnoise_val;

  return surface_point;
}

// формируем поверхность шляпки с разрешением
// pileus_rSegments * pileus_cSegments
for (var i = 1; i <= pileus_rSegments; i++) {
  var t0 = i / pileus_rSegments;
	for (var j = 0; j < pileus_cSegments; j++) {
    var a0 = Math.PI * 2 / pileus_cSegments * j;
    var surface_point = pileus_surface(a0, t0);
    pileus_points.push(
      surface_point.x, 
      surface_point.y, 
      surface_point.z
    );
	}
}

// индексная магия, соединяющая точки гранями
for (var i = 0; i < pileus_rSegments - 1; i ++) {
  if (i == 0) { 
    for (var j = 0; j < pileus_cSegments; j ++) 
      pileus_indices.push(
        0, 
        (j + 1) % pileus_cSegments + 1, 
        j + 1
      );
  }
  for (var j = 0; j < pileus_cSegments; j ++) {
    pileus_indices.push(
    	i * pileus_cSegments + 1 + j,
      (i + 1) * pileus_cSegments + 1 + (j + 1) % pileus_cSegments,
  		(i + 1) * pileus_cSegments + 1 + j
		);

    pileus_indices.push(
      i * pileus_cSegments + 1 + j,
      i * pileus_cSegments + 1 + (j + 1) % pileus_cSegments,
      (i + 1) * pileus_cSegments + 1 + (j + 1) % pileus_cSegments
    );
	}
}

// объединяем всё что нагенерили в буфферную геометрию
pileus.setAttribute('position', new THREE.BufferAttribute(new Float32Array(pileus_points), 3));
pileus.setIndex(pileus_indices);
pileus.computeVertexNormals();

NOISE.seed(Math.random());

function radnoise(a, t) {
  return -Math.abs(NOISE.perlin2(t * Math.cos(a), t * Math.sin(a)) * 0.5);
}

function angnoise(a, t) {
  return NOISE.perlin2(t * Math.cos(a), t * Math.sin(a)) * 0.2;
}

function orthnoise(a, t) {
  return NOISE.perlin2(t * Math.cos(a), t * Math.sin(a)) * t;
}

var bufgeoms = [];
var N = 10;

for (var i = 0; i < dots_num; i++) {
  var dot_points = [];

	// выбираем случайный центр точки на шляпке
  var a = Math.random() * Math.PI * 2;
  var t = Math.random();
  var dot_center = pileus_surface(a, t);

	// генерируем случайное облако точек вокруг центра
  for (var j = 0; j < N; j++) {
    dot_points.push(new THREE.Vector3(
      dot_center.x + (1 - Math.random() * 2) * dot_radius, 
      dot_center.y + (1 - Math.random() * 2) * dot_radius,
      dot_center.z + (1 - Math.random() * 2) * dot_radius
		);
  }

	// создаём замкнутую геометрию на основе облака точек
  var dot_geometry = new THREE.ConvexGeometry( dots_points );
  bufgeoms.push(dots_geometry);
}

// объединяем все мухоморные точки в одну буфферную геометрию
var dots = THREE.BufferGeometryUtils.mergeBufferGeometries(bufgeoms);

stipe_colors = [];

c = [100, 100, 100] // базовый цвет
v = [100, 100, 100] // диапазоны вариации цвета

function stipe_color(a, t) {
  return [c[0] + t * v[0], c[1] + t * v[1], c[2] + t * v[2]];
}

...
	stipe_points.push(v.x, v.y, v.z);
	stipe_colors.push(...stipe_color(a, t));
...

var stipe = new THREE.BufferGeometry();
...
stipe.setAttribute('color', new THREE.Float32BufferAttribute(stipe_colors, 3));