forked from slembcke/Chipmunk2D
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathVERSION.txt
214 lines (193 loc) · 17.5 KB
/
VERSION.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
CHANGES SINCE 6.1.3:
* MISC: Fixed a build script issue that was preventing the documentation from being generated.
CHANGES SINCE 6.1.2:
* BUG: Fixed a couple of very specific but fatal bugs that occur when sleeping is enabled and filtering collisions.
* BUG: Fixed an issue with cpvslerp() between very similar vectors.
* BUG: Fixed an issue with grab friction in ChipmunkMultiGrab. (Pro only)
* MISC: Implemented the cpConstraintGetImpulse() functionality for spring joints.
* MISC: Added more functions to chipmunk_ffi.h
CHANGES SINCE 6.1.1:
* API: Added a cpArbiter.data pointer. Now you can tag collisions with custom persistent data.
* API: Added segment to segment collisions (thanks to LegoCylon)
* API: cpSpaceAddPostStepCallback() now returns false if the callback was a duplicate.
* API: Added the ChipmunkAbstractSampler.marchThreshold property instead of hardcoding it to 0.5.
* API: Added ChipmunkGrooveJoint properties for the groove and joint anchors.
* API: ChipmunkMultiGrab now returns information about grabbed shapes.
* BUG: Fixed a minor (non-crashing, non-leaking) memory pooling issue with reindexing lots of static shapes.
* BUG: Fixed an issue with the slerp functions that would cause them to return incorrect results when given non-unit length input.
* BUG: Fixed a precision bug with the ChipmunkImage sampler classes that could cause artifacts or miss small features.
* BUG: Fixed a number of properties in Objective-Chipmunk that should have been nonatomic.
* BUG: Fixed a number of types in Objective-Chipmunk that were incorrectly id that should have been cpGroup, cpCollisionType etc. It's now possible to redefine them at compile time if you wish.
* MISC: Dropped armv6 support in favor of armv7s on iOS. (You can switch it back easily if you need.)
* MISC: Updated iOS build scripts to guess the latest SDK.
* MISC: Added the "Sticky Surfaces" demo as a cpArbiter.data example.
* MISC: Updated Objective-Chipmunk build scripts to always use the latest iOS SDK.
CHANGES SINCE 6.1.0:
* API: Renamed the new block based iterators as soon as possible to match the Apple convention ("_b" suffix).
CHANGES SINCE 6.0.3:
* API: Added a pthread based, multi-threaded solver to accelerate the game on multi-core systems. (Pro only)
* API: Added cpConvexHull() and CP_CONVEX_HULL() for generating convex hulls.
* API: Added cpPolylineConvexDecomposition_BETA() to generate an approximate concave decomposition of a polyline. (Pro only)
* API: Added [ChipmunkPolyline toConvexHull:] to generate approximate convex hulls. (Pro only).
* API: Added [ChipmunkPolylineSet toConvexHulls_BETA:]. (Pro only)
* API: Added nearest point queries.
* API: Added a push mode to ChipmunkMultiGrab so touches can interact with the scene even if they didn't initially touch a shape. (Pro only)
* API: Added optional block based iterators.
* API: Added a space property to cpBody, cpShape and cpConstraint types.
* BUG: Fixed an issue with changing the floating point and vector type on OS X.
* BUG: Fixed a pixel offset in ChipmunkImageSampler that could cause minor sampling artifacts. (Pro only)
* BUG: Fixed an issue where cpShape and cpConstraint structs could have garbage space pointers if cpcalloc() was redefined.
* BUG: Fixed assertions in cpArbiter getters to correctly reflect a contact count of 0 from separate() callbacks.
* BUG: Fixed a regression relating to registering post-step() callbacks from other post-step() callbacks.
* BUG: Fixed a minor memory leak for sleeping bodies when destroying a space.
* MISC: Point queries are now deprecated in preference to point queries.
* MISC: cpSpatialIndexPointQuery() was redundant and has been removed. Use cpSpatialIndexQuery() instead.
* MISC: cpShape*Query() functions now accept a NULL info pointer if you don't want detailed query info.
* MISC: The enableContactGraph property of cpSpace is deprecated and always be true.
* MISC: Added a new demos of the convex hull functions and a self balancing Unicycle.
CHANGES SINCE 6.0.2:
* API: Added a cpBBForCircle() convenience function.
* API: Added cpBBSegmentQuery() to check where a segment hits a cpBB.
* API: Added cpBodyGetVelAtWorldPoint() and cpBodyGetVelAtLocalPoint() to get point velocities on a body.
* API: Added cpArbiterTotalKE() to calculate the energy lost due to a collision. Great for calculating damage accurately.
* API: Added methods to get an ObjC pointer from a C chipmunk struct.
* API: Added a CHIPMUNK_ARBITER_GET_BODIES() macro for Objective-Chipmunk.
* API: The Objective-Chipmunk headers are now ARC compatible.
* API: Added a [ChipmunkSpace contains:] method to check if a ChipmunkObject has been added to the space or not.
* API: Added a cpBBNewForCircle() function.
* API: Added a cpBBSegmentQuery() function for raycasting againsts AABBs.
* BUG: Fixed a regression with ChipmunkSpace.bodies and ChipmunkSpace.shapes that caused crashes.
* BUG: Fixed a rare bug with postStep() callbacks and iterators.
* BUG: Fixed a border case in cpBBIntersectsSegment() that could cause missed segment queries.
* MISC: Added some new assertions for error conditions that were previously uncaught.
* MISC: Accelerated segment queries in cpBBTree by sorting the nodes.
* MISC: Added a new "Slice" demo that lets you cut up a polygon.
* MISC: Added NEON optimizations for Chipmunk Pro. Expect running on most ARM platforms to be 25-35% faster for contact heavy simulations.
* MISC: All ChipmunkObject instances added to a space are now retained, even composite ones.
CHANGES SINCE 6.0.1:
* API: Added cpSpaceIsLocked() to check if you are in a callback or not.
* API: Removed the long deprecated [ChipmunkSpace addShapeAHandler:] and [ChipmunkSpace addShapeBHandler:] methods.
* API: The ChipmunkObject protocol now can return any id<NSFastEnumeration> object instead of just an NSSet.
* API: The largely useless [ChipmunkSpace addBaseObjects:] and [ChipmunkSpace removeBaseObjects:] methods were removed.
* API: Added [ChipmunkSpace smartAdd:] and [ChipmunkSpace smartRemove:] methods for a consistent API to remove objects inside and out of callbacks.
* API: Added [ChipmunkSpace addPostStepBlock:key:] to complement [ChipmunkSpace addPostStepCallback:selector:key:].
* API: Added [ChipmunkSpace addPostStepAddition:].
* API: Objective-Chipmunk collision handlers no longer retain their target to avoid reference cycles.
* API: Added callbacks to joints.
* BUG: Soft errors (only checked when debug mode is enabled) and warnings were disabled. Whoops.
* BUG: cpShapeIsSensor() was incorrectly named in chipmunk_ffi.h.
* BUG: It should be safe to call cpActivateBody() from an space iterator callback now.
* MISC: Very nice bouyancy demo added based on callbacks.
* MISC: Breakable Joints demo showing how to use the new joint callbacks.
* MISC: Player demo updated and greatly enhanced by Chipmunk 6 features.
* MISC: Changed adding a static body to a space from a warning to a hard error.
* MISC: cpGroup and cpCollisionType now default to uintptr_t so you can safely use pointers instead of ints for these types.
* MISC: Updated the MSVC10 project file.
* MISC: Updated the FFI defs.
CHANGES SINCE 6.0.0:
* BUG: Calling cpBodySetPos() on a sleeping body was delaying the Separate() handler callback if one existed.
* BUG: Fixed a bug where Separate() handler callbacks were not occuring when removing shapes.
* BUG: Calling cpBodyApplyForce() or cpBodyResetForces() was not activating sleeping bodies.
* API: Added cpSpaceEachConstraint().
* API: Added a "CurrentTimeStep" property to cpSpace to retrieve the current (or most recent) timestep.
* MISC: Got rid of anonymous unions so that it is C99 clean again.
CHANGES SINCE 5.x:
Chipmunk 6.x's API is not quite 100% compatible with 5.x. Make sure you read the list of changes carefully.
Keep in mind that this is a x.0.0 release and that it's likely there are still some bugs I don't know about yet. I've spent a lot of effort rewritting the collision detection, sleeping, and contact graph algorithms that have required large changes and cleanup to the 5.x codebase. I've ironed out all the bugs that I know of, and the beta test went well. So it's finally time for 6!
* API: Chipmunk now has hard runtime assertions that aren't disabled in release mode for many error conditions. Most people have been using release builds of Chipmunk during development and were missing out on very important error checking.
* API: Access to the private API has been disabled by default now and much of the private API has changed. I've added official APIs for all the uses of the private API I knew of.
* API: Added accessor functions for every property on every type. As Chipmunk's complexity has grown, it's become more difficult to ignore accessors. You are encouraged to use them, but are not required to.
* API: Added cpSpaceEachBody() and cpSpaceEachShape() to iterate bodies/shapes in a space.
* API: Added cpSpaceReindexShapesForBody() to reindex all the shapes attached to a particular body.
* API: Added a 'data' pointer to spaces now too.
* API: cpSpace.staticBody is a pointer to the static body instead of a static reference.
* API: The globals cp_bias_coef, cp_collision_slop, cp_contact_persistence have been moved to properties of a space. (collisionBias, collisionSlop, collisionPersistence respectively)
* API: Added cpBodyActivateStatic() to wake up bodies touching a static body with an optional shape filter parameter.
* API: Added cpBodyEachShape() and cpBodyEachConstraint() iterators to iterate the active shapes/constraints attached to a body.
* API: Added cpBodyEeachArbiter() to iterate the collision pairs a body is involved in. This makes it easy to perform grounding checks or find how much collision force is being applied to an object.
* API: The error correction applied by the collision bias and joint bias is now timestep independent and the units have completely changed.
* FIX: Units of damping for springs are correct regardless of the number of iterations. Previously they were only correct if you had 1 or 2 iterations.
* MISC: Numerous changes to help make Chipmunk work better with variable timesteps. Use of constant timesteps is still highly recommended, but it is now easier to change the time scale without introducing artifacts.
* MISC: Performance! Chipmunk 6 should be way faster than Chipmunk 5 for almost any game.
* MISC: Chipmunk supports multiple spatial indexes and uses a bounding box tree similar to the one found in the Bullet physics library by default. This should provide much better performance for scenes with objects of differening size and works without any tuning for any scale.
CHANGES SINCE 5.3.4
* FIX: Fixed spelling of cpArbiterGetDepth(). Was cpArbiteGetDepth() before. Apparently nobody ever used this function.
* FIX: Added defines for M_PI and M_E. Apparently these values were never part of the C standard math library. Who knew!?
* FIX: Added a guard to cpBodyActivate() so that it's a noop for rouge bodies.
* FIX: Shape queries now work with (and against) sensor shapes.
* FIX: Fixed an issue where removing a collision handler while a separate() callback was waiting to fire the next step would cause crashes.
* FIX: Fixed an issue where the default callback would not be called for sensor shapes.
* FIX: Resetting or applying forces or impulses on a body causes it to wake up now.
* MISC: Added a check that a space was not locked when adding or removing a callback.
* MISC: Removed cpmalloc from the API and replaced all occurences with cpcalloc
* MISC: Added a benchmarking mode to the demo app. -trial runs it in time trial mode and -bench makes it run some benchmarking demos.
CHANGES SINCE 5.3.3:
* FIX: cpBodyActivate() can now be called from collision and query callbacks. This way you can use the setter functions to change properties without indirectly calling cpBodyActivate() and causing an assertion.
* FIX: cpArbiterGetContactPointSet() was returning the collision points for the normals.
* FIX: cpSpaceEachBody() now includes sleeping bodies.
* FIX: Shapes attached to static rogue bodies created with cpBodyNewStatic() are added as static shapes.
* MISC: Applied a user patch to update the MSVC project and add a .def file.
CHANGES SINCE 5.3.2:
* API: Added cpArbiteGetCount() to return the number of contact points.
* API: Added helper functions for calculating areas of Chipmunk shapes as well as calculating polygon centroids and centering polygons on their centroid.
* API: Shape queries. Query a shape to test for collisions if it were to be inserted into a space.
* API: cpBodyInitStatic() and cpBodyNewStatic() for creating additional static (rogue) bodies.
* API: cpBodySleepWithGroup() to allow you to create groups of sleeping objects that are woken up together.
* API: Added overloaded *, +, - and == operators for C++ users.
* API: Added cpSpaceActivateShapesTouchingShape() to query for and activate any shapes touching a given shape. Useful if you ever need to move a static body.
* FIX: Fixed an extremely rare memory bug in the collision cache.
* FIX: Fixed a memory leak in Objective-Chipmunk that could cause ChipmunkSpace objects to be leaked.
* MISC: C struct fields and function that are considered private have been explicitly marked as such. Defining CP_ALLOW_PRIVATE_ACCESS to 0 in Chipmunk.h will let you test which parts of the private API that you are using and give me feedback about how to build proper APIs in Chipmunk 6 for what you are trying to do.
* MISC: Allow CGPoints to be used as cpVect on Mac OS X as well as iOS.
CHANGES SINCE 5.3.1:
* FIX: Collision begin callbacks were being called continuously for sensors or collisions rejected from the pre-solve callback.
* FIX: Plugged a nasty memory leak when adding post-step callbacks.
* FIX: Shapes were being added to the spatial hash using an uninitialized bounding box in some cases.
* FIX: Perfectly aligned circle shapes now push each other apart.
* FIX: cpBody setter functions now call cpBodyActivate().
* FIX: Collision handler targets are released in Objective-Chipmunk when they are no longer needed instead of waiting for the space to be deallocated.
* API: cpSpaceSegmentQuery() no longer returns a boolean. Use cpSpaceSegmentQueryFirst() instead as it's more efficient.
* NEW: cpSpaceRehashShape() Rehash an individual shape, active or static.
* NEW: cpBodySleep() Force a body to fall asleep immediately.
* NEW: cpConstraintGetImpulse() Return the most recent impulse applied by a constraint.
* NEW: Added setter functions for the groove joint endpoints.
* MISC: A number of other minor optimizations and fixes.
CHANGES SINCE 5.3.0:
* NEW: Added a brand new tutorial for Objective-Chipmunk: SimpleObjectiveChipmunk that can be found in the Objective-Chipmunk folder.
* NEW: Proper API docs for Objective-Chipmunk.
* NEW: Updated the included Objective-Chipmunk library.
* FIX: Fixed a rare memory crash in the sensor demo.
* FIX: Fixed some warnings that users submitted.
CHANGES SINCE 5.2.0:
* FIX: Fixed the source so it can compile as C, C++, Objective-C, and Objective-C++.
* FIX: Fixed cp_contact_persistence. It was broken so that it would forget collision solutions after 1 frame instead of respecting the value set.
* OPTIMIZATION: Several minor optimizations have been added. Though performance should only differ by a few percent.
* OPTIMIZATION: Chipmunk now supports putting bodies to sleep when they become inactive.
* API: Elastic iterations are now deprecated as they should no longer be necessary.
* API: Added API elements to support body sleeping.
* API: Added a statically allocated static body to each space for attaching static shapes to.
* API: Static shapes attached to the space's static body can simply be added to the space using cpSpaceAddShape().
* NEW: New MSVC projects.
* NEW: Added boolean and time stamp types for clarity.
CHANGES SINCE 5.1.0:
* OPTIMIZATION: Chipmunk structs used within the solver are now allocated linearly in large blocks. This is much more CPU cache friendly. Programs have seen up to 50% performance improvements though 15-20% should be expected.
* API: Shape references in cpArbiter structs changed to private_a and private_b to discourage accessing the fields directly and getting them out of order. You should be using cpArbiterGetShapes() or CP_ARBITER_GET_SHAPES() to access the shapes in the correct order.
* API: Added assertion error messages as well as warnings and covered many new assertion cases.
* FIX: separate() callbacks are called before shapes are removed from the space to prevent dangling pointers.
* NEW: Added convenience functions for creating box shapes and calculating moments.
CHANGES SINCE 5.0.0:
* FIX: fixed a NaN issue that was causing raycasts for horizontal or vertical lines to end up in an infinite loop
* FIX: fixed a number of memory leaks
* FIX: fixed warnings for various compiler/OS combinations
* API: Rejecting a collision from a begin() callback permanently rejects the collision until separation
* API: Erroneous collision type parameterns removed from cpSpaceDefaulteCollisionHandler()
* MOVE: FFI declarations of inlined functions into their own header
* MOVE: Rearranged the project structure to separate out the header files into a separate include/ directory.
* NEW: Added a static library target for the iPhone.
* NEW: Type changes when building on the iPhone to make it friendlier to other iPhone APIs
* NEW: Added an AABB query to complement point and segment queries
* NEW: CP_NO_GROUP and CP_ALL_LAYERS constants
CHANGES SINCE 4.x:
* Brand new Joint/Constraint API: New constraints can be added easily and are much more flexible than the old joint system
* Efficient Segment Queries - Like raycasting, but with line segments.
* Brand new collision callback API: Collision begin/separate events, API for removal of objects within callbacks, more programable control over collision handling.