29 : m_softBodySolver(0), m_worldInfo(worldInfo)
44 for (
int i = 0, ni = node_count; i < ni; ++i)
50 n.
m_im = m ? *m++ : 1;
59 : m_worldInfo(worldInfo)
148 const Node* n[] = {node0, node1};
152 if ((l.
m_n[0] == n[0] && l.
m_n[1] == n[1]) ||
153 (l.
m_n[0] == n[1] && l.
m_n[1] == n[0]))
171 for (
int j = 0; j < 3; ++j)
173 if ((f.
m_n[j] == n[0]) ||
174 (f.
m_n[j] == n[1]) ||
180 if (c == 7)
return (
true);
270 n.
m_im = m > 0 ? 1 / m : 0;
304 if ((!bcheckexist) || (!
checkLink(node0, node1)))
391 appendAnchor(node, body, local, disableCollisionBetweenLinkedBodies, influence);
397 if (disableCollisionBetweenLinkedBodies)
439 static const btMatrix3x3 iwiStatic(0, 0, 0, 0, 0, 0, 0, 0, 0);
584 const bool as_lift = kLF > 0;
585 const bool as_drag = kDG > 0;
586 const bool as_aero = as_lift || as_drag;
618 btScalar tri_area = 0.5f * n.m_area;
620 fDrag = 0.5f * kDG * medium.
m_density * rel_v2 * tri_area * n_dot_v * (-rel_v_nrm);
624 if (0 < n_dot_v && n_dot_v < 0.98480f)
625 fLift = 0.5f * kLF * medium.
m_density * rel_v_len * tri_area *
btSqrt(1.0f - n_dot_v * n_dot_v) * (nrm.
cross(rel_v_nrm).
cross(rel_v_nrm));
629 btScalar del_v_by_fDrag_len2 = del_v_by_fDrag.length2();
632 if (del_v_by_fDrag_len2 >= v_len2 && del_v_by_fDrag_len2 > 0)
634 btScalar del_v_by_fDrag_len = del_v_by_fDrag.length();
636 fDrag *=
btScalar(0.8) * (v_len / del_v_by_fDrag_len);
652 const btScalar c0 = n.m_area * dvn * rel_v2 / 2;
654 force += nrm * (-c1 * kLF);
671 const bool as_lift = kLF > 0;
672 const bool as_drag = kDG > 0;
673 const bool as_aero = as_lift || as_drag;
706 fDrag = 0.5f * kDG * medium.
m_density * rel_v2 * tri_area * n_dot_v * (-rel_v_nrm);
710 if (0 < n_dot_v && n_dot_v < 0.98480f)
711 fLift = 0.5f * kLF * medium.
m_density * rel_v_len * tri_area *
btSqrt(1.0f - n_dot_v * n_dot_v) * (nrm.
cross(rel_v_nrm).
cross(rel_v_nrm));
716 for (
int j = 0; j < 3; ++j)
725 if (del_v_by_fDrag_len2 >= v_len2 && del_v_by_fDrag_len2 > 0)
729 fDrag *=
btScalar(0.8) * (v_len / del_v_by_fDrag_len);
749 force += nrm * (-c1 * kLF);
791 m_nodes[node].m_im = mass > 0 ? 1 / mass : 0;
829 for (
int j = 0; j < 3; ++j)
868 for (
int j = 0; j < 4; ++j)
891 for (
int j = 0; j < 4; ++j)
996 if (
m_nodes[i].m_im <= 0) tmass += kmass;
1070 for (
int i = 0, ni = cluster->
m_nodes.size(); i < ni; ++i)
1074 return (com * cluster->
m_imass);
1095 cluster->
m_lv += li;
1097 cluster->
m_av += ai;
1123 cluster->
m_av += ai;
1163 const unsigned inf = (~(unsigned)0) >> 1;
1164 unsigned* adj =
new unsigned[n * n];
1166#define IDX(_x_, _y_) ((_y_)*n + (_x_))
1167 for (j = 0; j < n; ++j)
1169 for (i = 0; i < n; ++i)
1173 adj[
IDX(i, j)] = adj[
IDX(j, i)] = inf;
1177 adj[
IDX(i, j)] = adj[
IDX(j, i)] = 0;
1185 adj[
IDX(ia, ib)] = 1;
1186 adj[
IDX(ib, ia)] = 1;
1207 for (
int ii = 0; ii < nodeLinks.
size(); ii++)
1211 for (
int jj = 0; jj < nodeLinks[ii].m_links.
size(); jj++)
1213 int k = nodeLinks[ii].m_links[jj];
1214 for (
int kk = 0; kk < nodeLinks[k].m_links.
size(); kk++)
1216 int j = nodeLinks[k].m_links[kk];
1219 const unsigned sum = adj[
IDX(i, k)] + adj[
IDX(k, j)];
1221 if (adj[
IDX(i, j)] >
sum)
1233 for (
int k = 0; k < n; ++k)
1235 for (j = 0; j < n; ++j)
1237 for (i = j + 1; i < n; ++i)
1239 const unsigned sum = adj[
IDX(i, k)] + adj[
IDX(k, j)];
1240 if (adj[
IDX(i, j)] >
sum)
1251 for (j = 0; j < n; ++j)
1253 for (i = j + 1; i < n; ++i)
1255 if (adj[
IDX(i, j)] == (
unsigned)distance)
1272 unsigned long seed = 243703;
1273#define NEXTRAND (seed = (1664525L * seed + 1013904223L) & 0xffffffff)
1334 const btScalar w = 2 - btMin<btScalar>(1, iterations / slope);
1339 for (i = 0; i < k; ++i)
1349 c = centers[i] + (c - centers[i]) * w;
1350 changed |= ((c - centers[i]).length2() >
SIMD_EPSILON);
1360 for (
int j = 1; j < k; ++j)
1371 }
while (changed && (iterations < maxiterations));
1387 for (
int j = 0; j < 3; ++j)
1389 const int cid = cids[idx[j]];
1390 for (
int q = 1; q < 3; ++q)
1392 const int kid = idx[(j + q) % 3];
1393 if (cids[kid] != cid)
1435 for (
int j = 0; j < 4; j++)
1452 for (
int j = 0; j < 3; ++j)
1473 bool connected =
false;
1476 for (
int i = 0; !connected && i < cla->
m_nodes.size(); i++)
1478 for (
int j = 0; j < clb->
m_nodes.size(); j++)
1523 edges(
int(l.
m_n[0] - nbase),
int(l.
m_n[1] - nbase)) = -1;
1528 edges(
int(f.
m_n[0] - nbase),
int(f.
m_n[1] - nbase)) = -1;
1529 edges(
int(f.
m_n[1] - nbase),
int(f.
m_n[2] - nbase)) = -1;
1530 edges(
int(f.
m_n[2] - nbase),
int(f.
m_n[0] - nbase)) = -1;
1533 for (i = 0; i < ncount; ++i)
1535 for (j = i + 1; j < ncount; ++j)
1537 if (edges(i, j) == -1)
1554 const btScalar f = (ma + mb) / (ma + mb + mc);
1555 a.
m_im = 1 / (ma * f);
1556 b.
m_im = 1 / (mb * f);
1588 const int idx[] = {int(feat.
m_n[0] - nbase),
1589 int(feat.
m_n[1] - nbase)};
1590 if ((idx[0] < ncount) && (idx[1] < ncount))
1592 const int ni = edges(idx[0], idx[1]);
1609 const int idx[] = {int(feat.
m_n[0] - nbase),
1610 int(feat.
m_n[1] - nbase),
1611 int(feat.
m_n[2] - nbase)};
1612 for (j = 2, k = 0; k < 3; j = k++)
1614 if ((idx[j] < ncount) && (idx[k] < ncount))
1616 const int ni = edges(idx[j], idx[k]);
1620 const int l = (k + 1) % 3;
1640 const int pcount = ncount;
1643 cnodes.
resize(ncount, 0);
1645 for (i = 0; i < ncount; ++i)
1648 if ((i >= pcount) || (
btFabs(ifn->
Eval(x)) < accurary))
1666 const int id[] = {int(
m_links[i].m_n[0] - nbase),
1667 int(
m_links[i].m_n[1] - nbase)};
1669 if (cnodes[
id[0]] && cnodes[
id[1]])
1676 if (((ifn->
Eval(
m_nodes[
id[0]].m_x) < accurary) &&
1683 for (
int j = 0; j < 2; ++j)
1685 int cn = cnodes[int(l.
m_n[j] - nbase)];
1694 if ((ifn->
Eval(n[0]->
m_x) < accurary) &&
1695 (ifn->
Eval(n[1]->
m_x) < accurary) &&
1696 (ifn->
Eval(n[2]->
m_x) < accurary))
1698 for (
int j = 0; j < 3; ++j)
1700 int cn = cnodes[int(n[j] - nbase)];
1712 for (
int j = 0; j < 2; ++j) ranks[
int(
m_links[i].m_n[j] - nbase)]++;
1716 for (
int j = 0; j < 3; ++j) ranks[
int(
m_faces[i].m_n[j] - nbase)]++;
1720 const int id[] = {int(
m_links[i].m_n[0] - nbase),
1721 int(
m_links[i].m_n[1] - nbase)};
1722 const bool sg[] = {ranks[
id[0]] == 1,
1734 for(i=nnodes-1;i>=0;--i)
1741 for(
int i=0;i<nnodes;++i) map[i]=i;
1742 PointersToIndices(
this);
1743 for(
int i=0,ni=todelete.
size();i<ni;++i)
1747 int& b=map[--nnodes];
1752 IndicesToPointers(
this,&map[0]);
1790 pft[0]->
m_n[1] = pn[mtch];
1791 pft[1]->
m_n[0] = pn[1 - mtch];
1797 for (
int k = 2, l = 0; l < 3; k = l++)
1804 pft[0]->
m_n[l] = pn[mtch];
1805 pft[1]->
m_n[k] = pn[1 - mtch];
1806 appendLink(pn[0], pft[0]->m_n[(l + 1) % 3], pft[0]->m_material,
true);
1807 appendLink(pn[1], pft[0]->m_n[(l + 1) % 3], pft[0]->m_material,
true);
1829 results.
body =
this;
1897 for (
int c = 0; c < 3; c++)
1899 if (deltaV[c] > clampDeltaV)
1901 deltaV[c] = clampDeltaV;
1903 if (deltaV[c] < -clampDeltaV)
1905 deltaV[c] = -clampDeltaV;
2068 for (
int isolve = 0; isolve < iterations; ++isolve)
2086 const int nb = bodies.
size();
2090 for (i = 0; i < nb; ++i)
2094 for (i = 0; i < nb; ++i)
2096 bodies[i]->prepareClusters(iterations);
2098 for (i = 0; i < iterations; ++i)
2101 for (
int j = 0; j < nb; ++j)
2103 bodies[j]->solveClusters(sor);
2106 for (i = 0; i < nb; ++i)
2108 bodies[i]->cleanupClusters();
2134 const btScalar t = rayFromToTriangle(m_rayFrom, m_rayTo, m_rayNormalizedDirection,
2139 if ((t > 0) && (t < m_mint))
2150 const btVector3& rayNormalizedDirection,
2166 if ((t > teps) && (t < maxt))
2168 const btVector3 hit = rayFrom + rayNormalizedDirection * t;
2183#define PTR2IDX(_p_, _b_) reinterpret_cast<btSoftBody::Node*>((_p_) - (_b_))
2191 m_nodes[i].m_leaf->data = *(
void**)&i;
2206 m_faces[i].m_leaf->data = *(
void**)&i;
2215 for (
int j = 0; j <
m_notes[i].m_rank; ++j)
2226#define IDX2PTR(_p_, _b_) map ? (&(_b_)[map[(((char*)_p_) - (char*)0)]]) : (&(_b_)[(((char*)_p_) - (char*)0)])
2258 for (
int j = 0; j <
m_notes[i].m_rank; ++j)
2314 int tetfaces[4][3] = {{0, 1, 2}, {0, 1, 3}, {1, 2, 3}, {0, 2, 3}};
2315 for (
int f = 0; f < 4; f++)
2317 int index0 = tetfaces[f][0];
2318 int index1 = tetfaces[f][1];
2319 int index2 = tetfaces[f][2];
2432 btVector3 v0 = b - a, v1 = c - a, v2 = p - a;
2438 btScalar denom = d00 * d11 - d01 * d01;
2439 bary.
setY((d11 * d20 - d01 * d21) / denom);
2440 bary.
setZ((d00 * d21 - d01 * d20) / denom);
2467#ifdef CACHE_PREV_COLLISION
2470 for (
int i = 0; i < 3; ++i)
2495 for (
int i = 0; i < 3; ++i)
2502#ifdef USE_QUADRATURE
2514 if (local_dst < dst)
2539 for (
int i = 0; i < 3; ++i)
2629 for (
int d = 0; d < 3; ++d)
2631 if (
m_nodes[i].m_x[d] > maxs[d])
2633 if (
m_nodes[i].m_x[d] < mins[d])
2670 Apq[0] = Apq[1] = Apq[2] =
btVector3(0, 0, 0);
2672 Apq[1].setY(eps * 2);
2673 Apq[2].setZ(eps * 3);
2678 Apq[0] += a.
x() * b;
2679 Apq[1] += a.
y() * b;
2680 Apq[2] += a.
z() * b;
2720 for (
int j = 0; j < 3; ++j)
2722 const int index = (int)(f.
m_n[j] - &
m_nodes[0]);
2747 for (
int j = 0; j < 3; ++j)
2755 m_nodes[i].m_area *= 0.3333333f;
2790 for (
int j = 0; j < c.
m_nodes.size(); ++j)
2810 ii[0] = ii[1] = ii[2] =
btVector3(0, 0, 0);
2814 for (i = 0, ni = c.
m_nodes.size(); i < ni; ++i)
2819 ii[0][0] += m * (q[1] + q[2]);
2820 ii[1][1] += m * (q[0] + q[2]);
2821 ii[2][2] += m * (q[0] + q[1]);
2822 ii[0][1] -= m * k[0] * k[1];
2823 ii[0][2] -= m * k[0] * k[2];
2824 ii[1][2] -= m * k[1] * k[2];
2827 ii[1][0] = ii[0][1];
2828 ii[2][0] = ii[0][2];
2829 ii[2][1] = ii[1][2];
2856 const int n = c.
m_nodes.size();
2863 m[0] = m[1] = m[2] =
btVector3(0, 0, 0);
2868 for (
int i = 0; i < c.
m_nodes.size(); ++i)
2890 c.
m_invwi=c.m_xform.getBasis().scaled(iin)*c.m_xform.getBasis().transpose();
2893 for (
int i = 0; i < n; ++i)
2898 c.
m_invwi[0][0] += m * (q[1] + q[2]);
2899 c.
m_invwi[1][1] += m * (q[0] + q[2]);
2900 c.
m_invwi[2][2] += m * (q[0] + q[1]);
2901 c.
m_invwi[0][1] -= m * k[0] * k[1];
2902 c.
m_invwi[0][2] -= m * k[0] * k[2];
2903 c.
m_invwi[1][2] -= m * k[1] * k[2];
2917 for (i = 0; i < n; ++i)
2935 for (
int j = 0; j < c.
m_nodes.size(); ++j)
2947 for (
int j = 1; j < n; ++j)
3027 for (
int j = 0; j < c.
m_nodes.size(); ++j)
3037 for (i = 0; i < deltas.
size(); ++i)
3041 m_nodes[i].m_x += deltas[i] / weights[i];
3056 for (
int j = 0; j < c.
m_nodes.size(); ++j)
3076 m_links[i].Feature::m_material->m_kLST = k;
3082 btScalar unit_simplex_measure = 1./6.;
3115 s.
m_trace = C[0].getX() + C[1].getY() + C[2].getZ();
3131 m_bodies[0].activate();
3132 m_bodies[1].activate();
3138 static const btScalar maxdrift = 4;
3140 m_rpos[0] = m_bodies[0].xform() * m_refs[0];
3141 m_rpos[1] = m_bodies[1].xform() * m_refs[1];
3142 m_drift =
Clamp(m_rpos[0] - m_rpos[1], maxdrift) * m_erp / dt;
3143 m_rpos[0] -= m_bodies[0].xform().getOrigin();
3144 m_rpos[1] -= m_bodies[1].xform().getOrigin();
3145 m_massmatrix =
ImpulseMatrix(m_bodies[0].invMass(), m_bodies[0].invWorldInertia(), m_rpos[0],
3146 m_bodies[1].invMass(), m_bodies[1].invWorldInertia(), m_rpos[1]);
3149 m_sdrift = m_massmatrix * (m_drift * m_split);
3150 m_drift *= 1 - m_split;
3158 const btVector3 va = m_bodies[0].velocity(m_rpos[0]);
3159 const btVector3 vb = m_bodies[1].velocity(m_rpos[1]);
3163 impulse.
m_velocity = m_massmatrix * (m_drift + vr * m_cfm) * sor;
3164 m_bodies[0].applyImpulse(-impulse, m_rpos[0]);
3165 m_bodies[1].applyImpulse(impulse, m_rpos[1]);
3173 m_bodies[0].applyDImpulse(-m_sdrift, m_rpos[0]);
3174 m_bodies[1].applyDImpulse(m_sdrift, m_rpos[1]);
3182 m_icontrol->Prepare(
this);
3184 m_axis[0] = m_bodies[0].xform().getBasis() * m_refs[0];
3185 m_axis[1] = m_bodies[1].xform().getBasis() * m_refs[1];
3187 m_drift *=
btMin(maxdrift,
btAcos(Clamp<btScalar>(
btDot(m_axis[0], m_axis[1]), -1, +1)));
3188 m_drift *= m_erp / dt;
3189 m_massmatrix =
AngularImpulseMatrix(m_bodies[0].invWorldInertia(), m_bodies[1].invWorldInertia());
3192 m_sdrift = m_massmatrix * (m_drift * m_split);
3193 m_drift *= 1 - m_split;
3201 const btVector3 va = m_bodies[0].angularVelocity();
3202 const btVector3 vb = m_bodies[1].angularVelocity();
3205 const btVector3 vc = vr - m_axis[0] * m_icontrol->Speed(
this, sp);
3208 impulse.
m_velocity = m_massmatrix * (m_drift + vc * m_cfm) * sor;
3209 m_bodies[0].applyAImpulse(-impulse);
3210 m_bodies[1].applyAImpulse(impulse);
3218 m_bodies[0].applyDAImpulse(-m_sdrift);
3219 m_bodies[1].applyDAImpulse(m_sdrift);
3227 const bool dodrift = (m_life == 0);
3228 m_delete = (++m_life) > m_maxlife;
3231 m_drift = m_drift * m_erp / dt;
3234 m_sdrift = m_massmatrix * (m_drift * m_split);
3235 m_drift *= 1 - m_split;
3241 m_drift = m_sdrift =
btVector3(0, 0, 0);
3248 const btVector3 va = m_bodies[0].velocity(m_rpos[0]);
3249 const btVector3 vb = m_bodies[1].velocity(m_rpos[1]);
3263 if (m_bodies[0].m_soft == m_bodies[1].m_soft)
3270 if (impulse.
m_velocity.
length() < m_bodies[0].m_soft->m_maxSelfCollisionImpulse)
3275 m_bodies[0].applyImpulse(-impulse * m_bodies[0].m_soft->m_selfCollisionImpulseFactor, m_rpos[0]);
3276 m_bodies[1].applyImpulse(impulse * m_bodies[0].m_soft->m_selfCollisionImpulseFactor, m_rpos[1]);
3283 m_bodies[0].applyImpulse(-impulse, m_rpos[0]);
3284 m_bodies[1].applyImpulse(impulse, m_rpos[1]);
3293 m_bodies[0].applyDImpulse(-m_sdrift, m_rpos[0]);
3294 m_bodies[1].applyDImpulse(m_sdrift, m_rpos[1]);
3307 const bool as_lift = kLF > 0;
3308 const bool as_drag = kDG > 0;
3309 const bool as_pressure = kPR != 0;
3310 const bool as_volume = kVC > 0;
3311 const bool as_aero = as_lift ||
3317 const bool use_medium = as_aero;
3318 const bool use_volume = as_pressure ||
3327 ivolumetp = 1 /
btFabs(volume) * kPR;
3379 for (
int j = 0; j < 4; ++j)
3391 for (
int i = 0; i <= N; ++i)
3393 for (
int j = 0; i+j <= N; ++j)
3447 if (multibodyLinkCol)
3459 for (
int j = 0; j < ndof; ++j)
3485 if (multibodyLinkCol)
3487 double multiplier = 0.5;
3535 for (
int i = 0, ni = psb->
m_links.
size(); i < ni; ++i)
3558 for (
int i = 0, ni = psb->
m_links.
size(); i < ni; ++i)
3634 volume.Expand(
btVector3(basemargin, basemargin, basemargin));
3635 docollide.
psb =
this;
3639 docollide.
dynmargin = basemargin + timemargin;
3669 volume.Expand(
btVector3(basemargin, basemargin, basemargin));
3671 docollideNode.
psb =
this;
3674 docollideNode.
dynmargin = basemargin + timemargin;
3681 docollideFace.
psb =
this;
3684 docollideFace.
dynmargin = basemargin + timemargin;
3735 root->
normal = (n0+n1).safeNormalize();
3766 docollide.
psb[0] =
this;
3767 docollide.
psb[1] = psb;
3772 docollide.
psb[0] = psb;
3773 docollide.
psb[1] =
this;
3782 if (psb->
isActive() || this->isActive())
3795 docollide.
psb[0] =
this;
3796 docollide.
psb[1] = psb;
3805 docollide.
psb[0] = psb;
3806 docollide.
psb[1] =
this;
3818 docollide.
psb[0] =
this;
3819 docollide.
psb[1] = psb;
3868 if (sbd->m_materials)
3871 int numElem = sbd->m_numMaterials;
3875 for (
int i = 0; i < numElem; i++, memPtr++)
3899 int numElem = sbd->m_numNodes;
3902 for (
int i = 0; i < numElem; i++, memPtr++)
3923 int numElem = sbd->m_numLinks;
3926 for (
int i = 0; i < numElem; i++, memPtr++)
3944 int numElem = sbd->m_numFaces;
3947 for (
int i = 0; i < numElem; i++, memPtr++)
3951 for (
int j = 0; j < 3; j++)
3962 if (sbd->m_tetrahedra)
3965 int numElem = sbd->m_numTetrahedra;
3968 for (
int i = 0; i < numElem; i++, memPtr++)
3970 for (
int j = 0; j < 4; j++)
3988 int numElem = sbd->m_numAnchors;
3991 for (
int i = 0; i < numElem; i++, memPtr++)
4005 sbd->m_config.m_dynamicFriction =
m_cfg.
kDF;
4007 sbd->m_config.m_pressure =
m_cfg.
kPR;
4016 sbd->m_config.m_damping =
m_cfg.
kDP;
4017 sbd->m_config.m_poseMatch =
m_cfg.
kMT;
4019 sbd->m_config.m_volume =
m_cfg.
kVC;
4020 sbd->m_config.m_rigidContactHardness =
m_cfg.
kCHR;
4021 sbd->m_config.m_kineticContactHardness =
m_cfg.
kKHR;
4022 sbd->m_config.m_softContactHardness =
m_cfg.
kSHR;
4023 sbd->m_config.m_anchorHardness =
m_cfg.
kAHR;
4027 sbd->m_config.m_softKineticClusterHardness =
m_cfg.
kSKHR_CL;
4054 for (
int i = 0; i < numElem; i++, memPtr++)
4069 int sz =
sizeof(float);
4071 float* memPtr = (
float*)chunk->
m_oldPtr;
4072 for (
int i = 0; i < numElem; i++, memPtr++)
4086 if (sbd->m_numClusters)
4088 int numElem = sbd->m_numClusters;
4092 for (
int i = 0; i < numElem; i++, memPtr++)
4132 for (
int j = 0; j < numElem; j++, memPtr++)
4134 m_clusters[i]->m_framerefs[j].serializeFloat(*memPtr);
4143 int sz =
sizeof(float);
4145 float* memPtr = (
float*)chunk->
m_oldPtr;
4146 for (
int j = 0; j < numElem; j++, memPtr++)
4157 int sz =
sizeof(int);
4159 int* memPtr = (
int*)chunk->
m_oldPtr;
4160 for (
int j = 0; j < numElem; j++, memPtr++)
4164 *memPtr = *indexPtr;
4182 for (
int i = 0; i < numElem; i++, memPtr++)
4192 for (
int j = 0; j < 4; j++)
4199 if (
m_joints[i]->m_bodies[0].m_soft)
4204 if (
m_joints[i]->m_bodies[0].m_collisionObject)
4209 if (
m_joints[i]->m_bodies[0].m_rigid)
4215 if (
m_joints[i]->m_bodies[1].m_soft)
4220 if (
m_joints[i]->m_bodies[1].m_collisionObject)
4225 if (
m_joints[i]->m_bodies[1].m_rigid)
#define btAlignedFree(ptr)
#define btAlignedAlloc(size, alignment)
#define DISABLE_DEACTIVATION
#define WANTS_DEACTIVATION
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
static btDbvtVolume bounds(btDbvtNode **leaves, int count)
const T & btMax(const T &a, const T &b)
const T & btMin(const T &a, const T &b)
btScalar dot(const btQuaternion &q1, const btQuaternion &q2)
Calculate the dot product between two quaternions.
btQuaternion inverse(const btQuaternion &q)
Return the inverse of a quaternion.
btScalar length(const btQuaternion &q)
Return the length of a quaternion.
btScalar btAngle(const btQuaternion &q1, const btQuaternion &q2)
Return the angle between two quaternions.
bool gDisableDeactivation
btScalar gDeactivationTime
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
#define ATTRIBUTE_ALIGNED16(a)
btScalar btSqrt(btScalar y)
btScalar btFabs(btScalar x)
btScalar btAcos(btScalar x)
bool btFuzzyZero(btScalar x)
#define BT_SBMATERIAL_CODE
@ BT_JOINT_SOFT_BODY_CLUSTER
@ BT_JOINT_COLLISION_OBJECT
static T sum(const btAlignedObjectArray< T > &items)
static btMatrix3x3 OuterProduct(const btScalar *v1, const btScalar *v2, const btScalar *v3, const btScalar *u1, const btScalar *u2, const btScalar *u3, int ndof)
static btMatrix3x3 Mul(const btMatrix3x3 &a, btScalar b)
static btScalar ImplicitSolve(btSoftBody::ImplicitFn *fn, const btVector3 &a, const btVector3 &b, const btScalar accuracy, const int maxiterations=256)
static btDbvtVolume VolumeOf(const btSoftBody::Face &f, btScalar margin)
static T Lerp(const T &a, const T &b, btScalar t)
static btMatrix3x3 AngularImpulseMatrix(const btMatrix3x3 &iia, const btMatrix3x3 &iib)
static btScalar AreaOf(const btVector3 &x0, const btVector3 &x1, const btVector3 &x2)
static btVector3 generateUnitOrthogonalVector(const btVector3 &u)
static btVector3 NormalizeAny(const btVector3 &v)
static int PolarDecompose(const btMatrix3x3 &m, btMatrix3x3 &q, btMatrix3x3 &s)
static int MatchEdge(const btSoftBody::Node *a, const btSoftBody::Node *b, const btSoftBody::Node *ma, const btSoftBody::Node *mb)
static void findJacobian(const btMultiBodyLinkCollider *multibodyLinkCol, btMultiBodyJacobianData &jacobianData, const btVector3 &contact_point, const btVector3 &dir)
btSoftBody implementation by Nathanael Presson
static T BaryEval(const T &a, const T &b, const T &c, const btVector3 &coord)
static bool SameSign(const T &x, const T &y)
static void EvaluateMedium(const btSoftBodyWorldInfo *wfi, const btVector3 &x, btSoftBody::sMedium &medium)
static void ZeroInitialize(T &value)
static btVector3 ProjectOnPlane(const btVector3 &v, const btVector3 &a)
static btScalar ClusterMetric(const btVector3 &x, const btVector3 &y)
static btMatrix3x3 ImpulseMatrix(btScalar dt, btScalar ima, btScalar imb, const btMatrix3x3 &iwi, const btVector3 &r)
static void ApplyClampedForce(btSoftBody::Node &n, const btVector3 &f, btScalar dt)
static btVector3 Clamp(const btVector3 &v, btScalar maxlength)
static btMatrix3x3 Diagonal(btScalar x)
static void calculateNormalCone(btDbvntNode *root)
#define IDX2PTR(_p_, _b_)
#define PTR2IDX(_p_, _b_)
static void getBarycentric(const btVector3 &p, btVector3 &a, btVector3 &b, btVector3 &c, btVector3 &bary)
static btDbvntNode * copyToDbvnt(const btDbvtNode *n)
#define btSoftBodyDataName
#define btSoftBodyData
btSoftBody implementation by Nathanael Presson
btScalar btDot(const btVector3 &v1, const btVector3 &v2)
Return the dot product between two vectors.
btVector3 btCross(const btVector3 &v1, const btVector3 &v2)
Return the cross product of two vectors.
int size() const
return the number of elements in the array
int findLinearSearch(const T &key) const
void resize(int newsize, const T &fillData=T())
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
void remove(const T &key)
void push_back(const T &_Val)
int capacity() const
return the pre-allocated (reserved) elements, this is at least as large as the total number of elemen...
virtual void setAabb(btBroadphaseProxy *proxy, const btVector3 &aabbMin, const btVector3 &aabbMax, btDispatcher *dispatcher)=0
btCollisionObject can be used to manage collision detection objects.
bool isStaticOrKinematicObject() const
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btTransform & getWorldTransform()
btBroadphaseProxy * getBroadphaseHandle()
btTransform m_worldTransform
btCollisionShape * m_collisionShape
int getInternalType() const
reserved for Bullet internal usage
bool hasContactResponse() const
void activate(bool forceActivation=false) const
void setActivationState(int newState) const
int m_internalType
m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody,...
btScalar getFriction() const
btScalar m_deactivationTime
const btTransform & getInterpolationWorldTransform() const
const btCollisionShape * getCollisionShape() const
int getActivationState() const
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
virtual void setMargin(btScalar margin)=0
virtual btScalar getMargin() const =0
virtual void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const =0
getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t.
The btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape...
The btHashMap template class implements a generic and lightweight hashmap.
void insert(const Key &key, const Value &value)
const Value * find(const Key &key) const
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
btMatrix3x3 adjoint() const
Return the adjoint of the matrix.
btMatrix3x3 inverse() const
Return the inverse of the matrix.
btMatrix3x3 transpose() const
Return the transpose of the matrix.
void setIdentity()
Set the matrix to the identity.
btScalar determinant() const
Return the determinant of the matrix.
void serializeFloat(struct btMatrix3x3FloatData &dataOut) const
static btMultiBodyLinkCollider * upcast(btCollisionObject *colObj)
btMultiBody * m_multiBody
void fillContactJacobianMultiDof(int link, const btVector3 &contact_point, const btVector3 &normal, btScalar *jac, btAlignedObjectArray< btScalar > &scratch_r, btAlignedObjectArray< btVector3 > &scratch_v, btAlignedObjectArray< btMatrix3x3 > &scratch_m) const
void calcAccelerationDeltasMultiDof(const btScalar *force, btScalar *output, btAlignedObjectArray< btScalar > &scratch_r, btAlignedObjectArray< btVector3 > &scratch_v) const
stepVelocitiesMultiDof is deprecated, use computeAccelerationsArticulatedBodyAlgorithmMultiDof instea...
void applyDeltaVeeMultiDof(const btScalar *delta_vee, btScalar multiplier)
const btScalar * getVelocityVector() const
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
The btRigidBody is the main class for rigid body objects.
btVector3 getVelocityInLocalPoint(const btVector3 &rel_pos) const
btScalar getInvMass() const
const btCollisionShape * getCollisionShape() const
void applyImpulse(const btVector3 &impulse, const btVector3 &rel_pos)
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
const btMatrix3x3 & getInvInertiaTensorWorld() const
virtual btChunk * allocate(size_t size, int numElements)=0
virtual void * getUniquePointer(void *oldPtr)=0
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
virtual void * findPointer(void *oldPtr)=0
btMultiBodyJacobianData jacobianData_t1
btMultiBodyJacobianData jacobianData_normal
btMultiBodyJacobianData jacobianData_t2
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
static void PSolve_Links(btSoftBody *psb, btScalar kst, btScalar ti)
static void PSolve_SContacts(btSoftBody *psb, btScalar, btScalar ti)
bool checkLink(int node0, int node1) const
btScalar m_sleepingThreshold
bool checkFace(int node0, int node1, int node2) const
void advanceDeformation()
void setPose(bool bvolume, bool bframe)
bool cutLink(int node0, int node1, btScalar position)
void appendFace(int model=-1, Material *mat=0)
void setMass(int node, btScalar mass)
void interpolateRenderMesh()
btScalar m_dampingCoefficient
btAlignedObjectArray< TetraScratch > m_tetraScratchesTn
void appendLinearJoint(const LJoint::Specs &specs, Cluster *body0, Body body1)
void scale(const btVector3 &scl)
btAlignedObjectArray< bool > m_clusterConnectivity
void defaultCollisionHandler(const btCollisionObjectWrapper *pcoWrap)
btScalar getVolume() const
bool rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, sRayCast &results)
Ray casting using rayFrom and rayTo in worldspace, (not direction!)
void addVelocity(const btVector3 &velocity)
void predictMotion(btScalar dt)
void setSelfCollision(bool useSelfCollision)
void appendTetra(int model, Material *mat)
void setRestLengthScale(btScalar restLength)
void rotate(const btQuaternion &rot)
void applyClusters(bool drift)
static void PSolve_Anchors(btSoftBody *psb, btScalar kst, btScalar ti)
btSoftBodyWorldInfo * m_worldInfo
void updateArea(bool averageArea=true)
void addForce(const btVector3 &force)
void prepareClusters(int iterations)
void setCollisionQuadrature(int N)
static void clusterVImpulse(Cluster *cluster, const btVector3 &rpos, const btVector3 &impulse)
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
static void VSolve_Links(btSoftBody *psb, btScalar kst)
btVector3 evaluateCom() const
void setTotalDensity(btScalar density)
btAlignedObjectArray< const class btCollisionObject * > m_collisionDisabledObjects
static void clusterDAImpulse(Cluster *cluster, const btVector3 &impulse)
void appendNode(const btVector3 &x, btScalar m)
btTransform m_initialWorldTransform
void staticSolve(int iterations)
void setVolumeMass(btScalar mass)
btScalar m_restLengthScale
bool checkDeformableContact(const btCollisionObjectWrapper *colObjWrap, const btVector3 &x, btScalar margin, btSoftBody::sCti &cti, bool predict=false) const
void updateDeactivation(btScalar timeStep)
btAlignedObjectArray< TetraScratch > m_tetraScratches
const btVector3 & getWindVelocity()
Return the wind velocity for interaction with the air.
void addAeroForceToFace(const btVector3 &windVelocity, int faceIndex)
btAlignedObjectArray< btVector4 > m_renderNodesInterpolationWeights
void appendAngularJoint(const AJoint::Specs &specs, Cluster *body0, Body body1)
void setVolumeDensity(btScalar density)
static void clusterDCImpulse(Cluster *cluster, const btVector3 &impulse)
void transform(const btTransform &trs)
static void clusterVAImpulse(Cluster *cluster, const btVector3 &impulse)
btScalar getMass(int node) const
tMaterialArray m_materials
void setMaxStress(btScalar maxStress)
btSoftBody(btSoftBodyWorldInfo *worldInfo, int node_count, const btVector3 *x, const btScalar *m)
btSoftBody implementation by Nathanael Presson
void addAeroForceToNode(const btVector3 &windVelocity, int nodeIndex)
static btVector3 clusterCom(const Cluster *cluster)
tRContactArray m_rcontacts
void appendAnchor(int node, btRigidBody *body, bool disableCollisionBetweenLinkedBodies=false, btScalar influence=1)
btScalar m_maxSpeedSquared
void releaseCluster(int index)
void setVelocity(const btVector3 &velocity)
int generateClusters(int k, int maxiterations=8192)
generateClusters with k=0 will create a convex cluster for each tetrahedron or triangle otherwise an ...
void refine(ImplicitFn *ifn, btScalar accurary, bool cut)
void setSolver(eSolverPresets::_ preset)
Material * appendMaterial()
btAlignedObjectArray< DeformableNodeRigidAnchor > m_deformableAnchors
static void solveClusters(const btAlignedObjectArray< btSoftBody * > &bodies)
void appendNote(const char *text, const btVector3 &o, const btVector4 &c=btVector4(1, 0, 0, 0), Node *n0=0, Node *n1=0, Node *n2=0, Node *n3=0)
bool checkDeformableFaceContact(const btCollisionObjectWrapper *colObjWrap, Face &f, btVector3 &contact_point, btVector3 &bary, btScalar margin, btSoftBody::sCti &cti, bool predict=false) const
virtual int calculateSerializeBufferSize() const
static void PSolve_RContacts(btSoftBody *psb, btScalar kst, btScalar ti)
static void clusterImpulse(Cluster *cluster, const btVector3 &rpos, const Impulse &impulse)
btAlignedObjectArray< btAlignedObjectArray< const btSoftBody::Node * > > m_renderNodesParents
static void clusterDImpulse(Cluster *cluster, const btVector3 &rpos, const btVector3 &impulse)
static btVector3 clusterVelocity(const Cluster *cluster, const btVector3 &rpos)
tSContactArray m_scontacts
void(* psolver_t)(btSoftBody *, btScalar, btScalar)
void initializeClusters()
btScalar getRestLengthScale()
void randomizeConstraints()
btScalar getTotalMass() const
void appendLink(int model=-1, Material *mat=0)
void setSpringStiffness(btScalar k)
void initializeDmInverse()
void setTotalMass(btScalar mass, bool fromfaces=false)
void appendDeformableAnchor(int node, btRigidBody *body)
void updateLinkConstants()
void(* vsolver_t)(btSoftBody *, btScalar)
btAlignedObjectArray< btVector3 > m_quads
static psolver_t getSolver(ePSolver::_ solver)
bool checkContact(const btCollisionObjectWrapper *colObjWrap, const btVector3 &x, btScalar margin, btSoftBody::sCti &cti) const
void indicesToPointers(const int *map=0)
static void solveCommonConstraints(btSoftBody **bodies, int count, int iterations)
void setWindVelocity(const btVector3 &velocity)
Set a wind velocity for interaction with the air.
int generateBendingConstraints(int distance, Material *mat=0)
void translate(const btVector3 &trs)
void initializeFaceTree()
void resetLinkRestLengths()
static void clusterAImpulse(Cluster *cluster, const Impulse &impulse)
btVector3 can be used to represent 3D points and vectors.
const btScalar & getZ() const
Return the z value.
void setMax(const btVector3 &other)
Set each element to the max of the current values and the values of another btVector3.
void setZ(btScalar _z)
Set the z value.
const btScalar & w() const
Return the w value.
const btScalar & z() const
Return the z value.
btVector3 & safeNormalize()
btScalar length() const
Return the length of the vector.
btVector3 cross(const btVector3 &v) const
Return the cross product between this and another vector.
btScalar dot(const btVector3 &v) const
Return the dot product.
void serializeFloat(struct btVector3FloatData &dataOut) const
btVector3 normalized() const
Return a normalized version of this vector.
void setY(btScalar _y)
Set the y value.
void setX(btScalar _x)
Set the x value.
btScalar length2() const
Return the length of the vector squared.
const btScalar & getY() const
Return the y value.
const btScalar & x() const
Return the x value.
void setMin(const btVector3 &other)
Set each element to the min of the current values and the values of another btVector3.
const btScalar & getX() const
Return the x value.
const btScalar & y() const
Return the y value.
btAlignedObjectArray< int > m_links
btMatrix3x3FloatData m_invwi
btVector3FloatData m_vimpulses[2]
btVector3FloatData * m_framerefs
btVector3FloatData m_dimpulses[2]
btMatrix3x3FloatData m_locii
float m_maxSelfCollisionImpulse
btTransformFloatData m_framexform
float m_selfCollisionImpulseFactor
btVector3FloatData m_normal
SoftBodyMaterialData * m_material
SoftBodyMaterialData * m_material
btVector3FloatData m_accumulatedForce
btVector3FloatData m_normal
btVector3FloatData m_previousPosition
btVector3FloatData m_velocity
btVector3FloatData m_position
SoftBodyMaterialData * m_material
btMatrix3x3FloatData m_rot
btVector3FloatData * m_positions
btMatrix3x3FloatData m_aqq
btMatrix3x3FloatData m_scale
btVector3FloatData m_c0[4]
SoftBodyMaterialData * m_material
btMatrix3x3FloatData m_c0
btVector3FloatData m_localFrame
btRigidBodyData * m_rigidBody
const btCollisionShape * getCollisionShape() const
const btTransform * m_preTransform
const btCollisionObject * getCollisionObject() const
const btTransform & getWorldTransform() const
DBVT_INLINE bool isleaf() const
static btDbvtAabbMm FromMM(const btVector3 &mi, const btVector3 &mx)
static btDbvtAabbMm FromCR(const btVector3 &c, btScalar r)
DBVT_INLINE bool isinternal() const
btDbvtNode * insert(const btDbvtVolume &box, void *data)
void optimizeIncremental(int passes)
void update(btDbvtNode *leaf, int lookahead=-1)
DBVT_PREFIX void collideTV(const btDbvtNode *root, const btDbvtVolume &volume, DBVT_IPOLICY) const
static DBVT_PREFIX void rayTest(const btDbvtNode *root, const btVector3 &rayFrom, const btVector3 &rayTo, DBVT_IPOLICY)
rayTest is a re-entrant ray test, and can be called in parallel as long as the btAlignedAlloc is thre...
void remove(btDbvtNode *leaf)
DBVT_PREFIX void collideTT(const btDbvtNode *root0, const btDbvtNode *root1, DBVT_IPOLICY)
DBVT_PREFIX void selfCollideT(const btDbvntNode *root, DBVT_IPOLICY)
static btScalar SignedDistance(const btVector3 &position, btScalar margin, const btConvexShape *shape, const btTransform &wtrs, sResults &results)
btAlignedObjectArray< btScalar > m_deltaVelocitiesUnitImpulse
btAlignedObjectArray< btScalar > m_jacobians
btAlignedObjectArray< btScalar > scratch_r
btAlignedObjectArray< btMatrix3x3 > scratch_m
btAlignedObjectArray< btVector3 > scratch_v
btVector3FloatData m_refs[2]
btVector3FloatData m_relPosition[2]
btDispatcher * m_dispatcher
btSparseSdf< 3 > m_sparsesdf
btScalar m_maxDisplacement
btBroadphaseInterface * m_broadphase
void Prepare(btScalar dt, int iterations)
void Solve(btScalar dt, btScalar sor)
void Terminate(btScalar dt)
const btTransform & xform() const
void Terminate(btScalar dt)
void Prepare(btScalar dt, int iterations)
void Solve(btScalar dt, btScalar sor)
tVector3Array m_framerefs
btAlignedObjectArray< Node * > m_nodes
tPSolverArray m_psequence
tPSolverArray m_dsequence
tVSolverArray m_vsequence
virtual btScalar Eval(const btVector3 &x)=0
virtual void Prepare(btScalar dt, int iterations)
void Solve(btScalar dt, btScalar sor)
void Prepare(btScalar dt, int iterations)
void Terminate(btScalar dt)
RayFromToCaster takes a ray from, ray to (instead of direction!)
RayFromToCaster(const btVector3 &rayFrom, const btVector3 &rayTo, btScalar mxt)
void Process(const btDbvtNode *leaf)
static btScalar rayFromToTriangle(const btVector3 &rayFrom, const btVector3 &rayTo, const btVector3 &rayNormalizedDirection, const btVector3 &a, const btVector3 &b, const btVector3 &c, btScalar maxt=SIMD_INFINITY)
btVector3 m_rayNormalizedDirection
btScalar m_element_measure
@ V_TwoSided
Vertex normals are oriented toward velocity.
@ V_OneSided
Vertex normals are flipped to match velocity and lift and drag forces are applied.
@ V_TwoSidedLiftDrag
Vertex normals are flipped to match velocity.
@ F_OneSided
Face normals are flipped to match velocity and lift and drag forces are applied.
@ F_TwoSided
Vertex normals are taken as it is.
@ F_TwoSidedLiftDrag
Face normals are flipped to match velocity.
@ RContacts
Anchor solver.
@ SContacts
Rigid contacts solver.
@ VF_SS
Rigid versus soft mask.
@ Default
Vertex vs face soft vs soft handling.
@ VF_DD
Cluster soft body self collision.
@ CL_SS
Vertex vs face soft vs soft handling.
@ CL_SELF
Cluster vs cluster soft vs soft handling.
@ SVSmask
DF based rigid vs deformable faces.
@ SDF_RS
Rigid versus soft mask.
@ SDF_RD
Cluster vs convex rigid vs soft.
@ CL_RS
SDF based rigid vs soft.
@ Default
Enable debug draw.
const btCollisionObject * m_colObj
eFeature::_ feature
soft body
btScalar fraction
feature index
void ProcessColObj(btSoftBody *ps, const btCollisionObjectWrapper *colObWrap)
void ProcessSoftSoft(btSoftBody *psa, btSoftBody *psb)
btRigidBody * m_rigidBody
const btCollisionObjectWrapper * m_colObj1Wrap
btRigidBody * m_rigidBody
const btCollisionObjectWrapper * m_colObj1Wrap
btRigidBody * m_rigidBody
const btCollisionObjectWrapper * m_colObj1Wrap
btScalar Evaluate(const btVector3 &x, const btCollisionShape *shape, btVector3 &normal, btScalar margin)