After three rounds of beta testing, NVIDIA has finally released new PhysX SDK 3.2 for Windows, Linux, Mac OSX and Android platforms.

You can check full Release Notes here: PhysX SDK 3.2 Release Notes

Free binary versions of PhysX SDK 3.2 are available for download through Developer Support Center (our registration guide) or new PhysX Registered Developer Program (not yet).

NVIDIA is about to meet the wishes of developer community with more friendly way to take advantage of PhysX SDK and APEX Tools – Registered Developer Program.

In comparison to previous account registration process, Developer Program features automated account approval (matter of minutes, not days) and simplified downloads structure (easier to find demanded files).

Attention ! Registered Developer Program only provides access to free binary versions of PhysX SDK, APEX DCC Tools (PhysXLab, PhysX plug-ins) and APEX SDK.

Source versions will still be available through PhysX Developer Support website only, as well as paid support.

IF YOU ARE NOT REGISTERED AT NVIDIA DEVELOPER ZONE

Step 1. Go to NVIDIA Developer Zone and click “New Account” (upper right corner)

Step 2. Fill-in account information, than press “Create new account” button

Step 3. Instructions and password will be sent to your e-mail. Complete the registration

IF/WHEN YOU ALREADY HAVE DEVELOPER ZONE ACCOUNT

Step 1. While logged-in, click “My Account” (upper right corner)

Step 2. Complete Basic Registered Developer Profile

You will be required to provide your Last and First name, information about your company and your location.

Step 3. Now you can apply to APEX/PhysX Registered Developer Program (PhysX RDP)

Step 4. Fill-in provided questionary

Please note that you will be required to agree to the terms and conditions specified in the PhysX/APEX EULA. Read it carefully.

Step 5. Wait until you Developer Program status will change from “Submitted” to “Approved” (may take up to 30 minutes – you will be also notified via e-mail upon completion).

You can access PhysX RDP website by clicking program’s title or direct link

Step 6. Now you can download latest binary PhysX SDKs, APEX SDK and DCC tools.

Subsequently, while logged, you access PhysX RDP via “My Account” panel, or through “Registered Developers Website” link on devzone main page, or via direct link.

If you have trouble with new account registration or existing account you can send your problem description to support@physxinfo.com (with subject – “PhysX RDP”) – we’ll try to provide a shortcut to PhysX dev. team.

If you are watching over PhysX SDK 3 development process, you may now that all-purpose cloth simulation engine, which can be found in SDK 2.x,  was replaced by new specialized PxCloth clothing solver in SDK 3.

Tech talk called “Character Clothing in PhysX 3“, presented by Tae-Yong Kim at SIGGRAPH ASIA 2011, provides in-depth overview of algorithms behind new clothing engine and its features.

Main features of new the solution are:

• Improved performance.
• Better artist control over bending and shearing of the cloth.
• Better handling of high-energy motion.
• Tapered capsules for better character representation.
• Other pleasing features like virtual particles (for increased collision resolution), CCD or particles mass scaling.

We are expecting PxCloth solver to become one of the major features of APEX Clothing 1.2 module, that is supposed to be released in upcoming months.

In addition, one may find other SIGGRAPH talk, “Real-Time Water Simulation on the GPU” by Nuttapong Chentanez, also interesting.

It cover recent advancements in NVIDIA’s research with the view to creation of universal water simulation solution, which combines best of heightfield fluids, SPH and grid simulation methods.

Thanks to Stefan for the links !

Remaining presentations from GDC 2012 are now available at GDC Vault.

Particularly interesting detail was revealed during “Mastering DX11 with Unity” (PDF) talk – NVIDIA APEX framework will be added to popular Unity game engine, which is currently using modified PhysX SDK 2.8.3 as physics engine.

A short demo (bus smashing through propane shop) of basic APEX Destruction module usage was presented, followed by promises to expand integration on other APEX modules in the future.

Next presentation, “Enhancing Games with Clothing and Destruction” is absolutely indentical to Game Technology Theather talk of the same name, we have reviewed it earlier.

Finally, it is worth to check a “Solving Rigid Body Contacts” tutorial from Richard Tonge, however, it is a bit technical.

More detailed videos of new experimental destruction engine with support for real-time fracturing, already previewed in previous demonstration, are now available.

