format 73
"collision" // sofa::core::collision
  revision 3
  modified_by 48 "allardj"
  // class settings
  //class diagram settings
  draw_all_relations default hide_attributes default hide_operations default hide_getset_operations default show_members_full_definition default show_members_visibility default show_members_stereotype default show_members_multiplicity default show_members_initialization default show_attribute_modifiers default member_max_width 0 show_parameter_dir default show_parameter_name default package_name_in_tab default class_drawing_mode default drawing_language default show_context_mode default auto_label_position default show_relation_modifiers default show_relation_visibility default show_infonote default shadow default show_stereotype_properties default
  //use case diagram settings
  package_name_in_tab default show_context default auto_label_position default draw_all_relations default class_drawing_mode default shadow default show_stereotype_properties default
  //sequence diagram settings
  show_full_operations_definition default write_horizontally default class_drawing_mode default drawing_language default draw_all_relations default shadow default show_stereotype_properties default
  //collaboration diagram settings
  show_full_operations_definition default show_hierarchical_rank default write_horizontally default drawing_language default package_name_in_tab default show_context default draw_all_relations default shadow default show_stereotype_properties default
  //object diagram settings
   write_horizontally default package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default show_stereotype_properties default
  //component diagram settings
  package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default
  draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
  //deployment diagram settings
  package_name_in_tab default show_context default write_horizontally default auto_label_position default draw_all_relations default shadow default
  draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
  //state diagram settings
  package_name_in_tab default show_context default auto_label_position default write_trans_label_horizontally default show_trans_definition default draw_all_relations default shadow default
  show_activities default region_horizontally default drawing_language default show_stereotype_properties default
  //activity diagram settings
  package_name_in_tab default show_context default show_opaque_action_definition default auto_label_position default write_flow_label_horizontally default draw_all_relations default shadow default
  show_infonote default drawing_language default show_stereotype_properties default
  
  cpp_h_dir "/home/allardj/work/Sofa/framework/sofa/core/collision/"
  cpp_src_dir "/home/allardj/work/Sofa/framework/sofa/core/collision/"
  cpp_namespace "sofa::core::collision"
  classview 128560 "collision"
    //class diagram settings
    draw_all_relations default hide_attributes default hide_operations default hide_getset_operations default show_members_full_definition default show_members_visibility default show_members_stereotype default show_members_multiplicity default show_members_initialization default show_attribute_modifiers default member_max_width 0 show_parameter_dir default show_parameter_name default package_name_in_tab default class_drawing_mode default drawing_language default show_context_mode default auto_label_position default show_relation_modifiers default show_relation_visibility default show_infonote default shadow default show_stereotype_properties default
    //collaboration diagram settings
    show_full_operations_definition default show_hierarchical_rank default write_horizontally default drawing_language default package_name_in_tab default show_context default draw_all_relations default shadow default show_stereotype_properties default
    //object diagram settings
     write_horizontally default package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default show_stereotype_properties default
    //sequence diagram settings
    show_full_operations_definition default write_horizontally default class_drawing_mode default drawing_language default draw_all_relations default shadow default show_stereotype_properties default
    //state diagram settings
    package_name_in_tab default show_context default auto_label_position default write_trans_label_horizontally default show_trans_definition default draw_all_relations default shadow default
    show_activities default region_horizontally default drawing_language default show_stereotype_properties default
    //class settings
    //activity diagram settings
    package_name_in_tab default show_context default show_opaque_action_definition default auto_label_position default write_flow_label_horizontally default draw_all_relations default shadow default
    show_infonote default drawing_language default show_stereotype_properties default
    class 174128 "BroadPhaseDetection"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 * @brief given a set of root collision models, computes potentially colliding pairs."
      classrelation 153264 // <generalisation>
	relation 153264 ---|>
	  a public
	    cpp virtual default "${type}"
	    classrelation_ref 153264 // <generalisation>
	  b parent class_ref 174256 // Detection
      end

      operation 244272 "~BroadPhaseDetection"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 244400 "beginBroadPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		cmPairs.clear();
	};
"
	
	
	
	
	comment "/ Clear all the potentially colliding pairs detected in the previous simulation step"
      end

      operation 244528 "addCollisionModel"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param inout name "cm" type class_ref 132016 // CollisionModel
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Add a new collision model to the set of root collision models managed by this class"
      end

      operation 244656 "addCollisionModels"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "v" explicit_type "sofa::helper::vector<core::CollisionModel *>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		for (sofa::helper::vector<core::CollisionModel *>::const_iterator it = v.begin(); it<v.end(); it++)
			addCollisionModel(*it);
	};
"
	
	
	
	
	comment "/ Add a list of collision models to the set of root collision models managed by this class"
      end

      operation 244784 "endBroadPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	};
"
	
	
	
	
	comment "/ Actions to accomplish when the broadPhase is finished. By default do nothing."
      end

      operation 244912 "getCollisionModelPairs"
	cpp_inline public explicit_return_type "sofa::helper::vector<std::pair<core::CollisionModel*, core::CollisionModel*> >"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return cmPairs; };
"
	
	
	
	
	comment "/ Get the potentially colliding pairs detected"
      end

      attribute 146736 "cmPairs"
	protected explicit_type " std::pair<core::CollisionModel*, core::CollisionModel*> "
	stereotype "sofa::helper::vector"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 146864 "storedCmPairs"
	protected explicit_type "Instance,sofa::helper::vector< std::pair<core::CollisionModel*, core::CollisionModel*> > "
	stereotype "std::map"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 245040 "changeInstanceBP"
	cpp_virtual cpp_inline protected explicit_return_type "void"
	nparams 1
	  param in name "inst" explicit_type "Instance"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		storedCmPairs[instance].swap(cmPairs);
		cmPairs.swap(storedCmPairs[inst]);
	};
"
	
	
	
	
      end
    end

    class 174256 "Detection"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 155568 // <generalisation>
	relation 155568 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 155568 // <generalisation>
	  b parent class_ref 174512 // typedef9
      end

      classrelation 155696 // <generalisation>
	relation 155696 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 155696 // <generalisation>
	  b parent class_ref 174384 // CollisionAlgorithm
      end

      classrelation 155824 // ()
	relation 155824 ---> name ""
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 155824 // ()
	  b parent class_ref 175408 // Intersection
      end

      classrelation 155952 // <unidirectional association>
	relation 155952 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<Instance,${type}*> ${name}${value};
"
	    classrelation_ref 155952 // <unidirectional association>
	  b parent class_ref 175408 // Intersection
      end

      operation 248880 "Detection"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : intersectionMethod(NULL)
	{
	};
