RELEASENOTES.md

PROJECT CHRONO

History of API changes, bug fixes, and new features

Release 2.0.0

October 14, 2013

• Migration of repository from SVN to GIT

• New FindChronoEngine.cmake file for easy creation of third party projects based on Chrono::Engine, using CMake.

Release 1.8.0

September 1, 2013

• Removed obsolete code in ChObject (old intrusive list members and data)

• Support for stiffness blocks in LCP/CCP/VIs/linear systems. For instance, this will foster the development of FEM functionalities. See, for instance, file source/lcp/ChLcpKstiffness.h.

• New functions BuildDiVector, FromVectorToUnknowns, FromUnknownsToVector, BuildDiagonalVector, in source/lcp/ChLcpSystemDescriptor.h These make much easier to develop solvers that leverage on the matrix by vector primitive, for the full VI(Zx-d) problem (not the reduced dual problem on Schur complement VI(Nl-r) as usual).

• Parallelization of many loops in performance-critical primitives in ChLcpSystemDescriptor, using OpenMP. This means that, in case of large systems, the performance is much better than in the previous releases.

• Optimizations in ChLcpConstraints about flags (the IsActive() function previously took many booleans, now it is cached).

Release 1.7.0

May 20, 2013

• Python support upgraded to Python 3.3 from 3.2, in pyChrono::Engine installer.

• New unit_COSIMULATION. It introduces functionalities to allow a side-to-side simulation of Chrono::Engine and another simulation software, such as Simulink or Amesim. It uses tcp-ip sockets for the communication and syncing. See the tutorial on the wiki.

• Important. A completely new approach to the realtime visualization in Irrlicht 3D has been developed. This is based on a new asset, called ChIrrNodeAsset: if added among the assets of a ChBody or other items, it will cause the other shapes in assets to be rendered in a Irrlicht window; it just takes a ChIrrAppInterfaceNew class and a ChIrrAssetConverter. See demo_irr_asset.cpp for an example. This new approach is the same method that you use in the unit_POSTPROCESS, that is, shapes and textures are added as assets. This unifies the approach to visualization, that is, you can switch to a POVray raytracing postprocessing to an Irrlicht realtime visualization by changing few lines of code. (Previously this was not possible because the Irrlich visualization was based on ChBody objects being wrapped inside ChBodySceneNodes that had to be inserted in Irrlicht managers).

• The Irrlicht visualization does not need to load the sphere and cylinder template meshes from .obj files in ../data/ , so there are troubles if the executable resides in a different directory structure.

• Improved method to handle 'cloned' items for visualization. The developer of new classes inherited from ChPhysicsItem should implement GetAssetsFrame() to return the coordinate frame of the shapes in the assets, and in the case of multiple clones of the same shapes (ex in ChParticlesClones) it shoould implement GetAssetsFrameNclones() and GetAssetsFrame(int n) must return the frame of the nth clone. This done, all visualization systems and postprocessors will render correctly and automatically.

• The way to import a SolidWorks system, in Python, has changed. Previously it was: import my_saved_system now it should be: chrono.ImportSolidWorksSystem('my_saved_system') This supports also paths, in the case that the saved system is in a subdirectory, ex '../my_dir/my_saved_system'. Also, it forces reloading.

• The ImportSolidWorksSystem() in unit_PYPARSER has been improved to support the case of systems saved in subdirectories. If assets contain relative paths such as in ChObjShapeFile, these are adjusted to avoid problems.

• new Python demos. The python demos have been moved into ChronoEngine/python, they have been removed from ChronoEngine/source/demos/python

• new demo_import_solidworks.cpp to show how to load a system that has been saved with SolidWorks using the C::E add-in.

• new CVisualization asset for defining the color of assets that define shapes to be rendered.

• Added ChSystem::IteratorPhysicsItems that iterates over all bodies, links and other physical items in general, that are inherited from the base class ChPhysicsItem.

