Updated to CL 22627414:

* docs updates
* authoring fixes
* stress solver crash fixes

17 files changed, 147 insertions, 154 deletions

diff --git a/docs/_source/apex_importer.txt b/docs/_source/apex_importer.txt
index a0caef0..4b9fd08 100644
--- a/docs/_source/apex_importer.txt
+++ b/docs/_source/apex_importer.txt
@@ -3,15 +3,15 @@
 ApexImporter is a tool for converting destructible assets from APEX Destruction format to Blast&tm; asset format.  Whereas APEX Destruction only needs a
 list of connected chunks, Blast&tm; has a Bond structure to describe chunk connections.  Each Bond describes the interface between two chunks, and needs
 the area, centroid, and average normal of this interface.  ApexImporter computes this data automatically.  Interface search can be done in several ways:
-- <b>Exact mode</b>: Importer tries to find triangles from two chunks which lay in common surface. If such triangles are found, their intersections are considered as the interface. Interface may not exist.
-- <b>Forced mode</b>: This mode based on search for midplane between two chunks and intersecting them with offsetted midplane to find interface parameters. Creates bonds even if chunks have no common surface.
+- <b>Exact mode</b>: Importer tries to find triangles from two chunks which lay in common surface. If such triangles are found, their intersections are considered as the interface. Such an interface may not exist.
+- <b>Forced mode</b>: This mode is based on search for midplane between two chunks and intersecting them with offsetted midplane to find interface parameters. Creates bonds even if chunks have no common surface.
 
 
-A bond is not created if area of interface is zero.  The interface centroid is computed as center of mass of all interface polygon points.  The interface normal is computed as an average of normals of all planes comprising the interface surface.
+A bond is not created if the area of interface is zero.  The interface centroid is computed as center of mass of all interface polygon points.  The interface normal is computed as an average of normals of all planes comprising the interface surface.
 
 Note - for Blast&tm; to operate with satisfactory fracturing behavior, it does not require exact area, centroid, and normal values for Bonds.
 
-Along with creating a Blast&tm; asset, ApexImporter creates an *.obj or *.fbx file with description of chunks render geometry.  Blast asset data can be saved to *.llasset, *.tkasset or *.bpxa format. BPXA asset contains collision geometry and can be used in \ref pagesampleassetviewer.
+Along with creating a Blast&tm; asset, ApexImporter creates an *.obj or *.fbx file with description of chunk render geometry.  Blast&tm; asset data can be saved to *.llasset, *.tkasset or *.bpxa format. BPXA asset contains collision geometry and can be used in \ref pagesampleassetviewer.
 
 \verbatim
 USAGE:
