WrapMode

151     void Update()
152     {
153         if (isControllable)
154         {
155             if (Input.GetButtonDown("Jump"))
156             {
157                 lastJumpButtonTime = Time.time;
158             }
159
160             UpdateSmoothedMovementDirection();
161
162             // Apply gravity
163             // - extra power jump modifies gravity
164             // - controlledDescent mode modifies gravity
165             ApplyGravity();
166
167             // Apply jumping logic
168             ApplyJumping();
169
170
171             // Calculate actual motion
172             Vector3 movement = moveDirection * moveSpeed + new Vector3(0, verticalSpeed, 0) + inAirVelocity;
173             movement *= Time.deltaTime;
174
175             //Debug.Log(movement.x.ToString("0.000") + ":" + movement.z.ToString("0.000"));
176
177             // Move the controller
178             CharacterController controller = GetComponent();
179             collisionFlags = controller.Move(movement);
180
181         }
182
183         // PUN: if a remote position is known, we smooth-move to it (being late(r) but smoother)
184         if (this.remotePosition != Vector3.zero)
185         {
186             transform.position = Vector3.Lerp(transform.position, this.remotePosition, Time.deltaTime * this.RemoteSmoothing);
187         }
188
189         velocity = (transform.position - lastPos)*25;
190
191         // ANIMATION sector
192         if (_animation)
193         {
194             if (_characterState == PickupCharacterState.Jumping)
195             {
196                 if (!jumpingReachedApex)
197                 {
198                     _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
199                     _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
200                     _animation.CrossFade(jumpPoseAnimation.name);
201                 }
202                 else
203                 {
204                     _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
205                     _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
206                     _animation.CrossFade(jumpPoseAnimation.name);
207                 }
208             }
209             else
210             {
211                 if (_characterState == PickupCharacterState.Idle)
212                 {
213                     _animation.CrossFade(idleAnimation.name);
214                 }
215                 else if (_characterState == PickupCharacterState.Running)
216                 {
217                     _animation[runAnimation.name].speed = runMaxAnimationSpeed;
218                     if (this.isControllable)
219                     {
220                         _animation[runAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, runMaxAnimationSpeed);
221                     }
222                     _animation.CrossFade(runAnimation.name);
223                 }
224                 else if (_characterState == PickupCharacterState.Trotting)
225                 {
226                     _animation[walkAnimation.name].speed = trotMaxAnimationSpeed;
227                     if (this.isControllable)
228                     {
229                         _animation[walkAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, trotMaxAnimationSpeed);
230                     }
231                     _animation.CrossFade(walkAnimation.name);
232                 }
233                 else if (_characterState == PickupCharacterState.Walking)
234                 {
235                     _animation[walkAnimation.name].speed = walkMaxAnimationSpeed;
236                     if (this.isControllable)
237                     {
238                         _animation[walkAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, walkMaxAnimationSpeed);
239                     }
240                     _animation.CrossFade(walkAnimation.name);
241                 }
242
243                 if (_characterState != PickupCharacterState.Running)
244                 {
245                     _animation[runAnimation.name].time = 0.0f;
246                 }
247             }
248         }
249         // ANIMATION sector
250
251         // Set rotation to the move direction
252         if (IsGrounded())
253         {
254             // a specialty of this controller: you can disable rotation!
255             if (DoRotate)
256             {
257                 transform.rotation = Quaternion.LookRotation(moveDirection);
258             }
259         }
260         else
261         {
262             /* This causes choppy behaviour when colliding with SIDES
263              * Vector3 xzMove = velocity;
264             xzMove.y = 0;
265             if (xzMove.sqrMagnitude > 0.001f)
266             {
267                 transform.rotation = Quaternion.LookRotation(xzMove);
268             }*/
269         }
270
271         // We are in jump mode but just became grounded
272         if (IsGrounded())
273         {
274             lastGroundedTime = Time.time;
275             inAirVelocity = Vector3.zero;
276             if (jumping)
277             {
278                 jumping = false;
279                 SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
280             }
281         }
282
283         lastPos = transform.position;
284     }

