OpenClonk
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros
C4MeshAnimation.cpp
Go to the documentation of this file.
1 /*
2  * OpenClonk, http://www.openclonk.org
3  *
4  * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
5  * Copyright (c) 2010-2016, The OpenClonk Team and contributors
6  *
7  * Distributed under the terms of the ISC license; see accompanying file
8  * "COPYING" for details.
9  *
10  * "Clonk" is a registered trademark of Matthes Bender, used with permission.
11  * See accompanying file "TRADEMARK" for details.
12  *
13  * To redistribute this file separately, substitute the full license texts
14  * for the above references.
15  */
16 
17 #include "C4Include.h"
18 #include "object/C4MeshAnimation.h"
19 
20 #include "object/C4Object.h"
21 #include "script/C4Aul.h"
22 #include "script/C4ValueArray.h"
23 
24 namespace
25 {
26  // Register value providers for serialization
28  const StdMeshInstance::SerializableValueProvider::ID<C4ValueProviderLinear> C4ValueProviderLinearID("linear");
38  const StdMeshInstance::SerializableValueProvider::ID<C4ValueProviderAbsRDir> C4ValueProviderAbsRDirID("absrdir");
43  const StdMeshInstance::SerializableValueProvider::ID<C4ValueProviderAction> C4ValueProviderActionID("action");
44 }
45 
47 {
48  int32_t type = Data[0].getInt();
49  switch (type)
50  {
51  case C4AVP_Const:
52  return new C4ValueProviderConst(itofix(Data[1].getInt(), 1000));
53  case C4AVP_Linear:
54  {
55  int32_t end = Data[3].getInt(), len = Data[4].getInt();
56  if (len == 0)
57  throw C4AulExecError("Length cannot be zero");
58  // Sanity check for linear animations that are too long and could cause excessive animation stacks
59  if (pos_for_animation)
60  {
61  int32_t max_end = fixtoi(ftofix(pos_for_animation->Length), 1000);
62  if (end < 0 || end > max_end)
63  throw C4AulExecError(FormatString("End (%d) not in range of animation '%s' (0-%d).", (int)end, pos_for_animation->Name.getData(), (int)max_end).getData());
64  }
65  return new C4ValueProviderLinear(itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(end, 1000), len, static_cast<C4AnimationEnding>(Data[5].getInt()));
66  }
67  case C4AVP_X:
68  if (!pForObj) return nullptr;
69  if (Data[4].getInt() == 0)
70  throw C4AulExecError("Length cannot be zero");
71 
72  return new C4ValueProviderX(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(), 1000), Data[4].getInt());
73  case C4AVP_Y:
74  if (!pForObj) return nullptr;
75  if (Data[4].getInt() == 0)
76  throw C4AulExecError("Length cannot be zero");
77 
78  return new C4ValueProviderY(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(), 1000), Data[4].getInt());
79  case C4AVP_R:
80  if(Data.GetSize() >= 4 && Data[3] != C4VNull)
81  pForObj = Data[3].getObj();
82  if (!pForObj) return nullptr;
83  return new C4ValueProviderR(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000));
84  case C4AVP_AbsX:
85  if (!pForObj) return nullptr;
86  if (Data[4].getInt() == 0)
87  throw C4AulExecError("Length cannot be zero");
88  return new C4ValueProviderAbsX(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(), 1000), Data[4].getInt());
89  case C4AVP_AbsY:
90  if (!pForObj) return nullptr;
91  if (Data[4].getInt() == 0)
92  throw C4AulExecError("Length cannot be zero");
93  return new C4ValueProviderAbsY(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(), 1000), Data[4].getInt());
94  case C4AVP_Dist:
95  if (!pForObj) return nullptr;
96  if (Data[4].getInt() == 0)
97  throw C4AulExecError("Length cannot be zero");
98  return new C4ValueProviderDist(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(), 1000), Data[4].getInt());
99  case C4AVP_XDir:
100  if (!pForObj) return nullptr;
101  if (Data[3].getInt() == 0)
102  throw C4AulExecError("MaxXDir cannot be zero");
103  return new C4ValueProviderXDir(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(),Data[4].getInt()));
104  case C4AVP_YDir:
105  if (!pForObj) return nullptr;
106  if (Data[3].getInt() == 0)
107  throw C4AulExecError("MaxYDir cannot be zero");
108  return new C4ValueProviderYDir(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(),Data[4].getInt()));
109  case C4AVP_RDir:
110  if (!pForObj) return nullptr;
111  if (Data[4].getInt() - Data[3].getInt() == 0)
112  throw C4AulExecError("MaxRDir - MinRDir cannot be zero");
113  return new C4ValueProviderRDir(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(),Data[5].getInt()), itofix(Data[4].getInt(),Data[5].getInt()));
114 
115  case C4AVP_AbsRDir:
116  if (!pForObj) return nullptr;
117  if (Data[4].getInt() - Data[3].getInt() == 0)
118  throw C4AulExecError("MaxRDir - MinRDir cannot be zero");
119  return new C4ValueProviderAbsRDir(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(),Data[5].getInt()), itofix(Data[4].getInt(),Data[5].getInt()));
120  case C4AVP_CosR:
121  if (!pForObj) return nullptr;
122  return new C4ValueProviderCosR(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(),Data[4].getInt()));
123  case C4AVP_SinR:
124  if (!pForObj) return nullptr;
125  return new C4ValueProviderSinR(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(),Data[4].getInt()));
126  case C4AVP_CosV:
127  if (!pForObj) return nullptr;
128  return new C4ValueProviderCosV(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(),Data[4].getInt()));
129  case C4AVP_SinV:
130  if (!pForObj) return nullptr;
131  return new C4ValueProviderSinV(pForObj, itofix(Data[1].getInt(), 1000), itofix(Data[2].getInt(), 1000), itofix(Data[3].getInt(),Data[4].getInt()));
132  case C4AVP_Action:
133  if (!pForObj) return nullptr;
134  return new C4ValueProviderAction(pForObj);
135  default:
136  return nullptr;
137  }
138 }
139 
141 {
142  Value = value;
143 }
144 
146 {
147  // Keep value we set in ctor
148  return true;
149 }
150 
152  Begin(begin), End(end), Length(length), Ending(ending), LastTick(Game.FrameCounter)
153 {
154  Value = pos;
155 }
156 
158 {
159  Value += (End - Begin) * itofix(Game.FrameCounter - LastTick) / Length;
160  LastTick = Game.FrameCounter;
161 
162  assert( (End >= Begin && Value >= Begin) || (End <= Begin && Value <= Begin));
163  while ( (End > Begin && Value > End) || (End < Begin && Value < End))
164  {
165  switch (Ending)
166  {
167  case ANIM_Loop:
168  Value -= (End - Begin);
169  return true;
170  case ANIM_Hold:
171  Value = End;
172  return true;
173  case ANIM_Remove:
174  Value = End;
175  return false;
176  }
177  }
178 
179  return true;
180 }
181 
183 {
184  const StdEnumEntry<C4AnimationEnding> Endings[] =
185  {
186  { "Loop", ANIM_Loop },
187  { "Hold", ANIM_Hold },
188  { "Remove", ANIM_Remove },
189 
190  { nullptr, static_cast<C4AnimationEnding>(0) }
191  };
192 
194  pComp->Separator();
195  pComp->Value(Begin);
196  pComp->Separator();
197  pComp->Value(End);
198  pComp->Separator();
199  pComp->Value(Length);
200  pComp->Separator();
201  pComp->Value(mkEnumAdaptT<uint8_t>(Ending, Endings));
202  pComp->Separator();
203  pComp->Value(LastTick);
204 
205  // When a scenario is saved as scenario the FrameCounter will be reset
206  // upon scenario start. The LastTick variable is fixed here.
207  // TODO: A nicer solution would be to always set LastTick to
208  // Game.FrameCounter and to make sure that the Value is always up to
209  // date (current frame) when saving by running Execute(). This could
210  // even be done in the base class.
211  if(pComp->isDeserializer())
212  if(LastTick > Game.FrameCounter)
213  LastTick = 0;
214 }
215 
216 C4ValueProviderX::C4ValueProviderX(C4Object* object, C4Real pos, C4Real begin, C4Real end, int32_t length):
217  Object(object), Begin(begin), End(end), Length(length)
218 {
219  Value = pos;
220 }
221 
223 {
224  // Object might have been removed
225  if(!Object) return false;
226 
227  Value += (End - Begin) * (Object->xdir) / Length;
228 
229  if (End > Begin)
230  {
231  while (Value > End)
232  Value -= (End - Begin);
233  while (Value < Begin)
234  Value += (End - Begin);
235  }
236  else
237  {
238  while (Value > Begin)
239  Value -= (Begin - End);
240  while (Value < End)
241  Value += (Begin - End);
242  }
243 
244  return true;
245 }
246 
248 {
250  pComp->Separator();
251  pComp->Value(Object);
252  pComp->Separator();
253  pComp->Value(Begin);
254  pComp->Separator();
255  pComp->Value(End);
256  pComp->Separator();
257  pComp->Value(Length);
258 }
259 
260 C4ValueProviderY::C4ValueProviderY(C4Object* object, C4Real pos, C4Real begin, C4Real end, int32_t length):
261  Object(object), Begin(begin), End(end), Length(length)
262 {
263  Value = pos;
264 }
265 
267 {
268  // Object might have been removed
269  if(!Object) return false;
270 
271  Value += (End - Begin) * (Object->ydir) / Length;
272 
273  if (End > Begin)
274  {
275  while (Value > End)
276  Value -= (End - Begin);
277  while (Value < Begin)
278  Value += (End - Begin);
279  }
280  else
281  {
282  while (Value > Begin)
283  Value -= (Begin - End);
284  while (Value < End)
285  Value += (Begin - End);
286  }
287 
288  return true;
289 }
290 
292 {
294  pComp->Separator();
295  pComp->Value(Object);
296  pComp->Separator();
297  pComp->Value(Begin);
298  pComp->Separator();
299  pComp->Value(End);
300  pComp->Separator();
301  pComp->Value(Length);
302 }
303 
305  Object(object), Begin(begin), End(end)
306 {
307  Execute();
308 }
309 
311 {
312  // Object might have been removed
313  if(!Object) return false;
314 
315  C4Real r = Object->fix_r;
316  if(r < 0) r += 360;
317 
318  Value = Begin + (End - Begin) * r / 360;
319  return true;
320 }
321 
323 {
325  pComp->Separator();
326  pComp->Value(Object);
327  pComp->Separator();
328  pComp->Value(Begin);
329  pComp->Separator();
330  pComp->Value(End);
331 }
332 
333 C4ValueProviderAbsX::C4ValueProviderAbsX(C4Object* object, C4Real pos, C4Real begin, C4Real end, int32_t length):
334  Object(object), Begin(begin), End(end), Length(length)
335 {
336  Value = pos;
337 }
338 
340 {
341  // Object might have been removed
342  if(!Object) return false;
343 
344  C4Real dist;
345  if(Object->xdir > itofix(100) || Object->ydir > itofix(100))
346  dist = itofix(Distance(0, 0, fixtoi(Object->xdir), fixtoi(Object->ydir)));
347  else if(Object->xdir > itofix(1) || Object->ydir > itofix(1))
348  dist = itofix(Distance(0, 0, fixtoi(Object->xdir, 256), fixtoi(Object->ydir, 256)), 16);
349  else
350  dist = itofix(Distance(0, 0, fixtoi(Object->xdir, 16384), fixtoi(Object->ydir, 16384)), 128);
351 
352  Value += (End - Begin) * Abs(Object->xdir) / Length;
353 
354  assert( (End >= Begin && Value >= Begin) || (End <= Begin && Value <= Begin));
355  while ( (End > Begin && Value > End) || (End < Begin && Value < End))
356  Value -= (End - Begin);
357 
358  return true;
359 }
360 
362 {
364  pComp->Separator();
365  pComp->Value(Object);
366  pComp->Separator();
367  pComp->Value(Begin);
368  pComp->Separator();
369  pComp->Value(End);
370  pComp->Separator();
371  pComp->Value(Length);
372 }
373 
374 C4ValueProviderAbsY::C4ValueProviderAbsY(C4Object* object, C4Real pos, C4Real begin, C4Real end, int32_t length):
375  Object(object), Begin(begin), End(end), Length(length)
376 {
377  Value = pos;
378 }
379 
381 {
382  // Object might have been removed
383  if(!Object) return false;
384 
385  Value += (End - Begin) * Abs(Object->ydir) / Length;
386 
387  assert( (End >= Begin && Value >= Begin) || (End <= Begin && Value <= Begin));
388  while ( (End > Begin && Value > End) || (End < Begin && Value < End))
389  Value -= (End - Begin);
390 
391  return true;
392 }
393 
395 {
397  pComp->Separator();
398  pComp->Value(Object);
399  pComp->Separator();
400  pComp->Value(Begin);
401  pComp->Separator();
402  pComp->Value(End);
403  pComp->Separator();
404  pComp->Value(Length);
405 }
406 
407 C4ValueProviderDist::C4ValueProviderDist(C4Object* object, C4Real pos, C4Real begin, C4Real end, int32_t length):
408  Object(object), Begin(begin), End(end), Length(length)
409 {
410  Value = pos;
411 }
412 
414 {
415  // Object might have been removed
416  if(!Object) return false;
417 
418  // The following computes sqrt(xdir**2 + ydir**2), and it attempts to
419  // do so without involving floating point numbers, and at the same
420  // time cover a large range of xdir and ydir.
421  C4Real dist;
422  if(Object->xdir > itofix(256) || Object->ydir > itofix(256))
423  dist = itofix(Distance(0, 0, fixtoi(Object->xdir), fixtoi(Object->ydir)));
424  else if(Object->xdir > itofix(1) || Object->ydir > itofix(1))
425  dist = itofix(Distance(0, 0, fixtoi(Object->xdir, 256), fixtoi(Object->ydir, 256)), 256);
426  else
427  dist = itofix(Distance(0, 0, fixtoi(Object->xdir, 65536), fixtoi(Object->ydir, 65536)), 65536);
428 
429  Value += (End - Begin) * dist / Length;
430 
431  assert( (End >= Begin && Value >= Begin) || (End <= Begin && Value <= Begin));
432  while ( (End > Begin && Value > End) || (End < Begin && Value < End))
433  Value -= (End - Begin);
434 
435  return true;
436 }
437 
439 {
441  pComp->Separator();
442  pComp->Value(Object);
443  pComp->Separator();
444  pComp->Value(Begin);
445  pComp->Separator();
446  pComp->Value(End);
447  pComp->Separator();
448  pComp->Value(Length);
449 }
450 
452  Object(object), Begin(begin), End(end), MaxXDir(max_xdir)
453 {
454  Execute();
455 }
456 
458 {
459  // Object might have been removed
460  if(!Object) return false;
461 
462  Value = Begin + (End - Begin) * std::min<C4Real>(Abs(Object->xdir/MaxXDir), itofix(1));
463  return true;
464 }
465 
467 {
469  pComp->Separator();
470  pComp->Value(Object);
471  pComp->Separator();
472  pComp->Value(Begin);
473  pComp->Separator();
474  pComp->Value(End);
475  pComp->Separator();
476  pComp->Value(MaxXDir);
477 }
478 
480  Object(object), Begin(begin), End(end), MaxYDir(max_ydir)
481 {
482  Execute();
483 }
484 
486 {
487  // Object might have been removed
488  if(!Object) return false;
489 
490  Value = Begin + (End - Begin) * std::min<C4Real>(Abs(Object->ydir/MaxYDir), itofix(1));
491  return true;
492 }
493 
495 {
497  pComp->Separator();
498  pComp->Value(Object);
499  pComp->Separator();
500  pComp->Value(Begin);
501  pComp->Separator();
502  pComp->Value(End);
503  pComp->Separator();
504  pComp->Value(MaxYDir);
505 }
506 
508  Object(object), Begin(begin), End(end), MinRDir(min_rdir), MaxRDir(max_rdir)
509 {
510  Execute();
511 }
512 
514 {
515  // Object might have been removed
516  if(!Object) return false;
517 
518  C4Real val = (Object->rdir - MinRDir) / (MaxRDir - MinRDir);
519 
520  Value = Begin + (End - Begin) * Clamp<C4Real>(val, itofix(0), itofix(1));
521  return true;
522 }
523 
525 {
527  pComp->Separator();
528  pComp->Value(Object);
529  pComp->Separator();
530  pComp->Value(Begin);
531  pComp->Separator();
532  pComp->Value(End);
533  pComp->Separator();
534  pComp->Value(MaxRDir);
535 }
536 
538  Object(object), Begin(begin), End(end), MinRDir(min_rdir), MaxRDir(max_rdir)
539 {
540  Execute();
541 }
542 
544 {
545  // Object might have been removed
546  if(!Object) return false;
547 
548  C4Real val = (Abs(Object->rdir) - MinRDir) / (MaxRDir - MinRDir);
549 
550  Value = Begin + (End - Begin) * Clamp<C4Real>(val, itofix(0), itofix(1));
551  return true;
552 }
553 
555 {
557  pComp->Separator();
558  pComp->Value(Object);
559  pComp->Separator();
560  pComp->Value(Begin);
561  pComp->Separator();
562  pComp->Value(End);
563  pComp->Separator();
564  pComp->Value(MaxRDir);
565 }
566 
568  Object(object), Begin(begin), End(end), Offset(offset)
569 {
570  Execute();
571 }
572 
574 {
575  // Object might have been removed
576  if(!Object) return false;
577 
578  Value = Begin + (End - Begin) * Cos(Object->fix_r + Offset);
579  return true;
580 }
581 
583 {
585  pComp->Separator();
586  pComp->Value(Object);
587  pComp->Separator();
588  pComp->Value(Begin);
589  pComp->Separator();
590  pComp->Value(End);
591  pComp->Separator();
592  pComp->Value(Offset);
593 }
594 
596  Object(object), Begin(begin), End(end), Offset(offset)
597 {
598  Execute();
599 }
600 
602 {
603  // Object might have been removed
604  if(!Object) return false;
605 
606  Value = Begin + (End - Begin) * Sin(Object->fix_r + Offset);
607  return true;
608 }
609 
611 {
613  pComp->Separator();
614  pComp->Value(Object);
615  pComp->Separator();
616  pComp->Value(Begin);
617  pComp->Separator();
618  pComp->Value(End);
619  pComp->Separator();
620  pComp->Value(Offset);
621 }
622 
624  Object(object), Begin(begin), End(end), Offset(offset)
625 {
626  Execute();
627 }
628 
630 {
631  // Object might have been removed
632  if(!Object) return false;
633 
634  // TODO: Maybe we can optimize this by using cos(r) = x/sqrt(x*x+y*y), sin(r)=y/sqrt(x*x+y*y)
635  // plus addition theorems for sin or cos.
636 
637  int angle = Angle(0, 0, fixtoi(Object->xdir, 256), fixtoi(Object->ydir, 256));
638  Value = Begin + (End - Begin) * Cos(itofix(angle) + Offset);
639  return true;
640 }
641 
643 {
645  pComp->Separator();
646  pComp->Value(Object);
647  pComp->Separator();
648  pComp->Value(Begin);
649  pComp->Separator();
650  pComp->Value(End);
651  pComp->Separator();
652  pComp->Value(Offset);
653 }
654 
656  Object(object), Begin(begin), End(end), Offset(offset)
657 {
658  Execute();
659 }
660 
662 {
663  // Object might have been removed
664  if(!Object) return false;
665 
666  // TODO: Maybe we can optimize this by using cos(r) = x/sqrt(x*x+y*y), sin(r)=y/sqrt(x*x+y*y),
667  // plus addition theorems for sin or cos.
668 
669  int angle = Angle(0, 0, fixtoi(Object->xdir, 256), fixtoi(Object->ydir, 256));
670  Value = Begin + (End - Begin) * Sin(itofix(angle) + Offset);
671  return true;
672 }
673 
675 {
677  pComp->Separator();
678  pComp->Value(Object);
679  pComp->Separator();
680  pComp->Value(Begin);
681  pComp->Separator();
682  pComp->Value(End);
683  pComp->Separator();
684  pComp->Value(Offset);
685 }
686 
688  Object(object)
689 {
690 }
691 
693 {
694  // Object might have been removed
695  if(!Object) return false;
696 
697  const C4Action& Action = Object->Action;
698  C4PropList* pActionDef = Object->GetAction();
699 
700  // TODO: We could cache these...
701  const StdMeshAnimation* animation = Action.Animation->GetAnimation();
702  const int32_t length = pActionDef->GetPropertyInt(P_Length);
703  const int32_t delay = pActionDef->GetPropertyInt(P_Delay);
704 
705  if (delay)
706  Value = itofix(Action.Phase * delay + Action.PhaseDelay) * ftofix(animation->Length) / (delay * length);
707  else
708  Value = itofix(Action.Phase) * ftofix(animation->Length) / length;
709 
710  return true;
711 }
712 
714 {
716  pComp->Separator();
717  pComp->Value(Object);
718 }
const char * getData() const
Definition: StdBuf.h:442
virtual bool Separator(Sep eSep=SEP_SEP)
Definition: StdCompiler.h:119
Definition: StdAdaptors.h:762
bool Execute() override
bool Execute() override
C4Game Game
Definition: C4Globals.cpp:52
void CompileFunc(StdCompiler *pComp) override
void CompileFunc(StdCompiler *pComp) override
C4PropList * GetAction() const
Definition: C4Object.cpp:2674
void CompileFunc(StdCompiler *pComp) override
C4Real rdir
Definition: C4Object.h:126
StdCopyStrBuf Name
Definition: StdMesh.h:97
void CompileFunc(StdCompiler *pComp) override
bool Execute() override
void CompileFunc(StdCompiler *pComp) override
StdMeshInstanceAnimationNode * Animation
Definition: C4Object.h:90
Definition: C4Real.h:58
int32_t Distance(int32_t iX1, int32_t iY1, int32_t iX2, int32_t iY2)
Definition: Standard.cpp:25
bool Execute() override
int32_t FrameCounter
Definition: C4Game.h:128
int32_t PhaseDelay
Definition: C4Object.h:85
bool Execute() override
StdMeshInstance::ValueProvider * CreateValueProviderFromArray(C4Object *pForObj, C4ValueArray &Data, const StdMeshAnimation *pos_for_animation)
C4Fixed itofix(int32_t x)
Definition: C4Real.h:261
bool Execute() override
int Angle(int iX1, int iY1, int iX2, int iY2)
Definition: Standard.cpp:36
bool Execute() override
void CompileFunc(StdCompiler *pComp) override
void Value(const T &rStruct)
Definition: StdCompiler.h:161
C4Fixed ftofix(float x)
Definition: C4Real.h:258
int32_t GetSize() const
Definition: C4ValueArray.h:36
bool Execute() override
void CompileFunc(StdCompiler *pComp) override
bool Execute() override
virtual bool isDeserializer()
Definition: StdCompiler.h:53
C4Object * Object(C4PropList *_this)
Definition: C4AulDefFunc.h:34
void CompileFunc(StdCompiler *pComp) override
const C4Value C4VNull
Definition: C4Value.cpp:30
C4Real fix_r
Definition: C4Object.h:125
int32_t Phase
Definition: C4Object.h:85
void CompileFunc(StdCompiler *pComp) override
void CompileFunc(StdCompiler *pComp) override
C4AnimationEnding
bool Execute() override
bool Execute() override
C4Object * Object
Definition: C4Menu.h:77
C4ValueProviderConst()=default
int32_t GetPropertyInt(C4PropertyName k, int32_t default_val=0) const
Definition: C4PropList.cpp:886
bool Execute() override
const StdMeshAnimation * GetAnimation() const
Definition: StdMesh.h:350
void CompileFunc(StdCompiler *pComp) override
void CompileFunc(StdCompiler *pComp) override
T Abs(T val)
Definition: Standard.h:42
C4Real Sin(const C4Real &fAngle)
Definition: C4Real.h:265
C4Action Action
Definition: C4Object.h:147
void CompileFunc(StdCompiler *pComp) override
bool Execute() override
float Length
Definition: StdMesh.h:98
int fixtoi(const C4Fixed &x)
Definition: C4Real.h:259
C4Real xdir
Definition: C4Object.h:126
void CompileFunc(StdCompiler *pComp) override
bool Execute() override
C4Real Cos(const C4Real &fAngle)
Definition: C4Real.h:266
C4Real ydir
Definition: C4Object.h:126
void CompileFunc(C4Real &rValue, StdCompiler *pComp)
Definition: C4Real.cpp:9033
void CompileFunc(StdCompiler *pComp) override
void CompileFunc(StdCompiler *pComp) override
StdStrBuf FormatString(const char *szFmt,...)
Definition: StdBuf.cpp:270