"
	
	
	
	
      end

      operation 249008 "setIntersectionMethod"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param inout name "v" type class_ref 175408 // Intersection
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { intersectionMethod = v;    };
"
	
	
	
	
	comment "/ virtual because subclasses might do precomputations based on intersection algorithms"
      end

      operation 249136 "getIntersectionMethod"
	const cpp_inline public return_type class_ref 175408 // Intersection
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} { return intersectionMethod; };
"
	
	
	
	
      end

      operation 249264 "changeInstanceBP"
	cpp_virtual cpp_inline protected explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "Instance"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
      end

      operation 249392 "changeInstanceNP"
	cpp_virtual cpp_inline protected explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "Instance"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
      end

      operation 249520 "changeInstance"
	cpp_virtual cpp_inline protected explicit_return_type "void"
	nparams 1
	  param in name "inst" explicit_type "Instance"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		storedIntersectionMethod[instance] = intersectionMethod;
		intersectionMethod = storedIntersectionMethod[inst];
		// callback overriden by BroadPhaseDetection
		changeInstanceBP(inst);
		// callback overriden by NarrowPhaseDetection
		changeInstanceNP(inst);
	};
"
	
	
	
	
      end
    end

    class 174384 "CollisionAlgorithm"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 153392 // <generalisation>
	relation 153392 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 153392 // <generalisation>
	  b parent class_ref 174512 // typedef9
      end

      classrelation 153520 // <generalisation>
	relation 153520 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 153520 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      class 174640 "Instance"
	visibility package stereotype "typedef" explicit_base_type "void"
	cpp_decl "${comment}typedef ${type}*  ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      classrelation 153648 // instance (<directional composition>)
	relation 153648 *-->
	  a role_name "instance" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 153648 // instance (<directional composition>)
	  b parent class_ref 174640 // Instance
      end

      operation 245168 "CollisionAlgorithm"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : instance(NULL)
	{
	};
"
	
	
	
	
      end

      operation 245296 "setInstance"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "inst" type class_ref 174640 // Instance
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		if (instance == inst) return;
		changeInstance(inst);
		instance = inst;
	};
"
	
	
	
	
	comment "/ Allow to store multiple internal states by specifying a different collision pipeline 'instance'"
      end

      operation 245424 "changeInstance"
	abstract cpp_virtual protected explicit_return_type "void"
	nparams 1
	  param in name "" type class_ref 174640 // Instance
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end
    end

    class 174512 "typedef9"
      visibility package stereotype "typedef" explicit_base_type "virtual"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 174768 "CollisionGroupManager"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "class Scene;
*
 * @brief Given a set of contacts, create integration groups
 *
 * For each pair of objects in contacts :
 *
 * - Look which mechanical integration algorithm is used
 *
 * - If they are “compatible”, create a algorithm merging them
 * 
 *   -# Often simply the most stable of the two
 *
 *	Explicit Euler + Explicit Runge Kutta -> Explicit Runge Kutta
 *
 *	Explicit * + Implicit Euler -> Implicit Euler
 *
 *"
      classrelation 153776 // <generalisation>
	relation 153776 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 153776 // <generalisation>
	  b parent class_ref 174512 // typedef9
      end

      classrelation 153904 // <generalisation>
	relation 153904 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 153904 // <generalisation>
	  b parent class_ref 174384 // CollisionAlgorithm
      end

      classrelation 154032 // groups (<unidirectional association>)
	relation 154032 --->
	  stereotype "sofa::helper::vector"
	  a role_name "groups" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}*> ${name}${value};
"
	    classrelation_ref 154032 // groups (<unidirectional association>)
	  b parent class_ref 141104 // BaseContext
      end

      operation 245552 "~CollisionGroupManager"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 245680 "createGroups"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 2
	  param inout name "scene" type class_ref 141104 // BaseContext
	  param in name "contacts" explicit_type "sofa::helper::vector<Contact*>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Create the integration groups"
      end

      operation 245808 "clearGroups"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param inout name "scene" type class_ref 141104 // BaseContext
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Clear de integration groups"
      end

      operation 245936 "getGroups"
	cpp_virtual cpp_inline public explicit_return_type "sofa::helper::vector<objectmodel::BaseContext*>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return groups; };
"
	
	
	
	
	comment "/ Get de integration groups"
      end

      attribute 146992 "storedGroups"
	protected explicit_type "Instance,sofa::helper::vector<core::objectmodel::BaseContext*> "
	stereotype "std::map"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 246064 "changeInstance"
	cpp_virtual cpp_inline protected explicit_return_type "void"
	nparams 1
	  param in name "inst" explicit_type "Instance"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		storedGroups[instance].swap(groups);
		groups.swap(storedGroups[inst]);
	};
"
	
	
	
	
      end
    end

    class 174896 "Contact"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 * @brief contact response component handling the response between a pair of models
 * 
 * - Dynamically created by the ContactManager
 *
 *   -# Persistent between iterations
 *
 *   -# New id data in DetectionOutput allow to keep an history of a contact
 *
 * - In most cases : create and initialize the real response component
 *
 *   -#InteractionForceField, Constraint, ...
 *
 * - Contact object dynamically appears in the scenegraph"
      classrelation 154160 // <generalisation>
	relation 154160 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 154160 // <generalisation>
	  b parent class_ref 174512 // typedef9
      end

      classrelation 154288 // <generalisation>
	relation 154288 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 154288 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 246192 "~Contact"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/Destructor"
      end

      operation 246320 "getCollisionModels"
	abstract cpp_virtual public explicit_return_type "std::pair< core::CollisionModel*, core::CollisionModel* >"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Get the pair of collision models which are in contact"
      end

      operation 246448 "setDetectionOutputs"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param inout name "outputs" type class_ref 175024 // DetectionOutputVector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Set the generic description of a contact point"
      end

      operation 246576 "createResponse"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param inout name "group" type class_ref 141104 // BaseContext
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 246704 "removeResponse"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 246832 "keepAlive"
	cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return false; };
"
	
	
	
	
	comment "/ Return true if this contact should be kept alive, even if objects are no longer in collision"
      end

      operation 246960 "setKeepAlive"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "/ Control the keepAlive flag of the contact. Note that not all contacts support this method"
      end

      class 175152 "Factory"
	visibility package 
	cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 154416 // <generalisation>
	  relation 154416 ---|>
	    a public
	      cpp default "${type}"
	      classrelation_ref 154416 // <generalisation>
	    b parent class_ref 175280 // typedef10
	end

	operation 247088 "getInstance"
	  class_operation preserve_cpp_body_indent public return_type class_ref 175152 // Factory
	  nparams 0
	  cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	  cpp_def "//template class Factory<std::string, Contact, std::pair<core::CollisionModel*,core::CollisionModel*> >;