57         public List BuildAnimationClips(GameObject root, Entity entity, string scmlAssetPath)
58         {
59             var allAnimClips = AssetDatabase.LoadAllAssetRepresentationsAtPath(scmlAssetPath).OfType().ToList();
60             Debug.Log(string.Format("Found {0} animation clips at {1}", allAnimClips.Count, scmlAssetPath));
61
62             var newAnimClips = new List();
63
64             foreach (var animation in entity.Animations)
65             {
66                 var animClip = MakeAnimationClip(root, animation, Path.GetDirectoryName(scmlAssetPath));
67                 Debug.Log(string.Format("Added animClip({0}) to asset path ({1}) WrapMode:{2}", animClip.name, scmlAssetPath, animClip.wrapMode));
68                 newAnimClips.Add(animClip);
69
70                 var originalAnimClip = allAnimClips.Where(clip => clip.name == animClip.name).FirstOrDefault();
71                 if (originalAnimClip != null)
72                 {
73                     Debug.Log("Replacing animation clip " + animClip.name);
74                     EditorUtility.CopySerialized(animClip, originalAnimClip);
75                     allAnimClips.Remove(originalAnimClip);
76                 }
77                 else
78                     AssetDatabase.AddObjectToAsset(animClip, scmlAssetPath);
79             }
80
81             //Remove any animation clips that are no longer present in the SCML
82             foreach(var clip in allAnimClips)
83             {
84                 //This may be a bad idea
85                 UnityEngine.Object.DestroyImmediate(clip, true);
86             }
87
88             return newAnimClips;
89         }

112         private void MakeAnimationCurves(GameObject root, AnimationClip animClip, Animation animation)
113         {
114             acb = new AnimationCurveBuilder();
115
116             //Get a list of all sprites on this GO
117             var allSprites = root.GetComponentsInChildren(true).Select(sr => AnimationUtility.CalculateTransformPath(sr.transform, root.transform));
118
119             //Add a key for all objects on the first frame
120             SetGameObjectForKey(root, animClip, animation.MainlineKeys.First(), 0);
121
122             foreach (var mainlineKey in animation.MainlineKeys)
123             {
124
125                 var visibleSprites = SetGameObjectForKey(root, animClip, mainlineKey);
126                 var hiddenSprites = allSprites.Except(visibleSprites);
127                 HideSprites(root, hiddenSprites, mainlineKey.Time);
128             }
129
130             switch (animation.LoopType)
131             {
132                 case LoopType.True:
133                     //Cycle back to first frame
134                     SetGameObjectForKey(root, animClip, animation.MainlineKeys.First(), animation.Length);
135                     break;
136                 case LoopType.False:
137                     //Duplicate the last key at the end time of the animation
138                     SetGameObjectForKey(root, animClip, animation.MainlineKeys.Last(), animation.Length);
139                     break;
140                 default:
141                     Debug.LogWarning("Unsupported loop type: " + animation.LoopType.ToString());
142                     break;
143             }
144
145             //Add the curves to our animation clip
146             //NOTE: This MUST be done before modifying the settings, thus the double switch statement
147             acb.AddCurves(animClip);
148
149             foreach (var sprite in spriteChangeKeys)
150             {
151                 if (sprite.Value.Count > 0)
152                 {
153                     BuildSpriteChangeCurve(ref animClip, sprite);
154                 }
155             }
156
157             //Set the loop/wrap settings for the animation clip
158             var animSettings = AnimationUtility.GetAnimationClipSettings(animClip);
159             switch(animation.LoopType)
160             {
161                 case LoopType.True:
162                     animClip.wrapMode = WrapMode.Loop;
163                     animSettings.loopTime = true;
164                     break;
165                 case LoopType.False:
166                     animClip.wrapMode = WrapMode.ClampForever;
167                     break;
168                 case LoopType.PingPong:
169                     animClip.wrapMode = WrapMode.PingPong;
170                     animSettings.loopTime = true;
171                     break;
172                 default:
173                     Debug.LogWarning("Unsupported loop type: " + animation.LoopType.ToString());
174                     break;
175             }
176
177             animClip.SetAnimationSettings(animSettings);
178
179             //Debug.Log(string.Format("Setting animation {0} to {1} loop mode (WrapMode:{2} LoopTime:{3}) ", animClip.name, animation.LoopType, animClip.wrapMode, animSettings.loopTime));
180         }

150         private void OnPreprocessTexture()
151         {
152             if (!UseThisImporter())
153                 return;
154
155             TextureImporter textureImporter = this.assetImporter as TextureImporter;
156             textureImporter.textureType = TextureImporterType.Default;
157             textureImporter.npotScale = TextureImporterNPOTScale.None;
158             textureImporter.convertToNormalmap = false;
159             textureImporter.lightmap = false;
160             textureImporter.alphaIsTransparency = true;
161             textureImporter.grayscaleToAlpha = false;
162             textureImporter.linearTexture = false;
163             textureImporter.spriteImportMode = SpriteImportMode.None;
164             textureImporter.mipmapEnabled = false;
165             textureImporter.generateCubemap = TextureImporterGenerateCubemap.None;
166             textureImporter.filterMode = FilterMode.Point;
167             textureImporter.wrapMode = TextureWrapMode.Clamp;
168             textureImporter.textureFormat = TextureImporterFormat.AutomaticTruecolor;
169         }

79         public void ResponsiveDtg(DataGridView dtg)
80         {
81             dtg.DefaultCellStyle.WrapMode = DataGridViewTriState.True;
82         }