pkg/box2d: 0.2.0 release

lib/src/particle/particle_system.dart

 /*******************************************************************************
  * Copyright (c) 2015, Daniel Murphy, Google
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *  * Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimer.
  *  * Redistributions in binary form must reproduce the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
@@ skipping 160 matching lines @@
         int a = system.proxyBuffer[proxy].index;
         Vector2 ap = system.positionBuffer.data[a];
         if (aabblowerBoundx <= ap.x &&
             ap.x <= aabbupperBoundx &&
             aabblowerBoundy <= ap.y &&
             ap.y <= aabbupperBoundy) {
           double d;
           final Vector2 n = _tempVec;
           d = fixture.computeDistance(ap, childIndex, n);
           if (d < system.particleDiameter) {
-            double invAm = (system.flagsBuffer.data[a] &
-                    ParticleType.b2_wallParticle) !=
-                0 ? 0 : system.getParticleInvMass();
+            double invAm =
+                (system.flagsBuffer.data[a] & ParticleType.b2_wallParticle) != 0
+                    ? 0
+                    : system.getParticleInvMass();
             final double rpx = ap.x - bp.x;
             final double rpy = ap.y - bp.y;
             double rpn = rpx * n.y - rpy * n.x;
             if (system.bodyContactCount >= system.bodyContactCapacity) {
               int oldCapacity = system.bodyContactCapacity;
               int newCapacity = system.bodyContactCount != 0
                   ? 2 * system.bodyContactCount
                   : Settings.minParticleBufferCapacity;
-              system.bodyContactBuffer = BufferUtils
-                  .reallocateBufferWithAlloc(system.bodyContactBuffer,
-                      oldCapacity, newCapacity, allocParticleBodyContact);
+              system.bodyContactBuffer = BufferUtils.reallocateBufferWithAlloc(
+                  system.bodyContactBuffer, oldCapacity, newCapacity,
+                  allocParticleBodyContact);
               system.bodyContactCapacity = newCapacity;
             }
             ParticleBodyContact contact =
                 system.bodyContactBuffer[system.bodyContactCount];
             contact.index = a;
             contact.body = b;
             contact.weight = 1 - d * system.inverseDiameter;
             contact.normal.x = -n.x;
             contact.normal.y = -n.y;
             contact.mass = 1 / (invAm + invBm + invBI * rpn * rpn);
@@ skipping 358 matching lines @@
       capacity = limitCapacity(capacity, colorBuffer.userSuppliedCapacity);
       capacity = limitCapacity(capacity, userDataBuffer.userSuppliedCapacity);
       if (internalAllocatedCapacity < capacity) {
         flagsBuffer.data = reallocateBufferInt(
             flagsBuffer, internalAllocatedCapacity, capacity, false);
         positionBuffer.data = reallocateBuffer(
             positionBuffer, internalAllocatedCapacity, capacity, false);
         velocityBuffer.data = reallocateBuffer(
             velocityBuffer, internalAllocatedCapacity, capacity, false);
         accumulationBuffer = BufferUtils.reallocateBufferFloat64Deferred(
-            accumulationBuffer, 0, internalAllocatedCapacity, capacity,
-            false);
+            accumulationBuffer, 0, internalAllocatedCapacity, capacity, false);
         accumulation2Buffer = BufferUtils.reallocateBufferWithAllocDeferred(
-            accumulation2Buffer, 0, internalAllocatedCapacity, capacity,
-            true, allocVec2);
+            accumulation2Buffer, 0, internalAllocatedCapacity, capacity, true,
+            allocVec2);
         depthBuffer = BufferUtils.reallocateBufferFloat64Deferred(
             depthBuffer, 0, internalAllocatedCapacity, capacity, true);
         colorBuffer.data = reallocateBuffer(
             colorBuffer, internalAllocatedCapacity, capacity, true);
-        groupBuffer = BufferUtils.reallocateBufferWithAllocDeferred(
-            groupBuffer, 0, internalAllocatedCapacity, capacity, false,
-            allocParticleGroup);
+        groupBuffer = BufferUtils.reallocateBufferWithAllocDeferred(groupBuffer,
+            0, internalAllocatedCapacity, capacity, false, allocParticleGroup);
         userDataBuffer.data = reallocateBuffer(
             userDataBuffer, internalAllocatedCapacity, capacity, true);
         internalAllocatedCapacity = capacity;
       }
     }
     if (count >= internalAllocatedCapacity) {
       return Settings.invalidParticleIndex;
     }
     int index = count++;
     flagsBuffer.data[index] = def.flags;
     positionBuffer.data[index].setFrom(def.position);
 //    assertNotSamePosition();
     velocityBuffer.data[index].setFrom(def.velocity);
     groupBuffer[index] = null;
     if (depthBuffer != null) {
       depthBuffer[index] = 0.0;
     }
     if (colorBuffer.data != null || def.color != null) {
       colorBuffer.data =
           requestParticleBuffer(colorBuffer.data, colorBuffer.allocClosure);
       colorBuffer.data[index].setParticleColor(def.color);
     }
     if (userDataBuffer.data != null || def.userData != null) {
       userDataBuffer.data = requestParticleBuffer(
           userDataBuffer.data, userDataBuffer.allocClosure);
       userDataBuffer.data[index] = def.userData;
     }
     if (proxyCount >= proxyCapacity) {
       int oldCapacity = proxyCapacity;
-      int newCapacity = proxyCount != 0
-          ? 2 * proxyCount
-          : Settings.minParticleBufferCapacity;
+      int newCapacity =
+          proxyCount != 0 ? 2 * proxyCount : Settings.minParticleBufferCapacity;
       proxyBuffer = BufferUtils.reallocateBufferWithAlloc(
           proxyBuffer, oldCapacity, newCapacity, allocPsProxy);
       proxyCapacity = newCapacity;
     }
     proxyBuffer[proxyCount++].index = index;
     return index;
   }
 
   // reallocate a buffer
   static List reallocateBuffer(
@@ skipping 385 matching lines @@
       contact.normal.y = invD * dy;
       contactCount++;
     }
   }
 
   void updateContacts(bool exceptZombie) {
     for (int p = 0; p < proxyCount; p++) {
       PsProxy proxy = proxyBuffer[p];
       int i = proxy.index;
       Vector2 pos = positionBuffer.data[i];
-      proxy.tag =
-          computeTag(inverseDiameter * pos.x, inverseDiameter * pos.y);
+      proxy.tag = computeTag(inverseDiameter * pos.x, inverseDiameter * pos.y);
     }
     BufferUtils.sort(proxyBuffer, 0, proxyCount);
     contactCount = 0;
     int c_index = 0;
     for (int i = 0; i < proxyCount; i++) {
       PsProxy a = proxyBuffer[i];
       int rightTag = computeRelativeTag(a.tag, 1, 0);
       for (int j = i + 1; j < proxyCount; j++) {
         PsProxy b = proxyBuffer[j];
         if (rightTag < b.tag) {
@@ skipping 404 matching lines @@
         final Vector2 vb = velocityBuffer.data[b];
         va.x -= fx;
         va.y -= fy;
         vb.x += fx;
         vb.y += fy;
       }
     }
   }
 
   void solveTensile(final TimeStep step) {
-    accumulation2Buffer =
-        requestParticleBuffer(accumulation2Buffer, allocVec2);
+    accumulation2Buffer = requestParticleBuffer(accumulation2Buffer, allocVec2);
     for (int i = 0; i < count; i++) {
       accumulationBuffer[i] = 0.0;
       accumulation2Buffer[i].setZero();
     }
     for (int k = 0; k < contactCount; k++) {
       final ParticleContact contact = contactBuffer[k];
       if ((contact.flags & ParticleType.b2_tensileParticle) != 0) {
         int a = contact.indexA;
         int b = contact.indexB;
         double w = contact.weight;
@@ skipping 206 matching lines @@
         newIndices[i] = newCount;
         if (i != newCount) {
           flagsBuffer.data[newCount] = flagsBuffer.data[i];
           positionBuffer.data[newCount].setFrom(positionBuffer.data[i]);
           velocityBuffer.data[newCount].setFrom(velocityBuffer.data[i]);
           groupBuffer[newCount] = groupBuffer[i];
           if (depthBuffer != null) {
             depthBuffer[newCount] = depthBuffer[i];
           }
           if (colorBuffer.data != null) {
-            colorBuffer.data[newCount]
-                .setParticleColor(colorBuffer.data[i]);
+            colorBuffer.data[newCount].setParticleColor(colorBuffer.data[i]);
           }
           if (userDataBuffer.data != null) {
             userDataBuffer.data[newCount] = userDataBuffer.data[i];
           }
         }
         newCount++;
       }
     }
 
     // update proxies
@@ skipping 294 matching lines @@
     return velocityBuffer.data;
   }
 
   List<ParticleColor> getParticleColorBuffer() {
     colorBuffer.data =
         requestParticleBuffer(colorBuffer.data, colorBuffer.allocClosure);
     return colorBuffer.data;
   }
 
   List<Object> getParticleUserDataBuffer() {
-    userDataBuffer.data = requestParticleBuffer(
-        userDataBuffer.data, userDataBuffer.allocClosure);
+    userDataBuffer.data =
+        requestParticleBuffer(userDataBuffer.data, userDataBuffer.allocClosure);
     return userDataBuffer.data;
   }
 
   int getParticleMaxCount() {
     return maxCount;
   }
 
   void setParticleMaxCount(int count) {
     assert(count <= count);
     maxCount = count;
@@ skipping 188 matching lines @@
       final double vx = vb.x - va.x;
       final double vy = vb.y - va.y;
       double vn = vx * n.x + vy * n.y;
       if (vn < 0) {
         sum_v2 += vn * vn;
       }
     }
     return 0.5 * getParticleMass() * sum_v2;
   }
 }