mirror of
https://github.com/godotengine/godot.git
synced 2026-02-08 03:38:29 +00:00
284 lines
10 KiB
C++
284 lines
10 KiB
C++
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
//
|
|
// Metal/MTL4CommandQueue.hpp
|
|
//
|
|
// Copyright 2020-2025 Apple Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include "../Foundation/Foundation.hpp"
|
|
#include "MTL4CommitFeedback.hpp"
|
|
#include "MTLDefines.hpp"
|
|
#include "MTLHeaderBridge.hpp"
|
|
#include "MTLPrivate.hpp"
|
|
#include "MTLResourceStateCommandEncoder.hpp"
|
|
#include "MTLTypes.hpp"
|
|
#include <cstdint>
|
|
#include <dispatch/dispatch.h>
|
|
|
|
namespace MTL
|
|
{
|
|
class Buffer;
|
|
class Device;
|
|
class Drawable;
|
|
class Event;
|
|
class Heap;
|
|
class ResidencySet;
|
|
class Texture;
|
|
}
|
|
|
|
namespace MTL4
|
|
{
|
|
class CommandBuffer;
|
|
class CommandQueueDescriptor;
|
|
class CommitOptions;
|
|
struct CopySparseBufferMappingOperation;
|
|
struct CopySparseTextureMappingOperation;
|
|
struct UpdateSparseBufferMappingOperation;
|
|
struct UpdateSparseTextureMappingOperation;
|
|
_MTL_ENUM(NS::Integer, CommandQueueError) {
|
|
CommandQueueErrorNone = 0,
|
|
CommandQueueErrorTimeout = 1,
|
|
CommandQueueErrorNotPermitted = 2,
|
|
CommandQueueErrorOutOfMemory = 3,
|
|
CommandQueueErrorDeviceRemoved = 4,
|
|
CommandQueueErrorAccessRevoked = 5,
|
|
CommandQueueErrorInternal = 6,
|
|
};
|
|
|
|
struct UpdateSparseTextureMappingOperation
|
|
{
|
|
MTL::SparseTextureMappingMode mode;
|
|
MTL::Region textureRegion;
|
|
NS::UInteger textureLevel;
|
|
NS::UInteger textureSlice;
|
|
NS::UInteger heapOffset;
|
|
} _MTL_PACKED;
|
|
|
|
struct CopySparseTextureMappingOperation
|
|
{
|
|
MTL::Region sourceRegion;
|
|
NS::UInteger sourceLevel;
|
|
NS::UInteger sourceSlice;
|
|
MTL::Origin destinationOrigin;
|
|
NS::UInteger destinationLevel;
|
|
NS::UInteger destinationSlice;
|
|
} _MTL_PACKED;
|
|
|
|
struct UpdateSparseBufferMappingOperation
|
|
{
|
|
MTL::SparseTextureMappingMode mode;
|
|
NS::Range bufferRange;
|
|
NS::UInteger heapOffset;
|
|
} _MTL_PACKED;
|
|
|
|
struct CopySparseBufferMappingOperation
|
|
{
|
|
NS::Range sourceRange;
|
|
NS::UInteger destinationOffset;
|
|
} _MTL_PACKED;
|
|
|
|
class CommitOptions : public NS::Referencing<CommitOptions>
|
|
{
|
|
public:
|
|
void addFeedbackHandler(const MTL4::CommitFeedbackHandler block);
|
|
void addFeedbackHandler(const MTL4::CommitFeedbackHandlerFunction& function);
|
|
|
|
static CommitOptions* alloc();
|
|
|
|
CommitOptions* init();
|
|
};
|
|
class CommandQueueDescriptor : public NS::Copying<CommandQueueDescriptor>
|
|
{
|
|
public:
|
|
static CommandQueueDescriptor* alloc();
|
|
|
|
dispatch_queue_t feedbackQueue() const;
|
|
|
|
CommandQueueDescriptor* init();
|
|
|
|
NS::String* label() const;
|
|
|
|
void setFeedbackQueue(const dispatch_queue_t feedbackQueue);
|
|
|
|
void setLabel(const NS::String* label);
|
|
};
|
|
class CommandQueue : public NS::Referencing<CommandQueue>
|
|
{
|
|
public:
|
|
void addResidencySet(const MTL::ResidencySet* residencySet);
|
|
void addResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count);
|
|
|
|
void commit(const MTL4::CommandBuffer* const commandBuffers[], NS::UInteger count);
|
|
void commit(const MTL4::CommandBuffer* const commandBuffers[], NS::UInteger count, const MTL4::CommitOptions* options);
|
|
|
|
void copyBufferMappingsFromBuffer(const MTL::Buffer* sourceBuffer, const MTL::Buffer* destinationBuffer, const MTL4::CopySparseBufferMappingOperation* operations, NS::UInteger count);
|
|
|
|
void copyTextureMappingsFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture, const MTL4::CopySparseTextureMappingOperation* operations, NS::UInteger count);
|
|
|
|
MTL::Device* device() const;
|
|
|
|
NS::String* label() const;
|
|
|
|
void removeResidencySet(const MTL::ResidencySet* residencySet);
|
|
void removeResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count);
|
|
|
|
void signalDrawable(const MTL::Drawable* drawable);
|
|
|
|
void signalEvent(const MTL::Event* event, uint64_t value);
|
|
|
|
void updateBufferMappings(const MTL::Buffer* buffer, const MTL::Heap* heap, const MTL4::UpdateSparseBufferMappingOperation* operations, NS::UInteger count);
|
|
|
|
void updateTextureMappings(const MTL::Texture* texture, const MTL::Heap* heap, const MTL4::UpdateSparseTextureMappingOperation* operations, NS::UInteger count);
|
|
|
|
void wait(const MTL::Event* event, uint64_t value);
|
|
void wait(const MTL::Drawable* drawable);
|
|
};
|
|
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommitOptions::addFeedbackHandler(const MTL4::CommitFeedbackHandler block)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addFeedbackHandler_), block);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommitOptions::addFeedbackHandler(const MTL4::CommitFeedbackHandlerFunction& function)
|
|
{
|
|
__block MTL4::CommitFeedbackHandlerFunction blockFunction = function;
|
|
addFeedbackHandler(^(MTL4::CommitFeedback* pFeedback) { blockFunction(pFeedback); });
|
|
}
|
|
|
|
_MTL_INLINE MTL4::CommitOptions* MTL4::CommitOptions::alloc()
|
|
{
|
|
return NS::Object::alloc<MTL4::CommitOptions>(_MTL_PRIVATE_CLS(MTL4CommitOptions));
|
|
}
|
|
|
|
_MTL_INLINE MTL4::CommitOptions* MTL4::CommitOptions::init()
|
|
{
|
|
return NS::Object::init<MTL4::CommitOptions>();
|
|
}
|
|
|
|
_MTL_INLINE MTL4::CommandQueueDescriptor* MTL4::CommandQueueDescriptor::alloc()
|
|
{
|
|
return NS::Object::alloc<MTL4::CommandQueueDescriptor>(_MTL_PRIVATE_CLS(MTL4CommandQueueDescriptor));
|
|
}
|
|
|
|
_MTL_INLINE dispatch_queue_t MTL4::CommandQueueDescriptor::feedbackQueue() const
|
|
{
|
|
return Object::sendMessage<dispatch_queue_t>(this, _MTL_PRIVATE_SEL(feedbackQueue));
|
|
}
|
|
|
|
_MTL_INLINE MTL4::CommandQueueDescriptor* MTL4::CommandQueueDescriptor::init()
|
|
{
|
|
return NS::Object::init<MTL4::CommandQueueDescriptor>();
|
|
}
|
|
|
|
_MTL_INLINE NS::String* MTL4::CommandQueueDescriptor::label() const
|
|
{
|
|
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueueDescriptor::setFeedbackQueue(const dispatch_queue_t feedbackQueue)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFeedbackQueue_), feedbackQueue);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueueDescriptor::setLabel(const NS::String* label)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::addResidencySet(const MTL::ResidencySet* residencySet)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addResidencySet_), residencySet);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::addResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addResidencySets_count_), residencySets, count);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::commit(const MTL4::CommandBuffer* const commandBuffers[], NS::UInteger count)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(commit_count_), commandBuffers, count);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::commit(const MTL4::CommandBuffer* const commandBuffers[], NS::UInteger count, const MTL4::CommitOptions* options)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(commit_count_options_), commandBuffers, count, options);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::copyBufferMappingsFromBuffer(const MTL::Buffer* sourceBuffer, const MTL::Buffer* destinationBuffer, const MTL4::CopySparseBufferMappingOperation* operations, NS::UInteger count)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyBufferMappingsFromBuffer_toBuffer_operations_count_), sourceBuffer, destinationBuffer, operations, count);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::copyTextureMappingsFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture, const MTL4::CopySparseTextureMappingOperation* operations, NS::UInteger count)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyTextureMappingsFromTexture_toTexture_operations_count_), sourceTexture, destinationTexture, operations, count);
|
|
}
|
|
|
|
_MTL_INLINE MTL::Device* MTL4::CommandQueue::device() const
|
|
{
|
|
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
|
}
|
|
|
|
_MTL_INLINE NS::String* MTL4::CommandQueue::label() const
|
|
{
|
|
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::removeResidencySet(const MTL::ResidencySet* residencySet)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(removeResidencySet_), residencySet);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::removeResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(removeResidencySets_count_), residencySets, count);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::signalDrawable(const MTL::Drawable* drawable)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(signalDrawable_), drawable);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::signalEvent(const MTL::Event* event, uint64_t value)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(signalEvent_value_), event, value);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::updateBufferMappings(const MTL::Buffer* buffer, const MTL::Heap* heap, const MTL4::UpdateSparseBufferMappingOperation* operations, NS::UInteger count)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateBufferMappings_heap_operations_count_), buffer, heap, operations, count);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::updateTextureMappings(const MTL::Texture* texture, const MTL::Heap* heap, const MTL4::UpdateSparseTextureMappingOperation* operations, NS::UInteger count)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateTextureMappings_heap_operations_count_), texture, heap, operations, count);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::wait(const MTL::Event* event, uint64_t value)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForEvent_value_), event, value);
|
|
}
|
|
|
|
_MTL_INLINE void MTL4::CommandQueue::wait(const MTL::Drawable* drawable)
|
|
{
|
|
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForDrawable_), drawable);
|
|
}
|