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

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

PhysX SDK 3.2 Beta-1/Beta-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.

PhysX SDK 3.2 Beta-1/Beta-2 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-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-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.
• 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.

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.
• Renamed PxPhysics::getMetaData() to ::PxGetSDKMetaData().
• Removed the CCD mode eSWEPT_CONTACT_PAIRS.
• PxActorDesc has been removed.
• [Beta-2] The ConvX tool has been removed.

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.

Following previosly revealed roadmap, NVIDIA has updated 3.x generation of PhysX physics engine to version 3.1

List of publicly available free binary PhysX SDKs includes SDK for Windows PC, Linux, Mac OSX and, for the first time, Android platforms.

Update: PhysX SDK 3.1.1 is available for download

Update #2: PhysX SDK 3.2 Beta released

PhysX SDK 3.1 Release Notes:

General

• VC10 support has been introduced.
• VC8 support has been discontinued.
• Upgraded GPU tech to CUDA 4.
• Various improvements to Foundation and classes shared with APEX.
• Extensions, Character Controller and Vehicle source code made available in binary distribution.

• Namespaces cleaned up.
• Cleaned up a large number of warnings at C++ warning level 4, and set SDK to compile with warnings as errors.
• No longer passing NULL pointers to user allocator to deallocate.
• Added x86,x64 suffix to PxTaskCUDA.dll
• Removed boolean return value from PxScene::addActor(…), and similar API calls.

• Removed individual sample executables in favor of SampleAllInOne from PC and console builds.
• Fixed alpha blending in samples.
• Simplified some code in samples.
• Improved ambient lighting in samples.
• Made samples work with older graphics cards.
• Renamed some XBOX 360 specific files and folders.
• Improved and added more content the user’s guide.

Cloth

• A new solution for simulating cloth and clothing.

New PxCloth cloth solver in SDK 3.1 is a rewrite of the PhysX 2.x deformables, oriented on clothing simulation. It is promised to offer better performance (especially on consoles) and cloth behaviour, but at this point lacks several features, like softbodies, tearing, pressure and collision with regular rigid bodies (special “conic capsules” are provided instead).

However, as we were told, missing options will be added in future iterations of PhysX 3 cloth solver.

Deformables

• Deformables are deprecated and will be removed in the next release.

Rigid Bodies

• Rigid Body: High performance alternative convex narrow phase code available to source licensees. See PERSISTENT_CONTACT_MANIFOLD in the code.
• Significant advancements in the continuous collision detection algorithm.
• A large number of misc. bug fixes and optimizations.

• Added support for vehicles with more than one chassis shape.
• Fixed swapped wheel graphs in sample vehicle.
• Fixed a crash bug in the tire model.

• Optimizations and robustness improvements for articulations.
• Added sleep code for articulations.
• Solver iteration count for articulations.
• Articulation limit padding configurable.
• Fixed crashing of single link articulations.
• Added articulation documentation.

• The reference count of meshes does now take the application’s reference into acount as well and thus has increased by 1 (it used to count the number of objects referencing the mesh only). Note that a mesh does only get destroyed and removed from the list of meshes once the reference count reaches 0.

• Constraint solver optimizations.
• Removed the angular velocity term in the joint positional drive error formula.
• Fixed D6 joint linear limits being uninitialized.
• Expanded manual sections on joints.

• Improved behavior of character controller on steep slopes.
• Binary serialization now saves names.
• Added reference doc for PxSerializable.
• Fixed bug related to removing elements of an aggregate.
• Fixed bug in capsule sweep versus mesh.
• Improved reference doc for PxSceneQueryHitType.
• Fixed autowake parameter sometimes being ignored.
• Fixed some slow moving bodies falling asleep in midair.
• Fixed missing collisions after a call to resetFiltering.
• Fixed broken autowake option in setAngularVelocity.

• Added some helper code to the API.
• Removed some descriptors from API.
• Improved documentation and error messages associated with running out of narrow phase buffer blocks.

Particles

• Particle index allocation removed from SDK. Added index allocation pool to extensions.
• Replaced GPU specific side band API PxPhysicsGpu and PxPhysics::getPhysicsGpu() with PxParticleGpu.
• Memory optimizations on all platforms and options to reduce memory usage according to use case with new per particle system flags:
  • PxParticleBaseFlag::eCOLLISION_WITH_DYNAMIC_ACTORS
  • PxParticleBaseFlag::ePER_PARTICLE_COLLISION_CACHE_HINT