diff --git a/docs/_source/api_ext_users_guide.txt b/docs/_source/api_ext_users_guide.txt
index fd03c94..e255e82 100644
--- a/docs/_source/api_ext_users_guide.txt
+++ b/docs/_source/api_ext_users_guide.txt
@@ -1,6 +1,6 @@
 /*! \page pageextapi Extensions (NvBlastExt)
 
-These are the current Blast extensions:
+These are the current Blast&tm; extensions:
 <br>
 <br>
 \subpage pageextshaders - Standard damage shaders (radial, shear, line segment) which can be used in NvBlast and NvBlastTk damage functions.
@@ -31,7 +31,7 @@ using a variety of encodings.  This extension comes with low-level serializers b
 \subpage pageextpxserialization - This module contains serializers for ExtPhysX objects.  Use in conjunction  with ExtSerialization.
 <br>
 <br>
-\subpage pageextphysx - A reference implementation of a physics manager, using the PhysX SDK.  Creates and manages actors and joints, and handles impact damage and uses the stress solver (ExtStress) to
+\subpage pageextphysx - A reference implementation of a physics manager, using the PhysX&tm; SDK.  Creates and manages actors and joints, and handles impact damage and uses the stress solver (ExtStress) to
 handle stress calculations.
 <br>
 <br>
diff --git a/docs/_source/api_globals_users_guide.txt b/docs/_source/api_globals_users_guide.txt
index 2a5a9bf..fe6d59f 100644
--- a/docs/_source/api_globals_users_guide.txt
+++ b/docs/_source/api_globals_users_guide.txt
@@ -59,7 +59,7 @@ NvBlastGlobalGetErrorCallback
 An internal, default error callback is used if the user does not set their own, or if NULL is passed into NvBlastGlobalSetErrorCallback.
 
 This error callback is used by NvBlastTk, as well as many extensions.  In addition, utility macros are provided such as
-<b>NVBLAST_LOG_ERROR</b> and <b>NVBLAST_LOG_WARNDING</b>.
+<b>NVBLAST_LOG_ERROR</b> and <b>NVBLAST_LOG_WARNING</b>.
 
 Finally, a function with signature given by NvBlastLog is provided which uses the global error callback,
 
diff --git a/docs/_source/api_hl_users_guide.txt b/docs/_source/api_hl_users_guide.txt
index c5262ed..c1504f5 100644
--- a/docs/_source/api_hl_users_guide.txt
+++ b/docs/_source/api_hl_users_guide.txt
@@ -49,8 +49,6 @@ For the remainder of this page we will be in the Nv::Blast namespace, and will d
 <br>
 
 
-BlastTk access the 
-
 BlastTk adds:
 
 - An object class hierarchy (see \ref tk_class_hierarchy, below).
@@ -63,7 +61,7 @@ the user to query them based upon either GUID or <b>TkIdentifiable</b> subclass
 <br>
 \section tk_class_hierarchy NvBlastTk Class Hierarchy
 
-- There are two abstract interfaces, one of which deriving from the other: <b>TkObject <- TkIdentifiable.
+- There are two abstract interfaces, one of which deriving from the other: <b>TkObject <- TkIdentifiable</b>.
  - Lightweight objects are derived from <b>TkObject</b>.
  - Objects which use a GUID and class identification are derieved from <b>TkIdentifiable</b>.
 - <b>TkAsset</b> derives from <b>TkIdentifiable</b>.  This is mostly a wrapper for NvBlastAsset, however it also stores
@@ -104,7 +102,7 @@ NvBlastTk(config)(arch).(ext)
 As a reminder, in this document we assume we are in the Nv::Blast namespace:
 
 \code
-using Nv::Blast;
+using namespace Nv::Blast;
 \endcode
 
 In order to use NvBlastTk, one first has to create a TkFramework singleton.  This simply requires a call
@@ -210,7 +208,9 @@ Otherwise, the mapped value will be a valid graph node index.
 
 Finally, to release a TkAsset, as with any TkObject-derived object, use the release() method:
 
+\code
 asset->release();
+\endcode
 
 <br>
 \section tkasset_instancing Instancing a TkAsset: Creation of a TkActor and a TkFamily
@@ -221,7 +221,7 @@ the framework's createActor function.  This family is accessible through the act
 <em>not</em> released automatically when all actors within it have been released.  The user must use the TkFamily's release() method (see TkObject base
 API) to do so.  (Or wait until the framework is released.)  If a family is released that contains actors, the actors within will be released as well.
 
-The TkFamily has a special roll in NvBlastTk, holding user-supplied event listeners (TkEventListener).  All <em>internal</em> actor creation and destruction
+The TkFamily has a special role in NvBlastTk, holding user-supplied event listeners (\ref TkEventListener).  All <em>internal</em> actor creation and destruction
 events are broadcast to listeners through split events (TkSplitEvent).  These signal when a fracturing operation has destroyed an actor and created
 child actors from it.  TkActor creation or release that occurs from an explicit API call do not produce events.  For example when creating a first unfractured
 instance of an asset using createAsset, or when calling the release() method on a TkActor.  TkJoint events are similarly broadcast to
@@ -229,7 +229,7 @@ receivers (TkJointEvent).  These signal when the actors which are joined by the
 They also signal when a joint no longer attaches actors and is therefore unreferenced.  The user may invalidate or release the joint using the TkObject
 release() method when this occurs (more on joint ownership in \ref tkjoints).
 
-To create an unfractured TkActor instance from a TkAsset, one first fills in a descriptor (TkActorDesc) and passes it to the framework's createActor function.
+To create an unfractured TkActor instance from a TkAsset, one first fills in a descriptor (\ref TkActorDesc) and passes it to the framework's createActor function.
 As with the TkAssetDesc, the TkActorDesc is derived from its low-level counterpart, the NvBlastActorDesc.  In addition the TkActorDesc holds a pointer to
 the TkAsset being instanced.  An example of TkActor creation is given below, given a TkAsset pointer <b>asset</b>.
 
@@ -292,7 +292,7 @@ actor3->getFamily().addListener(gMyReceiver);
 
 // Let's create two groups.  First, create a group descriptor.  This may be used to create both groups.
 TkGroupDesc groupDesc;
-groupDesc.pxTaskManager = &gTaskManager;	// physx::PxTaskManager-derived object
+groupDesc.workerCount = 1;	// this example processes groups on the calling thread only
 
 // Now create the groups
 TkGroup* group1 = framework->createGroup(groupDesc);
@@ -339,7 +339,7 @@ Examples of the three TkActor damage methods are given below.
 \subsection multiple_damage Multiple Damage Descriptors using NvBlastProgramParams
 
 <b>N.B. - with this method of damage, the lifetime of the NvBlastProgramParams <em>must</em> extend at
-least until the TkGroup::sync call for the actor.</b>
+least until the TkGroup::endProcess call for the actor.</b>
 
 \code
 NvBlastDamageProgram program =
@@ -376,7 +376,7 @@ material.maxDamageThreshold = 0.8f;
 NvBlastProgramParams params = { damageDescs, 2, &material };
 
 // Apply damage
-actor->damage(program, &params);	// params must be kept around until TkGroup::sync is called!
+actor->damage(program, &params);	// params must be kept around until TkGroup::endProcess is called!
 \endcode
 
 <br>
@@ -399,7 +399,7 @@ material.maxDamageThreshold = 0.8f;
 actor->getFamily().setMaterial(&material);
 \endcode
 
-<b>N.B. the lifetime of the material set <em>must</em> extend at least until the TkGroup::sync call for the actor.</b>
+<b>N.B. the lifetime of the material set <em>must</em> extend at least until the TkGroup::endProcess call for the actor.</b>
 
 Then to apply damage, use:
 
@@ -429,7 +429,7 @@ actor->damage(program, &damageDesc, (uint32_t)sizeof(RadialDamageDesc));
 
 This method is just like the one above, except that the user has the opportunity to override the material used during damage.
 
-<b>N.B. - the lifetime of the material passed in <em>must</em> extend at least until the TkGroup::sync call for the actor.</b>
+<b>N.B. - the lifetime of the material passed in <em>must</em> extend at least until the TkGroup::endProcess call for the actor.</b>
 
 This call is just like the one above with an extra material parameter:
 
@@ -462,10 +462,10 @@ given below.
 TkJointDesc desc;
 desc.families[0] = &actor0->getFamily();	// Assume we have a valid actor0 pointer
 desc.chunkIndices[0] = 1;	// This chunk *must* be a support chunk in the asset that created desc.families[0]
-desc.attachPositions[0] = physx::PxVec3(1.f, 2.f; 3.f);	// The attach position is in asset space
+desc.attachPositions[0] = physx::PxVec3(1.0f, 2.0f; 3.0f);	// The attach position is in asset space
 desc.families[1] = &actor1->getFamily();	// Assume we have a valid actor1 pointer... note, actor0 and actor1 could have the same family
 desc.chunkIndices[1] = 10;	// This chunk *must* be a support chunk in the asset that created desc.families[1]
-desc.attachPositions[1] = physx::PxVec3(4.f, 5.f; 6.f);	// The attach position is in asset space
+desc.attachPositions[1] = physx::PxVec3(4.0f, 5.0f; 6.0f);	// The attach position is in asset space
 
 // Create the external joint from the descriptor, which joins actor0 and actor1
 TkJoint* joint = framework->createJoint(desc);
@@ -473,10 +473,10 @@ TkJoint* joint = framework->createJoint(desc);
 // Now join actor0 to the NRF
 // desc.families[0] already contains actor0's family
 desc.chunkIndices[0] = 2;	// Again, this chunk must be a support chunk in the asset that created desc.families[0]
-desc.attachPositions[0] = physx::PxVec3(0.f, 0.f; 0.f);	// The attach position is in asset space
+desc.attachPositions[0] = physx::PxVec3(0.0f, 0.0f; 0.0f);	// The attach position is in asset space
 desc.families[1] = nullptr;	// Setting the family to NULL designates the world (NRF)
 // The value of desc.chunkIndices[1] is not used, since desc.families[1] is NULL
-desc.attachPositions[1] = physx::PxVec3(0.f, 0.f, 10.0f);	// Attach position in the world
+desc.attachPositions[1] = physx::PxVec3(0.0f, 0.0f, 10.0f);	// Attach position in the world
 
 // Create the external joint which joins actor0 to the world
 TkJoint* jointNRF = framework->createJoint(desc);
@@ -516,7 +516,7 @@ NvBlastTk uses events to communicate the results of actor splitting, joint updat
 that can be used to synchronize fracturing between multiple clients.
 
 Events are broadcast to listeners which implement the TkEventListener interface.  Listeners are held by TkFamily objects.  During
-a TkGroup::sync call (see \ref tkgroups), relevant events are broadcast to the listeners in the families associated with the actors
+a TkGroup::endProcess call (see \ref tkgroups), relevant events are broadcast to the listeners in the families associated with the actors
 in the group.
 
 A typical user's receiver implementation might take on the form shown below.
@@ -600,7 +600,7 @@ NvBlastTk objects that are derived from TkIdentifiable (TkAsset, TkFamily, and T
 system.  The TkIdentifiable interfaces setID and getID allow the user to set and access an NvBlastID for each object.  The NvBlastID
 is a 128-bit identifier.  TkIdentifiable objects are tracked by the TkFramework, which may be used to look up an object by its NvBlastID.
 
-Upon creation, TkIdentifiable objects are given a GUID, a unique NvBlastID.  The is welcome to change the object's guid at any time, with
+Upon creation, TkIdentifiable objects are given a GUID, a unique NvBlastID.  The user is welcome to change the object's guid at any time, with
 the restriction that the GUID cannot be all zero bytes.
 
 With an object's GUID, one may look up the object using the TkFramework function findObjectByID:
diff --git a/docs/_source/api_ll_users_guide.txt b/docs/_source/api_ll_users_guide.txt
index 4dddfdc..8d04ee8 100644
--- a/docs/_source/api_ll_users_guide.txt
+++ b/docs/_source/api_ll_users_guide.txt
@@ -34,9 +34,9 @@ in order to report warnings or errors.  Memory is managed by the user, and funct
 to be passed in.  A corresponding utility function that calculates the memory requirements is always present alongside such functions.  Temporary
 storage needed by a function is always handled via user-supplied scratch space.  For scratch, there is always a corresponding "RequiredScratch"
 function or documentation which lets the user know how much scratch space is needed based upon the function arguments.
-- Backwards-compatible, versioned, device-independent serialization is not handled by Blast&tm;.  There <em>is<\em> however a Blast&tm; extension
+- Backwards-compatible, versioned, device-independent serialization is not handled by Blast&tm;.  There <em>is</em> however a Blast&tm; extension
 which does, see \ref pageextserialization.  However, a simple form of serialization may be performed on assets and familes (see \ref pagedefinitions)
-via simple memory copy.  The data associated with these objects is available to the user, and may be copied and stored by the user.  There are
+via simple memory copy.  The data associated with these objects is available to the user, and may be copied and stored by the user.  
 Simply casting a pointer to such a block of memory to the correct object type will produce a usable object for Blast&tm;.  (The only restriction is
 that the block must be 16-byte aligned.)  Families contain a number of actors and so this form of deserialization recreates all actors in the family.
 This form of serialization may be used between two devices which have the same endianness, and contain Blast&tm; SDKs which use the same object format.
@@ -64,12 +64,12 @@ NvBlast(config)(arch).(ext)
 \section assets Creating an Asset from a Descriptor (Authoring)
 
 The NvBlastAsset is an opaque type pointing to an object constructed by Blast&tm; in memory allocated by the user.
-To create an asset from a descriptor, use the function NvBlastAssetCreate.  See the function documentation for a
+To create an asset from a descriptor, use the function \ref NvBlastCreateAsset.  See the function documentation for a
 description of its parameters.
 
 <b>N.B., there are strict rules for the ordering of chunks with an asset, and also conditions on the chunks marked as "support"
-(using the NvBlastChunkDesc::SupportFlag).  See the function documentation for these conditions.  NvBlastAssetCreate does
-<em>not</em> reorder chunks or modify support flags to meet these conditions.  If the conditions are not met, NvBlastAssetCreate
+(using the NvBlastChunkDesc::SupportFlag).  See the function documentation for these conditions.  NvBlastCreateAsset does
+<em>not</em> reorder chunks or modify support flags to meet these conditions.  If the conditions are not met, NvBlastCreateAsset
 fails and returns NULL.  However, Blast&tm; provides helper functions to reorder chunk descriptors and modify the support flags
 within those descriptors so that they are valid for asset creation.  The helper functions return a mapping from the original
 chunk ordering to the new chunk ordering, so that corresponding adjustments or mappings may be made for graphics and other data
@@ -84,21 +84,21 @@ std::vector<NvBlastChunkDesc> chunkDescs;
 chunkDescs.resize( chunkCount );	// chunkCount > 0
 
 chunkDescs[0].parentChunkIndex = UINT32_MAX;	// invalid index denotes a chunk hierarchy root
-chunkDescs[0].centroid[0] = 0.f;	// centroid position in asset-local space
-chunkDescs[0].centroid[1] = 0.f;
-chunkDescs[0].centroid[2] = 0.f;
-chunkDescs[0].volume = 1.f;	// Unit volume
+chunkDescs[0].centroid[0] = 0.0f;	// centroid position in asset-local space
+chunkDescs[0].centroid[1] = 0.0f;
+chunkDescs[0].centroid[2] = 0.0f;
+chunkDescs[0].volume = 1.0f;	// Unit volume
 chunkDescs[0].flags = NvBlastChunkDesc::NoFlags;
-chunkDescs[0].ID = 0;	// User-supplied ID.  For example, this can be the index of the chunkDesc.
-						// The ID can be left undefined.
+chunkDescs[0].userData = 0;	// User-supplied ID.  For example, this can be the index of the chunkDesc.
+                            // The userData can be left undefined.
 
 chunkDescs[1].parentChunkIndex = 0;	// child of chunk described by chunkDescs[0]
-chunkDescs[1].centroid[0] = 2.f;	// centroid position in asset-local space
-chunkDescs[1].centroid[1] = 4.f;
-chunkDescs[1].centroid[2] = 6.f;
-chunkDescs[1].volume = 1.0;	// Unit volume
+chunkDescs[1].centroid[0] = 2.0f;	// centroid position in asset-local space
+chunkDescs[1].centroid[1] = 4.0f;
+chunkDescs[1].centroid[2] = 6.0f;
+chunkDescs[1].volume = 1.0f;	// Unit volume
 chunkDescs[1].flags = NvBlastChunkDesc::SupportFlag; // This chunk should be represented in the support graph
-chunkDescs[1].ID = 1;
+chunkDescs[1].userData = 1;
 
 // ... etc. for all chunks
 
@@ -108,14 +108,14 @@ bondDescs.resize( bondCount );	// bondCount > 0
 
 bondDescs[0].chunkIndices[0] = 1;	// chunkIndices refer to chunk descriptor indices for support chunks
 bondDescs[0].chunkIndices[1] = 2;
-bondDescs[0].bond.m_normal[0] = 1.f;	// normal in the +x direction
-bondDescs[0].bond.m_normal[1] = 0.f;
-bondDescs[0].bond.m_normal[2] = 0.f;
-bondDescs[0].bond.m_area = 1.0;	// unit area
-bondDescs[0].bond.m_centroid[0] = 1.f;	// centroid position in asset-local space
-bondDescs[0].bond.m_centroid[1] = 2.f;
-bondDescs[0].bond.m_centroid[2] = 3.f;
-bondDescs[0].m_userData = 0;	// this can be used to tell the user more information about this
+bondDescs[0].bond.normal[0] = 1.0f;	// normal in the +x direction
+bondDescs[0].bond.normal[1] = 0.0f;
+bondDescs[0].bond.normal[2] = 0.0f;
+bondDescs[0].bond.area = 1.0f;	// unit area
+bondDescs[0].bond.centroid[0] = 1.0f;	// centroid position in asset-local space
+bondDescs[0].bond.centroid[1] = 2.0f;
+bondDescs[0].bond.centroid[2] = 3.0f;
+bondDescs[0].userData = 0;	// this can be used to tell the user more information about this
 								// bond for example to create a joint when this bond breaks
 
 bondDescs[1].chunkIndices[0] = 1;
@@ -165,9 +165,9 @@ N.B. the comment after the malloc call above.  NvBlastAsset memory <B>must</B> b
 <br>
 \subsection asset_releasing Releasing an Asset
 
-Blast&tm low-level does no internal allocation; since the memory is allocated by the user, one simply has to free the memory they've
+Blast&tm; low-level does no internal allocation; since the memory is allocated by the user, one simply has to free the memory they've
 allocated.  The asset pointer returned by NvBlastCreateAsset has the same numerical value as the mem block passed in (if the function
-is successful, or NULL otherwise).  So releasing an asset with memory allocate by <B>malloc</B> is simply done with a call to <B>free</B>:
+is successful, or NULL otherwise).  So releasing an asset with memory allocated by <B>malloc</B> is simply done with a call to <B>free</B>:
 
 \code
 free( asset );
@@ -177,7 +177,7 @@ free( asset );
 \section actors_and_families Creating Actors and Families
 
 Actors live within a family created from asset data.  To create an actor, one must first create a family.  This family is used by the initial actor created from
-the asset, as well as all of the descendent actors created by recursively fracturing the initial actor.  As with assets, family allocation is done by the user.
+the asset, as well as all of the descendant actors created by recursively fracturing the initial actor.  As with assets, family allocation is done by the user.
 
 To create a family, use:
 
@@ -374,7 +374,7 @@ NvBlastActorApplyFracture( fractureEvents, actor, fractureCommands, logFn, &time
 // Step three: Splitting
 
 // The Actor may be split into all its smallest pieces.
-uint32_t maxNewActorCount = NvBlastAssetGetChunkCount( asset, logFn );	// In the worst case, one NvBlastActor may be created for every chunk in the asset
+uint32_t maxNewActorCount = NvBlastActorGetMaxActorCountForSplit( actor, logFn );
 std::vector<NvBlastActor*> newActors( maxNewActorCount );
 
 // Make this memory available to NvBlastSplitEvent.
diff --git a/docs/_source/authoring_tool.txt b/docs/_source/authoring_tool.txt
index 602aa97..1ff1a33 100644
--- a/docs/_source/authoring_tool.txt
+++ b/docs/_source/authoring_tool.txt
@@ -2,11 +2,11 @@
 
 The application <b>AuthoringTool</b> is a command-line asset authoring utility.  It reads a file containing a single graphics mesh
 (currently .fbx and .obj format are supported in this tool), and fractures it according to the parameters given in the command line.
-User can configure output of tool. It can save render mesh geometry to .fbx or .obj file. 
+The user can configure the output of the tool. It can save render mesh geometry to .fbx or .obj files. 
 
-Additionally user can set how Blast data should be saved:
+Additionally, the user can choose how Blast&tm; data should be saved:
 
-	1) BPXA-asset which incorporates Blast data and collision geometry for physics engine. 
+	1) BPXA-asset which incorporates Blast&tm; data and collision geometry for physics engine. 
 
 	2) LL-asset which is Low Level asset data
 
diff --git a/docs/_source/definitions.txt b/docs/_source/definitions.txt
index f95e5a8..d73c310 100644
--- a/docs/_source/definitions.txt
+++ b/docs/_source/definitions.txt
@@ -1,7 +1,7 @@
 /*! \page pagedefinitions Definitions
 
 - <b>exact coverage</b>: the condition that a walk from any leaf chunk to its ancestor root chunk will always encounter exactly one support chunk
-- <b>family</b>: the memory allocated when an asset is instanced into its initial set of actors, and all descendent actors formed from fracturing the initial set, recursively
+- <b>family</b>: the memory allocated when an asset is instanced into its initial set of actors, and all descendant actors formed from fracturing the initial set, recursively
 - <b>root chunk</b>: a chunk with no parent
 - <b>leaf chunk</b>: a chunk with no children
 - <b>lower-support chunk</b>: a chunk that is either a support or subsupport chunk
diff --git a/docs/_source/ext_authoring.txt b/docs/_source/ext_authoring.txt
index aeae4e8..cc058d4 100644
--- a/docs/_source/ext_authoring.txt
+++ b/docs/_source/ext_authoring.txt
@@ -2,52 +2,51 @@
 
 The Authoring extension provides tools for creation of a Blast&tm; asset from a provided mesh.
 
-There are three tools for creation Blast asset.
+There are four tools for creation of Blast&tm; assets.
 
-First one is FractureTool (see NvBlastExtAuthoringFractureTool.h) which is used to fracture an input mesh. It supports Voronoi fracturing and also
-simple slicing.  Internal surfaces of output chunks can be tesselated and noise can be applied to them.  The slicing method supports slicing with
-a noisy slicing surface, which allows the creation of a jagged slicing line.  Noisy slicing is switched on by setting a non-zero noise amplitude
-in slicing parameters (Nv::Blast::SlicingConfiguration).
 
 <br>
 \section fracturetool FractureTool
 
-Nv::Blast::FractureTool supports two types of output:
+Nv::Blast::FractureTool (see NvBlastExtAuthoringFractureTool.h) is used to fracture an input mesh.  It supports Voronoi fracturing and also simple slicing.  Internal surfaces of output chunks can be tesselated and noise can be applied to them.  The slicing method supports slicing with a noisy slicing surface, which allows the creation of a jagged slicing line.  Noisy slicing is switched on by setting a non-zero noise amplitude in slicing parameters (Nv::Blast::SlicingConfiguration).
+
+
+FractureTool supports two types of output:
 
 1) Array of triangles - the tool fills provided array with triangles of chunk, ID of chunk should be provided.
 
-2) Buffered output - tool fills provided array with vertices, and another array of arrays with indices. Indices form triplets of vertices of triangle.
+2) Buffered output - the tool fills provided array with vertices, and another array of arrays with indices. Indices form triplets of vertices of triangle.
 
 <br>
 \section convexmeshbuilder ConvexMeshBuilder
 
-Nv::Blast::ConvexMeshBuilder is tool for creation collision geometry for physics engine. It recieves mesh vertices, and returns convex hull of that vertices. If creation of convex hull fails,
+Nv::Blast::ConvexMeshBuilder is a tool for creation of collision geometry for physics engine. It recieves mesh vertices, and returns the convex hull of those vertices. If creation of a convex hull fails, the
 tool creates collision geometry as a bounding box of provided vertices.
 
-Tool provides method to trim convex hulls against each other. It can be used along with noisy slicing to avoid "explosive" behavior due to penetration of neighboor collision hulls into each other.
-As a drawback penetration of render meshes into each other is possible due to trimmed collision geometry. 
+The tool provides a method to trim convex hulls against each other. It can be used along with noisy slicing to avoid "explosive" behavior due to penetration of neighboring collision hulls into each other.
+As a drawback, penetration of render meshes into each other is possible due to trimmed collision geometry. 
 
 <br>
 \section bondgenerator BondGenerator
 
-Nv::Blast::BlastBondGenerator tool for creation Blast Bond descriptors from provided geometry data. 
-It has separate method which is optimized for working FractureTool. 
+Nv::Blast::BlastBondGenerator is a tool for creation of Blast&tm; Bond descriptors from provided geometry data. 
+It has separate a method which is optimized for working FractureTool. 
 \code
 int32_t Nv::Blast::BlastBondGenerator::buildDescFromInternalFracture(FractureTool* tool, const std::vector<bool>& chunkIsSupport, std::vector<NvBlastBondDesc>& resultBondDescs, std::vector<NvBlastChunkDesc>& resultChunkDescriptors);
 \endcode
 
-Other methods can work with prefractured mesh created in Third party tool, and can be used for converting prefractured models to Blast assets.
+Other methods can work with prefractured meshes created in Third party tools, and can be used for converting prefractured models to Blast&tm; assets.
 
 Nv::Blast::BlastBondGenerator supports two modes of NvBlastBond data generation:
 
 1) Exact - in this mode exact common surface between chunks is found and considered as interface between them. Exact normal, area and centroid are computed.
 
-2) Average - this mode uses approximations of interface, and can be used for gathering NvBlastBond data for assets, where chunks penetrate each other, e.g. chunks with noise.
+2) Average - this mode uses approximations of the interface, and can be used for gathering NvBlastBond data for assets, where chunks penetrate each other, e.g. chunks with noise.
 
 <br>
 \section meshcleaner MeshCleaner
 
-Nv::Blast::MeshCleaner can be used to remove self intersections and open edges in interior of mesh, making it more likely to fracture well.
+Nv::Blast::MeshCleaner can be used to remove self intersections and open edges in the interior of a mesh, making it more likely to fracture well.
 
 To use it, create a MeshCleaner using
 
@@ -55,7 +54,7 @@ To use it, create a MeshCleaner using
 Nv::Blast::MeshCleaner* cleaner = NvBlastExtAuthoringCreateMeshCleaner();
 \endcode
 
-Given an Nv::Blast::Mesh called "mesh," simply call
+Given an Nv::Blast::Mesh called "mesh", simply call
 
 \code
 Nv::Blast::Mesh* newMesh = cleaner->cleanMesh(mesh);
diff --git a/docs/_source/ext_import.txt b/docs/_source/ext_import.txt
index b7a17e2..db5ff10 100644
--- a/docs/_source/ext_import.txt
+++ b/docs/_source/ext_import.txt
@@ -15,9 +15,9 @@ struct ApexImporterConfig
 
 1) EXACT - Importer tries to find triangles from two chunks which lay in common surface. If such triangles are found, their intersections are considered as the interface.
 
-2) FORCED - Bond creation is forced no matter how far chunks from each other. Interface parameters are approximated.
+2) FORCED - Bond creation is forced no matter how far chunks are from each other. Interface parameters are approximated.
 
-Nv::Blast::ApexImporter::ApexImportTool can be itinialized by providing ApexSDK and ModuleDestructible, or they can be created internally.
+Nv::Blast::ApexImporter::ApexImportTool can be initialized by providing ApexSDK and ModuleDestructible, or they can be created internally.
 
 If ApexSDK and ModuleDestructible were provided, they are not freed when Nv::Blast::ApexImporter::~ApexImportTool() is called.
 <br>
diff --git a/docs/_source/ext_physx.txt b/docs/_source/ext_physx.txt
index afc24a6..ff998c2 100644
--- a/docs/_source/ext_physx.txt
+++ b/docs/_source/ext_physx.txt
@@ -1,34 +1,34 @@
-/*! \page pageextphysx PhysX Extensions (NvBlastExtPhysX)
+/*! \page pageextphysx PhysX&tm; Extensions (NvBlastExtPhysX)
 
-NvBlastExtPhysX contains classes for easier use of Blast Toolkit with the PhysX SDK.
+NvBlastExtPhysX contains classes for easier use of Blast&tm; Toolkit with the PhysX&tm; SDK.
 There are 3 of them:
-- <b>ExtPxManager</b>: Manager to keep Blast Actors in sync with PhysX actors.
-- <b>ExtImpactDamageManager</b>: Manager to collect and apply impact damage caused by collision in PhysX Scene.
-- <b>ExtPxStressSolver</b>: Stress Solver to propagate stress through support graph and apply it as damage to Blast actors.
+- <b>ExtPxManager</b>: Manager to keep Blast&tm; actors in sync with PhysX&tm; actors.
+- <b>ExtImpactDamageManager</b>: Manager to collect and apply impact damage caused by collision in PhysX&tm; scene.
+- <b>ExtPxStressSolver</b>: Stress Solver to propagate stress through support graph and apply it as damage to Blast&tm; actors.
 
-This library also contains an extension for synchronizing Blast state:
-- <b>ExtSync</b> - Utility for writing Blast state to a buffer, to be read by a client.  This may be used for networking, for example.
+This library also contains an extension for synchronizing Blast&tm; state:
+- <b>ExtSync</b> - Utility for writing Blast&tm; state to a buffer, to be read by a client.  This may be used for networking, for example.
 
 
 <br>
 \section ExtPxManager
 
-<b>Physics Manager</b> - is a reference implementation for keeping Blast Actors synced with PhysX actors. It's main job is to listen
+<b>Physics Manager</b> - is a reference implementation for keeping Blast&tm; actors synced with PhysX&tm; actors. Its main job is to listen
 for TkFamily events and update \a PxScene (by adding and removing PxActors) accordingly.
 
-In order to use it create an ExtPxManager.  If we have a physx::PxPhysics object m_physics and a TkFramework m_tkFramework, use
+In order to use it, create an ExtPxManager.  If we have a physx::PxPhysics object m_physics and a TkFramework m_tkFramework, use
 
 \code
 ExtPxManager* pxManager = ExtPxManager::create(m_physics, m_tkFramework);
 \endcode
 
-For every \a TkAsset prepare \a ExtPxAsset. Which contains \a TkAsset + collection of physics geometry for every chunk. Every chunk can contain any number of subchunks.
-Where each subchunk is basically PxConvexMeshGeometry with transform. Also every chunk can be marked as static (\a isStatic flag). 
-If actor contains at least one static chunks in it's support graph it makes an actor kinematic (static), otherwise it's dynamic.
-Having zero subchunks makes chunk invisible in physics scene, it can be used for example to represent 'earth' as a special invisible static chunk and connect all near earth chunks to it.
+For every \a TkAsset prepare \a ExtPxAsset, which contains \a TkAsset + collection of physics geometry for every chunk. Every chunk can contain any number of subchunks,
+where each subchunk is basically a PxConvexMeshGeometry with transform. Also every chunk can be marked as static (\a isStatic flag). 
+If an actor contains at least one static chunk in its support graph, it makes that actor kinematic (static). Otherwise the actor is dynamic.
+Having zero subchunks makes the chunk invisible in the physics scene. It can be used for example to represent 'earth' as a special invisible static chunk and connect all near earth chunks to it.
 
 
-To create a \a ExtPxFamily from an \a ExtPxAsset:
+To create an \a ExtPxFamily from an \a ExtPxAsset:
 
 \code 
 ExtPxFamilyDesc familyDesc;
@@ -49,7 +49,7 @@ family->subscribe(listener);
 
 The listener will be notified with all physics actors added and removed.
 
-And finally spawn the family in some world position (the first actor/actors will be created and event will be fired to the listener):
+And finally spawn the family in some world position (the first actor/actors will be created and an event will be fired to the listener):
 
 \code 
 
@@ -62,15 +62,15 @@ ExtPxSpawnSettings spawnSettings = {
 family->spawn(PxTransform(0, 0, 0), PxVec3(1, 1, 1), spawnSettings);
 \endcode
 
-You can get families actor's either from listening to events or by calling getActors(). 
+You can get a family's actors either from listening to events or by calling \a getActors(). 
 Every \a ExtPxActor matches 1 <-> 1 with TkActor (which matches \a NvBlastActor accordingly).
 
 \code
 ExtPxActor* actor = ....; 
-physx::PxRigidDynamic rigidDynamic = actor->getPxActor(); // 
+physx::PxRigidDynamic rigidDynamic = actor->getPxActor(); 
 \endcode
 
-An ExtPxActor remains internally unchanged through its lifetime.
+An ExtPxActor remains internally unchanged throughout its lifetime.
 Use \a ExtPxActor \a getChunkIndices() and  \a getPxActor() to update your graphics representation. Sample code:
 
 \code
@@ -87,15 +87,15 @@ for (uint32_t i = 0; i < chunkIndexCount; i++)
 }
 \endcode
 
-In order to use joints set joint create function with \a ExtPxManager::setCreateJointFunction(...). It will be called when new TkJoint's are
-being created. All the joint updates and remove will be handled by manager internally.
+In order to use joints set a joint creation function with \a ExtPxManager::setCreateJointFunction(...). It will be called when new TkJoints are
+being created. All the joint updates and removals will be handled by the manager internally.
 
 <br>
 \section ExtImpactDamageManager
 
-<b>Impact Damage Manager</b> - is a reference implementation for fast and easy impact damage support. It's built on top of ExtPxManager.
+<b>Impact Damage Manager</b> - is a reference implementation for fast and easy impact damage support. It is built on top of ExtPxManager.
 
-In order to use it create it:
+In order to use it, create it as follows:
 
 \code
 ExtImpactDamageManager* impactManager = ExtImpactDamageManager::create(pxManager);
@@ -125,8 +125,7 @@ Call \a applyDamage() when you want the buffered damage to be applied:
 impactManager->applyDamage();
 \endcode
 
-<b>N.B.</b> for impact damage to work, you must enable contact notification with custom the filter shader for PxScene. \a ExtImpactDamageManager has a reference filter shader 
-implementation which can be used for that:
+<b>N.B.</b> for impact damage to work, you must enable contact notification with custom filter shader for PxScene. \a ExtImpactDamageManager has a reference filter shader implementation which can be used for that:
 
 \code
 PxSceneDesc sceneDesc;
@@ -156,8 +155,7 @@ stressSolver->update(doDamage);
 
 By default it will apply scene gravity on static actors and centrifugal force on dynamic actors.
 
-The underlying ExtStressSolver can be accessed using ExtPxStressSolver::getSolver().  For example, to apply impulse to
-a particular actor, use applyImpulse(...) can be called for additional stress to apply:
+The underlying ExtStressSolver can be accessed using \a ExtPxStressSolver::getSolver().  For example, to apply impulse to a particular actor, \a applyImpulse(...) can be called for additional stress to apply:
 
 \code
 stressSolver->getSolver().addForce(actor, position, impulse);
@@ -172,7 +170,7 @@ stressSolver->release();
 <br>
 \section ExtSync
 
-<b>Synchronization Extension (NvBlastExtSync)</b> - is a reference implementation for synchronizing Blast state. 
+<b>Synchronization Extension (NvBlastExtSync)</b> - is a reference implementation for synchronizing Blast&tm; state. 
 
 The idea is that you can use it to write synchronization events to the buffer (on server for example) and then apply this buffer on
 a client. TkFamily ID should be properly set for that.
@@ -183,13 +181,13 @@ a client. TkFamily ID should be properly set for that.
 - <b>ExtSyncEventType::FamilySync</b>: Family sync event. Contains all necessary information to fully sync TkFamily state.
 - <b>ExtSyncEventType::Physics</b>: Physics sync event. Contains all necessary information to fully sync ExtPxFamily state.
 
-In order to use it create ExtSync:
+In order to use it, create ExtSync:
 
 \code
 ExtSync* sync = ExtSync::create();
 \endcode
 
-Then let ExtSync insatnce listen to family fracture commands and write them to internal buffer:
+Then let ExtSync instance listen to family fracture commands and write them to internal buffer:
 
 \code
 TkFamily* family = ...;
diff --git a/docs/_source/ext_pxserialization.txt b/docs/_source/ext_pxserialization.txt
index 21761fb..a8f4ea0 100644
--- a/docs/_source/ext_pxserialization.txt
+++ b/docs/_source/ext_pxserialization.txt
@@ -4,7 +4,7 @@ This extension contains serializers which can be loaded into the ExtSerializatio
 
 To use this extension, you must also load the ExtSerialization extension and create a serialization manager as described in \ref pageextserialization.
 
-We repeat this here (again, assuming we're in the Nv::Blast namespace):
+We repeat this here (again, assuming we are in the Nv::Blast namespace):
 
 \code
 ExtSerialization* ser = NvBlastExtSerializationCreate();
@@ -39,10 +39,10 @@ uint64_t size = ser->serializeIntoBuffer(buffer, asset, ExtPxObjectTypeID::Asset
 
 or use the wrapper function defined in <b>NvBlastExtPxSerialization.h</b>:
 
-/code
+\code
 void* buffer;
 uint64_t size = NvBlastExtSerializationSerializeExtPxAssetIntoBuffer(buffer, *ser, asset);
-/endcode
+\endcode
 
 <br>
 */
