Program Listing for File Node.h

↰ Return to documentation for file (include/Karana/SOADyn/Node.h)

/*
*Copyright(c)2024-2026KaranaDynamicsPtyLtd.Allrightsreserved.
*
*NOTICETOUSER:
*
*Thissourcecodeand/ordocumentation(the"LicensedMaterials")is
*theconfidentialandproprietaryinformationofKaranaDynamicsInc.
*UseoftheseLicensedMaterialsisgovernedbythetermsandconditions
*ofaseparatesoftwarelicenseagreementbetweenKaranaDynamicsandthe
*Licensee("LicenseAgreement").Unlessexpresslypermittedunderthat
*agreement,anyreproduction,modification,distribution,ordisclosure
*oftheLicensedMaterials,inwholeorinpart,toanythirdparty
*withoutthepriorwrittenconsentofKaranaDynamicsisstrictlyprohibited.
*
*THELICENSEDMATERIALSAREPROVIDED"ASIS"WITHOUTWARRANTYOFANYKIND.
*KARANADYNAMICSDISCLAIMSALLWARRANTIES,EXPRESSORIMPLIED,INCLUDING
*BUTNOTLIMITEDTOWARRANTIESOFMERCHANTABILITY,NON-INFRINGEMENT,AND
*FITNESSFORAPARTICULARPURPOSE.
*
*INNOEVENTSHALLKARANADYNAMICSBELIABLEFORANYDAMAGESWHATSOEVER,
*INCLUDINGBUTNOTLIMITEDTOLOSSOFPROFITS,DATA,ORUSE,EVENIF
*ADVISEDOFTHEPOSSIBILITYOFSUCHDAMAGES,WHETHERINCONTRACT,TORT,
*OROTHERWISEARISINGOUTOFORINCONNECTIONWITHTHELICENSEDMATERIALS.
*
*U.S.GovernmentEndUsers:TheLicensedMaterialsarea"commercialitem"
*asdefinedat48C.F.R.2.101,andareprovidedtotheU.S.Government
*onlyasacommercialenditemunderthetermsofthislicense.
*
*AnyuseoftheLicensedMaterialsinindividualorcommercialsoftwaremust
*include,intheuserdocumentationandinternalsourcecodecomments,
*thisNotice,Disclaimer,andU.S.GovernmentUseProvision.
*/


#pragmaonce

#include"Karana/Frame/Frame.h"
#include"Karana/KCore/DataCache.h"
#include"Karana/Math/HomTran.h"
#include"Karana/ProxyScene/ProxyScene.h"

namespaceKarana::Dynamics{

namespacekc=Karana::Core;
namespacekf=Karana::Frame;
namespacekm=Karana::Math;
namespaceks=Karana::Scene;

classPhysicalBody;
classPinSubhinge;
classSubhingeBase;
classNode;
classMultibody;
classLoopConstraintBase;

structStickPartsConfig;

classNodeDeformationProvider:publickc::Base{

//foraccessto_getParams,_setParams
friendclassPhysicalBody;

public:
NodeDeformationProvider(std::string_viewname,kc::ks_ptr<Node>node)
:Base(name)
,_nd(node){}

~NodeDeformationProvider(){_nd.reset();}

protected:
structDeformationParams{
km::HomTran
body_to_node_transform;

DeformationParams()=default;

DeformationParams&operator=(constDeformationParams*p){
if(this!=p){
body_to_node_transform=p->body_to_node_transform;
}

return*this;
}
};

protected:
virtualkc::ks_ptr<DeformationParams>_getParams()const=0;

virtualvoid_setParams(constDeformationParams&params)=0;

protected:
kc::ks_ptr<Node>_nd=nullptr;
};

classNode:publickf::Frame{

//foraccessto_parent_body
friendclassPhysicalBody;

//foraccessto_deformation_provider
friendclassPhysicalModalBody;

//foraccessto_newtonian2node_f2f
friendclassCompoundSubhinge;
friendclassMultibody;
friendclassSubGraph;
friendclassPhysicalSubhinge;

//foraccesstoexternal_force_cache
friendclassHingePnode;

public:
statickc::ks_ptr<Node>
lookupOrCreate(std::string_viewname,kc::ks_ptr<PhysicalBody>bd,boolforce_node=false);

statickc::ks_ptr<Node>lookupOrCreateContact(constkc::ks_ptr<PhysicalBody>&bd,
constkm::HomTran&T,
std::string_viewname="");

virtualvoiddetach();

Node(std::string_viewname,constkc::ks_ptr<PhysicalBody>&bd);

virtual~Node();


constkc::ks_ptr<PhysicalBody>&parentBody()const{return_parent_body;}

boolisReady()constoverride;

voidsetBodyToNodeTransform(constkm::HomTran&t);

km::HomTrangetBodyToNodeTransform()const;

boolisExternalForceNode()const;

km::SpatialVectornodeObservedSpatialAccel()const;

constkm::SpatialVector&getSpForce()const{return_external_force_cache->get();}

virtualvoidsetExternalSpForce(constkm::SpatialVector&spforce,
constkc::ks_ptr<kf::Frame>&ref_frame=nullptr);

virtualvoidaccumExternalSpForce(constkm::SpatialVector&spforce,
constkc::ks_ptr<kf::Frame>&ref_frame=nullptr);

constkc::ks_ptr<NodeDeformationProvider>&deformationProvider()const{
return_deformation_provider;
}

std::stringdumpString(std::string_viewprefix,
constKarana::Core::Base::DumpOptions*options)constoverride;

kc::ks_ptr<kf::OrientedChainedFrameToFrame>newtonianToNodeFrameToFrame()const;

protected:
void_clearExternals();

void_discard(kc::ks_ptr<kc::Base>&base)override;

void_createStickParts(kc::ks_ptr<ks::ProxyScene>&scene,
constStickPartsConfig&c,
booladd_sphere);

protected:
kc::ks_ptr<PhysicalBody>_parent_body=nullptr;

km::SpatialVector_node_frame_spforce;

kc::ks_ptr<kc::DataCache<km::SpatialVector>>_external_force_cache=nullptr;

kc::ks_ptr<kf::OrientedChainedFrameToFrame>_newtonian2node_f2f=nullptr;

kc::ks_ptr<kf::OrientedChainedFrameToFrame>_pnode2node_f2f=nullptr;

kc::ks_ptr<NodeDeformationProvider>_deformation_provider=nullptr;

kc::ks_ptr<Multibody>_multibody=nullptr;
};

classConstraintNode:publicNode{

//foraccesstosetExternalSpForce
friendclassLoopConstraintBase;
friendclassCECompoundBody;

//foraccesstosetExternalSpForceT
friendclassLoopConstraintCutJoint;
friendclassLoopConstraintConVel;
friendclassAlgorithms;

public:
statickc::ks_ptr<ConstraintNode>lookupOrCreate(std::string_viewname,
kc::ks_ptr<PhysicalBody>bd);

ConstraintNode(std::string_viewname,kc::ks_ptr<PhysicalBody>bd)
:Node(name,bd){};

kc::ks_ptr<LoopConstraintBase>loopConstraint()const;

protected:
voiddetach()override;

voidsetExternalSpForce(constkm::SpatialVector&spforce,
constkc::ks_ptr<kf::Frame>&ref_frame=nullptr)override;

void_discard(kc::ks_ptr<kc::Base>&base)override;

protected:
kc::ks_ptr<LoopConstraintBase>_loop_constraint=nullptr;
};

}//namespaceKarana::Dynamics