${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	  
	  
	  
	  
	end

	operation 247216 "CreateObject"
	  class_operation cpp_inline public explicit_return_type "Object"
	  nparams 2
	    param in name "key" explicit_type "Key"
	    param in name "arg" explicit_type "Argument"
	  cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
		return getInstance()->createObject(key, arg);
	};
"
	  
	  
	  
	  
	end

	operation 247344 "CreateAnyObject"
	  class_operation cpp_inline public explicit_return_type "Object"
	  nparams 1
	    param in name "arg" explicit_type "Argument"
	  cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		return getInstance()->createAnyObject(arg);
	};
"
	  
	  
	  
	  
	end
      end

      class 175280 "typedef10"
	visibility package stereotype "typedef" explicit_base_type "helper::Factory< std::string, Contact, std::pair<std::pair<core::CollisionModel*,core::CollisionModel*>,Intersection*> >"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 247472 "Create"
	class_operation preserve_cpp_body_indent public return_type class_ref 174896 // Contact
	nparams 4
	  param in name "type" explicit_type "std::string"
	  param inout name "model1" type class_ref 132016 // CollisionModel
	  param inout name "model2" type class_ref 132016 // CollisionModel
	  param inout name "intersectionMethod" type class_ref 175408 // Intersection
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}const ${t0} & ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} * ${p2}${v2}, ${t3} * ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}const ${t0} & ${p0}, ${t1} * ${p1}, ${t2} * ${p2}, ${t3} * ${p3}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Create a new contact given 2 collision elements and an intersection method"
      end

      operation 247600 "create"
	stereotype "template"
	class_operation cpp_inline public explicit_return_type "void"
	nparams 2
	  param inout name "obj" explicit_type "RealContact"
	  param in name "arg" explicit_type "std::pair<std::pair<core::CollisionModel*,core::CollisionModel*>,Intersection*>"
	cpp_decl "    ${comment}template<class RealContact>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        typedef typename RealContact::CollisionModel1 RealCollisionModel1;
        typedef typename RealContact::CollisionModel2 RealCollisionModel2;
        typedef typename RealContact::Intersection RealIntersection;
        RealCollisionModel1* model1 = dynamic_cast<RealCollisionModel1*>(arg.first.first);
        RealCollisionModel2* model2 = dynamic_cast<RealCollisionModel2*>(arg.first.second);
        RealIntersection* inter  = dynamic_cast<RealIntersection*>(arg.second);
        // CHANGE(Jeremie A. 2007-12-07): disable automatic swapping of the models, as it brings hard to find bugs where the order does not match the DetectionOutputs...
        // The Intersector class is now modified so that they are swapped to an unique order at the detection phase of the pipeline.
        /* if (model1==NULL || model2==NULL)
        { // Try the other way around
            model1 = dynamic_cast<RealCollisionModel1*>(arg.first.second);
            model2 = dynamic_cast<RealCollisionModel2*>(arg.first.first);
        }
        */
        if (model1==NULL || model2==NULL || inter==NULL) return;
        obj = new RealContact(model1, model2, inter);
    };
"
	
	
	
	
      end
    end

    class 175024 "DetectionOutputVector"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Abstract description of a set of contact point."
      operation 249648 "~DetectionOutputVector"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {};
"
	
	
	
	
      end

      operation 249776 "clear"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Clear the content of this vector"
      end

      operation 249904 "size"
	abstract const cpp_virtual public explicit_return_type "uint"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Current size (number of detected contacts"
      end

      operation 250032 "empty"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return size()==0; };
"
	
	
	
	
	comment "/ Test if the vector is empty"
      end
    end

    class 175408 "Intersection"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "* @brief Given 2 collision elements, test if an intersection is possible (for bounding volumes), or compute intersection points if any"
      classrelation 157104 // <generalisation>
	relation 157104 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 157104 // <generalisation>
	  b parent class_ref 174512 // typedef9
      end

      classrelation 157232 // <generalisation>
	relation 157232 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 157232 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 252464 "~Intersection"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 252592 "findIntersector"
	abstract cpp_virtual public return_type class_ref 176816 // ElementIntersector
	nparams 3
	  param inout name "object1" type class_ref 132016 // CollisionModel
	  param inout name "object2" type class_ref 132016 // CollisionModel
	  param inout name "swapModels" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Return the intersector class handling the given pair of collision models, or NULL if not supported.
/ @param swapModel output value set to true if the collision models must be swapped before calling the intersector."
      end

      operation 252720 "isSupported"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type "bool"
	nparams 2
	  param in name "elem1" type class_ref 131888 // CollisionElementIterator
	  param in name "elem2" type class_ref 131888 // CollisionElementIterator
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Test if intersection between 2 types of elements is supported, i.e. an intersection test is implemented for this combinaison of types.
/ Note that this method is deprecated in favor of findIntersector"
      end

      operation 252848 "useProximity"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return false; };
"
	
	
	
	
	comment "/ returns true if algorithm uses proximity detection"
      end

      operation 252976 "useContinuous"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return false; };
"
	
	
	
	
	comment "/ returns true if algorithm uses continous detection"
      end

      operation 253104 "getAlarmDistance"
	const cpp_virtual cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return 0.0; };
"
	
	
	
	
	comment "/ Return the alarm distance (must return 0 if useProximity() is false)"
      end

      operation 253232 "getContactDistance"
	const cpp_virtual cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return 0.0; };
"
	
	
	
	
	comment "/ Return the contact distance (must return 0 if useProximity() is false)"
      end

      operation 253360 "beginBroadPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	};
"
	
	
	
	
	comment "/ Actions to accomplish when the broadPhase is started. By default do nothing."
      end

      operation 253488 "endBroadPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	};
"
	
	
	
	
	comment "/ Actions to accomplish when the broadPhase is finished. By default do nothing."
      end

      operation 253616 "beginNarrowPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	};
"
	
	
	
	
	comment "/ Actions to accomplish when the narrow Phase is started. By default do nothing."
      end

      operation 253744 "endNarrowPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	};