• Fixed rare crash appearing with multi-threaded non-GPU particle systems and rigid bodies.
• Fixed particles leaking through triangle mesh geometry on GPU.
• Fixed fast particles tunneling through scene geometry in some cases.
• Fixed erroneous collision of particles with teleporting rigid shapes (setGlobalPose).
• Fixed particle sample behavior with some older GPU models.
• Fixed a GPU particle crash bug.

PhysX SDK 3.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.

Despite the release of the new PhysX 3 engine, NVIDIA still continues to improve 2.x branch of PhysX SDKs – new PhysX SDK 2.8.4.6 has arrived today for PC, Xbox 360 and PS3.

Release Notes:

* Fixed a bug when vertex count is not a multiple of 4 and when NX_CLF_HARD_STRETCH_LIMITATION is enabled.

* SPU code enabled for APEX.

* Fixed SPU raycast bug.

* Other minor bugfixes for APEX.

As always, you can download PhysX SDK 2.8.4.6 via Developer Support Center.

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

NVIDIA has uploaded first minor bug-fix release for PhysX SDK 3 – PhysX SDK 3.0.1 for PC, PS3 and Xbox 360.

Update [04.10.2011]: PhysX SDK 3.1 released

Update [16.06.2011]: PhysX SDK 3.0.1 for Linux released, 32-bit libraries added, linking issues resolved.

Update [24.06.2006]: PhysX SDK 3.0.2 for PC released, with minor bugfixes.

Bug-fixes in 3.0.1 version include following:

• removed a troublesome assert, bad character fixes and a few broken macros
• fixed Xbox and Win32 install scripts
• renamed zeroDataCache to invalidateChache

Documentation was also updated. In addition, official Release Notes for SDK 3.0 were included with installation package. You can view them here.

As always, you can download PhysX SDK 3.0.2 via Developer Support Center.

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

No, your eyes are not deceiving you. After three years of development, NVIDIA has released new major version of PhysX physics engine – PhysX SDK 3.0.

Currently, free binary version of PhysX SDK 3.0 is available for PC only (32-bit and 64-bit, Mac and Linux versions are promised to be delivered later). SDK 3.0 can be downloaded from Developer Support Center. Follow the path: [Online Support] -> [Downloads] -> [PhysX SDK 3.0]

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

Update [04.10.2011] PhysX SDK 3.1 released

Update [01.06.2011] PhysX SDK 3.0.1 available

Update [13.05.2011] Physx SDK 3.0 for Mac OSX available

Update [17.05.2011] Physx SDK 3.0 for Linux available (Ubuntu based, 64-bit)

Now, while your download is undergoing, let’s take a look on PhysX SDK 3.0 features:

PhysX SDK 2.x was originally developed as a PC only physics engine, which was subsequently ported to support gaming consoles being developed by Sony (PS3) and Microsoft (Xbox 360). The PS3 port was developed independently and has been maintained in a separate code base since its development, as have later ports to Linux and Mac OSX. The unwieldy growth during the SDK lifetime and separate code bases have added to the considerable complexity of maintaining and updating succeeding versions of the PhysX SDK at a time when faster and more compact engines are required to effectively support phones and tablets.

PhysX SDK 3.0 represents a significant rewrite of the PhysX engine.

This rewrite involved extensive changes to the API that effectively results in a new PhysX engine rather than a chart of changes based on its predecessor version.  The various platforms versions are generated from a unified code base, further differentiating it from version 2.x.  In addition to a new modular design, considerable legacy clutter has been removed. Collectively these changes have resulted in a physics SDK designed to facilitate easier ongoing maintenance, enable simpler ports to emerging gaming platforms, and the addition of new features and capabilities.

Focus on consoles and emerging gaming platforms.

PhysX SDK 3.0 was designed to be competitive on current-gen consoles and anticipates devices with even less system resources. These architectural changes include but are not limited to better overall memory management, improvements to cache efficiency, cross-platform SIMD implementations, intelligent SPU usage on PS3, multi-threading across multiple cores, and AltiVec/VMX optimizations on Xbox 360.

Improved Threading.

PhysX SDK 3.0 features new Task Manager feature that supports two Dispatchers (for PC both CPU and GPU Dispatchers are available) that are responsible for managing task dependencies and distributing tasks across as many worker threads as the developer defines. This feature allows the developer to balance the proper mix of resources to achieve the desired performance level.

