MotionTypes.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/Result.h"
 
#include <cstddef>
#include <cstdint>
 
namespace eve::animation {
 
struct MotionHandle {
    std::uint32_t index      = 0;
    std::uint32_t generation = 0;
 
    [[nodiscard]] constexpr bool isNull() const noexcept { return generation == 0; }
 
    [[nodiscard]] constexpr bool operator==(const MotionHandle &other) const noexcept {
        return index == other.index && generation == other.generation;
    }
 
    [[nodiscard]] constexpr bool operator!=(const MotionHandle &other) const noexcept {
        return !(*this == other);
    }
};
 
struct MotionVec2 {
    float x = 0.f;
    float y = 0.f;
};
 
struct MotionVec3 {
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
};
 
struct MotionColor {
    float r = 0.f;
    float g = 0.f;
    float b = 0.f;
    float a = 1.f;
};
 
struct MotionQuat {
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
    float w = 1.f;
};
 
enum class MotionLoopMode : std::uint8_t {
    Restart = 0,  
    Yoyo    = 1,  
};
 
enum class MotionStyle : std::uint8_t {
    Tween = 0,  
    Punch = 1,  
    Shake = 2,  
};
 
class IMotionFloatSink {
public:
    static constexpr const char *capabilityName = "IMotionFloatSink";
 
    virtual ~IMotionFloatSink() = default;
 
    [[nodiscard]] virtual eve::Result<void> write(float value) = 0;
};
 
class IMotionVec2Sink {
public:
    static constexpr const char *capabilityName = "IMotionVec2Sink";
 
    virtual ~IMotionVec2Sink() = default;
 
    [[nodiscard]] virtual eve::Result<void> write(MotionVec2 value) = 0;
};
 
class IMotionVec3Sink {
public:
    static constexpr const char *capabilityName = "IMotionVec3Sink";
 
    virtual ~IMotionVec3Sink() = default;
 
    [[nodiscard]] virtual eve::Result<void> write(MotionVec3 value) = 0;
};
 
class IMotionColorSink {
public:
    static constexpr const char *capabilityName = "IMotionColorSink";
 
    virtual ~IMotionColorSink() = default;
 
    [[nodiscard]] virtual eve::Result<void> write(MotionColor value) = 0;
};
 
class IMotionQuatSink {
public:
    static constexpr const char *capabilityName = "IMotionQuatSink";
 
    virtual ~IMotionQuatSink() = default;
 
    [[nodiscard]] virtual eve::Result<void> write(MotionQuat value) = 0;
};
 
class EVENGINE_API_WORLD FloatPointerSink final : public IMotionFloatSink {
public:
    explicit FloatPointerSink(float *target) : target_(target) {}
 
    [[nodiscard]] eve::Result<void> write(float value) override;
 
private:
    float *target_ = nullptr;
};
 
class EVENGINE_API_WORLD FloatBufferSink final : public IMotionFloatSink {
public:
    FloatBufferSink(float *buffer, std::size_t index) : buffer_(buffer), index_(index) {}
 
    [[nodiscard]] eve::Result<void> write(float value) override;
 
private:
    float       *buffer_ = nullptr;
    std::size_t  index_  = 0;
};
 
 
class EVENGINE_API_WORLD Vec2PointerSink final : public IMotionVec2Sink {
public:
    Vec2PointerSink(float *x, float *y) : x_(x), y_(y) {}
 
    [[nodiscard]] eve::Result<void> write(MotionVec2 value) override;
 
private:
    float *x_ = nullptr;
    float *y_ = nullptr;
};
 
class Vec3PointerSink final : public IMotionVec3Sink {
public:
    Vec3PointerSink(float *x, float *y, float *z) : x_(x), y_(y), z_(z) {}
 
    [[nodiscard]] eve::Result<void> write(MotionVec3 value) override;
 
private:
    float *x_ = nullptr;
    float *y_ = nullptr;
    float *z_ = nullptr;
};
 
class EVENGINE_API_WORLD ColorPointerSink final : public IMotionColorSink {
public:
    ColorPointerSink(float *r, float *g, float *b, float *a) : r_(r), g_(g), b_(b), a_(a) {}
 
    [[nodiscard]] eve::Result<void> write(MotionColor value) override;
 
private:
    float *r_ = nullptr;
    float *g_ = nullptr;
    float *b_ = nullptr;
    float *a_ = nullptr;
};
 
class EVENGINE_API_WORLD QuatPointerSink final : public IMotionQuatSink {
public:
    QuatPointerSink(float *x, float *y, float *z, float *w) : x_(x), y_(y), z_(z), w_(w) {}
 
    [[nodiscard]] eve::Result<void> write(MotionQuat value) override;
 
private:
    float *x_ = nullptr;
    float *y_ = nullptr;
    float *z_ = nullptr;
    float *w_ = nullptr;
};
 
[[nodiscard]] EVENGINE_API_WORLD float evaluateMotionEase(float t, const char *kind);
 
[[nodiscard]] EVENGINE_API_WORLD float evaluateMotionOscillation(float t, int frequency, float dampingRatio);
 
[[nodiscard]] EVENGINE_API_WORLD float evaluateMotionShakeSign(std::uint32_t seed, int frequency, float t, int axis);
 
[[nodiscard]] MotionColor lerpMotionColor(MotionColor a, MotionColor b, float t);
 
[[nodiscard]] MotionQuat slerpMotionQuat(MotionQuat a, MotionQuat b, float t);
 
}  // namespace eve::animation