void CURVE_OT_primitive_newspline_curve_add(wmOperatorType *ot)

static int add_primitive_newspline_exec(bContext *C, wmOperator *op)
{
  return curve_prim_add(C, op, CU_NEWSPLINE | CU_PRIM_CURVE);
}

else if (cutype == CU_NEWSPLINE) {
  nu->pntsu = // 制御点の数
  nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNewSplineprim3"); //ハンドルなし

// 全選択とスケールとソフトボディ用のウェイト
  bp = nu->bp;
  for (a = 0; a < nu->pntsu; a++, bp++) {
          bp->f1 = SELECT;
          bp->radius = bp->weight = 1.0;
  }

// 座標の代入

//原点の座標変換

        bp = nu->bp;
        for (a = 0; a < 4; a++, bp++) {
          mul_m4_v3(mat, bp->vec);
        }

}

// DispListを用意
DispList *dl = (DispList *)MEM_callocN(sizeof(DispList), __func__);
// サンプリング点の数だけ頂点を作成
dl->verts = (float *)MEM_mallocN(len * sizeof(float[3]), __func__);

BLI_addtail(r_dispbase, dl);
dl->parts = 1; //
dl->nr = len;  // サンプル数
dl->col = nu->mat_nr;  // マテリアルインデックス
dl->charidx = nu->charidx;
dl->type = (is_cyclic && (dl->nr != 2)) ? DL_POLY : DL_SEGM;  // 開いているか閉じているか?

// `dl->verts` にサンプル点の座標を格納する

repo:^github\.com/blender/blender$ file:^source/blender

region->do_draw |= RGN_DRAW;

            BKE_curve_forward_diff_bezier(prevbezt->vec[1][j],  // 制御点
                                          prevbezt->vec[2][j],  // ハンドル
                                          bezt->vec[0][j],  // ハンドル
                                          bezt->vec[1][j],  // 制御点
                                          data + j,  // 出力
                                          resolution,  // 分割数
                                          sizeof(float[3]));

void BKE_curve_forward_diff_bezier(
    float q0, float q1, float q2, float q3, float *p, int it, int stride)
{
  float rt0, rt1, rt2, rt3, f;
  int a;

  f = (float)it;
  rt0 = q0; // t^0 の係数
  rt1 = 3.0f * (q1 - q0) / f; // t^1 の係数
  f *= f;
  rt2 = 3.0f * (q0 - 2.0f * q1 + q2) / f; // t^2 の係数
  f *= it;
  rt3 = (q3 - q0 + 3.0f * (q1 - q2)) / f; // t^3 の係数

  q0 = rt0;
  q1 = rt1 + rt2 + rt3;
  q2 = 2 * rt2 + 6 * rt3;
  q3 = 6 * rt3;

  for (a = 0; a <= it; a++) {  // サンプル数だけ微小区間を適宜加算していく処理
    *p = q0;
    p = POINTER_OFFSET(p, stride);
    q0 += q1;
    q1 += q2;
    q2 += q3;
  }
}

      BKE_nurb_makeCurve(nu, dl->verts, nullptr, nullptr, nullptr, resolution, sizeof(float[3]));

void BKE_nurb_makeCurve(const Nurb *nu,
                        float *coord_array,
                        float *tilt_array,
                        float *radius_array,
                        float *weight_array,
                        int resolu,
                        int stride)
{
  const float eps = 1e-6f;
  BPoint *bp;
  float u, ustart, uend, ustep, sumdiv;
  float *basisu, *sum, *fp;
  float *coord_fp = coord_array, *tilt_fp = tilt_array, *radius_fp = radius_array,
        *weight_fp = weight_array;
  int i, len, istart, iend, cycl;

  if (nu->knotsu == NULL) {
    return;
  }
  if (nu->orderu > nu->pntsu) {
    return;
  }
  if (coord_array == NULL) {
    return;
  }

  /* allocate and initialize */
  len = nu->pntsu;
  if (len == 0) {
    return;
  }
  sum = (float *)MEM_calloc_arrayN(len, sizeof(float), "makeNurbcurve1");

  resolu = (resolu * SEGMENTSU(nu));

  if (resolu == 0) {
    MEM_freeN(sum);
    return;
  }

  fp = nu->knotsu;
  ustart = fp[nu->orderu - 1];
  if (nu->flagu & CU_NURB_CYCLIC) {
    uend = fp[nu->pntsu + nu->orderu - 1];
  }
  else {
    uend = fp[nu->pntsu];
  }
  ustep = (uend - ustart) / (resolu - ((nu->flagu & CU_NURB_CYCLIC) ? 0 : 1));

  basisu = (float *)MEM_malloc_arrayN(KNOTSU(nu), sizeof(float), "makeNurbcurve3");

  if (nu->flagu & CU_NURB_CYCLIC) {
    cycl = nu->orderu - 1;
  }
  else {
    cycl = 0;
  }

  u = ustart;
  while (resolu--) {
    basisNurb(u, nu->orderu, nu->pntsu + cycl, nu->knotsu, basisu, &istart, &iend);

    /* calc sum */
    sumdiv = 0.0;
    fp = sum;
    bp = nu->bp + istart - 1;
    for (i = istart; i <= iend; i++, fp++) {
      if (i >= nu->pntsu) {
        bp = nu->bp + (i - nu->pntsu);
      }
      else {
        bp++;
      }

      *fp = basisu[i] * bp->vec[3];
      sumdiv += *fp;
    }
    if ((sumdiv != 0.0f) && (sumdiv < 1.0f - eps || sumdiv > 1.0f + eps)) {
      /* is normalizing needed? */
      fp = sum;
      for (i = istart; i <= iend; i++, fp++) {
        *fp /= sumdiv;
      }
    }

    zero_v3(coord_fp);

    /* one! (1.0) real point */
    fp = sum;
    bp = nu->bp + istart - 1;
    for (i = istart; i <= iend; i++, fp++) {
      if (i >= nu->pntsu) {
        bp = nu->bp + (i - nu->pntsu);
      }
      else {
        bp++;
      }

      if (*fp != 0.0f) {
        madd_v3_v3fl(coord_fp, bp->vec, *fp);

        if (tilt_fp) {
          (*tilt_fp) += (*fp) * bp->tilt;
        }

        if (radius_fp) {
          (*radius_fp) += (*fp) * bp->radius;
        }

        if (weight_fp) {
          (*weight_fp) += (*fp) * bp->weight;
        }
      }
    }

    coord_fp = POINTER_OFFSET(coord_fp, stride);

    if (tilt_fp) {
      tilt_fp = POINTER_OFFSET(tilt_fp, stride);
    }
    if (radius_fp) {
      radius_fp = POINTER_OFFSET(radius_fp, stride);
    }
    if (weight_fp) {
      weight_fp = POINTER_OFFSET(weight_fp, stride);
    }

    u += ustep;
  }

  /* free */
  MEM_freeN(sum);
  MEM_freeN(basisu);
}