zoukankan      html  css  js  c++  java

  • 14073102（CCDIKRecoil）

    【目标】

    CCDIKRecoil

     

    【思路】

    1 CCDIK和Recoil的结合

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

    3 添加一个Recoil基类

     

     

    【步骤】

    1 将SrcGameFrameworkClassesGameSkelCtrl_Recoil.uc复制到SrcEngineClassesSkelControlRecoilBase.uc

    修改一下名称 作为基类

     

    2 其他相关类继承于SkelControlRecoilBase， EngineClassesSkelControlLimbRecoil.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

     

     

     
  • 相关阅读:
    hibernate理解
    struts理解
    网上书城项目
    编码过程中遇到的问题
    JS回调函数
    requirejs 一个拆分js项目的类库
    jq插件开发总结
    转载-- 魔兽哈希算法封装和测试
    转载--C# PLINQ 内存列表查询优化历程
    Oracle删除死锁进程的方法
  • 原文地址：https://www.cnblogs.com/username/p/5821410.html
Copyright © 2011-2022 走看看