• Improved ChPovRay postprocessor: when saving ChParticleClones items, instead than repeating the dump of assets in the my_stateNNN.pov file (which might lead to very large files when using >1'000 particles) it just dumps a #while loop in the pov file, that in turn will load only the xyz and rotation coordinates from raw data saved in a compact .dat file, in rendertime. This helps saving disk space.

• ChPovRay had a problem with texture suffixes longer than 3 chars, ex foo.jpeg. Bug fixed.

• In Python, the constructors of shared pointers to objects (objects that are handled via shared pointers, that end with ..Shared) now can optionally accept also the parameters of the pointed class, for example if ChConveyor can be built with three arguments: body_belt = chrono.ChConveyorShared(conv_length,conv_thick,conv_width) whereas previously you could do only body_belt = chrono.ChConveyorShared()

• bug with the Wavefront .obj loader for the POVray postprocessing unit (it crashed randomly when non-triangle faces were found). Note that only triangle faces are used, anyway.

• Experimental. The Irrlicht visualization system supports shadow maps. You just have to use application.AddLightWithShadow(..) instead than application.AddLight(..) or AddTypicalLights(..). The performance is a bit slower, but much faster and better looking than the previous system that used stencil shadows. NOTE: This works fine with Irrlicht v.1.7.3, but in Irrlicht v.1.8 it does not work with default DirextX driver: you must use video::EDT_OPENGL as argument when creating the ChIrrApp for OpenGL driver (and it works with a single lamp only).

• The build system has been changed so that the built binaries are not copied in the ChronoEngine source directory, in bin/, but stay into out-of-source directories. Also, debug and release libraries are not stored together anymore: the _DBG suffix is not used anymore, they are stored in Release and Debug sub directories. This will help porting to different platforms. The previous ChronoEngine/bin/ and ChronoEngine/lib/ directories are not used anymore. The ready-to-use prebuilt SDK has prebuit binaries and libs in Win32/, Win64/ directories.

• The installer for the prebuilt SDK has been updated.

• The template for the MSVC wizard has been update to reflect the new asset-based approach to visualization.

• The makes/FindChronoEngine.txt file has been updated to reflect the new build system. Also, the template_project/ files have been modified and a new demo project is here.

Release 1.6.0

July 19, 2012

• New asset of 'ChCamera' type, for defining a videocamera point ov view, zoom etc. This asset can be interpreted by postprocessing system (ex the exporter for POVray). Cameras can be added to moving objects.

• New asset of 'ChAssetLevel' type, that contains sub-assets and that can define a coordinate transformation respect to the parent asset. This allows the definition of hierarchies of assets with shapes, group of shapes, etc.

• Plug-in for SolidWorks. A custom SolidWorks add-in can be installed, so that in the SolidWorks CAD interface one can see some buttons to save the mechanism as a .py script.

• New installer for deploying the precompiled SolidWorks add-in.

• The SolidWorks add-in now exports also the UV coordinates of the mesh vertex points in the .obj shape files. This makes the .obj UV texturing easier (ex. by using BLender etc.).

• New ChPovRayAssetCustom in unit_POSTPROCESS. Allows adding custom POVray chuncks of code to the output .pov files (ex. materials, finishing, pigments, etc.)

• Improved Python units: support for dynamic casting via CastToXXYY helper functions, larger number of wrapped and supported classes, etc.

• New unit: unit_PYPARSER. It can be used by C++ programs to execute Python statements, scripts, etc. Most important, it can be used to populate a ChSystem with parts and constraints from a .py file exported from the SolidWorks Add-In.

• Updated to Irrlicht 1.7.3

• CMake v. 2.8.8 is required now (the old 2.8.6 had some problem in finding Python libraries from Python v.3)

Release 1.5.1

May 12, 2012

• New asset system. Look in source/assets/ directory. Assets can be assigned to ChPhysicsItems. This is extensively used in the new postprocessing system. The use can also inherit his special assets from the base class ChAsset.

• New installer for deploying the Python version of Chrono::Engine on user systems without efforts.

• New ChLinkMate class, with ChLinkMateGeneric, ChLinkMatePlan, etc, These can represent higher pair joints often used in mechanics, but they are less sophisticated (and faster) than the ChLinkLock classes, for example they do not need the addition of ChLinkMarker objects into the ChBody. They can represent the typical 'mating' constraints in assemblies of typical 3D CADs.

• New unit_POSTPROCESS supported also in Python. In python, after you imported chrono engine, yu can also type: import ChronoEngine_PYTHON_postprocess as postprocess

• The old ChTriangleMesh class has been renamed to ChTriangleMeshSoup. This because the ChTriangleMesh has become and abstract interface class for different types of triangle meshes. It is inherited by ChTriangleMeshSoup and the new ChTriangleMeshConnected, that allows shared vertices and information about normals and UV.

• By default, when two materials with different compliances become in contact, the resulting unique compliance of the contact is the SUM of the two compliances as a default behavior (whereas for other material parameters such as friction, the result is the minimum of the two values). This follows the theory of two springs in series.

• New installer for deploying the PyChrono::Engine stand-alone precompiled module for Python

Release 1.5.0

February 8, 2012

• File logging of system matrices and vectors. This feature has been added to allow off-line testing, debugging and development about the solver: the mass matrix, the jacobians and other terms that define the DVI are saved on disk in an Ascii format that can be loaded in Matlab for testing. Use ChLcpSystemDescriptor::ConvertToMatrixForm(). This overrides obsolete BuildMatrices() and BuildVectors().

• When pressing the 'Print Screen' key in the Irrlicht demos, the DVI system matrices are saved on disk in the same directory of the executable, as many 'dump_xxxyyyy.dat' files, for Matlab. This basically calls ChIrrAppInterface::DumpMatrices().

• New unit_PYTHON. This unit, once compiled, allows users to use Chrono::Engine from Python because a library is deployed among the 'modules' of Python. This is a major new feature. Users could develop programs based on Chrono::Engine without using C++ at all. Most functions and classes that are used in C++ are now accessible via Python, and the sytax is almost the same (some classes are not yet wrapped, but for the most important ones there is a one-to-one mapping - also operator overloading is supported).

• To modify friction, restitution and other surface properties of ChBody, ChrParticleClones and similar stuff, now one must use mybody->GetMaterialSurface()->.. In fact now surface properties are contained in a ChMaterialSurface object, that is referenced by each body. The reason is that in this way, many objects can share the same material (saving some memory and making the coding cleaner). By default, each body creates its own material when instanced, but later one can assign a shared material to multiple bodies, for example: ChSharedPtr msurface(new ChMaterialSurface); my_body_A->SetMaterialSurface(msurface); my_body_B->SetMaterialSurface(msurface); my_body_C->SetMaterialSurface(msurface); msurface->SetSfriction(0.3); Note that thank to shared pointers, material is automatically replaced in SetMaterialSurface and, if needed, also automatically deleted. Moreover backward API compability is ensured.

• New contact property: compliance. The compliance (inverse of stiffness) can be set for normal and tangential directions, in the new ChMaterialSurface object. It has the unit of m/N. Compliance, in general, has also the positive effect of making the convergence of the solver somehow faster. When compliance = 0, it turns into the original method with infinitely rigid bodies. Note that non-zero compliance disables the stabilization limit that one sets with SetMaxPenetrationRecoverySpeed(), so this means that with non-zero compliance one might have 'popping' contacts if the timestep is too large.

• New contact property: damping. The damping is specified as a factor 'alpha' of the stiffness K in the contact. That is, damping R=alpha*K; where for example it could be alpha=0.3 (it has the unit of time, [s]) Damping in general helps to have stable simulations and avoids numerical artifacts when simulating stacks of objects at rest.

• Important API change! Previous version of Chrono::Engine used to compute the friction coefficient in a contact as the average of the two friction coefficients of the two surfaces. From this version, instead, the default behavior has changed as THE MINIMUM of the two values. This applies also to other surface parameters in ChMaterialSurface, such as rolling friction, etc., excluding compliances (tangential,normal,etc) because they are summed, as happens for two springs in series.

• New functionality in ChIrrAppInterface class, to allow single-step of realtime simulations, by pressing the 'p' key, and to pause physics, by pressing the 'space' key. (Press also 'i' for infos).

• To use the new pause/singlestepping of the ChIrrAppInterface class, you should change the way you invoke the time integration in your program screen redraw loop, that is change commands like mphysicalSystem.DoStepDynamics( 0.01); into the new command application.DoStep(); Note that before entering the 'while()' loop, you need to enable the advanced step control by calling something like this: application.SetStepManage(true); application.SetTimestep(0.02);

• New solver based on spectral gradient method (Barzilai-Borwein) with nonmonotone Armijo steplength. It is called ChLcpIterativeBB. It has a much better convergence than projected SOR and similars, and the benefit of using it can be appreciated especially when running large scenarios with many iterations.

• New contact property: cohesion.

• The build system for the 'OpenCASCADE' unit was not compatible with the most recent version 6.5.1 of OpenCascade. Updated and fixed.

Release 1.4.0

September 1, 2011

• The collision family features previously required that a body was already added to a ChSystem, now collision families can be set also before adding bodies to a system.

• The rolling and spinning friction did not work properly with SOR-multithreaded solver: fixed.

• The ChParticlesClones class now supports rolling friction and spinning friction as in the ChBody class.

• New ChBodyAuxRef. This class is inherited from ChBody, but the difference is that in ChBodyAuxRef one can define a COG (center of mass) position that is not necessarily the main coordinate system of the rigid body (in this way, markers and collision shapes can be defined respect to some more intuitive coordinate system, and the COG can be displaced without affecting markers, links and collision shapes)

• New unit 'unit_CASCADE', in source/ dir. This new unit can be used to load CAD models in STEP format, using the conversion features of the OpenCASCADE opensource library. Note that you need to install the huge OpenCASCADE SDK in order to be able to compile the 'unit_CASCADE' (if you do not want to compile it, simply disable it in the CMake interface).

• New demos source/demos/matlab/demo_chfunctions_plot.cpp source/demos/basics/demo_chfunctions.cpp

• New demo source/demos/basics/demo_stepfile.cpp showing how to use the CASCADE unit to import a 3D model saved in STEP format from a 3D CAD (such as SolidEdge, Catia, SolidWorks, etc.)

• New demo source/demos/basics/demo_robot.cpp showing how to use the CASCADE unit to import a complex 3D assembly saved in STEP format from a 3D CAD (such as SolidEdge, Catia, SolidWorks, etc.), and how to compute the inverse kinematics of a robot by 'driving' the end effector with a ChLinkLockLock constraint.

• All the classes that were in the file source/physics/ChFunction.h are now placed in separate .h and .cpp files, in a new directory named source/motion_functions/ , and this will make easier to introduce new scalar functions. The old ChFunction.h simply loads the headers in motion_functions/ for backward compability.

• Important API change: the old ChFunction class was used both as a base class for other functions (ex. ChFunction_Sine) and as a 'y=constant' function; now it is only a base class, a pure interface, that does not implement Set_yconst() anymore. If you used the Set_yconst function, now you may need to do a dynamic_cast<ChFunction_Const>() before.

• The new demo 'demo_converter' shows how to load a 3D model in STEP format, that you have saved using a CAD. It also allows to save its triangulated mesh in .obj format. It requires the OpenCASCADE library - without that library, you cannot compile and/or run the demo.

• New functions in ChCModelBullet: AddTriangleMeshConcave() and AddTriangleMeshConcaveDecomposed() , to allow more control on the concave meshes for collision detection. The already-known basic method AddTriangleMesh(), in case of dynamic concave mesh, falls back to AddTriangleMeshConcaveDecomposed() with a default decomposition threshold.

Release 1.3.0

February 2, 2011

• Modified CMakeLists.txt to support also MingW GNU c++ under Windows and GNU C++ under Linux.

• From this release, the old 'makefile' based system is not_supported_anymore because there is the new CMake system. Files such as 'config.mak' and similar hae been removed.

• Other improvements in CMakeLists. In particular, the user can choose if to build only the demos or only the API, or both, and advanced units compilation can be disabled/enabled. Also, the path to ChronoEngine API is automatically initialized.

• License has been switched to GPL v.3

• Fixed a bug in deallocation of smart pointers in vectors of btCollisionShape items in ChCollisionShape deletion: it caused crashes when closing demos, in debug mode.

• Various warnings removed.

• Hash table classes improved for better compatibility with the GNU compiler.

• Better Doxygen template

• The MSVC wizard did not work properly with the latest release: now it is fixed.

• Added the /template_project/ directory, with files that can be used as a template for CMake-based external projects that use Chrono::Engine.

• A new WIKI has been started in the web site, aimed at containing instructions and tutorials.

Release 1.2.0

January 12, 2011

• MAJOR IMPROVEMENT: new build system based on CMake.
  This means that developers will exploit the power of IDE editors at their best, and the dependency of files is completely automated. [The previous system, based on the makefiles and config.mak, is -unsupported- even if the files will stay in the SVN for a while.]

• New API building process for exporting symbols from the dll. Previously, if one needed to rebuild the entire Chrono::Engine dll, he needed also the dlltool.exe and the sed.exe utilities, because a .def file was automatically generated. This was complicated and a bit unusual, so now we use the __declspec() method to mark exported classes (using macros in ChApiCE.h) and this is a more 'standard' process in Windows.

• The 'ChronoEngine/demos' directory has been moved to the 'ChronoEngine/source/demos' directory, to be more consistent (it contains source, for demo executables).

• Fixed a bug in the collision detection engine, that caused some collisions to be missed once in a while. This was related to different ways of managing thresholds in Bullet and Chrono::Engine.

• The CH_UNIT_CUDA flag has been renamed CH_UNIT_GPU.

Release 1.1.0

November 3, 2010

• The 64 bit versions of dll and lib are included in the Windows distribution.

• New feature: cohesion in contacts. This can be activated using the ChCustomCollisionPointCallback as shown in demo_cohesion.cpp

• New demo 'demo_cohesion', showing the simplified cohesion model, a new feature that allows to model granular material with some sticking (ex. soil).

• Collision engine updated to Bullet 2.77. Now also the collision shapes of rigid bodies can be marshalled using the C::E serialization.

• New unit: ChronoEngine_MPI.dll. This will be used to host code for cluster computing. It contains features for exploiting the MPI interface for high performance parallel computing. Compatibility is tested under MPICH-2. Under development / please do not use it.

• All CUDA code, previously spread in many directories and mixed with normal code, now is grouped in a single directory: unit_GPU.

• ChLcpIterativeCuda renamed ChLcpIterativeSolverGPUsimple. For this reason, and for the previous one, some includes have been changed.

• ChModelBullet::SetFamilyMaskNoCollisionWithFamily was broken in last release, since the Bullet collision code was updated with different functionalities. Bug fixed.

• The Javascript code is now completely separated from the main ChronoEngine.dll. This means that Javascript API is no longer needed if one wants to recompile C::E on platforms where JS is not easily available. The Javascript features are in ChronoEngine_JS.dll .

• The Cuda/GPU code is now completely separated from the main ChronoEngine.dll. This means that Cuda API is no longer needed if one wants to recompile C::E on platforms where Cuda is not easily available. The Cuda/GPU features are in ChronoEngine_GPU.dll .

• The CH_NOCUDA flag has been renamed CH_UNIT_CUDA, and its behaviour is reversed (TRUE enables CUDA).

• The GLOBAL_Vars global variable is deprecated. Use CHGLOBALS() function instead. Also, implementation of static global data have been improved.

• If the user forgets the DLL_CreateGlobals() and DLL_DeleteGlobals pair at the beginning/end of the program, a static default ChGlobal is used anyway.

• New classes ChStreamOstreamWrapper, ChStreamIstreamWrapper, ChStreamOutBinaryStream, ChStreamInBinaryStream. Class ChStreamWrapper renamed ChStreamOstreamWrapper

• In demos using Irrlicht realtime 3d view, now the AABB bounding boxes of rigid bodies can be drawn (press 'i' to show debugging GUI).

Release 1.0.0

September 1, 2010

• Elastic restitution is added. Use mybody->SetImpactC() to set the restitution coefficient. The Newton model is used (coefficient = ratio between pre/post impact normal speeds).

• Added SetMinBounceSpeed() in ChSystem class, to set a clamping that avoids high frequency rebounces with nonzero restitution coefficients.

• New ChConveyor class for creating conveyor belts.

• New demo_conveyor.exe to show an example of usage of the new ChConveyor class.

• Major feature: new ChMatterMeshless object to simulate point-based plastic deformable materials, using the meshless FEM approach. Useful for simulating mud, etc.

• Major feature: new ChMatterSPH object to simulate fluids.

• Improved ChVoightTensor class (computation of invariants etc.).

• New classes for continumm material properties: density, viscosity etc. Basic hookean material properties and tensor transformations are added.

• New classes for elastoplastic materials, with plastic flow.

• Experimental classes for different models of plastic flow: the strain-yeld-based Von Mises, and the Drucker-Prager criterion (the latter is under development)

• Improved ChSharedPtr and ChSmartPtr classes (added functions IsNull, boolean type casting, safer casting, etc.)

• Gyroscopic torque calculation contained a bug

• In case Chrono::Engine was installed in a path with spaces (ex. C:\blabla\Doucuments and Settings\blabla...) the make-chrono_lib did not work properly. Fixed.

• StreamOUTsparseMatlabFormat() for ChSparseMatrix, to dump sparse matrices on disk, for example, in Matlab sparse format.

• ComputeFeasabilityViolation, FromVariablesToVector, FromVectorToVariables moved from ChLcpSolver to ChLcpSystemDescriptor. Also, new method BuildMatrices() in ChLcpSystemDescriptor, for debugging, testing, etc., allowing to dump full mass and jacobian matrices.

Release 0.9.0

February 23, 2010

• The convex decomposition code has been updated and improved. Now there is a class collision/ChCConvexDecomposition.h that manages the convex decomposition for concave meshes, with settings.

• New demo 'demo_decomposition.exe', that shows interactively the effects of the parameters of the convex decompostion. It can save the decomposed hulls as files, with '.chulls' suffix, that can be loaded directly in the ChCollisionSystem.

• Improved ChIrrAppInterface.h Now the realtime visualization system of the demos allows also to change other settings such as the stabilization speed clamping and the lambda complementarity smoothing using mouse & sliders (when the info panel is displayed, pressing 'i').

• Added support for using a 'smoothing factor' lambda in the iterative complementarity solvers. This can help convergence and precision.

• New example 'demo_forklift.exe', showing a forklift vehicle that can be driven using the keyboard.

• New ChShaft physical object: it represents a 1-degree-of-freedom object (i.e. a rotating shaft, with no 3D shape) that can be used to create schematic power trains, when assembled with ChShaftsGear, ChShaftsClutch, etc.

• New ChShaftsGear: connects two ChShafts in 1D models of powertrains. It can be also used to simulate rigid torque joints between two ChShafts. Remember: this is a 1D model, useful whan you do not need full 3D representation of shafts, gears, bearings, etc (in that case, you would use Chbody, ChLinkGear, etc., but they are often more complicate than necessary).

• New ChShaftsClutch: it simulates a clutch between two ChShaft, for making 1D models of powertrains. Note that the clutch can be used also to simulate a brake, if one of the two ChShaft objects is set as 'fixed', to represent the truss.

• The ChShaftsClutch can have two different values for forward/backward max transmissible torque, to simulate freewheels and overrunning clutches.

• New ChShaftsPlanetary: it simulates a planetary gear, that is a constraint between three ChShaft entities. For instance, it can be used to make differentials in 1D powertrains of cars, or 1D models of epicycloidal reducers, or summation devices.

• New classes for constraints between three entities, in LCP solver libary. Those classes are used, for example, to make differentials in 1D models of powertrains. These are ChLcpConstraintThree, ChLcpConstraintThreeBBShaft, ChLcpConstraintThreeGeneric.

• New ChLcpConstraintTwoGenericBoxed constraint.

• The ChLinkLinActuator, in long simulations, added some numerical accumulation of errors (drifting of imposed positions). Fixed.

• Collision detection system updated to Bullet release 2.75.

• ChIrrCamera namespaces modified to avoid name pollution.

• The LCP_ITERATIVE_JACOBI solver had a bug that gave bad results in scenarios with lot of friction. (this is the normal CPU version of the Jacobi solver, the GPU version was correct). Fixed.

• For API developers: the ChCollisionSystem class does not have a SetContactContainer() function anymore, because we do not assume that there could be only one contact container. Now, instead, during the Run() command, now no contact is added to any container - only the basic CD is performed. Then, after the Run(), the new function ReportContacts(ChContactContainerBase* mcontactcontainer) can be called: this will fill the 'mcontactcontainer' object by calling its usual BeginAddContacts(), AddContact(), EndAddContacts() functions. The ChSystem manager will call automatically the ReportContacts() for the default contact container of the physical system after the collision detection, but it will also scan the list of ChPhysicsItems to see if there's some other container to be filled. Note: the same happens with ChProximityContainer physical items, that are filled ChContactContainer::ReportProximities() at each collision detection; for instance this is currently used to manage the SPH.

• API change! Class "ChParticles" renamed "ChParticlesClones". This makes more sense (it recalls that the particles share the same mass and the same collision shape). In fact now it is inherited from a new class ChIndexedParticles, for generic types of clusters of 6-DOF particles. Similarly, we added a new base class ChIndexedNodes for clusters of 3-DOF nodes, for instance in SPH and meshless point clouds.

• New ChMatterSPH class. It allows the creation of plasto-elastic material with large nonlinear deformations, based on a particle approach. Note, still experimental!

• Demos updated to newest Irrlicht-1.7.1. Older versions of Irrlich not supported.

Release 0.8

July 10, 2009

• New feature: rolling friction, and spinning (drilling) friction. The ChBody items can have coefficients for these two additional types of friction. Note, if using zero values for rolling and spinning friction, as by default, the simulation will be faster than with nonzero values.

• New demo for rolling friction 'demo_friction'.

• New function ChIrrTools::drawAllContactLabels(), to print infos near the contact points in 3D view (reaction forces, etc.)

• New ChMatlabEngine class, for starting a Matlab engine (if installed) and executing Matlab commands, or copying data from/to Matlab within a Chrono::Engine program. This is very useful because, if you have Matlab on your system, you can exploit the very powerful plotting capabilities of Matlab. See the new example demo_matlab.exe . Note: configure the demo makefile for your Matlab SDK directories, if any, otherwise do not compile the demo.

• Important note for developers: major changes in the class hierarchy and interfaces of the collision detection and contact management! In detail, contacts aren't added to the ChLink list anymore, but they are handled by a new object of ChContactContainerBase type. Inherited from ChContactContainerBase there is a default ChContactContainer class specialization that stores contacts in simple linked lists, for a typical CPU implementation; while a future ChContactContainerGPU specialization will handle contacts directly as buffers on the GPU. Read the points above for important changes that stem from this new design.

• The demo_hopper and demo_reactor (optional examples) have been updated to support the new way of handling contacts. Also, they do not use anymore ChBody items as spheres, but rather use the new ChParticles container, that save about 20% of RAM.

• ChSystem::SetCustomComputeCollisionCallback() interface has been changed. Its ChCustomComputeCollisionCallback::PerformCustomCollision() callback function now uses only (ChSystem* msys) as parameter. Some users used it to execute custom addition of further contacts to the system. Now this can be done in the callback by using the new concept msys->GetContactContainer()->AddContact(...)

• ChSystem::SetCustomCollisionPointCallback() interface has been changed. Its ChCustomCollisionPointCallback::ContactCallback() callback function now uses different parameters. See demo_suspension.cpp to see the modified example.

• New classes ChCollisionInfo, ChContactContainerBase, ChContactContainer, ChModelBulletBody, ChModelBulletParticle, ChPhysicsItem, ChParticles, ChAparticle, ChSharedMass, etc.

• Important change! ChBody and ChLink objects now share a parent class ChPhysicsItem. The ChPhysicsItem class is responsible of communicating ChVariables and ChConstraints to the LCP solver. Not only this unified interface simplifies things in the ChSystem methods, but also makes easier to develop custom new types of physical actors from the user-side. For instance, the new ChParticles object is inherited from ChPhysicsItem. The ChSystem supports whatever custom ChPhysicsItem object by new functions AddOtherPhysicsItem() and RemoveOtherPhysicsItem().

• Simplified Add() / Remove(). To add/remove items from the ChSystem, either you use AddBody(), AddLink() and AddOtherPhysicsItem(), or you can use a simplier unified function ' Add(ChPhysicsItem*) ' , that work in all cases (since also ChBody and ChLink objects are inherited form ChPhysicsItem anyway). The same for the new ' Remove(ChPhysicsItem*) ' function.

• To scan through all the contacts, now you should use a callback. Use ChContactContainerBase::ReportAllContacts(ChReportContactCallback* mcallback) for this purpose. (Previously, one iterated through the ChLink list until he found a ChLink of contact type, but the new design based on contact containers made this obsolete). See inside ChIrrDisplayTools.h for an example.

• The ChIrrWizard::add_typical_Camera() created a custom Irrlicht 3d camera that did not work properly in debug mode. Bug in ChIrrCamera.h code fixed.

• The VisualStudio wizard (that is installed automatically when an API user uses the InnoSetup installer to install Chrono::Engine on his system) has been updated to support VC 9.0, with some improvements.

• New function SetFriction() in ChBody and ChParticles. It sets both static and kinetic friction at once, with the same value. [Note: current version of the library does not yet support different values of static and kinetic friction coefficients, so this is suggested over the use of SetSfriction and SetKfriction, for the moment]

Release 0.7

May 10, 2009

• New feature: object picking (in demos inherited from the ChIrrAppInterface class, for example demo_collision.cpp). Use the middle mouse button to pick an object and move it in the interactive 3D view. Only objects that collide can be picked.

• For ChSystem object, you can use the method my_system.SetLcpSolverType(ChSystem::LCP_SIMPLEX); to enable a direct solver for calculating speeds. This is much slower than all iterative solvers (LC_ITERATIVE_xxx family) and cannot be used for systems with contacts, but it has the advantage that it is very precise. Hence, it can be used for simple mechanisms where precision is an issue (ex. robots or articulated mechanisms as in the demo_fourbar.exe).

• The GPU solver did not support the application of external forces (ex. springs). Now these forces are supported.

• Bug with ChLinkDistance: the clamping on speed recovery worked only in one direction.

• New ChSystem::SetOmega and ChSystem::GetOmega to set overrelaxation parameter of the iterative solver, if any, saving lot of typing respect to previous versions.

• New slider in Irrlicht setting panel, to set omega overrelaxation

• Collision margins for cylinder objects were a bit displaced (causing cylinders to 'sink' a bit into other shapes). Fixed.

Release 0.6

March 6, 2009

• The GPU complementarity solver has been optimized so that it skips unneeded compuations when thousands of objects touch a fixed object (this happens often, for example when many objects like pebbles are placed on the ground).

• Previous version of the GPU solver didn't work with the INT_TASORA timestepper. Now it works also with this stepper.

• A bug in the GPU solver has been fixed, about the loss of precision when using friction coefficients larger than 0.1

• Default omega relaxation value for Jacobi CCP solver has been reduced to 0.2 instead of 1.0, otherwise it was too likely a divergent value.

• New Length2() and LengthInf() in the ChVector class, to improve the speed of the norm of a vector in some optimised circumstances. Same Length2() and LengthInf() also for ChQuaternion class.

• New feature: rigid body sleeping. Use my_system.SetUseSleeping(true) When this feature is activated, bodies that remain in a resting position for enough time will be 'frozen' until a collision will set them awake again. In this way, simulating large scenarios with many objects resting on the ground can be much faster. However note that this feature aims at realtime simulations hence it may affect the precision of the results.

• Body sleeping can be turned on/off selectively for each body, when turning on global sleeping with my_system.SetUseSleeping(true).

• Support for Irrlicht 1.5. Few compatibility bugs are fixed. The old Irrlicht 1.4.2 isn't supported anymore.

• New custom camera for Irrlicht 3D viewing (the old Maya-like default camera in Irrlicht doesn't work anymore as desired). The new camera rotation/pan is controlled by mouse left and right buttons, the zoom is controlled by mouse wheel or rmb+lmb+mouse, the position can be changed also with keyboard up/down/left/right arrows, the height can be changed with keyboard 'PgUp' and 'PgDn' keys.

• Improved function ChIrrWizard functions (add_typical_Lights etc)

• New class ChIrrAppInterface to ease the creation of applications based on Irrlicht and Chrono::Engine. Applications based on this class will use Irrlicht for 3d rendering and, when the 'i' key is pressed on the keyboard, a small interface pops up and shows some profiling informations (num. of bodies, CPU time, etc.) and also allows the user to change the settings of the integrator.

• Most demos have been modified to use the ChIrrAppInterface base class. Their source code is simplier, yet the visualization has more features (press the 'i' key to show interfaces for settings).

Release 0.5

December 25, 2008

• Parallel solver for NVIDIA GPU architecture has been improved. A bug happened because single-precision in CUDA hardware caused normalization problems during time integration. Fixed. The performance of the GPU<->CPU memory communication has been improved.

• Porting to Linux platform completed (Thank to Jean-Luc Charles for hints and help). Only static linking is supported at the moment. The code has been succesfully tested in Ubuntu. There are two new directories in lib/ directory: Linux32_gcc and Linux64_gcc. Similar directories are in the bin/ directory (precompiled examples are not provided for Linux, to save space). To compile demos in Linux, cd into the ChronoEngine/demos/ directory and enter "make".

• New code for POSIX multithreading support in Linux/Unix platform. This allows the use of the multithreaded SOR parallel solver also in the Linux version. Note that multithreading support in Linux vesrion is still experimental.

• IMPORTANT: the recent ChMatrixBase class (introduced with release 0.4 as a base for the specialized ChMatrix33, ChMatrixNM and ChMatrixDynamic) has been renamed as ChMatrix for readability reasons, and also to be more coherent with releases previous than the v.0.4.

• Updated 'wizard' for the Visual C++ 2008 Express IDE: it is installed automatically in your VC editor during the installation of the chrono::engine SDK. This wizard replaces the old wizard for Visual C++ 2005 IDE, that is not supported anymore.

• New collision detection feature: contact families. Each body can be assigned to a family (in the interval 0..15) and each body can define a mask of families to collide with. This allows situations where two bodies are constrained near each other (as in the shoes of a track, for instance) but there is no need that they generate contacts. See ChCollisionModel class, for the functions SetFamily(int mfamily); GetFamily(); SetFamilyMaskNoCollisionWithFamily(int mfamily); etc.

• New demo 'demo_tracks', showing a simplfied bulldozer with tracks. This is an example of how to use the 'clone' objects that share the same collision geometry (each shoe-track collision model is described by many shapes, coming from the convex decomposition of a concave triangle mesh from an .obj file, so 'cloning' saves some memory and avoids that the cpu wastes time to repeat the convex decomposition for each shoe.)

• Serialization of ChLink inherited class has been completed and improved (StreamOUT, StreamIN).

Release 0.4

November 2, 2008

• Merged latest Chrono::Engine into the Chrono::R3D development trunk (for Realsoft OY). The Chrono::R3D plugin will use the new features.

• New function AddBarrel() in the ChCollisionModel class. This can be used to create convex collision geometries that are defined by lathing an arc of an ellipse around an axis. It can be used, for instance, to create the rollers of omnidirectional wheels of mobile robots, simplified rigid wheels for motorbikes or bycicles, etc.

• Support of latest Irrlicht library for 3D realtime viewing in demos. Please download Irrlicht 1.5 if you are using it for viewing. Also update your config.bak accordingly.

• New demo_mecanum.exe demo, showing a small mobile robot with unidirictional wheels.

• The entire ChVector class has been templated.

• new function addChBodySceneNode_easyClone() for the Irrlicht realtime viewing tools. This can be used to replicate a shape (with its mesh, colliding shape, mass, inertia, etc.) without the need of repeating the creation of distinct shapes, In fact, clones will use less memory because they can share the collision shapes.

• new function AddCopyOfAnotherModel() in ChCCollisionModel class. This can be used to have multiple object that share the same collision shapes. This is memory-friendly, especially if the cloned collision shapes are very complicated.

• Previous version had a bug in sphere-box collision algorithm causing spheres to sink a bit into boxes: since the amount of the penetration was small, it was not noticed. Now it has been fixed.

• Speed improvements. Many small structures, formerly allocated on heap, now are allocated on stack. This allows a general speedup of the simulation, up to x1.5 in many situations.

• Data structures optimized for smaller memory footprint. On average, large simulations require 30% less RAM. Also, the NCP complementarity solver uses jacobians with elements of 'float' type instead of 'double' type, saving memory (with minimum impact on precision)

• IMPORTANT: Major refactoring and evolution of the ChMatrix class. Now the ChMatrix class is only a base matrix class for the following specialized classes:

  • ChMatrixDynamic (works exactly as the former ChMatrix)
  • ChMatrixNM (faster performance since it uses stack, but cannot be resized)
  • ChMatrix33 (for coordinate transformations etc.Uses stack) Since the ChMatrix now is an abstract class, now you cannot create matrices from it: you must use the three child classes above. For example, if you previously created a 4x4 matrix using ChMatrix<> mm(4,4); now you must write ChMatrixDynamic<> mm(4,4); if you created 3x3 matrices with ChMatrix<> mm; now either use ChMatrixDynamic<> mm; or, better, the custom ChMatrix33<> mm. Note that you still can use ChMatrix as a pointer to whatever matrix.

• Functions for linear algebra have been moved to a new file with the class ChLinearAlgebra.

• Supporting of Microsoft Visual C++ Express 2008. From this version, support of VC 2005 edition is dropped.

• Bug in file streaming with different little/big endian convention has been fixed.

• Removed static data structures that made reentrancy difficult; the ChronoEngine dll now should be thread-safe.

Release 0.3.4

April 21, 2008

• The ChLcpIterativeCuda solver now supports also the bilateral links (not only the frictional contacts). The feature is still experimental (only 1000 scalar constraints by default, see num_GPU_bilaterals.h).

• Added support for compilation on 64bit platforms, thank to the two new compiler types COMPILER_MSVC_X64 and COMPILER_GCC_X64. This is under testing.

• The GPU solver also takes care of the time integration, which has been parallelized.

• Major revisions to the makefile system. If you created your own config.mak, please switch to the new one.

• The NONCUDA flag has been renamed CH_NOCUDA

• The 'b' values (known terms of constraint residuals) in the LCP solver structures were considered negative, now are considered positive, to match the same sign formalism in A.Tasora and M.Anitescu papers.

• Removed some auxiliary data structure in ChBody, so that each ChBody object is almost 30 bytes smaller. Also, ChBody updates of applied forces are faster.

Release 0.3.3

April 1, 2008

• New class ChLcpIterativeCuda: it is a solver which uses the GPU via CUDA parallel programming API (still at experimental stage).

• The ChSystem class supports the GPU solver ChLcpIterativeCuda

• New classes ChLcpConstraintTwoGPUcontN and ChLcpConstraintTwoGPUcontT added in the HyperOctant solver. Meanwhile, some classes in the solver have been refacored.

• ChLinkContact class inserted in ChLink hierarchy, between ChLink and ChLinkFastContact, so that the new ChLinkGPUcontact is its child too. Meanwhile, the entire ChLinkFast contact has been refactored.

• The ChDisplayTool functions have been updated to reflect the new functions of the ChLinkContact class. User code is not affected by these changes.

• Support for DigitalMars compiler temporarily removed, since no user is using it. Removed Win32_DigitalMars directories from bin/ and lib/.

• The 'nvcc' compiler had a compatibility problem with MS 'nmake': in fact nmake wasn't able to launch the nvcc compilation (strange enough, this does not happen if building with 'make' from MingW). Anyway, a workaround has been developed (nmake sets an env.variable and launches nvcc_compile.bat, which launches nvcc with the proper parameters).

Release 0.3.2

December 22, 2007

• All demos use the new Irrlicht-1.4 rendering engine (please UPGRADE to Irrlicht-1.4 if you used previous releases, and if you want to recompile the demos).

• Because of new features in Irrlicht-1.4, the ChBodySceneNode has been completely rewritten. (This class is useful only if you want to use Irrlicht as a visualization, as in the examples).

• Collision engine updated to Bullet 2.66, which provides better pool allocators.

• New function in ChSystem class: SetParallelThreadNumber(). This function can be used to modify the number of threads which run in parallel when you are using a parallel solver (ex. LCP_ITERATIVE_SOR_MULTITHREAD) In fact, by default the threads are 2, but more threads can give high performnce if you have a N-core processor (4-core, 8-core, etc.). If you are not using a multithreaded solver, this setting has no effect.

• Bug in the last version (0.3.1) of the collision engine: the creation of a ChSystem implied the allocation of 40Mb for contact manifolds, but it were never released at ChSystem deletion, hence: memory leakage. Fixed.

• Improved basic parser of ASCII streams in Chstream.h.

• New static functions to set the default margin and envelope. Use them once, and later, all times you will add geometries to your ChCollisionModel(s), these margin and envelope values will be used by default(if not otherwise specified): ChCollisionModel::SetDefaultSuggestedEnvelope(); ChCollisionModel::SetDefaultSuggestedMargin();

• New static string irr::scene::irrlicht_default_obj_dir in ChBodySceneNodeTools.h, to specify the directory where 3D .obj files with models for sphere, cylinder and cube can be found. Default is "../data/", but it can be changed.

• New ChLinkLockHook joint, wihch can be used to create hinges similar to spherical joints, but one of the three rotations is not allowed. That is, the objects are connected with a vertical hook (or a short chain) so that rotation on link's Y is not possible.

• Light range of Irrlicht created by ChIrrWizard::add_typical_Lights() is higher, because scenes were too dark in Irrlicht 1.4

• Bug: when zero contacts happened, the LCP_ITERATIVE_SOR_MULTITHREAD solver crashed. Fixed.

• API help for class documentation has been updated (previously was not complete because of a problem with the Doxygen automatic documentation).

Release 0.3.1

November 28, 2007

• New LCP_ITERATIVE_SOR_MULTITHREAD solver type, which exploits dual-core processors. The multithreading allows faster simulation. To activate it, use ChSystem::SetLcpSolverType(ChSystem::LCP_ITERATIVE_SOR_MULTITHREAD); This feature is still experimental (optimal processor balancing and efficient thread spinlocks are not yet implemented) but enough to work.

• Iterative solver 'warm starting' feature can be used also for the Tasora stepper (previously it worked only for Anitescu stepper).

• The way that collision margin was used has changed. Now contacts are created also a bit before the shapes come into contact. This improves the stability of the complementarity solver.

• New ChHashTable class for sublinear search of key-values records.

• New SetMaxPenetrationRecoverySpeed() and GetMaxPenetrationRecoverySpeed() methods in ChSystem class, for clamping correction speed in Anitescu stepper.

• New SetIterLCPwarmStarting() method in ChSystem for easily turn on/off the warm starting feature of both iterative solvers (speed and pos.stabilization) if used.

• New SetTolSpeeds() and GetTolSpeeds() in ChSystem, to specify which is the tolerance threshold for satisfying speeds in constraints (i.e. the LCP solver will stop iterating if reaches this tolerance during the solution of the speed-impulse problem)

• New SuggestSafeMargin() and SuggestEnvelope() functions in ChModelBullet class, replacing the old SuggestMargin() function. The SuggestSafeMargin() is almost as the previous SuggestMargin(), while SuggestEnvelope() is used to get contact infos from collision detection even if distance>0.

• Various bug fixes. Zero friction hanged the solver: fixed; Other minor fixes here and there.

Release 0.3.0

November 13, 2007

• Collision engine updated to Bullet 2.64 rc2. Better handling of collision envelopes, better concave-concave collision algorithm, etc.

• Support of convex decomposition of concave triangle meshes! (just remember: the triangle mesh must have a correct topology, ie. without holes, cracks, degenerate points, etc. Also, the convex decomposition can take some CPU time, so -for complex projects like videogames- it would be better if your art department performs convex decomposition off-line with some in-house asset tools, then you quickly load compounds of convex shapes on the fly, when the exe starts.)

• Improved demo_racing example: the car can cross some bumps which are imported using convex decomposition of generic concave meshes.

• Improved ChLinkGear constraint. The previous version had a bug in the SetCheckphase() function - now it works.

• New ChLinkPulley constraint. Can be used to constraint two pulleys as it they were connected by synchro belts.

• New example demo_gears. It explains how to simulate spur gears, bevel gears, inner-teeth gears and pulleys. All these topics are covered within a single mechanism, similar to an epicycloidal reducer.

• New RayTest() function in the ChCollisionSystem class. Example: it can be used for 'raycasting' type of simulations (ex. fast moving cars, where a simple radius/ground test can be sufficient to approximate the wheel/ground contact). Also, it can be used to simulate optical barrier sensors, and so on.

Release 0.2.2

October 31, 2007

• New installer: it automatically sets up the config.mak with the correct path to the chrono::engine SDK (and to the Irrlicht SDK, if needed). The same for the Visual C++ 2005 ChronoEngineWizard. So the user will need little or no efforts at all in configuring the SDK after the installation - no more manual typing of settings in the config.mak is needed.

• New 'wizard' for the Visual C++ 2005 Express IDE: it is installed automatically in your VC editor during the installation of the chrono::engine SDK. This means that you can use the menu File/New/Project.. of the VC editor, than choose ChronoEngineWizard from the Visual C++ group, and it automatically set up a C++ template project for you, already configured to use Chrono::Engine libs and headers (the same for Irrlicht).

• New directory demos/msvc/ containing examples based on Microsoft Visual C++ 2005 Express projects. These demos can be compiled only by users with that IDE.

• New ChIrrTools::drawChFunction() simple function to draw ChFunction objects as x-y plots in the Irrlicht 3D view. Test it with the new ChFunction_oscilloscope as in the 'racing' demo. Useful for testing, debugging, easy visualization of data, etc.

• Improved 'racing' demo, showing a simplified car model with real suspensions.

• Improved Initialize() methods for links. Can make easier the creation of constraints.

• New directory ChronoEngine/msvc_config. It contains three property sheets to be used to quickly configure a VisualC++ 2005 project - so that it can link and use ChronoEngine and Irrlicht. For example, create a project of 'Empty' type, go to the 'Property Manager' tab (usually at the left of the interface) and add the chrono_proj_config.vsprops property sheet to all configurations, then add chrono_proj_debug_libs.vsprops to your debug config only, then add chrono_proj_release_libs.vsprops to your release configuration only. Select the chrono_proj_config.vsprops, use the popup menu to see its properties, go to Macros tab, edit the two paths of ChronoEngine and Irrlicht so they match your installations. Note: all this task is not needed if you use the ChronoEngineWizard available in the Visual C++ Express, thank to the new SDK installer.

• New 'oscillator' project, showing how to use a Windows.Forms interface plus ChronoEngine plus an Irrlicht 3D view inside the Windows.Forms window. Note that the demo is not yet complete.

• Integration with the Irrklang library for sound effects has been tested.

• New tutorial 'Visual C++ Wizard' explaining how to use the new wizard, step by step.

• New 'install' documentation, with more detailed info, and easier to understand also for novice users.

Release 0.2.1

October 9, 2007

• A very large refactoring of all classes inherited from ChLink has been performed. New ChLinkMasked, ChLinkMarkers and other classes has been added as 'layers' between the ChLinkLock and the base ChLink.

• Thank to the refactoring of the ChLink class hierarchy, the ChLinkFastContact class inherits as few data as possible from the base ChLink (which is really lightweight when compared to the old implementation). This means that simulating systems with more than 100'000 objects (with contacts) is possible with systems with 2Gb of RAM, thank to this memory optimization.

• 'Warm starting' of iterative solver has been implemented. This means that, optionally, chrono::engine can cache the values of reaction forces in constraints (or contacts) so that they can be reused at the next integration step as a 'guess' to start the iterative complementarity solver. Using warm starting, the solver requires few iterations to get appreciable precision, regardless of the complexity of the system (while without warm starting, the more the objects, the more iterations could be needed to converge). The drawback is that in some cases large stacks might behave too 'bouncy'.

• New ChLinkDistance link, if you need a simple and computationally- efficient constraint imposing distance between two points on two bodies. Unlike the ChLinkLockLinact joint, this has less features but it is simplier and faster to compute (it does not need the two markers in bodies, it just takes two relative positions on the two bodies representing the end points of the imposed distance).

• New example: demo_suspension.exe . This shows how to use the new ChLinkDistance link to model rod structures such as those in racing car suspensions, which can be considered massless. (This saves you from creating specific bodies for all rods, with spherical links at the end, which could be a waste of cpu resources if the effect of their masses is negligible anyway). Also, it shows how to use the ChLinkSpring class to model a spring-damper.

• New example: racing.exe This is a project for the Microsoft Visual C++ 2005 Express, which shows how to use only the IDE to compile a program without dealing with makefiles and command line tools.

• Both 'release' and 'debug' libraries are available now, either for MingW GCC and MSVC. Previously, only the release liblaries were distributed, so creating programs in debug mode was difficult (because mixing debug and release libraries can give troubles if one uses 'new' for c++ objects shared across libraries). Now this is fixed, because ChronoEngineDBG.dll is distributed too.

• New example 'oscillator.exe' showing how to use chrono::engine and a Irrlicht 3D view within the Windows.Forms environment. Here, the user interface (buttons, etc.) are created with the .NET toolset of Windows.Forms, but a 3D OpenGL view is managed by Irrlicht.

• New ChFunction_Oscilloscope class. Similar to ChFunction_Recorder, but simpler and more targeted to recording with a circular buffer, for infinite storage queue of 'fifo' type.

Release 0.1.9

July 12, 2007

• This last minute release fixes a problem with the previous 0.1.8, that is the installer did not install some header files which might be required in some projects.

• Previous releases could not be installed in directories containing spaces in path names (ex: C:\Program files\chronoengine) otherwise this caused problems with the 'nmake' command-line building. Problem fixed.

Release 0.1.8

July 11, 2007

• The previous 0.1.7 release was compatible with Irrlicht 1.3 only, and gave compilation errors with the new release of Irrlicht 1.3.1 (for demo executables). Problem fixed.

• New 'benchmark.exe' demo, for testing and profiling purposes.

• Major code refactoring on the ChLink classes and derivates, but the updated code is NOT included in this minor release and will we postponed to the future major release. Anyway, be prepared to meet a new hierarchy of ChLink classes in future.

• New installer and new 'readme.txt' file with the list of changes in Chrono::Engine API.

Release 0.1.7

• First public downloadable release of the API.