"
	
	
	
	
	comment "/ Actions to accomplish when the narrow Phase is finished. By default do nothing."
      end
    end

    class 175536 "ContactManager"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 * @brief Given a set of detected contact points, create contact response components"
      classrelation 154544 // <generalisation>
	relation 154544 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 154544 // <generalisation>
	  b parent class_ref 174512 // typedef9
      end

      classrelation 154672 // <generalisation>
	relation 154672 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 154672 // <generalisation>
	  b parent class_ref 174384 // CollisionAlgorithm
      end

      class 175920 "DetectionOutputMap"
	visibility package stereotype "typedef" base_type class_ref 175792 // DetectionOutputMap
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 154800 // <dependency>
	  relation 154800 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 154800 // <dependency>
	    b parent class_ref 175792 // DetectionOutputMap
	end
      end

      class 176048 "ContactVector"
	visibility package stereotype "typedef" base_type class_ref 174896 // Contact
	cpp_decl "${comment}typedef sofa::helper::vector<${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 154928 // <dependency>
	  relation 154928 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 154928 // <dependency>
	    b parent class_ref 174896 // Contact
	end
      end

      operation 247728 "ContactManager"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : intersectionMethod(NULL)
	{
	};
"
	
	
	
	
	comment "/ Constructor"
      end

      operation 247856 "~ContactManager"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 247984 "createContacts"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param inout name "outputs" type class_ref 175920 // DetectionOutputMap
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 248112 "getContacts"
	cpp_virtual cpp_inline public return_type class_ref 176048 // ContactVector
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return contacts; };
"
	
	
	
	
      end

      operation 248240 "removeContacts"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" type class_ref 176048 // ContactVector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { };
"
	
	
	
	
	comment "/ virtual methods used for cleaning the pipeline after a dynamic graph node deletion.
* 
	 * Contacts can be attached to a deleted node and their deletion is a problem for the pipeline.
	 * @param c is the list of deleted contacts."
      end

      operation 248368 "setIntersectionMethod"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param inout name "v" type class_ref 175408 // Intersection
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { intersectionMethod = v;    };
"
	
	
	
	
	comment "/ virtual because subclasses might do precomputations based on intersection algorithms"
      end

      operation 248496 "getIntersectionMethod"
	const cpp_inline public return_type class_ref 175408 // Intersection
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} { return intersectionMethod; };
"
	
	
	
	
      end

      operation 248624 "getContactResponse"
	abstract cpp_virtual public explicit_return_type "std::string"
	nparams 2
	  param inout name "model1" type class_ref 132016 // CollisionModel
	  param inout name "model2" type class_ref 132016 // CollisionModel
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      classrelation 155056 // intersectionMethod (<unidirectional association>)
	relation 155056 --->
	  a role_name "intersectionMethod" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 155056 // intersectionMethod (<unidirectional association>)
	  b parent class_ref 175408 // Intersection
      end

      classrelation 155184 // contacts (<directional composition>)
	relation 155184 *-->
	  a role_name "contacts" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 155184 // contacts (<directional composition>)
	  b parent class_ref 176048 // ContactVector
      end

      classrelation 155312 // storedIntersectionMethod (<unidirectional association>)
	relation 155312 --->
	  stereotype "std::map"
	  a role_name "storedIntersectionMethod" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<Instance,${type}*> ${name}${value};
"
	    classrelation_ref 155312 // storedIntersectionMethod (<unidirectional association>)
	  b parent class_ref 175408 // Intersection
      end

      classrelation 155440 // storedContacts (<directional composition>)
	relation 155440 *-->
	  stereotype "std::map"
	  a role_name "storedContacts" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<Instance,${type}> ${name}${value};
"
	    classrelation_ref 155440 // storedContacts (<directional composition>)
	  b parent class_ref 176048 // ContactVector
      end

      operation 248752 "changeInstance"
	cpp_virtual cpp_inline protected explicit_return_type "void"
	nparams 1
	  param in name "inst" explicit_type "Instance"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		storedIntersectionMethod[instance] = intersectionMethod;
		intersectionMethod = storedIntersectionMethod[inst];
		storedContacts[instance].swap(contacts);
		contacts.swap(storedContacts[inst]);
	};
"
	
	
	
	
      end

      classrelation 185776 // <unidirectional association>
	relation 185776 --->
	  a role_name "" private
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 185776 // <unidirectional association>
	  b parent class_ref 175024 // DetectionOutputVector
      end

      classrelation 185904 // <directional composition>
	relation 185904 *-->
	  a role_name "" private
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 185904 // <directional composition>
	  b parent class_ref 174896 // Contact
      end
    end

    class 175664 "NarrowPhaseDetection"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "* 
* @brief Given a set of potentially colliding pairs of models, compute set of contact points"
      class 175792 "DetectionOutputMap"
	visibility package stereotype "typedef" base_type class_ref 175024 // DetectionOutputVector
	cpp_decl "${comment}typedef std::map<std::pair<core::CollisionModel*,core::CollisionModel*>,${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 157488 // <dependency>
	  relation 157488 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 157488 // <dependency>
	    b parent class_ref 175024 // DetectionOutputVector
	end
      end

      classrelation 157360 // <generalisation>
	relation 157360 ---|>
	  a public
	    cpp virtual default "${type}"
	    classrelation_ref 157360 // <generalisation>
	  b parent class_ref 174256 // Detection
      end

      operation 253872 "~NarrowPhaseDetection"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 254000 "beginNarrowPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        for (DetectionOutputMap::iterator it = outputsMap.begin(); it!=outputsMap.end(); it++)
        {
            if (it->second)
                it->second->clear();
        }
    };
"
	
	
	
	
	comment "/ Clear all the potentially colliding pairs detected in the previous simulation step"
      end

      operation 254128 "addCollisionPair"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param in name "cmPair" explicit_type "std::pair<core::CollisionModel*, core::CollisionModel*>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Add a new potentially colliding pairs of models"
      end

      operation 254256 "addCollisionPairs"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "v" explicit_type "sofa::helper::vector< std::pair<core::CollisionModel*, core::CollisionModel*> >"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        for (sofa::helper::vector< std::pair<core::CollisionModel*, core::CollisionModel*> >::const_iterator it = v.begin(); it!=v.end(); it++)
            addCollisionPair(*it);
    };
"
	
	
	
	
	comment "/ Add a new list of potentially colliding pairs of models"
      end

      operation 254384 "endNarrowPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        DetectionOutputMap::iterator it = outputsMap.begin();
        while(it!=outputsMap.end())
        {
            if (!it->second || it->second->empty())
            {
                DetectionOutputMap::iterator it2 = it;
                ++it2;
                delete it->second;
                outputsMap.erase(it);
                it = it2;
            }
            else
            {
                ++it;
            }
        }
    };
"
	
	
	
	
      end

      operation 254512 "getDetectionOutputs"
	cpp_inline public return_type class_ref 175792 // DetectionOutputMap
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return outputsMap;
    };
