mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 08:00:42 +00:00
Thirteen files declared their own typedefs for the engine's anchor
functions:
- SetPoint (FUN_REGION_SET_POINT 0x00767C70) in 11 files;
- ClearAllPoints (FUN_LAYOUT_CLEAR_ALL_POINTS 0x00767620) in 3;
- the point-name converters (FUN_STRING_TO_FRAME_POINT 0x006F1840,
FUN_FRAME_POINT_TO_STRING 0x006F1890) in 6.
Five places read an anchor slot by hand: the node at
OFF_REGION_ANCHOR_ARRAY, its relative through vtable +0x0C, and the
point and offsets. Points.cpp's ShiftPoints also read the relative point
from nodes with no relative. Those nodes are 12 bytes {vtable, x, y} and
have no such field.
Frame::Layout now has SetPoint, ClearAllPoints, StringToPoint,
PointToString, PointNode and GetPoint, taking the object like its other
calls. SetPoint's relative is a layout sub-object, as the engine stores
it, and its last argument is the engine's resize flag (benilla-re
ui/anchors). GetPoint reads the relative point only when the node has a
relative.
915 lines
32 KiB
C++
915 lines
32 KiB
C++
// This file is part of ClassicAPI.
|
|
//
|
|
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
|
// of the GNU General Public License as published by the Free Software Foundation, either
|
|
// version 3 of the License, or (at your option) any later version.
|
|
//
|
|
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
// PURPOSE. See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License along with
|
|
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
// 4.3.4's CSimpleAnim and its Alpha, Translation, Scale and Rotation
|
|
// subclasses (wowdecomp15595 CSimpleAnim.cpp, CSimple*Anim.cpp and their
|
|
// _Scripts.cpp), on Animation::Object, and the group's CreateAnimation.
|
|
// Path and its control points are in Path.cpp.
|
|
//
|
|
// Later clients' additions, on the same objects:
|
|
// - the target setters (SetTarget, SetTargetName, SetTargetKey,
|
|
// SetChildKey, SetTargetParent, GetTarget);
|
|
// - Alpha's fromAlpha / toAlpha. Blizzard's own code starts a fade from
|
|
// the region's current alpha with SetFromAlpha(region:GetAlpha()), and
|
|
// its XML fades in with toAlpha="1" alone, so the alpha is absolute (the
|
|
// target's alpha becomes from + (to - from) x progress) and an unset
|
|
// fromAlpha is 0. SetChange goes back to 4.3.4's relative change;
|
|
// - Scale's SetScaleFrom / SetScaleTo. 4.3.4's scale is the case from = 1,
|
|
// and SetScale sets the end, so its old results do not change.
|
|
|
|
#include "animation/Classes.h"
|
|
#include "animation/Region.h"
|
|
#include "animation/Xml.h"
|
|
|
|
#include "Game.h"
|
|
#include "Offsets.h"
|
|
#include "baselib/Ascii.h"
|
|
#include "frame/Layout.h"
|
|
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <string>
|
|
|
|
namespace Animation {
|
|
|
|
namespace {
|
|
|
|
const char *const kAnimScripts[] = {"onload", "onplay", "onpause", "onstop", "onfinished", "onupdate"};
|
|
|
|
Class &ClassOf(AnimKind kind) {
|
|
switch (kind) {
|
|
case KIND_ALPHA: return Anim::s_alphaClass;
|
|
case KIND_TRANSLATION: return Anim::s_translationClass;
|
|
case KIND_SCALE: return Anim::s_scaleClass;
|
|
case KIND_ROTATION: return Anim::s_rotationClass;
|
|
case KIND_PATH: return Anim::s_pathClass;
|
|
default: return Anim::s_class;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
AnimKind Anim::KindOf(const char *typeName) {
|
|
if (typeName == nullptr || *typeName == '\0')
|
|
return KIND_ANIMATION;
|
|
if (Ascii::EqualCI(typeName, "Alpha"))
|
|
return KIND_ALPHA;
|
|
if (Ascii::EqualCI(typeName, "Translation"))
|
|
return KIND_TRANSLATION;
|
|
if (Ascii::EqualCI(typeName, "Scale"))
|
|
return KIND_SCALE;
|
|
if (Ascii::EqualCI(typeName, "Rotation"))
|
|
return KIND_ROTATION;
|
|
if (Ascii::EqualCI(typeName, "Path"))
|
|
return KIND_PATH;
|
|
return KIND_ANIMATION;
|
|
}
|
|
|
|
// ---- Construction ---------------------------------------------------------------
|
|
|
|
// 4.3.4's constructor links the animation into the group's list; it joins an
|
|
// order list only once it has an order (NotifyAnimAdded, SortAnimations).
|
|
Anim::Anim(Group *group, AnimKind kind, const char *name) : Object(ClassOf(kind), group, name), kind(kind) {
|
|
if (group != nullptr)
|
|
group->animations.push_back(this);
|
|
}
|
|
|
|
// ~CSimplePathAnim: a path's control points go with it.
|
|
Anim::~Anim() {
|
|
for (ControlPoint *point : controlPoints)
|
|
delete point;
|
|
}
|
|
|
|
// ---- Playback --------------------------------------------------------------------
|
|
|
|
void Anim::ResolveTarget() {
|
|
if (!targetKey.empty())
|
|
target = Region::FindRegionByKey(this, targetKey.c_str());
|
|
else if (targetName[0] != '\0')
|
|
target = Region::FindRegionByName(targetName);
|
|
}
|
|
|
|
bool Anim::Play() {
|
|
ResolveTarget();
|
|
if (playState != 1) {
|
|
playState = 1;
|
|
RunScript(A_ONPLAY, 0);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void Anim::Pause() {
|
|
GetGroup()->Pause();
|
|
if (playState == 1) {
|
|
playState = 2;
|
|
RunScript(A_ONPAUSE, 0);
|
|
}
|
|
}
|
|
|
|
void Anim::Stop(bool requested) {
|
|
if (playState == 0)
|
|
return;
|
|
loopState = STATE_NONE;
|
|
playState = 0;
|
|
elapsed = 0.0f;
|
|
progressWithDelay = 0.0f;
|
|
progress = 0.0f;
|
|
if (HasScript(A_ONSTOP)) {
|
|
Game::Lua::PushBool(Game::Lua::State(), requested);
|
|
RunScript(A_ONSTOP, 1);
|
|
}
|
|
}
|
|
|
|
bool Anim::IsDelaying() const {
|
|
if (progressWithDelay <= 0.0f || progressWithDelay >= 1.0f)
|
|
return false;
|
|
const float total = endDelay + duration + startDelay;
|
|
if (std::fabs(total) < 0.00000023841858f)
|
|
return false;
|
|
if (loopState == STATE_REVERSE) {
|
|
if (endDelay > elapsed)
|
|
return true;
|
|
if (endDelay + duration > elapsed)
|
|
return false;
|
|
} else {
|
|
if (startDelay > elapsed)
|
|
return true;
|
|
if (duration + startDelay > elapsed)
|
|
return false;
|
|
}
|
|
return total > elapsed;
|
|
}
|
|
|
|
float Anim::UpdateProgress(float elapsedSec) {
|
|
const float prevElapsed = elapsed;
|
|
elapsed += elapsedSec;
|
|
const float total = orderPadding + startDelay + endDelay + duration;
|
|
float now;
|
|
if (total > elapsed) {
|
|
now = elapsed;
|
|
progressWithDelay = now / total;
|
|
if (progressWithDelay > 1.0f)
|
|
progressWithDelay = 1.0f;
|
|
if (std::fabs(duration) < 0.00000023841858f) {
|
|
progress = 1.0f;
|
|
} else {
|
|
frameElapsed += elapsedSec;
|
|
if ((GetGroup()->flags & GROUP_IGNORE_THROTTLE) || frameElapsed >= g_frameInterval) {
|
|
const float delay = loopState == STATE_REVERSE ? orderPadding + endDelay : startDelay;
|
|
progress = (now - delay) / duration;
|
|
if (progress < 0.0f)
|
|
progress = 0.0f;
|
|
else if (progress >= 1.0f)
|
|
progress = 1.0f;
|
|
frameElapsed = 0.0f;
|
|
}
|
|
}
|
|
} else {
|
|
now = total;
|
|
progressWithDelay = 1.0f;
|
|
progress = 1.0f;
|
|
}
|
|
float p = loopState == STATE_REVERSE ? 1.0f - progress : progress;
|
|
if (hasSmoother) {
|
|
// CSimpleAnimSCurveSmoother::GetSmoothProgress.
|
|
if (std::fabs(smoothIn) >= 0.001f && std::fabs(smoothOut) >= 0.001f)
|
|
p = 0.5f - std::cos(p * 3.1415927f) * 0.5f;
|
|
else if (std::fabs(smoothIn) >= 0.001f)
|
|
p = 1.0f - std::cos(p * 1.5707964f);
|
|
else if (std::fabs(smoothOut) >= 0.001f)
|
|
p = std::cos((p + 1.0f) * 1.5707964f) * -1.0f;
|
|
}
|
|
smoothProgress = p;
|
|
return now - prevElapsed;
|
|
}
|
|
|
|
bool Anim::OnUpdate(float elapsedSec, float &consumed) {
|
|
consumed = 0.0f;
|
|
if (progressWithDelay >= 1.0f) {
|
|
Apply(smoothProgress);
|
|
return true;
|
|
}
|
|
if (playState == 0)
|
|
return true;
|
|
if (playState == 2) {
|
|
Apply(smoothProgress);
|
|
return false;
|
|
}
|
|
consumed = UpdateProgress(elapsedSec);
|
|
if (HasScript(A_ONUPDATE)) {
|
|
Game::Lua::PushNumber(Game::Lua::State(), elapsedSec);
|
|
RunScript(A_ONUPDATE, 1);
|
|
}
|
|
Apply(smoothProgress);
|
|
if (progressWithDelay < 1.0f)
|
|
return false;
|
|
RunScript(A_ONFINISHED, 0);
|
|
return true;
|
|
}
|
|
|
|
void Anim::Apply(float p) {
|
|
void *region = GetRegionParent();
|
|
if (region == nullptr)
|
|
return;
|
|
switch (kind) {
|
|
case KIND_ALPHA:
|
|
if (alphaFromTo)
|
|
Region::SetAnimAlpha(region, target, static_cast<uint8_t>((fromAlpha + (toAlpha - fromAlpha) * p) * 255.0f));
|
|
else
|
|
Region::AddAnimAlpha(region, target, static_cast<int16_t>(change * p));
|
|
break;
|
|
case KIND_TRANSLATION:
|
|
Region::AddAnimTranslation(region, target, offsetX * p, offsetY * p);
|
|
break;
|
|
case KIND_SCALE: {
|
|
// AddAnimScale takes the share of the way to the origin, 1 - scale.
|
|
const float x = scaleFromX + (scaleToX - scaleFromX) * p;
|
|
const float y = scaleFromY + (scaleToY - scaleFromY) * p;
|
|
Region::AddAnimScale(region, target, originPoint, originX, originY, 1.0f - x, 1.0f - y);
|
|
break;
|
|
}
|
|
case KIND_ROTATION:
|
|
Region::AddAnimRotation(region, target, originPoint, originX, originY, radians * p);
|
|
break;
|
|
case KIND_PATH:
|
|
ApplyPath(p);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ---- Settings ----------------------------------------------------------------------
|
|
|
|
void Anim::SetStartDelay(float delay, bool notify) {
|
|
startDelay = delay < 0.0f ? 0.0f : delay;
|
|
if (notify && parent != nullptr)
|
|
GetGroup()->ComputeDuration();
|
|
}
|
|
|
|
void Anim::SetEndDelay(float delay, bool notify) {
|
|
endDelay = delay < 0.0f ? 0.0f : delay;
|
|
if (notify && parent != nullptr)
|
|
GetGroup()->ComputeDuration();
|
|
}
|
|
|
|
void Anim::SetDuration(float value, bool notify) {
|
|
duration = value;
|
|
if (notify && parent != nullptr)
|
|
GetGroup()->ComputeDuration();
|
|
}
|
|
|
|
void Anim::SetOrder(int value, bool notify, bool wrap) {
|
|
const int oldOrder = order;
|
|
if (wrap)
|
|
order = value < 0 || value > 99 ? 0 : value;
|
|
else
|
|
order = value < 0 ? 0 : (value > 99 ? 99 : value);
|
|
// 4.3.4 compares the old order with the argument, not the clamped value.
|
|
if (notify && parent != nullptr && oldOrder != value)
|
|
GetGroup()->NotifyOrderChanged(this, oldOrder);
|
|
}
|
|
|
|
void Anim::SetSmoothing(float in, float out) {
|
|
if ((in > 0.0f && in <= 1.0f) || (out > 0.0f && out <= 1.0f)) {
|
|
hasSmoother = true;
|
|
smoothIn = in < 0.0f ? 0.0f : (in < 1.0f ? in : 1.0f);
|
|
smoothOut = out < 0.0f ? 0.0f : (out < 1.0f ? out : 1.0f);
|
|
}
|
|
}
|
|
|
|
bool Anim::GetSmoothing(float &in, float &out) const {
|
|
in = hasSmoother ? smoothIn : 0.0f;
|
|
out = hasSmoother ? smoothOut : 0.0f;
|
|
return hasSmoother;
|
|
}
|
|
|
|
bool Anim::ChangeParent(Group *group) {
|
|
if (group == nullptr || parent == group)
|
|
return false;
|
|
GetGroup()->NotifyAnimRemoved(this);
|
|
parent = group;
|
|
group->NotifyAnimAdded(this);
|
|
return true;
|
|
}
|
|
|
|
void Anim::PostLoadXML() {
|
|
flags &= ~1;
|
|
if (kind == KIND_PATH) {
|
|
// CSimplePathAnim::PostLoadXML: the points' orders and positions.
|
|
BuildSpline();
|
|
UpdateControlPointPositions();
|
|
}
|
|
RunScript(A_ONLOAD, 0);
|
|
}
|
|
|
|
// ---- Lua methods ----------------------------------------------------------------------
|
|
|
|
namespace {
|
|
|
|
|
|
Anim *Self(void *L) { return static_cast<Anim *>(Resolve(L, 1, Anim::s_class)); }
|
|
Anim *SelfOf(void *L, Class &cls) { return static_cast<Anim *>(Resolve(L, 1, cls)); }
|
|
|
|
// Usage error when argument `idx` isn't a number; the number otherwise.
|
|
bool NumberArg(void *L, int idx, Anim *anim, const char *usage) {
|
|
if (Game::Lua::IsNumber(L, idx))
|
|
return true;
|
|
Game::Lua::Error(L, usage, anim->DisplayName());
|
|
return false;
|
|
}
|
|
|
|
int __fastcall Script_Play(void *L) {
|
|
if (Anim *a = Self(L))
|
|
a->Play();
|
|
return 0;
|
|
}
|
|
int __fastcall Script_Pause(void *L) {
|
|
if (Anim *a = Self(L))
|
|
a->Pause();
|
|
return 0;
|
|
}
|
|
int __fastcall Script_Stop(void *L) {
|
|
if (Anim *a = Self(L))
|
|
a->Stop(true);
|
|
return 0;
|
|
}
|
|
|
|
template <typename Fn> int PushBoolOf(void *L, Fn fn) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushBool(L, fn(a));
|
|
return 1;
|
|
}
|
|
template <typename Fn> int PushNumberOf(void *L, Fn fn) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, fn(a));
|
|
return 1;
|
|
}
|
|
|
|
int __fastcall Script_IsDone(void *L) { return PushBoolOf(L, [](Anim *a) { return a->progressWithDelay >= 1.0f; }); }
|
|
int __fastcall Script_IsPlaying(void *L) { return PushBoolOf(L, [](Anim *a) { return a->playState == 1; }); }
|
|
int __fastcall Script_IsPaused(void *L) { return PushBoolOf(L, [](Anim *a) { return a->playState == 2; }); }
|
|
int __fastcall Script_IsStopped(void *L) { return PushBoolOf(L, [](Anim *a) { return a->playState == 0; }); }
|
|
int __fastcall Script_IsDelaying(void *L) { return PushBoolOf(L, [](Anim *a) { return a->IsDelaying(); }); }
|
|
int __fastcall Script_GetElapsed(void *L) { return PushNumberOf(L, [](Anim *a) { return a->elapsed; }); }
|
|
int __fastcall Script_GetStartDelay(void *L) { return PushNumberOf(L, [](Anim *a) { return a->startDelay; }); }
|
|
int __fastcall Script_GetEndDelay(void *L) { return PushNumberOf(L, [](Anim *a) { return a->endDelay; }); }
|
|
int __fastcall Script_GetDuration(void *L) { return PushNumberOf(L, [](Anim *a) { return a->duration; }); }
|
|
int __fastcall Script_GetSmoothProgress(void *L) {
|
|
return PushNumberOf(L, [](Anim *a) { return a->smoothProgress; });
|
|
}
|
|
int __fastcall Script_GetProgress(void *L) { return PushNumberOf(L, [](Anim *a) { return a->progress; }); }
|
|
int __fastcall Script_GetProgressWithDelay(void *L) {
|
|
return PushNumberOf(L, [](Anim *a) { return a->progressWithDelay; });
|
|
}
|
|
int __fastcall Script_GetOrder(void *L) {
|
|
return PushNumberOf(L, [](Anim *a) { return static_cast<double>(a->order + 1); });
|
|
}
|
|
|
|
int __fastcall Script_SetStartDelay(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a != nullptr && NumberArg(L, 2, a, "Usage: %s:SetStartDelay(delaySec)"))
|
|
a->SetStartDelay(static_cast<float>(Game::Lua::ToNumber(L, 2)), true);
|
|
return 0;
|
|
}
|
|
int __fastcall Script_SetEndDelay(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a != nullptr && NumberArg(L, 2, a, "Usage: %s:SetEndDelay(delaySec)"))
|
|
a->SetEndDelay(static_cast<float>(Game::Lua::ToNumber(L, 2)), true);
|
|
return 0;
|
|
}
|
|
int __fastcall Script_SetDuration(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a != nullptr && NumberArg(L, 2, a, "Usage: %s:SetDuration(durationSec)"))
|
|
a->SetDuration(static_cast<float>(Game::Lua::ToNumber(L, 2)), true);
|
|
return 0;
|
|
}
|
|
int __fastcall Script_SetSmoothProgress(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a != nullptr && NumberArg(L, 2, a, "Usage: %s:SetSmoothProgress(smoothProgress)"))
|
|
a->smoothProgress = static_cast<float>(Game::Lua::ToNumber(L, 2));
|
|
return 0;
|
|
}
|
|
int __fastcall Script_SetOrder(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a != nullptr && NumberArg(L, 2, a, "Usage: %s:SetOrder(order)"))
|
|
a->SetOrder(static_cast<int>(Game::Lua::ToNumber(L, 2)) - 1, true, false);
|
|
return 0;
|
|
}
|
|
int __fastcall Script_SetSmoothing(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
if (!Game::Lua::IsString(L, 2)) {
|
|
Game::Lua::Error(L, "Usage: %s:SetSmoothing(\"smoothingType\")", a->DisplayName());
|
|
return 0;
|
|
}
|
|
float in, out;
|
|
if (StringToSmoothWeights(Game::Lua::ToString(L, 2), in, out)) {
|
|
a->SetSmoothing(in, out);
|
|
return 0;
|
|
}
|
|
Game::Lua::Error(L, "%s:SetSmoothing(): Unknown smoothing type specified", a->DisplayName());
|
|
return 0;
|
|
}
|
|
int __fastcall Script_GetSmoothing(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
float in, out;
|
|
a->GetSmoothing(in, out);
|
|
Game::Lua::PushString(L, SmoothWeightsToString(in, out));
|
|
return 1;
|
|
}
|
|
|
|
int __fastcall Script_SetParent(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
if (Game::Lua::Type(L, 2) == Game::Lua::TYPE_NIL) {
|
|
Game::Lua::Error(L, "%s:SetParent(): Cannot set a 'nil' parent for animations", a->DisplayName());
|
|
return 0;
|
|
}
|
|
Group *group = nullptr;
|
|
if (Game::Lua::IsString(L, 2)) {
|
|
// CScriptObject::GetScriptObjectByName(name, AnimationGroup).
|
|
Game::Lua::PushString(L, Game::Lua::ToString(L, 2));
|
|
Game::Lua::RawGet(L, Game::Lua::GLOBALS_INDEX);
|
|
void *object = Game::Lua::Type(L, -1) == Game::Lua::TYPE_TABLE ? Game::Lua::ResolveObject(L, -1) : nullptr;
|
|
Game::Lua::SetTop(L, -2);
|
|
if (object != nullptr && IsOurs(object) &&
|
|
Game::Lua::IsA(object, reinterpret_cast<uintptr_t>(&Group::s_class.typeId)))
|
|
group = static_cast<Group *>(object);
|
|
} else if (Game::Lua::Type(L, 2) == Game::Lua::TYPE_TABLE) {
|
|
void *object = Game::Lua::ResolveObject(L, 2);
|
|
if (object == nullptr) {
|
|
Game::Lua::Error(L, "%s:SetParent(): Couldn't find 'this' in parent object", a->DisplayName());
|
|
return 0;
|
|
}
|
|
if (!IsOurs(object) || !Game::Lua::IsA(object, reinterpret_cast<uintptr_t>(&Group::s_class.typeId))) {
|
|
Game::Lua::Error(L, "%s:SetParent(): Wrong parent object type, expected AnimationGroup", a->DisplayName());
|
|
return 0;
|
|
}
|
|
group = static_cast<Group *>(object);
|
|
}
|
|
if (group == nullptr) {
|
|
Game::Lua::Error(L, "%s:SetParent(): Couldn't find animation group named '%s'", a->DisplayName(),
|
|
Game::Lua::IsString(L, 2) ? Game::Lua::ToString(L, 2) : "");
|
|
return 0;
|
|
}
|
|
const int oldOrder = a->order;
|
|
if (Game::Lua::IsNumber(L, 3)) {
|
|
a->SetOrder(static_cast<int>(Game::Lua::ToNumber(L, 3)) - 1, false, false);
|
|
} else {
|
|
int value = a->order;
|
|
if (value == -1)
|
|
value = group->GetMaxAnimOrder() + 1;
|
|
a->SetOrder(value, false, true);
|
|
}
|
|
if (!a->ChangeParent(group) && oldOrder != a->order)
|
|
group->NotifyOrderChanged(a, oldOrder);
|
|
return 0;
|
|
}
|
|
|
|
int __fastcall Script_GetRegionParent(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
void *region = a->GetRegionParent();
|
|
if (region != nullptr)
|
|
Game::Lua::PushObject(L, region);
|
|
else
|
|
Game::Lua::PushNil(L);
|
|
return 1;
|
|
}
|
|
|
|
// ---- Target (later clients) ----
|
|
//
|
|
// An animation with no target animates its group's region. Each setter
|
|
// replaces the others' target and returns whether it names a region now;
|
|
// a name or key is looked up again on Play, as 4.3.4 looks up `target`.
|
|
|
|
int PushTargetFound(void *L, const Anim *a) {
|
|
Game::Lua::PushBool(L, a->target != nullptr);
|
|
return 1;
|
|
}
|
|
|
|
void *RegionArg(void *L, int idx) {
|
|
if (Game::Lua::Type(L, idx) != Game::Lua::TYPE_TABLE)
|
|
return nullptr;
|
|
void *object = Game::Lua::ResolveObject(L, idx);
|
|
if (object == nullptr || IsOurs(object) || !Game::Lua::IsA(object, Offsets::VAR_REGION_LUA_TYPE_ID))
|
|
return nullptr;
|
|
return object;
|
|
}
|
|
|
|
const char *StringArg(void *L, Anim *a, const char *usage) {
|
|
if (Game::Lua::IsString(L, 2))
|
|
return Game::Lua::ToString(L, 2);
|
|
Game::Lua::Error(L, usage, a->DisplayName());
|
|
return nullptr;
|
|
}
|
|
|
|
int __fastcall Script_SetTarget(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
void *region = RegionArg(L, 2);
|
|
if (region == nullptr) {
|
|
Game::Lua::PushBool(L, false);
|
|
return 1;
|
|
}
|
|
a->targetName[0] = '\0';
|
|
a->targetKey.clear();
|
|
a->target = region;
|
|
return PushTargetFound(L, a);
|
|
}
|
|
int __fastcall Script_SetTargetName(void *L) {
|
|
Anim *a = Self(L);
|
|
const char *name = a != nullptr ? StringArg(L, a, "Usage: %s:SetTargetName(name)") : nullptr;
|
|
if (name == nullptr)
|
|
return 0;
|
|
std::snprintf(a->targetName, sizeof(a->targetName), "%s", CreateName(name, a).c_str());
|
|
a->targetKey.clear();
|
|
a->target = nullptr;
|
|
a->ResolveTarget();
|
|
return PushTargetFound(L, a);
|
|
}
|
|
int __fastcall Script_SetTargetKey(void *L) {
|
|
Anim *a = Self(L);
|
|
const char *key = a != nullptr ? StringArg(L, a, "Usage: %s:SetTargetKey(key)") : nullptr;
|
|
if (key == nullptr)
|
|
return 0;
|
|
a->targetName[0] = '\0';
|
|
a->targetKey = key;
|
|
a->target = nullptr;
|
|
a->ResolveTarget();
|
|
return PushTargetFound(L, a);
|
|
}
|
|
int __fastcall Script_SetChildKey(void *L) {
|
|
Anim *a = Self(L);
|
|
const char *key = a != nullptr ? StringArg(L, a, "Usage: %s:SetChildKey(childKey)") : nullptr;
|
|
if (key == nullptr)
|
|
return 0;
|
|
a->targetName[0] = '\0';
|
|
a->targetKey = std::string("$parent.$parent.") + key;
|
|
a->target = nullptr;
|
|
a->ResolveTarget();
|
|
return PushTargetFound(L, a);
|
|
}
|
|
int __fastcall Script_SetTargetParent(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
a->targetName[0] = '\0';
|
|
a->targetKey.clear();
|
|
a->target = a->GetRegionParent();
|
|
return PushTargetFound(L, a);
|
|
}
|
|
int __fastcall Script_GetTarget(void *L) {
|
|
Anim *a = Self(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
void *region = a->target != nullptr ? a->target : a->GetRegionParent();
|
|
if (region != nullptr)
|
|
Game::Lua::PushObject(L, region);
|
|
else
|
|
Game::Lua::PushNil(L);
|
|
return 1;
|
|
}
|
|
|
|
// ---- Alpha ----
|
|
|
|
int __fastcall Script_SetChange(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_alphaClass);
|
|
if (a == nullptr || !NumberArg(L, 2, a, "Usage: %s:SetChange(change)"))
|
|
return 0;
|
|
// CSimpleAlphaAnim::SetChange.
|
|
const float change = static_cast<float>(Game::Lua::ToNumber(L, 2));
|
|
const float value = change < -1.0f ? -1.0f : (change >= 1.0f ? 1.0f : change);
|
|
a->change = static_cast<int16_t>(value * 255.0f);
|
|
a->alphaFromTo = false;
|
|
return 0;
|
|
}
|
|
int __fastcall Script_GetChange(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_alphaClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, a->change * (1.0f / 255.0f));
|
|
return 1;
|
|
}
|
|
|
|
// Later clients' absolute alpha. Setting either end turns it on; the other
|
|
// end keeps its value, 0 until set.
|
|
void SetAlphaEnd(void *L, float Anim::*end, const char *usage) {
|
|
Anim *a = SelfOf(L, Anim::s_alphaClass);
|
|
if (a == nullptr || !NumberArg(L, 2, a, usage))
|
|
return;
|
|
const float value = static_cast<float>(Game::Lua::ToNumber(L, 2));
|
|
a->*end = value < 0.0f ? 0.0f : (value > 1.0f ? 1.0f : value);
|
|
a->alphaFromTo = true;
|
|
}
|
|
int __fastcall Script_SetFromAlpha(void *L) {
|
|
SetAlphaEnd(L, &Anim::fromAlpha, "Usage: %s:SetFromAlpha(alpha)");
|
|
return 0;
|
|
}
|
|
int __fastcall Script_SetToAlpha(void *L) {
|
|
SetAlphaEnd(L, &Anim::toAlpha, "Usage: %s:SetToAlpha(alpha)");
|
|
return 0;
|
|
}
|
|
int __fastcall Script_GetFromAlpha(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_alphaClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, a->fromAlpha);
|
|
return 1;
|
|
}
|
|
int __fastcall Script_GetToAlpha(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_alphaClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, a->toAlpha);
|
|
return 1;
|
|
}
|
|
|
|
// ---- Translation ----
|
|
|
|
int __fastcall Script_SetOffset(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_translationClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
if (!Game::Lua::IsNumber(L, 2) || !Game::Lua::IsNumber(L, 3)) {
|
|
Game::Lua::Error(L, "Usage: %s:SetOffset(x, y)", a->DisplayName());
|
|
return 0;
|
|
}
|
|
const float x = Game::PixelToInternal(static_cast<float>(Game::Lua::ToNumber(L, 2)));
|
|
const float y = Game::PixelToInternal(static_cast<float>(Game::Lua::ToNumber(L, 3)));
|
|
// CSimpleTranslationAnim::SetOffset: a near-zero offset is zero.
|
|
if (x * x + y * y <= 0.00000023841858f) {
|
|
a->offsetX = 0.0f;
|
|
a->offsetY = 0.0f;
|
|
} else {
|
|
a->offsetX = x;
|
|
a->offsetY = y;
|
|
}
|
|
return 0;
|
|
}
|
|
int __fastcall Script_GetOffset(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_translationClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, Game::InternalToPixel(a->offsetX));
|
|
Game::Lua::PushNumber(L, Game::InternalToPixel(a->offsetY));
|
|
return 2;
|
|
}
|
|
|
|
// ---- Scale and Rotation origin (ReadOrigin) ----
|
|
|
|
Anim *OriginSelf(void *L) {
|
|
Anim *a = static_cast<Anim *>(Resolve(L, 1, Anim::s_class));
|
|
if (a != nullptr && a->kind != KIND_SCALE && a->kind != KIND_ROTATION) {
|
|
// The type test of 4.3.4's Scale / Rotation SetOrigin.
|
|
Game::Lua::Error(L, "Wrong object type for member function");
|
|
return nullptr;
|
|
}
|
|
return a;
|
|
}
|
|
int __fastcall Script_SetOrigin(void *L) {
|
|
Anim *a = OriginSelf(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
if (!Game::Lua::IsString(L, 2) || !Game::Lua::IsNumber(L, 3) || !Game::Lua::IsNumber(L, 4)) {
|
|
Game::Lua::Error(L, "Usage: %s:SetOrigin(point, offsetX, offsetY)", a->DisplayName());
|
|
return 0;
|
|
}
|
|
int point = Offsets::FRAMEPOINT_CENTER;
|
|
if (!Frame::Layout::StringToPoint(Game::Lua::ToString(L, 2), &point))
|
|
point = Offsets::FRAMEPOINT_CENTER;
|
|
a->originPoint = point;
|
|
a->originX = Game::PixelToInternal(static_cast<float>(Game::Lua::ToNumber(L, 3)));
|
|
a->originY = Game::PixelToInternal(static_cast<float>(Game::Lua::ToNumber(L, 4)));
|
|
return 0;
|
|
}
|
|
// 4.3.4 pushes the stored offsets as they are, in layout units.
|
|
int __fastcall Script_GetOrigin(void *L) {
|
|
Anim *a = OriginSelf(L);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushString(L, Frame::Layout::PointToString(a->originPoint));
|
|
Game::Lua::PushNumber(L, a->originX);
|
|
Game::Lua::PushNumber(L, a->originY);
|
|
return 3;
|
|
}
|
|
|
|
// ---- Scale ----
|
|
|
|
int __fastcall Script_SetScale(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_scaleClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
if (!Game::Lua::IsNumber(L, 2) || !Game::Lua::IsNumber(L, 3)) {
|
|
Game::Lua::Error(L, "Usage: %s:SetScale(x, y)", a->DisplayName());
|
|
return 0;
|
|
}
|
|
// CSimpleScaleAnim::SetScale: the scale it ends on.
|
|
const float x = static_cast<float>(Game::Lua::ToNumber(L, 2));
|
|
const float y = static_cast<float>(Game::Lua::ToNumber(L, 3));
|
|
a->scaleToX = x >= 0.001f ? x : 0.001f;
|
|
a->scaleToY = y >= 0.001f ? y : 0.001f;
|
|
return 0;
|
|
}
|
|
int __fastcall Script_GetScale(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_scaleClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, a->scaleToX);
|
|
Game::Lua::PushNumber(L, a->scaleToY);
|
|
return 2;
|
|
}
|
|
|
|
// Later clients' SetScaleFrom / SetScaleTo: the scale the animation starts
|
|
// and ends on, as given.
|
|
void SetScaleEnd(void *L, float Anim::*x, float Anim::*y, const char *usage) {
|
|
Anim *a = SelfOf(L, Anim::s_scaleClass);
|
|
if (a == nullptr)
|
|
return;
|
|
if (!Game::Lua::IsNumber(L, 2) || !Game::Lua::IsNumber(L, 3)) {
|
|
Game::Lua::Error(L, usage, a->DisplayName());
|
|
return;
|
|
}
|
|
a->*x = static_cast<float>(Game::Lua::ToNumber(L, 2));
|
|
a->*y = static_cast<float>(Game::Lua::ToNumber(L, 3));
|
|
}
|
|
int __fastcall Script_SetScaleFrom(void *L) {
|
|
SetScaleEnd(L, &Anim::scaleFromX, &Anim::scaleFromY, "Usage: %s:SetScaleFrom(x, y)");
|
|
return 0;
|
|
}
|
|
int __fastcall Script_SetScaleTo(void *L) {
|
|
SetScaleEnd(L, &Anim::scaleToX, &Anim::scaleToY, "Usage: %s:SetScaleTo(x, y)");
|
|
return 0;
|
|
}
|
|
int __fastcall Script_GetScaleFrom(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_scaleClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, a->scaleFromX);
|
|
Game::Lua::PushNumber(L, a->scaleFromY);
|
|
return 2;
|
|
}
|
|
int __fastcall Script_GetScaleTo(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_scaleClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, a->scaleToX);
|
|
Game::Lua::PushNumber(L, a->scaleToY);
|
|
return 2;
|
|
}
|
|
|
|
// ---- Rotation ----
|
|
|
|
int __fastcall Script_SetDegrees(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_rotationClass);
|
|
if (a != nullptr && NumberArg(L, 2, a, "Usage: %s:SetDegrees(degrees)"))
|
|
a->radians = static_cast<float>(Game::Lua::ToNumber(L, 2) * 0.017453292f);
|
|
return 0;
|
|
}
|
|
int __fastcall Script_GetDegrees(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_rotationClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, a->radians * 57.29578f);
|
|
return 1;
|
|
}
|
|
int __fastcall Script_SetRadians(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_rotationClass);
|
|
if (a != nullptr && NumberArg(L, 2, a, "Usage: %s:SetRadians(radians)"))
|
|
a->radians = static_cast<float>(Game::Lua::ToNumber(L, 2));
|
|
return 0;
|
|
}
|
|
int __fastcall Script_GetRadians(void *L) {
|
|
Anim *a = SelfOf(L, Anim::s_rotationClass);
|
|
if (a == nullptr)
|
|
return 0;
|
|
Game::Lua::PushNumber(L, a->radians);
|
|
return 1;
|
|
}
|
|
|
|
const Game::Lua::FrameMethodEntry kAnimMethods[] = {
|
|
{"GetObjectType", &Script_GetObjectType},
|
|
{"IsObjectType", &Script_IsObjectType},
|
|
{"GetName", &Script_GetName},
|
|
{"GetParent", &Script_GetParent},
|
|
{"Play", &Script_Play},
|
|
{"Pause", &Script_Pause},
|
|
{"Stop", &Script_Stop},
|
|
{"IsDone", &Script_IsDone},
|
|
{"IsPlaying", &Script_IsPlaying},
|
|
{"IsPaused", &Script_IsPaused},
|
|
{"IsStopped", &Script_IsStopped},
|
|
{"IsDelaying", &Script_IsDelaying},
|
|
{"GetElapsed", &Script_GetElapsed},
|
|
{"SetStartDelay", &Script_SetStartDelay},
|
|
{"GetStartDelay", &Script_GetStartDelay},
|
|
{"SetEndDelay", &Script_SetEndDelay},
|
|
{"GetEndDelay", &Script_GetEndDelay},
|
|
{"SetDuration", &Script_SetDuration},
|
|
{"GetDuration", &Script_GetDuration},
|
|
{"GetSmoothProgress", &Script_GetSmoothProgress},
|
|
{"SetSmoothProgress", &Script_SetSmoothProgress},
|
|
{"GetProgress", &Script_GetProgress},
|
|
{"GetProgressWithDelay", &Script_GetProgressWithDelay},
|
|
{"SetOrder", &Script_SetOrder},
|
|
{"GetOrder", &Script_GetOrder},
|
|
{"SetSmoothing", &Script_SetSmoothing},
|
|
{"GetSmoothing", &Script_GetSmoothing},
|
|
{"SetParent", &Script_SetParent},
|
|
{"GetRegionParent", &Script_GetRegionParent},
|
|
{"SetTarget", &Script_SetTarget},
|
|
{"SetTargetName", &Script_SetTargetName},
|
|
{"SetTargetKey", &Script_SetTargetKey},
|
|
{"SetChildKey", &Script_SetChildKey},
|
|
{"SetTargetParent", &Script_SetTargetParent},
|
|
{"GetTarget", &Script_GetTarget},
|
|
{"HasScript", &Script_HasScript},
|
|
{"GetScript", &Script_GetScript},
|
|
{"SetScript", &Script_SetScript},
|
|
{"HookScript", &Script_HookScript},
|
|
};
|
|
const Game::Lua::FrameMethodEntry kAlphaMethods[] = {
|
|
{"SetChange", &Script_SetChange}, {"GetChange", &Script_GetChange},
|
|
{"SetFromAlpha", &Script_SetFromAlpha}, {"GetFromAlpha", &Script_GetFromAlpha},
|
|
{"SetToAlpha", &Script_SetToAlpha}, {"GetToAlpha", &Script_GetToAlpha},
|
|
};
|
|
const Game::Lua::FrameMethodEntry kTranslationMethods[] = {
|
|
{"SetOffset", &Script_SetOffset},
|
|
{"GetOffset", &Script_GetOffset},
|
|
};
|
|
const Game::Lua::FrameMethodEntry kScaleMethods[] = {
|
|
{"SetOrigin", &Script_SetOrigin}, {"GetOrigin", &Script_GetOrigin},
|
|
{"SetScale", &Script_SetScale}, {"GetScale", &Script_GetScale},
|
|
{"SetScaleFrom", &Script_SetScaleFrom}, {"GetScaleFrom", &Script_GetScaleFrom},
|
|
{"SetScaleTo", &Script_SetScaleTo}, {"GetScaleTo", &Script_GetScaleTo},
|
|
};
|
|
const Game::Lua::FrameMethodEntry kRotationMethods[] = {
|
|
{"SetOrigin", &Script_SetOrigin}, {"GetOrigin", &Script_GetOrigin}, {"SetDegrees", &Script_SetDegrees},
|
|
{"GetDegrees", &Script_GetDegrees}, {"SetRadians", &Script_SetRadians}, {"GetRadians", &Script_GetRadians},
|
|
};
|
|
|
|
template <size_t N> constexpr int Count(const Game::Lua::FrameMethodEntry (&)[N]) { return static_cast<int>(N); }
|
|
|
|
} // namespace
|
|
|
|
Class Anim::s_class{"Animation", nullptr, kAnimScripts, 6, kAnimMethods, Count(kAnimMethods), 0, 0};
|
|
Class Anim::s_alphaClass{"Alpha", &Anim::s_class, nullptr, 0, kAlphaMethods, Count(kAlphaMethods), 0, 0};
|
|
Class Anim::s_translationClass{"Translation", &Anim::s_class, nullptr, 0, kTranslationMethods,
|
|
Count(kTranslationMethods), 0, 0};
|
|
Class Anim::s_scaleClass{"Scale", &Anim::s_class, nullptr, 0, kScaleMethods, Count(kScaleMethods), 0, 0};
|
|
Class Anim::s_rotationClass{"Rotation", &Anim::s_class, nullptr, 0, kRotationMethods, Count(kRotationMethods), 0, 0};
|
|
|
|
// ---- AnimationGroup:CreateAnimation ------------------------------------------------------
|
|
|
|
int __fastcall Script_CreateAnimation(void *L) {
|
|
Group *group = static_cast<Group *>(Resolve(L, 1, Group::s_class));
|
|
if (group == nullptr)
|
|
return 0;
|
|
const char *type = Game::Lua::IsString(L, 2) ? Game::Lua::ToString(L, 2) : "Animation";
|
|
const char *name = Game::Lua::IsString(L, 3) ? Game::Lua::ToString(L, 3) : nullptr;
|
|
const void *templateNode = nullptr;
|
|
if (Game::Lua::Type(L, 4) == Game::Lua::TYPE_STRING) {
|
|
const char *inherits = Game::Lua::ToString(L, 4);
|
|
templateNode = Xml::Template(inherits);
|
|
if (templateNode == nullptr) {
|
|
Game::Lua::Error(L, "%s:CreateAnimation(): Couldn't find inherited node \"%s\"", group->DisplayName(),
|
|
inherits);
|
|
return 0;
|
|
}
|
|
}
|
|
Anim *anim = new Anim(group, Anim::KindOf(type), name);
|
|
if (templateNode != nullptr) {
|
|
Xml::LoadAnim(anim, templateNode, nullptr);
|
|
anim->PostLoadXML();
|
|
}
|
|
if (anim->order == -1)
|
|
anim->SetOrder(group->GetMaxAnimOrder(), false, true);
|
|
group->NotifyAnimAdded(anim);
|
|
Push(L, anim);
|
|
return 1;
|
|
}
|
|
|
|
} // namespace Animation
|