summaryloggraphiclog1graphiclog2commitcommitdifftreerefseditfork
rawpatchinlineside by side (parent: 0fe716b)
rawpatchinlineside by side (parent: 0fe716b)
| author | oleh-derevenko <[email protected]> | |
| Sun, 14 Jan 2024 01:05:26 +0000 (14 03:05 +0200) | ||
| committer | oleh-derevenko <[email protected]> | |
| Sun, 14 Jan 2024 01:09:11 +0000 (14 03:09 +0200) |
74 files changed:
#define GIM_BOXPRUNING_H_INCLUDED\r
\r
/*! \file gim_boxpruning.h\r
-\author Francisco León\r
+\author Francisco Le�n\r
*/\r
/*\r
-----------------------------------------------------------------------------\r
@@ -137,17 +137,17 @@ void gim_aabbset_bipartite_intersections_brute_force(GIM_AABB_SET * aabbset1,GIM
/*\r
Brute-Force Vs Sorted pruning\r
Different approaches must be applied when colliding sets with different number of\r
-elements. When sets have less of 100 boxes, is often better to apply force brute\r
+elements. When sets have less of 100 boxes, it is often better to apply brute force\r
approach instead of sorted methods, because at lowlevel bruteforce routines gives\r
-better perormance and consumes less resources, due of their simplicity.\r
-But when sets are larger, the complexiity of bruteforce increases exponencially.\r
+better performance and consumes less resources, due of their simplicity.\r
+But when sets are larger, the complexiity of bruteforce increases exponentially.\r
In the case of large sets, sorted approach is applied. So GIMPACT has the following\r
strategies:\r
\r
On Sorting sets:\r
!) When sets have more of 140 boxes, the boxes are sorted by its coded min coord\r
and the global box is calculated. But when sets are smaller (less of 140 boxes),\r
-Is convenient to apply brute force approach.\r
+it is convenient to apply brute force approach.\r
\r
*******************************************************************************/\r
\r
\r
//Use these functions for general initialization\r
\r
-//! Initalizes the set. Sort Boxes if needed.\r
+//! Initalizes the set. Sort boxes if needed.\r
/*!\r
\pre aabbset must be allocated. And the boxes must be already set.\r
\post If the set has less of GIM_MIN_SORTED_BIPARTITE_PRUNING_BOXES boxes, only calcs the global box,\r
@@ -236,7 +236,7 @@ void gim_aabbset_box_collision(aabb3f *test_aabb, GIM_AABB_SET * aabbset, GDYNAM
\param vorigin Origin point of ray.\r
\param vdir Direction vector of ray.\r
\param tmax Max distance param for ray.\r
-\param aabbset Set of boxes .Global bound is required.\r
+\param aabbset Set of boxes. Global bound is required.\r
\param collided Array of GUINT elements, indices of boxes. Must be initialized before (Reserve size ~ 100)\r
*/\r
void gim_aabbset_ray_collision(vec3f vorigin,vec3f vdir, GREAL tmax, GIM_AABB_SET * aabbset, GDYNAMIC_ARRAY * collided);\r
@@ -274,7 +274,7 @@ So the maximum size of a room should be about 3276x3276 . Its dimensions must li
uint_key = (uint_key<<16) + _z;\\r
}\\r
\r
-//! Converts a vector coordinate to an integer for box sorting,rounding to the upper int\r
+//! Converts a vector coordinate to an integer for box sorting, rounding to the upper int\r
/*!\r
\param vx X component\r
\param vz Z component\r
#define GIM_CONTACT_H_INCLUDED\r
\r
/*! \file gim_contact.h\r
-\author Francisco León\r
+\author Francisco Le�n\r
*/\r
/*\r
-----------------------------------------------------------------------------\r
@@ -39,9 +39,9 @@ email: [email protected]
\brief\r
Functions for managing and sorting contacts resulting from a collision query.\r
<ul>\r
-<li> Contact lists must be create by calling \ref GIM_CREATE_CONTACT_LIST\r
+<li> Contact lists must be created by calling \ref GIM_CREATE_CONTACT_LIST\r
<li> After querys, contact lists must be destroy by calling \ref GIM_DYNARRAY_DESTROY\r
-<li> Contacts can be merge for avoid duplicate results by calling \ref gim_merge_contacts\r
+<li> Contacts can be merged to avoid duplicate results by calling \ref gim_merge_contacts\r
</ul>\r
\r
*/\r
#define GIM_VECTOR_H_INCLUDED\r
\r
/*! \file gim_geometry.h\r
-\author Francisco León\r
+\author Francisco Le�n\r
*/\r
/*\r
-----------------------------------------------------------------------------\r
/** inverse transpose of matrix times vector\r
*\r
* This macro computes inverse transpose of matrix m,\r
- * and multiplies vector v into it, to yeild vector p\r
+ * and multiplies vector v into it, to yield vector p\r
*\r
- * DANGER !!! Do Not use this on normal vectors!!!\r
+ * DANGER !!! Do not use this on normal vectors!!!\r
* It will leave normals the wrong length !!!\r
* See macro below for use on normals.\r
*/\r
p[0] = m[1][1]*v[0] - m[1][0]*v[1]; \\r
p[1] = - m[0][1]*v[0] + m[0][0]*v[1]; \\r
\\r
- /* if matrix not singular, and not orthonormal, then renormalize */ \\r
+ /* if matrix is not singular, and not orthonormal, then renormalize */ \\r
if ((det!=1.0f) && (det != 0.0f)) { \\r
det = 1.0f / det; \\r
p[0] *= det; \\r
* and then renormalize the vector\r
*\r
* This macro computes inverse transpose of matrix m,\r
- * and multiplies vector v into it, to yeild vector p\r
+ * and multiplies vector v into it, to yield vector p\r
* Vector p is then normalized.\r
*/\r
#define NORM_XFORM_2X2(p,m,v) \\r
\r
/** outer product of vector times vector transpose\r
*\r
- * The outer product of vector v and vector transpose t yeilds\r
+ * The outer product of vector v and vector transpose t yields\r
* dyadic matrix m.\r
*/\r
#define OUTER_PRODUCT_2X2(m,v,t) \\r
\r
/** outer product of vector times vector transpose\r
*\r
- * The outer product of vector v and vector transpose t yeilds\r
+ * The outer product of vector v and vector transpose t yields\r
* dyadic matrix m.\r
*/\r
#define OUTER_PRODUCT_3X3(m,v,t) \\r
\r
/** outer product of vector times vector transpose\r
*\r
- * The outer product of vector v and vector transpose t yeilds\r
+ * The outer product of vector v and vector transpose t yields\r
* dyadic matrix m.\r
*/\r
#define OUTER_PRODUCT_4X4(m,v,t) \\r
\r
/** outer product of vector times vector transpose\r
*\r
- * The outer product of vector v and vector transpose t yeilds\r
+ * The outer product of vector v and vector transpose t yields\r
* dyadic matrix m.\r
*/\r
#define ACCUM_OUTER_PRODUCT_2X2(m,v,t) \\r
\r
/** outer product of vector times vector transpose\r
*\r
- * The outer product of vector v and vector transpose t yeilds\r
+ * The outer product of vector v and vector transpose t yields\r
* dyadic matrix m.\r
*/\r
#define ACCUM_OUTER_PRODUCT_3X3(m,v,t) \\r
\r
/** outer product of vector times vector transpose\r
*\r
- * The outer product of vector v and vector transpose t yeilds\r
+ * The outer product of vector v and vector transpose t yields\r
* dyadic matrix m.\r
*/\r
#define ACCUM_OUTER_PRODUCT_4X4(m,v,t) \\r
(dest_aabb).maxZ = (src_aabb).maxZ;\\r
}\\r
\r
-//! Computes an Axis aligned box from a triangle\r
+//! Computes an Axis aligned box from a triangle\r
#define COMPUTEAABB_FOR_TRIANGLE(aabb,V1,V2,V3) {\\r
(aabb).minX = MIN3(V1[0],V2[0],V3[0]);\\r
(aabb).maxX = MAX3(V1[0],V2[0],V3[0]);\\r
VEC_SUM(clipped,clipped,s1); \\r
}\\r
\r
-//! Confirms if the plane intersect the edge or nor\r
+//! Confirms if the plane intersects the edge or not\r
/*!\r
intersection type must have the following values\r
<ul>\r
\param p2 Plane 2\r
\param p Contains the origin of the ray upon returning if planes intersect\r
\param d Contains the direction of the ray upon returning if planes intersect\r
- \param dointersect 1 if the planes intersect, 0 if paralell.\r
+ \param dointersect 1 if the planes intersect, 0 if parallel.\r
\r
*/\r
#define INTERSECT_PLANES(p1,p2,p,d,dointersect) \\r
\param point2 Point of line 2\r
\param t1 Result Parameter for line 1\r
\param t2 Result Parameter for line 2\r
-\param dointersect 0 if the lines won't intersect, else 1\r
+\param dointersect 0 if the lines won't intersect, else 1\r
\r
*/\r
#define LINE_INTERSECTION_PARAMS(dir1,point1, dir2, point2,t1,t2,dointersect) {\\r
#ifndef GIM_MEMORY_H_INCLUDED\r
#define GIM_MEMORY_H_INCLUDED\r
/*! \file gim_memory.h\r
-\author Francisco León\r
+\author Francisco Le�n\r
*/\r
/*\r
-----------------------------------------------------------------------------\r
//! @}\r
\r
/*! \defgroup MEMORY_FUNCTIONS\r
-Standar Memory functions\r
+Standard Memory functions\r
*/\r
//! @{\r
void * gim_alloc(size_t size);\r
<ul>\r
<li> Before using buffers you must initializes GIMPACT buffer managers by calling \ref gimpact_init.\r
<li> For initializes a buffer, use \ref gim_create_buffer, \ref gim_create_buffer_from_data , \ref gim_create_common_buffer, \ref gim_create_common_buffer_from_data or \ref gim_create_shared_buffer_from_data.\r
-<li> For accessing to the buffer memory, you must call \ref gim_lock_buffer, and then \ref gim_unlock_buffer for finish the access.\r
+<li> For accessing the buffer memory, you must call \ref gim_lock_buffer, and then \ref gim_unlock_buffer to finish the access.\r
<li> When a buffer is no longer needed, you must free it by calling \ref gim_buffer_free.\r
<li> You must call \ref gimpact_terminate when finish your application.\r
<li> For a safe manipulation of buffers, use \ref BUFFER_ARRAYS\r
\param buffer_manager_id\r
\param buffer_size\r
\param usage An usage constant. Use G_MU_DYNAMIC_READ_WRITE as default.\r
-\param buffer_id a pointer for receive the new buffer id\r
+\param buffer_id a pointer to receive the new buffer id\r
\return An error code. 0 if success.\r
\post m_refcount = 0\r
*/\r
\param pdata Data for allocating\r
\param buffer_size Size of the data buffer\r
\param usage An usage constant. Use G_MU_DYNAMIC_READ_WRITE as default.\r
-\param buffer_id a pointer for receive the new buffer id\r
+\param buffer_id a pointer to receive the new buffer id\r
\return An error code. 0 if success.\r
\post m_refcount = 0\r
*/\r
<li> Before using buffer arrays you must initializes GIMPACT buffer managers by calling gimpact_init.\r
<li> Before creating buffer arrays, you must create a buffer. see \ref BUFFERS.\r
<li> Create a buffer narray by calling \ref GIM_BUFFER_ARRAY_INIT_TYPE, \ref GIM_BUFFER_ARRAY_INIT_TYPE_OFFSET or \ref GIM_BUFFER_ARRAY_INIT_OFFSET_STRIDE.\r
-<li> For accessing to the array elements, you must call \ref gim_buffer_array_lock, and then \ref gim_buffer_array_unlock for finish the access.\r
+<li> For accessing to the array elements, you must call \ref gim_buffer_array_lock, and then \ref gim_buffer_array_unlock to finish the access.\r
<li> When a buffer array is no longer needed, you must free it by calling \ref GIM_BUFFER_ARRAY_DESTROY.\r
</ul>\r
The following example shows how Buffer arrays can be used:\r
\r
//! Pushes a new element at last position\r
/*!\r
-\pre array_data must be unlocked, and must be the aligned (GIM_BUFFER_ARRAY_IS_ALIGNED )\r
+\pre array_data must be unlocked, and must be aligned (GIM_BUFFER_ARRAY_IS_ALIGNED )\r
*/\r
#define GIM_BUFFER_ARRAY_PUSH_EMPTY(type, array_data) \\r
{\\r
\r
//! Inserts an element\r
/*!\r
-\pre array_data must be unlocked, and must be the aligned (GIM_BUFFER_ARRAY_IS_ALIGNED )\r
+\pre array_data must be unlocked, and must be aligned (GIM_BUFFER_ARRAY_IS_ALIGNED )\r
*/\r
#define GIM_BUFFER_ARRAY_INSERT_ITEM(type, array_data, item, index) \\r
{ \\r
\r
//! Deletes an element\r
/*!\r
-\pre array_data must be unlocked, and must be the aligned (GIM_BUFFER_ARRAY_IS_ALIGNED )\r
+\pre array_data must be unlocked, and must be aligned (GIM_BUFFER_ARRAY_IS_ALIGNED )\r
*/\r
#define GIM_BUFFER_ARRAY_DELETE_ITEM(type, array_data, index) \\r
{ \\r
\r
//! Deletes an element at last position\r
/*!\r
-\pre array_data must be unlocked, and must be the aligned (GIM_BUFFER_ARRAY_IS_ALIGNED )\r
+\pre array_data must be unlocked, and must be aligned (GIM_BUFFER_ARRAY_IS_ALIGNED )\r
*/\r
#define GIM_BUFFER_ARRAY_POP_ITEM(array_data) \\r
{ \\r
\r
//! Initializes an GBUFFER_ARRAY object from a buffer ID\r
/*!\r
-m_buffer_data will be 0, for acces to the elements, you'd need to call lock_array\r
+m_buffer_data will be 0, for access to the elements, you'd need to call lock_array\r
\param array_data Array structure to be filled\r
\param buffer_id A GBUFFER_ID structure which this array_daya will refer to\r
\param element_count Number of elements\r
\param offset element offset, it isn't byte offset. 0 is recomended\r
-\param byte_stride size of each element. 0 is recomended.\r
+\param byte_stride size of each element. 0 is recomended.\r
\post Adds reference to the buffer\r
\sa gim_buffer_add_ref\r
*/\r
@@ -864,7 +864,7 @@ m_buffer_data will be 0, for acces to the elements, you'd need to call lock_arra
\r
//! Initializes an GBUFFER_ARRAY object from a buffer ID and a Given type\r
/*!\r
-m_buffer_data will be 0, for acces to the elements, you'd need to call lock_array\r
+m_buffer_data will be 0, for access to the elements, you'd need to call lock_array\r
\param type Type of the Array. It determines the stride.\r
\param array_data Array structure to be filled\r
\param buffer_id A GBUFFER_ID structure which this array_daya will refer to\r
@@ -886,7 +886,7 @@ m_buffer_data will be 0, for acces to the elements, you'd need to call lock_arra
\r
//! Initializes a buffer array giving a data type and a buffer id\r
/*!\r
-m_buffer_data will be 0, for acces to the elements, you'd need to call lock_array.\r
+m_buffer_data will be 0, for access to the elements, you'd need to call lock_array.\r
\param type Type of the Array. It determines the stride.\r
\param array_data Array structure to be filled\r
\param buffer_id A GBUFFER_ID structure which this array_daya will refer to\r
} \\r
} \\r
\r
-//! Upload the content of a a pointer to a buffered array\r
+//! Upload the content of a pointer to a buffered array\r
/*!\r
\pre source_data must have the same size as the array_data\r
\param type\r
@@ -1011,7 +1011,7 @@ This macro executes a kernel macro or function for each element of the streams
\r
\param _uniform_data An argument to be passed to the Kernel function\r
\param _src_array An GBUFFER_ARRAY structure passed as the source stream\r
-\param _dst_array An GBUFFER_ARRAY structure passed as the source stream\r
+\param _dst_array An GBUFFER_ARRAY structure passed as the source stream\r
\param _kernel Macro or function of the kernel\r
\param _src_type Required. Type of all elements of the source stream\r
\param _dst_type Required. Type of all elements of the dest stream\r
diff --git a/GIMPACT/include/GIMPACT/gim_tri_capsule_collision.h b/GIMPACT/include/GIMPACT/gim_tri_capsule_collision.h
#define GIM_TRI_CAPSULE_COLLISION_H_INCLUDED\r
\r
/*! \file gim_tri_capsule_collision.h\r
-\author Francisco León\r
+\author Francisco Le�n\r
*/\r
/*\r
-----------------------------------------------------------------------------\r
}\\r
}\\r
\r
-//! Utility function for find the closest point between a segment and a triangle\r
+//! Utility function to find the closest point between a segment and a triangle\r
/*!\r
\r
\param triangle\r
\param s2\r
\param contacts Contains the closest points on the segment (1,2), and the normal points to segment, and m_depth contains the distance\r
\r
-\post The contacts array is not set to 0. It adds aditional contacts\r
+\post The contacts array is not set to 0. It adds additional contacts\r
*/\r
void gim_closest_point_triangle_segment(GIM_TRIANGLE_DATA * triangle, vec3f s1,vec3f s2, GDYNAMIC_ARRAY * contacts);\r
\r
@@ -96,14 +96,14 @@ void gim_closest_point_triangle_segment(GIM_TRIANGLE_DATA * triangle, vec3f s1,v
\r
\r
\r
-//! Utility function for find the closest point between a capsule and a triangle\r
+//! Utility function to find the closest point between a capsule and a triangle\r
/*!\r
\r
\param triangle\r
\param capsule\r
\param contacts Contains the closest points on the capsule, and the normal points to triangle\r
\return 1 if the triangle collides the capsule\r
-\post The contacts array is not set to 0. It adds aditional contacts\r
+\post The contacts array is not set to 0. It adds additional contacts\r
*/\r
int gim_triangle_capsule_collision(GIM_TRIANGLE_DATA * triangle, GIM_CAPSULE_DATA * capsule, GDYNAMIC_ARRAY * contacts);\r
//! @}\r
diff --git a/GIMPACT/include/GIMPACT/gim_tri_collision.h b/GIMPACT/include/GIMPACT/gim_tri_collision.h
#define GIM_TRI_COLLISION_H_INCLUDED\r
\r
/*! \file gim_tri_collision.h\r
-\author Francisco León Nájera\r
+\author Francisco Le�n N�jera\r
*/\r
/*\r
-----------------------------------------------------------------------------\r
//! Finds the contact points from a collision of two triangles\r
/*!\r
Returns the contact points, the penetration depth and the separating normal of the collision\r
-between two triangles. The normal is pointing toward triangle 1 from triangle 2\r
+between two triangles. The normal is pointing towards triangle 1 from triangle 2\r
*/\r
int gim_triangle_triangle_collision(\r
GIM_TRIANGLE_DATA *tri1,\r
#ifndef GIM_TRIMESH_H_INCLUDED\r
#define GIM_TRIMESH_H_INCLUDED\r
/*! \file gim_trimesh.h\r
-\author Francisco León\r
+\author Francisco Le�n\r
*/\r
/*\r
-----------------------------------------------------------------------------\r
<ul>\r
<li> For creating trimeshes, you must initialize Buffer managers by calling \ref gimpact_init\r
<li> Then you must define the vertex and index sources by creating them with \ref BUFFER_ARRAYS routines, and then call \ref gim_trimesh_create_from_arrays.\r
-<li> An alternative way for creaing trimesh objects is calling \ref gim_trimesh_create_from_data.\r
-<li> For access to the trimesh data (vertices, triangle indices), you must call \ref gim_trimesh_locks_work_data , and \ref gim_trimesh_unlocks_work_data for finish the access.\r
+<li> An alternative way for creating trimesh objects is calling \ref gim_trimesh_create_from_data.\r
+<li> For access to the trimesh data (vertices, triangle indices), you must call \ref gim_trimesh_locks_work_data , and \ref gim_trimesh_unlocks_work_data to finish the access.\r
<li> Each time when the trimesh data is modified, you must call \ref gim_trimesh_update after.\r
<li> When a trimesh is no longer needed, you must call \ref gim_trimesh_destroy.\r
</ul>\r
<p>Note that parameter transformed_reply is 0, that means that m_transformed_vertex_buffer is a reference to m_source_vertex on the trimesh, and transformations are not avaliable. Use that configuration if you have to simulate a deformable trimesh like cloth or elastic bodies.</p>\r
<p>When the trimesh is no longer needed, destroy it safely with gim_trimesh_destroy()</p>\r
<p><strong>UPDATING TRIMESHES</strong></p>\r
-<p>On simulation loops, is needed to update trimeshes every time for update vertices althought updating triangle boxes and planes cache. There is two ways for update trimeshes: </p>\r
+<p>On simulation loops, is needed to update trimeshes every time to update vertices althought updating triangle boxes and planes cache. There is two ways to update trimeshes: </p>\r
<ul>\r
<li> Updating vertices directly. You need to access to the \ref GIM_TRIMESH.m_source_vertex_buffer member; a vertex buffer which has access to the source vertices.\r
\code\r
//@{\r
GBUFFER_ARRAY m_source_vertex_buffer;//!< Buffer of vec3f coordinates\r
\r
- //! (GUINT) Indices of triangles,groups of three elements.\r
+ //! (GUINT) Indices of triangles, groups of three elements.\r
/*!\r
Array of GUINT. Triangle indices. Each triple contains indices of the vertices for each triangle.\r
\invariant must be aligned\r
//! Returns 1 if the trimesh needs to update their aabbset and the planes cache.\r
char gim_trimesh_needs_update(GIM_TRIMESH * trimesh);\r
\r
-//! Change the state of the trimesh for force it to update\r
+//! Change the state of the trimesh to force it to update\r
/*!\r
-Call it after made changes to the trimesh.\r
+Call it after having made changes to the trimesh.\r
\post gim_trimesh_need_update(trimesh) will return 1\r
\sa gim_trimesh_needs_update,gim_trimesh_has_tranformed_reply\r
*/\r
\param trimesh\r
\param vertex_array\r
\param triindex_array\r
-\param transformed_reply If 1, then the m_transformed_vertices is a reply of the source vertices. Else it just be a reference to the original array.\r
+\param transformed_reply If 1, then the m_transformed_vertices is a reply of the source vertices. Else it just is a reference to the original array.\r
\post it copies the arrays by reference, and creates the auxiliary data (m_aabbset,m_planes_cache_buffer)\r
*/\r
void gim_trimesh_create_from_arrays(GBUFFER_MANAGER_DATA buffer_managers[],\r
\r
//! Create a trimesh from vertex array and an index array\r
/*!\r
-\param trimesh An uninitialized GIM_TRIMESH structure\r
+\param trimesh An uninitialized GIM_TRIMESH structure\r
\param vertex_array A buffer to a vec3f array\r
\param vertex_count\r
\param triindex_array\r
/*!\r
\param source_trimesh\r
\param dest_trimesh\r
-\param copy_by_reference If 1, it attach a reference to the source vertices, else it copies the vertices\r
+\param copy_by_reference If 1, it attaches a reference to the source vertices, else it copies the vertices\r
\param transformed_reply If 1, transformed vertices are reply of source vertives. 1 Is recommended\r
*/\r
void gim_trimesh_copy(GIM_TRIMESH * source_trimesh,\r
@@ -275,7 +275,7 @@ void gim_trimesh_get_triangle_vertices(GIM_TRIMESH * trimesh, GUINT32 triangle_i
\r
//! Trimesh Trimesh Collisions\r
/*!\r
-Before use this function you must update each trimesh:\r
+Before use of this function you must update each trimesh:\r
\code\r
gim_trimesh_update(TriMesh1);\r
gim_trimesh_update(TriMesh2);\r
//Collide trimeshes\r
gim_trimesh_trimesh_collision(TriMesh1,TriMesh2,&trimeshcontacts);\r
\r
- if(trimeshcontacts.m_size == 0) //do nothing\r
+ if(trimeshcontacts.m_size == 0) //do nothing\r
{\r
GIM_DYNARRAY_DESTROY(trimeshcontacts);//clean contact array\r
return 0;\r
@@ -334,7 +334,7 @@ void gim_trimesh_trimesh_collision(GIM_TRIMESH * trimesh1, GIM_TRIMESH * trimesh
\r
//! Trimesh Sphere Collisions\r
/*!\r
-Before use this function you must update the trimesh:\r
+Before use of this function you must update the trimesh:\r
\code\r
gim_trimesh_update(trimesh);\r
\endcode\r
@@ -393,9 +393,9 @@ void gim_trimesh_sphere_collision(GIM_TRIMESH * trimesh,vec3f center,GREAL radiu
\r
//! Trimesh Capsule collision\r
/*!\r
-Find the closest primitive collided by the ray.\r
+Finds the closest primitive collided with the ray.\r
\r
-Before use this function you must update the trimesh:\r
+Before use of this function you must update the trimesh:\r
\code\r
gim_trimesh_update(trimesh);\r
\endcode\r
@@ -457,7 +457,7 @@ void gim_trimesh_capsule_collision(GIM_TRIMESH * trimesh, GIM_CAPSULE_DATA * cap
//! Trimesh Plane Collisions\r
/*!\r
\r
-Before use this function you must update the trimesh:\r
+Before use of this function you must update the trimesh:\r
\code\r
gim_trimesh_update(trimesh);\r
\endcode\r
}\r
\endcode\r
\r
-In each contact the 3 first coordinates refers to the contact point, the fourth refers to the distance depth and the normal is the normal of the plane.\r
+In each contact the 3 first coordinates refer to the contact point, the fourth refers to the distance depth and the normal is the normal of the plane.\r
\r
\param trimesh\r
\param plane vec4f plane\r
@@ -527,7 +527,7 @@ int gim_trimesh_ray_collision(GIM_TRIMESH * trimesh,vec3f origin,vec3f dir, GREA
\r
//! Trimesh Ray Collisions closest\r
/*!\r
-Find the closest primitive collided by the ray\r
+Finds the closest primitive collided by the ray\r
\param trimesh\r
\param origin\r
\param dir\r
#define GIMPACT_H_INCLUDED\r
\r
/*! \file gimpact.h\r
-\author Francisco León\r
+\author Francisco Le�n\r
*/\r
/*\r
-----------------------------------------------------------------------------\r
@@ -37,9 +37,9 @@ email: [email protected]
/*! \defgroup GIMPACT_INIT\r
*/\r
//! @{\r
-//! Call this for initialize GIMPACT system structures.\r
+//! Call this to initialize GIMPACT system structures.\r
void gimpact_init();\r
-//! Call this for clean GIMPACT system structures.\r
+//! Call this to clean GIMPACT system structures.\r
void gimpact_terminate();\r
//! @}\r
#endif // GIMPACT_H_INCLUDED\r
@@ -98,7 +98,7 @@ email: [email protected]
#define POINT_IN_TRI(V0,U0,U1,U2) \\r
{ \\r
float a,b,c,d0,d1,d2; \\r
- /* is T1 completly inside T2? */ \\r
+ /* is T1 completely inside T2? */ \\r
/* check if V0 is inside tri(U0,U1,U2) */ \\r
a=U1[i1]-U0[i1]; \\r
b=-(U1[i0]-U0[i0]); \\r
\param trimesh\r
\param vertex_array\r
\param triindex_array\r
-\param transformed_reply If 1, then the m_transformed_vertices is a reply of the source vertices. Else it just be a reference to the original array.\r
+\param transformed_reply If 1, then the m_transformed_vertices is a reply of the source vertices. Else it just is a reference to the original array.\r
\post it copies the arrays by reference, and creates the auxiliary data (m_aabbset,m_planes_cache_buffer)\r
*/\r
void gim_trimesh_create_from_arrays(GBUFFER_MANAGER_DATA buffer_managers[],\r
//! Create a trimesh from vertex array and an index array\r
/*!\r
\r
-\param trimesh An uninitialized GIM_TRIMESH structure\r
+\param trimesh An uninitialized GIM_TRIMESH structure\r
\param vertex_array A buffer to a vec3f array\r
\param vertex_count\r
\param triindex_array\r
\param index_count\r
-\param copy_vertices If 1, it copies the source vertices in another buffer. Else (0) it constructs a reference to the data.\r
-\param copy_indices If 1, it copies the source vertices in another buffer. Else (0) it constructs a reference to the data.\r
-\param transformed_reply If , then the m_transformed_vertices is a reply of the source vertices. Else it just be a reference to the original array.\r
+\param copy_vertices If 1, it copies the source vertices to another buffer. Else (0) it constructs a reference to the data.\r
+\param copy_indices If 1, it copies the source vertices to another buffer. Else (0) it constructs a reference to the data.\r
+\param transformed_reply If 1, then the m_transformed_vertices is a reply of the source vertices. Else (0) it just is a reference to the original array.\r
*/\r
void gim_trimesh_create_from_data(GBUFFER_MANAGER_DATA buffer_managers[],\r
GIM_TRIMESH * trimesh, vec3f * vertex_array, GUINT32 vertex_count,char copy_vertices, \r
\post dest_trimesh will be created\r
\param source_trimesh\r
\param dest_trimesh\r
-\param copy_by_reference If 1, it attach a reference to the source vertices, else it copies the vertices\r
-\param transformed_reply IF 1, then it forces the m_trasnformed_vertices to be a reply of the source vertices\r
+\param copy_by_reference If 1, it attaches a reference to the source vertices, else it copies the vertices\r
+\param transformed_reply IF 1, then it forces the m_trasnformed_vertices to be a reply of the source vertices\r
*/\r
void gim_trimesh_copy(GIM_TRIMESH * source_trimesh,\r
GBUFFER_MANAGER_DATA dest_buffer_managers[], GIM_TRIMESH * dest_trimesh, \r
\r
//! Change the state of the trimesh for force it to update\r
/*!\r
-Call it after made changes to the trimesh.\r
+Call it after having made changes to the trimesh.\r
\post gim_trimesh_need_update(trimesh) will return 1\r
*/\r
void gim_trimesh_post_update(GIM_TRIMESH * trimesh)\r
diff --git a/GIMPACT/src/gim_trimesh_capsule_collision.cpp b/GIMPACT/src/gim_trimesh_capsule_collision.cpp
@@ -28,7 +28,7 @@ email: [email protected]
#include "GIMPACT/gim_trimesh.h"
-//! Utility function for find the closest point between a segment and a triangle
+//! Utility function to find the closest point between a segment and a triangle
/*!
\param triangle
@@ -36,7 +36,7 @@ email: [email protected]
\param s2
\param contacts Contains the closest points on the segment (1,2), and the normal points to segment, and m_depth contains the distance
-\post The contacts array is not set to 0. It adds aditional contacts
+\post The contacts array is not set to 0. It adds additional contacts
*/
void gim_closest_point_triangle_segment(GIM_TRIANGLE_DATA * triangle, vec3f s1,vec3f s2, GDYNAMIC_ARRAY * contacts)
{
@@ -166,14 +166,14 @@ void gim_closest_point_triangle_segment(GIM_TRIANGLE_DATA * triangle, vec3f s1,v
}
-//! Utility function for find the closest point between a capsule and a triangle
+//! Utility function to find the closest point between a capsule and a triangle
/*!
\param triangle
\param capsule
\param contacts Contains the closest points on the capsule, and the normal points to triangle
-\post The contacts array is not set to 0. It adds aditional contacts
+\post The contacts array is not set to 0. It adds additional contacts
*/
int gim_triangle_capsule_collision(GIM_TRIANGLE_DATA * triangle, GIM_CAPSULE_DATA * capsule, GDYNAMIC_ARRAY * contacts)
{
@@ -215,7 +215,7 @@ int gim_triangle_capsule_collision(GIM_TRIANGLE_DATA * triangle, GIM_CAPSULE_DAT
//! Trimesh Capsule collision
/*!
-Find the closest primitive collided by the ray
+Finds the closest primitive collided by the ray
\param trimesh
\param capsule
\param contact
\r
//! Trimesh Ray Collisions closest\r
/*!\r
-Find the closest primitive collided by the ray\r
+Finds the closest primitive collided by the ray\r
\param trimesh\r
\param contact\r
\return 1 if the ray collides, else 0\r
diff --git a/GIMPACT/src/gim_trimesh_trimesh_collision.cpp b/GIMPACT/src/gim_trimesh_trimesh_collision.cpp
\r
\r
\r
- //State variabnles\r
+ //State variables\r
GUINT32 mostdir=0;\r
GUINT32 clipped2_count=0;\r
\r
return 0;//Reject\r
}\r
\r
- //find most deep interval face1\r
+ //find deepest interval face1\r
GUINT32 deep2_count=0;\r
\r
GREAL maxdeep;\r
}
-// call this to update the current camera position. the bits in `mode' say
+// call this to update the current camera position. the bits in 'mode' say
// if the left (1), middle (2) or right (4) mouse button is pressed, and
// (deltax,deltay) is the amount by which the mouse pointer has moved.
--- a/include/ode/collision.h
+++ b/include/ode/collision.h
* the enabled state.
*
* @param geom the geom to disable
- * @sa dGeomDisable
+ * @sa dGeomEnable
* @sa dGeomIsEnabled
* @ingroup collide
*/
* @param geom the geom to query
* @returns Non-zero if the geom is enabled, zero otherwise.
* @sa dGeomDisable
- * @sa dGeomIsEnabled
+ * @sa dGeomEnable
* @ingroup collide
*/
ODE_API int dGeomIsEnabled (dGeomID geom);
* dGeomCommonAnyControlCode applies to any control class and returns success if
* at least one control code is available for the given class with given geom.
*
- * Currently there are the folliwing control classes supported:
+ * Currently there are the following control classes supported:
* @li dGeomColliderControlClass
*
* For dGeomColliderControlClass there are the following codes available:
/**
- * @brief Calculate the depth of the a given point within a sphere.
+ * @brief Calculate the depth of the given point within a sphere.
*
* @param sphere the sphere to query.
* @param x the X coordinate of the point.
*
* @param data The user data object, as passed to dSpaceCollide.
* @param o1 The first geom being tested.
- * @param o2 The second geom being test.
+ * @param o2 The second geom being tested.
*
* @remarks The callback function can call dCollide on o1 and o2 to generate
* contact points between each pair. Then these contact points may be added
* Trimesh data.
* This is where the actual vertexdata (pointers), and BV tree is stored.
* Vertices should be single precision!
- * This should be more sophisticated, so that the user can easyly implement
+ * This should be more sophisticated, so that the user can easily implement
* another collision library, but this is a lot of work, and also costs some
* performance because some data has to be copied.
*/
@@ -178,7 +178,7 @@ ODE_API dResourceRequirementsID dResourceRequirementsClone(/*const */dResourceRe
*
* The function updates @a summaryRequirements requirements to be also sufficient
* for the purposes @a extraRequirements could be used for. The @a extraRequirements
- * object is not changed. The both objects should normally have had been created
+ * object is not changed. Both objects should normally have been created
* with the same Cooperative object.
*
* @param summaryRequirements A ResourceRequirements object to be changed
diff --git a/include/ode/mass.h b/include/ode/mass.h
--- a/include/ode/mass.h
+++ b/include/ode/mass.h
/**
* Check if a mass structure has valid value.
- * The function check if the mass and innertia matrix are positive definits
+ * The function check if the mass and inertia matrix are positive definits
*
* @param m A mass structure to check
*
* estimated in @c dEstimateCooperativelyFactorLDLTResourceRequirements.
*
* The operation is performed cooperatively by up to @a allowedThreadCount threads
- * from thread pool available in @a resources. The threading must must not be simultaneously
+ * from thread pool available in @a resources. The threading must not be simultaneously
* used (via other @c dResourceContainerID instances) in other calls that employ its features.
*
* @param resources The resources allocated for the function
@@ -123,7 +123,7 @@ ODE_API void dEstimateCooperativelySolveLDLTResourceRequirements(dResourceRequir
* estimated in @c dEstimateCooperativelySolveLDLTResourceRequirements.
*
* The operation is performed cooperatively by up to @a allowedThreadCount threads
- * from thread pool available in @a resources. The threading must must not be simultaneously
+ * from thread pool available in @a resources. The threading must not be simultaneously
* used (via other @c dResourceContainerID instances) in other calls that employ its features.
*
* @param resources The resources allocated for the function
@@ -172,7 +172,7 @@ ODE_API void dEstimateCooperativelySolveL1StraightResourceRequirements(dResource
* estimated in @c dEstimateCooperativelySolveL1StraightResourceRequirements.
*
* The operation is performed cooperatively by up to @a allowedThreadCount threads
- * from thread pool available in @a resources. The threading must must not be simultaneously
+ * from thread pool available in @a resources. The threading must not be simultaneously
* used (via other @c dResourceContainerID instances) in other calls that employ its features.
*
* @param resources The resources allocated for the function
@@ -220,7 +220,7 @@ ODE_API void dEstimateCooperativelySolveL1TransposedResourceRequirements(dResour
* estimated in @c dEstimateCooperativelySolveL1TransposedResourceRequirements.
*
* The operation is performed cooperatively by up to @a allowedThreadCount threads
- * from thread pool available in @a resources. The threading must must not be simultaneously
+ * from thread pool available in @a resources. The threading must not be simultaneously
* used (via other @c dResourceContainerID instances) in other calls that employ its features.
*
* @param resources The resources allocated for the function
@@ -266,7 +266,7 @@ ODE_API void dEstimateCooperativelyScaleVectorResourceRequirements(dResourceRequ
* estimated in @c dEstimateCooperativelyScaleVectorResourceRequirements.
*
* The operation is performed cooperatively by up to @a allowedThreadCount threads
- * from thread pool available in @a resources. The threading must must not be simultaneously
+ * from thread pool available in @a resources. The threading must not be simultaneously
* used (via other @c dResourceContainerID instances) in other calls that employ its features.
*
* @param resources The resources allocated for the function
diff --git a/include/ode/objects.h b/include/ode/objects.h
--- a/include/ode/objects.h
+++ b/include/ode/objects.h
* A body is considered to be idle when the magnitudes of both its
* linear average velocity and angular average velocity are below given thresholds.
* The sample size for the average defaults to one and can be disabled by setting
- * to zero with
+ * to zero with @c dWorldSetAutoDisableAverageSamplesCount
*
- * Thus, every body has six auto-disable parameters: an enabled flag, a idle step
- * count, an idle time, linear/angular average velocity thresholds, and the
+ * Thus, every body has six auto-disable parameters: enabled flag, idle step
+ * count, idle time, linear/angular average velocity thresholds and
* average samples count.
*
* Newly created bodies get these parameters from world.
* @brief sets the finite rotation axis for a body.
* @ingroup bodies
* @remarks
- * This is axis only has meaning when the finite rotation mode is set
+ * This axis only has meaning when the finite rotation mode is set
* If this axis is zero (0,0,0), full finite rotations are performed on
* the body.
* If this axis is nonzero, the body is rotated by performing a partial finite
/**
* @brief Get the way a body's orientation is updated each timestep.
* @ingroup bodies
- * @return the mode 0 (infitesimal) or 1 (finite).
+ * @return the mode 0 (infinitesimal) or 1 (finite).
*/
ODE_API int dBodyGetFiniteRotationMode (dBodyID);
/**
* @brief Return a joint attached to this body, given by index.
* @ingroup bodies
- * @param index valid range is 0 to n-1 where n is the value returned by
+ * @param index valid range is 0 to n-1 where n is the value returned by
* dBodyGetNumJoints().
*/
ODE_API dJointID dBodyGetJoint (dBodyID, int index);
* offset1 and offset2 appart with respect to axis1 and axis2.
* @ingroup joints
*
- * This function initialize the axis1 and the relative orientation of
+ * This function initializes the axis1 and the relative orientation of
* each body as if body1 was rotated around the new axis1 by the offset1
* value and as if body2 was rotated around the axis2 by offset2. \br
* Ex:
@@ -2284,7 +2284,7 @@ ODE_API_DEPRECATED ODE_API void dJointSetPUAnchorDelta (dJointID, dReal x, dReal
* @brief Set the PU anchor as if the 2 bodies were already at [dx, dy, dz] appart.
* @ingroup joints
*
- * This function initialize the anchor and the relative position of each body
+ * This function initializes the anchor and the relative position of each body
* as if the position between body1 and body2 was already the projection of [dx, dy, dz]
* along the Piston axis. (i.e as if the body1 was at its current position - [dx,dy,dy] when the
* axis is set).
* @brief Set the Piston anchor as if the 2 bodies were already at [dx,dy, dz] appart.
* @ingroup joints
*
- * This function initialize the anchor and the relative position of each body
+ * This function initializes the anchor and the relative position of each body
* as if the position between body1 and body2 was already the projection of [dx, dy, dz]
* along the Piston axis. (i.e as if the body1 was at its current position - [dx,dy,dy] when the
* axis is set).
* @param x The x component of the axis
* @param y The y component of the axis
* @param z The z component of the axis
- * @param dx The Initial position of the prismatic join in the x direction
- * @param dy The Initial position of the prismatic join in the y direction
- * @param dz The Initial position of the prismatic join in the z direction
+ * @param dx The Initial position of the prismatic joint in the x direction
+ * @param dy The Initial position of the prismatic joint in the y direction
+ * @param dz The Initial position of the prismatic joint in the z direction
*/
ODE_API_DEPRECATED ODE_API void dJointSetPistonAxisDelta (dJointID j, dReal x, dReal y, dReal z, dReal ax, dReal ay, dReal az);
ODE_API dReal dJointGetPistonPositionRate (dJointID);
/**
- * @brief Get the Piston angular position (i.e. the twist between the 2 bodies)
+ * @brief Get the Piston angular position (i.e. the twist between the 2 bodies)
*
* When the axis is set, the current position of the attached bodies is
* examined and that position will be the zero position.
diff --git a/include/ode/odeinit.h b/include/ode/odeinit.h
--- a/include/ode/odeinit.h
+++ b/include/ode/odeinit.h
* @defgroup init Library Initialization
*
* Library initialization functions prepare ODE internal data structures for use
- * and release allocated resources after ODE is not needed any more.
+ * and release allocated resources after ODE is not needed anymore.
*/
* in advance. If collision detection is not going to be used, it is not necessary
* to specify this flag.
*
- * @c dAllocateMaskAll is a mask that can be used for for allocating all possible
+ * @c dAllocateMaskAll is a mask that can be used for allocating all possible
* data in cases when it is not known what exactly features of ODE will be used.
* The mask may not be used in combination with other flags. It is guaranteed to
* include all the current and future legal allocation flags. However, mature
/**
- * @brief Close ODE after it is not needed any more.
+ * @brief Close ODE after it is not needed anymore.
*
- * The function is required to be called when program does not need ODE features any more.
+ * The function is required to be called when program does not need ODE features anymore.
* The call to @c dCloseODE releases all the resources allocated for library
* including all the thread local data that might be allocated for all the threads
* that were using ODE.
/*
- * These macros are not used any more inside of ODE
+ * These macros are not used anymore inside of ODE
* They are kept for backward compatibility with external code that
* might still be using them.
*/
/*
- * These macros are not used any more inside of ODE
+ * These macros are not used anymore inside of ODE
* They are kept for backward compatibility with external code that
* might still be using them.
*/
--- a/include/ode/threading.h
+++ b/include/ode/threading.h
/**
- * @brief Allocates a group of muteces.
+ * @brief Allocates a group of mutexes.
*
* The Mutex allocated do not need to support recursive locking.
*
typedef dMutexGroupID dMutexGroupAllocFunction (dThreadingImplementationID impl, dmutexindex_t Mutex_count, const char *const *Mutex_names_ptr/*=NULL*/);
/**
- * @brief Deletes a group of muteces.
+ * @brief Deletes a group of mutexes.
*
* @param impl Threading implementation ID
* @param mutex_group Mutex group to deallocate
typedef void dMutexGroupFreeFunction (dThreadingImplementationID impl, dMutexGroupID mutex_group);
/**
- * @brief Locks a mutex in a group of muteces.
+ * @brief Locks a mutex in a group of mutexes.
*
* The function is to block execution until requested mutex can be locked.
*
@@ -106,7 +106,7 @@ typedef void dMutexGroupFreeFunction (dThreadingImplementationID impl, dMutexGro
typedef void dMutexGroupMutexLockFunction (dThreadingImplementationID impl, dMutexGroupID mutex_group, dmutexindex_t mutex_index);
/**
- * @brief Attempts to lock a mutex in a group of muteces.
+ * @brief Attempts to lock a mutex in a group of mutexes.
*
* The function is to lock the requested mutex if it is unoccupied or
* immediately return failure if mutex is already locked by other thread.
@@ -128,7 +128,7 @@ typedef void dMutexGroupMutexLockFunction (dThreadingImplementationID impl, dMut
/* typedef int dMutexGroupMutexTryLockFunction (dThreadingImplementationID impl, dMutexGroupID mutex_group, dmutexindex_t mutex_index);*/
/**
- * @brief Unlocks a mutex in a group of muteces.
+ * @brief Unlocks a mutex in a group of mutexes.
*
* The function is to unlock the given mutex provided it had been locked before.
*
diff --git a/libccd/README b/libccd/README
--- a/libccd/README
+++ b/libccd/README
Simply type 'make' and 'make install' in src/ directory.
Library libccd is by default compiled in double precision of floating point
-numbers - you can controll this by options USE_SINGLE/USE_DOUBLE, i.e.:
+numbers - you can control this by options USE_SINGLE/USE_DOUBLE, i.e.:
$ make USE_SINGLE=yes
will compile library in single precision.
diff --git a/libccd/src/ccd.c b/libccd/src/ccd.c
--- a/libccd/src/ccd.c
+++ b/libccd/src/ccd.c
static void expandPolytope(ccd_pt_t *pt, ccd_pt_el_t *el,
const ccd_support_t *newv);
-/** Finds next support point (at stores it in out argument).
+/** Finds next support point (and stores it in out argument).
* Returns 0 on success, -1 otherwise */
static int nextSupport(const void *obj1, const void *obj2, const ccd_t *ccd,
const ccd_pt_el_t *el,
// and add this point to simplex as last one
ccdSimplexAdd(simplex, &last);
- // set up direction vector to as (O - last) which is exactly -last
+ // set up direction vector as (O - last) which is exactly -last
ccdVec3Copy(&dir, &last.v);
ccdVec3Scale(&dir, -CCD_ONE);
}
// check if triangle is really triangle (has area > 0)
- // if not simplex can't be expanded and thus no itersection is found
+ // if not simplex can't be expanded and thus no intersection is found
if (ccdVec3Eq(&A->v, &B->v) || ccdVec3Eq(&A->v, &C->v)){
return -1;
}
ccdVec3Copy(&AO, &A->v);
ccdVec3Scale(&AO, -CCD_ONE);
- // compute AB and AC segments and ABC vector (perpendircular to triangle)
+ // compute AB and AC segments and ABC vector (perpendicular to triangle)
ccdVec3Sub2(&AB, &B->v, &A->v);
ccdVec3Sub2(&AC, &C->v, &A->v);
ccdVec3Cross(&ABC, &AB, &AC);
// This situation is a bit tricky. If only one segment comes from
// previous run of GJK - it means that either this segment is on
- // minkowski edge (and thus we have touch contact) or it it isn't and
+ // minkowski edge (and thus we have touch contact) or it isn't and
// therefore segment is somewhere *inside* minkowski sum and it *must*
// be possible to fully enclose this segment with polyhedron formed by
// at least 8 triangle faces.
}
}
-/** Finds next support point (at stores it in out argument).
+/** Finds next support point (and stores it in out argument).
* Returns 0 on success, -1 otherwise */
static int nextSupport(const void *obj1, const void *obj2, const ccd_t *ccd,
const ccd_pt_el_t *el,
diff --git a/libccd/src/ccd/ccd.h b/libccd/src/ccd/ccd.h
--- a/libccd/src/ccd/ccd.h
+++ b/libccd/src/ccd/ccd.h
/**
* This function computes separation vector of two objects. Separation
- * vector is minimal translation of obj2 to get obj1 and obj2 speparated
+ * vector is minimal translation of obj2 to get obj1 and obj2 separated
* (without intersection).
* Returns 0 if obj1 and obj2 intersect and sep is filled with translation
* vector. If obj1 and obj2 don't intersect -1 is returned.
* Computes penetration of obj2 into obj1.
* Depth of penetration, direction and position is returned, i.e. if obj2
* is translated by computed depth in resulting direction obj1 and obj2
- * would have touching contact. Position is point in global coordinates
- * where force should be take a place.
+ * would have touching contact. Position is a point in global coordinates
+ * where force should take place.
*
* Minkowski Portal Refinement algorithm is used (MPR, a.k.a. XenoCollide,
* see Game Programming Gem 7).
diff --git a/libccd/src/ccd/list.h b/libccd/src/ccd/list.h
--- a/libccd/src/ccd/list.h
+++ b/libccd/src/ccd/list.h
item = (item)->next)
/**
- * Iterates over list safe against remove of list entry
+ * Iterates over list safe against removal of list entry
*/
#define ccdListForEachSafe(list, item, tmp) \
for (item = (list)->next, tmp = (item)->next; \
ccd_pt_edge_t *e;
size_t i;
- // remove face from edges' recerence lists
+ // remove face from edges' reference lists
for (i = 0; i < 3; i++){
e = f->edge[i];
if (e->faces[0] == f){
/* globally used file descriptor for reading/writing messages */
int fd;
-/* indicate if test was failed */
+/* indicate if test has failed */
int test_failed;
/* codes of messages */
fprintf(stdout, "Test suite terminated abnormaly!\n");
}
- /* mark this test suite as failed, because was terminated
+ /* mark this test suite as failed, because it was terminated
* prematurely */
cu_fail_test_suites++;
}
/**
* Assertations
- * Assertations with suffix 'M' (e.g. assertTrueM) is variation of macro
- * where is possible to specify error message.
+ * Assertations with suffix 'M' (e.g. assertTrueM) are variations of macros
+ * where it is possible to specify error message.
*/
#define assertTrueM(a, message) \
if (a){ \
/**
* Returns supporting vertex via v.
- * Supporting vertex is fathest vertex from object in direction dir.
+ * Supporting vertex is farthest vertex from object in direction dir.
*/
void ccdSupport(const void *obj, const ccd_vec3_t *dir,
ccd_vec3_t *v);
ccdVec3Set(&a, 0., 0., 0.);
ccdVec3Set(&b, 1., 0., 0.);
- // extereme w == a
+ // extreme w == a
ccdVec3Set(&P, -1., 0., 0.);
dist = ccdVec3PointSegmentDist2(&P, &a, &b, &w);
assertTrue(ccdEq(dist, 1.));
assertTrue(ccdVec3Eq(&w, &a));
- // extereme w == b
+ // extreme w == b
ccdVec3Set(&P, 2., 0., 0.);
dist = ccdVec3PointSegmentDist2(&P, &a, &b, &w);
assertTrue(ccdEq(dist, 1.));
ccdVec3Set(&a, -.5, 2., 1.);
ccdVec3Set(&b, 1., 1.5, 0.5);
- // extereme w == a
+ // extreme w == a
ccdVec3Set(&P, -10., 0., 0.);
dist = ccdVec3PointSegmentDist2(&P, &a, &b, &w);
assertTrue(ccdEq(dist, 9.5 * 9.5 + 2. * 2. + 1.));
assertTrue(ccdEq(dist, 9.5 * 9.5 + 7.2 * 7.2 + 2.4 * 2.4));
assertTrue(ccdVec3Eq(&w, &a));
- // extereme w == b
+ // extreme w == b
ccdVec3Set(&P, 10., 0., 0.);
dist = ccdVec3PointSegmentDist2(&P, &a, &b, &w);
assertTrue(ccdEq(dist, 9. * 9. + 1.5 * 1.5 + 0.5 * 0.5));
diff --git a/ode/TODO b/ode/TODO
--- a/ode/TODO
+++ b/ode/TODO
actually an old ODE group is the equivalent of an old ODE simple space.
- just call dCollide() or not.
-the group doesn't get passed to the space callback any more ... only the
+the group doesn't get passed to the space callback anymore ... only the
intersecting geoms get passed? maybe the callback can initiate the extra
intersection tests itself? (because we want programmable flexibility to
determine what gets intersected and what doesn't)
diff --git a/ode/demo/demo_ode.cpp b/ode/demo/demo_ode.cpp
--- a/ode/demo/demo_ode.cpp
+++ b/ode/demo/demo_ode.cpp
testCrossProduct();
testSetZero();
testNormalize3();
- //testReorthonormalize(); ... not any more
+ //testReorthonormalize(); ... not anymore
testPlaneSpace();
testMatrixMultiply();
testSmallMatrixMultiply();
diff --git a/ode/doc/Doxyfile.in b/ode/doc/Doxyfile.in
--- a/ode/doc/Doxyfile.in
+++ b/ode/doc/Doxyfile.in
# tag to YES if you prefer the old behavior instead.
#
# Note that setting this tag to YES also means that rational rose comments are
-# not recognized any more.
+# not recognized anymore.
# The default value is: NO.
MULTILINE_CPP_IS_BRIEF = NO
return 0;
}
- // Finalyze the depth calculation
+ // Finalize the depth calculation
fDepth -= dFabs(fd);
// get maximum depth
}
else if( (radius - t) <= s && (radius - t) <= (length - s) )
{
- // 1. collsision
+ // 1. collision
if(t > (radius2 + toleranz))
{
// cylinder-axis is outside the sphere
// 2. collision
if(s <= (length * REAL(0.5)) )
{
- // collsision with the first disc
+ // collision with the first disc
contact->depth = s + radius2;
if(contact->depth < 0)
{
}
else
{
- // collsision with the second disc
+ // collision with the second disc
contact->depth = (radius2 + length - s);
if(contact->depth < 0)
{
// Use to classify contacts to be "near" in normal direction\r
static const dReal fSameContactNormalEpsilon = REAL(0.0001); // 1e-4\r
\r
-// If this two contact can be classified as "near"\r
+// If these two contact can be classified as "near"\r
inline int _IsNearContacts(sLocalContactData& c1,sLocalContactData& c2)\r
{\r
int bPosNear = 0;\r
// the contained geoms are divided into two kinds: clean and dirty.
// the clean geoms have not moved since they were put in the list,
// and their AABBs are valid. the dirty geoms have changed position, and
-// their AABBs are may not be valid. the two types are distinguished by the
+// their AABBs may not be valid. the two types are distinguished by the
// GEOM_DIRTY flag. all dirty geoms come *before* all clean geoms in the list.
#if dTLS_ENABLED
@@ -1046,7 +1046,7 @@ int dCollideCCTL(dxGeom *o1, dxGeom *o2, int flags, dContactGeom *contact, int s
TrimeshCollidersCache *pccColliderCache = GetTrimeshCollidersCache(uiTLSKind);
OBBCollider& Collider = pccColliderCache->m_OBBCollider;
- // Will it better to use LSS here? -> confirm Pierre.
+ // Will it be better to use LSS here? -> confirm Pierre.
dQueryCCTLPotentialCollisionTriangles(Collider, cData,
TriMesh, Capsule, pccColliderCache->m_DefaultBoxCache);
if (useFlags != NULL)
{
- // For the last element EdgeRecord::kAbsVertexUsed assignment can be skipped as noone is going to need it any more
+ // For the last element EdgeRecord::kAbsVertexUsed assignment can be skipped as noone is going to need it anymore
useFlags[currEdge[0].m_triIdx] |= ((edges[currEdge[0].m_vertIdx1].m_absVertexFlags & EdgeRecord::AVF_VERTEX_USED) == 0 ? currEdge[0].m_vert1Flags : 0)
| ((edges[currEdge[0].m_vertIdx2].m_absVertexFlags & EdgeRecord::AVF_VERTEX_USED) == 0 ? currEdge[0].m_vert2Flags : 0)
| currEdge[0].m_edgeFlags;
@@ -177,7 +177,7 @@ void dxTriDataBase::meaningfulPreprocess_buildEdgeFlags(uint8 *useFlags/*=NULL*/
dReal normalSegmentDot = dCalcVectorDot3(triangleNormal, secondOppositeVertexSegment);
// This is a concave edge, leave it for the next pass
- // OD: This is the "dot >= kConcaveThresh" check, but since the vectros were not normalized to save on roots and divisions,
+ // OD: This is the "dot >= kConcaveThresh" check, but since the vectors were not normalized to save on roots and divisions,
// the check against zero is performed first and then the dot product is squared and compared against the threshold multiplied by lengths' squares
// OD: Originally, there was dot > -kConcaveThresh check, but this does not seem to be a good idea
// as it can mark all edges on potentially large (nearly) flat surfaces concave.
@@ -131,7 +131,7 @@ int dCollideTrimeshPlane( dxGeom *o1, dxGeom *o2, int flags, dContactGeom* conta
// Collision?
//
- // If alpha < 0 then point is if front of plane. i.e. no contact
+ // If alpha < 0 then point is in front of plane. i.e. no contact
// If alpha = 0 then the point is on the plane
alpha = plane->p[ 3 ] - dCalcVectorDot3( plane->p, vertex );
*************************************************************************/
// OPCODE TriMesh/TriMesh collision code
-// Written at 2006-10-28 by Francisco León (http://gimpact.sourceforge.net)
+// Written at 2006-10-28 by Francisco Le�n (http://gimpact.sourceforge.net)
#ifdef _MSC_VER
#pragma warning(disable:4244 4305) // for VC++, no precision loss complaints
@@ -136,7 +136,7 @@ void SwapNormals(dVector3 *&pen_v, dVector3 *&col_v, dVector3* v1, dVector3* v2,
}
///////////////////////MECHANISM FOR AVOID CONTACT REDUNDANCE///////////////////////////////
-////* Written by Francisco León (http://gimpact.sourceforge.net) *///
+////* Written by Francisco Le�n (http://gimpact.sourceforge.net) *///
#define CONTACT_DIFF_EPSILON REAL(0.00001)
#if defined(dDOUBLE)
#define CONTACT_NORMAL_ZERO REAL(0.0000001)
MULT(normal,normal, REAL(-1.0));
int tempInt = TriIndex1; TriIndex1 = TriIndex2; TriIndex2 = tempInt;
// This should be discarded by optimizer as g1 and g2 are
- // not used any more but it's preferable to keep this line for
+ // not used anymore but it's preferable to keep this line for
// the sake of consistency in variable values.
dxGeom *tempGeom = g1; g1 = g2; g2 = tempGeom;
}
#endif
-// Find the intersectiojn point between a coplanar line segement,
+// Find the intersection point between a coplanar line segement,
// defined by X1 and X2, and a ray defined by X3 and direction N.
//
// This forumla for this calculation is:
This function is called after maximal number of contacts has already been
collected because it has a side effect of replacing penetration depth of
existing contact with larger penetration depth of another matching normal contact.
- If this logic is not necessary any more, you can bail out on reach of contact
+ If this logic is not necessary anymore, you can bail out on reach of contact
number maximum immediately in dCollideTTL(). You will also need to correct
conditional statements after invocations of GenerateContact() in dCollideTTL().
*/
diff --git a/ode/src/convex.cpp b/ode/src/convex.cpp
--- a/ode/src/convex.cpp
+++ b/ode/src/convex.cpp
\param Direction1 The direction of Ray 3
\param t the time "t" in Ray 1 that gives us the closest point
(closest_point=Origin1+(Direction1*t).
- \return true if there is a closest point, false if the rays are paralell.
+ \return true if there is a closest point, false if the rays are parallel.
*/
inline bool ClosestPointInRay(const dVector3 Origin1,
const dVector3 Direction1,
\param q2 end of segment 2
\param t the time "t" in Ray 1 that gives us the closest point
(closest_point=Origin1+(Direction1*t).
- \return true if there is a closest point, false if the rays are paralell.
+ \return true if there is a closest point, false if the rays are parallel.
\note Adapted from Christer Ericson's Real Time Collision Detection Book.
*/
inline void ClosestPointBetweenSegments(dVector3& p1,
\param p2 Plane 2
\param p Contains the origin of the ray upon returning if planes intersect
\param d Contains the direction of the ray upon returning if planes intersect
- \return true if the planes intersect, false if paralell.
+ \return true if the planes intersect, false if parallel.
*/
inline bool IntersectPlanes(const dVector4 p1, const dVector4 p2, dVector3 p, dVector3 d)
{
// Check if contacts are full and both signs have been already found
if (((contacts ^ maxc) | totalsign) == BOTH_SIGNS) // harder to comprehend but requires one register less
{
- break; // Nothing can be changed any more
+ break; // Nothing can be changed anymore
}
}
if (totalsign == BOTH_SIGNS) return contacts;
}
}
// *: usually using the distance part of the plane (axis) is
- // not necesary, however, here we need it here in order to know
+ // not necesary, however, here we need it in order to know
// which face to pick when there are 2 parallel sides.
}
Take only into account the faces that penetrate cvx1 to determine
minimum depth
((max2*min2)<=0) = different sign, or one is zero and thus
- cvx2 barelly touches cvx1
+ cvx2 barely touches cvx1
*/
if (((max2*min2)<=0) && (dFabs(depth)<dFabs(ccso.min_depth)))
{
p[2] = i1[2]+((i2[2]-i1[2])*t);
#else
// Apply reference convex transformations to p
- // The commented out piece of code is likelly to
+ // The commented out piece of code is likely to
// produce less operations than this one, but
// this way we know we are getting the right data
dMultiply0_331(tmp,cvx1.final_posr->R,p);
diff --git a/ode/src/export-dif.cpp b/ode/src/export-dif.cpp
--- a/ode/src/export-dif.cpp
+++ b/ode/src/export-dif.cpp
// @@@ TODO:
// * export all spaces, and geoms in spaces, not just ones attached to bodies
// (separate export function?)
-// * say the space each geom is in, so reader can construct space heirarchy
+// * say the space each geom is in, so reader can construct space hierarchy
// * limot --> separate out into limits and motors?
// * make sure ODE-specific parameters divided out
@@ -873,7 +873,7 @@ void ThreadedEquationSolverLDLT::participateSolvingL1Stripe_X(const dReal *L, dR
break;
}
- // Take a look if any more rows have been completed...
+ // Take a look if anymore rows have been completed...
completedBlocks = refBlockCompletionProgress;
dIASSERT(completedBlocks >= finalColumnBlock);
@@ -1249,7 +1249,7 @@ void ThreadedEquationSolverLDLT::participateSolvingL1Stripe_X(const dReal *L, dR
if (lookaheadBoundaryReached)
{
- dIASSERT(blockProcessingState != BPS_COMPETING_FOR_A_BLOCK); // Why did not we compete???
+ dIASSERT(blockProcessingState != BPS_COMPETING_FOR_A_BLOCK); // Why did we not compete???
// If no row has been processed in the previous pass, compete for the next row to avoid cycling uselessly
if (blockProcessingState <= BPS_NO_BLOCKS_PROCESSED)
@@ -434,7 +434,7 @@ void solveL1Straight (const dReal *L, dReal *B, unsigned rowCount, unsigned rowS
Z11 += p1 * q1;
/* advance pointers */
- // ptrLElement += 1; -- not needed any more
+ // ptrLElement += 1; -- not needed anymore
ptrBElement += 1 * b_stride;
}
@@ -832,7 +832,7 @@ void ThreadedEquationSolverLDLT::participateSolvingL1Straight(const dReal *L, dR
break;
}
- // Take a look if any more columns have been completed...
+ // Take a look if anymore columns have been completed...
completedBlocks = refBlockCompletionProgress;
dIASSERT(completedBlocks >= finalColumnBlock);
@@ -990,7 +990,7 @@ void ThreadedEquationSolverLDLT::participateSolvingL1Straight(const dReal *L, dR
break;
}
- // Take a look if any more columns have been completed...
+ // Take a look if anymore columns have been completed...
completedBlocks = refBlockCompletionProgress;
dIASSERT(completedBlocks >= finalColumnBlock);
@@ -1581,7 +1581,7 @@ void ThreadedEquationSolverLDLT::participateSolvingL1Straight(const dReal *L, dR
if (lookaheadBoundaryReached)
{
- dIASSERT(blockProcessingState != BPS_COMPETING_FOR_A_BLOCK); // Why did not we compete???
+ dIASSERT(blockProcessingState != BPS_COMPETING_FOR_A_BLOCK); // Why did we not compete???
// If no row has been processed in the previous pass, compete for the next row to avoid cycling uselessly
if (blockProcessingState <= BPS_NO_BLOCKS_PROCESSED)
break;
}
- // Take a look if any more columns have been completed...
+ // Take a look if anymore columns have been completed...
completedBlocks = refBlockCompletionProgress;
dIASSERT(completedBlocks >= finalRowBlock);
break;
}
- // Take a look if any more columns have been completed...
+ // Take a look if anymore columns have been completed...
completedBlocks = refBlockCompletionProgress;
dIASSERT(completedBlocks >= finalRowBlock);
@@ -1411,7 +1411,7 @@ void ThreadedEquationSolverLDLT::participateSolvingL1Transposed(const dReal *L,
if (lookaheadBoundaryReached)
{
- dIASSERT(blockProcessingState != BPS_COMPETING_FOR_A_BLOCK); // Why did not we compete???
+ dIASSERT(blockProcessingState != BPS_COMPETING_FOR_A_BLOCK); // Why did we not compete???
// If no row has been processed in the previous pass, compete for the next row to avoid cycling uselessly
if (blockProcessingState <= BPS_NO_BLOCKS_PROCESSED)
--- a/ode/src/heightfield.cpp
+++ b/ode/src/heightfield.cpp
// Uncomment this #define to use the (0,0) corner of the geom as the origin,
// rather than the center. This was the way the original heightfield worked,
-// but as it does not match the way all other geometries work, so for constancy it
+// but as it does not match the way all other geometries work, so, for consistency, it
// was changed to work like this.
// #define DHEIGHTFIELD_CORNER_ORIGIN
@@ -1401,7 +1401,7 @@ int dxHeightfield::dCollideHeightfieldZone( const int minX, const int maxX, cons
itTriangle->planeDef[3] = triplane[3];
}
- // group by Triangles by Planes sharing shame plane definition
+ // group by Triangles by Planes sharing same plane definition
if (tempPlaneBufferSize < numTri)
{
resetPlaneBuffer();
diff --git a/ode/src/joints/pr.cpp b/ode/src/joints/pr.cpp
--- a/ode/src/joints/pr.cpp
+++ b/ode/src/joints/pr.cpp
if (( parameter & 0xff00 ) == 0x100 )\r
{\r
joint->limotR.set( parameter & 0xff, value ); // Take only lower part of the\r
- } // parameter alue\r
+ } // parameter value\r
else\r
{\r
joint->limotP.set( parameter, value );\r
// constraints won't be perfectly satisfied, or even very well\r
// satisfied.)\r
//\r
- // However, we'd need a version of getHingeAngleFromRElativeQuat()\r
+ // However, we'd need a version of getHingeAngleFromRelativeQuat()\r
// that CAN handle when its relative quat is rotated along a direction\r
// other than the given axis. What I have here works,\r
// although it's probably much slower than need be.\r
// dRFrom2Axes(R, ax2[0], ax2[1], ax2[2], ax1[0], ax1[1], ax1[2]);\r
// You see that the R is constructed from the same 2 axis as for angle1\r
// but the first and second axis are swapped.\r
- // So we can take the first R and rapply a rotation to it.\r
+ // So we can take the first R and reapply a rotation to it.\r
// The rotation is around the axis between the 2 axes (ax1 and ax2).\r
// We do a rotation of 180deg.\r
\r
// constraints won't be perfectly satisfied, or even very well\r
// satisfied.)\r
//\r
- // However, we'd need a version of getHingeAngleFromRElativeQuat()\r
+ // However, we'd need a version of getHingeAngleFromRelativeQuat()\r
// that CAN handle when its relative quat is rotated along a direction\r
// other than the given axis. What I have here works,\r
// although it's probably much slower than need be.\r
// constraints won't be perfectly satisfied, or even very well\r
// satisfied.)\r
//\r
- // However, we'd need a version of getHingeAngleFromRElativeQuat()\r
+ // However, we'd need a version of getHingeAngleFromRelativeQuat()\r
// that CAN handle when its relative quat is rotated along a direction\r
// other than the given axis. What I have here works,\r
// although it's probably much slower than need be.\r
diff --git a/ode/src/mat.h b/ode/src/mat.h
--- a/ode/src/mat.h
+++ b/ode/src/mat.h
*************************************************************************/
// matrix class. this is mostly for convenience in the testing code, it is
-// not optimized at all. correctness is much more importance here.
+// not optimized at all. correctness is of much more importance here.
#ifndef _ODE_MAT_H_
#define _ODE_MAT_H_
diff --git a/ode/src/ode.cpp b/ode/src/ode.cpp
--- a/ode/src/ode.cpp
+++ b/ode/src/ode.cpp
dJointGroupID dJointGroupCreate (int /*max_size*/)
{
- // not any more ... dUASSERT (max_size > 0,"max size must be > 0");
+ // not anymore ... dUASSERT (max_size > 0,"max size must be > 0");
dxJointGroup *group = new dxJointGroup();
return group;
}
diff --git a/ode/src/step.cpp b/ode/src/step.cpp
--- a/ode/src/step.cpp
+++ b/ode/src/step.cpp
{\r
// Warning!!!\r
// This code depends on A elements and JinvM elements and therefore \r
- // must be in different sub-stage from A initialization and JinvM calculation in Stage2b \r
+ // must be in a different sub-stage from A initialization and JinvM calculation in Stage2b \r
// to ensure proper synchronization and avoid accessing numbers being modified.\r
// Warning!!!\r
dReal *A = localContext->m_A;\r
//const unsigned int *mindex = localContext->m_mindex;\r
int *findex = localContext->m_findex;\r
dReal *A = localContext->m_A;\r
- dReal *pairsRhsLambda = localContext->m_pairsRhsCfm; // Reuse cfm buffer for lambdas as the former values are not needed any more\r
+ dReal *pairsRhsLambda = localContext->m_pairsRhsCfm; // Reuse cfm buffer for lambdas as the former values are not needed anymore\r
dReal *pairsLoHi = localContext->m_pairsLoHi;\r
\r
if (m > 0) {\r
diff --git a/ode/src/util.cpp b/ode/src/util.cpp
--- a/ode/src/util.cpp
+++ b/ode/src/util.cpp
for (unsigned int j=0; j<3; j++) b->posr.pos[j] += h * b->lvel[j];
if (b->flags & dxBodyFlagFiniteRotation) {
- dVector3 irv; // infitesimal rotation vector
+ dVector3 irv; // infinitesimal rotation vector
dQuaternion q; // quaternion for finite rotation
if (b->flags & dxBodyFlagFiniteRotationAxis) {
dQMultiply0 (q2,q,b->q);
for (unsigned int j=0; j<4; j++) b->q[j] = q2[j];
- // do the infitesimal rotation if required
+ // do the infinitesimal rotation if required
if (b->flags & dxBodyFlagFiniteRotationAxis) {
dReal dq[4];
dWtoDQ (irv,b->q,dq);
}
}
else {
- // the normal way - do an infitesimal rotation
+ // the normal way - do an infinitesimal rotation
dReal dq[4];
dWtoDQ (b->avel,b->q,dq);
for (unsigned int j=0; j<4; j++) b->q[j] += h * dq[j];
diff --git a/ou/include/ou/atomic.h b/ou/include/ou/atomic.h
--- a/ou/include/ou/atomic.h
+++ b/ou/include/ou/atomic.h
* All atomic API implementations are inlined, Exceptions are implementations via
* mutex locks for which it is not reasonable to generate inlined code.
*
- * Atomic functions' prototypes were selected to to provide maximal possible
+ * Atomic functions' prototypes were selected to provide maximal possible
* functionality available on all the platforms mentioned above in common. Function
* names were chosen as a mix of Windows and UNIX naming traditions (more closely
* to Windows though).
* \return \c true if exchange was performed and \c false otherwise.
*
* The function performs comparison of \a aoComparand value with the value pointed
- * by \a paoDestination. If the values match an \a aoExchange is assigned to
- * destination location. If values do not match, the restination remains unchanged.
+ * by \a paoDestination. If the values match the \a aoExchange is assigned to the
+ * destination location. If values do not match the destination remains unchanged.
* Function returns boolean status whether the match and assignment occurred or not.
* The most common uses are relaxed synchronization and construction of LIFO lists.
* \see AtomicExchange
*
* \c AtomicAnd updates variable pointed to by \a paoDestination with result of
* bitwise AND of \a aoBitMask and existing \a paoDestination target. The result
- * is original value that was pointed to by \a paoDestination before the operation
+ * is the original value that was pointed to by \a paoDestination before the operation
* was performed. Common applications are object state manipulations.
* \see AtomicOr
* \see AtomicXor
/**
* \fn atomicord32 _OU_CONVENTION_API AtomicOr(volatile atomicord32 *paoDestination, atomicord32 aoBitMask)
- * \brief Applies a mask with bitwise OR to the destination and returns original
+ * \brief Applies a mask with bitwise OR to the destination and returns the original
* value of destination.
* \param paoDestination A pointer to a variable the bitmask is to be applied to.
* \param aoBitMask A bitmask to be used in operation.
*
* \c AtomicOr updates variable pointed to by \a paoDestination with result of
* bitwise OR of \a aoBitMask and existing \a paoDestination target. The result
- * is original value that was pointed to by \a paoDestination before the operation
+ * is the original value that was pointed to by \a paoDestination before the operation
* was performed. Common applications are object state manipulations.
* \see AtomicAnd
* \see AtomicXor
/**
* \fn atomicord32 _OU_CONVENTION_API AtomicXor(volatile atomicord32 *paoDestination, atomicord32 aoBitMask)
- * \brief Applies a mask with bitwise XOR to the destination and returns original
+ * \brief Applies a mask with bitwise XOR to the destination and returns the original
* value of destination.
* \param paoDestination A pointer to a variable the bitmask is to be applied to.
* \param aoBitMask A bitmask to be used in operation.
*
* \c AtomicXor updates variable pointed to by \a paoDestination with result of
* bitwise XOR of \a aoBitMask and existing \a paoDestination target. The result
- * is original value that was pointed to by \a paoDestination before the operation
+ * is the original value that was pointed to by \a paoDestination before the operation
* was performed. Common applications are object state manipulations.
* \see AtomicAnd
* \see AtomicOr
* \brief The function is identical to \c AtomicIncrement but does not return a result.
*
* The function implementation can be faster on some platforms and it is recommended
- * to use "NoResult" variants in cases when the result of operation or previous value
- * of destination is not used.
+ * to use "NoResult" variants in cases when the result of the operation or the previous value
+ * of the destination is not used.
* \see AtomicIncrement
*/
* \brief The function is identical to \c AtomicDecrement but does not return a result.
*
* The function implementation can be faster on some platforms and it is recommended
- * to use "NoResult" variants in cases when the result of operation or previous value
- * of destination is not used.
+ * to use "NoResult" variants in cases when the result of the operation or the previous value
+ * of the destination is not used.
* \see AtomicDecrement
*/
* \brief The function is identical to \c AtomicExchangeAdd but does not return a result.
*
* The function implementation can be faster on some platforms and it is recommended
- * to use "NoResult" variants in cases when the result of operation or previous value
- * of destination is not used.
+ * to use "NoResult" variants in cases when the result of the operation or the previous value
+ * of the destination is not used.
* \see AtomicExchangeAdd
*/
* \brief The function is identical to \c AtomicAnd but does not return a result.
*
* The function implementation can be faster on some platforms and it is recommended
- * to use "NoResult" variants in cases when the result of operation or previous value
- * of destination is not used.
+ * to use "NoResult" variants in cases when the result of the operation or the previous value
+ * of the destination is not used.
* \see AtomicAnd
*/
* \brief The function is identical to \c AtomicOr but does not return a result.
*
* The function implementation can be faster on some platforms and it is recommended
- * to use "NoResult" variants in cases when the result of operation or previous value
- * of destination is not used.
+ * to use "NoResult" variants in cases when the result of the operation or the previous value
+ * of the destination is not used.
* \see AtomicOr
*/
* \brief The function is identical to \c AtomicXor but does not return a result.
*
* The function implementation can be faster on some platforms and it is recommended
- * to use "NoResult" variants in cases when the result of operation or previous value
- * of destination is not used.
+ * to use "NoResult" variants in cases when the result of the operation or the previous value
+ * of the destination is not used.
* \see AtomicXor
*/
* \brief Performs initialization tasks to allow using atomic functions.
* \return Boolean initialization status.
*
- * The function is required to be called before first use of atomic functions.
+ * The function is required to be called before the first use of atomic functions.
* The initialization uses reference counting, so multiple calls to \c InitializeAtomicAPI
* are allowed. However the counter is not thread safe. Therefore it is recommended
* that the function is always called from main thread on program startup or
*
* The function returns initialization status. If initialization succeeds,
* \c FinalizeAtomicAPI is to be called for each call to \c InitializeAtomicAPI after
- * atomic functions are not needed any more. If \c InitializeAtomicAPI returns
+ * atomic functions are not needed anymore. If \c InitializeAtomicAPI returns
* \c false, the atomic functions may not be used and \c FinalizeAtomicAPI must not be called.
* \see FinalizeAtomicAPI
*/
/*
* Implementation Note:
* The array is intended to store static constant data.
- * Therefore CElementEqualType should not ever need a nontrivial constructor
+ * Therefore CElementEqualType should never need a nontrivial constructor
* and it is acceptable to have it as template parameter.
*/
/*
* Implementation Note:
* The array is intended to store static constant data.
- * Therefore CElementLessType and CElementEqualType should not ever need
+ * Therefore CElementLessType and CElementEqualType should never need
* a nontrivial constructor and it is acceptable to have them
* as template parameters.
*/
--- a/ou/include/ou/platform.h
+++ b/ou/include/ou/platform.h
\r
#if !defined(MAC_OS_X_VERSION)\r
\r
-#error Please defile preprocessor symbol MAC_OS_X_VERSION in command line (e.g. "-DMAC_OS_X_VERSION=1050" for MacOS 10.5)\r
+#error Please define preprocessor symbol MAC_OS_X_VERSION in command line (e.g. "-DMAC_OS_X_VERSION=1050" for MacOS 10.5)\r
\r
\r
#endif // #if !defined(MAC_OS_X_VERSION)\r
@@ -471,14 +471,14 @@ bool CTLSStorageArray::FindFreeStorageBlockIndex(unsigned int &nOutFreeBlockInde
else if (!bIsManualCleanup)
{
- // Execution gets here is all slots were already occupied or
- // they become occupied during search (otherwise why
+ // If execution gets here it means that all slots were already occupied or
+ // they becomed occupied during the search (otherwise why has
// FindFreeStorageBlockIndexWithPossibilityVerified call failed???).
// In Automatic cleanup mode a block can't become free by itself -
// it is just re-allocated for new thread and remains busy.
OU_ASSERT(GetAreAllBlocksOccupied());
- // The locking is performed to avoid more than one threads checking
+ // The locking is performed to avoid more than one thread checking
// for abandoned handles simultaneously.
// If locking fails, execution just proceeds to next array in the chain
if (SetArrayLockedFlag())
@@ -610,7 +610,7 @@ unsigned int CTLSStorageArray::TranslateClientHandles(CClientHandleArray haTrans
if (nSourceCurrentIndex == TLS_ARRAY_ELEMENT__MAX)
{
- // Start indice can be equal if and only if no invalid handles have been found
+ // Start indices can be equal if and only if no invalid handles have been found
if (nSourceStartIndex != nTargetStartIndex)
{
const HANDLE *ph_BlockThreadHandles = GetBlockThreadHandlesStorage();
diff --git a/tests/friction.cpp b/tests/friction.cpp
--- a/tests/friction.cpp
+++ b/tests/friction.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joint.cpp
//
//
/*
- * Now try with no frictino in the second direction. The Jacobian should look like:
+ * Now try with no friction in the second direction. The Jacobian should look like:
* J[1] = [ 0 1 0 0 0 1 0 -1 0 0 0 1 ]
*/
// try again, with zero mu2
diff --git a/tests/joint.cpp b/tests/joint.cpp
--- a/tests/joint.cpp
+++ b/tests/joint.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joint.cpp
//
//
--- a/tests/joints/amotor.cpp
+++ b/tests/joints/amotor.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/fixed.cpp
//
//
diff --git a/tests/joints/ball.cpp b/tests/joints/ball.cpp
--- a/tests/joints/ball.cpp
+++ b/tests/joints/ball.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/ball.cpp
//
//
SUITE (TestdxJointBall)
{
- // The 2 bodies are positionned at (-1, -2, -3), and (11, 22, 33)
- // The bodis have rotation of 27deg around some axis.
+ // The 2 bodies are positioned at (-1, -2, -3) and (11, 22, 33)
+ // The bodies have rotation of 27deg around some axis.
// The joint is a Ball Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
diff --git a/tests/joints/dball.cpp b/tests/joints/dball.cpp
--- a/tests/joints/dball.cpp
+++ b/tests/joints/dball.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/dball.cpp
//
//
diff --git a/tests/joints/fixed.cpp b/tests/joints/fixed.cpp
--- a/tests/joints/fixed.cpp
+++ b/tests/joints/fixed.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/fixed.cpp
//
//
diff --git a/tests/joints/hinge.cpp b/tests/joints/hinge.cpp
--- a/tests/joints/hinge.cpp
+++ b/tests/joints/hinge.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/hinge.cpp
//
//
SUITE (TestdxJointHinge)
{
- // The 2 bodies are positionned at (0, 0, 0), with no rotation
+ // The 2 bodies are positioned at (0, 0, 0) with no rotation
// The joint is an Hinge Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
}
- // The 2 bodies are positionned at (0, 0, 0), with no rotation
+ // The 2 bodies are positioned at (0, 0, 0) with no rotation
// The joint is an Hinge Joint.
// Axis in the inverse direction of the X axis
// Anchor at (0, 0, 0)
--- a/tests/joints/hinge2.cpp
+++ b/tests/joints/hinge2.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/hinge2.cpp
//
//
SUITE (TestdxJointHinge2)
{
- // The 2 bodies are positionned at (-1, -2, -3), and (11, 22, 33)
- // The bodis have rotation of 27deg around some axis.
+ // The 2 bodies are positioned at (-1, -2, -3) and (11, 22, 33)
+ // The bodies have rotation of 27deg around some axis.
// The joint is a Hinge2 Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
--- a/tests/joints/piston.cpp
+++ b/tests/joints/piston.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/piston.cpp
//
//
SUITE (TestdxJointPiston)
{
- // The 2 bodies are positionned at (0, 0, 0), with no rotation
+ // The 2 bodies are positioned at (0, 0, 0) with no rotation
// The joint is a Piston Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
- // The 2 bodies are positionned at (0, 0, 0), with no rotation
+ // The 2 bodies are positioned at (0, 0, 0) with no rotation
// The joint is a Piston Joint
// Axis is the opposite of the X axis
// Anchor at (0, 0, 0)
// Only body 1
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a Piston Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
}
// Only body 1
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a Piston Joint
// Axis is in the oppsite X axis
// Anchor at (0, 0, 0)
// Only body 2
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a Piston Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
}
// Only body 2
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a Piston Joint
// Axis is in the opposite X axis
// Anchor at (0, 0, 0)
// Test Position Rate
// ==========================================================================
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> Axis -->
// B1 F-> => B1
}
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> <-- Axis
// B1 F-> => B1
CHECK_CLOSE (1, dJointGetPistonPositionRate (jId), 1e-4);
}
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> Axis -->
// B1 => B1
}
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> <-- Axis
// B1 => B1
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> Axis -->
// B1 F-> => B1
}
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> <-- Axis
// B1 F-> => B1
}
- // Apply force on body 2 in the X direction also the Axis direction
+ // Apply force on body 2 in the X direction that also is the axis direction
//
// X-------> X---------> Axis -->
// B2 F-> B2
}
- // Apply force on body 2 in the X direction also the Axis direction
+ // Apply force on body 2 in the X direction that also is the axis direction
//
// X-------> X---------> <-- Axis
// B2 F-> B2
-// Create 2 bodies attached by a Piston joint
+ // Create 2 bodies attached by a Piston joint
// Axis is along the X axis (Default value
// Anchor at (0, 0, 0) (Default value)
//
// Compare only one body to 2 bodies with one fixed.
//
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a Piston Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
dJointID jId; // Joint with one body
};
- // This test compare the result of a slider with 2 bodies where body body 2 is
+ // This test compares the result of a slider with 2 bodies where body 2 is
// fixed to the world to a slider with only one body at position 1.
//
- // Test the limits [-1, 0.25] when only one body at is attached to the joint
- // using dJointAttache(jId, bId, 0);
+ // Test the limits [-1, 0.25] when only one body at attached to the joint
+ // using dJointAttach(jId, bId, 0);
//
TEST_FIXTURE(Fixture_dxJointPiston_Compare_Body_At_Zero_Axis_Along_X,
test_Limit_minus1_025_One_Body_on_left)
- // This test compare the result of a slider with 2 bodies where body body 1 is
+ // This test compares the result of a slider with 2 bodies where body 1 is
// fixed to the world to a slider with only one body at position 2.
//
- // Test the limits [-1, 0.25] when only one body at is attached to the joint
- // using dJointAttache(jId, 0, bId);
+ // Test the limits [-1, 0.25] when only one body is attached to the joint
+ // using dJointAttach(jId, 0, bId);
//
TEST_FIXTURE(Fixture_dxJointPiston_Compare_Body_At_Zero_Axis_Along_X,
test_Limit_minus1_025_One_Body_on_right)
- // This test compare the result of a slider with 2 bodies where body body 2 is
+ // This test compares the result of a slider with 2 bodies where body 2 is
// fixed to the world to a slider with only one body at position 1.
//
- // Test the limits [0, 0] when only one body at is attached to the joint
- // using dJointAttache(jId, bId, 0);
+ // Test the limits [0, 0] when only one body is attached to the joint
+ // using dJointAttach(jId, bId, 0);
//
// The body should not move since their is no room between the two limits
//
}
- // This test compare the result of a slider with 2 bodies where body body 1 is
+ // This test compares the result of a slider with 2 bodies where body 1 is
// fixed to the world to a slider with only one body at position 2.
//
- // Test the limits [0, 0] when only one body at is attached to the joint
- // using dJointAttache(jId, 0, bId);
+ // Test the limits [0, 0] when only one body is attached to the joint
+ // using dJointAttach(jId, 0, bId);
//
// The body should not move since their is no room between the two limits
//
diff --git a/tests/joints/pr.cpp b/tests/joints/pr.cpp
--- a/tests/joints/pr.cpp
+++ b/tests/joints/pr.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/pr.cpp
//
//
SUITE (TestdxJointPR)
{
- // The 2 bodies are positionned at (0, 0, 0), with no rotation
+ // The 2 bodies are positioned at (0, 0, 0) with no rotation
// The joint is a PR Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
// Only body 1
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a PR Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
}
// Only body 1
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a PR Joint
// Axis is in the oppsite X axis
// Anchor at (0, 0, 0)
// Compare only one body to 2 bodies with one fixed.
//
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a PR Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
// Only body 2
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a PR Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
}
// Only body 2
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a PR Joint
// Axis is in the opposite X axis
// Anchor at (0, 0, 0)
}
- // The 2 bodies are positionned at (0, 0, 0), and (0, 0, 0)
- // The bodis have rotation of 27deg around some axis.
+ // The 2 bodies are positioned at (0, 0, 0) and (0, 0, 0)
+ // The bodies have rotation of 27deg around some axis.
// The joint is a PR Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
- // This test compare the result of a slider with 2 bodies where body body 2 is
+ // This test compares the result of a slider with 2 bodies where body 2 is
// fixed to the world to a slider with only one body at position 1.
//
- // Test the limits [-1, 0.25] when only one body at is attached to the joint
- // using dJointAttache(jId, bId, 0);
+ // Test the limits [-1, 0.25] when only one body is attached to the joint
+ // using dJointAttach(jId, bId, 0);
//
TEST_FIXTURE(Fixture_dxJointPR_Compare_Body_At_Zero_AxisP_Along_Y,
test_Limit_minus1_025_One_Body_on_left)
- // This test compare the result of a slider with 2 bodies where body body 1 is
+ // This test compares the result of a slider with 2 bodies where body 1 is
// fixed to the world to a slider with only one body at position 2.
//
- // Test the limits [-1, 0.25] when only one body at is attached to the joint
- // using dJointAttache(jId, 0, bId);
+ // Test the limits [-1, 0.25] when only one body is attached to the joint
+ // using dJointAttach(jId, 0, bId);
//
TEST_FIXTURE(Fixture_dxJointPR_Compare_Body_At_Zero_AxisP_Along_Y,
test_Limit_minus1_025_One_Body_on_right)
- // This test compare the result of a slider with 2 bodies where body body 2 is
+ // This test compares the result of a slider with 2 bodies where body 2 is
// fixed to the world to a slider with only one body at position 1.
//
- // Test the limits [0, 0] when only one body at is attached to the joint
- // using dJointAttache(jId, bId, 0);
+ // Test the limits [0, 0] when only one body is attached to the joint
+ // using dJointAttach(jId, bId, 0);
//
// The body should not move since their is no room between the two limits
//
}
- // This test compare the result of a slider with 2 bodies where body body 1 is
+ // This test compares the result of a slider with 2 bodies where body 1 is
// fixed to the world to a slider with only one body at position 2.
//
- // Test the limits [0, 0] when only one body at is attached to the joint
- // using dJointAttache(jId, 0, bId);
+ // Test the limits [0, 0] when only one body is attached to the joint
+ // using dJointAttach(jId, 0, bId);
//
// The body should not move since their is no room between the two limits
//
diff --git a/tests/joints/pu.cpp b/tests/joints/pu.cpp
--- a/tests/joints/pu.cpp
+++ b/tests/joints/pu.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/pu.cpp
//
//
SUITE (TestdxJointPU)
{
- // The 2 bodies are positionned at (0, 0, 0), and (0, 0, 0)
+ // The 2 bodies are positioned at (0, 0, 0) and (0, 0, 0)
// The second body has a rotation of 27deg around X axis.
// The joint is a PU Joint
// Axis is along the X axis
// The joint is a PU Joint
// Default joint value
- // The two bodies at at (0, 0, 0)
+ // The two bodies are at (0, 0, 0)
struct Fixture_dxJointPU_B1_and_B2_At_Zero
{
Fixture_dxJointPU_B1_and_B2_At_Zero()
CHECK_CLOSE (0.0, dJointGetPUPosition (jId), 1e-4);
}
- // Attache only one body at position 1 to the joint dJointAttach (jId, bId, 0)
+ // Attach only one body at position 1 to the joint dJointAttach (jId, bId, 0)
// Move 1st body offset unit in the opposite X direction
//
// X-------> X---------> Axis -->
- // Attache only one body at position 2 to the joint dJointAttach (jId, 0, bId)
+ // Attach only one body at position 2 to the joint dJointAttach (jId, 0, bId)
// Move 1st body offset unit in the X direction
//
// X-------> X---------> Axis -->
CHECK_CLOSE (0.0, dJointGetPUPosition (jId), 1e-4);
}
- // Attache only one body at position 2 to the joint dJointAttach (jId, 0, bId)
+ // Attach only one body at position 2 to the joint dJointAttach (jId, 0, bId)
// Move 1st body offset unit in the opposite X direction
//
// X-------> X---------> Axis -->
// Only one body
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body is positioned at (0, 0, 0) with no rotation
// The joint is a PU Joint
// Axis is in the oppsite X axis
// Anchor at (0, 0, 0)
test_dJointSetPUAxisOffset_B2_OffsetUnit)
{
// By default it is attached to position 1
- // Now attach the body at positiojn 2
+ // Now attach the body at position 2
dJointAttach(jId, 0, bId);
CHECK_CLOSE (0.0, dJointGetPUPosition (jId), 1e-4);
test_dJointSetPUAxisOffset_B2_Minus_OffsetUnit)
{
// By default it is attached to position 1
- // Now attach the body at positiojn 2
+ // Now attach the body at position 2
dJointAttach(jId, 0, bId);
CHECK_CLOSE (0.0, dJointGetPUPosition (jId), 1e-4);
// Compare only one body to 2 bodies with one fixed.
//
- // The body are positionned at (0, 0, 0), with no rotation
+ // The bodies are positioned at (0, 0, 0) with no rotation
// The joint is a PU Joint with default values
struct Fixture_dxJointPU_Compare_One_Body_To_Two_Bodies_At_Zero
{
- // This test compare the result of a pu joint with 2 bodies where body body 2 is
+ // This test compares the result of a pu joint with 2 bodies where body 2 is
// fixed to the world to a pu joint with only one body at position 1.
//
- // Test the limits [-1, 0.25] when only one body at is attached to the joint
- // using dJointAttache(jId, bId, 0);
+ // Test the limits [-1, 0.25] when only one body is attached to the joint
+ // using dJointAttach(jId, bId, 0);
//
TEST_FIXTURE(Fixture_dxJointPU_Compare_One_Body_To_Two_Bodies_At_Zero,
test_Limit_minus1_025_One_Body_on_left)
- // This test compare the result of a pu joint with 2 bodies where body body 1 is
+ // This test compares the result of a pu joint with 2 bodies where body 1 is
// fixed to the world to a pu joint with only one body at position 2.
//
- // Test the limits [-1, 0.25] when only one body at is attached to the joint
- // using dJointAttache(jId, 0, bId);
+ // Test the limits [-1, 0.25] when only one body is attached to the joint
+ // using dJointAttach(jId, 0, bId);
//
TEST_FIXTURE(Fixture_dxJointPU_Compare_One_Body_To_Two_Bodies_At_Zero,
test_Limit_minus1_025_One_Body_on_right)
- // This test compare the result of a pu joint with 2 bodies where body 2 is
+ // This test compares the result of a pu joint with 2 bodies where body 2 is
// fixed to the world to a pu joint with only one body at position 1.
//
- // Test the limits [0, 0] when only one body at is attached to the joint
- // using dJointAttache(jId, bId, 0);
+ // Test the limits [0, 0] when only one body is attached to the joint
+ // using dJointAttach(jId, bId, 0);
//
// The body should not move since their is no room between the two limits
//
}
- // This test compare the result of a pu joint with 2 bodies where body body 1 is
+ // This test compares the result of a pu joint with 2 bodies where body 1 is
// fixed to the world to a pu joint with only one body at position 2.
//
- // Test the limits [0, 0] when only one body at is attached to the joint
- // using dJointAttache(jId, 0, bId);
+ // Test the limits [0, 0] when only one body is attached to the joint
+ // using dJointAttach(jId, 0, bId);
//
// The body should not move since their is no room between the two limits
//
--- a/tests/joints/slider.cpp
+++ b/tests/joints/slider.cpp
// 1 2 3 4 5 6 7
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/slider.cpp
//
//
- // The 2 bodies are positionned at (0, 0, 0), with no rotation
+ // The 2 bodies are positioned at (0, 0, 0) with no rotation
// The joint is a Slider Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
- // The 2 bodies are positionned at (0, 0, 0), with no rotation
+ // The 2 bodies are positioned at (0, 0, 0) with no rotation
// The joint is a Slider Joint
// Axis is the opposite of the X axis
// Anchor at (0, 0, 0)
// Only body 1
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body is positioned at (0, 0, 0) with no rotation
// The joint is a Slider Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
// Only body 1
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body is positioned at (0, 0, 0) with no rotation
// The joint is a Slider Joint
// Axis is in the oppsite X axis
// Anchor at (0, 0, 0)
// Only body 2
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body is positioned at (0, 0, 0) with no rotation
// The joint is a Slider Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
}
// Only body 2
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body is positioned at (0, 0, 0) with no rotation
// The joint is a Slider Joint
// Axis is in the oppsite X axis
// Anchor at (0, 0, 0)
// ==========================================================================
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> Axis -->
// B1 F-> => B1
}
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> <-- Axis
// B1 F-> => B1
CHECK_CLOSE (1, dJointGetSliderPositionRate(jId), 1e-4);
}
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> Axis -->
// B1 => B1
}
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> <-- Axis
// B1 => B1
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> Axis -->
// B1 F-> => B1
}
- // Apply force on 1st body in the X direction also the Axis direction
+ // Apply force on 1st body in the X direction that also is the axis direction
//
// X-------> X---------> <-- Axis
// B1 F-> => B1
}
- // Apply force on body 2 in the X direction also the Axis direction
+ // Apply force on body 2 in the X direction that also is the axis direction
//
// X-------> X---------> Axis -->
// B2 F-> B2
}
- // Apply force on body 2 in the X direction also the Axis direction
+ // Apply force on body 2 in the X direction that also is the axis direction
//
// X-------> X---------> <-- Axis
// B2 F-> B2
// Create 2 bodies attached by a Slider joint
- // Axis is along the X axis (Default value
+ // Axis is along the X axis (Default value)
// Anchor at (0, 0, 0) (Default value)
//
// ^Y
// Compare Only body 1 to 2 bodies with one fixed.
//
- // The body are positionned at (0, 0, 0), with no rotation
+ // The body are positioned at (0, 0, 0) with no rotation
// The joint is a Slider Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
dJointID jId; // Joint with one body
};
- // This test compare the result of a slider with 2 bodies where body body 2 is
+ // This test compares the result of a slider with 2 bodies where body 2 is
// fixed to the world to a slider with only one body at position 1.
//
- // Test the limits [-1, 0.25] when only one body at is attached to the joint
- // using dJointAttache(jId, bId, 0);
+ // Test the limits [-1, 0.25] when only one body is attached to the joint
+ // using dJointAttach(jId, bId, 0);
//
TEST_FIXTURE(Fixture_dxJointSlider_Compare_Body_At_Zero_Axis_Along_X,
test_Limit_minus1_025_One_Body_on_left)
- // This test compare the result of a slider with 2 bodies where body body 1 is
+ // This test compares the result of a slider with 2 bodies where body 1 is
// fixed to the world to a slider with only one body at position 2.
//
- // Test the limits [-1, 0.25] when only one body at is attached to the joint
- // using dJointAttache(jId, 0, bId);
+ // Test the limits [-1, 0.25] when only one body is attached to the joint
+ // using dJointAttach(jId, 0, bId);
//
TEST_FIXTURE(Fixture_dxJointSlider_Compare_Body_At_Zero_Axis_Along_X,
test_Limit_minus1_025_One_Body_on_right)
- // This test compare the result of a slider with 2 bodies where body body 2 is
+ // This test compares the result of a slider with 2 bodies where body 2 is
// fixed to the world to a slider with only one body at position 1.
//
- // Test the limits [0, 0] when only one body at is attached to the joint
- // using dJointAttache(jId, bId, 0);
+ // Test the limits [0, 0] when only one body is attached to the joint
+ // using dJointAttach(jId, bId, 0);
//
// The body should not move since their is no room between the two limits
//
}
- // This test compare the result of a slider with 2 bodies where body body 1 is
+ // This test compares the result of a slider with 2 bodies where body 1 is
// fixed to the world to a slider with only one body at position 2.
//
- // Test the limits [0, 0] when only one body at is attached to the joint
- // using dJointAttache(jId, 0, bId);
+ // Test the limits [0, 0] when only one body is attached to the joint
+ // using dJointAttach(jId, 0, bId);
//
// The body should not move since their is no room between the two limits
//
*************************************************************************/
////////////////////////////////////////////////////////////////////////////////
-// This file create unit test for some of the functions found in:
+// This file creates unit tests for some of the functions found in:
// ode/src/joinst/universal.cpp
//
//
SUITE (TestdxJointUniversal)
{
- // The 2 bodies are positionned at (0, 0, 0)
- // The bodis have no rotation.
+ // The 2 bodies are positioned at (0, 0, 0)
+ // The bodies have no rotation.
// The joint is a Universal Joint
// Axis1 is along the X axis
// Axis2 is along the Y axis
};
- // The 2 bodies are positionned at (-1, -2, -3), and (11, 22, 33)
- // The bodis have rotation of 27deg around some axis.
+ // The 2 bodies are positioned at (-1, -2, -3) and (11, 22, 33)
+ // The bodies have rotation of 27deg around some axis.
// The joint is a Universal Joint
// Axis is along the X axis
// Anchor at (0, 0, 0)
// Create 2 bodies attached by a Universal joint
- // Axis is along the X axis (Default value
+ // Axis is along the X axis (Default value)
// Anchor at (0, 0, 0) (Default value)
//
// ^Y
// Rotate 1st body 0.23rad around X axis and 2nd body 0.37rad around Y (Axis2)
// then back to their original position.
- // The Axis offset are set one at a time
+ // The Axis offsets are set one at a time
//
// ^ ^ ^ ^ Z ^ ^ Y (N.B. Y is going in the screen)
// | | => \ / | /
-// The 2 bodies are positionned at (0, 0, 0), with no rotation
+// The 2 bodies are positioned at (0, 0, 0) with no rotation
// The joint is an Universal Joint.
// Axis in the inverse direction of the X axis
// Anchor at (0, 0, 0)
// Rotate the body by 90deg around X then back to original position.
// The body is attached at the second position of the joint:
- // dJointAttache(jId, 0, bId);
+ // dJointAttach(jId, 0, bId);
//
// ^
// | => <---
// Rotate the body by -0.23rad around X then back to original position.
// The body is attached at the second position of the joint:
- // dJointAttache(jId, 0, bId);
+ // dJointAttach(jId, 0, bId);
//
// ^ ^
// | => /
- // The 2 bodies are positionned at (0,0,0), and (0,0,0)
- // The bodis have no rotation.
+ // The 2 bodies are positioned at (0,0,0) and (0,0,0)
+ // The bodies have no rotation.
// The joint is a Universal Joint
// The axis of the joint are at random (Still at 90deg w.r.t each other)
// Anchor at (0, 0, 0)