"
	
	
	
	
	comment "sofa::helper::vector<std::pair<core::CollisionElementIterator, core::CollisionElementIterator> >& getCollisionElementPairs() { return elemPairs; }"
      end

      classrelation 157616 // outputsMap (<directional composition>)
	relation 157616 *-->
	  a role_name "outputsMap" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 157616 // outputsMap (<directional composition>)
	  b parent class_ref 175792 // DetectionOutputMap
      end

      classrelation 157744 // storedOutputsMap (<directional composition>)
	relation 157744 *-->
	  stereotype "std::map"
	  a role_name "storedOutputsMap" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<Instance,${type}> ${name}${value};
"
	    classrelation_ref 157744 // storedOutputsMap (<directional composition>)
	  b parent class_ref 175792 // DetectionOutputMap
      end

      operation 254640 "changeInstanceNP"
	cpp_virtual cpp_inline protected explicit_return_type "void"
	nparams 1
	  param in name "inst" explicit_type "Instance"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		storedOutputsMap[instance].swap(outputsMap);
		outputsMap.swap(storedOutputsMap[inst]);
	};
"
	
	
	
	
      end

      classrelation 185520 // <unidirectional association>
	relation 185520 --->
	  a role_name "" private
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 185520 // <unidirectional association>
	  b parent class_ref 175408 // Intersection
      end

      classrelation 185648 // <unidirectional association>
	relation 185648 --->
	  a role_name "" private
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 185648 // <unidirectional association>
	  b parent class_ref 175024 // DetectionOutputVector
      end
    end

    class 176176 "DetectionOutput"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "
 *  \\brief Generic description of a contact point, used for most collision models except special cases such as GPU-based collisions.
 *
 *  Each contact point is described by :
 *
 *  \\item elem: pair of colliding elements.
 *  \\item id: unique id of the contact for the given pair of collision models.
 *  \\item point: contact points on the surface of each model.
 *  \\item normal: normal of the contact, pointing outward from the first model.
 *  \\item value: signed distance (negative if objects are interpenetrating).
 *  \\item deltaT: estimated of time of contact.
 *
 *  The contact id is used to filter redundant contacts (only the contact with
 *  the smallest distance is kept), and to store persistant data over time for
 *  the response.
 *"
      classrelation 156080 // elem (<directional composition>)
	relation 156080 *-->
	  stereotype "std::pair"
	  a role_name "elem" public
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type},core::CollisionElementIterator> ${name}${value};
"
	    classrelation_ref 156080 // elem (<directional composition>)
	  b parent class_ref 131888 // CollisionElementIterator
      end

      class 176304 "ContactId"
	visibility package stereotype "typedef" explicit_base_type "int64_t"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      classrelation 156208 // id (<directional composition>)
	relation 156208 *-->
	  a role_name "id" public
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 156208 // id (<directional composition>)
	  b parent class_ref 176304 // ContactId
      end

      attribute 147120 "point"
	public explicit_type "Vector3"
	multiplicity "[2]"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${multiplicity}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 147248 "freePoint"
	public explicit_type "Vector3"
	multiplicity "[2]"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${multiplicity}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
	comment "/< free Point in contact on each element"
      end

      attribute 147376 "baryCoords"
	public explicit_type "Vector3"
	multiplicity "[2]"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${multiplicity}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
	comment "/< provides the barycentric Coordinates (alpha, beta, gamma) of each contact points over the element"
      end

      attribute 147504 "normal"
	public explicit_type "Vector3"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 147632 "value"
	public explicit_type "double"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 147760 "deltaT"
	public explicit_type "double"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 250160 "DetectionOutput"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : elem( (sofa::core::CollisionModel* )NULL, 
	      (sofa::core::CollisionModel* ) NULL), id(0), value(0.0), deltaT(0.0)
    {
    };
"
	
	
	
	
      end
    end

    class 176432 "TDetectionOutputVector"
      visibility package 
      nformals 2
      formal name "CM1" type "class" explicit_default_value ""
        explicit_extends ""
      formal name "CM2" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Generic description of a set of contact point between two specific collision models"
      classrelation 156336 // <generalisation>
	relation 156336 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 156336 // <generalisation>
	  b parent class_ref 175024 // DetectionOutputVector
      end

      classrelation 156464 // <generalisation>
	relation 156464 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 156464 // <generalisation>
	  b parent class_ref 176560 // typedef11
      end

      class 176688 "Vector"
	visibility package stereotype "typedef" base_type class_ref 176176 // DetectionOutput
	cpp_decl "${comment}typedef sofa::helper::vector<${type}> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 156592 // <dependency>
	  relation 156592 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 156592 // <dependency>
	    b parent class_ref 176176 // DetectionOutput
	end
      end

      operation 250288 "~TDetectionOutputVector"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {};
"
	
	
	
	
      end

      operation 250416 "clear"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return this->Vector::clear();
    };
"
	
	
	
	
	comment "/ Clear the content of this vector"
      end

      operation 250544 "size"
	const cpp_virtual cpp_inline public explicit_return_type "uint"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return this->Vector::size();
    };
"
	
	
	
	
	comment "/ Current size (number of detected contacts)"
      end
    end

    class 176560 "typedef11"
      visibility package stereotype "typedef" explicit_base_type "sofa::helper::vector<DetectionOutput>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 176816 "ElementIntersector"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      operation 250672 "~ElementIntersector"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {};
"
	
	
	
	
      end

      operation 250800 "canIntersect"
	abstract cpp_virtual public explicit_return_type "bool"
	nparams 2
	  param in name "elem1" type class_ref 131888 // CollisionElementIterator
	  param in name "elem2" type class_ref 131888 // CollisionElementIterator
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Test if 2 elements can collide. Note that this can be conservative (i.e. return true even when no collision is present)"
      end

      operation 250928 "beginIntersect"
	abstract cpp_virtual public explicit_return_type "int"
	nparams 3
	  param inout name "model1" type class_ref 132016 // CollisionModel
	  param inout name "model2" type class_ref 132016 // CollisionModel
	  param inout name "contacts" type class_ref 175024 // DetectionOutputVector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} * & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Begin intersection tests between two collision models. Return the number of contacts written in the contacts vector.
/ If the given contacts vector is NULL, then this method should allocate it."
      end

      operation 251056 "intersect"
	abstract cpp_virtual public explicit_return_type "int"
	nparams 3
	  param in name "elem1" type class_ref 131888 // CollisionElementIterator
	  param in name "elem2" type class_ref 131888 // CollisionElementIterator
	  param inout name "contacts" type class_ref 175024 // DetectionOutputVector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Compute the intersection between 2 elements. Return the number of contacts written in the contacts vector."
      end

      operation 251184 "endIntersect"
	abstract cpp_virtual public explicit_return_type "int"
	nparams 3
	  param inout name "model1" type class_ref 132016 // CollisionModel
	  param inout name "model2" type class_ref 132016 // CollisionModel
	  param inout name "contacts" type class_ref 175024 // DetectionOutputVector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ End intersection tests between two collision models. Return the number of contacts written in the contacts vector."
      end

      operation 251312 "name"
	abstract const cpp_virtual public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end
    end

    class 176944 "IntersectorMap"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Table storing associations between types of collision models and intersectors implementing intersection tests
