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

来自为知笔记(Wiz)