25 #define DNA_DEPRECATED_ALLOW
84 const Curve *curve_src = (
const Curve *)id_src;
221 if (cu->
vfont ==
nullptr) {
253 if (cu->
vfont ==
nullptr) {
392 cu->
type = curve_type;
404 cu->
tb[0].
w = cu->
tb[0].
h = 0.0;
529 float loc[3],
size[3];
536 for (
int a = 0;
a < 3;
a++) {
537 if (
size[
a] == 0.0f) {
540 else if (
size[
a] > 0.0f &&
size[
a] < 0.00001f) {
543 else if (
size[
a] < 0.0f &&
size[
a] > -0.00001f) {
570 if (index - tot < tot_nu) {
571 copy_v3_v3(r_co, nu->bezt[index - tot].vec[1]);
576 tot_nu = nu->pntsu * nu->pntsv;
577 if (index - tot < tot_nu) {
594 tot += 3 * nu->pntsu;
597 tot += nu->pntsu * nu->pntsv;
613 tot += nu->pntsu * nu->pntsv;
667 if (newnu ==
nullptr) {
670 *newnu = blender::dna::shallow_copy(*nu);
704 *newnu = blender::dna::shallow_copy(*
src);
707 SWAP(
int, pntsu, pntsv);
709 newnu->
pntsu = pntsu;
710 newnu->
pntsv = pntsv;
746 bezt->
vec[0][2] = 0.0;
747 bezt->
vec[1][2] = 0.0;
748 bezt->
vec[2][2] = 0.0;
774 float radius_vector[3];
775 radius_vector[0] = radius_vector[1] = radius_vector[2] = bezt->
radius;
795 if (nu->
pntsv == 1 && use_radius) {
796 float radius_vector[3];
797 radius_vector[0] = radius_vector[1] = radius_vector[2] = bp->
radius;
820 int resolu = resolution ? resolution : nu->
resolu;
821 int pntsu = nu->
pntsu;
822 float *points, *pntsit, *prevpntsit;
829 prevbp = nu->
bp + (nu->
pntsu - 1);
843 points = (
float *)
MEM_mallocN(
sizeof(
float[3]) * (resolu + 1),
"getLength_bezier");
860 for (
int j = 0; j < 3; j++) {
870 prevpntsit = pntsit = points;
885 if (nu->
pntsv == 1) {
887 points = (
float *)
MEM_callocN(
sizeof(
float[3]) * pntsu * resolu,
"getLength_nurbs");
892 b = pntsu * resolu + 1;
893 prevpntsit = points + 3 * (pntsu * resolu - 1);
897 b = (pntsu - 1) * resolu;
921 for (i = 0, bp = &nu->
bp[nu->
pntsu]; i < number; i++, bp++) {
935 for (i = 0, bezt = &nu->
bezt[nu->
pntsu]; i < number; i++, bezt++) {
944 const int totu = nu->
pntsu;
945 const int totv = nu->
pntsv;
950 else if (u < 0 || u >= totu) {
957 else if (v < 0 || v >= totv) {
961 return (
v * totu) + u;
966 const int totu = nu->
pntsu;
967 const int totv = nu->
pntsv;
969 *r_u = (index % totu);
970 *r_v = (index / totu) % totv;
981 bezt_next = nu->
bezt;
988 bezt_next = bezt + 1;
1000 if (bp == &nu->
bp[nu->
pntsu - 1]) {
1022 if (bezt == nu->
bezt) {
1027 bezt_prev =
nullptr;
1031 bezt_prev = bezt - 1;
1046 bp_prev = &nu->
bp[nu->
pntsu - 1];
1062 float dir_prev[3], dir_next[3];
1076 float dir_prev[3], dir_next[3];
1102 float dir_mid[3], tvec[3];
1139 float dir_prev[3] = {0.0f}, dir_next[3] = {0.0f};
1153 float dir_mid[3], tvec[3];
1164 static void calcknots(
float *knots,
const int pnts,
const short order,
const short flag)
1170 const int repeat_inner = is_bezier ?
order - 1 : 1;
1173 (is_bezier ?
min_ii(2, repeat_inner) : 1);
1181 float current = 0.0f;
1198 const int tail_index = knot_count - tail;
1200 knots[tail_index + i] = current + (knots[i] - knots[0]);
1245 float t,
short order,
int pnts,
const float *knots,
float *basis,
int *start,
int *end)
1248 int i,
i1 = 0, i2 = 0, j, orderpluspnts, opp2, o2;
1250 orderpluspnts =
order + pnts;
1251 opp2 = orderpluspnts - 1;
1257 else if (
t > knots[opp2]) {
1263 for (i = 0; i < opp2; i++) {
1264 if (knots[i] != knots[i + 1] &&
t >= knots[i] &&
t <= knots[i + 1]) {
1284 for (j = 2; j <=
order; j++) {
1286 if (i2 + j >= orderpluspnts) {
1290 for (i =
i1; i <= i2; i++) {
1291 if (basis[i] != 0.0f) {
1292 d = ((
t - knots[i]) * basis[i]) / (knots[i + j - 1] - knots[i]);
1298 if (basis[i + 1] != 0.0f) {
1299 e = ((knots[i + j] -
t) * basis[i + 1]) / (knots[i + j] - knots[i + 1]);
1312 for (i =
i1; i <= i2; i++) {
1313 if (basis[i] > 0.0f) {
1315 if (*start == 1000) {
1325 float *basisu, *basis, *basisv, *
sum, *fp, *in;
1326 float u,
v, ustart, uend, ustep, vstart, vend, vstep, sumdiv;
1327 int i, j, iofs, jofs, cycl,
len, curu, curv;
1328 int istart, iend, jsta, jen, *jstart, *jend, ratcomp;
1330 int totu = nu->
pntsu * resolu, totv = nu->
pntsv * resolv;
1341 if (coord_array ==
nullptr) {
1357 if (bp->
vec[3] != 1.0f) {
1365 ustart = fp[nu->
orderu - 1];
1370 uend = fp[nu->
pntsu];
1377 vstart = fp[nu->
orderv - 1];
1383 vend = fp[nu->
pntsv];
1423 jsta = jstart[curv];
1430 for (j = jsta; j <= jen; j++) {
1432 if (j >= nu->
pntsv) {
1433 jofs = (j - nu->
pntsv);
1438 bp = nu->
bp + nu->
pntsu * jofs + istart - 1;
1440 for (i = istart; i <= iend; i++, fp++) {
1441 if (i >= nu->
pntsu) {
1442 iofs = i - nu->
pntsu;
1443 bp = nu->
bp + nu->
pntsu * jofs + iofs;
1450 *fp = basisu[i] * basis[j] * bp->
vec[3];
1454 *fp = basisu[i] * basis[j];
1461 for (j = jsta; j <= jen; j++) {
1462 for (i = istart; i <= iend; i++, fp++) {
1472 for (j = jsta; j <= jen; j++) {
1474 if (j >= nu->
pntsv) {
1475 jofs = (j - nu->
pntsv);
1480 bp = nu->
bp + nu->
pntsu * jofs + istart - 1;
1482 for (i = istart; i <= iend; i++, fp++) {
1483 if (i >= nu->
pntsu) {
1484 iofs = i - nu->
pntsu;
1485 bp = nu->
bp + nu->
pntsu * jofs + iofs;
1501 if (rowstride != 0) {
1502 in = (
float *)(((
unsigned char *)in) + (rowstride - 3 * totv *
sizeof(*in)));
1517 float *radius_array,
1518 float *weight_array,
1522 const float eps = 1e-6f;
1524 float u, ustart, uend, ustep, sumdiv;
1525 float *basisu, *
sum, *fp;
1526 float *coord_fp = coord_array, *tilt_fp = tilt_array, *radius_fp = radius_array,
1527 *weight_fp = weight_array;
1528 int i,
len, istart, iend, cycl;
1530 if (nu->
knotsu ==
nullptr) {
1536 if (coord_array ==
nullptr) {
1555 ustart = fp[nu->
orderu - 1];
1560 uend = fp[nu->
pntsu];
1580 bp = nu->
bp + istart - 1;
1581 for (i = istart; i <= iend; i++, fp++) {
1582 if (i >= nu->
pntsu) {
1583 bp = nu->
bp + (i - nu->
pntsu);
1589 *fp = basisu[i] * bp->
vec[3];
1592 if ((sumdiv != 0.0f) && (sumdiv < 1.0f -
eps || sumdiv > 1.0f +
eps)) {
1595 for (i = istart; i <= iend; i++, fp++) {
1604 bp = nu->
bp + istart - 1;
1605 for (i = istart; i <= iend; i++, fp++) {
1606 if (i >= nu->
pntsu) {
1607 bp = nu->
bp + (i - nu->
pntsu);
1617 (*tilt_fp) += (*fp) * bp->
tilt;
1621 (*radius_fp) += (*fp) * bp->
radius;
1625 (*weight_fp) += (*fp) * bp->
weight;
1651 const unsigned int resolu,
1653 const bool use_cyclic_duplicate_endpoint)
1655 const unsigned int segments = bezt_array_len - (
is_cyclic ? 0 : 1);
1656 const unsigned int points_len = (segments * resolu) +
1657 (
is_cyclic ? (use_cyclic_duplicate_endpoint) : 1);
1662 const unsigned int bezt_array_len,
1663 const unsigned int resolu,
1665 const bool use_cyclic_duplicate_endpoint,
1667 const unsigned int axis,
1668 const unsigned int stride,
1672 bezt_array_len, resolu,
is_cyclic, use_cyclic_duplicate_endpoint);
1673 float *r_points_offset = r_points;
1675 const unsigned int resolu_stride = resolu *
stride;
1676 const unsigned int bezt_array_last = bezt_array_len - 1;
1678 for (
unsigned int i = 0; i < bezt_array_last; i++) {
1679 const BezTriple *bezt_curr = &bezt_array[i];
1680 const BezTriple *bezt_next = &bezt_array[i + 1];
1682 bezt_curr->
vec[2][axis],
1683 bezt_next->
vec[0][axis],
1684 bezt_next->
vec[1][axis],
1688 r_points_offset = (
float *)
POINTER_OFFSET(r_points_offset, resolu_stride);
1692 const BezTriple *bezt_curr = &bezt_array[bezt_array_last];
1693 const BezTriple *bezt_next = &bezt_array[0];
1695 bezt_curr->
vec[2][axis],
1696 bezt_next->
vec[0][axis],
1697 bezt_next->
vec[1][axis],
1701 r_points_offset = (
float *)
POINTER_OFFSET(r_points_offset, resolu_stride);
1702 if (use_cyclic_duplicate_endpoint) {
1703 *r_points_offset = *r_points;
1708 float *r_points_last = (
float *)
POINTER_OFFSET(r_points, bezt_array_last * resolu_stride);
1709 *r_points_last = bezt_array[bezt_array_last].
vec[1][axis];
1718 float q0,
float q1,
float q2,
float q3,
float *p,
int it,
int stride)
1720 float rt0, rt1, rt2, rt3, f;
1725 rt1 = 3.0f * (
q1 - q0) / f;
1727 rt2 = 3.0f * (q0 - 2.0f *
q1 + q2) / f;
1729 rt3 = (q3 - q0 + 3.0f * (
q1 - q2)) / f;
1732 q1 = rt1 + rt2 + rt3;
1733 q2 = 2 * rt2 + 6 * rt3;
1736 for (
a = 0;
a <= it;
a++) {
1746 float q0,
float q1,
float q2,
float q3,
float *p,
int it,
int stride)
1748 float rt0, rt1, rt2, f;
1751 f = 1.0f / (
float)it;
1753 rt0 = 3.0f * (
q1 - q0);
1754 rt1 = f * (3.0f * (q3 - q0) + 9.0f * (
q1 - q2));
1755 rt2 = 6.0f * (q0 + q2) - 12.0f *
q1;
1758 q1 = f * (rt1 + rt2);
1759 q2 = 2.0f * f * rt1;
1761 for (
a = 0;
a <= it;
a++) {
1781 for (
int a = 0;
a <= it;
a++) {
1782 float t = (
float)
a / (
float)it;
1784 for (
int i = 0; i < 3; i++) {
1785 p[i] = (-6.0f *
t + 6.0f) * p0[i] + (18.0f *
t - 12.0f) * p1[i] +
1786 (-18.0f *
t + 6.0f) * p2[i] + (6.0f *
t) * p3[i];
1811 deler = (
v1[cox] -
v2[cox]) * (v3[coy] - v4[coy]) - (v3[cox] - v4[cox]) * (
v1[coy] -
v2[coy]);
1812 if (deler == 0.0f) {
1816 *lambda = (
v1[coy] - v3[coy]) * (v3[cox] - v4[cox]) - (
v1[cox] - v3[cox]) * (v3[coy] - v4[coy]);
1817 *lambda = -(*lambda / deler);
1819 deler = v3[coy] - v4[coy];
1821 deler = v3[cox] - v4[cox];
1822 *mu = -(*lambda * (
v2[cox] -
v1[cox]) +
v1[cox] - v3[cox]) / deler;
1825 *mu = -(*lambda * (
v2[coy] -
v1[coy]) +
v1[coy] - v3[coy]) / deler;
1827 vec[cox] = *lambda * (
v2[cox] -
v1[cox]) +
v1[cox];
1828 vec[coy] = *lambda * (
v2[coy] -
v1[coy]) +
v1[coy];
1830 if (*lambda >= 0.0f && *lambda <= 1.0f && *mu >= 0.0f && *mu <= 1.0f) {
1831 if (*lambda == 0.0f || *lambda == 1.0f || *mu == 0.0f || *mu == 1.0f) {
1844 float min,
max, vec[3], hvec1[3], hvec2[3], lab, mu;
1845 int nr, links = 0, rechts = 0, mode;
1850 hvec1[0] = bevp->
vec[0];
1851 hvec1[1] = bevp->
vec[1];
1861 prevbevp = bevp + (nr - 1);
1871 if (
min <= hvec1[1] &&
max >= hvec1[1]) {
1873 mode =
cu_isectLL(prevbevp->
vec, bevp->
vec, hvec1, hvec2, 0, 1, &lab, &mu, vec);
1877 if (mode >= 0 && lab != 0.0f) {
1878 if (vec[0] < hvec1[0]) {
1891 return (links & 1) && (rechts & 1);
1904 if (x1->
left >
x2->left) {
1907 if (x1->
left <
x2->left) {
1916 float x1,
float y1,
float x2,
float y2,
float *r_sina,
float *r_cosa)
1918 float t01, t02, x3, y3;
1934 t02 = x1 *
x2 +
y1 * y2;
1935 if (
fabsf(t02) >= 1.0f) {
1939 t02 = (
saacos(t02)) / 2.0f;
1949 if (x3 == 0 && y3 == 0) {
1954 t01 =
sqrtf(x3 * x3 + y3 * y3);
1959 *r_sina = -y3 / t02;
1967 float *radius_array,
1968 float *weight_array,
1973 float fac, dfac,
t[4];
1976 if (tilt_array ==
nullptr && radius_array ==
nullptr) {
1983 if (prevbezt == nu->
bezt) {
1992 pprev = prevbezt - 1;
2009 dfac = 1.0f / (
float)resolu;
2011 for (
a = 0;
a < resolu;
a++, fac += dfac) {
2015 *tilt_array = prevbezt->
tilt +
2016 (bezt->
tilt - prevbezt->
tilt) * (3.0f * fac * fac - 2.0f * fac * fac * fac);
2020 *tilt_array =
t[0] * pprev->
tilt +
t[1] * prevbezt->
tilt +
t[2] * bezt->
tilt +
2033 (3.0f * fac * fac - 2.0f * fac * fac * fac);
2042 t[3] *
next->radius;
2051 (3.0f * fac * fac - 2.0f * fac * fac * fac);
2070 bevp1 = bevp2 + (
bl->
nr - 1);
2130 bevp1 = bevp2 + (
bl->
nr - 1);
2152 bevp1 = bevp2 + (
bl->
nr - 1);
2171 float bevp0_quat[4];
2176 bevp1 = bevp2 + (
bl->
nr - 1);
2198 float zaxis[3] = {0, 0, 1},
cross[3], q2[4];
2257 bevp1 = bevp2 + (
bl->
nr - 1);
2271 for (nr = 1; nr <
bl->
nr; nr++) {
2292 float vec_1[3] = {0, 1, 0}, vec_2[3] = {0, 1, 0},
angle, ang_fac, cross_tmp[3];
2298 bevp_first +=
bl->
nr - 1;
2299 bevp_last = bevp_first;
2327 bevp1 = bevp2 + (
bl->
nr - 1);
2353 bevp1 = bevp2 + (
bl->
nr - 1);
2371 bevp1 = bevp2 + (
bl->
nr - 1);
2388 bevp1 = bevp2 + (
bl->
nr - 1);
2397 const float zero[3] = {0, 0, 0};
2411 switch (twist_mode) {
2460 const float x1 = bevp1->
vec[0] - bevp2->
vec[0];
2461 const float y1 = bevp1->
vec[1] - bevp2->
vec[1];
2481 bevp1 = bevp2 + (
bl->
nr - 1);
2494 const float x1 = bevp1->
vec[0] - bevp0->
vec[0];
2495 const float x2 = bevp1->
vec[0] - bevp2->
vec[0];
2496 const float y1 = bevp1->
vec[1] - bevp0->
vec[1];
2497 const float y2 = bevp1->
vec[1] - bevp2->
vec[1];
2526 bevp += (
bl->
nr - 1);
2536 if (nu->
pntsu > 1) {
2541 last_bevp = first_bevp + (
bl->
nr - 1);
2582 BevPoint *bevp2, *bevp1 =
nullptr, *bevp0;
2585 float *seglen =
nullptr;
2587 int a,
b, nr, poly, resolu = 0,
len = 0, segcount;
2589 bool do_tilt, do_radius, do_weight;
2590 bool is_editmode =
false;
2594 const bool need_seglen =
ELEM(
2614 if (nu->hide && is_editmode) {
2644 resolu = nu->resolu;
2651 BevList *
bl = MEM_cnew<BevList>(__func__);
2671 bevp->
tilt = bp->tilt;
2672 bevp->
radius = bp->radius;
2673 bevp->
weight = bp->weight;
2675 if (seglen !=
nullptr &&
len != 0) {
2699 len = segcount * resolu + 1;
2701 BevList *
bl = MEM_cnew<BevList>(__func__);
2717 if (seglen !=
nullptr) {
2726 prevbezt = nu->bezt + (nu->pntsu - 1);
2742 bevp->
tilt = prevbezt->tilt;
2743 bevp->
radius = prevbezt->radius;
2744 bevp->
weight = prevbezt->weight;
2749 if (seglen !=
nullptr) {
2750 *seglen =
len_v3v3(prevbezt->vec[1], bezt->
vec[1]);
2765 for (j = 0; j < 3; j++) {
2767 prevbezt->vec[2][j],
2779 do_tilt ? &bevp->
tilt :
nullptr,
2780 do_radius ? &bevp->
radius :
nullptr,
2781 do_weight ? &bevp->
weight :
nullptr,
2796 if (seglen !=
nullptr) {
2799 for (j = 0; j < resolu; j++) {
2823 bevp->
tilt = prevbezt->tilt;
2824 bevp->
radius = prevbezt->radius;
2825 bevp->
weight = prevbezt->weight;
2834 if (nu->pntsv == 1) {
2835 len = (resolu * segcount);
2837 BevList *
bl = MEM_cnew<BevList>(__func__);
2855 do_tilt ? &bevp->
tilt :
nullptr,
2856 do_radius ? &bevp->
radius :
nullptr,
2857 do_weight ? &bevp->
weight :
nullptr,
2862 if (seglen !=
nullptr) {
2871 for (j = 0; j < ((nr == 1) ? (resolu - 1) : resolu); j++) {
2900 const float threshold_resolu = 0.00001f / resolu;
2905 bevp0 = bevp1 + (nr - 1);
2914 if (seglen !=
nullptr) {
2916 bevp0->dupe_tag =
true;
2921 if (
compare_v3v3(bevp0->vec, bevp1->vec, threshold_resolu)) {
2922 bevp0->dupe_tag =
true;
2940 if (!blnew->bevpoints) {
2950 bevp1 = blnew->bevpoints;
2953 if (bevp0->dupe_tag == 0) {
2954 memcpy(bevp1, bevp0,
sizeof(
BevPoint));
2986 min = bevp1->vec[0];
2989 if (
min > bevp->
vec[0]) {
2999 if (bevp1 == bevp) {
3000 bevp0 = bevp + (
bl->
nr - 1);
3005 bevp = bevp + (
bl->
nr - 1);
3006 if (bevp1 == bevp) {
3013 inp = ((bevp1->vec[0] - bevp0->vec[0]) * (bevp0->vec[1] - bevp2->vec[1]) +
3014 (bevp0->vec[1] - bevp1->vec[1]) * (bevp0->vec[0] - bevp2->vec[0]));
3029 for (
a = 1;
a < poly;
a++, sd++) {
3031 sd1 = sortdata + (
a - 1);
3032 for (
b =
a - 1;
b >= 0;
b--, sd1--) {
3035 bl->
hole = 1 - sd1->bl->hole;
3045 for (
a = 0;
a < poly;
a++, sd++) {
3046 if (sd->bl->hole == sd->dir) {
3049 bevp2 = bevp1 + (
bl->
nr - 1);
3070 else if (
bl->
nr == 2) {
3085 else if (
bl->
nr == 2) {
3103 char fcurve_smoothing)
3106 #define p2_h1 ((p2)-3)
3107 #define p2_h2 ((p2) + 3)
3109 const float *p1, *p3;
3112 float dvec_a[3], dvec_b[3];
3113 float len, len_a, len_b;
3114 const float eps = 1
e-5;
3119 if (bezt->
h1 == 0 && bezt->
h2 == 0) {
3125 if (
prev ==
nullptr) {
3127 pt[0] = 2.0f * p2[0] - p3[0];
3128 pt[1] = 2.0f * p2[1] - p3[1];
3129 pt[2] = 2.0f * p2[2] - p3[2];
3136 if (
next ==
nullptr) {
3137 pt[0] = 2.0f * p2[0] - p1[0];
3138 pt[1] = 2.0f * p2[1] - p1[1];
3139 pt[2] = 2.0f * p2[2] - p1[2];
3158 if (len_a == 0.0f) {
3161 if (len_b == 0.0f) {
3167 tvec[0] = dvec_b[0] / len_b + dvec_a[0] / len_a;
3168 tvec[1] = dvec_b[1] / len_b + dvec_a[1] / len_a;
3169 tvec[2] = dvec_b[2] / len_b + dvec_a[2] / len_a;
3175 len = 6.0f / 2.5614f;
3188 bool leftviolate =
false, rightviolate =
false;
3191 if (len_a > 5.0f * len_b) {
3192 len_a = 5.0f * len_b;
3194 if (len_b > 5.0f * len_a) {
3195 len_b = 5.0f * len_a;
3204 float ydiff1 =
prev->vec[1][1] - bezt->
vec[1][1];
3205 float ydiff2 =
next->vec[1][1] - bezt->
vec[1][1];
3206 if ((ydiff1 <= 0.0f && ydiff2 <= 0.0f) || (ydiff1 >= 0.0f && ydiff2 >= 0.0f)) {
3207 bezt->
vec[0][1] = bezt->
vec[1][1];
3211 if (ydiff1 <= 0.0f) {
3212 if (
prev->vec[1][1] > bezt->
vec[0][1]) {
3213 bezt->
vec[0][1] =
prev->vec[1][1];
3218 if (
prev->vec[1][1] < bezt->
vec[0][1]) {
3219 bezt->
vec[0][1] =
prev->vec[1][1];
3231 float ydiff1 =
prev->vec[1][1] - bezt->
vec[1][1];
3232 float ydiff2 =
next->vec[1][1] - bezt->
vec[1][1];
3233 if ((ydiff1 <= 0.0f && ydiff2 <= 0.0f) || (ydiff1 >= 0.0f && ydiff2 >= 0.0f)) {
3234 bezt->
vec[2][1] = bezt->
vec[1][1];
3238 if (ydiff1 <= 0.0f) {
3239 if (
next->vec[1][1] < bezt->
vec[2][1]) {
3240 bezt->
vec[2][1] =
next->vec[1][1];
3241 rightviolate =
true;
3245 if (
next->vec[1][1] > bezt->
vec[2][1]) {
3246 bezt->
vec[2][1] =
next->vec[1][1];
3247 rightviolate =
true;
3253 if (leftviolate || rightviolate) {
3256 float h1_x =
p2_h1[0] - p2[0];
3257 float h2_x = p2[0] -
p2_h2[0];
3260 p2_h2[1] = p2[1] + ((p2[1] -
p2_h1[1]) / h1_x) * h2_x;
3263 p2_h1[1] = p2[1] + ((p2[1] -
p2_h2[1]) / h2_x) * h1_x;
3290 if (len_a == 0.0f) {
3293 if (len_b == 0.0f) {
3297 const float len_ratio = len_a / len_b;
3299 if (bezt->
f1 & handle_sel_flag) {
3302 len = 1.0f / len_ratio;
3328 len = 1.0f / len_ratio;
3348 if (nu->
pntsu < 2) {
3355 prev = bezt + (
a - 1);
3393 size_t num_floats = 0, num_chars = 0;
3395 while (floats && floats[num_floats]) {
3399 while (chars && chars[num_chars]) {
3409 float *fptr = (
float *)
buffer;
3411 for (
int i = 0; i < num_floats; i++, fptr +=
count) {
3415 char *cptr = (
char *)fptr;
3417 for (
int i = 0; i < num_chars; i++, cptr +=
count) {
3477 float *a0, *b0, *c0, *d0;
3478 float **
arrays[] = {&a0, &b0, &c0, &d0,
nullptr};
3479 char *is_locked, *num_unlocks;
3480 char **flagarrays[] = {&is_locked, &num_unlocks,
nullptr};
3487 memcpy(a0,
a,
sizeof(
float) * solve_count);
3488 memcpy(b0,
b,
sizeof(
float) * solve_count);
3489 memcpy(c0,
c,
sizeof(
float) * solve_count);
3490 memcpy(d0, d,
sizeof(
float) * solve_count);
3492 memset(is_locked, 0, solve_count);
3493 memset(num_unlocks, 0, solve_count);
3495 bool overshoot, unlocked;
3504 bool all =
false, locked =
false;
3506 overshoot = unlocked =
false;
3509 for (
int i = 0; i < solve_count; i++) {
3510 if (h[i] >= hmin[i] && h[i] <= hmax[i]) {
3516 float target = h[i] > hmax[i] ? hmax[i] : hmin[i];
3519 if (target != 0.0f ||
all) {
3529 }
while (overshoot && !locked);
3534 for (
int i = 0; i < solve_count; i++) {
3536 if (!is_locked[i] || num_unlocks[i] >= 2) {
3543 if ((relax > 0 && h[i] < hmax[i]) || (relax < 0 && h[i] > hmin[i])) {
3552 }
while (overshoot || unlocked);
3631 float *
a,
float *
b,
float *
c,
float *d,
const float *dy,
const float *
l,
int i)
3634 b[i] = 2.0f * (
l[i] + 1);
3635 c[i] = 1.0f /
l[i + 1];
3636 d[i] = dy[i] *
l[i] *
l[i] + dy[i + 1];
3640 float *
a,
float *
b,
float *
c,
float *d,
const float *dy,
const float *
l,
int i)
3644 c[i] = 1.0f /
l[i + 1];
3649 float *
a,
float *
b,
float *
c,
float *d,
const float *dy,
const float *
l,
int i)
3654 d[i] = dy[i] *
l[i] *
l[i];
3659 float *hmax,
float *hmin,
int i,
float dy,
bool no_reverse,
bool no_overshoot)
3663 hmax[i] =
min_ff(hmax[i], dy);
3674 hmin[i] =
max_ff(hmin[i], dy);
3677 else if (no_reverse || no_overshoot) {
3678 hmax[i] = hmin[i] = 0.0f;
3685 const float newval[3],
3690 int idx =
right ? 2 : 0;
3722 tmp[1] = bezt->
vec[1][1] + dy;
3736 float fac = dx / (hsize[0] + dx / 3.0f);
3740 return 1.0f - 3.0f * hsize[0] / dx;
3746 float *dx, *dy, *
l, *
a, *
b, *
c, *d, *h, *hmax, *hmin;
3747 float **
arrays[] = {&dx, &dy, &
l, &
a, &
b, &
c, &d, &h, &hmax, &hmin,
nullptr};
3749 int solve_count =
count;
3760 bool full_cycle = (start == 0 &&
count == total && cycle);
3764 &bezt[(start +
count > total) ? start +
count - total : start +
count - 1];
3768 bezt_last, bezt_last->
h1, start +
count == total);
3770 if (
count == 2 && !full_cycle && solve_first == solve_last) {
3785 for (
int i = 1, j = start + 1; i <
count; i++, j++) {
3786 dx[i] = bezt[j].
vec[1][0] - bezt[j - 1].
vec[1][0];
3787 dy[i] = bezt[j].
vec[1][1] - bezt[j - 1].
vec[1][1];
3790 if (cycle && j == total - 1) {
3798 dx[0] = dx[
count - 1];
3799 dy[0] = dy[
count - 1];
3801 l[0] =
l[
count - 1] = dx[1] / dx[0];
3807 for (
int i = 1; i <
count - 1; i++) {
3808 l[i] = dx[i + 1] / dx[i];
3815 for (
int i = 0; i <
count; i++) {
3820 for (
int i = 1, j = start + 1; i <
count; i++, j++) {
3821 clamped_prev = clamped_cur;
3824 if (cycle && j == total - 1) {
3829 bezier_clamp(hmax, hmin, i - 1, dy[i], clamped_prev, clamped_prev);
3830 bezier_clamp(hmax, hmin, i, dy[i] *
l[i], clamped_cur, clamped_cur);
3835 float first_handle_adj = 0.0f, last_handle_adj = 0.0f;
3839 int i = solve_count =
count - 1;
3841 hmin[0] =
max_ff(hmin[0], hmin[i]);
3842 hmax[0] =
min_ff(hmax[0], hmax[i]);
3844 solve_first = solve_last =
true;
3875 for (
int i = 1; i <
count - 1; i++) {
3882 if (
count > 2 || solve_last) {
3883 b[1] +=
l[1] * first_handle_adj;
3886 if (
count > 2 || solve_first) {
3887 b[
count - 2] += last_handle_adj;
3895 h[
count - 1] = h[0];
3898 for (
int i = 1, j = start + 1; i <
count - 1; i++, j++) {
3899 bool end = (j == total - 1);
3935 int search_base = 0;
3938 for (
int i = 1; i < total - 1; i++) {
3946 if (search_base == 0) {
3954 int start = search_base,
count = 1;
3956 for (
int i = 1, j = start + 1; i < total; i++, j++) {
3958 if (j == total - 1 && cyclic) {
3988 const bool is_fcurve,
3989 const char smoothing)
4009 for (i = nu->
pntsu, bezt = nu->
bezt; i--; bezt++) {
4027 if (nu->
pntsu > 1) {
4036 if (nu->
pntsu > 1) {
4037 const char h1_back = bezt->
h1, h2_back = bezt->
h2;
4051 const bool use_handle,
4052 const bool use_around_local)
4056 #define SEL_F1 (1 << 0)
4057 #define SEL_F2 (1 << 1)
4058 #define SEL_F3 (1 << 2)
4061 if (bezt->
f1 & sel_flag) {
4064 if (bezt->
f2 & sel_flag) {
4067 if (bezt->
f3 & sel_flag) {
4075 if (use_around_local) {
4127 const float eps = 0.0001f;
4128 const float eps_sq =
eps *
eps;
4130 if (nu ==
nullptr || nu->
bezt ==
nullptr) {
4140 bool align =
false, leftsmall =
false, rightsmall =
false;
4143 if (flag == 0 || (bezt1->
f1 & flag)) {
4163 if (flag == 0 || (bezt1->
f3 & flag)) {
4230 if (bezt->
h1 != bezt->
h2) {
4254 else if (code == 6) {
4298 const bool calc_length,
4309 bool changed =
false;
4311 for (
a = nu->pntsu, bezt = nu->bezt;
a--; bezt++) {
4313 const bool h1_select = (bezt->
f1 & flag) == flag;
4314 const bool h2_select = (bezt->
f3 & flag) == flag;
4316 if (h1_select || h2_select) {
4318 float co1_back[3], co2_back[3];
4379 a = nu->pntsu * nu->pntsv;
4391 bool changed =
false;
4395 for (
int i = 0; i < nu->pntsu; i++) {
4397 uint8_t old_f1 = bezt->
f1, old_f2 = bezt->
f2, old_f3 = bezt->
f3;
4403 changed |= (old_f1 != bezt->
f1) || (old_f2 != bezt->
f2) || (old_f3 != bezt->
f3);
4407 for (
int i = 0; i < nu->pntsu * nu->pntsv; i++) {
4412 changed |= (old_f1 != bp->
f1);
4424 float *fp1, *fp2, *tempf;
4434 bezt2 = bezt1 + (
a - 1);
4440 if (bezt1 != bezt2) {
4446 if (bezt1 != bezt2) {
4453 if (bezt1 != bezt2) {
4467 else if (nu->
pntsv == 1) {
4470 bp2 = bp1 + (
a - 1);
4472 while (bp1 != bp2 &&
a > 0) {
4483 if (nu->
pntsu & 1) {
4492 fp2 = fp1 + (
a - 1);
4494 while (fp1 != fp2 &&
a > 0) {
4495 SWAP(
float, *fp1, *fp2);
4507 fp2[0] =
fabsf(fp1[1] - fp1[0]);
4518 fp1[0] = fp1[-1] + fp2[0];
4530 bp2 = bp1 + (
a - 1);
4533 while (bp1 != bp2 &&
a > 0) {
4545 float *co = vert_coords[0];
4549 for (
int i = 0; i < nu->pntsu; i++, bezt++) {
4559 const BPoint *bp = nu->bp;
4560 for (
int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
4574 vert_len,
sizeof(*vert_coords), __func__);
4576 *r_vert_len = vert_len;
4581 const float (*vert_coords)[3],
4582 const float mat[4][4],
4583 const bool constrain_2d)
4585 const float *co = vert_coords[0];
4591 for (
int i = 0; i < nu->pntsu; i++, bezt++) {
4603 for (
int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
4618 const float (*vert_coords)[3],
4619 const bool constrain_2d)
4621 const float *co = vert_coords[0];
4627 for (
int i = 0; i < nu->pntsu; i++, bezt++) {
4639 for (
int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
4663 for (
int i = 0; i < nu->pntsu; i++, bezt++) {
4674 const BPoint *bp = nu->bp;
4676 for (
int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
4683 *r_vert_len = vert_len;
4693 for (
int i = 0; i < nu->pntsu; i++, bezt++) {
4694 bezt->
tilt = key[9];
4702 for (
int i = 0; i < nu->pntsu * nu->pntsv; i++, bp++) {
4716 int *r_points_needed)
4726 int points_needed = 0;
4728 const int remainder = pnts % (
order - 1);
4729 points_needed = remainder > 0 ?
order - 1 - remainder : 0;
4732 points_needed =
order + 1 - pnts;
4734 if (points_needed) {
4735 *r_points_needed = points_needed;
4751 const size_t maxncpy)
4755 pnts,
order, flag,
type, is_surf, &points_needed);
4757 const char *msg_template =
nullptr;
4768 msg_template =
TIP_(
"At least two points required");
4771 msg_template =
TIP_(
"Must have more control points than Order");
4774 msg_template =
TIP_(
"%d more %s row(s) needed for Bezier");
4777 msg_template =
TIP_(
"%d more point(s) needed for Bezier");
4781 BLI_snprintf(message_dst, maxncpy, msg_template, points_needed,
dir == 0 ?
"U" :
"V");
4815 bool changed =
false;
4825 bool changed =
false;
4835 const bool use_handles,
4836 const char **r_err_msg)
4851 bezt->
f1 = bezt->
f2 = bezt->
f3 = bp->
f1;
4880 nr = use_handles ? (3 * nu->
pntsu) : nu->
pntsu;
4887 (use_handles ==
false)) {
4901 for (
c = 0;
c < 3;
c++, f++) {
4940 if (r_err_msg !=
nullptr) {
4941 *r_err_msg =
"At least 6 points required for conversion";
4996 if (nu ==
nullptr) {
5015 void *vert =
nullptr;
5052 void *vert =
nullptr;
5073 return (*r_vert !=
nullptr);
5104 ListBase temp_nurb_lb = {
nullptr,
nullptr};
5112 nurb_lb = &temp_nurb_lb;
5140 for (bezt = nu->bezt; i--; bezt++) {
5148 i = nu->pntsu * nu->pntsv;
5150 for (bp = nu->bp; i--; bp++) {
5160 return (total != 0);
5176 const float mat[4][4],
5178 const bool do_props,
5179 const float unit_scale)
5190 for (bezt = nu->bezt; i--; bezt++) {
5195 bezt->
radius *= unit_scale;
5197 if (!is_uniform_scaled) {
5206 i = nu->pntsu * nu->pntsv;
5207 for (bp = nu->bp; i--; bp++) {
5210 bp->
radius *= unit_scale;
5216 if (do_keys && cu->
key) {
5218 float *fp = (
float *)kb->data;
5219 int n = kb->totelem;
5228 fp[10] *= unit_scale;
5237 fp[4] *= unit_scale;
5260 for (
BezTriple *bezt = nu->bezt; i--; bezt++) {
5267 int i = nu->pntsu * nu->pntsv;
5268 for (
BPoint *bp = nu->bp; i--; bp++) {
5274 if (do_keys && cu->
key) {
5276 float *fp = (
float *)kb->data;
5277 int n = kb->totelem;
5305 for (
int i = cu->
len_char32 - 1; i >= 0; i--, info++) {
5313 if (nu->mat_nr && nu->mat_nr >= index) {
5326 for (
int i = cu->
len_char32 - 1; i >= 0; i--, info++) {
5327 if (info->
mat_nr == index) {
5334 if (nu->mat_nr == index) {
5349 for (
int i = cu->
len_char32 - 1; i >= 0; i--, info++) {
5369 for (i = cu->
len_char32 - 1; i >= 0; i--, info++) {
5370 if (info->
mat_nr > max_idx) {
5379 if (nu->mat_nr > max_idx) {
5396 const short remap_len_short = (short)remap_len;
5398 #define MAT_NR_REMAP(n) \
5399 if (n < remap_len_short) { \
5400 BLI_assert(n >= 0 && remap[n] < remap_len_short); \
5407 int charinfo_len, i;
5412 charinfo_len = ef->
len;
5419 for (i = 0; i <= charinfo_len; i++) {
5420 if (strinfo[i].
mat_nr > 0) {
5456 struct rctf *r_rect)
5467 float h1[2], h2[2], len1, len2,
len, fac;
5470 h1[0] =
v1[0] -
v2[0];
5471 h1[1] =
v1[1] -
v2[1];
5473 h2[0] = v4[0] - v3[0];
5474 h2[1] = v4[1] - v3[1];
5481 len = v4[0] -
v1[0];
5482 len1 =
fabsf(h1[0]);
5483 len2 =
fabsf(h2[0]);
5486 if ((len1 + len2) == 0.0f) {
5493 if ((len1 + len2) >
len) {
5494 fac =
len / (len1 + len2);
5496 v2[0] = (
v1[0] - fac * h1[0]);
5497 v2[1] = (
v1[1] - fac * h1[1]);
5499 v3[0] = (v4[0] - fac * h2[0]);
5500 v3[1] = (v4[1] - fac * h2[1]);
typedef float(TangentPoint)[2]
void BKE_animdata_blend_read_data(struct BlendDataReader *reader, struct AnimData *adt)
void BKE_animdata_blend_write(struct BlendWriter *writer, struct AnimData *adt)
#define CU_DO_RADIUS(cu, nu)
int eBezTriple_Flag__Alias
void BKE_curveprofile_blend_read(struct BlendDataReader *reader, struct CurveProfile *profile)
struct CurveProfile * BKE_curveprofile_copy(const struct CurveProfile *profile)
void BKE_curveprofile_blend_write(struct BlendWriter *writer, const struct CurveProfile *profile)
void BKE_curveprofile_free(struct CurveProfile *profile)
display list (or rather multi purpose list) stuff.
@ IDTYPE_FLAGS_APPEND_IS_REUSABLE
void key_curve_position_weights(float t, float data[4], int type)
struct ID * BKE_id_copy_ex(struct Main *bmain, const struct ID *id, struct ID **r_newid, int flag)
void * BKE_libblock_alloc(struct Main *bmain, short type, const char *name, int flag) ATTR_WARN_UNUSED_RESULT
void BKE_id_blend_write(struct BlendWriter *writer, struct ID *id)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(_data, _id_super, _cb_flag)
General operations, lookup, etc. for blender objects.
void BKE_boundbox_init_from_minmax(struct BoundBox *bb, const float min[3], const float max[3])
struct VFont * BKE_vfont_builtin_get(void)
bool BKE_vfont_to_curve_ex(struct Object *ob, struct Curve *cu, int mode, struct ListBase *r_nubase, const char32_t **r_text, int *r_text_len, bool *r_text_free, struct CharTrans **r_chartransdata)
void BLI_endian_switch_float_array(float *val, int size) ATTR_NONNULL(1)
bool BLI_ghash_remove(GHash *gh, const void *key, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
BLI_INLINE bool BLI_listbase_is_empty(const struct ListBase *lb)
#define LISTBASE_FOREACH(type, var, list)
#define LISTBASE_FOREACH_MUTABLE(type, var, list)
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
int BLI_findindex(const struct ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BLI_insertlinkbefore(struct ListBase *listbase, void *vnextlink, void *vnewlink) ATTR_NONNULL(1)
void * BLI_findlink(const struct ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
MINLINE float saacos(float fac)
MINLINE float max_ff(float a, float b)
MINLINE int min_ii(int a, int b)
MINLINE float min_ff(float a, float b)
MINLINE int max_ii(int a, int b)
MINLINE int mod_i(int i, int n)
float dist_squared_to_line_v3(const float p[3], const float l1[3], const float l2[3])
bool is_uniform_scaled_m4(const float m[4][4])
void mul_m4_v3(const float M[4][4], float r[3])
float mat4_to_scale(const float M[4][4])
void mul_v3_m4v3(float r[3], const float M[4][4], const float v[3])
void interp_qt_qtqt(float q[4], const float a[4], const float b[4], float t)
float tri_to_quat(float q[4], const float a[3], const float b[3], const float c[3])
void axis_angle_to_quat(float r[4], const float axis[3], float angle)
void vec_to_quat(float q[4], const float vec[3], short axis, short upflag)
float normalize_qt(float q[4])
void mul_qt_v3(const float q[4], float r[3])
void mul_qt_qtqt(float q[4], const float a[4], const float b[4])
void copy_qt_qt(float q[4], const float a[4])
bool BLI_tridiagonal_solve_cyclic(const float *a, const float *b, const float *c, const float *d, float *r_x, int count)
Solve a possibly cyclic tridiagonal system using the Sherman-Morrison formula.
MINLINE bool compare_v3v3(const float a[3], const float b[3], float limit) ATTR_WARN_UNUSED_RESULT
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
MINLINE float normalize_v3(float r[3])
MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void mul_v2_fl(float r[2], float f)
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE bool is_zero_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void negate_v3(float r[3])
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
void mid_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void swap_v3_v3(float a[3], float b[3])
MINLINE void copy_v3_fl(float r[3], float f)
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
MINLINE void zero_v3(float r[3])
float angle_normalized_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void add_v3_v3(float r[3], const float a[3])
void dist_ensure_v3_v3fl(float v1[3], const float v2[3], float dist)
void bisect_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3])
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL()
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
#define INIT_MINMAX(min, max)
#define ARRAY_HAS_ITEM(arr_item, arr_start, arr_len)
#define UNUSED_VARS_NDEBUG(...)
#define SET_FLAG_FROM_TEST(value, test, flag)
#define MEMCMP_STRUCT_AFTER_IS_ZERO(struct_var, member)
#define POINTER_OFFSET(v, ofs)
#define MEMCPY_STRUCT_AFTER(struct_dst, struct_src, member)
#define BLO_read_data_address(reader, ptr_p)
#define BLO_write_id_struct(writer, struct_name, id_address, id)
#define BLO_write_struct(writer, struct_name, data_ptr)
void BLO_read_list(BlendDataReader *reader, struct ListBase *list)
void BLO_write_float_array(BlendWriter *writer, uint num, const float *data_ptr)
#define BLO_read_id_address(reader, lib, id_ptr_p)
#define BLO_write_struct_array(writer, struct_name, array_size, data_ptr)
#define BLO_expand(expander, id)
bool BLO_read_requires_endian_switch(BlendDataReader *reader)
void BLO_write_raw(BlendWriter *writer, size_t size_in_bytes, const void *data_ptr)
void BLO_read_pointer_array(BlendDataReader *reader, void **ptr_p)
void BLO_write_pointer_array(BlendWriter *writer, uint num, const void *data_ptr)
#define BLT_I18NCONTEXT_ID_CURVE_LEGACY
struct Depsgraph Depsgraph
bool DEG_is_active(const struct Depsgraph *depsgraph)
void DEG_debug_print_eval(struct Depsgraph *depsgraph, const char *function_name, const char *object_name, const void *object_address)
void DEG_id_tag_update(struct ID *id, int flag)
struct ID * DEG_get_original_id(struct ID *id)
#define FILTER_ID_CU_LEGACY
#define BEZT_IS_AUTOH(bezt)
#define BEZT_ISSEL_ANY(bezt)
@ HD_AUTOTYPE_LOCKED_FINAL
struct BezTriple BezTriple
#define DNA_struct_default_get(struct_name)
#define KEYELEM_ELEM_LEN_BPOINT
#define KEYELEM_FLOAT_LEN_BEZTRIPLE
#define KEYELEM_FLOAT_LEN_BPOINT
#define KEYELEM_ELEM_LEN_BEZTRIPLE
Object is a sort of wrapper for general info.
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble y1
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble y2 _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat y2 _GL_VOID_RET _GL_VOID GLint GLint GLint y2 _GL_VOID_RET _GL_VOID GLshort GLshort GLshort y2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLuint *buffer _GL_VOID_RET _GL_VOID GLdouble t _GL_VOID_RET _GL_VOID GLfloat t _GL_VOID_RET _GL_VOID GLint t _GL_VOID_RET _GL_VOID GLshort t _GL_VOID_RET _GL_VOID GLdouble GLdouble r _GL_VOID_RET _GL_VOID GLfloat GLfloat r _GL_VOID_RET _GL_VOID GLint GLint r _GL_VOID_RET _GL_VOID GLshort GLshort r _GL_VOID_RET _GL_VOID GLdouble GLdouble r
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble x2
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble right
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint i1
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei stride
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble y2 _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat y2 _GL_VOID_RET _GL_VOID GLint GLint GLint y2 _GL_VOID_RET _GL_VOID GLshort GLshort GLshort y2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLuint *buffer _GL_VOID_RET _GL_VOID GLdouble t _GL_VOID_RET _GL_VOID GLfloat t _GL_VOID_RET _GL_VOID GLint t _GL_VOID_RET _GL_VOID GLshort t _GL_VOID_RET _GL_VOID GLdouble t
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint order
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble v1
Read Guarded memory(de)allocation.
#define MEM_recallocN(vmemh, len)
static void smooth_iter(CorrectiveSmoothModifierData *csmd, Mesh *mesh, float(*vertexCos)[3], uint verts_num, const float *smooth_weights, uint iterations)
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position CLAMP
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a point
__forceinline bool all(const avxb &b)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
ATTR_WARN_UNUSED_RESULT const BMLoop * l
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
ATTR_WARN_UNUSED_RESULT const BMVert * v
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
static T sum(const btAlignedObjectArray< T > &items)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
void BKE_nurb_handles_autocalc(Nurb *nu, uint8_t flag)
static void bevel_list_flip_tangents(BevList *bl)
static void makeknots(Nurb *nu, short uv)
void BKE_nurb_handle_calc_simple_auto(Nurb *nu, BezTriple *bezt)
bool BKE_nurbList_flag_set_from_flag(ListBase *editnurb, uint8_t from_flag, uint8_t flag)
static void basisNurb(float t, short order, int pnts, const float *knots, float *basis, int *start, int *end)
void BKE_nurb_handle_calc_simple(Nurb *nu, BezTriple *bezt)
void BKE_curve_batch_cache_dirty_tag(Curve *cu, int mode)
void BKE_nurb_index_to_uv(Nurb *nu, int index, int *r_u, int *r_v)
void BKE_nurb_handles_calc(Nurb *nu)
Nurb * BKE_nurb_copy(Nurb *src, int pntsu, int pntsv)
static void bezier_eq_noaccel_left(float *a, float *b, float *c, float *d, const float *dy, const float *l, int i)
void BKE_curve_translate(Curve *cu, const float offset[3], const bool do_keys)
static void nurbList_handles_swap_select(Nurb *nu)
BPoint * BKE_nurb_bpoint_get_next(Nurb *nu, BPoint *bp)
void BKE_curve_rect_from_textbox(const struct Curve *cu, const struct TextBox *tb, struct rctf *r_rect)
static void make_bevel_list_segment_2D(BevList *bl)
void BKE_curve_editNurb_free(Curve *cu)
static void * allocate_arrays(int count, float ***floats, char ***chars, const char *name)
bool BKE_curve_center_median(Curve *cu, float cent[3])
void BKE_nurb_makeFaces(const Nurb *nu, float *coord_array, int rowstride, int resolu, int resolv)
static void curve_editNurb_keyIndex_cv_free_cb(void *val)
void BKE_curve_smooth_flag_set(Curve *cu, const bool use_smooth)
IDTypeInfo IDType_ID_CU_LEGACY
void BKE_curve_correct_bezpart(const float v1[2], float v2[2], float v3[2], const float v4[2])
static bool bevelinside(const BevList *bl1, const BevList *bl2)
void BKE_nurb_project_2d(Nurb *nu)
static void bevel_list_calc_bisect(BevList *bl)
void BKE_curve_texspace_ensure(Curve *cu)
bool BKE_nurb_order_clamp_u(struct Nurb *nu)
static void curve_init_data(ID *id)
static void free_arrays(void *buffer)
void BKE_nurbList_handles_autocalc(ListBase *editnurb, uint8_t flag)
void BKE_curve_material_remap(Curve *cu, const unsigned int *remap, unsigned int remap_len)
static void make_bevel_list_3D_minimum_twist(BevList *bl)
void BKE_nurb_minmax(const Nurb *nu, bool use_radius, float min[3], float max[3])
static void curve_blend_read_data(BlendDataReader *reader, ID *id)
static void curve_foreach_id(ID *id, LibraryForeachIDData *data)
void BKE_curve_transform_ex(Curve *cu, const float mat[4][4], const bool do_keys, const bool do_props, const float unit_scale)
void BKE_nurb_handles_test(Nurb *nu, const bool use_handle, const bool use_around_local)
static void curve_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int flag)
static void forward_diff_bezier_cotangent(const float p0[3], const float p1[3], const float p2[3], const float p3[3], float p[3], int it, int stride)
static void bevel_list_smooth(BevList *bl, int smooth_iter)
void BKE_nurb_free(Nurb *nu)
void BKE_curve_nurbs_vert_coords_apply_with_mat4(ListBase *lb, const float(*vert_coords)[3], const float mat[4][4], const bool constrain_2d)
void BKE_curve_init(Curve *cu, const short curve_type)
static void make_bevel_list_segment_3D(BevList *bl)
Nurb * BKE_curve_nurb_active_get(Curve *cu)
static void curve_blend_read_lib(BlendLibReader *reader, ID *id)
void BKE_curve_type_test(Object *ob)
static void make_bevel_list_3D_tangent(BevList *bl)
void BKE_curve_bevelList_free(ListBase *bev)
void BKE_curve_nurb_active_set(Curve *cu, const Nurb *nu)
static int vergxcobev(const void *a1, const void *a2)
void BKE_curve_texspace_calc(Curve *cu)
static void make_bevel_list_2D(BevList *bl)
static bool is_free_auto_point(BezTriple *bezt)
void BKE_nurb_bpoint_calc_plane(struct Nurb *nu, BPoint *bp, float r_plane[3])
Curve * BKE_curve_add(Main *bmain, const char *name, int type)
bool BKE_nurb_check_valid_uv(const Nurb *nu)
void(* BKE_curve_batch_cache_free_cb)(Curve *cu)
void BKE_curve_batch_cache_free(Curve *cu)
void BKE_nurb_makeCurve(const Nurb *nu, float *coord_array, float *tilt_array, float *radius_array, float *weight_array, int resolu, int stride)
float BKE_nurb_calc_length(const Nurb *nu, int resolution)
void BKE_curve_transform(Curve *cu, const float mat[4][4], const bool do_keys, const bool do_props)
ListBase * BKE_curve_editNurbs_get(Curve *cu)
bool BKE_nurb_type_convert(Nurb *nu, const short type, const bool use_handles, const char **r_err_msg)
void BKE_curve_editNurb_keyIndex_free(GHash **keyindex)
bool BKE_curve_center_bounds(Curve *cu, float cent[3])
static void make_bevel_list_3D_zup(BevList *bl)
void BKE_curve_nurb_vert_active_set(Curve *cu, const Nurb *nu, const void *vert)
static void calchandlesNurb_intern(Nurb *nu, eBezTriple_Flag handle_sel_flag, bool skip_align)
void BKE_nurb_knot_calc_u(Nurb *nu)
void BKE_nurb_handle_smooth_fcurve(BezTriple *bezt, int total, bool cyclic)
unsigned int BKE_curve_calc_coords_axis_len(const unsigned int bezt_array_len, const unsigned int resolu, const bool is_cyclic, const bool use_cyclic_duplicate_endpoint)
static float bezier_calc_handle_adj(float hsize[2], float dx)
static void bevel_list_apply_tilt(BevList *bl)
void BKE_curve_nurbs_vert_coords_get(const ListBase *lb, float(*vert_coords)[3], int vert_len)
void BKE_curve_dimension_update(Curve *cu)
void BKE_nurbList_handles_set(ListBase *editnurb, const char code)
void BKE_curve_nurbs_key_vert_tilts_apply(ListBase *lb, const float *key)
void BKE_nurbList_duplicate(ListBase *lb1, const ListBase *lb2)
bool BKE_curve_minmax(Curve *cu, bool use_radius, float min[3], float max[3])
static bool tridiagonal_solve_with_limits(float *a, float *b, float *c, float *d, float *h, const float *hmin, const float *hmax, int solve_count)
void BKE_nurb_handle_calc(BezTriple *bezt, BezTriple *prev, BezTriple *next, const bool is_fcurve, const char smoothing)
void BKE_nurb_bpoint_calc_normal(struct Nurb *nu, BPoint *bp, float r_normal[3])
static void calcknots(float *knots, const int pnts, const short order, const short flag)
static void bezier_lock_unknown(float *a, float *b, float *c, float *d, int i, float value)
static void bezier_handle_calc_smooth_fcurve(BezTriple *bezt, int total, int start, int count, bool cycle)
void BKE_curve_forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride)
static void bezier_eq_noaccel_right(float *a, float *b, float *c, float *d, const float *dy, const float *l, int i)
void BKE_nurbList_free(ListBase *lb)
static void curve_blend_write(BlendWriter *writer, ID *id, const void *id_address)
void BKE_curve_editfont_free(Curve *cu)
bool BKE_nurb_check_valid_v(const Nurb *nu)
static void calchandleNurb_intern(BezTriple *bezt, const BezTriple *prev, const BezTriple *next, eBezTriple_Flag handle_sel_flag, bool is_fcurve, bool skip_align, char fcurve_smoothing)
int BKE_nurbList_verts_count(const ListBase *nurb)
void BKE_curve_nurbs_vert_coords_apply(ListBase *lb, const float(*vert_coords)[3], const bool constrain_2d)
static void bevlist_firstlast_direction_calc_from_bpoint(const Nurb *nu, BevList *bl)
void BKE_curve_material_index_remove(Curve *cu, int index)
int BKE_nurb_index_from_uv(Nurb *nu, int u, int v)
void BKE_curve_bevelList_make(Object *ob, const ListBase *nurbs, const bool for_render)
void BKE_curve_forward_diff_tangent_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride)
void BKE_curve_calc_coords_axis(const BezTriple *bezt_array, const unsigned int bezt_array_len, const unsigned int resolu, const bool is_cyclic, const bool use_cyclic_duplicate_endpoint, const unsigned int axis, const unsigned int stride, float *r_points)
static void nurb_handles_calc__align_selected(Nurb *nu)
void BKE_nurb_knot_calc_v(Nurb *nu)
static void make_bevel_list_3D(BevList *bl, int smooth_iter, int twist_mode)
static bool bezier_check_solve_end_handle(BezTriple *bezt, char htype, bool end)
short BKE_curve_type_get(const Curve *cu)
Nurb * BKE_nurb_duplicate(const Nurb *nu)
void BKE_nurb_bezt_handle_test(BezTriple *bezt, const eBezTriple_Flag__Alias sel_flag, const bool use_handle, const bool use_around_local)
void(* BKE_curve_batch_cache_dirty_tag_cb)(Curve *cu, int mode)
bool BKE_curve_material_index_used(const Curve *cu, int index)
BPoint * BKE_nurb_bpoint_get_prev(Nurb *nu, BPoint *bp)
void BKE_nurb_direction_switch(Nurb *nu)
static void curve_blend_read_expand(BlendExpander *expander, ID *id)
void BKE_curve_nurb_vert_active_validate(Curve *cu)
void BKE_curve_material_index_clear(Curve *cu)
BoundBox * BKE_curve_boundbox_get(Object *ob)
void BKE_curve_eval_geometry(Depsgraph *depsgraph, Curve *curve)
const ListBase * BKE_curve_editNurbs_get_for_read(const Curve *cu)
bool BKE_curve_nurb_vert_active_get(Curve *cu, Nurb **r_nu, void **r_vert)
bool BKE_nurbList_index_get_co(ListBase *nurb, const int index, float r_co[3])
bool BKE_nurb_check_valid_u(const Nurb *nu)
void BKE_nurb_bezierPoints_add(Nurb *nu, int number)
static float bezier_relax_direction(const float *a, const float *b, const float *c, const float *d, const float *h, int i, int count)
void BKE_nurbList_flag_set(ListBase *editnurb, uint8_t flag, bool set)
static void bezier_output_handle_inner(BezTriple *bezt, bool right, const float newval[3], bool endpoint)
static NURBSValidationStatus nurb_check_valid(const int pnts, const short order, const short flag, const short type, const bool is_surf, int *r_points_needed)
static void curve_free_data(ID *id)
static int cu_isectLL(const float v1[3], const float v2[3], const float v3[3], const float v4[3], short cox, short coy, float *lambda, float *mu, float vec[3])
static void bezier_restore_equation(float *a, float *b, float *c, float *d, const float *a0, const float *b0, const float *c0, const float *d0, int i)
void * BKE_curve_vert_active_get(Curve *cu)
bool BKE_nurb_valid_message(const int pnts, const short order, const short flag, const short type, const bool is_surf, const int dir, char *message_dst, const size_t maxncpy)
static void minimum_twist_between_two_points(BevPoint *current_point, BevPoint *previous_point)
void BKE_curve_editNurb_keyIndex_delCV(GHash *keyindex, const void *cv)
int BKE_nurbList_verts_count_without_handles(const ListBase *nurb)
BezTriple * BKE_nurb_bezt_get_prev(Nurb *nu, BezTriple *bezt)
static void bezier_output_handle(BezTriple *bezt, bool right, float dy, bool endpoint)
float(* BKE_curve_nurbs_key_vert_coords_alloc(const ListBase *lb, float *key, int *r_vert_len))[3]
bool BKE_nurb_order_clamp_v(struct Nurb *nu)
static void switch_endian_knots(Nurb *nu)
static void calc_bevel_sin_cos(float x1, float y1, float x2, float y2, float *r_sina, float *r_cosa)
void BKE_nurb_bezt_calc_plane(struct Nurb *nu, BezTriple *bezt, float r_plane[3])
int BKE_curve_nurb_vert_index_get(const Nurb *nu, const void *vert)
static void bezier_eq_continuous(float *a, float *b, float *c, float *d, const float *dy, const float *l, int i)
static void bezier_clamp(float *hmax, float *hmin, int i, float dy, bool no_reverse, bool no_overshoot)
void BKE_nurb_bezt_calc_normal(struct Nurb *UNUSED(nu), BezTriple *bezt, float r_normal[3])
static void tilt_bezpart(const BezTriple *prevbezt, const BezTriple *bezt, const Nurb *nu, float *tilt_array, float *radius_array, float *weight_array, int resolu, int stride)
@ MorePointsThanOrderRequired
@ AtLeastTwoPointsRequired
@ MorePointsForBezierRequired
@ MoreRowsForBezierRequired
float(* BKE_curve_nurbs_vert_coords_alloc(const ListBase *lb, int *r_vert_len))[3]
const ListBase * BKE_curve_nurbs_get_for_read(const Curve *cu)
void BKE_nurb_handle_calc_ex(BezTriple *bezt, BezTriple *prev, BezTriple *next, const eBezTriple_Flag__Alias handle_sel_flag, const bool is_fcurve, const char smoothing)
void BKE_nurbList_handles_recalculate(ListBase *editnurb, const bool calc_length, const uint8_t flag)
BezTriple * BKE_nurb_bezt_get_next(Nurb *nu, BezTriple *bezt)
bool BKE_curve_material_index_validate(Curve *cu)
void BKE_nurb_points_add(Nurb *nu, int number)
ListBase * BKE_curve_nurbs_get(Curve *cu)
const Depsgraph * depsgraph
SyclQueue void void * src
SyclQueue void void size_t num_bytes void
static bool is_cyclic(const Nurb *nu)
ccl_global float * buffer
ccl_gpu_kernel_postfix ccl_global float int int int int float threshold
ccl_gpu_kernel_postfix ccl_global float int int int int float bool int offset
void *(* MEM_malloc_arrayN)(size_t len, size_t size, const char *str)
void(* MEM_freeN)(void *vmemh)
void *(* MEM_dupallocN)(const void *vmemh)
void *(* MEM_calloc_arrayN)(size_t len, size_t size, const char *str)
void *(* MEM_callocN)(size_t len, const char *str)
void *(* MEM_mallocN)(size_t len, const char *str)
INLINE Rall1d< T, V, S > cos(const Rall1d< T, V, S > &arg)
vec_base< T, 3 > cross(const vec_base< T, 3 > &a, const vec_base< T, 3 > &b)
T length(const vec_base< T, Size > &a)
SymEdge< T > * prev(const SymEdge< T > *se)
vec_base< float, 3 > float3
static RawVector< RawArray< int64_t, 0 > > arrays
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
char edit_data_from_original
struct CurveProfile * bevel_profile
struct EditFont * editfont
struct CharInfo * strinfo
struct Object * textoncurve
EditFontSelBox * selboxes
struct CharInfo * textbufinfo
struct CurveCache * curve_cache