/
/ This class uses the new ClassInfo metaclass to be able to recognize derived classes. So it is no longer necessary
/ to register all derived collision models (i.e. an intersector registered for RayModel will also be used for RayPickIntersector)."
      class 177072 "InternalMap"
	visibility package stereotype "typedef" base_type class_ref 176816 // ElementIntersector
	cpp_decl "${comment}typedef std::map<std::pair<helper::TypeInfo,helper::TypeInfo>,${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 156720 // <dependency>
	  relation 156720 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 156720 // <dependency>
	    b parent class_ref 176816 // ElementIntersector
	end
      end

      class 177200 "MapKey"
	visibility package stereotype "typedef" explicit_base_type "InternalMap::key_type"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 177328 "MapValue"
	visibility package stereotype "typedef" explicit_base_type "InternalMap::value_type"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 251440 "add"
	stereotype "template"
	public explicit_return_type "void"
	nparams 1
	  param inout name "ptr" explicit_type "T"
	cpp_decl "    ${comment}template<class Model1template<class Model2template<class T>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 251568 "ignore"
	stereotype "template"
	public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}template<class Model1template<class Model2>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 251696 "~IntersectorMap"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 251824 "getType"
	preserve_cpp_body_indent public explicit_return_type "helper::TypeInfo"
	nparams 1
	  param inout name "model" type class_ref 132016 // CollisionModel
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 251952 "get"
	preserve_cpp_body_indent public return_type class_ref 176816 // ElementIntersector
	nparams 3
	  param inout name "model1" type class_ref 132016 // CollisionModel
	  param inout name "model2" type class_ref 132016 // CollisionModel
	  param inout name "swapModels" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${t0} * ${p0}, ${t1} * ${p1}, ${t2} & ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 252080 "add_impl"
	stereotype "template"
	protected explicit_return_type "void"
	nparams 1
	  param inout name "intersector" type class_ref 176816 // ElementIntersector
	cpp_decl "    ${comment}template<class Model1template<class Model2>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 252208 "add_impl"
	preserve_cpp_body_indent protected explicit_return_type "void"
	nparams 3
	  param in name "c1" type class_ref 177456 // ClassInfo
	  param in name "c2" type class_ref 177456 // ClassInfo
	  param inout name "intersector" type class_ref 176816 // ElementIntersector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, ${t2} * ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 252336 "insert"
	preserve_cpp_body_indent protected explicit_return_type "void"
	nparams 3
	  param in name "t1" explicit_type "helper::TypeInfo"
	  param in name "t2" explicit_type "helper::TypeInfo"
	  param inout name "intersector" type class_ref 176816 // ElementIntersector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, ${t2} * ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      classrelation 156848 // intersectorsMap (<directional composition>)
	relation 156848 *-->
	  a role_name "intersectorsMap" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 156848 // intersectorsMap (<directional composition>)
	  b parent class_ref 177072 // InternalMap
      end

      attribute 147888 "castMap"
	protected explicit_type " helper::TypeInfo, helper::TypeInfo "
	stereotype "std::map"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 156976 // classes (<unidirectional association>)
	relation 156976 --->
	  stereotype "std::set"
	  a role_name "classes" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<const ${type}*> ${name}${value};
"
	    classrelation_ref 156976 // classes (<unidirectional association>)
	  b parent class_ref 177456 // ClassInfo
      end
    end

    class 177584 "ParallelAddCollisionPair"
      visibility package stereotype "struct"
      nformals 1
      formal name "T" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      operation 254768 "operator ()"
	cpp_inline public explicit_return_type "void"
	nparams 6
	  param inout name "d" explicit_type "T"
	  param inout name "cm1" type class_ref 141744 // ParallelCollisionModel
	  param inout name "cm2" type class_ref 141744 // ParallelCollisionModel
	  param in name "cm1Ready" explicit_type "a1::Shared_r<bool>"
	  param in name "cm2Ready" explicit_type "a1::Shared_r<bool>"
	  param inout name "outptr" type class_ref 175024 // DetectionOutputVector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} * ${p2}${v2}, ${t3} ${p3}${v3}, ${t4} ${p4}${v4}, ${t5} * * ${p5}${v5}${)}${const}${volatile}${throw}${abstract} {
	cm1Ready.read();
	cm2Ready.read();
	std::pair<core::CollisionModel*, core::CollisionModel* > cmPair(cm1->getFirst(), cm2->getFirst());
	if (*outptr) (*outptr)->clear();
	d->addCollisionPair(cmPair, outptr);
    };
"
	
	
	
	
      end
    end

    class 177712 "ParallelNarrowPhaseDetection"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 157872 // <generalisation>
	relation 157872 ---|>
	  a public
	    cpp virtual default "${type}"
	    classrelation_ref 157872 // <generalisation>
	  b parent class_ref 175664 // NarrowPhaseDetection
      end

      class 177840 "DetectionOutputMap"
	visibility package stereotype "typedef" base_type class_ref 175024 // DetectionOutputVector
	cpp_decl "${comment}typedef std::map<std::pair<core::CollisionModel*,core::CollisionModel*>,${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 158000 // <dependency>
	  relation 158000 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 158000 // <dependency>
	    b parent class_ref 175024 // DetectionOutputVector
	end
      end

      class 177968 "PairSet"
	visibility package stereotype "typedef" explicit_base_type "std::set< std::pair<core::CollisionModel*, core::CollisionModel* > >"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 254896 "~ParallelNarrowPhaseDetection"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 255024 "getOutputPair"
	abstract cpp_virtual public explicit_return_type "bool"
	nparams 1
	  param inout name "cmPair" explicit_type "std::pair<core::CollisionModel*, core::CollisionModel*>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Compute the final output pair at which the result of the collision between the two given model
/ @return false if no collisions will be computed"
      end

      operation 255152 "addCollisionPair"
	abstract const cpp_virtual public explicit_return_type "void"
	nparams 2
	  param in name "cmPair" explicit_type "std::pair<core::CollisionModel*, core::CollisionModel*>"
	  param inout name "outptr" type class_ref 175024 // DetectionOutputVector
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} * * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Compute collisions between the given models, storing the pointer to the outputs in outptr
/ This method should not modify any internal class data, as it can be used in parallel"
      end

      operation 255280 "addCollisionPair"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "cmPair" explicit_type "std::pair<core::CollisionModel*, core::CollisionModel*>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
	std::pair<core::CollisionModel*, core::CollisionModel*> cmFinal(cmPair.first->getLast(), cmPair.second->getLast());
	if (!getOutputPair(cmFinal)) return;
	addCollisionPair(cmPair, &(outputsMap[cmFinal]));
    };