In this video we show our new destruction prototype. Here, piec fractures pieces on the fly. There is no limit of how many times pieces can be fractured. Also, the fracture pattern depends on the impact location.

To simulate the massive amount of rigid bodies we use GRBs – GPU accelerated rigid boides.

Destruction algorithm also works well for objects with concave geometry.

In this video we show our new destruction prototype. Here, objects are fractured on the fly. There is no limit of how many times pieces can be fractured. Also, the fracture pattern depends on the impact location. The original objects as well as the pieces are allowed to be non-convex which is an additional challenge.

To simulate the massive amount of rigid bodies we use GRBs – GPU accelerated rigid boides. The scene runs above 40 fps until the end including rendering on an nvidia GeForce GTX 480.

Update: Lately, more detailed video with some technical description was added.

Update #2: Finally, there is one more video from GTX 680 press kit.

Without doubt, pretty impressive technology.

Gametrailers has published several videos, revealing what kind of newest additions to PhysX SDK engine and APEX Framework were showcased at NVIDIA Booth, at current GDC.

First video is showing yet experimental technology – new cloth solver and real-time fracturing.

Wooly character contains 840 000 particles simulated as 100 000 invidual strands of fur and is running on new solver that is currently under active research.

Real-time fracturing will be nice addition to the APEX Destruction module, which, currently, is utilizing only pre-fractured meshes. Fracturing happening in real-time, accordingly to impact force and point of damage application will certanly make destruction look more natural and immersive.

Update: more detailed videos of new fracturing engine.

Update #2: fur simulation technology video

Second video is showcasing production technology: APEX Turbulence, APEX Destruction and APEX Clothing modules integrated in UE3.

APEX Turbulence module, so far only featured in Dark Void title is making a coming back ! Fully realisitic and dynamic smoke or dust it can produce would be welcomed addition to upcoming games.

APEX Destruction was demonstrated in a form of good old Art Gallery scene, used at previous GDC as well.

And finally, Samaritan character was utilized to showcase capabilities of clothing simulation through APEX Clothing module.

NVIDIA has released APEX SDK 1.1 (Build 112), next version of NVIDIA APEX – scalable dynamics framework, oriented on complex physical simulations.

In comparison to APEX 1.0 Beta, new version includes many bugfixes, several additions to underlying framework and various new features, like ability to calculate rigid body physics on GPU.

APEX 1.1 contains only Destruction and Clothing modules, and is still based on PhysX SDK 2.8.4.6 – first version with PhysX 3 support is going to be APEX 1.2 (that is supposed to be released in a few months).

We must also note that APEX 1.1 requires corresponding authoring tools – PhysXLab 1.1 and 2.71 DCC plug-ins.

NVIDIA APEX SDK 1.1 is available for download at Developer Support Center.

If you are experiencing trouble with registration of PhysX Developer account, please refer to our registration guide.

Release Notes:

APEX DESTRUCTION 1.1

New Features

• GPU Rigid Bodies: the NxModuleDestructible has settings to enable calculation of Rigid Body physics on GPU.

Highly anticipated feature. While using same assets and same settings, GPU Rigid Bodies are showing significantly higher performance – 70 fps for 5000+ rigid body chunks on single GTX 580 vs 10 fps on Core i7 2600K.

One-way interaction with dynamic CPU actors is also supported (via transfer of momentum). GPU accelerated rigid body physics requires NVIDIA driver 270.81 or later, PhysX 2.8.4 RC6 or later and a CUDA capable GPU.

• Chunk instancing: (when authored to instance) correponding chunks between different destructible actors will be rendered using an instance buffer. This is advantageous if there are many destructible actors which reference the same asset.
• Chunk tiling: (when authored to tile) matching chunks created from cutout fracturing will be instanced within the same actor, as well as other destructible actors which reference the same asset. This can drastically reduce the memory size of the asset.
• NxDestructibleActor:
  • LOD setting sets the maximum chunk depth which can be fractured, implementing forcePhysicalLOD interface.
  • getChunkLinearVelocity and getChunkAngularVelocity API in the actor.
  • Per-actor materials in the actor descriptor.
  • Can specify a separate render mesh for static chunks which gets drawn in a single draw call, using the renderStaticChunksSeparately field in the actor descriptor
  • Can set a separate set of static materials used by the static mesh if renderStaticChunksSeparately is set.
  • minimumFractureDepth added to destructible parameters, to limit the size of the pieces that can be broken free.
  • Implements applyTransformation interface to geometrically transform an asset.