diff --git a/docs/_source/ext_serialization.txt b/docs/_source/ext_serialization.txt
index fe276f8..b6b8ef0 100644
--- a/docs/_source/ext_serialization.txt
+++ b/docs/_source/ext_serialization.txt
@@ -43,22 +43,22 @@ Each serialization module defines the object types it can serialize.  ExtSeriali
 
 To serialize an object, for example an NvBlastAsset, use ExtSerialization::serializeIntoBuffer as follows:
 
-/code
+\code
 const NvBlastAsset* asset = ... // Given pointer to an NvBlastAsset
 
 void* buffer;
 uint64_t size = ser->serializeIntoBuffer(buffer, asset, LlObjectTypeID::Asset);
-/endcode
+\endcode
 
 If successful, the data is written into a buffer allocated using the NvBlastGlobals allocator, written to the "buffer" parameter, and the size of the buffer
 written is the return value of the function.  If the function returns 0, then serialization was unsuccessful.  Notice that the second function parameter is actually a void*,
-so it requires the last parameter to tell it what object it's serializing.  A utility wrapper function is given in <b>NvBlastExtLlSerialization.h</b> which performs the
+so it requires the last parameter to tell it what object it is serializing.  A utility wrapper function is given in <b>NvBlastExtLlSerialization.h</b> which performs the
 same operation with an NvBlastAsset, so one could equivalently use
 
