NLCommon.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_NL_SAFE_CAST
 
#define CE_NL_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_NL_RENDER_API_OBJECT_FORWARD(N) \
    class NL##N;                           \
    using NL##N##Ptr = RC<NL##N>;
    CE_RENDER_API_OBJECT_EACH(CE_NL_RENDER_API_OBJECT_FORWARD);
#undef CE_NL_RENDER_API_OBJECT_FORWARD
 
    template<typename ChildTypeName, typename ParentType = void> class NLObject {
    public:
        [[nodiscard]] static RC<ChildTypeName> cast(const RC<ParentType>& ptr) {
#if defined(CE_NL_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_NL_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_NL_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_NL_SAFE_CAST)
            return static_cast<ChildTypeName*>(object);
#else
            return safeCast<ChildTypeName*>(object);
#endif
        }
 
        [[nodiscard]] static const ChildTypeName* cast(const ParentType* object) {
#if defined(CE_NL_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 NLObject<ChildTypeName, void> {};
 
    template<typename ChildTypeName, typename ParentType = void> class NLDeviceObject : public NLObject<ChildTypeName, ParentType> {
    protected:
        NLDevice& deviceNL;
 
    protected:
        explicit NLDeviceObject(NLDevicePtr device) : deviceNL(*device) {}
    };
 
#if defined(__OBJC__)
    [[nodiscard]] NSString* NLString(const String& string);
    [[nodiscard]] NSString* NLString(const StringView& string);
 
    [[nodiscard]] NLLResourceOptions NLResourceOptions(const GPUMemoryProperties& memoryProperty);
    [[nodiscard]] NLLViewport NLViewport(const Viewport& viewport);
    [[nodiscard]] NLLScissorRect NLScissorRect(const Scissor& scissor);
#endif
 
} // namespace CeresEngine