• Fracture event callback now consolidates chunk information to reduce the number of fracture events reported.
• NxActor (chunk island) FIFO can now be sorted by “benefit” (takes into account screen size and age of the chunk), so that less-beneficial chunks are removed first.
• NxShape count limit can be set in addition to NxActor count.

Improvements

• Chunk creation can be amortized over many frames.
• Fracture processing can be amortized over many frames.
• Conforms to new LOD system.
• Removed the per-chunk thread locks, for better performance and resource usage.
• SimpleDestruction has multiple sample scenes, loaded using the keys 1-7.

Bug Fixes

• Damage reports are no longer issued when a destructible is set free using setDynamic().
• Several crash bugs fixed.

Authoring Improvements

• Ability to have multiple collision hulls per chunk.
• Can cancel the fracture operation.
• “Trim face hulls” option in cutout fracturing.
• Ability to use multiple UV channels and color channels from FBX meshes
• cookChunks does not use the internal ExplicitHierarchicalMesh any longer, only information passed in from the descriptor.

APEX CLOTHING 1.1

New Features

• Per-Actor scaling. Each actor can have an individual scale and simulates properly.
• Asynchronous cooking. When several actors with different per-actor scale are created, cooking will be delayed if another actor already started cooking. While waiting, actors will not be simulated.
• Manual substepping: A PhysX scene that will run multiple substeps is now handled properly by clothing. Interpolated simulation meshes will be generated for each individual substep to remove simulation artifacts caused by substepping.
• Teleport without reset: Clothing Actors can now be teleported without all the vertices being reset to the animated positions. This will only lead to good results if only the pose of the actor and not the state of the animation is changed.
• Frozen state: Clothing can be frozen in a given state and will cease simulation. It can then be woken again in the same state. This contrasts the regular way where re-enabled clothing starts from the animated state instead.
• Velocity Callback: A user callback that allows to read and write the velocity values of every simulated vertex. Can be used to play sound depending on certain changes in velocity or to implement i.e. a wind effect.
• Support for morph targets (also known as blendshapes): At actor creation a set of vertex displacements can be used to modify the mesh.
• Platform Tags: Each graphical LOD can have a list of strings attached. When converting the .apx/.apb files to a given platform, LODs that don’t match a certain pattern can be removed based on this.This allows for reducing asset size by removing LODs that are unsuited for a particular platform.
• Correct Simulation Normals: Vertices that are on the border of the simulated and non-simulated part of the physical mesh can have wrongly calculated normals. This setting will try to correct for that.
• Adaptive Target Frequency: Reduces the high frequency jittering that happens due to slightly varying timesteps.
• Pressure: Closed cloth meshes can be filled with pressure.
• Vertex Velocity Clamp: Adds a maximum velocity in all 6 major axis and clamps all velocities to those.

Improvements

• Switching of graphical LoDs has been improved in respect to copying position and velocity from the old to the new simulation mesh.

Removed

• Legacy serialization is gone. Any old .aca file cannot be loaded anymore. They need to be converted to .apx/.apb using the 1.0 ParamTool instead.
• Some API marked as deprecated has been deleted such as NxClothingActor::setFlags().
• Removed separate NxClothingMaterialLibrary (.acml files) as an asset type. Materials are now integrated into the Clothing Asset file directly.
• Parallel physics mesh skinning and parallel mesh-mesh skinning. The frame delay that was introduced by this feature made it useless to most applications.

APEX FRAMEWORK

NxParameterized

• New method Interface::clone.
• Handles which are constructed from const Interfaces do not allow to change those Interfaces via setParamXxx.
• Generic reference visitor NxParameterized::getReferences.
• Streamed non-inplace binary deserialization.
• Fixed handling of defaultValue in structs.
• Fixed detection of hint types.
• Automated versioning of legacy classes.
• Customizable order of legacy objects upgrade instead of fixed bottom-up.
• Custom alignments of struct fields.
• ParamTool can now print summary of file contents.

Serialization

• ParamTool does not support legacy asset formats anymore.
• Changed some error codes.

Render Mesh Asset

• setOverrideMaterial was added to allow switching of material directly at runtime.
• Debug rendering vor vertex normals and tangents.

Use of Cuda 4.1

• Necessary for supporting latest hardware.