-/code
+\code
 void* buffer;
 uint64_t size = NvBlastExtSerializationSerializeAssetIntoBuffer(buffer, *ser, asset);
-/endcode
+\endcode
 
 A corresponding function also exists for NvBlastFamily, as well as other data types supported by other serialization extensions.
 
@@ -155,7 +155,7 @@ default:
 \subsection peeking_and_skipping Peeking at and Skipping Buffer Data
 
 If a buffer contains multiple objects, you may peek at the buffer to get object information including object type, encoding, and data size, and skip to
-the next object in the buffer (whether or not you've chosen to read the current object).  For example:
+the next object in the buffer (whether or not you have chosen to read the current object).  For example:
 
 \code
 const void* buffer = ... // The input buffer
diff --git a/docs/_source/ext_stress.txt b/docs/_source/ext_stress.txt
index 6ea909a..341fc12 100644
--- a/docs/_source/ext_stress.txt
+++ b/docs/_source/ext_stress.txt
@@ -1,11 +1,11 @@
 /*! \page pageextstress Stress Solver Extension (NvBlastExtStress)
 
 
-The Blast&tm; stress solver extension provides implementation of quite fast and easy to use stress solver which works directly with bond graph. It simulates more
-complex damage model on support graph by allowing to apply forces on nodes of support graph (on chunks). The most common usage is just applying gravity force on a static construction
-so that it will fall apart at some point when carcass can't hold anymore. Dynamic actors are also supported, you could for example add centrifugal force so that rotating object fast enough will break bonds.
+The Blast&tm; stress solver extension provides an implementation of a quite fast and easy to use stress solver which works directly with the bond graph. It simulates more
+complex damage model on support graph by allowing to apply forces on nodes of the support graph (on chunks). The most common usage is just applying gravity force on a static construction
+so that it will fall apart at some point when the carcass cannot hold anymore. Dynamic actors are also supported, you could for example add centrifugal force so that rotating an object fast enough will break bonds.
 
-It is also can be used as an another way to apply impact damage, which can give visually pleasant result of breaking actor in a weak place instead of the place of contact.
+It also can be used as another way to apply impact damage, which can give the visually pleasant result of an actor breaking in a weak place instead of the place of contact.
 
 <br>
 \section stresssolverfeatures Features
@@ -13,24 +13,22 @@ It is also can be used as an another way to apply impact damage, which can give
 - Requires only core \a NvBlast
 - Supports both static and dynamic actors
 - Propagates both linear and angular momentum
-- Graph complexity selection (reduces support graph to smaller size trade off speed and quality)
-- Apply stress damage on Blast Actor
+- Graph complexity selection (reduces support graph to smaller size to trade-off speed for quality)
+- Apply stress damage on Blast&tm; actor
 - Debug Render
 
 <br>
-\section stresssolvertunning Settings Tuning
+\section stresssolvertuning Settings Tuning
 
-Computational time is linearly proprtional to \a bondIterationsPerFrame setting. To fine tune look for balance 
-between \a bondIterationsPerFrame and \a graphReductionLevel . The more bond iterations
-are set the more precise computation will be. The smaller graph allows to make higher fidelity computations witihing 
-the same bond iterations per frame (same time spent), but actual cracks (damaged bonds) will be more sparsed as the result.
+Computational time is linearly proportional to the \a bondIterationsPerFrame setting. To fine tune, look for balance between \a bondIterationsPerFrame and \a graphReductionLevel . The more bond iterations
+are set, the more precise the computation will be. The smaller graph allows to make higher fidelity computations within the same bond iterations per frame (same time spent), but actual cracks (damaged bonds) will be more sparse as the result.
 
-Debug render could help a lot with that, consider using \a stressSolver->fillDebugRender(...) for that.
+Debug render can help a lot for tuning, consider using \a stressSolver->fillDebugRender(...) for that.
 
 <br>
 \section stresssolverusage Usage 
 
-In order to use it create an instance with \a ExtStressSolver::create(...).
+In order to use the stress solver, create an instance with \a ExtStressSolver::create(...).
 
 \code
 ExtStressSolver* stressSolver = ExtStressSolver::create(family, settings);
@@ -38,25 +36,23 @@ ExtStressSolver* stressSolver = ExtStressSolver::create(family, settings);
 
 \a ExtStressSolverSettings are passed in create function, but also can be changed at any time with \a stressSolver->setSettings(...).
 
-It fully utilizes the fact that it knows initial support graph structure and does maximum of processing 
-in \a create(...) method calls. After that all actors split calls are synced internally quite fast and only the actual
-stress propagation takes most of computational time. 
+It fully utilizes the fact that it knows the initial support graph structure and does a maximum of processing 
+in the \a create(...) method call. After that, all actor split calls are synchronized internally and efficiently so only the actual stress propagation takes most of computational time.
 
-Then you need to provide physics specific information (mass, volume, position, static) for every node in support graph since Blast itself is physics agnostic. There are two ways to do it, you can call \a stressSolver->setNodeInfo(...) for every graph node. Another was is to call stressSolver->setAllNodesInfoFromLL() once all the data will be populated using NvBlastAsset chunk's data, in particular
-\a volume and \a centroid are used. All nodes connected to 'world' chunk are marked as static.
+You need to provide physics specific information (mass, volume, position, static) for every node in support graph since Blast&tm; itself is physics agnostic. There are two ways to do it. One way is to call \a stressSolver->setNodeInfo(...) for every graph node. The other way is to call stressSolver->setAllNodesInfoFromLL() once: all the data will be populated using NvBlastAsset chunk's data, in particular \a volume and \a centroid. All nodes connected to 'world' chunk are marked as static.
 
 \code
 stressSolver->setAllNodesInfoFromLL();
 \endcode
 
-Stress solver needs to keep track for actor create/destroy events in order to update it's internal stress graph accordingly. So you need to call \a stressSolver->notifyActorCreated(actor) and \a stressSolver->notifyActorDestroyed(actor) every time actor is created or destroyed including the initial actor family had when stress solver were created. There is no need to track actors which contain only one or lesser graph nodes in that case \a notifyActorCreated(actor) returns 'false' as a hint, it means that stress solver will ignore them. For those actors applying forces is also doesn't make any sense.
+Stress solver needs to keep track for actor create/destroy events in order to update its internal stress graph accordingly. So you need to call \a stressSolver->notifyActorCreated(actor) and \a stressSolver->notifyActorDestroyed(actor) every time an actor is created or destroyed, including the initial actor the family had when the stress solver was created. There is no need to track actors which contain only one or less graph nodes. In that case \a notifyActorCreated(actor) returns 'false' as a hint. It means that the stress solver will ignore them, as for those actors applying forces does not make any sense.
 
-Typical update loop would can look like this:
+A typical update loop looks like this:
 
--# If split happend call relevant stressSolver->notifyActorCreated(actor) and stressSolver->notifyActorDestroyed(actor)
+-# If split happened, call relevant stressSolver->notifyActorCreated(actor) and stressSolver->notifyActorDestroyed(actor)
 -# Apply all forces, use \a stressSolver->addForce(...), stressSolver->addGravityForce(...), \a stressSolver->addAngularVelocity(...)
--# Call \a stressSolver->update(). This is where all expensive computation happens.
--# If \a stressSolver->getOverstressedBondCount() > 0 use one of \a stressSolver->generateFractureCommands() methods to get bond fracture commands and apply on them actors.
+-# Call \a stressSolver->update(). This is where all expensive computation takes place.
+-# If \a stressSolver->getOverstressedBondCount() > 0, use one of \a stressSolver->generateFractureCommands() methods to get bond fracture commands and apply them on actors.
 
 Example code from ExtPxStressSolverImpl:
 
@@ -112,7 +108,7 @@ void ExtPxStressSolverImpl::update(bool doDamage)
 }
 \endcode
 
-Have a look at \a ExtPxStressSolver implementation code, which is basically high level wrapper on \a NvBlastExtStress to couple it with PhysX&tm; and \a NvBlatExtPx extension (see \ref extpxstresssolver).
+Have a look at \a ExtPxStressSolver implementation code, which is basically a high level wrapper on \a NvBlastExtStress to couple it with PhysX&tm; and \a NvBlastExtPx extension (see \ref extpxstresssolver).
 
 <br>
 
diff --git a/docs/_source/ext_tkserialization.txt b/docs/_source/ext_tkserialization.txt
index 3addaae..6dbd4f5 100644
--- a/docs/_source/ext_tkserialization.txt
+++ b/docs/_source/ext_tkserialization.txt
@@ -4,7 +4,7 @@ This extension contains serializers which can be loaded into the ExtSerializatio
 
 To use this extension, you must also load the ExtSerialization extension and create a serialization manager as described in \ref pageextserialization.
 
-We repeat this here (again, assuming we're in the Nv::Blast namespace):
+We repeat this here (again, assuming we are in the Nv::Blast namespace):
 
 \code
 ExtSerialization* ser = NvBlastExtSerializationCreate();
@@ -36,10 +36,10 @@ uint64_t size = ser->serializeIntoBuffer(buffer, asset, TkObjectTypeID::Asset);
 
 or use the wrapper function defined in <b>NvBlastExtTkSerialization.h</b>:
 
-/code
+\code
 void* buffer;
 uint64_t size = NvBlastExtSerializationSerializeTkAssetIntoBuffer(buffer, *ser, asset);
-/endcode
+\endcode
 
 <br>
 */
diff --git a/docs/_source/introduction.txt b/docs/_source/introduction.txt
index 3ff30b9..402deeb 100644
--- a/docs/_source/introduction.txt
+++ b/docs/_source/introduction.txt
@@ -30,7 +30,7 @@ asset is initially instanced.  Subsequent fracturing has the effect of breaking
 
 Blast&tm; requires that support chunks form an <em>exact cover</em> (see the definition of exact coverage in \ref pagedefinitions).
 The geometric interpretation of exact coverage is that the support chunks fill the space of the root (unfractured) chunk, without
-any volume being covered by more than one chunk.  A helper function are provided to modify a set of chunk descriptors so that they
+any volume being covered by more than one chunk.  A helper function is provided to modify a set of chunk descriptors so that they
 have exact coverage.  This function fills in missing coverage by assigning support to chunks at the highest place possible (closest
 to root) in the hierarchy, and redundant support is removed: if a chunk and one of its descendant chunks are both marked as support,
 the function will remove support from the descendant chunk.
diff --git a/docs/_source/sample_asset_viewer.txt b/docs/_source/sample_asset_viewer.txt
index 61405d6..d4be09b 100644
--- a/docs/_source/sample_asset_viewer.txt
+++ b/docs/_source/sample_asset_viewer.txt
@@ -28,11 +28,11 @@ the models in the subdirectories of <b>samples/resources/models</b>.
 
 \section using_assetviewer Using SampleAssetViewer
 
-Upon startup, the viewer will instance its first asset in its assets list.  Using the default assets.xml, this is a brick will.
+Upon startup, the viewer will instance its first asset in its assets list.  Using the default assets.xml, this is a brick wall.
 
 The menu is displayed using an overlay on the left side of the screen.  It is divided into many submenus, which are described below.
 
-In any scene, you may press <b>'F'</b> to fire a box into the scene in the direction the camer is pointing.
+In any scene, you may press <b>'F'</b> to fire a box into the scene in the direction the camera is pointing.
 
 You may also press <b>SPACE</b> to toggle between damage and drag mode.  (The mode is shown at the top of the screen.)  In drag mode, dynamic objects can be manipulated by
 placing the mouse cursor over them, and using <b>Left Mouse / Drag</b> to pull on the object.  In damage mode, <b>left-clicking</b> a destructible actor will apply damage to it.
@@ -62,7 +62,7 @@ You may also select actors in the Scene Actors list,  and remove (or reload) the
 unfractured state.
 
 Note, in addition to destructible actors, the Scene Actors list shows the boxes that were fired into the scene using the 'F' key.  Holding down the 'F' key "charges"
-the throw, increasing the cube's speed the longer you hold down the kye.  You may remove the cubes using the scene controls.  All cubes will be removed when the scene
+the throw, increasing the cube's speed the longer you hold down the key.  You may remove the cubes using the scene controls.  All cubes will be removed when the scene
 is reset.
 
 The Blast Material properties are used by the various damage tools available.
@@ -71,15 +71,15 @@ The Blast Material properties are used by the various damage tools available.
 - Min Damage Threshold = a fraction of Health, below which damage has no effect
 - Max Damage Threshold = a fraction of Health, equal to the maximum damage that can be applied per damage event
 
-A stress solver may be enabled by selcting the Stress Solver Enabled checkbox.  When enabled you will be presented with several options.  
-NOTE: you must then select the Stress Damage Enabled checkbox in order to allow stress to do damage to the actors in the scene.
-Bond Iterations Per Frame - is max amount of bonds allowed to be processed in one frame. The more this value the better quality of stress solver, but the time taken by it is increased linearly. You can 
-check this timing in \a Stats submenu. Using this value stress solver takes fixed amount of CPU time on asset of any size. So the more asset complex (the more bonds it has) the less total iterations (on all bonds) are made. 
-Use graph reduction level param to simplify stress graph for large assets. You can look at stress graph using by using \a Debug Render submenu.
-Stress linear and angular factors are corresponded for amount of damage to be applied on bonds from linear and angular momentum of stress on every bond.
+A stress solver may be enabled by selcting the Stress Solver Enabled checkbox.  When enabled, you will be presented with several options.  
+NOTE: you must then select the Stress Damage Enabled checkbox in order to allow stress to do damage to the actors in the scene.<br>
+Bond Iterations Per Frame - is max amount of bonds allowed to be processed in one frame. The higher this value, the better quality of stress solver, but the time taken by it is increased linearly. 9You can 
+check this timing in \a Stats submenu.) Using this value stress solver takes a fixed amount of CPU time on assets of any size. So the more complex an asset is (the more bonds it has) the less total iterations (on all bonds) are made.<br>
+Use graph reduction level param to simplify stress graph for large assets. You can look at stress graph by using the \a Debug Render submenu.
+Stress linear and angular factors are corresponded to the amount of damage to be applied on bonds from linear and angular momentum of stress on every bond.
 
