138 lines
3.4 KiB
C++
138 lines
3.4 KiB
C++
#pragma once
|
|
|
|
#include <extra2d/act/act.h>
|
|
#include <extra2d/node/node.h>
|
|
#include <vector>
|
|
#include <initializer_list>
|
|
|
|
namespace extra2d {
|
|
|
|
class Delay : public ActInterval {
|
|
public:
|
|
explicit Delay(f32 d) : ActInterval(d) {}
|
|
|
|
void update(f32 t) override {}
|
|
Act* clone() const override { return new Delay(dur_); }
|
|
Act* reverse() const override { return clone(); }
|
|
};
|
|
|
|
class Seq : public ActInterval {
|
|
public:
|
|
Seq(Act* a1, Act* a2);
|
|
|
|
template<typename... As>
|
|
static Seq* create(As... as) {
|
|
std::initializer_list<Act*> acts = {static_cast<Act*>(as)...};
|
|
return createFromArray(acts);
|
|
}
|
|
|
|
void start(Node* t) override;
|
|
void stop() override;
|
|
void step(f32 dt) override;
|
|
void update(f32 t) override {}
|
|
bool done() const override;
|
|
Act* clone() const override;
|
|
Act* reverse() const override;
|
|
|
|
private:
|
|
std::vector<Act*> acts_;
|
|
size_t curIdx_ = 0;
|
|
f32 split_ = 0.0f;
|
|
|
|
static Seq* createFromArray(std::initializer_list<Act*> acts);
|
|
};
|
|
|
|
class Spawn : public ActInterval {
|
|
public:
|
|
Spawn(Act* a1, Act* a2);
|
|
|
|
template<typename... As>
|
|
static Spawn* create(As... as) {
|
|
std::initializer_list<Act*> acts = {static_cast<Act*>(as)...};
|
|
return createFromArray(acts);
|
|
}
|
|
|
|
void start(Node* t) override;
|
|
void stop() override;
|
|
void step(f32 dt) override;
|
|
void update(f32 t) override;
|
|
Act* clone() const override;
|
|
Act* reverse() const override;
|
|
|
|
private:
|
|
std::vector<Act*> acts_;
|
|
|
|
static Spawn* createFromArray(std::initializer_list<Act*> acts);
|
|
};
|
|
|
|
class Repeat : public ActInterval {
|
|
public:
|
|
Repeat(Act* a, int times);
|
|
explicit Repeat(Act* a);
|
|
|
|
bool done() const override;
|
|
void start(Node* t) override;
|
|
void stop() override;
|
|
void step(f32 dt) override;
|
|
void update(f32 t) override;
|
|
Act* clone() const override;
|
|
Act* reverse() const override;
|
|
|
|
Act* inner() const { return inner_; }
|
|
|
|
private:
|
|
Act* inner_ = nullptr;
|
|
int times_ = 1;
|
|
int cnt_ = 0;
|
|
bool inf_ = false;
|
|
};
|
|
|
|
class RepeatForever : public Act {
|
|
public:
|
|
explicit RepeatForever(Act* a) : inner_(a) {
|
|
if (auto* interval = dynamic_cast<ActInterval*>(a)) {
|
|
dur_ = interval->dur();
|
|
}
|
|
}
|
|
|
|
bool done() const override { return false; }
|
|
void start(Node* t) override;
|
|
void step(f32 dt) override;
|
|
void update(f32 t) override {}
|
|
Act* clone() const override { return new RepeatForever(inner_->clone()); }
|
|
Act* reverse() const override { return new RepeatForever(inner_->reverse()); }
|
|
|
|
private:
|
|
Act* inner_ = nullptr;
|
|
f32 dur_ = 0.0f;
|
|
f32 elap_ = 0.0f;
|
|
};
|
|
|
|
class Speed : public ActInterval {
|
|
public:
|
|
Speed(Act* a, f32 s) : ActInterval(0), inner_(a), speed_(s) {
|
|
if (a) {
|
|
if (auto* interval = dynamic_cast<ActInterval*>(a)) {
|
|
dur_ = interval->dur() / s;
|
|
}
|
|
}
|
|
}
|
|
|
|
void start(Node* t) override;
|
|
void stop() override;
|
|
void step(f32 dt) override;
|
|
bool done() const override { return inner_ ? inner_->done() : true; }
|
|
void update(f32 t) override {}
|
|
Act* clone() const override { return new Speed(inner_->clone(), speed_); }
|
|
Act* reverse() const override { return new Speed(inner_->reverse(), speed_); }
|
|
|
|
void speed(f32 s) { speed_ = s; }
|
|
f32 speed() const { return speed_; }
|
|
|
|
private:
|
|
Act* inner_ = nullptr;
|
|
f32 speed_ = 1.0f;
|
|
};
|
|
|
|
}
|