P.S. We expect APEX 1.1 integration with UE3/UDK to be available in February 2012 release.

NVIDIA has revealed presentations schedule for Game Developers Conference 2012 (GDC 2012), taking place on March 5-9 in San Francisco.

As usually, certain talks will be demonstrating latest advances in PhysX and APEX technologies. Let’s take a look:

March 7th, Booth #1424

3dsMax with MassFX

11:00am - 12:00pm. Chris Murray, Autodesk

Autodesk’s implementation of MassFX within 3dsMax will show you just how easy the workflow is for rigid body dynamics and how versatile to the tool can be. Additionally, Autodesk will be giving a technology preview of some aspects of MassFX currently being experimented with in 3dsMax.

IKinema IK for Combining Physics and Animation in Maya

2:00pm - 3:00pm. Alexandre Pechev, IKinema

IKinema is a production-proven solution for animating with inverse kinematics (IK) in Maya. Come see how we combine IKinema IK with NVIDIA’s PhysX Plugin for Maya to produce animations that can capture a character’s intent and physical simulation at with an improved speed and accuracy over handmade animations. Dressing the character with APEX Clothing can add even more dramatic physical effects and secondary motion to your film or game.

March 8th, Room 2011 & Booth #1424

Enhancing Games with Clothing and Destruction

4:00pm - 5:00pm. Aron Zoellner, NVIDIA. Kevin Newkirk, NVIDIA

In this two-part presentation, we will first show you step by step how physically simulated clothing was added to Bruce Wayne in Batman: Arkham City – we will go through the DCC authoring pipeline, importing to UE3, running the asset in a game level and discuss how to avoid common problems when moving from static to dynamic clothing. Next we will demonstrate clothing using the lead character from Epic’s Samaritan demo as a playable character in UE3.

In the second part of the session we will be focusing on the APEX Destruction pipeline using PhysXLab and go through the authoring of recent destruction game examples as well as authoring the massive destruction in the UE3 Art Gallery Demo.

March 9th, Booth #1424

Enhancing games with APEX (Clothing, Destruction, Turbulence)

2:00pm – 3:00pm. Aron Zoellner, NVIDIA. Kevin Newkirk, NVIDIA

APEX has been used in various games to enhance game interactivity. In this session we will show you how APEX Modules (Destruction, Clothing) can be used to add more realistic clothing and destruction into your game. We will provide several APEX examples in current games and guide you through the entire pipeline of authoring, importing and setup of APEX Clothing and Destruction in a UE3 level.

This session will provide an overview of the full NVIDIA APEX suite of tools used in the creation of clothing and destruction as well as an overview of the upcoming APEX Turbulence module.

After the GDC ends,  we expect all recorded sessions to be available for download at NVIDIA Developer Zone or GDC Vault.

NVIDIA has revealed PhysX SDK 3.2 Beta-1, thus providing early public access to next general release of PhysX 3, enhanced with many features and improvements – as a Christmas present, we suppose.

Update [25.01.2012]: PhysX SDK 3.2 Beta-2 is available

Update #2 [20.03.2012]: SDK 3.2 Beta-3 is released

Update #3 [10.05.2012]: Final release is available

Binary SDKs are available for Windows PC, Linux, Mac OSX and Android platforms.

PhysX SDK 3.2 Beta-1/Beta-2/Beta-3 can be downloaded at Developer Support Center.

If you are experiencing trouble with registration of PhysX Developer account, please refer to our registration guide.

PhysX SDK 3.2 Beta-1/Beta-2/Beta-3 Release Notes:

General:

