use of spacegraph.space2d.phys.fracture.util.MyList in project narchy by automenta.
the class Fracture method smash.
/**
* Rozbije objekt. Upravi objekt world tak, ze vymaze triesteny objekt
* a nahradi ho fragmentami na zaklade nastaveneho materialu a clenskych
* premennych.
*
* @param dt casova dlzka framu
*/
public void smash(Smasher smasher, float dt) {
Shape s = f1.shape;
if (s == null)
return;
if (contact == null) {
// riesi sa staticky prvok, ktory ma priliz maly obsah
b1.setType(BodyType.DYNAMIC);
return;
}
Dynamics2D w = b1.W;
Polygon p = f1.polygon;
if (p == null) {
switch(s.m_type) {
case POLYGON:
PolygonShape ps = (PolygonShape) s;
Tuple2f[] vertices = ps.vertex;
int n = ps.vertices;
p = new Polygon(n);
for (int i = 0; i < n; ++i) {
p.add(vertices[n - i - 1]);
}
break;
case CIRCLE:
CircleShape cs = (CircleShape) s;
p = new Polygon(CIRCLEVERTICES);
float radius = cs.radius;
double u = Math.PI * 2 / CIRCLEVERTICES;
// upravim radius tak, aby bola zachovana velkost obsahu
radius = (float) Math.sqrt(u / Math.sin(u)) * radius;
Tuple2f center = cs.center;
for (int i = 0; i < CIRCLEVERTICES; ++i) {
// uhol
double j = u * i;
float sin = (float) Math.sin(j);
float cos = (float) Math.cos(j);
Tuple2f v = new v2(sin, cos).scaled(radius).added(center);
p.add(v);
}
break;
default:
throw new RuntimeException("Dany typ tvaru nepodporuje stiepenie");
}
}
// sila v zavislosti na pevnosti telesa
float mConst = f1.material.m_rigidity / normalImpulse;
// true, ak f2 je v objekte contact ako m_fixtureA
boolean fixA = f1 == contact.aFixture;
float oldAngularVelocity = fixA ? contact.m_angularVelocity_bodyA : contact.m_angularVelocity_bodyB;
Tuple2f oldLinearVelocity = fixA ? contact.m_linearVelocity_bodyA : contact.m_linearVelocity_bodyB;
b1.setAngularVelocity((b1.velAngular - oldAngularVelocity) * mConst + oldAngularVelocity);
b1.setLinearVelocity(b1.vel.sub(oldLinearVelocity).scaled(mConst).added(oldLinearVelocity));
if (!w.isFractured(f2) && b2.type == BodyType.DYNAMIC && !b2.m_fractureTransformUpdate) {
// ak sa druhy objekt nerozbija, tak sa jej nahodia povodne hodnoty (TREBA MODIFIKOVAT POHYB OBJEKTU, KTORY SPOSOBUJE ROZPAD)
oldAngularVelocity = !fixA ? contact.m_angularVelocity_bodyA : contact.m_angularVelocity_bodyB;
oldLinearVelocity = !fixA ? contact.m_linearVelocity_bodyA : contact.m_linearVelocity_bodyB;
b2.setAngularVelocity((b2.velAngular - oldAngularVelocity) * mConst + oldAngularVelocity);
b2.setLinearVelocity(b2.vel.sub(oldLinearVelocity).scaled(mConst).added(oldLinearVelocity));
b2.setTransform(b2.transformPrev.pos.add(b2.vel.scale(dt)), b2.transformPrev.angle());
// osetruje jbox2d od posuvania telesa pri rieseni kolizie
b2.m_fractureTransformUpdate = true;
}
Tuple2f localPoint = Transform.mulTrans(b1, point);
Tuple2f b1Vec = b1.getLinearVelocityFromWorldPoint(point);
Tuple2f b2Vec = b2.getLinearVelocityFromWorldPoint(point);
Tuple2f localVelocity = b2Vec.subbed(b1Vec);
localVelocity.scaled(dt);
// rodeli to
Polygon[] fragment = m.split(smasher, p, localPoint, localVelocity, normalImpulse);
if (fragment.length <= 1) {
// nerozbilo to na ziadne fragmenty
return;
}
// definuje tela fragmentov - tie maju vsetky rovnaku definiciu (preberaju parametre z povodneho objektu)
BodyDef bodyDef = new BodyDef();
// pozicia
bodyDef.position.set(b1.pos);
// otocenie
bodyDef.angle = b1.angle();
bodyDef.fixedRotation = b1.isFixedRotation();
bodyDef.angularDamping = b1.m_angularDamping;
bodyDef.allowSleep = b1.isSleepingAllowed();
FixtureDef fd = new FixtureDef();
// trenie
fd.friction = f1.friction;
// odrazivost
fd.restitution = f1.restitution;
fd.isSensor = f1.isSensor;
fd.density = f1.density;
// odstrani fragmentacne predmety/cele teleso
List<Fixture> fixtures = new FasterList<>();
if (f1.polygon != null) {
for (Fixture f = b1.fixtures; f != null; f = f.next) {
if (f.polygon == f1.polygon) {
fixtures.add(f);
}
}
} else {
fixtures.add(f1);
}
for (Fixture f : fixtures) {
b1.removeFixture(f);
}
if (b1.fixtureCount == 0) {
w.removeBody(b1);
}
// prida fragmenty do simulacie
MyList<Body2D> newbodies = new MyList<>();
for (Polygon pg : fragment) {
// vytvori tela, prida fixtury, poriesi konvexnu dekompoziciu
if (pg.isCorrect()) {
if (pg instanceof Fragment) {
Polygon[] convex = pg.convexDecomposition();
bodyDef.type = BodyType.DYNAMIC;
for (Polygon pgx : convex) {
Body2D f_body = w.addBody(bodyDef);
pgx.flip();
PolygonShape ps = new PolygonShape();
ps.set(pgx.getArray(), pgx.size());
fd.shape = ps;
fd.polygon = null;
fd.material = f1.material;
// .m_fragments; //rekurzivne stiepenie
f_body.addFixture(fd);
f_body.setAngularVelocity(b1.velAngular);
f_body.setLinearVelocity(b1.getLinearVelocityFromLocalPoint(f_body.getLocalCenter()));
newbodies.add(f_body);
}
} else {
fd.material = // .m_fragments; //rekurzivne stiepenie
f1.material;
bodyDef.type = b1.getType();
Body2D f_body = w.addBody(bodyDef);
PolygonFixture pf = new PolygonFixture(pg);
f_body.addFixture(pf, fd);
f_body.setLinearVelocity(b1.getLinearVelocityFromLocalPoint(f_body.getLocalCenter()));
f_body.setAngularVelocity(b1.velAngular);
newbodies.add(f_body);
}
}
}
// zavola sa funkcia z fraction listeneru (pokial je nadefinovany)
FractureListener fl = w.getContactManager().m_fractureListener;
if (fl != null) {
fl.action(m, normalImpulse, newbodies);
}
}
use of spacegraph.space2d.phys.fracture.util.MyList in project narchy by automenta.
the class Smasher method zjednotenie.
/**
* Vezme polygony a vrati ich zjednotenie. Plygony su navzajom disjunknte
* avsak dotykaju sa bodmi hranami, ktore maju referencnu zavislost.
*
* @param polygony
* @return Vrati List zjednotenych polygonov.
*/
private static MyList<Polygon> zjednotenie(MyList<Fragment> polygony) {
HashTabulka<GraphVertex> graf = new HashTabulka<>();
for (Polygon p : polygony) {
for (int i = 1; i <= p.size(); ++i) {
Tuple2f v = p.cycleGet(i);
GraphVertex vertex = graf.get(v);
if (vertex == null) {
vertex = new GraphVertex(v);
graf.add(vertex);
vertex.first = p;
} else {
vertex.polygonCount++;
vertex.second = p;
}
}
}
for (Polygon p : polygony) {
for (int i = 0; i < p.size(); ++i) {
GraphVertex v1 = graf.get(p.get(i));
GraphVertex v2 = graf.get(p.cycleGet(i + 1));
if (v1.polygonCount == 1 || v2.polygonCount == 1 || (v1.polygonCount <= 2 && v2.polygonCount <= 2 && !((v1.first == v2.first && v1.second == v2.second) || (v1.first == v2.second && v1.second == v2.first)))) {
v1.next = v2;
v2.prev = v1;
}
}
}
MyList<Polygon> vysledok = new MyList<>();
GraphVertex[] arr = graf.toArray(new GraphVertex[graf.size()]);
for (GraphVertex v : arr) {
if (v.next != null && !v.visited) {
Polygon p = new Polygon();
for (GraphVertex iterator = v; !iterator.visited; iterator = iterator.next) {
if (PlatformMathUtils.siteDef(iterator.next.value, iterator.value, iterator.prev.value) != 0) {
p.add(iterator.value);
}
iterator.visited = true;
}
vysledok.add(p);
}
}
return vysledok;
}
use of spacegraph.space2d.phys.fracture.util.MyList in project narchy by automenta.
the class Smasher method calculate.
/**
* Vrati prienik voronoi diagramu a polygonu.
*
* @param focee
* @param p Kopia polygonu, moze byt modifikovana
* @param contactPoint Bod dotyku
* @param ic Funkcionalny interface, ktory definuje, ci fragment patri,
* alebo nepatri do mnoziny ulomkov
*/
public void calculate(Polygon p, Tuple2f[] focee, Tuple2f contactPoint, IContains ic) {
this.focee = focee;
this.p = p;
// Geometry geom = new Geometry(foceeAll, p);
List<Fragment> list = getVoronoi();
List<EdgePolygon> polygonEdgesList = new FasterList<>();
HashTabulka<EdgeDiagram> diagramEdges = new HashTabulka<>();
HashTabulka<EdgePolygon> polygonEdges = new HashTabulka<>();
// vlozim hrany polygonu do hashovacej tabulky hran polygonu
int count = p.size();
for (int i = 1; i <= count; i++) {
Tuple2f p1 = p.get(i - 1);
Tuple2f p2 = p.get(i == count ? 0 : i);
EdgePolygon e = new EdgePolygon(p1, p2);
polygonEdges.add(e);
polygonEdgesList.add(e);
}
// vlozim hrany diagramu do hashovacej tabulky hran diagramu
for (Fragment pp : list) {
count = pp.size();
for (int i = 1; i <= count; i++) {
Tuple2f p1 = pp.get(i - 1);
Tuple2f p2 = pp.get(i == count ? 0 : i);
EdgeDiagram e = new EdgeDiagram(p1, p2);
EdgeDiagram alternative = diagramEdges.get(e);
if (alternative == null) {
diagramEdges.add(e);
e.d1 = pp;
} else {
alternative.d2 = pp;
}
}
}
AEdge[][] allEdges = new AEdge[][] { diagramEdges.toArray(new AEdge[diagramEdges.size()]), polygonEdges.toArray(new AEdge[polygonEdges.size()]) };
diagramEdges.clear();
polygonEdges.clear();
List<EVec2> vectorList = new FasterList<>();
for (AEdge[] array : allEdges) {
for (AEdge e : array) {
EVec2 v1 = new EVec2(e.p1);
EVec2 v2 = new EVec2(e.p2);
v1.e = e;
v2.e = e;
if (v1.p.y < v2.p.y) {
v1.start = true;
} else {
v2.start = true;
}
vectorList.add(v1);
vectorList.add(v2);
}
}
EVec2[] vectors = vectorList.toArray(new EVec2[vectorList.size()]);
// zotriedim body
Arrays.sort(vectors);
for (EVec2 e : vectors) {
if (e.e instanceof EdgeDiagram) {
if (e.start) {
EdgeDiagram ex = (EdgeDiagram) e.e;
diagramEdges.add(ex);
// for (EdgePolygon px : polygonEdges.toArray(new EdgePolygon[polygonEdges.size()])) {
// process(px, ex);
// }
polygonEdges.forEach(px -> process(px, ex));
} else {
diagramEdges.remove(e.e);
}
} else {
// je instanciou EdgePolygon
if (e.start) {
EdgePolygon px = (EdgePolygon) e.e;
polygonEdges.add(px);
diagramEdges.forEach(ex -> process(px, ex));
// for (EdgeDiagram ex : diagramEdges.toArray(new EdgeDiagram[diagramEdges.size()]))
// process(px, ex);
} else {
polygonEdges.remove(e.e);
}
}
}
for (Fragment pol : list) {
pol.resort();
int pn = pol.size();
for (int i = 0; i < pn; i++) {
Tuple2f v = pol.get(i);
if (v instanceof Vec2Intersect) {
Vec2Intersect vi = (Vec2Intersect) v;
if (vi.p1 == pol) {
vi.i1 = i;
} else {
vi.i2 = i;
}
}
}
}
Polygon polygonAll = new Polygon();
for (EdgePolygon ex : polygonEdgesList) {
polygonAll.add(ex.p1);
ex.list.sort(c);
polygonAll.add(ex.list);
}
for (int i = 0; i < polygonAll.size(); i++) {
Tuple2f v = polygonAll.get(i);
if (v instanceof Vec2Intersect) {
((Vec2Intersect) v).index = i;
}
}
MyList<Fragment> allIntersections = new MyList<>();
// ostatne algoritmy generovali diery - tento je najlepsi - najdem najblizsi bod na hrane polygonu a zistim kolizny fargment - od neho prehladavam do sirky a kontrolujem vzdialenost a viditelnost (jednoduche, ciste)
precalc_values();
for (Fragment ppp : list) {
List<Fragment> intsc = getIntersections(ppp, polygonAll);
if (intsc == null) {
// cely polygon sa nachadza vnutri fragmentu
fragments = new Polygon[] { p };
return;
}
allIntersections.addAll(intsc);
}
table.clear();
// vytvorim hashovaciu tabulku hran
for (Fragment f : allIntersections) {
for (int i = 0; i < f.size(); ++i) {
Tuple2f v1 = f.get(i);
Tuple2f v2 = f.cycleGet(i + 1);
EdgeDiagram e = new EdgeDiagram(v1, v2);
EdgeDiagram e2 = table.get(e);
if (e2 != null) {
e = e2;
e.d2 = f;
} else {
e.d1 = f;
table.add(e);
}
}
}
// rozdelim polygony na 2 mnoziny - na tie, ktore budu ulomky a tie, ktore budu spojene a drzat spolu
final double[] distance = { Double.MAX_VALUE };
final Fragment[] startPolygon = { null };
final Tuple2f[] kolmicovyBod = { null };
MyList<EdgeDiagram> allEdgesPolygon = new MyList<>();
// EdgeDiagram[] ee = table.toArray(new EdgeDiagram[table.size()]);
table.forEach(ep -> {
if (ep.d2 == null) {
// toto sa nahradi vzorcom na vypocet vzdialenosti body od usecky
Tuple2f vv = ep.kolmicovyBod(contactPoint);
double newDistance = contactPoint.distanceSq(vv);
if (newDistance <= distance[0]) {
distance[0] = newDistance;
kolmicovyBod[0] = vv;
startPolygon[0] = ep.d1;
}
allEdgesPolygon.add(ep);
}
});
MyList<Fragment> ppx = new MyList<>();
ppx.add(startPolygon[0]);
EdgeDiagram epx = new EdgeDiagram(null, null);
HashTabulka<Fragment> vysledneFragmenty = new HashTabulka<>();
startPolygon[0].visited = true;
while (!ppx.isEmpty()) {
Fragment px = ppx.get(0);
vysledneFragmenty.add(px);
for (int i = 0; i < px.size(); ++i) {
Tuple2f v1 = px.get(i);
Tuple2f v2 = px.cycleGet(i + 1);
epx.p1 = v1;
epx.p2 = v2;
EdgeDiagram ep = table.get(epx);
Fragment opposite = ep.d1 == px ? ep.d2 : ep.d1;
if (opposite != null && !opposite.visited) {
Tuple2f centroid = opposite.centroid();
opposite.visited = true;
if (ic.contains(centroid)) {
boolean intersection = false;
for (EdgeDiagram edge : allEdgesPolygon) {
// neberie do uvahy hrany polygonu
if (edge.d1 != startPolygon[0] && edge.d2 != startPolygon[0] && edge.intersectAre(centroid, kolmicovyBod[0])) {
intersection = true;
break;
}
}
// tu bude podmienka - ci ten polygon vezmem do uvahy, ak hej, priplnim ho do MyListu
if (!intersection) {
ppx.add(opposite);
}
}
}
}
ppx.removeAt(0);
}
Fragment[] fragmentsArray = vysledneFragmenty.toArray(new Fragment[vysledneFragmenty.size()]);
MyList<Fragment> fragmentsBody = new MyList<>();
for (Fragment fx : allIntersections) {
if (!vysledneFragmenty.contains(fx)) {
fragmentsBody.add(fx);
}
}
MyList<Polygon> result = zjednotenie(fragmentsBody);
result.add(fragmentsArray);
fragments = new Polygon[result.size()];
result.addToArray(fragments);
}
use of spacegraph.space2d.phys.fracture.util.MyList in project narchy by automenta.
the class Box2DTests method drawBody.
private void drawBody(Body2D body) {
if (body.getType() == BodyType.DYNAMIC) {
g.setColor(Color.LIGHT_GRAY);
} else {
g.setColor(Color.GRAY);
}
Tuple2f v = new Vec2();
MyList<PolygonFixture> generalPolygons = new MyList<>();
for (Fixture f = body.fixtures; f != null; f = f.next) {
PolygonFixture pg = f.polygon;
if (pg != null) {
if (!generalPolygons.contains(pg)) {
generalPolygons.add(pg);
}
} else {
Shape shape = f.shape();
switch(shape.m_type) {
case POLYGON:
PolygonShape poly = (PolygonShape) shape;
for (int i = 0; i < poly.vertices; ++i) {
body.getWorldPointToOut(poly.vertex[i], v);
Point p = getPoint(v);
x[i] = p.x;
y[i] = p.y;
}
g.fillPolygon(x, y, poly.vertices);
break;
case CIRCLE:
CircleShape circle = (CircleShape) shape;
float r = circle.radius;
body.getWorldPointToOut(circle.center, v);
Point p = getPoint(v);
int wr = (int) (r * zoom);
g.fillOval(p.x - wr, p.y - wr, wr * 2, wr * 2);
break;
case EDGE:
EdgeShape edge = (EdgeShape) shape;
Tuple2f v1 = edge.m_vertex1;
Tuple2f v2 = edge.m_vertex2;
Point p1 = getPoint(v1);
Point p2 = getPoint(v2);
g.drawLine(p1.x, p1.y, p2.x, p2.y);
break;
}
}
}
if (generalPolygons.size() != 0) {
PolygonFixture[] polygonArray = generalPolygons.toArray(new PolygonFixture[generalPolygons.size()]);
for (PolygonFixture poly : polygonArray) {
int n = poly.size();
int[] x = new int[n];
int[] y = new int[n];
for (int i = 0; i < n; ++i) {
body.getWorldPointToOut(poly.get(i), v);
Point p = getPoint(v);
x[i] = p.x;
y[i] = p.y;
}
g.fillPolygon(x, y, n);
}
}
}
Aggregations