PhysX SDK 3.0 also incorporates a SolverBatch that supports multiple threads for Rigid Bodies and Deformables that are using different solver islands.  Additionally, narrow phase computation can use this feature to run multiple threads.

The particles and particle fluids pipeline currently provides tasks to run the following in parallel (PC/Xbox 360):

• Multiple particle system instances (for collision and SPH phases)
• Multiple work units for collision per particle system instance
• Multiple work units for SPH per particle fluid instance

For PS3 there is additional parallelization available for shape generation, which isn’t implemented yet for PC/Xbox 360. However, it doesn’t provide the parallelization across multiple particle system instances.

PC plus GPU provides more but overall differently structured parallelization.

Vehicles.

A reworked vehicle model now includes components such as engine, clutch, gears, autobox, differential, wheels, tyres, suspensions and chassis, in comparison to simplified suspension/wheel/tire NXWheelShape class in PhysX SDK 2.x.  One of the interesting aspects of the new model is the ability to create tire types, drivable surface types, and specify the friction used in the vehicle simulator to combine different tire and drivable surface types.

Like PhysX SDK 2.x, the vehicle model exists outside of the PhysX Core and so it does not have to be compiled into a game, to reduce executable size, if not needed. Source code is provided to facilitate developer customization.

New Serialization API.

Serialization (the process by which SDK objects are saved from memory to disk) in SDK 3.0 is much more powerful and much more efficient than in previous SDK versions. It supports all SDK objects, and desterilizes them “in place” – without any data copy or extra memory allocation, allowing them to be loaded as fast as possible. Serialization and cooking are not mutually exclusive though. The cooking library is still available – and mandatory – in the PhysX SDK 3.0. In fact, one cannot serialize a convex or triangle mesh without cooking it first.

Aggregates & Broadphase Clustering.

In PhysX SDK 2.x each NxShape was represented by a separate AABB in the broadphase.  This caused a significant performance issue in large scenes, particularly when adding and removing shapes from the scene.

In PhysX SDK 3.0, developers can combine a collection of actors into an aggregate that can be managed as single entity in a broadphase data structure, purely as an optimization feature. For example, assigning the various body parts of a ragdoll to a single aggregate will result in decreased number of overlap tests (while joint limits are already preventing most body parts from penetrating each-other). Thus, in PhysX SDK 3.0, aggregates can be collectively represented by a single AABB in the broadphase, which improves overall efficiency.

Double Buffering.

This allows the client application to read and write to actors and the scene while the simulation is running on another thread.

Articulations.

An articulation is a single actor representing an acyclic system of jointed actors. Only an anatomical joint (similar to the spherical joint with swing and twist limits) is currently available for articulations. Articulations use solver techniques similar to Featherstone; although, they are more robust than sets of jointed actors and have drive models, which are easier to combine with procedurally generated motion.  They’re also much more expensive in terms of CPU processing time.

Deformables and Force Fields.

Cloth and soft bodies were re-organized under one experimental Deformables actor.

Force fields are no longer needed. They were provided in PhysX SDK 2.x primarily because the architecture prevented efficient implementation of user-defined callbacks for force fields.  In the PhysX SDK 3.0 implementation, because of the extra freedom allowed by double buffering and other architecture changes, users can efficiently apply forces directly to the rigid bodies and there is no longer a need for the force field mechanism.  This approach provides greater flexibility and freedom for developers.

Distance based collision detection.

In PhysX SDK 3.0, collision routines can generate contacts when the shapes are a small distance apart but not quite yet touching.  The benefit is that bodies can now come to rest without concern for a tiny overlap between them.

PhysX Visual Debugger Support (PVD).

Event profiling for all platforms and thread utilization graphing within PVD.

Mesh Scaling.

It is now possible to create different non-uniformly scaled instances of your meshes and convexes without duplicating the memory.

Non-Simulation Objects.

Allows developers to create a staging area outside of the simulation from where they can add things into the simulation at high speed.

Driverless.

SDK 3.0 does not require installation of PhysX System Software on client or developer machine – it is fully driverless, like SDK 2.8.4.

Character Controller has not changed much from that of 2.8.4. It is planned however, to improve it in a future releases.

GPU hardware acceleration in SDK 3.0 is only available for particles/fluids.

Our big thanks to NVIDIA PhysX engineers, who have helped in the preparation of this article