• Three new sample applications: SampleCharacterCloth (character with cloth cape and cloth flags), SampleBridges (character controller walking on dynamic bridges and moving platforms), SampleGravity (character controller with arbitrary up vector).
• On Windows, the PxFoundation instance is now a process wide singleton and part of the new PhysX3Common.dll library.
• PxCreatePhysics() does not create a PxFoundation instance any longer. The PxFoundation instance has to be created in advance through PxCreateFoundation().
• Calls to PxCreatePhysics() are not valid anymore if a PxPhysics instance already exists.
• If profiling information should be sent to the PhysX Visual Debugger, a PxProfileZoneManager instance has to be provided when creating the PxPhysics instance.
• The version number constant PX_PUBLIC_FOUNDATION_VERSION has been replaced with PX_PHYSICS_VERSION. Both PxFoundation and PxPhysics use the same version number now.
• The API now distinguishes between input and output stream types.
• Added mechanism to reduce code size by not linking optional components. See PxCreateBasePhysics() and the PxRegister*() functions.
• Added getConcreteTypeName() to API classes to provide run time type information.
• Added PxScene::getTimestamp() to retrieve the simulation counter.
• PxGetFoundation has been moved to PxGetFoundation.h
• Changed the functions PxPhysics::releaseUserReferences(), releaseCollection(), addCollection() and releaseCollected() to now take a reference rather than a pointer.
• The signature of PxCreatePhysics has changed: The Foundation SDK instance must be passed in explicitly. One can also hook profiling information by passing a PxProfileZoneManager.
• [Beta-3] Contact data block allocation now provides statistics on usage and max usage.
• [Beta-3] On all platforms except PS3, contact data blocks can be progressively allocated.
• [Beta-3] Changed the functions PxPhysics::releaseUserReferences(), releaseCollection(), addCollection() and releaseCollected() to now take a reference rather than a pointer.
• [Beta-3] Default implementations of memory and file streams added in PxDefaultStreams.h
• [Beta-3] Renamed PxPhysics::getMetaData() to ::PxGetSDKMetaData().
• [Beta-2] Platform conversion for serialized data has been moved from the ConvX command line tool to the PxBinaryConverter interface in the cooking library.
• [Beta-2] Documentation has been updated.
• [Beta-3] Added migration guide page from 3.1 to 3.2 to user’s guide.
• [Beta-2] Samples have been updated.
• [Beta-2] Various bug fixes.

Rigid Bodies

• Introduced a new contact generation mode, see eENABLE_PCM.

Persistent Contact Manifold (PCM) is a fully distance-based collision detection system, which uses the Gilbert-Johnson-Keerthi algorithm (GJK) and the Expanding Polytope Algorithm (EPA) to calculate one contact at the point of deepest penetration. It then uses an incremental method to build up a contact manifold by recycling contacts from past frames, accumulating up to four contacts per frame.

This approach is quite efficient in terms of performance and memory. However, it can reduce stacking stability when simulating with large timesteps, tall stacks and small objects. As this approach is distance-based, it will generate the correct contact points for arbitrary contact offsets/rest offsets.

• Introduced two new friction simulation modes, see eENABLE_ONE_DIRECTIONAL_FRICTION and eENABLE_TWO_DIRECTIONAL_FRICTION.

The Coulomb friction model is based on the Coulomb laws of friction. It is less efficient than the default friction model and it can require more solver iterations to achieve stable stacking behavior. However, its friction behaviors are much closer to the analytical results than the default friction model so could be preferable for applications where accurate friction behavior is important.

The Coulomb model comes in two variants, one-directional and two-directional. The one-directional approach is similar in terms of workload to the default friction model and can be stable at similar solver iteration counts. Its behavior is closer to the analytical results but diverges slightly. The one-directional approach is a simplification of the full Coulomb model, in which the friction for a given point of contact is reduced to a one-directional friction model.

• Introduced a new scene query flag PxSceneQueryFlag::eINITIAL_OVERLAP_KEEP to control how initial overhaps are treated in scene queries.
• Per-triangle materials have been implemented.
• Changes to material properties are automatically reflected in contact resolution.
• New helper methods to compute mass properties for a dynamic rigid body taking per shape density/mass values into account (see documentation on PxRigidBodyExt for details).
• A new set of methods for overlap, sweep and raycast tests based on PxGeometry objects has been introduced. See documentation on PxMeshQuery and PxGeometryQuery for details).
• The contact report API has changed (for details see the documentation on PxSimulationEventCallback::onContact()). Among the changes are:
  • Reports only get sent for shape pairs which request them. Previously, reports were sent for an actor pair even if the requested shape pair event was not triggered (for example because other shapes of the same actors started colliding etc.)
  • The following PxPairFlags have been removed eNOTIFY_CONTACT_FORCES, eNOTIFY_CONTACT_FORCE_PER_POINT,  eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT.
  • Forces and feature indices are now always provided if applicable.
  • It is much easier now to skip shape pairs or contact point information when traversing the contact report data.
  • The memory footprint of contact reports has been reduced.
