abs_scene.hpp

浏览该文件的文档.

 
#pragma once
#include <xcal/public.h>
 
#include <memory>
#include <type_traits>
#include <vector>
#include <xcal/animation/core/abs_animation.hpp>
#include <xcal/animation/core/timeline.hpp>
#include <xcal/camera/core/abs_camera.hpp>
#include <xcal/mobject/core/abs_mobject.hpp>
 
namespace xcal::scene {
 
template <typename ObjectPtr = mobject::AbsMObject_ptr>
class XCAL_API AbsScene {
   private:
    using object_t = ObjectPtr::element_type;  
    std::vector<ObjectPtr> mobjects_{};        
    std::vector<std::unique_ptr<camera::AbsCamera>> cameras_{};  
    std::vector<std::unique_ptr<animation::AbsAnimation>>
        animations_{};  
    std::vector<std::unique_ptr<animation::Timeline>>
        timelines_{};  
 
   public:
    AbsScene() {};
    AbsScene(const AbsScene&) = delete;
    AbsScene& operator=(const AbsScene&) = delete;
 
    template <typename T, class... Args>
    T* add(Args&&... args) {
        if constexpr (std::is_base_of_v<animation::Timeline, T>)
            return (T*)timelines_.emplace_back(std::make_unique<T>(args...))
                .get();
        else if constexpr (std::is_base_of_v<animation::AbsAnimation, T>)
            return (T*)animations_.emplace_back(std::make_unique<T>(args...))
                .get();
        else if constexpr (std::is_base_of_v<mobject::AbsMObject, T>)
            return (T*)mobjects_.emplace_back(std::make_unique<T>(args...))
                .get();
        else if constexpr (std::is_base_of_v<camera::AbsCamera, T>)
            return (T*)cameras_.emplace_back(std::make_unique<T>(args...))
                .get();
        else
            static_assert(false, "unsupported type");
    }
    template <typename T>
    T* add(std::unique_ptr<T>&& obj) {
        if constexpr (std::is_base_of_v<object_t, T>)
            return (T*)mobjects_.emplace_back(std::move(obj)).get();
        else if constexpr (std::is_base_of_v<camera::AbsCamera, T>)
            return (T*)cameras_.emplace_back(std::move(obj)).get();
        else if constexpr (std::is_base_of_v<animation::AbsAnimation, T>)
            return (T*)animations_.emplace_back(std::move(obj)).get();
        else if constexpr (std::is_base_of_v<animation::Timeline, T>)
            return (T*)timelines_.emplace_back(std::move(obj)).get();
        else
            static_assert(false, "unsupported type");
    }
    template <typename T>
    T* add(T* obj) {
        if constexpr (std::is_base_of_v<object_t, T>)
            return (T*)mobjects_.emplace_back(obj).get();
        else if constexpr (std::is_base_of_v<camera::AbsCamera, T>)
            return (T*)cameras_.emplace_back(obj).get();
        else if constexpr (std::is_base_of_v<animation::AbsAnimation, T>)
            return (T*)animations_.emplace_back(obj).get();
        else if constexpr (std::is_base_of_v<animation::Timeline, T>)
            return (T*)timelines_.emplace_back(obj).get();
        else
            static_assert(false, "unsupported type");
    }
    template <typename T>
    T* add(T&& obj) {
        if constexpr (std::is_base_of_v<object_t, T>)
            return (T*)mobjects_.emplace_back(std::move(obj)).get();
        else if constexpr (std::is_base_of_v<camera::AbsCamera, T>)
            return (T*)cameras_.emplace_back(std::move(obj)).get();
        else if constexpr (std::is_base_of_v<animation::AbsAnimation, T>)
            return (T*)animations_.emplace_back(std::move(obj)).get();
        else if constexpr (std::is_base_of_v<animation::Timeline, T>)
            return (T*)timelines_.emplace_back(std::move(obj)).get();
        else
            static_assert(false, "unsupported type");
    }
 
    std::vector<ObjectPtr>& mobjects() { return mobjects_; }
    std::vector<std::unique_ptr<camera::AbsCamera>>& cameras() {
        return cameras_;
    }
    std::vector<std::unique_ptr<animation::Timeline>>& timelines() {
        return timelines_;
    }
    std::vector<std::unique_ptr<animation::AbsAnimation>>& animations() {
        return animations_;
    }
 
    const std::vector<ObjectPtr>& mobjects() const { return mobjects_; }
    const std::vector<std::unique_ptr<camera::AbsCamera>>& cameras() const {
        return cameras_;
    }
    const std::vector<std::unique_ptr<animation::AbsAnimation>>& animations()
        const {
        return animations_;
    }
 
   public:
    virtual ~AbsScene() = default;
};
 
}  // namespace xcal::scene