14073102（CCDIKRecoil）

【目标】

CCDIKRecoil

 

【思路】

1 CCDIK和Recoil的结合

2 Recoil的回弹机制，逐渐回到原来位置

3 添加一个Recoil基类

 

 

【步骤】

1 将\Src\GameFramework\Classes\GameSkelCtrl_Recoil.uc复制到\Src\Engine\Classes\SkelControlRecoilBase.uc

修改一下名称 作为基类

 

2 其他相关类继承于SkelControlRecoilBase， \Engine\Classes\SkelControlLimbRecoil.uc

 

make一下

编译不通过

 

原因是USkeletalControlRecoilBase是在后面声明的

方案：

采取将派生类放GameFrameWork工程中

编译后发现

 

这里有语法错误

 

 

最后还是没有用继承方式，脚本目前很难使用双基类

所以目前还是重复写相同代码

 

3 添加一个继承类GameSkelCtrl_CCD_IK_Recoil_CCD_IK_Recoil.uc，放到GameFramework中，否则又牵扯到那些结构体声明的先后顺序问题

 

 

4 在GameSkelControls.cpp 中添加实现宏，及函数实现

 

  1. IMPLEMENT_CLASS(UGameSkelCtrl_CCD_IK_Recoil);
 
  1. /*-----------------------------------------------------------------------------
  2. UGameSkelCtrl_CCD_IK_Recoil
  3. -----------------------------------------------------------------------------*/
  4. FVector2DUGameSkelCtrl_CCD_IK_Recoil::GetAim(USkeletalMeshComponent*InSkelComponent)
  5. {
  6. returnAim;
  7. }
  9. /** Is skeleton currently mirrored */
  10. UBOOL UGameSkelCtrl_CCD_IK_Recoil::IsMirrored(USkeletalMeshComponent*InSkelComponent)
  11. {
  12. return FALSE;
  13. }
  15. // USkelControlBase interface
  16. voidUGameSkelCtrl_CCD_IK_Recoil::TickSkelControl(FLOAT DeltaSeconds,USkeletalMeshComponent*SkelComp)
  17. {
  18. bApplyControl = FALSE;
  20. if(ControlStrength> ZERO_ANIMWEIGHT_THRESH )
  21. {
  22. // if willing to play recoil, reset its state
  23. if( bPlayRecoil != bOldPlayRecoil )
  24. {
  25. bPlayRecoil = bOldPlayRecoil;
  27. Recoil.TimeToGo=Recoil.TimeDuration;
  29. // ERS_Random == Start at random position along sine wave,
  30. // ERS_Zero == Start at 0
  31. const FLOAT TWO_PI =2.f*(FLOAT)PI;
  32. Recoil.RotSinOffset.X =Recoil.RotParams.X == ERS_Random ? appFrand()* TWO_PI :0.f;
  33. Recoil.RotSinOffset.Y =Recoil.RotParams.Y == ERS_Random ? appFrand()* TWO_PI :0.f;
  34. Recoil.RotSinOffset.Z =Recoil.RotParams.Z == ERS_Random ? appFrand()* TWO_PI :0.f;
  36. Recoil.LocSinOffset.X =Recoil.LocParams.X == ERS_Random ? appFrand()* TWO_PI :0.f;
  37. Recoil.LocSinOffset.Y =Recoil.LocParams.Y == ERS_Random ? appFrand()* TWO_PI :0.f;
  38. Recoil.LocSinOffset.Z =Recoil.LocParams.Z == ERS_Random ? appFrand()* TWO_PI :0.f;
  40. Recoil.RotOffset=FRotator(0,0,0);
  41. Recoil.LocOffset=FVector(0.f);
  42. }
  44. if(Recoil.TimeToGo>DeltaSeconds)
  45. {
  46. Recoil.TimeToGo-=DeltaSeconds;
  48. if(Recoil.TimeToGo>0.f)
  49. {
  50. bApplyControl = TRUE;
  52. // Smooth fade out
  53. const FLOAT TimePct=Clamp<FLOAT>(Recoil.TimeToGo/Recoil.TimeDuration,0.f,1.f);
  54. const FLOAT Alpha=TimePct*TimePct*(3.f-2.f*TimePct);
  55. const FLOAT AlphaTimesDelta=Alpha*DeltaSeconds;
  57. // Recoil Bone Rotation, compute sin wave value for each component
  58. if(!Recoil.RotAmplitude.IsZero())
  59. {
  60. if(Recoil.RotAmplitude.X !=0.f)
  61. {
  62. Recoil.RotSinOffset.X +=AlphaTimesDelta*Recoil.RotFrequency.X;
  63. Recoil.RotOffset.Pitch= appTrunc(Alpha*Recoil.RotAmplitude.X * appSin(Recoil.RotSinOffset.X));
  64. }
  65. if(Recoil.RotAmplitude.Y !=0.f)
  66. {
  67. Recoil.RotSinOffset.Y +=AlphaTimesDelta*Recoil.RotFrequency.Y;
  68. Recoil.RotOffset.Yaw= appTrunc(Alpha*Recoil.RotAmplitude.Y * appSin(Recoil.RotSinOffset.Y));
  69. }
  70. if(Recoil.RotAmplitude.Z !=0.f)
  71. {
  72. Recoil.RotSinOffset.Z +=AlphaTimesDelta*Recoil.RotFrequency.Z;
  73. Recoil.RotOffset.Roll= appTrunc(Alpha*Recoil.RotAmplitude.Z * appSin(Recoil.RotSinOffset.Z));
  74. }
  75. }
  77. // Recoil Bone Location, compute sin wave value for each component
  78. if(!Recoil.LocAmplitude.IsZero())
  79. {
  80. if(Recoil.LocAmplitude.X !=0.f)
  81. {
  82. Recoil.LocSinOffset.X +=AlphaTimesDelta*Recoil.LocFrequency.X;
  83. Recoil.LocOffset.X =Alpha*Recoil.LocAmplitude.X * appSin(Recoil.LocSinOffset.X);
  84. }
  85. if(Recoil.LocAmplitude.Y !=0.f)
  86. {
  87. Recoil.LocSinOffset.Y +=AlphaTimesDelta*Recoil.LocFrequency.Y;
  88. Recoil.LocOffset.Y =Alpha*Recoil.LocAmplitude.Y * appSin(Recoil.LocSinOffset.Y);
  89. }
  90. if(Recoil.LocAmplitude.Z !=0.f)
  91. {
  92. Recoil.LocSinOffset.Z +=AlphaTimesDelta*Recoil.LocFrequency.Z;
  93. Recoil.LocOffset.Z =Alpha*Recoil.LocAmplitude.Z * appSin(Recoil.LocSinOffset.Z);
  94. }
  95. }
  96. }
  97. }
  98. }
  100. Super::TickSkelControl(DeltaSeconds,SkelComp);
  101. }
  103. voidUGameSkelCtrl_CCD_IK_Recoil::GetAffectedBones(INT BoneIndex,USkeletalMeshComponent*SkelComp,TArray<INT>&OutBoneIndices)
  104. {
  105. check(OutBoneIndices.Num()==0);
  107. // Only process bone if there is something to do
  108. if( bApplyControl )
  109. Super::GetAffectedBones(BoneIndex,SkelComp,OutBoneIndices);
  110. }
  112. voidUGameSkelCtrl_CCD_IK_Recoil::CalculateNewBoneTransforms(INT BoneIndex,USkeletalMeshComponent*SkelComp,TArray<FBoneAtom>&OutBoneTransforms)
  113. {
  114. check(OutBoneTransforms.Num()==0);
  116. // Current bone transform matrix in component space
  117. FBoneAtomNewBoneTM=SkelComp->SpaceBases(BoneIndex);
  119. if(bBoneSpaceRecoil)
  120. {
  121. if(!Recoil.LocOffset.IsZero()||!Recoil.RotOffset.IsZero())
  122. {
  123. FBoneAtomRecoilTM(Recoil.RotOffset,Recoil.LocOffset);
  124. NewBoneTM=RecoilTM*NewBoneTM;
  125. OutBoneTransforms.AddItem(NewBoneTM);
  126. }
  128. return;
  129. }
  132. // Extract Aim
  133. Aim=GetAim(SkelComp);
  135. // Actor to Aim transform matrix
  136. constFRotatorAimRotOffset( appTrunc(Aim.Y*16384), appTrunc(Aim.X*16384),0);
  137. FBoneAtomActorToAim(AimRotOffset,FVector::ZeroVector);
  138. ActorToAim.RemoveScaling();
  139. ActorToAim.SetOrigin(FVector(0.f));
  140. constFBoneAtomAimToActor=ActorToAim.Inverse();
  142. // Component to Actor transform matrix
  143. FBoneAtomComponentToActor=SkelComp->CalcComponentToFrameMatrix(BoneIndex, BCS_ActorSpace, NAME_None);
  144. ComponentToActor.RemoveScaling();
  145. ComponentToActor.SetOrigin(FVector(0.f));
  146. constFBoneAtomActorToComponent=ComponentToActor.InverseSafe();
  148. // Add rotation offset in component space
  149. if(!Recoil.RotOffset.IsZero())
  150. {
  151. FRotatorRotOffset=Recoil.RotOffset;
  153. // Handle mirroring
  154. if(IsMirrored(SkelComp))
  155. {
  156. RotOffset.Yaw=-RotOffset.Yaw;
  157. }
  159. FBoneAtomNewRotTM=NewBoneTM*(ComponentToActor*(AimToActor*FBoneAtom(RotOffset,FVector::ZeroVector)*ActorToAim)*ActorToComponent);
  160. NewRotTM.SetOrigin(NewBoneTM.GetOrigin());
  161. NewBoneTM=NewRotTM;
  162. }
  164. // Add location offset in component space
  165. if(!Recoil.LocOffset.IsZero())
  166. {
  167. FVectorLocOffset=Recoil.LocOffset;
  169. // Handle mirroring
  170. if(IsMirrored(SkelComp))
  171. {
  172. LocOffset.Y =-LocOffset.Y;
  173. }
  175. constFVectorTransInWorld=ActorToAim.TransformNormal(LocOffset);
  176. constFVectorTransInComp=ActorToComponent.TransformNormal(TransInWorld);
  177. constFVectorNewOrigin=NewBoneTM.GetOrigin()+TransInComp;
  178. NewBoneTM.SetOrigin(NewOrigin);
  179. }
  181. // OutBoneTransforms.AddItem(NewBoneTM);
  182. EffectorLocation=NewBoneTM.GetOrigin();
  184. EffectorLocationSpace= BCS_WorldSpace;
  186. Super::CalculateNewBoneTransforms(BoneIndex,SkelComp,OutBoneTransforms);
  187. }
 

 

5 运行

 

如果单独一根骨骼的Recoil

 
 

 

 

6

 

 

 





posted on 2016-08-30 11:47  维尔福  阅读(573)  评论(0)    收藏  举报