• The members featureIndex0/1 of PxContactPoint have been renamed to internalFaceIndex0/1 for consistency.
• For trigger reports, the eNOTIFY_TOUCH_PERSISTS event has been deprecated and will be removed in the next release. For performance and flexibility reasons it is recommended to use eNOTIFY_TOUCH_FOUND and eNOTIFY_TOUCH_LOST only and manage the persistent state separately.
• Added PxConstraintVisualizer interface and code to visualize joint frames and limits.
• Improved PxBatchQuery API.
• PxPhysics::getProfileZoneManager() now returns a pointer rather than a reference.
• PxRigidDynamic::moveKinematic() has been renamed to setKinematicTarget() to underline its precise semantics.
• Added new function PxShape::getGeometry and class PxGeometryHolder to improve Geometry APIs.
• [Beta-3] PxCreatePlane now takes a PxPlane equation as a parameter. Note that the interpretation of the distance value is negated relative to 3.1
• Added new actor creation helpers PxCloneStatic, PxCloneDynamic, PxScaleActor.
• Added new functions PxTransformFromSegment, PxTransformFromPlaneEquation to simplify creation of planes and capsules.
• Some methods of PxAggregate have been renamed for consistency or replaced for extended functionality.
• getMaxSize() is now called getMaxNbActors().
• getCurrentSize() is now called getNbActors().
• getActor() has been replaced by getActors() which copies the actor pointers to a user buffer.
• [Beta-3] Added support for kinematic triangle meshes, planes and heighfields.

Scene queries:

• [Beta-3]: Dynamic AABBTree has been set as the default dynamic pruning structure.

Particles:

• Removed descriptors from particle API: The properties maxParticles and PxParticleBaseFlag::ePER_PARTICLE_REST_OFFSET need to be specified when calling PxPhysics::createParticleSystem() and createParticleFluid(). All other properties can be adjusted after creation through set methods.

Cloth:

• Added convex collision shapes, see PxCloth::addCollisionConvex().
• Added friction support, see PxCloth::setFrictionCoefficient()..
• Added angle based bending constraints, see PxClothPhaseSolverConfig::SolverType::eBENDING
• Added separation constraints, a spherical volume that particles should stay outside of, see PxCloth::setSeparationConstraints().
• Added drag, see PxCloth::setDragCoefficient().
• Added inertia scaling, controls how much movement due to PxCloth::setTargetPose() will affect the cloth.
• Added support for setting particle previous positions, see PxCloth::setParticles().
• Added controls for scaling particle mass during collision, this can help reduce edge stretching around joints on characters, see PxCloth::setCollisionMassScale().
• Particle data is now copied asynchronously from the GPU after simulate (rather than on demand).
• Improved fabric layout, you can now share fabric data across multiple phases to reduce memory usage, see PxClothFabric.
• Fixed bug in collision when capsules are tapered at a slope > 1.

Vehicles:

• Added PxVehicleDriveTank, a vehicle class that enables tank behaviors.
• Support for vehicles with more than 4 wheels, see PxVehicleDrive4W, PxVehicleDriveTank.
• Significant refactor of vehicle api to allow further types of vehicle to be added.
• Americal English spelling used in vehicle api.
• PxVehicle4W replaced with PxVehicleDrive4W, PxVehicle4WSimulationData replaced with PxVehicleDriveSimData4W.
• Removal of scene query helper functions and structs: PxVehicle4WSceneQueryData, PxVehicle4WSetUpSceneQuery, PxWheelRaycastPreFilter, PxSetupDrivableShapeQueryFilterData, PxSetupNonDrivableShapeQueryFilterData, PxSetupVehicleShapeQueryFilterData. See SampleVehicle_SceneQuery.h for their implementation in SampleVehicle.
• PxVehicle4WSimpleSetup and PxCreateVehicle4WSimulationData have been removed and replaced with default values in vehicle components, see PxVehicleComponents.h.
• PxVehicle4WTelemetryData has been replaced with PxVehicleTelemetryData, a class that supports vehicles with any number of wheels, see PxVehicleTelemetryData
• PxVehicleDrivableSurfaceType no longer stored in PxMaterial::userData. A hash table of PxMaterial pointers is instead used to associate each PxMaterial with a PxVehicleDrivableSurfaceType, see PxVehicleDrivableSurfaceToTireFrictionPairs.
• PxVehicleTyreData::mLongitudinalStiffness has been replaced with PxVehicleTireData::mLongitudinalStiffnessPerUnitGravity, see PxVehicleTireData.
• Tire forces now computed from a shader to allow user-specified tire force functions, see PxVehicleTireForceCalculator.
• Added helper functions to quickly configure 3-wheeled cars, see PxVehicle4WEnable3WTadpoleMode, PxVehicle4WEnable3WDeltaMode.