“Game Engine Survey 2011″ article, that can be found in May 2011 Issue of Game Developer Magazine is containing some interesting information about developer’s preferences regarding middleware solutions.

91.4 % of traditional (big-budget) developers prefer to use middleware libraries, and PhysX SDK is holding #4 place – it’s the only one physics engine in this category (we were surprised that Havok was not mentioned).

Far fewer casual developers (48.6 %) are relying on middleware solutions, so unexpensive or free (but good) libraries – FMOD, open-source Bullet engine and PhysX SDK – are the most popular.

Previosly,  Game Developer Magazine has performed similar survey in Year 2009.

]]> http://physxinfo.com/news/5645/physx-sdk-in-top-5-middleware-libraries-used/feed/ 4 http://physxinfo.com/news/5073/nvidia-apex-1-0-beta-is-now-available-details/ http://physxinfo.com/news/5073/nvidia-apex-1-0-beta-is-now-available-details/#comments Fri, 25 Mar 2011 00:02:44 +0000 Zogrim http://physxinfo.com/news/?p=5073 #leftcontainerBox { float:left; position: fixed; top: 60%; left: 70px; } #leftcontainerBox .buttons { float:left; clear:both; margin:4px 4px 4px 4px; padding-bottom:2px; } #bottomcontainerBox { height: 30px; width:50%; padding-top:1px; } #bottomcontainerBox .buttons { float:left; height: 30px; margin:4px 4px 4px 4px; }

NVIDIA has uploaded last piece of APEX Framework puzzle – actual APEX SDK component. Now, it is time to take detailed overview on APEX features and structure.

So what is NVIDIA APEX ? APEX is multi-platform scalable developement framework, designed to reduce development time and costs when creating complex physics content.

APEX addresses following typical problems:

• Significant programmer involvement is required to take a relatively abstract PhysX-SDK and create a lot of meaningful content.

APEX provides a high-level interface to artists and content developers. This reduces the need for programmer time, adds automatic physics behavior to familiar objects, and leverages multiple low-level PhysX-SDK features with a single easy-to-use authoring interface.

• Game physics content typically gets designed to the game’s “min-spec” system.

APEX requires each functional module to provide one or more ways to “scale the content” when running on better-than-min-spec systems, and to do this without requiring a lot of extra work from the game developer (artist or programmer, but especially programmer).

• Game engine performance limitations.

APEX avoids many of the game engine bottlenecks by allowing the designer to identify the physics that is important to the game logic, and what can be sent directly to the renderer, bypassing the fully generic path through the game engine.

It also allows the game engine to treat an APEX asset as a single game object, even though it may actually comprise many hundreds or even thousands of low-level physics components.

Authoring tools (DCC plug-ins for 3ds Max/Maya and standalone PhysXLab app) are used create and tune physics assets (for example, destructible wall) while runtime component (APEX SDK) is responsible for deserialization, LOD, data management and interaction with game engine. Accordingly, APEX SDK must be integrated with your engine before you’ll be able to use APEX assets.

Few facts about APEX 1.0 Beta:

• APEX is not the replacement for PhysX SDK, nor the new version of it. It is a layer that sits on top of the PhysX SDK.
• APEX 1.0 public Beta includes Clothing and Destruction modules (and partially – Particles module).
• APEX is free for commercial and non-commercial use.
• All necessary documentation and tutorials are included with APEX 1.0 package.
• APEX supports PC, PS3 and Xbox 360 (with optimizations for consoles), and but only PC version is available for public currently.
• APEX is based on latest PhysX SDK 2.8.4 and does not require PhysX System Software installation.

How to download APEX: Follow this guide and register PhysX Developer account.

Go to [Online Support] -> [Download]

• [APEX] -> [APEX PhysX Lab Beta] -> NVIDIA APEX PhysX Lab-1.0.100.0 for PhysXLab (APEX Destruction authoring)
• [APEX] -> [APEX DCC Clothing Plugins] -> [Max 2.60 beta] -> NVIDIA PhysX Plug-in 3dsMax20– x– WithAPEX 2.60.– for 3ds Max PhysX plug-in (APEX Clothing authoring, don’t forget to choose proper 3ds Max version)
• [APEX] -> [APEX DCC Clothing Plugins] -> [Maya 2.6 beta] -> NVIDIA PhysX Plug-in Maya20– x– WithAPEX 2.60.– for Maya PhysX plug-in (APEX Clothing authoring, don’t forget to choose proper Maya version)
• [APEX] -> [APEX SDK Beta] -> APEXSDK-1.0.39 beta-PhysX_2.8.4.5-WIN-VC9 for APEX SDK (game engine integration)