"
	
	
	
	
	comment "/ Compute collisions between the given models, storing the pointer to the outputs in outptr"
      end

      operation 255408 "parallelClearOutputs"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	parallelOutputs.clear();
	parallelOutputsTemp.clear();
    };
"
	
	
	
	
      end

      operation 255536 "parallelCreateOutputs"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 3
	  param inout name "cm1" type class_ref 141744 // ParallelCollisionModel
	  param inout name "cm2" type class_ref 141744 // ParallelCollisionModel
	  param in name "keepAlive" explicit_type "bool"
	    defaultvalue "true"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract} {
	std::pair<core::CollisionModel*, core::CollisionModel*> cmFinal(cm1->getLast(), cm2->getLast());
	if (!getOutputPair(cmFinal)) return;
	if (keepAlive)
	    parallelOutputs.insert(cmFinal);
	else
	    parallelOutputsTemp.insert(cmFinal);
    };
"
	
	
	
	
      end

      operation 255664 "parallelAddCollisionPair"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 4
	  param inout name "cm1" type class_ref 141744 // ParallelCollisionModel
	  param inout name "cm2" type class_ref 141744 // ParallelCollisionModel
	  param inout name "cm1Ready" explicit_type "a1::Shared<bool>"
	  param inout name "cm2Ready" explicit_type "a1::Shared<bool>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} & ${p2}${v2}, ${t3} & ${p3}${v3}${)}${const}${volatile}${throw}${abstract} {
	std::pair<core::CollisionModel*, core::CollisionModel*> cmFinal(cm1->getLast(), cm2->getLast());
	if (!getOutputPair(cmFinal)) return;
	parallelCreateOutputs(cm1, cm2);
	core::ParallelCollisionModel* maincm;
	if (!cm1->isSimulated()) maincm = cm2;
	else if (!cm2->isSimulated()) maincm = cm1;
	else if (cm1->getSize() >= cm2->getSize()) maincm = cm1;
	else maincm = cm2;
	maincm->Task< ParallelAddCollisionPair<ParallelNarrowPhaseDetection> >(this, cm1, cm2, cm1Ready, cm2Ready, &(outputsMap[cmFinal]));
    };
"
	
	
	
	
      end

      operation 255792 "beginNarrowPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        for (DetectionOutputMap::iterator it = outputsMap.begin(); it!=outputsMap.end(); it++)
        {
            if (it->second && !parallelOutputs.count(it->first) && !parallelOutputsTemp.count(it->first))
                it->second->clear();
        }
    };
"
	
	
	
	
	comment "/ Clear all the potentially colliding pairs detected in the previous simulation step"
      end

      operation 255920 "addCollisionPairs"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "v" explicit_type "sofa::helper::vector< std::pair<core::CollisionModel*, core::CollisionModel*> >"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        for (sofa::helper::vector< std::pair<core::CollisionModel*, core::CollisionModel*> >::const_iterator it = v.begin(); it!=v.end(); it++)
	{
	    std::pair<core::CollisionModel*, core::CollisionModel*> cmFinal(it->first->getLast(), it->second->getLast());
	    if (!getOutputPair(cmFinal)) continue;
	    if (!parallelOutputs.count(cmFinal) && !parallelOutputsTemp.count(cmFinal))
		addCollisionPair(*it, &(outputsMap[cmFinal]));
	}
    };
"
	
	
	
	
	comment "/ Add a new list of potentially colliding pairs of models"
      end

      operation 256048 "endNarrowPhase"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	parallelOutputsTemp.clear(); // temporary parallel tasks are recreated at each step
        DetectionOutputMap::iterator it = outputsMap.begin();
        while(it!=outputsMap.end())
        {
            if ((!it->second || it->second->empty()) && !parallelOutputs.count(it->first))
            {
                DetectionOutputMap::iterator it2 = it;
                ++it2;
                delete it->second;
                outputsMap.erase(it);
                it = it2;
            }
            else
            {
                ++it;
            }
        }
    };
"
	
	
	
	
      end

      classrelation 158128 // parallelOutputs (<directional composition>)
	relation 158128 *-->
	  a role_name "parallelOutputs" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 158128 // parallelOutputs (<directional composition>)
	  b parent class_ref 177968 // PairSet
      end

      classrelation 158256 // parallelOutputsTemp (<directional composition>)
	relation 158256 *-->
	  a role_name "parallelOutputsTemp" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 158256 // parallelOutputsTemp (<directional composition>)
	  b parent class_ref 177968 // PairSet
      end

      classrelation 158384 // storedParallelOutputs (<directional composition>)
	relation 158384 *-->
	  stereotype "std::map"
	  a role_name "storedParallelOutputs" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<Instance,${type}> ${name}${value};
"
	    classrelation_ref 158384 // storedParallelOutputs (<directional composition>)
	  b parent class_ref 177968 // PairSet
      end

      classrelation 158512 // storedParallelOutputsTemp (<directional composition>)
	relation 158512 *-->
	  stereotype "std::map"
	  a role_name "storedParallelOutputsTemp" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<Instance,${type}> ${name}${value};
"
	    classrelation_ref 158512 // storedParallelOutputsTemp (<directional composition>)
	  b parent class_ref 177968 // PairSet
      end

      operation 256176 "changeInstanceNP"
	cpp_virtual cpp_inline protected explicit_return_type "void"
	nparams 1
	  param in name "inst" explicit_type "Instance"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
	storedOutputsMap[instance].swap(outputsMap);
	outputsMap.swap(storedOutputsMap[inst]);
	storedParallelOutputs[instance].swap(parallelOutputs);
	parallelOutputs.swap(storedParallelOutputs[inst]);
	storedParallelOutputsTemp[instance].swap(parallelOutputsTemp);
	parallelOutputsTemp.swap(storedParallelOutputsTemp[inst]);
    };
"
	
	
	
	
      end
    end

    class 178096 "ParallelPipeline"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 158640 // <generalisation>
	relation 158640 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 158640 // <generalisation>
	  b parent class_ref 174512 // typedef9
      end

      classrelation 158768 // <generalisation>
	relation 158768 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 158768 // <generalisation>
	  b parent class_ref 178224 // Pipeline
      end

      operation 256304 "ParallelPipeline"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 256432 "~ParallelPipeline"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 256560 "parallelComputeCollisions"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end
    end

    class 178224 "Pipeline"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "* 
 * @brief Pipeline component gather list of collision models and control the sequence of computations"
      classrelation 158896 // <generalisation>
	relation 158896 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 158896 // <generalisation>
	  b parent class_ref 174512 // typedef9
      end

      classrelation 159024 // <generalisation>
	relation 159024 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 159024 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      classrelation 159152 // <unidirectional association>
	relation 159152 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}*> ${name}${value};
