BVB Source Codes

CRYENGINE Show PipeUserMovementActorAdapter.cpp Source code

Return Download CRYENGINE: download PipeUserMovementActorAdapter.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "PipeUserMovementActorAdapter.h"
  5. #include "PipeUser.h"
  6. #include "Cover/CoverSystem.h"
  7.  
  8. void PipeUserMovementActorAdapter::OnMovementPlanProduced()
  9. {
  10.         m_attachedPipeUser.SetSignal(AISIGNAL_DEFAULT, "MovementPlanProduced");
  11. }
  12.  
  13. void PipeUserMovementActorAdapter::SetInCover(const bool inCover)
  14. {
  15.         m_attachedPipeUser.SetInCover(inCover);
  16. }
  17.  
  18. bool PipeUserMovementActorAdapter::GetDesignedPath(SShape& pathShape) const
  19. {
  20.         return gAIEnv.pNavigation->GetDesignerPath(m_attachedPipeUser.GetPathToFollow(), pathShape);
  21. }
  22.  
  23. NavigationAgentTypeID PipeUserMovementActorAdapter::GetNavigationAgentTypeID() const
  24. {
  25.         return m_attachedPipeUser.GetNavigationTypeID();
  26. }
  27.  
  28. Vec3 PipeUserMovementActorAdapter::GetPhysicsPosition() const
  29. {
  30.         return m_attachedPipeUser.GetPhysicsPos();
  31. }
  32.  
  33. void PipeUserMovementActorAdapter::SetActorPath(const MovementStyle& style, const INavPath& navPath)
  34. {
  35.         m_attachedPipeUser.m_Path.SetPathPoints(navPath.GetPath());
  36. }
  37.  
  38. MovementStyle::Speed GetPipeUserAdjustedSpeedForPathLength(const MovementStyle& style, const float pathLength)
  39. {
  40.         MovementStyle::Speed requestedSpeed = style.GetSpeed();
  41.  
  42.         static float minDistForSprint = 5.0f;
  43.         static float minDistForRun = 2.5f;
  44.  
  45.         if ((requestedSpeed == MovementStyle::Sprint) && (pathLength < minDistForSprint))
  46.                 requestedSpeed = MovementStyle::Run;
  47.  
  48.         if ((requestedSpeed == MovementStyle::Run) && (pathLength < minDistForRun))
  49.                 requestedSpeed = MovementStyle::Walk;
  50.  
  51.         return requestedSpeed;
  52. }
  53.  
  54. void SetPipeUserSpeedValueFromMovementSpeed(MovementStyle::Speed speedLiteral, CPipeUser& pipeUser)
  55. {
  56.         switch (speedLiteral)
  57.         {
  58.         case MovementStyle::Walk:
  59.                 pipeUser.SetSpeed(AISPEED_WALK);
  60.                 break;
  61.  
  62.         case MovementStyle::Run:
  63.                 pipeUser.SetSpeed(AISPEED_RUN);
  64.                 break;
  65.  
  66.         case MovementStyle::Sprint:
  67.                 pipeUser.SetSpeed(AISPEED_SPRINT);
  68.                 break;
  69.  
  70.         default:
  71.                 assert(false);
  72.                 break;
  73.         }
  74. }
  75.  
  76. void PipeUserMovementActorAdapter::SetActorStyle(const MovementStyle& style, const INavPath& navPath)
  77. {
  78.         const bool isMoving = m_attachedPipeUser.GetBodyInfo().isMoving;
  79.  
  80.         const bool continueMovingAtPathEnd = navPath.GetParams().continueMovingAtEnd;
  81.  
  82.         const bool adjustSpeedForPathLength = !isMoving && !continueMovingAtPathEnd;
  83.         if (adjustSpeedForPathLength)
  84.         {
  85.                 const MovementStyle::Speed adjustedSpeed = GetPipeUserAdjustedSpeedForPathLength(style, navPath.GetPathLength(false));
  86.                 SetPipeUserSpeedValueFromMovementSpeed(adjustedSpeed, m_attachedPipeUser);
  87.         }
  88.         else
  89.         {
  90.                 if (style.HasSpeedLiteral())
  91.                 {
  92.                         m_attachedPipeUser.SetSpeed(style.GetSpeedLiteral());
  93.                 }
  94.                 else
  95.                 {
  96.                         SetPipeUserSpeedValueFromMovementSpeed(style.GetSpeed(), m_attachedPipeUser);
  97.                 }
  98.         }
  99.  
  100.         SetStance(style.GetStance());
  101.  
  102.         if (style.ShouldStrafe())
  103.                 m_attachedPipeUser.SetAllowedStrafeDistances(999.0f, 999.0f, true);
  104.         else
  105.                 m_attachedPipeUser.SetAllowedStrafeDistances(0.0f, 0.0f, false);
  106.  
  107.         m_attachedPipeUser.GetState().bodyOrientationMode = style.GetBodyOrientationMode();
  108. }
  109.  
  110. std::shared_ptr<Vec3> PipeUserMovementActorAdapter::CreateLookTarget()
  111. {
  112.         return m_attachedPipeUser.CreateLookTarget();
  113. }
  114.  
  115. void PipeUserMovementActorAdapter::ResetMovementContext()
  116. {
  117.         m_attachedPipeUser.ResetMovementContext();
  118. }
  119.  
  120. void PipeUserMovementActorAdapter::UpdateCoverLocations()
  121. {
  122.         CoverID coverID = m_attachedPipeUser.GetCoverID();
  123.         IF_UNLIKELY (coverID == 0)
  124.                 return;
  125.  
  126.         float radius = m_attachedPipeUser.GetParameters().distanceToCover;
  127.         Vec3 coverNormal(ZERO);
  128.         Vec3 coverPosition = gAIEnv.pCoverSystem->GetCoverLocation(coverID, radius, 0, &coverNormal);
  129.  
  130.         SOBJECTSTATE& state = m_attachedPipeUser.GetState();
  131.         SAICoverRequest& coverRequest = state.coverRequest;
  132.  
  133.         coverRequest.SetCoverLocation(coverPosition, -coverNormal);
  134.  
  135.         const Vec3 agentPosition = m_attachedPipeUser.GetPhysicsPos();
  136.  
  137.         if (m_attachedPipeUser.IsMovingInCover())
  138.         {
  139.                 m_attachedPipeUser.SetDesiredBodyDirectionAtTarget(-coverNormal);
  140.  
  141.                 // Turn body to the direction we're moving
  142.                 const Vec3 directionAgentIsMovingIn = (coverPosition - agentPosition).GetNormalized();
  143.                 coverRequest.SetCoverBodyDirection(coverNormal, directionAgentIsMovingIn);
  144.         }
  145.         else
  146.         {
  147.                 // Give hints to the animation system for sliding into cover
  148.                 m_attachedPipeUser.SetDesiredBodyDirectionAtTarget(-coverNormal); // TODO: Change this to something like DesiredCoverLocation when old cover alignment method is not used anymore
  149.  
  150.                 // Update the desired cover body direction while we're further
  151.                 // away from the cover than a certain threshold.
  152.                 // The threshold is there to prevent us from setting the cover
  153.                 // body direction while being very close, because we could
  154.                 // by accident overshoot slightly and set the wrong direction.
  155.  
  156.                 if (agentPosition.GetSquaredDistance(coverPosition) > square(1.0f) ||
  157.                     coverRequest.coverBodyDirection == eCoverBodyDirection_Unspecified)
  158.                 {
  159.                         // Turn the body towards the direction we're coming from.
  160.                         // This is because we know that the direction we're coming from
  161.                         // was traversable and therefor makes somewhat sense to look
  162.                         // towards. If we look in the direction we're running towards,
  163.                         // or in the direction of our target we might end up with
  164.                         // characters looking straight into the wall.
  165.  
  166.                         const Vec3 directionAgentIsComingFrom = (agentPosition - coverPosition).GetNormalized();
  167.                         coverRequest.SetCoverBodyDirection(coverNormal, directionAgentIsComingFrom);
  168.                 }
  169.  
  170.                 enum
  171.                 {
  172.                         MovingIntoLowCover = 1,
  173.                 };
  174.  
  175.                 m_attachedPipeUser.SetMovementContext(MovingIntoLowCover);
  176.         }
  177. }
  178.  
  179. void PipeUserMovementActorAdapter::SetLookTimeOffset(float lookTimeOffset)
  180. {
  181.         m_lookTimeOffset = lookTimeOffset;
  182. }
  183.  
  184. void PipeUserMovementActorAdapter::UpdateLooking(float updateTime, std::shared_ptr<Vec3> lookTarget, const bool targetReachable, const float pathDistanceToEnd, const Vec3& followTargetPosition, const MovementStyle& style)
  185. {
  186.         if (lookTarget.get() && style.ShouldGlanceInMovementDirection())
  187.         {
  188.                 // Once every X seconds the agent will look in the direction of
  189.                 // the follow target. This conveys the fact that the agent
  190.                 // is planning to see where he's going and not just blindly
  191.                 // walking backwards somewhere.
  192.                 // The agent will only glance in the XY-plane.
  193.  
  194.                 static float lookDuration = 0.7f;
  195.                 static float timeBetweenLooks = 4.0f;
  196.                 static float blendFactor = 0.5f;            // 1.0 = look straight at follow target, 0.0 = look straight at aim target
  197.                 static float distanceToEndThreshold = 3.0f; // If we're closer to the end than this we won't glance
  198.  
  199.                 m_lookTimeOffset += updateTime;
  200.                 if (m_lookTimeOffset > timeBetweenLooks)
  201.                         m_lookTimeOffset = 0.0f;
  202.  
  203.                 const bool lookAtFollowTarget = m_lookTimeOffset >= 0.0f && m_lookTimeOffset<lookDuration&& targetReachable&& pathDistanceToEnd> distanceToEndThreshold;
  204.                 if (lookAtFollowTarget)
  205.                 {
  206.                         const Vec3 eyePosition = m_attachedPipeUser.GetPos();
  207.                         const Vec3 aimTargetPosition = m_attachedPipeUser.GetState().vAimTargetPos;
  208.  
  209.                         const Vec3 eyeToFollowTargetDirection = (followTargetPosition - eyePosition).GetNormalized();
  210.                         const Vec3 eyeToAimTargetDirection = (aimTargetPosition - eyePosition).GetNormalized();
  211.  
  212.                         Vec3 blendedAndSummedLookDirection = eyeToFollowTargetDirection * blendFactor + eyeToAimTargetDirection * (1.0f - blendFactor);
  213.                         blendedAndSummedLookDirection.z = 0.0f;
  214.                         const Vec3 finalLookDirection = blendedAndSummedLookDirection.GetNormalizedSafe(eyeToAimTargetDirection);
  215.                         *lookTarget = eyePosition + finalLookDirection * 30.0f;
  216.                 }
  217.                 else
  218.                 {
  219.                         // Setting the look target to zero means we're not providing
  220.                         // a look target at this moment, so another look target in the
  221.                         // look target stack may be used until we start providing again.
  222.                         *lookTarget = Vec3(ZERO);
  223.                 }
  224.         }
  225. }
  226.  
  227. Vec3 PipeUserMovementActorAdapter::GetVelocity() const
  228. {
  229.         return m_attachedPipeUser.GetVelocity();
  230. }
  231.  
  232. Vec3 PipeUserMovementActorAdapter::GetMoveDirection() const
  233. {
  234.         return m_attachedPipeUser.GetState().vMoveDir;
  235. }
  236.  
  237. void PipeUserMovementActorAdapter::ConfigurePathfollower(const MovementStyle& style)
  238. {
  239.         SOBJECTSTATE& pipeUserState = m_attachedPipeUser.GetState();
  240.         float normalSpeed = 1.0f;
  241.         float minSpeed = 1.0f;
  242.         float maxSpeed = 1.0f;
  243.  
  244.         m_attachedPipeUser.GetMovementSpeedRange(
  245.           pipeUserState.fMovementUrgency,
  246.           pipeUserState.allowStrafing,
  247.           normalSpeed, minSpeed, maxSpeed);
  248.  
  249.         INavPath* navPath = m_attachedPipeUser.GetINavPath();
  250.         const bool continueMovingAtEnd = navPath ? navPath->GetParams().continueMovingAtEnd : false;
  251.  
  252.         PathFollowerParams& pathFollowerParams = m_attachedPipeUser.GetPathFollower()->GetParams();
  253.         pathFollowerParams.minSpeed = minSpeed;
  254.         pathFollowerParams.maxSpeed = maxSpeed;
  255.         pathFollowerParams.normalSpeed = clamp_tpl(normalSpeed, minSpeed, maxSpeed);
  256.         pathFollowerParams.endDistance = 0.0f;
  257.         pathFollowerParams.maxAccel = m_attachedPipeUser.m_movementAbility.maxAccel;
  258.         pathFollowerParams.maxDecel = m_attachedPipeUser.m_movementAbility.maxDecel;
  259.         pathFollowerParams.stopAtEnd = !continueMovingAtEnd;
  260.         pathFollowerParams.isAllowedToShortcut = !style.IsMovingAlongDesignedPath();
  261. }
  262.  
  263. void PipeUserMovementActorAdapter::SetMovementOutputValue(const PathFollowResult& result)
  264. {
  265.         Vec3 desiredMoveDir = result.velocityOut;
  266.         const float desiredSpeed = desiredMoveDir.NormalizeSafe();
  267.         Vec3 physicalPosition = m_attachedPipeUser.GetPhysicsPos();
  268.  
  269.         SOBJECTSTATE& pipeUserState = m_attachedPipeUser.GetState();
  270.         IPathFollower* pPathFollower = m_attachedPipeUser.GetPathFollower();
  271.  
  272.         pipeUserState.fDesiredSpeed = desiredSpeed;
  273.         pipeUserState.fTargetSpeed = desiredSpeed;
  274.         pipeUserState.fDistanceToPathEnd = pPathFollower ? pPathFollower->GetDistToEnd(&physicalPosition) : .0f;
  275.         pipeUserState.vMoveDir = desiredMoveDir;
  276.         pipeUserState.vMoveTarget = result.followTargetPos;
  277.         pipeUserState.vInflectionPoint = result.inflectionPoint;
  278. }
  279.  
  280. void PipeUserMovementActorAdapter::ClearMovementState()
  281. {
  282.         SOBJECTSTATE& pipeUserState = m_attachedPipeUser.GetState();
  283.         pipeUserState.fDesiredSpeed = 0.0f;
  284.         pipeUserState.vMoveTarget.zero();
  285.         pipeUserState.vMoveDir.zero();
  286.         pipeUserState.vInflectionPoint.zero();
  287. }
  288.  
  289. void PipeUserMovementActorAdapter::SetStance(const MovementStyle::Stance stance)
  290. {
  291.         switch (stance)
  292.         {
  293.         case MovementStyle::Relaxed:
  294.                 m_attachedPipeUser.GetState().bodystate = STANCE_RELAXED;
  295.                 break;
  296.  
  297.         case MovementStyle::Alerted:
  298.                 m_attachedPipeUser.GetState().bodystate = STANCE_ALERTED;
  299.                 break;
  300.  
  301.         case MovementStyle::Stand:
  302.                 m_attachedPipeUser.GetState().bodystate = STANCE_STAND;
  303.                 break;
  304.  
  305.         case MovementStyle::Crouch:
  306.                 m_attachedPipeUser.GetState().bodystate = STANCE_CROUCH;
  307.                 break;
  308.  
  309.         default:
  310.                 assert(false);
  311.                 break;
  312.         }
  313. }
  314.  
  315. bool PipeUserMovementActorAdapter::IsMoving() const
  316. {
  317.         const SAIBodyInfo& bodyInfo = m_attachedPipeUser.QueryBodyInfo();
  318.         return bodyInfo.isMoving;
  319. }
  320.  
  321. void PipeUserMovementActorAdapter::InstallInLowCover(const bool inCover)
  322. {
  323.         if (m_attachedPipeUser.GetCoverID() != 0)
  324.         {
  325.                 m_attachedPipeUser.SetInCover(inCover);
  326.                 m_attachedPipeUser.GetState().bodystate = STANCE_LOW_COVER;
  327.                 m_attachedPipeUser.SetMovingToCover(false);
  328.         }
  329. }
  330.  
  331. void PipeUserMovementActorAdapter::SetupCoverInformation()
  332. {
  333.         if (CoverID nextCoverID = m_attachedPipeUser.GetCoverRegister())
  334.         {
  335.                 // The cover we are in or moving towards
  336.                 CoverID currCoverID = m_attachedPipeUser.GetCoverID();
  337.  
  338.                 if (currCoverID && m_attachedPipeUser.IsInCover())
  339.                 {
  340.                         CCoverSystem& coverSystem = *gAIEnv.pCoverSystem;
  341.  
  342.                         bool movingInCover = false;
  343.  
  344.                         if (coverSystem.GetSurfaceID(currCoverID) == coverSystem.GetSurfaceID(nextCoverID))
  345.                         {
  346.                                 movingInCover = true;
  347.                         }
  348.                         else
  349.                         {
  350.                                 // Check if surfaces are neighbors (edges are close to each other)
  351.                                 const CoverSurface& currSurface = coverSystem.GetCoverSurface(currCoverID);
  352.                                 const CoverSurface& nextSurface = coverSystem.GetCoverSurface(nextCoverID);
  353.  
  354.                                 const float neighborDistSq = square(0.3f);
  355.  
  356.                                 ICoverSystem::SurfaceInfo currSurfaceInfo;
  357.                                 ICoverSystem::SurfaceInfo nextSurfaceInfo;
  358.  
  359.                                 if (currSurface.GetSurfaceInfo(&currSurfaceInfo) && nextSurface.GetSurfaceInfo(&nextSurfaceInfo))
  360.                                 {
  361.                                         const Vec3& currLeft = currSurfaceInfo.samples[0].position;
  362.                                         const Vec3& currRight = currSurfaceInfo.samples[currSurfaceInfo.sampleCount - 1].position;
  363.                                         const Vec3& nextLeft = nextSurfaceInfo.samples[0].position;
  364.                                         const Vec3& nextRight = nextSurfaceInfo.samples[nextSurfaceInfo.sampleCount - 1].position;
  365.  
  366.                                         if (Distance::Point_Point2DSq(currLeft, nextRight) < neighborDistSq ||
  367.                                             Distance::Point_Point2DSq(currRight, nextLeft) < neighborDistSq)
  368.                                         {
  369.                                                 movingInCover = true;
  370.                                         }
  371.                                 }
  372.                         }
  373.  
  374.                         m_attachedPipeUser.SetMovingInCover(movingInCover);
  375.                         m_attachedPipeUser.SetInCover(movingInCover);
  376.                 }
  377.  
  378.                 m_attachedPipeUser.SetCoverID(nextCoverID);
  379.         }
  380.  
  381.         m_attachedPipeUser.SetMovingToCover(true);
  382. }
  383.  
  384. void PipeUserMovementActorAdapter::ResetBodyTarget()
  385. {
  386.         m_attachedPipeUser.ResetBodyTargetDir();
  387. }
  388.  
  389. void PipeUserMovementActorAdapter::SetBodyTargetDirection(const Vec3& direction)
  390. {
  391.         m_attachedPipeUser.SetBodyTargetDir(direction);
  392. }
  393.  
  394. Vec3 PipeUserMovementActorAdapter::GetAnimationBodyDirection() const
  395. {
  396.         return m_attachedPipeUser.GetBodyInfo().vAnimBodyDir;
  397. }
  398.  
  399. void PipeUserMovementActorAdapter::RequestExactPosition(const SAIActorTargetRequest* request, const bool lowerPrecision)
  400. {
  401.         assert(request != NULL);
  402.  
  403.         SAIActorTargetRequest& pipeUserActorTargetRequest = m_attachedPipeUser.GetState().actorTargetReq;
  404.  
  405.         pipeUserActorTargetRequest = *request;
  406.         pipeUserActorTargetRequest.id = ++m_attachedPipeUser.m_actorTargetReqId;
  407.         pipeUserActorTargetRequest.lowerPrecision = lowerPrecision;
  408. }
  409.  
  410. EActorTargetPhase PipeUserMovementActorAdapter::GetActorPhase() const
  411. {
  412.         return m_attachedPipeUser.GetState().curActorTargetPhase;
  413. }
  414.  
  415. const CAIActor* FindClosestActorTryingToUseSmartObject(const OffMeshLink_SmartObject& SOLink, const CPipeUser& defaultClosestPipeUser)
  416. {
  417.         CSmartObject* pSmartObject = SOLink.m_pSmartObject;
  418.         EntityId smartObjectId = pSmartObject->GetEntityId();
  419.  
  420.         const Vec3 smartObjectStart = pSmartObject->GetHelperPos(SOLink.m_pFromHelper);
  421.         const CAIActor* closestActor = defaultClosestPipeUser.CastToCAIActor();
  422.  
  423.         // Find the closest of all actors trying to use this SmartObject
  424.         {
  425.                 ActorLookUp& lookUp = *gAIEnv.pActorLookUp;
  426.                 size_t activeCount = lookUp.GetActiveCount();
  427.  
  428.                 float distanceClosestSq = Distance::Point_PointSq(closestActor->GetPos(), smartObjectStart);
  429.  
  430.                 for (size_t actorIndex = 0; actorIndex < activeCount; ++actorIndex)
  431.                 {
  432.                         const Vec3 position = lookUp.GetPosition(actorIndex);
  433.                         const float distanceSq = Distance::Point_PointSq(position, smartObjectStart);
  434.  
  435.                         if (distanceSq < distanceClosestSq)
  436.                         {
  437.                                 if (CPipeUser* closerActor = lookUp.GetActor<CPipeUser>(actorIndex))
  438.                                 {
  439.                                         if (closerActor->GetPendingSmartObjectID() == smartObjectId)
  440.                                         {
  441.                                                 distanceClosestSq = distanceSq;
  442.  
  443.                                                 closestActor = closerActor;
  444.                                         }
  445.                                 }
  446.                         }
  447.                 }
  448.         }
  449.  
  450.         assert(closestActor);
  451.  
  452.         return closestActor;
  453. }
  454.  
  455. bool AreWeClosestActorTryingToUseSmartObject(const OffMeshLink_SmartObject& SOLink, const CPipeUser& pipeUser)
  456. {
  457.         const CAIActor* closestActor = FindClosestActorTryingToUseSmartObject(SOLink, pipeUser);
  458.         return (closestActor && (closestActor == pipeUser.CastToCAIActor()));
  459. }
  460.  
  461. bool PipeUserMovementActorAdapter::IsClosestToUseTheSmartObject(const OffMeshLink_SmartObject& smartObjectLink) const
  462. {
  463.         return AreWeClosestActorTryingToUseSmartObject(smartObjectLink, m_attachedPipeUser);
  464. }
  465.  
  466. bool PipeUserMovementActorAdapter::PrepareNavigateSmartObject(CSmartObject* pSmartObject, OffMeshLink_SmartObject* pSmartObjectLink)
  467. {
  468.         CSmartObjectManager* pSmartObjectManager = gAIEnv.pSmartObjectManager;
  469.         if (pSmartObjectManager->PrepareNavigateSmartObject(&m_attachedPipeUser, pSmartObject, pSmartObjectLink->m_pSmartObjectClass, pSmartObjectLink->m_pFromHelper, pSmartObjectLink->m_pToHelper) && m_attachedPipeUser.m_eNavSOMethod != nSOmNone)
  470.         {
  471.                 SAIActorTargetRequest& pipeUserActorTargetRequest = m_attachedPipeUser.GetState().actorTargetReq;
  472.                 pipeUserActorTargetRequest.id = ++m_attachedPipeUser.m_actorTargetReqId;
  473.                 pipeUserActorTargetRequest.lowerPrecision = true;
  474.                 return true;
  475.         }
  476.  
  477.         return false;
  478. }
  479.  
  480. void PipeUserMovementActorAdapter::InvalidateSmartObjectLink(CSmartObject* pSmartObject, OffMeshLink_SmartObject* pSmartObjectLink)
  481. {
  482.         assert(pSmartObject != NULL && pSmartObjectLink != NULL);
  483.         m_attachedPipeUser.InvalidateSOLink(pSmartObject, pSmartObjectLink->m_pFromHelper, pSmartObjectLink->m_pToHelper);
  484. }
  485.  
  486. void PipeUserMovementActorAdapter::ResetActorTargetRequest()
  487. {
  488.         SAIActorTargetRequest& pipeUserActorTargetRequest = m_attachedPipeUser.GetState().actorTargetReq;
  489.         pipeUserActorTargetRequest.Reset();
  490. }
  491.  
  492. bool PipeUserMovementActorAdapter::IsInCover() const
  493. {
  494.         return m_attachedPipeUser.IsInCover();
  495. }
  496.  
  497. void PipeUserMovementActorAdapter::CancelRequestedPath()
  498. {
  499.         const bool isActorRemoved = false;
  500.         m_attachedPipeUser.CancelRequestedPath(isActorRemoved);
  501. }
  502.  
downloadPipeUserMovementActorAdapter.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top