MKCommon.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/RenderAPI/Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
 
#define CE_MK_SAFE_CAST
 
#define CE_MK_POOLED(T)                                            \
    using Allocator = VKObjectAllocator;                           \
    [[nodiscard]] static Allocator& getAllocator() noexcept;       \
    [[nodiscard]] static void* operator new(size_t size) noexcept; \
    static void operator delete(void* p, std::size_t size) noexcept;
 
namespace CeresEngine {
 
#define CE_MK_RENDER_API_OBJECT_FORWARD(N) \
    class MK##N;                           \
    using MK##N##Ptr = RC<MK##N>;
    CE_RENDER_API_OBJECT_EACH(CE_MK_RENDER_API_OBJECT_FORWARD);
#undef CE_MK_RENDER_API_OBJECT_FORWARD
 
    template<typename ChildTypeName, typename ParentType = void> class MKObject {
    public:
        [[nodiscard]] static RC<ChildTypeName> cast(const RC<ParentType>& ptr) {
#if defined(CE_MK_SAFE_CAST)
            return RC<ChildTypeName>(static_cast<ChildTypeName*>(ptr.get()));
#else
            return safeCast<ChildTypeName>(ptr);
#endif
        }
 
        [[nodiscard]] static RC<ChildTypeName> safeCast(const RC<ParentType>& ptr) {
            return RC<ChildTypeName>(dynamic_cast<ChildTypeName*>(ptr.get()));
        }
 
        [[nodiscard]] static ChildTypeName& cast(ParentType& object) {
#if defined(CE_MK_SAFE_CAST)
            return static_cast<ChildTypeName&>(object);
#else
            return dynamic_cast<ChildTypeName&>(object);
#endif
        }
 
        [[nodiscard]] static const ChildTypeName& cast(const ParentType& object) {
#if defined(CE_MK_SAFE_CAST)
            return static_cast<const ChildTypeName&>(object);
#else
            return dynamic_cast<const ChildTypeName&>(object);
#endif
        }
 
        [[nodiscard]] static ChildTypeName* cast(ParentType* object) {
#if defined(CE_MK_SAFE_CAST)
            return static_cast<ChildTypeName*>(object);
#else
            return safeCast<ChildTypeName*>(object);
#endif
        }
 
        [[nodiscard]] static const ChildTypeName* cast(const ParentType* object) {
#if defined(CE_MK_SAFE_CAST)
            return static_cast<const ChildTypeName*>(object);
#else
            return safeCast<const ChildTypeName*>(object);
#endif
        }
 
        [[nodiscard]] static ChildTypeName* safeCast(ParentType* object) { return dynamic_cast<ChildTypeName*>(object); }
 
        [[nodiscard]] static const ChildTypeName* safeCast(const ParentType* object) { return dynamic_cast<const ChildTypeName*>(object); }
    };
 
    template<typename ChildTypeName> class MKObject<ChildTypeName, void> {};
 
    template<typename ChildTypeName, typename ParentType = void> class MKDeviceObject : public MKObject<ChildTypeName, ParentType> {
    protected:
        MKDevice& deviceMK;
 
    protected:
        explicit MKDeviceObject(MKDevicePtr device) : deviceMK(*device) {}
    };
 
    [[noreturn]] void MKNotImplemented();
 
#if defined(__OBJC__)
    [[nodiscard]] NSString* MKString(const String& string);
    [[nodiscard]] NSString* MKString(const StringView& string);
 
    [[nodiscard]] MKLResourceOptions MKResourceOptions(const GPUMemoryProperties& memoryProperty);
    [[nodiscard]] MKLViewport MKViewport(const Viewport& viewport);
    [[nodiscard]] MKLScissorRect MKScissorRect(const Scissor& scissor);
#endif
 
} // namespace CeresEngine