-Replay control section allows to control recording and replaying Blast events. It demonstrates the usage of ExtSync extension. You may start/stop recording of blast events (damage, split). 
-If you toggle to sync initial actors once recording starts full blast state is saved.
+Replay control section allows to control recording and replaying Blast&tm; events. It demonstrates the usage of \ref ExtSync extension. You may start/stop recording of Blast&tm; events (damage, split). 
+If you toggle to sync initial actors, once recording starts, the full Blast&tm; state is saved.
 
 \subsection viewer_blast Blast
 
@@ -88,7 +88,7 @@ Here you may disable or enable impact damage, using the Impact Damage checkbox (
 The Fragility setting is a multiplier that turns impact forces into damage amounts.
 
 You can toggle to pass impact damage to stress solver instead of just applying it with simple damage shader. Impact impulse will be passed to stress graph and damage will be applied
-accordingly to stress solver settings mentioned above.
+according to stress solver settings mentioned above.
 
 When dragging static actors (with mouse dragging tool) stress impulse is also applied on stress graph. Use Dragging To Stress Factor to tune the amount.
 
@@ -133,7 +133,7 @@ The green segments show the linear impulse, the red segments the rotational impu
 
 \subsection viewer_physx PhysX
 
-This menu controls PhysX simulation parameters.  Here you may choose to use fixed time steps (off by default), and set the time step (if Use Fixed Timestep is checked) with the Fixed Timestep control.
+This menu controls PhysX&tm; simulation parameters.  Here you may choose to use fixed time steps (off by default), and set the time step (if Use Fixed Timestep is checked) with the Fixed Timestep control.
 
 If a suitable GPU is available, GPU Physics may be enabled using the Use GPU Physics control.
 
diff --git a/docs/_source/tools.txt b/docs/_source/tools.txt
index 3ac7ebd..ecded90 100644
--- a/docs/_source/tools.txt
+++ b/docs/_source/tools.txt
@@ -5,7 +5,7 @@
 See \ref pagecopyrights for license information regarding third-party software used by the tools.
 
 <br>
-\subpage pageimporter - Import Apex assets into Blast format.
+\subpage pageimporter - Import Apex assets into Blast&tm; format.
 
 
 <br>