"
	    classrelation_ref 159152 // <unidirectional association>
	  b parent class_ref 175408 // Intersection
      end

      classrelation 159280 // <unidirectional association>
	relation 159280 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}*> ${name}${value};
"
	    classrelation_ref 159280 // <unidirectional association>
	  b parent class_ref 174128 // BroadPhaseDetection
      end

      classrelation 159408 // <unidirectional association>
	relation 159408 --->
	  stereotype "sofa::helper::vector"
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}*> ${name}${value};
"
	    classrelation_ref 159408 // <unidirectional association>
	  b parent class_ref 175664 // NarrowPhaseDetection
      end

      classrelation 159536 // <unidirectional association>
	relation 159536 --->
	  stereotype "sofa::helper::vector"
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}*> ${name}${value};
"
	    classrelation_ref 159536 // <unidirectional association>
	  b parent class_ref 175536 // ContactManager
      end

      classrelation 159664 // <unidirectional association>
	relation 159664 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}*> ${name}${value};
"
	    classrelation_ref 159664 // <unidirectional association>
	  b parent class_ref 174768 // CollisionGroupManager
      end

      classrelation 159792 // <unidirectional association>
	relation 159792 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 159792 // <unidirectional association>
	  b parent class_ref 175408 // Intersection
      end

      classrelation 159920 // <unidirectional association>
	relation 159920 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 159920 // <unidirectional association>
	  b parent class_ref 174128 // BroadPhaseDetection
      end

      classrelation 160048 // <unidirectional association>
	relation 160048 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 160048 // <unidirectional association>
	  b parent class_ref 175664 // NarrowPhaseDetection
      end

      classrelation 160176 // <unidirectional association>
	relation 160176 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 160176 // <unidirectional association>
	  b parent class_ref 175536 // ContactManager
      end

      classrelation 160304 // <unidirectional association>
	relation 160304 --->
	  a role_name "" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 160304 // <unidirectional association>
	  b parent class_ref 174768 // CollisionGroupManager
      end

      class 178352 "DetectionOutputMap"
	visibility package stereotype "typedef" base_type class_ref 175792 // DetectionOutputMap
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 160432 // <dependency>
	  relation 160432 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 160432 // <dependency>
	    b parent class_ref 175792 // DetectionOutputMap
	end
      end

      operation 256688 "Pipeline"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw};
"
	cpp_def "//#include <sofa/component/collision/DiscreteIntersection.h>
//#include <sofa/simulation/tree/GNode.h>
//using namespace core::objectmodel;
//using namespace core::behavior;

${inline}${class}::${name}${(}${)}
: intersectionMethod(NULL),
  broadPhaseDetection(NULL),
  narrowPhaseDetection(NULL),
  contactManager(NULL),
  groupManager(NULL)
${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 256816 "~Pipeline"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 256944 "reset"
	abstract preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 257072 "computeCollisionReset"
	abstract preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Remove collision response from last step"
      end

      operation 257200 "computeCollisionDetection"
	abstract preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Detect new collisions. Note that this step must not modify the simulation graph"
      end

      operation 257328 "computeCollisionResponse"
	abstract preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Add collision response in the simulation graph"
      end

      operation 257456 "computeCollisions"
	cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		computeCollisionReset();
		computeCollisionDetection();
		computeCollisionResponse();
	};
"
	
	
	
	
      end

      operation 257584 "getBroadPhaseDetection"
	preserve_cpp_body_indent const public return_type class_ref 174128 // BroadPhaseDetection
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}const ${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "sofa::helper::vector<DetectionOutput*>& getDetectionOutputs() { return detectionOutputs; }
/ Broad phase collision detection method accessor."
      end

      operation 257712 "getNarrowPhaseDetection"
	preserve_cpp_body_indent const public return_type class_ref 175664 // NarrowPhaseDetection
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}const ${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Narrow phase collision detection method accessor."
      end

      operation 257840 "getResponseList"
	abstract const cpp_virtual public explicit_return_type "helper::set< std::string >"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ get the set of response available with the current collision pipeline"
      end

      operation 257968 "doCollisionReset"
	abstract cpp_virtual protected explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Remove collision response from last step"
      end

      operation 258096 "doCollisionDetection"
	abstract cpp_virtual protected explicit_return_type "void"
	nparams 1
	  param in name "collisionModels" explicit_type "sofa::helper::vector<core::CollisionModel*>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Detect new collisions. Note that this step must not modify the simulation graph"
      end

      operation 258224 "doCollisionResponse"
	abstract cpp_virtual protected explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Add collision response in the simulation graph"
      end
    end
  end

  deploymentview 128304 "collision"
    //deployment diagram settings
    package_name_in_tab default show_context default write_horizontally default auto_label_position default draw_all_relations default shadow default
    draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
    artifact 135088 "BroadPhaseDetection"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 174128 // BroadPhaseDetection
      end
    end

    artifact 135216 "CollisionAlgorithm"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 174512 // typedef9
	class_ref 174384 // CollisionAlgorithm
      end
    end

    artifact 135344 "CollisionGroupManager"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 174768 // CollisionGroupManager
      end
    end

    artifact 135472 "Contact"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 174896 // Contact
      end
    end

    artifact 135600 "ContactManager"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 175536 // ContactManager
      end
    end

    artifact 135728 "Detection"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 174256 // Detection
      end
    end

    artifact 135856 "DetectionOutput"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 175024 // DetectionOutputVector
	class_ref 176176 // DetectionOutput
	class_ref 176560 // typedef11
	class_ref 176432 // TDetectionOutputVector
      end
    end

    artifact 135984 "Intersection"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 176816 // ElementIntersector
	class_ref 176944 // IntersectorMap
	class_ref 175408 // Intersection
      end
    end

    artifact 136112 "NarrowPhaseDetection"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 175664 // NarrowPhaseDetection
      end
    end

    artifact 136240 "ParallelNarrowPhaseDetection"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 177584 // ParallelAddCollisionPair
	class_ref 177712 // ParallelNarrowPhaseDetection
      end
    end

    artifact 136368 "ParallelPipeline"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 178096 // ParallelPipeline
      end
    end

    artifact 136496 "Pipeline"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 178224 // Pipeline
      end
    end
  end
end