What we removed:

• Deformables have been removed. Use the optimized solution for clothing simulation instead (see documentation on PxCloth for details).
• PxSweepCache is deprecated.
• PVD is no longer enabled in the release build.
• Removed anisotropic friction.
• Removed the CCD mode eSWEPT_CONTACT_PAIRS.
• PxActorDesc has been removed.
• [Beta-2] The ConvX tool has been removed.
• [Beta-3] Removed empty default implementations of functions in PxSimulationEventCallback for consistency.
• [Beta-3] Octree and quadtree pruning structures have been removed.
• [Beta-3] PxScene.overlapAny has been removed. overlapMultiple with maxNumHits 1 does the same.

Fixed Bugs:

• [Beta-3] PxScene::getActors() might not work properly when the startIndex parameter is used.
• [Beta-3] Improved the doc-comment of PxConvexMesh::getMassInformation().
• [Beta-3] RepX instantiation can lose all internal references when addOriginalIdsToObjectMap is false.
• [Beta-3] PxSetGroup crashed when used on a compound.
• [Beta-3] PhysXCommon.dll can be delay loaded.
• [Beta-3] ContactReportStream can now handle huge report numbers and size (resize-able flag) can be set in PxSceneDesc.h.
• [Beta-3] Fixed assert in sweep tests.
• [Beta-3] Concurrent read/write operations during a PxScene::fetchResults() call were not detected properly and no warning message got sent in checked builds.

Updated PhysX 3.1.1, which adresses many issues found in SDK 3.1.0, is now available for download.

Update [11.01.2012]: PhysX SDK 3.1.2 available

• Fixed wrong write/read clash checks.
• Removed some compiler warnings from public header files.
• Fixed PxScene::getActors() returning wrong actors when a start index is specified.
• Fixed broken joint projection in connection with kinematics.
• Fixed inaccurate normals returned from height field scene queries.
• Fixed a crash when the geometry of a shape changes and then the actor gets removed from the scene while the simulation is running.
• Fixed a crash when re-adding scene-query shape actors to scene.
• Fixed crash bug in particle simulation code on GPU.
• Fixed a crash when GPU fabrics are shared between cloths.
• Fixed a hang in cloth fiber cooker when handed non-manifold geometry.
• Fixed SampleVehicle doing an invalid write.
• Fixed SampleVehicle jitter in profile build.

PhysX SDK 3.1.1 Release Notes:

General

• Ported samples to Linux.
• Fixed crash bug in ConvX.
• Fixed crash bug in the allocator code of PXC_NP_MEM_BLOCK_EXTENSIBLE.
• Fixed crash bug when connected to PVD on various platforms.
• Fixed bogus asserts due to overly strict validation of quaternions.
• Fixed one frame lag in PVD scene statistics.
• Fixed a number of OSX PVD sockets issues.
• Fixed SampleSubmarine code that violated concurrent read/writes restriction.
• Added warnings about read/write hazards to the checked build.
• Fixed RepX not reading joint properties.
• Fixed support for concurrent scene queries.
• Fixed PhysX GPU Visual Indicator support.
• Made it more clear in documentation that simulate(0) is not allowed.

Rigid Bodies

• eNOTIFY_TOUCH_LOST trigger events do now get reported if one of the objects in contact gets deleted (see documentation of PxTriggerPair for details).
• Dynamic rigid bodies with trigger shapes only do not wake up other touching bodies anymore.
• Added lost touch events for trigger reports when objects get deleted.
• Fixed dynamic triggers waking up actors they are triggered by.
• Removed an inapropriate assert from articulation code.
• Fixed problem with the angular momentum conservation of articulations.
• Fixed articulation sleep problems.
• Fixed a linear velocity related bug in CCD.
• Fixed crash bug CCD.
• Optimized performance of joint information being sent to PVD.

PhysX SDK 3.1.1/3.1.2 can be downloaded at Developer Support Center.

If you are experiencing trouble with registration of PhysX Developer account, please refer to our registration guide.