You don't need to download PhysX SDK, or PhysX System Software, or anything else.

Now let’s see what is included in APEX 1.0 public Beta package:

AUTHORING TOOLS

DCC PhysX plug-ins for Autodesk 3ds Max and Autodesk Maya are used as authoring tools for APEX Clothing – module that allows to convert skinned mesh into fully simulated cloth. In addition, plug-ins are providing rigid body and joints simulation functionality, that can be usefull for VFX artists.

PhysX plug-in for 3ds Max v. 2.60.0314

Next version of 2.x series of 3ds Max plug-ins, that contains all anticipated features like substeps control and concave (composite) rigid bodies, and, of course, full APEX Clothing functionality.

Supports 3ds Max (2009, 2010, 2011) and 3ds Max Design (2010, 2011), 32-bit and 64-bit versions.

Set of video tutorials on APEX Clothing authoring workflow are available here. In addition, plug-in package also includes tutorial scenes and documentation.

PhysX plug-in for Maya v. 2.60.0314

First public release 2.x Maya PhysX plug-ins.

Supports Maya 2009, 2010 and 2011, 32-bit and 64-bit versions.

In generally, provides almost same functionality as 3ds Max plug-in, APEX Clothing as well.

In addition, 3ds Max plug-in includes special standalone application – Clothing Tool (also, clothing tool is provided with APEX SDK).

Using CT, APEX Clothing asset can be authored, previewed and debugged in game-like environment, not binded by Max internal performance restrictions.

More detailed overview of PhysX plug-ins features is available here.

PhysXLab v. 1.0.100

PhysXLab is a standalone authoring application for APEX Destruction – module responcible for simulation of destructible objects. PhysXLab allows artists to create APEX assets (by pre-fracturing graphical mesh via built-in slicing tool), specify destruction behaviour and preview simulation.

PhysXLab workflow tutorials can be viewed here. And runtime result – here

Note: Current version may have some problems with slicing and simulation parameters editing, due to bug with decimal symbols.

PhysXLab also includes authoring interface for APEX Particles module, but it is not fully supported yet.

APEX SDK

The APEX SDK comprises a set of C++ header files that define the SDK public API, a set of binary libraries that implement the functionality, as well as documentation and examples – all you need to integrate APEX with your engine.

The heart of APEX SDK architecture is Authorable Object – a data structure, the specification of how it will be authored, the specification of the run time functionality associated with it, and the software which implements this functionality.

APEX uses a framework called NxParameterized for storing asset and actor data. NxParameterized classes provide reflection on every parameter they include making it effective for serialization and auto-generation of user interfaces for tools.

APEX render data is stored in a vertex buffer accessible through the NxVertexBuffer interface. This vertex buffer supports a wide variety of attributes, and it also supports a variety of formats for each attribute.

Detailed documentation on APEX SDK and API is available as “apexdoc.chm” file. (“\Program Files (x86)\NVIDIA Corporation\APEX SDK\1.0\PhysX_2.8.4\win\docs” folder).

ENGINE INTEGRATION

APEX is already integrated into several game engines, including Unreal Engine 3 and Unreal Development Kit (UDK) from Epic Games. You can freely preview APEX integration capabilities via recently released March version of UDK.

APEX Destruction assets can be added to UDK levels simply by dragging them from Content Browser window. Clothing assets are binded with AnimSetEditor.

Note: APEX Destructible assets are not visible in DX 11 render mode, only in DX 9.

Detailed docs on APEX Integration with UDK

We encourage developers to share their first impressions on APEX, using comments to this article.

NVIDIA PhysX SDK was updated to version 2.8.4.5

Since no updated release notes are avaialble, we assume that only minor bug fixes differs this release from previous one – 2.8.4.4

As always, you can download PhysX SDK 2.8.4.5 via Developer Support Center.

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

NVIDIA has released a first public version of PhysX SDK for Mac OS X.

Feature set is almost the same as for PhysX SDK 2.8.4 for PC, but unfortunately, Mac version is missing GPU PhysX support.

You can download PhysX SDK 2.8.4 for Mac OS X via Developer Support Center.

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