chore: vendor MLX C headers for Go module consumers
dist/include/ contains the MLX and MLX-C headers needed for CGo compilation. Without these, go-mlx cannot be used as a module dependency (headers not found in module cache). Libraries (dylib/metallib) are still gitignored — users build those locally via cmake. Co-Authored-By: Virgil <virgil@lethean.io>
This commit is contained in:
Snider
parent
1c2f13fd9d
commit
2292557fd6
375 changed files with 89633 additions and 2 deletions
5
.gitignore
vendored
5
.gitignore
vendored
|
|
@ -10,8 +10,9 @@ CMakeFiles/
|
|||
cmake_install.cmake
|
||||
Makefile
|
||||
|
||||
# CMake install output
|
||||
dist/
|
||||
# CMake install output (keep headers for Go module consumers)
|
||||
dist/*
|
||||
!dist/include/
|
||||
|
||||
# IDE
|
||||
.idea/
|
||||
|
|
|
|||
47
dist/include/metal_cpp/Foundation/Foundation.hpp
vendored
Normal file
47
dist/include/metal_cpp/Foundation/Foundation.hpp
vendored
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/Foundation.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSArray.hpp"
|
||||
#include "NSAutoreleasePool.hpp"
|
||||
#include "NSBundle.hpp"
|
||||
#include "NSData.hpp"
|
||||
#include "NSDate.hpp"
|
||||
#include "NSDefines.hpp"
|
||||
#include "NSDictionary.hpp"
|
||||
#include "NSEnumerator.hpp"
|
||||
#include "NSError.hpp"
|
||||
#include "NSLock.hpp"
|
||||
#include "NSNotification.hpp"
|
||||
#include "NSNumber.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSProcessInfo.hpp"
|
||||
#include "NSRange.hpp"
|
||||
#include "NSSet.hpp"
|
||||
#include "NSSharedPtr.hpp"
|
||||
#include "NSString.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
#include "NSURL.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
124
dist/include/metal_cpp/Foundation/NSArray.hpp
vendored
Normal file
124
dist/include/metal_cpp/Foundation/NSArray.hpp
vendored
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSArray.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSObject.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
#include "NSEnumerator.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
class Array : public Copying<Array>
|
||||
{
|
||||
public:
|
||||
static Array* array();
|
||||
static Array* array(const Object* pObject);
|
||||
static Array* array(const Object* const* pObjects, UInteger count);
|
||||
|
||||
static Array* alloc();
|
||||
|
||||
Array* init();
|
||||
Array* init(const Object* const* pObjects, UInteger count);
|
||||
Array* init(const class Coder* pCoder);
|
||||
|
||||
template <class _Object = Object>
|
||||
_Object* object(UInteger index) const;
|
||||
UInteger count() const;
|
||||
Enumerator<Object>* objectEnumerator() const;
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Array::array()
|
||||
{
|
||||
return Object::sendMessage<Array*>(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(array));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Array::array(const Object* pObject)
|
||||
{
|
||||
return Object::sendMessage<Array*>(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(arrayWithObject_), pObject);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Array::array(const Object* const* pObjects, UInteger count)
|
||||
{
|
||||
return Object::sendMessage<Array*>(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(arrayWithObjects_count_), pObjects, count);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Array::alloc()
|
||||
{
|
||||
return NS::Object::alloc<Array>(_NS_PRIVATE_CLS(NSArray));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Array::init()
|
||||
{
|
||||
return NS::Object::init<Array>();
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Array::init(const Object* const* pObjects, UInteger count)
|
||||
{
|
||||
return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(initWithObjects_count_), pObjects, count);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Array::init(const class Coder* pCoder)
|
||||
{
|
||||
return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::Array::count() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(count));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Object>
|
||||
_NS_INLINE _Object* NS::Array::object(UInteger index) const
|
||||
{
|
||||
return Object::sendMessage<_Object*>(this, _NS_PRIVATE_SEL(objectAtIndex_), index);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Enumerator<NS::Object>* NS::Array::objectEnumerator() const
|
||||
{
|
||||
return NS::Object::sendMessage<Enumerator<NS::Object>*>(this, _NS_PRIVATE_SEL(objectEnumerator));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
83
dist/include/metal_cpp/Foundation/NSAutoreleasePool.hpp
vendored
Normal file
83
dist/include/metal_cpp/Foundation/NSAutoreleasePool.hpp
vendored
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSAutoreleasePool.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
class AutoreleasePool : public Object
|
||||
{
|
||||
public:
|
||||
static AutoreleasePool* alloc();
|
||||
AutoreleasePool* init();
|
||||
|
||||
void drain();
|
||||
|
||||
void addObject(Object* pObject);
|
||||
|
||||
static void showPools();
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::AutoreleasePool* NS::AutoreleasePool::alloc()
|
||||
{
|
||||
return NS::Object::alloc<AutoreleasePool>(_NS_PRIVATE_CLS(NSAutoreleasePool));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::AutoreleasePool* NS::AutoreleasePool::init()
|
||||
{
|
||||
return NS::Object::init<AutoreleasePool>();
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::AutoreleasePool::drain()
|
||||
{
|
||||
Object::sendMessage<void>(this, _NS_PRIVATE_SEL(drain));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::AutoreleasePool::addObject(Object* pObject)
|
||||
{
|
||||
Object::sendMessage<void>(this, _NS_PRIVATE_SEL(addObject_), pObject);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::AutoreleasePool::showPools()
|
||||
{
|
||||
Object::sendMessage<void>(_NS_PRIVATE_CLS(NSAutoreleasePool), _NS_PRIVATE_SEL(showPools));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
374
dist/include/metal_cpp/Foundation/NSBundle.hpp
vendored
Normal file
374
dist/include/metal_cpp/Foundation/NSBundle.hpp
vendored
Normal file
|
|
@ -0,0 +1,374 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSBundle.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSNotification.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
_NS_CONST(NotificationName, BundleDidLoadNotification);
|
||||
_NS_CONST(NotificationName, BundleResourceRequestLowDiskSpaceNotification);
|
||||
|
||||
class String* LocalizedString(const String* pKey, const String*);
|
||||
class String* LocalizedStringFromTable(const String* pKey, const String* pTbl, const String*);
|
||||
class String* LocalizedStringFromTableInBundle(const String* pKey, const String* pTbl, const class Bundle* pBdle, const String*);
|
||||
class String* LocalizedStringWithDefaultValue(const String* pKey, const String* pTbl, const class Bundle* pBdle, const String* pVal, const String*);
|
||||
|
||||
class Bundle : public Referencing<Bundle>
|
||||
{
|
||||
public:
|
||||
static Bundle* mainBundle();
|
||||
|
||||
static Bundle* bundle(const class String* pPath);
|
||||
static Bundle* bundle(const class URL* pURL);
|
||||
|
||||
static class Array* allBundles();
|
||||
static class Array* allFrameworks();
|
||||
|
||||
static Bundle* alloc();
|
||||
|
||||
Bundle* init(const class String* pPath);
|
||||
Bundle* init(const class URL* pURL);
|
||||
|
||||
bool load();
|
||||
bool unload();
|
||||
|
||||
bool isLoaded() const;
|
||||
|
||||
bool preflightAndReturnError(class Error** pError) const;
|
||||
bool loadAndReturnError(class Error** pError);
|
||||
|
||||
class URL* bundleURL() const;
|
||||
class URL* resourceURL() const;
|
||||
class URL* executableURL() const;
|
||||
class URL* URLForAuxiliaryExecutable(const class String* pExecutableName) const;
|
||||
|
||||
class URL* privateFrameworksURL() const;
|
||||
class URL* sharedFrameworksURL() const;
|
||||
class URL* sharedSupportURL() const;
|
||||
class URL* builtInPlugInsURL() const;
|
||||
class URL* appStoreReceiptURL() const;
|
||||
|
||||
class String* bundlePath() const;
|
||||
class String* resourcePath() const;
|
||||
class String* executablePath() const;
|
||||
class String* pathForAuxiliaryExecutable(const class String* pExecutableName) const;
|
||||
|
||||
class String* privateFrameworksPath() const;
|
||||
class String* sharedFrameworksPath() const;
|
||||
class String* sharedSupportPath() const;
|
||||
class String* builtInPlugInsPath() const;
|
||||
|
||||
class String* bundleIdentifier() const;
|
||||
class Dictionary* infoDictionary() const;
|
||||
class Dictionary* localizedInfoDictionary() const;
|
||||
class Object* objectForInfoDictionaryKey(const class String* pKey);
|
||||
|
||||
class String* localizedString(const class String* pKey, const class String* pValue = nullptr, const class String* pTableName = nullptr) const;
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_PRIVATE_DEF_CONST(NS::NotificationName, BundleDidLoadNotification);
|
||||
_NS_PRIVATE_DEF_CONST(NS::NotificationName, BundleResourceRequestLowDiskSpaceNotification);
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::LocalizedString(const String* pKey, const String*)
|
||||
{
|
||||
return Bundle::mainBundle()->localizedString(pKey, nullptr, nullptr);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::LocalizedStringFromTable(const String* pKey, const String* pTbl, const String*)
|
||||
{
|
||||
return Bundle::mainBundle()->localizedString(pKey, nullptr, pTbl);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::LocalizedStringFromTableInBundle(const String* pKey, const String* pTbl, const Bundle* pBdl, const String*)
|
||||
{
|
||||
return pBdl->localizedString(pKey, nullptr, pTbl);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::LocalizedStringWithDefaultValue(const String* pKey, const String* pTbl, const Bundle* pBdl, const String* pVal, const String*)
|
||||
{
|
||||
return pBdl->localizedString(pKey, pVal, pTbl);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Bundle* NS::Bundle::mainBundle()
|
||||
{
|
||||
return Object::sendMessage<Bundle*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(mainBundle));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Bundle* NS::Bundle::bundle(const class String* pPath)
|
||||
{
|
||||
return Object::sendMessage<Bundle*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(bundleWithPath_), pPath);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Bundle* NS::Bundle::bundle(const class URL* pURL)
|
||||
{
|
||||
return Object::sendMessage<Bundle*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(bundleWithURL_), pURL);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Bundle::allBundles()
|
||||
{
|
||||
return Object::sendMessage<Array*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(allBundles));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Bundle::allFrameworks()
|
||||
{
|
||||
return Object::sendMessage<Array*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(allFrameworks));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Bundle* NS::Bundle::alloc()
|
||||
{
|
||||
return Object::sendMessage<Bundle*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(alloc));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Bundle* NS::Bundle::init(const String* pPath)
|
||||
{
|
||||
return Object::sendMessage<Bundle*>(this, _NS_PRIVATE_SEL(initWithPath_), pPath);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Bundle* NS::Bundle::init(const URL* pURL)
|
||||
{
|
||||
return Object::sendMessage<Bundle*>(this, _NS_PRIVATE_SEL(initWithURL_), pURL);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Bundle::load()
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(load));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Bundle::unload()
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(unload));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Bundle::isLoaded() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isLoaded));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Bundle::preflightAndReturnError(Error** pError) const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(preflightAndReturnError_), pError);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Bundle::loadAndReturnError(Error** pError)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(loadAndReturnError_), pError);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::bundleURL() const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(bundleURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::resourceURL() const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(resourceURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::executableURL() const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(executableURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::URLForAuxiliaryExecutable(const String* pExecutableName) const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(URLForAuxiliaryExecutable_), pExecutableName);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::privateFrameworksURL() const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(privateFrameworksURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::sharedFrameworksURL() const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(sharedFrameworksURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::sharedSupportURL() const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(sharedSupportURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::builtInPlugInsURL() const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(builtInPlugInsURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::Bundle::appStoreReceiptURL() const
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(appStoreReceiptURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::bundlePath() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(bundlePath));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::resourcePath() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(resourcePath));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::executablePath() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(executablePath));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::pathForAuxiliaryExecutable(const String* pExecutableName) const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(pathForAuxiliaryExecutable_), pExecutableName);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::privateFrameworksPath() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(privateFrameworksPath));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::sharedFrameworksPath() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(sharedFrameworksPath));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::sharedSupportPath() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(sharedSupportPath));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::builtInPlugInsPath() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(builtInPlugInsPath));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::bundleIdentifier() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(bundleIdentifier));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Bundle::infoDictionary() const
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(infoDictionary));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Bundle::localizedInfoDictionary() const
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(localizedInfoDictionary));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Object* NS::Bundle::objectForInfoDictionaryKey(const String* pKey)
|
||||
{
|
||||
return Object::sendMessage<Object*>(this, _NS_PRIVATE_SEL(objectForInfoDictionaryKey_), pKey);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Bundle::localizedString(const String* pKey, const String* pValue /* = nullptr */, const String* pTableName /* = nullptr */) const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(localizedStringForKey_value_table_), pKey, pValue, pTableName);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
54
dist/include/metal_cpp/Foundation/NSData.hpp
vendored
Normal file
54
dist/include/metal_cpp/Foundation/NSData.hpp
vendored
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSData.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSObject.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
class Data : public Copying<Data>
|
||||
{
|
||||
public:
|
||||
void* mutableBytes() const;
|
||||
UInteger length() const;
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void* NS::Data::mutableBytes() const
|
||||
{
|
||||
return Object::sendMessage<void*>(this, _NS_PRIVATE_SEL(mutableBytes));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::Data::length() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(length));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
53
dist/include/metal_cpp/Foundation/NSDate.hpp
vendored
Normal file
53
dist/include/metal_cpp/Foundation/NSDate.hpp
vendored
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSDate.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
|
||||
using TimeInterval = double;
|
||||
|
||||
class Date : public Copying<Date>
|
||||
{
|
||||
public:
|
||||
static Date* dateWithTimeIntervalSinceNow(TimeInterval secs);
|
||||
};
|
||||
|
||||
} // NS
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Date* NS::Date::dateWithTimeIntervalSinceNow(NS::TimeInterval secs)
|
||||
{
|
||||
return NS::Object::sendMessage<NS::Date*>(_NS_PRIVATE_CLS(NSDate), _NS_PRIVATE_SEL(dateWithTimeIntervalSinceNow_), secs);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
45
dist/include/metal_cpp/Foundation/NSDefines.hpp
vendored
Normal file
45
dist/include/metal_cpp/Foundation/NSDefines.hpp
vendored
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSDefines.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
#define _NS_WEAK_IMPORT __attribute__((weak_import))
|
||||
#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN
|
||||
#define _NS_EXPORT __attribute__((visibility("hidden")))
|
||||
#else
|
||||
#define _NS_EXPORT __attribute__((visibility("default")))
|
||||
#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN
|
||||
#define _NS_EXTERN extern "C" _NS_EXPORT
|
||||
#define _NS_INLINE inline __attribute__((always_inline))
|
||||
#define _NS_PACKED __attribute__((packed))
|
||||
|
||||
#define _NS_CONST(type, name) _NS_EXTERN type const name
|
||||
#define _NS_ENUM(type, name) enum name : type
|
||||
#define _NS_OPTIONS(type, name) \
|
||||
using name = type; \
|
||||
enum : name
|
||||
|
||||
#define _NS_CAST_TO_UINT(value) static_cast<NS::UInteger>(value)
|
||||
#define _NS_VALIDATE_SIZE(ns, name) static_assert(sizeof(ns::name) == sizeof(ns##name), "size mismatch " #ns "::" #name)
|
||||
#define _NS_VALIDATE_ENUM(ns, name) static_assert(_NS_CAST_TO_UINT(ns::name) == _NS_CAST_TO_UINT(ns##name), "value mismatch " #ns "::" #name)
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
128
dist/include/metal_cpp/Foundation/NSDictionary.hpp
vendored
Normal file
128
dist/include/metal_cpp/Foundation/NSDictionary.hpp
vendored
Normal file
|
|
@ -0,0 +1,128 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSDictionary.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSEnumerator.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
class Dictionary : public NS::Copying<Dictionary>
|
||||
{
|
||||
public:
|
||||
static Dictionary* dictionary();
|
||||
static Dictionary* dictionary(const Object* pObject, const Object* pKey);
|
||||
static Dictionary* dictionary(const Object* const* pObjects, const Object* const* pKeys, UInteger count);
|
||||
|
||||
static Dictionary* alloc();
|
||||
|
||||
Dictionary* init();
|
||||
Dictionary* init(const Object* const* pObjects, const Object* const* pKeys, UInteger count);
|
||||
Dictionary* init(const class Coder* pCoder);
|
||||
|
||||
template <class _KeyType = Object>
|
||||
Enumerator<_KeyType>* keyEnumerator() const;
|
||||
|
||||
template <class _Object = Object>
|
||||
_Object* object(const Object* pKey) const;
|
||||
UInteger count() const;
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary()
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionary));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary(const Object* pObject, const Object* pKey)
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionaryWithObject_forKey_), pObject, pKey);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary(const Object* const* pObjects, const Object* const* pKeys, UInteger count)
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionaryWithObjects_forKeys_count_),
|
||||
pObjects, pKeys, count);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Dictionary::alloc()
|
||||
{
|
||||
return NS::Object::alloc<Dictionary>(_NS_PRIVATE_CLS(NSDictionary));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Dictionary::init()
|
||||
{
|
||||
return NS::Object::init<Dictionary>();
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Dictionary::init(const Object* const* pObjects, const Object* const* pKeys, UInteger count)
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(initWithObjects_forKeys_count_), pObjects, pKeys, count);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Dictionary::init(const class Coder* pCoder)
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _KeyType>
|
||||
_NS_INLINE NS::Enumerator<_KeyType>* NS::Dictionary::keyEnumerator() const
|
||||
{
|
||||
return Object::sendMessage<Enumerator<_KeyType>*>(this, _NS_PRIVATE_SEL(keyEnumerator));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Object>
|
||||
_NS_INLINE _Object* NS::Dictionary::object(const Object* pKey) const
|
||||
{
|
||||
return Object::sendMessage<_Object*>(this, _NS_PRIVATE_SEL(objectForKey_), pKey);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::Dictionary::count() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(count));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
78
dist/include/metal_cpp/Foundation/NSEnumerator.hpp
vendored
Normal file
78
dist/include/metal_cpp/Foundation/NSEnumerator.hpp
vendored
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSEnumerator.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSObject.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
struct FastEnumerationState
|
||||
{
|
||||
unsigned long state;
|
||||
Object** itemsPtr;
|
||||
unsigned long* mutationsPtr;
|
||||
unsigned long extra[5];
|
||||
} _NS_PACKED;
|
||||
|
||||
class FastEnumeration : public Referencing<FastEnumeration>
|
||||
{
|
||||
public:
|
||||
NS::UInteger countByEnumerating(FastEnumerationState* pState, Object** pBuffer, NS::UInteger len);
|
||||
};
|
||||
|
||||
template <class _ObjectType>
|
||||
class Enumerator : public Referencing<Enumerator<_ObjectType>, FastEnumeration>
|
||||
{
|
||||
public:
|
||||
_ObjectType* nextObject();
|
||||
class Array* allObjects();
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::FastEnumeration::countByEnumerating(FastEnumerationState* pState, Object** pBuffer, NS::UInteger len)
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(countByEnumeratingWithState_objects_count_), pState, pBuffer, len);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _ObjectType>
|
||||
_NS_INLINE _ObjectType* NS::Enumerator<_ObjectType>::nextObject()
|
||||
{
|
||||
return Object::sendMessage<_ObjectType*>(this, _NS_PRIVATE_SEL(nextObject));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _ObjectType>
|
||||
_NS_INLINE NS::Array* NS::Enumerator<_ObjectType>::allObjects()
|
||||
{
|
||||
return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(allObjects));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
173
dist/include/metal_cpp/Foundation/NSError.hpp
vendored
Normal file
173
dist/include/metal_cpp/Foundation/NSError.hpp
vendored
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSError.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
using ErrorDomain = class String*;
|
||||
|
||||
_NS_CONST(ErrorDomain, CocoaErrorDomain);
|
||||
_NS_CONST(ErrorDomain, POSIXErrorDomain);
|
||||
_NS_CONST(ErrorDomain, OSStatusErrorDomain);
|
||||
_NS_CONST(ErrorDomain, MachErrorDomain);
|
||||
|
||||
using ErrorUserInfoKey = class String*;
|
||||
|
||||
_NS_CONST(ErrorUserInfoKey, UnderlyingErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, LocalizedDescriptionKey);
|
||||
_NS_CONST(ErrorUserInfoKey, LocalizedFailureReasonErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, LocalizedRecoverySuggestionErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, LocalizedRecoveryOptionsErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, RecoveryAttempterErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, HelpAnchorErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, DebugDescriptionErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, LocalizedFailureErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, StringEncodingErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, URLErrorKey);
|
||||
_NS_CONST(ErrorUserInfoKey, FilePathErrorKey);
|
||||
|
||||
class Error : public Copying<Error>
|
||||
{
|
||||
public:
|
||||
static Error* error(ErrorDomain domain, Integer code, class Dictionary* pDictionary);
|
||||
|
||||
static Error* alloc();
|
||||
Error* init();
|
||||
Error* init(ErrorDomain domain, Integer code, class Dictionary* pDictionary);
|
||||
|
||||
Integer code() const;
|
||||
ErrorDomain domain() const;
|
||||
class Dictionary* userInfo() const;
|
||||
|
||||
class String* localizedDescription() const;
|
||||
class Array* localizedRecoveryOptions() const;
|
||||
class String* localizedRecoverySuggestion() const;
|
||||
class String* localizedFailureReason() const;
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, CocoaErrorDomain);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, POSIXErrorDomain);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, OSStatusErrorDomain);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, MachErrorDomain);
|
||||
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, UnderlyingErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedDescriptionKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedFailureReasonErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedRecoverySuggestionErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedRecoveryOptionsErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, RecoveryAttempterErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, HelpAnchorErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, DebugDescriptionErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedFailureErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, StringEncodingErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, URLErrorKey);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, FilePathErrorKey);
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Error* NS::Error::error(ErrorDomain domain, Integer code, class Dictionary* pDictionary)
|
||||
{
|
||||
return Object::sendMessage<Error*>(_NS_PRIVATE_CLS(NSError), _NS_PRIVATE_SEL(errorWithDomain_code_userInfo_), domain, code, pDictionary);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Error* NS::Error::alloc()
|
||||
{
|
||||
return Object::alloc<Error>(_NS_PRIVATE_CLS(NSError));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Error* NS::Error::init()
|
||||
{
|
||||
return Object::init<Error>();
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Error* NS::Error::init(ErrorDomain domain, Integer code, class Dictionary* pDictionary)
|
||||
{
|
||||
return Object::sendMessage<Error*>(this, _NS_PRIVATE_SEL(initWithDomain_code_userInfo_), domain, code, pDictionary);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Integer NS::Error::code() const
|
||||
{
|
||||
return Object::sendMessage<Integer>(this, _NS_PRIVATE_SEL(code));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::ErrorDomain NS::Error::domain() const
|
||||
{
|
||||
return Object::sendMessage<ErrorDomain>(this, _NS_PRIVATE_SEL(domain));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Error::userInfo() const
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(userInfo));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Error::localizedDescription() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(localizedDescription));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::Error::localizedRecoveryOptions() const
|
||||
{
|
||||
return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(localizedRecoveryOptions));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Error::localizedRecoverySuggestion() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(localizedRecoverySuggestion));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Error::localizedFailureReason() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(localizedFailureReason));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
118
dist/include/metal_cpp/Foundation/NSLock.hpp
vendored
Normal file
118
dist/include/metal_cpp/Foundation/NSLock.hpp
vendored
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSLock.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
#include "NSDate.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
|
||||
template <class _Class, class _Base = class Object>
|
||||
class Locking : public _Base
|
||||
{
|
||||
public:
|
||||
void lock();
|
||||
void unlock();
|
||||
};
|
||||
|
||||
class Condition : public Locking<Condition>
|
||||
{
|
||||
public:
|
||||
static Condition* alloc();
|
||||
|
||||
Condition* init();
|
||||
|
||||
void wait();
|
||||
bool waitUntilDate(Date* pLimit);
|
||||
void signal();
|
||||
void broadcast();
|
||||
};
|
||||
|
||||
} // NS
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template<class _Class, class _Base /* = NS::Object */>
|
||||
_NS_INLINE void NS::Locking<_Class, _Base>::lock()
|
||||
{
|
||||
NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(lock));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template<class _Class, class _Base /* = NS::Object */>
|
||||
_NS_INLINE void NS::Locking<_Class, _Base>::unlock()
|
||||
{
|
||||
NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(unlock));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Condition* NS::Condition::alloc()
|
||||
{
|
||||
return NS::Object::alloc<NS::Condition>(_NS_PRIVATE_CLS(NSCondition));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Condition* NS::Condition::init()
|
||||
{
|
||||
return NS::Object::init<NS::Condition>();
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::Condition::wait()
|
||||
{
|
||||
NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(wait));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Condition::waitUntilDate(NS::Date* pLimit)
|
||||
{
|
||||
return NS::Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(waitUntilDate_), pLimit);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::Condition::signal()
|
||||
{
|
||||
NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(signal));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::Condition::broadcast()
|
||||
{
|
||||
NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(broadcast));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
110
dist/include/metal_cpp/Foundation/NSNotification.hpp
vendored
Normal file
110
dist/include/metal_cpp/Foundation/NSNotification.hpp
vendored
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSNotification.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSDictionary.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSString.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
#include <functional>
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
using NotificationName = class String*;
|
||||
|
||||
class Notification : public NS::Referencing<Notification>
|
||||
{
|
||||
public:
|
||||
NS::String* name() const;
|
||||
NS::Object* object() const;
|
||||
NS::Dictionary* userInfo() const;
|
||||
};
|
||||
|
||||
using ObserverBlock = void(^)(Notification*);
|
||||
using ObserverFunction = std::function<void(Notification*)>;
|
||||
|
||||
class NotificationCenter : public NS::Referencing<NotificationCenter>
|
||||
{
|
||||
public:
|
||||
static class NotificationCenter* defaultCenter();
|
||||
Object* addObserver(NotificationName name, Object* pObj, void* pQueue, ObserverBlock block);
|
||||
Object* addObserver(NotificationName name, Object* pObj, void* pQueue, ObserverFunction &handler);
|
||||
void removeObserver(Object* pObserver);
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Notification::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _NS_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Object* NS::Notification::object() const
|
||||
{
|
||||
return Object::sendMessage<NS::Object*>(this, _NS_PRIVATE_SEL(object));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::Notification::userInfo() const
|
||||
{
|
||||
return Object::sendMessage<NS::Dictionary*>(this, _NS_PRIVATE_SEL(userInfo));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::NotificationCenter* NS::NotificationCenter::defaultCenter()
|
||||
{
|
||||
return NS::Object::sendMessage<NS::NotificationCenter*>(_NS_PRIVATE_CLS(NSNotificationCenter), _NS_PRIVATE_SEL(defaultCenter));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Object* NS::NotificationCenter::addObserver(NS::NotificationName name, Object* pObj, void* pQueue, NS::ObserverBlock block)
|
||||
{
|
||||
return NS::Object::sendMessage<Object*>(this, _NS_PRIVATE_SEL(addObserverName_object_queue_block_), name, pObj, pQueue, block);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Object* NS::NotificationCenter::addObserver(NS::NotificationName name, Object* pObj, void* pQueue, NS::ObserverFunction &handler)
|
||||
{
|
||||
__block ObserverFunction blockFunction = handler;
|
||||
|
||||
return addObserver(name, pObj, pQueue, ^(NS::Notification* pNotif) {blockFunction(pNotif);});
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::NotificationCenter::removeObserver(Object* pObserver)
|
||||
{
|
||||
return NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(removeObserver_), pObserver);
|
||||
}
|
||||
|
||||
501
dist/include/metal_cpp/Foundation/NSNumber.hpp
vendored
Normal file
501
dist/include/metal_cpp/Foundation/NSNumber.hpp
vendored
Normal file
|
|
@ -0,0 +1,501 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSNumber.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSObjCRuntime.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
class Value : public Copying<Value>
|
||||
{
|
||||
public:
|
||||
static Value* value(const void* pValue, const char* pType);
|
||||
static Value* value(const void* pPointer);
|
||||
|
||||
static Value* alloc();
|
||||
|
||||
Value* init(const void* pValue, const char* pType);
|
||||
Value* init(const class Coder* pCoder);
|
||||
|
||||
void getValue(void* pValue, UInteger size) const;
|
||||
const char* objCType() const;
|
||||
|
||||
bool isEqualToValue(Value* pValue) const;
|
||||
void* pointerValue() const;
|
||||
};
|
||||
|
||||
class Number : public Copying<Number, Value>
|
||||
{
|
||||
public:
|
||||
static Number* number(char value);
|
||||
static Number* number(unsigned char value);
|
||||
static Number* number(short value);
|
||||
static Number* number(unsigned short value);
|
||||
static Number* number(int value);
|
||||
static Number* number(unsigned int value);
|
||||
static Number* number(long value);
|
||||
static Number* number(unsigned long value);
|
||||
static Number* number(long long value);
|
||||
static Number* number(unsigned long long value);
|
||||
static Number* number(float value);
|
||||
static Number* number(double value);
|
||||
static Number* number(bool value);
|
||||
|
||||
static Number* alloc();
|
||||
|
||||
Number* init(const class Coder* pCoder);
|
||||
Number* init(char value);
|
||||
Number* init(unsigned char value);
|
||||
Number* init(short value);
|
||||
Number* init(unsigned short value);
|
||||
Number* init(int value);
|
||||
Number* init(unsigned int value);
|
||||
Number* init(long value);
|
||||
Number* init(unsigned long value);
|
||||
Number* init(long long value);
|
||||
Number* init(unsigned long long value);
|
||||
Number* init(float value);
|
||||
Number* init(double value);
|
||||
Number* init(bool value);
|
||||
|
||||
char charValue() const;
|
||||
unsigned char unsignedCharValue() const;
|
||||
short shortValue() const;
|
||||
unsigned short unsignedShortValue() const;
|
||||
int intValue() const;
|
||||
unsigned int unsignedIntValue() const;
|
||||
long longValue() const;
|
||||
unsigned long unsignedLongValue() const;
|
||||
long long longLongValue() const;
|
||||
unsigned long long unsignedLongLongValue() const;
|
||||
float floatValue() const;
|
||||
double doubleValue() const;
|
||||
bool boolValue() const;
|
||||
Integer integerValue() const;
|
||||
UInteger unsignedIntegerValue() const;
|
||||
class String* stringValue() const;
|
||||
|
||||
ComparisonResult compare(const Number* pOtherNumber) const;
|
||||
bool isEqualToNumber(const Number* pNumber) const;
|
||||
|
||||
class String* descriptionWithLocale(const Object* pLocale) const;
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Value* NS::Value::value(const void* pValue, const char* pType)
|
||||
{
|
||||
return Object::sendMessage<Value*>(_NS_PRIVATE_CLS(NSValue), _NS_PRIVATE_SEL(valueWithBytes_objCType_), pValue, pType);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Value* NS::Value::value(const void* pPointer)
|
||||
{
|
||||
return Object::sendMessage<Value*>(_NS_PRIVATE_CLS(NSValue), _NS_PRIVATE_SEL(valueWithPointer_), pPointer);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Value* NS::Value::alloc()
|
||||
{
|
||||
return NS::Object::alloc<Value>(_NS_PRIVATE_CLS(NSValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Value* NS::Value::init(const void* pValue, const char* pType)
|
||||
{
|
||||
return Object::sendMessage<Value*>(this, _NS_PRIVATE_SEL(initWithBytes_objCType_), pValue, pType);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Value* NS::Value::init(const class Coder* pCoder)
|
||||
{
|
||||
return Object::sendMessage<Value*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::Value::getValue(void* pValue, UInteger size) const
|
||||
{
|
||||
Object::sendMessage<void>(this, _NS_PRIVATE_SEL(getValue_size_), pValue, size);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE const char* NS::Value::objCType() const
|
||||
{
|
||||
return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(objCType));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Value::isEqualToValue(Value* pValue) const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isEqualToValue_), pValue);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void* NS::Value::pointerValue() const
|
||||
{
|
||||
return Object::sendMessage<void*>(this, _NS_PRIVATE_SEL(pointerValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(char value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithChar_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(unsigned char value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedChar_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(short value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithShort_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(unsigned short value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedShort_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(int value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithInt_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(unsigned int value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedInt_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(long value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithLong_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(unsigned long value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedLong_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(long long value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithLongLong_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(unsigned long long value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedLongLong_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(float value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithFloat_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(double value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithDouble_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::number(bool value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithBool_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::alloc()
|
||||
{
|
||||
return NS::Object::alloc<Number>(_NS_PRIVATE_CLS(NSNumber));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(const Coder* pCoder)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(char value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithChar_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(unsigned char value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedChar_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(short value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithShort_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(unsigned short value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedShort_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(int value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithInt_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(unsigned int value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedInt_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(long value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithLong_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(unsigned long value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedLong_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(long long value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithLongLong_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(unsigned long long value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedLongLong_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(float value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithFloat_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(double value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithDouble_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Number* NS::Number::init(bool value)
|
||||
{
|
||||
return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithBool_), value);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE char NS::Number::charValue() const
|
||||
{
|
||||
return Object::sendMessage<char>(this, _NS_PRIVATE_SEL(charValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE unsigned char NS::Number::unsignedCharValue() const
|
||||
{
|
||||
return Object::sendMessage<unsigned char>(this, _NS_PRIVATE_SEL(unsignedCharValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE short NS::Number::shortValue() const
|
||||
{
|
||||
return Object::sendMessage<short>(this, _NS_PRIVATE_SEL(shortValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE unsigned short NS::Number::unsignedShortValue() const
|
||||
{
|
||||
return Object::sendMessage<unsigned short>(this, _NS_PRIVATE_SEL(unsignedShortValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE int NS::Number::intValue() const
|
||||
{
|
||||
return Object::sendMessage<int>(this, _NS_PRIVATE_SEL(intValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE unsigned int NS::Number::unsignedIntValue() const
|
||||
{
|
||||
return Object::sendMessage<unsigned int>(this, _NS_PRIVATE_SEL(unsignedIntValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE long NS::Number::longValue() const
|
||||
{
|
||||
return Object::sendMessage<long>(this, _NS_PRIVATE_SEL(longValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE unsigned long NS::Number::unsignedLongValue() const
|
||||
{
|
||||
return Object::sendMessage<unsigned long>(this, _NS_PRIVATE_SEL(unsignedLongValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE long long NS::Number::longLongValue() const
|
||||
{
|
||||
return Object::sendMessage<long long>(this, _NS_PRIVATE_SEL(longLongValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE unsigned long long NS::Number::unsignedLongLongValue() const
|
||||
{
|
||||
return Object::sendMessage<unsigned long long>(this, _NS_PRIVATE_SEL(unsignedLongLongValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE float NS::Number::floatValue() const
|
||||
{
|
||||
return Object::sendMessage<float>(this, _NS_PRIVATE_SEL(floatValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE double NS::Number::doubleValue() const
|
||||
{
|
||||
return Object::sendMessage<double>(this, _NS_PRIVATE_SEL(doubleValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Number::boolValue() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(boolValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Integer NS::Number::integerValue() const
|
||||
{
|
||||
return Object::sendMessage<Integer>(this, _NS_PRIVATE_SEL(integerValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::Number::unsignedIntegerValue() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(unsignedIntegerValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Number::stringValue() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(stringValue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::ComparisonResult NS::Number::compare(const Number* pOtherNumber) const
|
||||
{
|
||||
return Object::sendMessage<ComparisonResult>(this, _NS_PRIVATE_SEL(compare_), pOtherNumber);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Number::isEqualToNumber(const Number* pNumber) const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isEqualToNumber_), pNumber);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Number::descriptionWithLocale(const Object* pLocale) const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(descriptionWithLocale_), pLocale);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
43
dist/include/metal_cpp/Foundation/NSObjCRuntime.hpp
vendored
Normal file
43
dist/include/metal_cpp/Foundation/NSObjCRuntime.hpp
vendored
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSObjCRuntime.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
|
||||
_NS_ENUM(Integer, ComparisonResult) {
|
||||
OrderedAscending = -1L,
|
||||
OrderedSame,
|
||||
OrderedDescending
|
||||
};
|
||||
|
||||
const Integer NotFound = IntegerMax;
|
||||
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
302
dist/include/metal_cpp/Foundation/NSObject.hpp
vendored
Normal file
302
dist/include/metal_cpp/Foundation/NSObject.hpp
vendored
Normal file
|
|
@ -0,0 +1,302 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSObject.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
#include <objc/message.h>
|
||||
#include <objc/runtime.h>
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
template <class _Class, class _Base = class Object>
|
||||
class _NS_EXPORT Referencing : public _Base
|
||||
{
|
||||
public:
|
||||
_Class* retain();
|
||||
void release();
|
||||
|
||||
_Class* autorelease();
|
||||
|
||||
UInteger retainCount() const;
|
||||
};
|
||||
|
||||
template <class _Class, class _Base = class Object>
|
||||
class Copying : public Referencing<_Class, _Base>
|
||||
{
|
||||
public:
|
||||
_Class* copy() const;
|
||||
};
|
||||
|
||||
template <class _Class, class _Base = class Object>
|
||||
class SecureCoding : public Referencing<_Class, _Base>
|
||||
{
|
||||
};
|
||||
|
||||
class Object : public Referencing<Object, objc_object>
|
||||
{
|
||||
public:
|
||||
UInteger hash() const;
|
||||
bool isEqual(const Object* pObject) const;
|
||||
|
||||
class String* description() const;
|
||||
class String* debugDescription() const;
|
||||
|
||||
protected:
|
||||
friend class Referencing<Object, objc_object>;
|
||||
|
||||
template <class _Class>
|
||||
static _Class* alloc(const char* pClassName);
|
||||
template <class _Class>
|
||||
static _Class* alloc(const void* pClass);
|
||||
template <class _Class>
|
||||
_Class* init();
|
||||
|
||||
template <class _Dst>
|
||||
static _Dst bridgingCast(const void* pObj);
|
||||
static class MethodSignature* methodSignatureForSelector(const void* pObj, SEL selector);
|
||||
static bool respondsToSelector(const void* pObj, SEL selector);
|
||||
template <typename _Type>
|
||||
static constexpr bool doesRequireMsgSendStret();
|
||||
template <typename _Ret, typename... _Args>
|
||||
static _Ret sendMessage(const void* pObj, SEL selector, _Args... args);
|
||||
template <typename _Ret, typename... _Args>
|
||||
static _Ret sendMessageSafe(const void* pObj, SEL selector, _Args... args);
|
||||
|
||||
private:
|
||||
Object() = delete;
|
||||
Object(const Object&) = delete;
|
||||
~Object() = delete;
|
||||
|
||||
Object& operator=(const Object&) = delete;
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Class, class _Base /* = Object */>
|
||||
_NS_INLINE _Class* NS::Referencing<_Class, _Base>::retain()
|
||||
{
|
||||
return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(retain));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Class, class _Base /* = Object */>
|
||||
_NS_INLINE void NS::Referencing<_Class, _Base>::release()
|
||||
{
|
||||
Object::sendMessage<void>(this, _NS_PRIVATE_SEL(release));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Class, class _Base /* = Object */>
|
||||
_NS_INLINE _Class* NS::Referencing<_Class, _Base>::autorelease()
|
||||
{
|
||||
return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(autorelease));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Class, class _Base /* = Object */>
|
||||
_NS_INLINE NS::UInteger NS::Referencing<_Class, _Base>::retainCount() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(retainCount));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Class, class _Base /* = Object */>
|
||||
_NS_INLINE _Class* NS::Copying<_Class, _Base>::copy() const
|
||||
{
|
||||
return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(copy));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Dst>
|
||||
_NS_INLINE _Dst NS::Object::bridgingCast(const void* pObj)
|
||||
{
|
||||
#ifdef __OBJC__
|
||||
return (__bridge _Dst)pObj;
|
||||
#else
|
||||
return (_Dst)pObj;
|
||||
#endif // __OBJC__
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <typename _Type>
|
||||
_NS_INLINE constexpr bool NS::Object::doesRequireMsgSendStret()
|
||||
{
|
||||
#if (defined(__i386__) || defined(__x86_64__))
|
||||
constexpr size_t kStructLimit = (sizeof(std::uintptr_t) << 1);
|
||||
|
||||
return sizeof(_Type) > kStructLimit;
|
||||
#elif defined(__arm64__)
|
||||
return false;
|
||||
#elif defined(__arm__)
|
||||
constexpr size_t kStructLimit = sizeof(std::uintptr_t);
|
||||
|
||||
return std::is_class_v<_Type> && (sizeof(_Type) > kStructLimit);
|
||||
#else
|
||||
#error "Unsupported architecture!"
|
||||
#endif
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <>
|
||||
_NS_INLINE constexpr bool NS::Object::doesRequireMsgSendStret<void>()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <typename _Ret, typename... _Args>
|
||||
_NS_INLINE _Ret NS::Object::sendMessage(const void* pObj, SEL selector, _Args... args)
|
||||
{
|
||||
#if (defined(__i386__) || defined(__x86_64__))
|
||||
if constexpr (std::is_floating_point<_Ret>())
|
||||
{
|
||||
using SendMessageProcFpret = _Ret (*)(const void*, SEL, _Args...);
|
||||
|
||||
const SendMessageProcFpret pProc = reinterpret_cast<SendMessageProcFpret>(&objc_msgSend_fpret);
|
||||
|
||||
return (*pProc)(pObj, selector, args...);
|
||||
}
|
||||
else
|
||||
#endif // ( defined( __i386__ ) || defined( __x86_64__ ) )
|
||||
#if !defined(__arm64__)
|
||||
if constexpr (doesRequireMsgSendStret<_Ret>())
|
||||
{
|
||||
using SendMessageProcStret = void (*)(_Ret*, const void*, SEL, _Args...);
|
||||
|
||||
const SendMessageProcStret pProc = reinterpret_cast<SendMessageProcStret>(&objc_msgSend_stret);
|
||||
_Ret ret;
|
||||
|
||||
(*pProc)(&ret, pObj, selector, args...);
|
||||
|
||||
return ret;
|
||||
}
|
||||
else
|
||||
#endif // !defined( __arm64__ )
|
||||
{
|
||||
using SendMessageProc = _Ret (*)(const void*, SEL, _Args...);
|
||||
|
||||
const SendMessageProc pProc = reinterpret_cast<SendMessageProc>(&objc_msgSend);
|
||||
|
||||
return (*pProc)(pObj, selector, args...);
|
||||
}
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::MethodSignature* NS::Object::methodSignatureForSelector(const void* pObj, SEL selector)
|
||||
{
|
||||
return sendMessage<MethodSignature*>(pObj, _NS_PRIVATE_SEL(methodSignatureForSelector_), selector);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Object::respondsToSelector(const void* pObj, SEL selector)
|
||||
{
|
||||
return sendMessage<bool>(pObj, _NS_PRIVATE_SEL(respondsToSelector_), selector);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <typename _Ret, typename... _Args>
|
||||
_NS_INLINE _Ret NS::Object::sendMessageSafe(const void* pObj, SEL selector, _Args... args)
|
||||
{
|
||||
if ((respondsToSelector(pObj, selector)) || (nullptr != methodSignatureForSelector(pObj, selector)))
|
||||
{
|
||||
return sendMessage<_Ret>(pObj, selector, args...);
|
||||
}
|
||||
|
||||
if constexpr (!std::is_void<_Ret>::value)
|
||||
{
|
||||
return _Ret(0);
|
||||
}
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE _Class* NS::Object::alloc(const char* pClassName)
|
||||
{
|
||||
return sendMessage<_Class*>(objc_lookUpClass(pClassName), _NS_PRIVATE_SEL(alloc));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE _Class* NS::Object::alloc(const void* pClass)
|
||||
{
|
||||
return sendMessage<_Class*>(pClass, _NS_PRIVATE_SEL(alloc));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE _Class* NS::Object::init()
|
||||
{
|
||||
return sendMessage<_Class*>(this, _NS_PRIVATE_SEL(init));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::Object::hash() const
|
||||
{
|
||||
return sendMessage<UInteger>(this, _NS_PRIVATE_SEL(hash));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Object::isEqual(const Object* pObject) const
|
||||
{
|
||||
return sendMessage<bool>(this, _NS_PRIVATE_SEL(isEqual_), pObject);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Object::description() const
|
||||
{
|
||||
return sendMessage<String*>(this, _NS_PRIVATE_SEL(description));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::Object::debugDescription() const
|
||||
{
|
||||
return sendMessageSafe<String*>(this, _NS_PRIVATE_SEL(debugDescription));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
531
dist/include/metal_cpp/Foundation/NSPrivate.hpp
vendored
Normal file
531
dist/include/metal_cpp/Foundation/NSPrivate.hpp
vendored
Normal file
|
|
@ -0,0 +1,531 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSPrivate.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 <objc/runtime.h>
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
#define _NS_PRIVATE_CLS(symbol) (Private::Class::s_k##symbol)
|
||||
#define _NS_PRIVATE_SEL(accessor) (Private::Selector::s_k##accessor)
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
#if defined(NS_PRIVATE_IMPLEMENTATION)
|
||||
|
||||
#include <dlfcn.h>
|
||||
|
||||
namespace NS::Private
|
||||
{
|
||||
template <typename _Type>
|
||||
inline _Type const LoadSymbol(const char* pSymbol)
|
||||
{
|
||||
const _Type* pAddress = static_cast<_Type*>(dlsym(RTLD_DEFAULT, pSymbol));
|
||||
|
||||
return pAddress ? *pAddress : _Type();
|
||||
}
|
||||
} // NS::Private
|
||||
|
||||
#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN
|
||||
#define _NS_PRIVATE_VISIBILITY __attribute__((visibility("hidden")))
|
||||
#else
|
||||
#define _NS_PRIVATE_VISIBILITY __attribute__((visibility("default")))
|
||||
#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN
|
||||
|
||||
#define _NS_PRIVATE_IMPORT __attribute__((weak_import))
|
||||
|
||||
#ifdef __OBJC__
|
||||
#define _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol) ((__bridge void*)objc_lookUpClass(#symbol))
|
||||
#define _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol) ((__bridge void*)objc_getProtocol(#symbol))
|
||||
#else
|
||||
#define _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol) objc_lookUpClass(#symbol)
|
||||
#define _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol) objc_getProtocol(#symbol)
|
||||
#endif // __OBJC__
|
||||
|
||||
#define _NS_PRIVATE_DEF_CLS(symbol) void* s_k##symbol _NS_PRIVATE_VISIBILITY = _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol)
|
||||
#define _NS_PRIVATE_DEF_PRO(symbol) void* s_k##symbol _NS_PRIVATE_VISIBILITY = _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol)
|
||||
#define _NS_PRIVATE_DEF_SEL(accessor, symbol) SEL s_k##accessor _NS_PRIVATE_VISIBILITY = sel_registerName(symbol)
|
||||
|
||||
#if defined(__MAC_26_0) || defined(__IPHONE_26_0) || defined(__TVOS_26_0)
|
||||
#define _NS_PRIVATE_DEF_CONST(type, symbol) \
|
||||
_NS_EXTERN type const NS##symbol _NS_PRIVATE_IMPORT; \
|
||||
type const NS::symbol = (nullptr != &NS##symbol) ? NS##symbol : type()
|
||||
#else
|
||||
#define _NS_PRIVATE_DEF_CONST(type, symbol) \
|
||||
_NS_EXTERN type const MTL##symbol _NS_PRIVATE_IMPORT; \
|
||||
type const NS::symbol = Private::LoadSymbol<type>("NS" #symbol)
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define _NS_PRIVATE_DEF_CLS(symbol) extern void* s_k##symbol
|
||||
#define _NS_PRIVATE_DEF_PRO(symbol) extern void* s_k##symbol
|
||||
#define _NS_PRIVATE_DEF_SEL(accessor, symbol) extern SEL s_k##accessor
|
||||
#define _NS_PRIVATE_DEF_CONST(type, symbol) extern type const NS::symbol
|
||||
|
||||
#endif // NS_PRIVATE_IMPLEMENTATION
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
namespace Private
|
||||
{
|
||||
namespace Class
|
||||
{
|
||||
|
||||
_NS_PRIVATE_DEF_CLS(NSArray);
|
||||
_NS_PRIVATE_DEF_CLS(NSAutoreleasePool);
|
||||
_NS_PRIVATE_DEF_CLS(NSBundle);
|
||||
_NS_PRIVATE_DEF_CLS(NSCondition);
|
||||
_NS_PRIVATE_DEF_CLS(NSDate);
|
||||
_NS_PRIVATE_DEF_CLS(NSDictionary);
|
||||
_NS_PRIVATE_DEF_CLS(NSError);
|
||||
_NS_PRIVATE_DEF_CLS(NSNotificationCenter);
|
||||
_NS_PRIVATE_DEF_CLS(NSNumber);
|
||||
_NS_PRIVATE_DEF_CLS(NSObject);
|
||||
_NS_PRIVATE_DEF_CLS(NSProcessInfo);
|
||||
_NS_PRIVATE_DEF_CLS(NSSet);
|
||||
_NS_PRIVATE_DEF_CLS(NSString);
|
||||
_NS_PRIVATE_DEF_CLS(NSURL);
|
||||
_NS_PRIVATE_DEF_CLS(NSValue);
|
||||
|
||||
} // Class
|
||||
} // Private
|
||||
} // MTL
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
namespace Private
|
||||
{
|
||||
namespace Protocol
|
||||
{
|
||||
|
||||
} // Protocol
|
||||
} // Private
|
||||
} // NS
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
namespace Private
|
||||
{
|
||||
namespace Selector
|
||||
{
|
||||
|
||||
_NS_PRIVATE_DEF_SEL(addObject_,
|
||||
"addObject:");
|
||||
_NS_PRIVATE_DEF_SEL(addObserverName_object_queue_block_,
|
||||
"addObserverForName:object:queue:usingBlock:");
|
||||
_NS_PRIVATE_DEF_SEL(activeProcessorCount,
|
||||
"activeProcessorCount");
|
||||
_NS_PRIVATE_DEF_SEL(allBundles,
|
||||
"allBundles");
|
||||
_NS_PRIVATE_DEF_SEL(allFrameworks,
|
||||
"allFrameworks");
|
||||
_NS_PRIVATE_DEF_SEL(allObjects,
|
||||
"allObjects");
|
||||
_NS_PRIVATE_DEF_SEL(alloc,
|
||||
"alloc");
|
||||
_NS_PRIVATE_DEF_SEL(appStoreReceiptURL,
|
||||
"appStoreReceiptURL");
|
||||
_NS_PRIVATE_DEF_SEL(arguments,
|
||||
"arguments");
|
||||
_NS_PRIVATE_DEF_SEL(array,
|
||||
"array");
|
||||
_NS_PRIVATE_DEF_SEL(arrayWithObject_,
|
||||
"arrayWithObject:");
|
||||
_NS_PRIVATE_DEF_SEL(arrayWithObjects_count_,
|
||||
"arrayWithObjects:count:");
|
||||
_NS_PRIVATE_DEF_SEL(automaticTerminationSupportEnabled,
|
||||
"automaticTerminationSupportEnabled");
|
||||
_NS_PRIVATE_DEF_SEL(autorelease,
|
||||
"autorelease");
|
||||
_NS_PRIVATE_DEF_SEL(beginActivityWithOptions_reason_,
|
||||
"beginActivityWithOptions:reason:");
|
||||
_NS_PRIVATE_DEF_SEL(boolValue,
|
||||
"boolValue");
|
||||
_NS_PRIVATE_DEF_SEL(broadcast,
|
||||
"broadcast");
|
||||
_NS_PRIVATE_DEF_SEL(builtInPlugInsPath,
|
||||
"builtInPlugInsPath");
|
||||
_NS_PRIVATE_DEF_SEL(builtInPlugInsURL,
|
||||
"builtInPlugInsURL");
|
||||
_NS_PRIVATE_DEF_SEL(bundleIdentifier,
|
||||
"bundleIdentifier");
|
||||
_NS_PRIVATE_DEF_SEL(bundlePath,
|
||||
"bundlePath");
|
||||
_NS_PRIVATE_DEF_SEL(bundleURL,
|
||||
"bundleURL");
|
||||
_NS_PRIVATE_DEF_SEL(bundleWithPath_,
|
||||
"bundleWithPath:");
|
||||
_NS_PRIVATE_DEF_SEL(bundleWithURL_,
|
||||
"bundleWithURL:");
|
||||
_NS_PRIVATE_DEF_SEL(caseInsensitiveCompare_,
|
||||
"caseInsensitiveCompare:");
|
||||
_NS_PRIVATE_DEF_SEL(characterAtIndex_,
|
||||
"characterAtIndex:");
|
||||
_NS_PRIVATE_DEF_SEL(charValue,
|
||||
"charValue");
|
||||
_NS_PRIVATE_DEF_SEL(countByEnumeratingWithState_objects_count_,
|
||||
"countByEnumeratingWithState:objects:count:");
|
||||
_NS_PRIVATE_DEF_SEL(cStringUsingEncoding_,
|
||||
"cStringUsingEncoding:");
|
||||
_NS_PRIVATE_DEF_SEL(code,
|
||||
"code");
|
||||
_NS_PRIVATE_DEF_SEL(compare_,
|
||||
"compare:");
|
||||
_NS_PRIVATE_DEF_SEL(copy,
|
||||
"copy");
|
||||
_NS_PRIVATE_DEF_SEL(count,
|
||||
"count");
|
||||
_NS_PRIVATE_DEF_SEL(dateWithTimeIntervalSinceNow_,
|
||||
"dateWithTimeIntervalSinceNow:");
|
||||
_NS_PRIVATE_DEF_SEL(defaultCenter,
|
||||
"defaultCenter");
|
||||
_NS_PRIVATE_DEF_SEL(descriptionWithLocale_,
|
||||
"descriptionWithLocale:");
|
||||
_NS_PRIVATE_DEF_SEL(disableAutomaticTermination_,
|
||||
"disableAutomaticTermination:");
|
||||
_NS_PRIVATE_DEF_SEL(disableSuddenTermination,
|
||||
"disableSuddenTermination");
|
||||
_NS_PRIVATE_DEF_SEL(debugDescription,
|
||||
"debugDescription");
|
||||
_NS_PRIVATE_DEF_SEL(description,
|
||||
"description");
|
||||
_NS_PRIVATE_DEF_SEL(dictionary,
|
||||
"dictionary");
|
||||
_NS_PRIVATE_DEF_SEL(dictionaryWithObject_forKey_,
|
||||
"dictionaryWithObject:forKey:");
|
||||
_NS_PRIVATE_DEF_SEL(dictionaryWithObjects_forKeys_count_,
|
||||
"dictionaryWithObjects:forKeys:count:");
|
||||
_NS_PRIVATE_DEF_SEL(domain,
|
||||
"domain");
|
||||
_NS_PRIVATE_DEF_SEL(doubleValue,
|
||||
"doubleValue");
|
||||
_NS_PRIVATE_DEF_SEL(drain,
|
||||
"drain");
|
||||
_NS_PRIVATE_DEF_SEL(enableAutomaticTermination_,
|
||||
"enableAutomaticTermination:");
|
||||
_NS_PRIVATE_DEF_SEL(enableSuddenTermination,
|
||||
"enableSuddenTermination");
|
||||
_NS_PRIVATE_DEF_SEL(endActivity_,
|
||||
"endActivity:");
|
||||
_NS_PRIVATE_DEF_SEL(environment,
|
||||
"environment");
|
||||
_NS_PRIVATE_DEF_SEL(errorWithDomain_code_userInfo_,
|
||||
"errorWithDomain:code:userInfo:");
|
||||
_NS_PRIVATE_DEF_SEL(executablePath,
|
||||
"executablePath");
|
||||
_NS_PRIVATE_DEF_SEL(executableURL,
|
||||
"executableURL");
|
||||
_NS_PRIVATE_DEF_SEL(fileSystemRepresentation,
|
||||
"fileSystemRepresentation");
|
||||
_NS_PRIVATE_DEF_SEL(fileURLWithPath_,
|
||||
"fileURLWithPath:");
|
||||
_NS_PRIVATE_DEF_SEL(floatValue,
|
||||
"floatValue");
|
||||
_NS_PRIVATE_DEF_SEL(fullUserName,
|
||||
"fullUserName");
|
||||
_NS_PRIVATE_DEF_SEL(getValue_size_,
|
||||
"getValue:size:");
|
||||
_NS_PRIVATE_DEF_SEL(globallyUniqueString,
|
||||
"globallyUniqueString");
|
||||
_NS_PRIVATE_DEF_SEL(hash,
|
||||
"hash");
|
||||
_NS_PRIVATE_DEF_SEL(hasPerformanceProfile_,
|
||||
"hasPerformanceProfile:");
|
||||
_NS_PRIVATE_DEF_SEL(hostName,
|
||||
"hostName");
|
||||
_NS_PRIVATE_DEF_SEL(infoDictionary,
|
||||
"infoDictionary");
|
||||
_NS_PRIVATE_DEF_SEL(init,
|
||||
"init");
|
||||
_NS_PRIVATE_DEF_SEL(initFileURLWithPath_,
|
||||
"initFileURLWithPath:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithBool_,
|
||||
"initWithBool:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithBytes_objCType_,
|
||||
"initWithBytes:objCType:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithBytesNoCopy_length_encoding_freeWhenDone_,
|
||||
"initWithBytesNoCopy:length:encoding:freeWhenDone:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithChar_,
|
||||
"initWithChar:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithCoder_,
|
||||
"initWithCoder:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithCString_encoding_,
|
||||
"initWithCString:encoding:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithDomain_code_userInfo_,
|
||||
"initWithDomain:code:userInfo:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithDouble_,
|
||||
"initWithDouble:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithFloat_,
|
||||
"initWithFloat:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithInt_,
|
||||
"initWithInt:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithLong_,
|
||||
"initWithLong:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithLongLong_,
|
||||
"initWithLongLong:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithObjects_count_,
|
||||
"initWithObjects:count:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithObjects_forKeys_count_,
|
||||
"initWithObjects:forKeys:count:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithPath_,
|
||||
"initWithPath:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithShort_,
|
||||
"initWithShort:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithString_,
|
||||
"initWithString:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithUnsignedChar_,
|
||||
"initWithUnsignedChar:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithUnsignedInt_,
|
||||
"initWithUnsignedInt:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithUnsignedLong_,
|
||||
"initWithUnsignedLong:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithUnsignedLongLong_,
|
||||
"initWithUnsignedLongLong:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithUnsignedShort_,
|
||||
"initWithUnsignedShort:");
|
||||
_NS_PRIVATE_DEF_SEL(initWithURL_,
|
||||
"initWithURL:");
|
||||
_NS_PRIVATE_DEF_SEL(integerValue,
|
||||
"integerValue");
|
||||
_NS_PRIVATE_DEF_SEL(intValue,
|
||||
"intValue");
|
||||
_NS_PRIVATE_DEF_SEL(isDeviceCertified_,
|
||||
"isDeviceCertifiedFor:");
|
||||
_NS_PRIVATE_DEF_SEL(isEqual_,
|
||||
"isEqual:");
|
||||
_NS_PRIVATE_DEF_SEL(isEqualToNumber_,
|
||||
"isEqualToNumber:");
|
||||
_NS_PRIVATE_DEF_SEL(isEqualToString_,
|
||||
"isEqualToString:");
|
||||
_NS_PRIVATE_DEF_SEL(isEqualToValue_,
|
||||
"isEqualToValue:");
|
||||
_NS_PRIVATE_DEF_SEL(isiOSAppOnMac,
|
||||
"isiOSAppOnMac");
|
||||
_NS_PRIVATE_DEF_SEL(isLoaded,
|
||||
"isLoaded");
|
||||
_NS_PRIVATE_DEF_SEL(isLowPowerModeEnabled,
|
||||
"isLowPowerModeEnabled");
|
||||
_NS_PRIVATE_DEF_SEL(isMacCatalystApp,
|
||||
"isMacCatalystApp");
|
||||
_NS_PRIVATE_DEF_SEL(isOperatingSystemAtLeastVersion_,
|
||||
"isOperatingSystemAtLeastVersion:");
|
||||
_NS_PRIVATE_DEF_SEL(keyEnumerator,
|
||||
"keyEnumerator");
|
||||
_NS_PRIVATE_DEF_SEL(length,
|
||||
"length");
|
||||
_NS_PRIVATE_DEF_SEL(lengthOfBytesUsingEncoding_,
|
||||
"lengthOfBytesUsingEncoding:");
|
||||
_NS_PRIVATE_DEF_SEL(load,
|
||||
"load");
|
||||
_NS_PRIVATE_DEF_SEL(loadAndReturnError_,
|
||||
"loadAndReturnError:");
|
||||
_NS_PRIVATE_DEF_SEL(localizedDescription,
|
||||
"localizedDescription");
|
||||
_NS_PRIVATE_DEF_SEL(localizedFailureReason,
|
||||
"localizedFailureReason");
|
||||
_NS_PRIVATE_DEF_SEL(localizedInfoDictionary,
|
||||
"localizedInfoDictionary");
|
||||
_NS_PRIVATE_DEF_SEL(localizedRecoveryOptions,
|
||||
"localizedRecoveryOptions");
|
||||
_NS_PRIVATE_DEF_SEL(localizedRecoverySuggestion,
|
||||
"localizedRecoverySuggestion");
|
||||
_NS_PRIVATE_DEF_SEL(localizedStringForKey_value_table_,
|
||||
"localizedStringForKey:value:table:");
|
||||
_NS_PRIVATE_DEF_SEL(lock,
|
||||
"lock");
|
||||
_NS_PRIVATE_DEF_SEL(longValue,
|
||||
"longValue");
|
||||
_NS_PRIVATE_DEF_SEL(longLongValue,
|
||||
"longLongValue");
|
||||
_NS_PRIVATE_DEF_SEL(mainBundle,
|
||||
"mainBundle");
|
||||
_NS_PRIVATE_DEF_SEL(maximumLengthOfBytesUsingEncoding_,
|
||||
"maximumLengthOfBytesUsingEncoding:");
|
||||
_NS_PRIVATE_DEF_SEL(methodSignatureForSelector_,
|
||||
"methodSignatureForSelector:");
|
||||
_NS_PRIVATE_DEF_SEL(mutableBytes,
|
||||
"mutableBytes");
|
||||
_NS_PRIVATE_DEF_SEL(name,
|
||||
"name");
|
||||
_NS_PRIVATE_DEF_SEL(nextObject,
|
||||
"nextObject");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithBool_,
|
||||
"numberWithBool:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithChar_,
|
||||
"numberWithChar:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithDouble_,
|
||||
"numberWithDouble:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithFloat_,
|
||||
"numberWithFloat:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithInt_,
|
||||
"numberWithInt:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithLong_,
|
||||
"numberWithLong:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithLongLong_,
|
||||
"numberWithLongLong:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithShort_,
|
||||
"numberWithShort:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithUnsignedChar_,
|
||||
"numberWithUnsignedChar:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithUnsignedInt_,
|
||||
"numberWithUnsignedInt:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithUnsignedLong_,
|
||||
"numberWithUnsignedLong:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithUnsignedLongLong_,
|
||||
"numberWithUnsignedLongLong:");
|
||||
_NS_PRIVATE_DEF_SEL(numberWithUnsignedShort_,
|
||||
"numberWithUnsignedShort:");
|
||||
_NS_PRIVATE_DEF_SEL(objCType,
|
||||
"objCType");
|
||||
_NS_PRIVATE_DEF_SEL(object,
|
||||
"object");
|
||||
_NS_PRIVATE_DEF_SEL(objectAtIndex_,
|
||||
"objectAtIndex:");
|
||||
_NS_PRIVATE_DEF_SEL(objectEnumerator,
|
||||
"objectEnumerator");
|
||||
_NS_PRIVATE_DEF_SEL(objectForInfoDictionaryKey_,
|
||||
"objectForInfoDictionaryKey:");
|
||||
_NS_PRIVATE_DEF_SEL(objectForKey_,
|
||||
"objectForKey:");
|
||||
_NS_PRIVATE_DEF_SEL(operatingSystem,
|
||||
"operatingSystem");
|
||||
_NS_PRIVATE_DEF_SEL(operatingSystemVersion,
|
||||
"operatingSystemVersion");
|
||||
_NS_PRIVATE_DEF_SEL(operatingSystemVersionString,
|
||||
"operatingSystemVersionString");
|
||||
_NS_PRIVATE_DEF_SEL(pathForAuxiliaryExecutable_,
|
||||
"pathForAuxiliaryExecutable:");
|
||||
_NS_PRIVATE_DEF_SEL(performActivityWithOptions_reason_usingBlock_,
|
||||
"performActivityWithOptions:reason:usingBlock:");
|
||||
_NS_PRIVATE_DEF_SEL(performExpiringActivityWithReason_usingBlock_,
|
||||
"performExpiringActivityWithReason:usingBlock:");
|
||||
_NS_PRIVATE_DEF_SEL(physicalMemory,
|
||||
"physicalMemory");
|
||||
_NS_PRIVATE_DEF_SEL(pointerValue,
|
||||
"pointerValue");
|
||||
_NS_PRIVATE_DEF_SEL(preflightAndReturnError_,
|
||||
"preflightAndReturnError:");
|
||||
_NS_PRIVATE_DEF_SEL(privateFrameworksPath,
|
||||
"privateFrameworksPath");
|
||||
_NS_PRIVATE_DEF_SEL(privateFrameworksURL,
|
||||
"privateFrameworksURL");
|
||||
_NS_PRIVATE_DEF_SEL(processIdentifier,
|
||||
"processIdentifier");
|
||||
_NS_PRIVATE_DEF_SEL(processInfo,
|
||||
"processInfo");
|
||||
_NS_PRIVATE_DEF_SEL(processName,
|
||||
"processName");
|
||||
_NS_PRIVATE_DEF_SEL(processorCount,
|
||||
"processorCount");
|
||||
_NS_PRIVATE_DEF_SEL(rangeOfString_options_,
|
||||
"rangeOfString:options:");
|
||||
_NS_PRIVATE_DEF_SEL(release,
|
||||
"release");
|
||||
_NS_PRIVATE_DEF_SEL(removeObserver_,
|
||||
"removeObserver:");
|
||||
_NS_PRIVATE_DEF_SEL(resourcePath,
|
||||
"resourcePath");
|
||||
_NS_PRIVATE_DEF_SEL(resourceURL,
|
||||
"resourceURL");
|
||||
_NS_PRIVATE_DEF_SEL(respondsToSelector_,
|
||||
"respondsToSelector:");
|
||||
_NS_PRIVATE_DEF_SEL(retain,
|
||||
"retain");
|
||||
_NS_PRIVATE_DEF_SEL(retainCount,
|
||||
"retainCount");
|
||||
_NS_PRIVATE_DEF_SEL(setAutomaticTerminationSupportEnabled_,
|
||||
"setAutomaticTerminationSupportEnabled:");
|
||||
_NS_PRIVATE_DEF_SEL(setProcessName_,
|
||||
"setProcessName:");
|
||||
_NS_PRIVATE_DEF_SEL(sharedFrameworksPath,
|
||||
"sharedFrameworksPath");
|
||||
_NS_PRIVATE_DEF_SEL(sharedFrameworksURL,
|
||||
"sharedFrameworksURL");
|
||||
_NS_PRIVATE_DEF_SEL(sharedSupportPath,
|
||||
"sharedSupportPath");
|
||||
_NS_PRIVATE_DEF_SEL(sharedSupportURL,
|
||||
"sharedSupportURL");
|
||||
_NS_PRIVATE_DEF_SEL(shortValue,
|
||||
"shortValue");
|
||||
_NS_PRIVATE_DEF_SEL(showPools,
|
||||
"showPools");
|
||||
_NS_PRIVATE_DEF_SEL(signal,
|
||||
"signal");
|
||||
_NS_PRIVATE_DEF_SEL(string,
|
||||
"string");
|
||||
_NS_PRIVATE_DEF_SEL(stringValue,
|
||||
"stringValue");
|
||||
_NS_PRIVATE_DEF_SEL(stringWithString_,
|
||||
"stringWithString:");
|
||||
_NS_PRIVATE_DEF_SEL(stringWithCString_encoding_,
|
||||
"stringWithCString:encoding:");
|
||||
_NS_PRIVATE_DEF_SEL(stringByAppendingString_,
|
||||
"stringByAppendingString:");
|
||||
_NS_PRIVATE_DEF_SEL(systemUptime,
|
||||
"systemUptime");
|
||||
_NS_PRIVATE_DEF_SEL(thermalState,
|
||||
"thermalState");
|
||||
_NS_PRIVATE_DEF_SEL(unload,
|
||||
"unload");
|
||||
_NS_PRIVATE_DEF_SEL(unlock,
|
||||
"unlock");
|
||||
_NS_PRIVATE_DEF_SEL(unsignedCharValue,
|
||||
"unsignedCharValue");
|
||||
_NS_PRIVATE_DEF_SEL(unsignedIntegerValue,
|
||||
"unsignedIntegerValue");
|
||||
_NS_PRIVATE_DEF_SEL(unsignedIntValue,
|
||||
"unsignedIntValue");
|
||||
_NS_PRIVATE_DEF_SEL(unsignedLongValue,
|
||||
"unsignedLongValue");
|
||||
_NS_PRIVATE_DEF_SEL(unsignedLongLongValue,
|
||||
"unsignedLongLongValue");
|
||||
_NS_PRIVATE_DEF_SEL(unsignedShortValue,
|
||||
"unsignedShortValue");
|
||||
_NS_PRIVATE_DEF_SEL(URLForAuxiliaryExecutable_,
|
||||
"URLForAuxiliaryExecutable:");
|
||||
_NS_PRIVATE_DEF_SEL(userInfo,
|
||||
"userInfo");
|
||||
_NS_PRIVATE_DEF_SEL(userName,
|
||||
"userName");
|
||||
_NS_PRIVATE_DEF_SEL(UTF8String,
|
||||
"UTF8String");
|
||||
_NS_PRIVATE_DEF_SEL(valueWithBytes_objCType_,
|
||||
"valueWithBytes:objCType:");
|
||||
_NS_PRIVATE_DEF_SEL(valueWithPointer_,
|
||||
"valueWithPointer:");
|
||||
_NS_PRIVATE_DEF_SEL(wait,
|
||||
"wait");
|
||||
_NS_PRIVATE_DEF_SEL(waitUntilDate_,
|
||||
"waitUntilDate:");
|
||||
} // Class
|
||||
} // Private
|
||||
} // MTL
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
386
dist/include/metal_cpp/Foundation/NSProcessInfo.hpp
vendored
Normal file
386
dist/include/metal_cpp/Foundation/NSProcessInfo.hpp
vendored
Normal file
|
|
@ -0,0 +1,386 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSProcessInfo.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSNotification.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
#include <functional>
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
_NS_CONST(NotificationName, ProcessInfoThermalStateDidChangeNotification);
|
||||
_NS_CONST(NotificationName, ProcessInfoPowerStateDidChangeNotification);
|
||||
_NS_CONST(NotificationName, ProcessInfoPerformanceProfileDidChangeNotification);
|
||||
|
||||
_NS_ENUM(NS::Integer, ProcessInfoThermalState) {
|
||||
ProcessInfoThermalStateNominal = 0,
|
||||
ProcessInfoThermalStateFair = 1,
|
||||
ProcessInfoThermalStateSerious = 2,
|
||||
ProcessInfoThermalStateCritical = 3
|
||||
};
|
||||
|
||||
_NS_OPTIONS(std::uint64_t, ActivityOptions) {
|
||||
ActivityIdleDisplaySleepDisabled = (1ULL << 40),
|
||||
ActivityIdleSystemSleepDisabled = (1ULL << 20),
|
||||
ActivitySuddenTerminationDisabled = (1ULL << 14),
|
||||
ActivityAutomaticTerminationDisabled = (1ULL << 15),
|
||||
ActivityUserInitiated = (0x00FFFFFFULL | ActivityIdleSystemSleepDisabled),
|
||||
ActivityUserInitiatedAllowingIdleSystemSleep = (ActivityUserInitiated & ~ActivityIdleSystemSleepDisabled),
|
||||
ActivityBackground = 0x000000FFULL,
|
||||
ActivityLatencyCritical = 0xFF00000000ULL,
|
||||
};
|
||||
|
||||
typedef NS::Integer DeviceCertification;
|
||||
_NS_CONST(DeviceCertification, DeviceCertificationiPhonePerformanceGaming);
|
||||
|
||||
typedef NS::Integer ProcessPerformanceProfile;
|
||||
_NS_CONST(ProcessPerformanceProfile, ProcessPerformanceProfileDefault);
|
||||
_NS_CONST(ProcessPerformanceProfile, ProcessPerformanceProfileSustained);
|
||||
|
||||
class ProcessInfo : public Referencing<ProcessInfo>
|
||||
{
|
||||
public:
|
||||
static ProcessInfo* processInfo();
|
||||
|
||||
class Array* arguments() const;
|
||||
class Dictionary* environment() const;
|
||||
class String* hostName() const;
|
||||
class String* processName() const;
|
||||
void setProcessName(const String* pString);
|
||||
int processIdentifier() const;
|
||||
class String* globallyUniqueString() const;
|
||||
|
||||
class String* userName() const;
|
||||
class String* fullUserName() const;
|
||||
|
||||
UInteger operatingSystem() const;
|
||||
OperatingSystemVersion operatingSystemVersion() const;
|
||||
class String* operatingSystemVersionString() const;
|
||||
bool isOperatingSystemAtLeastVersion(OperatingSystemVersion version) const;
|
||||
|
||||
UInteger processorCount() const;
|
||||
UInteger activeProcessorCount() const;
|
||||
unsigned long long physicalMemory() const;
|
||||
TimeInterval systemUptime() const;
|
||||
|
||||
void disableSuddenTermination();
|
||||
void enableSuddenTermination();
|
||||
|
||||
void disableAutomaticTermination(const class String* pReason);
|
||||
void enableAutomaticTermination(const class String* pReason);
|
||||
bool automaticTerminationSupportEnabled() const;
|
||||
void setAutomaticTerminationSupportEnabled(bool enabled);
|
||||
|
||||
class Object* beginActivity(ActivityOptions options, const class String* pReason);
|
||||
void endActivity(class Object* pActivity);
|
||||
void performActivity(ActivityOptions options, const class String* pReason, void (^block)(void));
|
||||
void performActivity(ActivityOptions options, const class String* pReason, const std::function<void()>& func);
|
||||
void performExpiringActivity(const class String* pReason, void (^block)(bool expired));
|
||||
void performExpiringActivity(const class String* pReason, const std::function<void(bool expired)>& func);
|
||||
|
||||
ProcessInfoThermalState thermalState() const;
|
||||
bool isLowPowerModeEnabled() const;
|
||||
|
||||
bool isiOSAppOnMac() const;
|
||||
bool isMacCatalystApp() const;
|
||||
|
||||
bool isDeviceCertified(DeviceCertification performanceTier) const;
|
||||
bool hasPerformanceProfile(ProcessPerformanceProfile performanceProfile) const;
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_PRIVATE_DEF_CONST(NS::NotificationName, ProcessInfoThermalStateDidChangeNotification);
|
||||
_NS_PRIVATE_DEF_CONST(NS::NotificationName, ProcessInfoPowerStateDidChangeNotification);
|
||||
|
||||
// The linker searches for these symbols in the Metal framework, be sure to link it in as well:
|
||||
_NS_PRIVATE_DEF_CONST(NS::NotificationName, ProcessInfoPerformanceProfileDidChangeNotification);
|
||||
_NS_PRIVATE_DEF_CONST(NS::DeviceCertification, DeviceCertificationiPhonePerformanceGaming);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ProcessPerformanceProfile, ProcessPerformanceProfileDefault);
|
||||
_NS_PRIVATE_DEF_CONST(NS::ProcessPerformanceProfile, ProcessPerformanceProfileSustained);
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::ProcessInfo* NS::ProcessInfo::processInfo()
|
||||
{
|
||||
return Object::sendMessage<ProcessInfo*>(_NS_PRIVATE_CLS(NSProcessInfo), _NS_PRIVATE_SEL(processInfo));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Array* NS::ProcessInfo::arguments() const
|
||||
{
|
||||
return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(arguments));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Dictionary* NS::ProcessInfo::environment() const
|
||||
{
|
||||
return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(environment));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::ProcessInfo::hostName() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(hostName));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::ProcessInfo::processName() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(processName));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::setProcessName(const String* pString)
|
||||
{
|
||||
Object::sendMessage<void>(this, _NS_PRIVATE_SEL(setProcessName_), pString);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE int NS::ProcessInfo::processIdentifier() const
|
||||
{
|
||||
return Object::sendMessage<int>(this, _NS_PRIVATE_SEL(processIdentifier));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::ProcessInfo::globallyUniqueString() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(globallyUniqueString));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::ProcessInfo::userName() const
|
||||
{
|
||||
return Object::sendMessageSafe<String*>(this, _NS_PRIVATE_SEL(userName));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::ProcessInfo::fullUserName() const
|
||||
{
|
||||
return Object::sendMessageSafe<String*>(this, _NS_PRIVATE_SEL(fullUserName));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::ProcessInfo::operatingSystem() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(operatingSystem));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::OperatingSystemVersion NS::ProcessInfo::operatingSystemVersion() const
|
||||
{
|
||||
return Object::sendMessage<OperatingSystemVersion>(this, _NS_PRIVATE_SEL(operatingSystemVersion));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::ProcessInfo::operatingSystemVersionString() const
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(operatingSystemVersionString));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::ProcessInfo::isOperatingSystemAtLeastVersion(OperatingSystemVersion version) const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isOperatingSystemAtLeastVersion_), version);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::ProcessInfo::processorCount() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(processorCount));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::ProcessInfo::activeProcessorCount() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(activeProcessorCount));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE unsigned long long NS::ProcessInfo::physicalMemory() const
|
||||
{
|
||||
return Object::sendMessage<unsigned long long>(this, _NS_PRIVATE_SEL(physicalMemory));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::TimeInterval NS::ProcessInfo::systemUptime() const
|
||||
{
|
||||
return Object::sendMessage<TimeInterval>(this, _NS_PRIVATE_SEL(systemUptime));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::disableSuddenTermination()
|
||||
{
|
||||
Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(disableSuddenTermination));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::enableSuddenTermination()
|
||||
{
|
||||
Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(enableSuddenTermination));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::disableAutomaticTermination(const String* pReason)
|
||||
{
|
||||
Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(disableAutomaticTermination_), pReason);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::enableAutomaticTermination(const String* pReason)
|
||||
{
|
||||
Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(enableAutomaticTermination_), pReason);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::ProcessInfo::automaticTerminationSupportEnabled() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(automaticTerminationSupportEnabled));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::setAutomaticTerminationSupportEnabled(bool enabled)
|
||||
{
|
||||
Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(setAutomaticTerminationSupportEnabled_), enabled);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Object* NS::ProcessInfo::beginActivity(ActivityOptions options, const String* pReason)
|
||||
{
|
||||
return Object::sendMessage<Object*>(this, _NS_PRIVATE_SEL(beginActivityWithOptions_reason_), options, pReason);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::endActivity(Object* pActivity)
|
||||
{
|
||||
Object::sendMessage<void>(this, _NS_PRIVATE_SEL(endActivity_), pActivity);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::performActivity(ActivityOptions options, const String* pReason, void (^block)(void))
|
||||
{
|
||||
Object::sendMessage<void>(this, _NS_PRIVATE_SEL(performActivityWithOptions_reason_usingBlock_), options, pReason, block);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::performActivity(ActivityOptions options, const String* pReason, const std::function<void()>& function)
|
||||
{
|
||||
__block std::function<void()> blockFunction = function;
|
||||
|
||||
performActivity(options, pReason, ^() { blockFunction(); });
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::performExpiringActivity(const String* pReason, void (^block)(bool expired))
|
||||
{
|
||||
Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(performExpiringActivityWithReason_usingBlock_), pReason, block);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE void NS::ProcessInfo::performExpiringActivity(const String* pReason, const std::function<void(bool expired)>& function)
|
||||
{
|
||||
__block std::function<void(bool expired)> blockFunction = function;
|
||||
|
||||
performExpiringActivity(pReason, ^(bool expired) { blockFunction(expired); });
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::ProcessInfoThermalState NS::ProcessInfo::thermalState() const
|
||||
{
|
||||
return Object::sendMessage<ProcessInfoThermalState>(this, _NS_PRIVATE_SEL(thermalState));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::ProcessInfo::isLowPowerModeEnabled() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(isLowPowerModeEnabled));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::ProcessInfo::isiOSAppOnMac() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(isiOSAppOnMac));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::ProcessInfo::isMacCatalystApp() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(isMacCatalystApp));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::ProcessInfo::isDeviceCertified(DeviceCertification performanceTier) const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(isDeviceCertified_), performanceTier);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::ProcessInfo::hasPerformanceProfile(ProcessPerformanceProfile performanceProfile) const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(hasPerformanceProfile_), performanceProfile);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
83
dist/include/metal_cpp/Foundation/NSRange.hpp
vendored
Normal file
83
dist/include/metal_cpp/Foundation/NSRange.hpp
vendored
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSRange.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
struct Range
|
||||
{
|
||||
static Range Make(UInteger loc, UInteger len);
|
||||
|
||||
Range(UInteger loc, UInteger len);
|
||||
|
||||
bool Equal(const Range& range) const;
|
||||
bool LocationInRange(UInteger loc) const;
|
||||
UInteger Max() const;
|
||||
|
||||
UInteger location;
|
||||
UInteger length;
|
||||
} _NS_PACKED;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Range::Range(UInteger loc, UInteger len)
|
||||
: location(loc)
|
||||
, length(len)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Range NS::Range::Make(UInteger loc, UInteger len)
|
||||
{
|
||||
return Range(loc, len);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Range::Equal(const Range& range) const
|
||||
{
|
||||
return (location == range.location) && (length == range.length);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::Range::LocationInRange(UInteger loc) const
|
||||
{
|
||||
return (!(loc < location)) && ((loc - location) < length);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::Range::Max() const
|
||||
{
|
||||
return location + length;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
87
dist/include/metal_cpp/Foundation/NSSet.hpp
vendored
Normal file
87
dist/include/metal_cpp/Foundation/NSSet.hpp
vendored
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSSet.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSObject.hpp"
|
||||
#include "NSEnumerator.hpp"
|
||||
|
||||
/*****Immutable Set*******/
|
||||
|
||||
namespace NS
|
||||
{
|
||||
class Set : public NS::Copying <Set>
|
||||
{
|
||||
public:
|
||||
UInteger count() const;
|
||||
Enumerator<Object>* objectEnumerator() const;
|
||||
|
||||
static Set* alloc();
|
||||
|
||||
Set* init();
|
||||
Set* init(const Object* const* pObjects, UInteger count);
|
||||
Set* init(const class Coder* pCoder);
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::Set::count() const
|
||||
{
|
||||
return NS::Object::sendMessage<NS::UInteger>(this, _NS_PRIVATE_SEL(count));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Enumerator<NS::Object>* NS::Set::objectEnumerator() const
|
||||
{
|
||||
return NS::Object::sendMessage<Enumerator<NS::Object>*>(this, _NS_PRIVATE_SEL(objectEnumerator));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Set* NS::Set::alloc()
|
||||
{
|
||||
return NS::Object::alloc<Set>(_NS_PRIVATE_CLS(NSSet));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Set* NS::Set::init()
|
||||
{
|
||||
return NS::Object::init<Set>();
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Set* NS::Set::init(const Object* const* pObjects, NS::UInteger count)
|
||||
{
|
||||
return NS::Object::sendMessage<Set*>(this, _NS_PRIVATE_SEL(initWithObjects_count_), pObjects, count);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Set* NS::Set::init(const class Coder* pCoder)
|
||||
{
|
||||
return Object::sendMessage<Set*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
|
||||
}
|
||||
310
dist/include/metal_cpp/Foundation/NSSharedPtr.hpp
vendored
Normal file
310
dist/include/metal_cpp/Foundation/NSSharedPtr.hpp
vendored
Normal file
|
|
@ -0,0 +1,310 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSSharedPtr.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 <cstddef>
|
||||
#include "NSDefines.hpp"
|
||||
|
||||
namespace NS
|
||||
{
|
||||
template <class _Class>
|
||||
class SharedPtr
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Create a new null pointer.
|
||||
*/
|
||||
SharedPtr();
|
||||
|
||||
/**
|
||||
* Destroy this SharedPtr, decreasing the reference count.
|
||||
*/
|
||||
~SharedPtr();
|
||||
|
||||
/**
|
||||
* Create a new null pointer.
|
||||
*/
|
||||
SharedPtr(std::nullptr_t) noexcept;
|
||||
|
||||
/**
|
||||
* SharedPtr copy constructor.
|
||||
*/
|
||||
SharedPtr(const SharedPtr<_Class>& other) noexcept;
|
||||
|
||||
/**
|
||||
* Construction from another pointee type.
|
||||
*/
|
||||
template <class _OtherClass>
|
||||
SharedPtr(const SharedPtr<_OtherClass>& other, typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>> * = nullptr) noexcept;
|
||||
|
||||
/**
|
||||
* SharedPtr move constructor.
|
||||
*/
|
||||
SharedPtr(SharedPtr<_Class>&& other) noexcept;
|
||||
|
||||
/**
|
||||
* Move from another pointee type.
|
||||
*/
|
||||
template <class _OtherClass>
|
||||
SharedPtr(SharedPtr<_OtherClass>&& other, typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>> * = nullptr) noexcept;
|
||||
|
||||
/**
|
||||
* Copy assignment operator.
|
||||
* Copying increases reference count. Only releases previous pointee if objects are different.
|
||||
*/
|
||||
SharedPtr& operator=(const SharedPtr<_Class>& other);
|
||||
|
||||
/**
|
||||
* Copy-assignment from different pointee.
|
||||
* Copying increases reference count. Only releases previous pointee if objects are different.
|
||||
*/
|
||||
template <class _OtherClass>
|
||||
typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>, SharedPtr &>
|
||||
operator=(const SharedPtr<_OtherClass>& other);
|
||||
|
||||
/**
|
||||
* Move assignment operator.
|
||||
* Move without affecting reference counts, unless pointees are equal. Moved-from object is reset to nullptr.
|
||||
*/
|
||||
SharedPtr& operator=(SharedPtr<_Class>&& other);
|
||||
|
||||
/**
|
||||
* Move-asignment from different pointee.
|
||||
* Move without affecting reference counts, unless pointees are equal. Moved-from object is reset to nullptr.
|
||||
*/
|
||||
template <class _OtherClass>
|
||||
typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>, SharedPtr &>
|
||||
operator=(SharedPtr<_OtherClass>&& other);
|
||||
|
||||
/**
|
||||
* Access raw pointee.
|
||||
* @warning Avoid wrapping the returned value again, as it may lead double frees unless this object becomes detached.
|
||||
*/
|
||||
_Class* get() const;
|
||||
|
||||
/**
|
||||
* Call operations directly on the pointee.
|
||||
*/
|
||||
_Class* operator->() const;
|
||||
|
||||
/**
|
||||
* Implicit cast to bool.
|
||||
*/
|
||||
explicit operator bool() const;
|
||||
|
||||
/**
|
||||
* Reset this SharedPtr to null, decreasing the reference count.
|
||||
*/
|
||||
void reset();
|
||||
|
||||
/**
|
||||
* Detach the SharedPtr from the pointee, without decreasing the reference count.
|
||||
*/
|
||||
void detach();
|
||||
|
||||
template <class _OtherClass>
|
||||
friend SharedPtr<_OtherClass> RetainPtr(_OtherClass* ptr);
|
||||
|
||||
template <class _OtherClass>
|
||||
friend SharedPtr<_OtherClass> TransferPtr(_OtherClass* ptr);
|
||||
|
||||
private:
|
||||
_Class* m_pObject;
|
||||
};
|
||||
|
||||
/**
|
||||
* Create a SharedPtr by retaining an existing raw pointer.
|
||||
* Increases the reference count of the passed-in object.
|
||||
* If the passed-in object was in an AutoreleasePool, it will be removed from it.
|
||||
*/
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class> RetainPtr(_Class* pObject)
|
||||
{
|
||||
NS::SharedPtr<_Class> ret;
|
||||
ret.m_pObject = pObject->retain();
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Create a SharedPtr by transfering the ownership of an existing raw pointer to SharedPtr.
|
||||
* Does not increase the reference count of the passed-in pointer, it is assumed to be >= 1.
|
||||
* This method does not remove objects from an AutoreleasePool.
|
||||
*/
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class> TransferPtr(_Class* pObject)
|
||||
{
|
||||
NS::SharedPtr<_Class> ret;
|
||||
ret.m_pObject = pObject;
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::SharedPtr()
|
||||
: m_pObject(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::~SharedPtr<_Class>() __attribute__((no_sanitize("undefined")))
|
||||
{
|
||||
m_pObject->release();
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(std::nullptr_t) noexcept
|
||||
: m_pObject(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(const SharedPtr<_Class>& other) noexcept
|
||||
: m_pObject(other.m_pObject->retain())
|
||||
{
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
template <class _OtherClass>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(const SharedPtr<_OtherClass>& other, typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>> *) noexcept
|
||||
: m_pObject(reinterpret_cast<_Class*>(other.get()->retain()))
|
||||
{
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(SharedPtr<_Class>&& other) noexcept
|
||||
: m_pObject(other.m_pObject)
|
||||
{
|
||||
other.m_pObject = nullptr;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
template <class _OtherClass>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(SharedPtr<_OtherClass>&& other, typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>> *) noexcept
|
||||
: m_pObject(reinterpret_cast<_Class*>(other.get()))
|
||||
{
|
||||
other.detach();
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE _Class* NS::SharedPtr<_Class>::get() const
|
||||
{
|
||||
return m_pObject;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE _Class* NS::SharedPtr<_Class>::operator->() const
|
||||
{
|
||||
return m_pObject;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::operator bool() const
|
||||
{
|
||||
return nullptr != m_pObject;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE void NS::SharedPtr<_Class>::reset() __attribute__((no_sanitize("undefined")))
|
||||
{
|
||||
m_pObject->release();
|
||||
m_pObject = nullptr;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE void NS::SharedPtr<_Class>::detach()
|
||||
{
|
||||
m_pObject = nullptr;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class>& NS::SharedPtr<_Class>::operator=(const SharedPtr<_Class>& other) __attribute__((no_sanitize("undefined")))
|
||||
{
|
||||
_Class* pOldObject = m_pObject;
|
||||
|
||||
m_pObject = other.m_pObject->retain();
|
||||
|
||||
pOldObject->release();
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
template <class _OtherClass>
|
||||
typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>, NS::SharedPtr<_Class> &>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::operator=(const SharedPtr<_OtherClass>& other) __attribute__((no_sanitize("undefined")))
|
||||
{
|
||||
_Class* pOldObject = m_pObject;
|
||||
|
||||
m_pObject = reinterpret_cast<_Class*>(other.get()->retain());
|
||||
|
||||
pOldObject->release();
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
_NS_INLINE NS::SharedPtr<_Class>& NS::SharedPtr<_Class>::operator=(SharedPtr<_Class>&& other) __attribute__((no_sanitize("undefined")))
|
||||
{
|
||||
if (m_pObject != other.m_pObject)
|
||||
{
|
||||
m_pObject->release();
|
||||
m_pObject = other.m_pObject;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pObject = other.m_pObject;
|
||||
other.m_pObject->release();
|
||||
}
|
||||
other.m_pObject = nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class _Class>
|
||||
template <class _OtherClass>
|
||||
typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>, NS::SharedPtr<_Class> &>
|
||||
_NS_INLINE NS::SharedPtr<_Class>::operator=(SharedPtr<_OtherClass>&& other) __attribute__((no_sanitize("undefined")))
|
||||
{
|
||||
if (m_pObject != other.get())
|
||||
{
|
||||
m_pObject->release();
|
||||
m_pObject = reinterpret_cast<_Class*>(other.get());
|
||||
other.detach();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pObject = other.get();
|
||||
other.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class _ClassLhs, class _ClassRhs>
|
||||
_NS_INLINE bool operator==(const NS::SharedPtr<_ClassLhs>& lhs, const NS::SharedPtr<_ClassRhs>& rhs)
|
||||
{
|
||||
return lhs.get() == rhs.get();
|
||||
}
|
||||
|
||||
template <class _ClassLhs, class _ClassRhs>
|
||||
_NS_INLINE bool operator!=(const NS::SharedPtr<_ClassLhs>& lhs, const NS::SharedPtr<_ClassRhs>& rhs)
|
||||
{
|
||||
return lhs.get() != rhs.get();
|
||||
}
|
||||
255
dist/include/metal_cpp/Foundation/NSString.hpp
vendored
Normal file
255
dist/include/metal_cpp/Foundation/NSString.hpp
vendored
Normal file
|
|
@ -0,0 +1,255 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSString.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSObjCRuntime.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSRange.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
_NS_ENUM(NS::UInteger, StringEncoding) {
|
||||
ASCIIStringEncoding = 1,
|
||||
NEXTSTEPStringEncoding = 2,
|
||||
JapaneseEUCStringEncoding = 3,
|
||||
UTF8StringEncoding = 4,
|
||||
ISOLatin1StringEncoding = 5,
|
||||
SymbolStringEncoding = 6,
|
||||
NonLossyASCIIStringEncoding = 7,
|
||||
ShiftJISStringEncoding = 8,
|
||||
ISOLatin2StringEncoding = 9,
|
||||
UnicodeStringEncoding = 10,
|
||||
WindowsCP1251StringEncoding = 11,
|
||||
WindowsCP1252StringEncoding = 12,
|
||||
WindowsCP1253StringEncoding = 13,
|
||||
WindowsCP1254StringEncoding = 14,
|
||||
WindowsCP1250StringEncoding = 15,
|
||||
ISO2022JPStringEncoding = 21,
|
||||
MacOSRomanStringEncoding = 30,
|
||||
|
||||
UTF16StringEncoding = UnicodeStringEncoding,
|
||||
|
||||
UTF16BigEndianStringEncoding = 0x90000100,
|
||||
UTF16LittleEndianStringEncoding = 0x94000100,
|
||||
|
||||
UTF32StringEncoding = 0x8c000100,
|
||||
UTF32BigEndianStringEncoding = 0x98000100,
|
||||
UTF32LittleEndianStringEncoding = 0x9c000100
|
||||
};
|
||||
|
||||
_NS_OPTIONS(NS::UInteger, StringCompareOptions) {
|
||||
CaseInsensitiveSearch = 1,
|
||||
LiteralSearch = 2,
|
||||
BackwardsSearch = 4,
|
||||
AnchoredSearch = 8,
|
||||
NumericSearch = 64,
|
||||
DiacriticInsensitiveSearch = 128,
|
||||
WidthInsensitiveSearch = 256,
|
||||
ForcedOrderingSearch = 512,
|
||||
RegularExpressionSearch = 1024
|
||||
};
|
||||
|
||||
using unichar = unsigned short;
|
||||
|
||||
class String : public Copying<String>
|
||||
{
|
||||
public:
|
||||
static String* string();
|
||||
static String* string(const String* pString);
|
||||
static String* string(const char* pString, StringEncoding encoding);
|
||||
|
||||
static String* alloc();
|
||||
String* init();
|
||||
String* init(const String* pString);
|
||||
String* init(const char* pString, StringEncoding encoding);
|
||||
String* init(void* pBytes, UInteger len, StringEncoding encoding, bool freeBuffer);
|
||||
|
||||
unichar character(UInteger index) const;
|
||||
UInteger length() const;
|
||||
|
||||
const char* cString(StringEncoding encoding) const;
|
||||
const char* utf8String() const;
|
||||
UInteger maximumLengthOfBytes(StringEncoding encoding) const;
|
||||
UInteger lengthOfBytes(StringEncoding encoding) const;
|
||||
|
||||
bool isEqualToString(const String* pString) const;
|
||||
Range rangeOfString(const String* pString, StringCompareOptions options) const;
|
||||
|
||||
const char* fileSystemRepresentation() const;
|
||||
|
||||
String* stringByAppendingString(const String* pString) const;
|
||||
ComparisonResult caseInsensitiveCompare(const String* pString) const;
|
||||
};
|
||||
|
||||
/// Create an NS::String* from a string literal.
|
||||
#define MTLSTR(literal) (NS::String*)__builtin___CFStringMakeConstantString("" literal "")
|
||||
|
||||
template <std::size_t _StringLen>
|
||||
[[deprecated("please use MTLSTR(str)")]] constexpr const String* MakeConstantString(const char (&str)[_StringLen])
|
||||
{
|
||||
return reinterpret_cast<const String*>(__CFStringMakeConstantString(str));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::string()
|
||||
{
|
||||
return Object::sendMessage<String*>(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(string));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::string(const String* pString)
|
||||
{
|
||||
return Object::sendMessage<String*>(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(stringWithString_), pString);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::string(const char* pString, StringEncoding encoding)
|
||||
{
|
||||
return Object::sendMessage<String*>(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(stringWithCString_encoding_), pString, encoding);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::alloc()
|
||||
{
|
||||
return Object::alloc<String>(_NS_PRIVATE_CLS(NSString));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::init()
|
||||
{
|
||||
return Object::init<String>();
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::init(const String* pString)
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(initWithString_), pString);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::init(const char* pString, StringEncoding encoding)
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(initWithCString_encoding_), pString, encoding);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::init(void* pBytes, UInteger len, StringEncoding encoding, bool freeBuffer)
|
||||
{
|
||||
return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(initWithBytesNoCopy_length_encoding_freeWhenDone_), pBytes, len, encoding, freeBuffer);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::unichar NS::String::character(UInteger index) const
|
||||
{
|
||||
return Object::sendMessage<unichar>(this, _NS_PRIVATE_SEL(characterAtIndex_), index);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::String::length() const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(length));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE const char* NS::String::cString(StringEncoding encoding) const
|
||||
{
|
||||
return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(cStringUsingEncoding_), encoding);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE const char* NS::String::utf8String() const
|
||||
{
|
||||
return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(UTF8String));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::String::maximumLengthOfBytes(StringEncoding encoding) const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(maximumLengthOfBytesUsingEncoding_), encoding);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::UInteger NS::String::lengthOfBytes(StringEncoding encoding) const
|
||||
{
|
||||
return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(lengthOfBytesUsingEncoding_), encoding);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE bool NS::String::isEqualToString(const NS::String* pString) const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isEqualToString_), pString);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::Range NS::String::rangeOfString(const NS::String* pString, NS::StringCompareOptions options) const
|
||||
{
|
||||
return Object::sendMessage<Range>(this, _NS_PRIVATE_SEL(rangeOfString_options_), pString, options);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE const char* NS::String::fileSystemRepresentation() const
|
||||
{
|
||||
return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(fileSystemRepresentation));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::String* NS::String::stringByAppendingString(const String* pString) const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _NS_PRIVATE_SEL(stringByAppendingString_), pString);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::ComparisonResult NS::String::caseInsensitiveCompare(const String* pString) const
|
||||
{
|
||||
return Object::sendMessage<NS::ComparisonResult>(this, _NS_PRIVATE_SEL(caseInsensitiveCompare_), pString);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
51
dist/include/metal_cpp/Foundation/NSTypes.hpp
vendored
Normal file
51
dist/include/metal_cpp/Foundation/NSTypes.hpp
vendored
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSTypes.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
|
||||
#include <CoreFoundation/CoreFoundation.h>
|
||||
#include <cstdint>
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
using TimeInterval = double;
|
||||
|
||||
using Integer = std::intptr_t;
|
||||
using UInteger = std::uintptr_t;
|
||||
|
||||
const Integer IntegerMax = INTPTR_MAX;
|
||||
const Integer IntegerMin = INTPTR_MIN;
|
||||
const UInteger UIntegerMax = UINTPTR_MAX;
|
||||
|
||||
struct OperatingSystemVersion
|
||||
{
|
||||
Integer majorVersion;
|
||||
Integer minorVersion;
|
||||
Integer patchVersion;
|
||||
} _NS_PACKED;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
90
dist/include/metal_cpp/Foundation/NSURL.hpp
vendored
Normal file
90
dist/include/metal_cpp/Foundation/NSURL.hpp
vendored
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Foundation/NSURL.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "NSDefines.hpp"
|
||||
#include "NSObject.hpp"
|
||||
#include "NSPrivate.hpp"
|
||||
#include "NSTypes.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace NS
|
||||
{
|
||||
class URL : public Copying<URL>
|
||||
{
|
||||
public:
|
||||
static URL* fileURLWithPath(const class String* pPath);
|
||||
|
||||
static URL* alloc();
|
||||
URL* init();
|
||||
URL* init(const class String* pString);
|
||||
URL* initFileURLWithPath(const class String* pPath);
|
||||
|
||||
const char* fileSystemRepresentation() const;
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::URL::fileURLWithPath(const String* pPath)
|
||||
{
|
||||
return Object::sendMessage<URL*>(_NS_PRIVATE_CLS(NSURL), _NS_PRIVATE_SEL(fileURLWithPath_), pPath);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::URL::alloc()
|
||||
{
|
||||
return Object::alloc<URL>(_NS_PRIVATE_CLS(NSURL));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::URL::init()
|
||||
{
|
||||
return Object::init<URL>();
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::URL::init(const String* pString)
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(initWithString_), pString);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE NS::URL* NS::URL::initFileURLWithPath(const String* pPath)
|
||||
{
|
||||
return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(initFileURLWithPath_), pPath);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_NS_INLINE const char* NS::URL::fileSystemRepresentation() const
|
||||
{
|
||||
return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(fileSystemRepresentation));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
202
dist/include/metal_cpp/LICENSE.txt
vendored
Normal file
202
dist/include/metal_cpp/LICENSE.txt
vendored
Normal file
|
|
@ -0,0 +1,202 @@
|
|||
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright © 2024 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.
|
||||
1395
dist/include/metal_cpp/Metal/MTL4AccelerationStructure.hpp
vendored
Normal file
1395
dist/include/metal_cpp/Metal/MTL4AccelerationStructure.hpp
vendored
Normal file
File diff suppressed because it is too large
Load diff
93
dist/include/metal_cpp/Metal/MTL4Archive.hpp
vendored
Normal file
93
dist/include/metal_cpp/Metal/MTL4Archive.hpp
vendored
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4Archive.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class ComputePipelineState;
|
||||
class RenderPipelineState;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class BinaryFunction;
|
||||
class BinaryFunctionDescriptor;
|
||||
class ComputePipelineDescriptor;
|
||||
class PipelineDescriptor;
|
||||
class PipelineStageDynamicLinkingDescriptor;
|
||||
class RenderPipelineDynamicLinkingDescriptor;
|
||||
|
||||
class Archive : public NS::Referencing<Archive>
|
||||
{
|
||||
public:
|
||||
NS::String* label() const;
|
||||
|
||||
BinaryFunction* newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, NS::Error** error);
|
||||
|
||||
MTL::ComputePipelineState* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, NS::Error** error);
|
||||
MTL::ComputePipelineState* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, NS::Error** error);
|
||||
|
||||
MTL::RenderPipelineState* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, NS::Error** error);
|
||||
MTL::RenderPipelineState* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, NS::Error** error);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE NS::String* MTL4::Archive::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::BinaryFunction* MTL4::Archive::newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL4::BinaryFunction*>(this, _MTL_PRIVATE_SEL(newBinaryFunctionWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineState* MTL4::Archive::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineState* MTL4::Archive::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_error_), descriptor, dynamicLinkingDescriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderPipelineState* MTL4::Archive::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderPipelineState* MTL4::Archive::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_error_), descriptor, dynamicLinkingDescriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::Archive::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
187
dist/include/metal_cpp/Metal/MTL4ArgumentTable.hpp
vendored
Normal file
187
dist/include/metal_cpp/Metal/MTL4ArgumentTable.hpp
vendored
Normal file
|
|
@ -0,0 +1,187 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4ArgumentTable.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 "MTLDefines.hpp"
|
||||
#include "MTLGPUAddress.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class ArgumentTableDescriptor : public NS::Copying<ArgumentTableDescriptor>
|
||||
{
|
||||
public:
|
||||
static ArgumentTableDescriptor* alloc();
|
||||
|
||||
ArgumentTableDescriptor* init();
|
||||
bool initializeBindings() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
NS::UInteger maxBufferBindCount() const;
|
||||
|
||||
NS::UInteger maxSamplerStateBindCount() const;
|
||||
|
||||
NS::UInteger maxTextureBindCount() const;
|
||||
|
||||
void setInitializeBindings(bool initializeBindings);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void setMaxBufferBindCount(NS::UInteger maxBufferBindCount);
|
||||
|
||||
void setMaxSamplerStateBindCount(NS::UInteger maxSamplerStateBindCount);
|
||||
|
||||
void setMaxTextureBindCount(NS::UInteger maxTextureBindCount);
|
||||
|
||||
void setSupportAttributeStrides(bool supportAttributeStrides);
|
||||
bool supportAttributeStrides() const;
|
||||
};
|
||||
class ArgumentTable : public NS::Referencing<ArgumentTable>
|
||||
{
|
||||
public:
|
||||
MTL::Device* device() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
void setAddress(MTL::GPUAddress gpuAddress, NS::UInteger bindingIndex);
|
||||
void setAddress(MTL::GPUAddress gpuAddress, NS::UInteger stride, NS::UInteger bindingIndex);
|
||||
|
||||
void setResource(MTL::ResourceID resourceID, NS::UInteger bindingIndex);
|
||||
|
||||
void setSamplerState(MTL::ResourceID resourceID, NS::UInteger bindingIndex);
|
||||
|
||||
void setTexture(MTL::ResourceID resourceID, NS::UInteger bindingIndex);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::ArgumentTableDescriptor* MTL4::ArgumentTableDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::ArgumentTableDescriptor>(_MTL_PRIVATE_CLS(MTL4ArgumentTableDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::ArgumentTableDescriptor* MTL4::ArgumentTableDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::ArgumentTableDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::ArgumentTableDescriptor::initializeBindings() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(initializeBindings));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::ArgumentTableDescriptor::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::ArgumentTableDescriptor::maxBufferBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxBufferBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::ArgumentTableDescriptor::maxSamplerStateBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxSamplerStateBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::ArgumentTableDescriptor::maxTextureBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTextureBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTableDescriptor::setInitializeBindings(bool initializeBindings)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInitializeBindings_), initializeBindings);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTableDescriptor::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTableDescriptor::setMaxBufferBindCount(NS::UInteger maxBufferBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxBufferBindCount_), maxBufferBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTableDescriptor::setMaxSamplerStateBindCount(NS::UInteger maxSamplerStateBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxSamplerStateBindCount_), maxSamplerStateBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTableDescriptor::setMaxTextureBindCount(NS::UInteger maxTextureBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTextureBindCount_), maxTextureBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTableDescriptor::setSupportAttributeStrides(bool supportAttributeStrides)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAttributeStrides_), supportAttributeStrides);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::ArgumentTableDescriptor::supportAttributeStrides() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAttributeStrides));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL4::ArgumentTable::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::ArgumentTable::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTable::setAddress(MTL::GPUAddress gpuAddress, NS::UInteger bindingIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAddress_atIndex_), gpuAddress, bindingIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTable::setAddress(MTL::GPUAddress gpuAddress, NS::UInteger stride, NS::UInteger bindingIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAddress_attributeStride_atIndex_), gpuAddress, stride, bindingIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTable::setResource(MTL::ResourceID resourceID, NS::UInteger bindingIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResource_atBufferIndex_), resourceID, bindingIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTable::setSamplerState(MTL::ResourceID resourceID, NS::UInteger bindingIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerState_atIndex_), resourceID, bindingIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ArgumentTable::setTexture(MTL::ResourceID resourceID, NS::UInteger bindingIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTexture_atIndex_), resourceID, bindingIndex);
|
||||
}
|
||||
50
dist/include/metal_cpp/Metal/MTL4BinaryFunction.hpp
vendored
Normal file
50
dist/include/metal_cpp/Metal/MTL4BinaryFunction.hpp
vendored
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4BinaryFunction.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLLibrary.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
|
||||
class BinaryFunction : public NS::Referencing<BinaryFunction>
|
||||
{
|
||||
public:
|
||||
MTL::FunctionType functionType() const;
|
||||
|
||||
NS::String* name() const;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionType MTL4::BinaryFunction::functionType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionType>(this, _MTL_PRIVATE_SEL(functionType));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::BinaryFunction::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
97
dist/include/metal_cpp/Metal/MTL4BinaryFunctionDescriptor.hpp
vendored
Normal file
97
dist/include/metal_cpp/Metal/MTL4BinaryFunctionDescriptor.hpp
vendored
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4BinaryFunctionDescriptor.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class BinaryFunctionDescriptor;
|
||||
class FunctionDescriptor;
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, BinaryFunctionOptions) {
|
||||
BinaryFunctionOptionNone = 0,
|
||||
BinaryFunctionOptionPipelineIndependent = 1 << 1,
|
||||
};
|
||||
|
||||
class BinaryFunctionDescriptor : public NS::Copying<BinaryFunctionDescriptor>
|
||||
{
|
||||
public:
|
||||
static BinaryFunctionDescriptor* alloc();
|
||||
|
||||
FunctionDescriptor* functionDescriptor() const;
|
||||
|
||||
BinaryFunctionDescriptor* init();
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
BinaryFunctionOptions options() const;
|
||||
|
||||
void setFunctionDescriptor(const MTL4::FunctionDescriptor* functionDescriptor);
|
||||
|
||||
void setName(const NS::String* name);
|
||||
|
||||
void setOptions(MTL4::BinaryFunctionOptions options);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::BinaryFunctionDescriptor* MTL4::BinaryFunctionDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::BinaryFunctionDescriptor>(_MTL_PRIVATE_CLS(MTL4BinaryFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::BinaryFunctionDescriptor::functionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(functionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::BinaryFunctionDescriptor* MTL4::BinaryFunctionDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::BinaryFunctionDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::BinaryFunctionDescriptor::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::BinaryFunctionOptions MTL4::BinaryFunctionDescriptor::options() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::BinaryFunctionOptions>(this, _MTL_PRIVATE_SEL(options));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::BinaryFunctionDescriptor::setFunctionDescriptor(const MTL4::FunctionDescriptor* functionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionDescriptor_), functionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::BinaryFunctionDescriptor::setName(const NS::String* name)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setName_), name);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::BinaryFunctionDescriptor::setOptions(MTL4::BinaryFunctionOptions options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOptions_), options);
|
||||
}
|
||||
100
dist/include/metal_cpp/Metal/MTL4CommandAllocator.hpp
vendored
Normal file
100
dist/include/metal_cpp/Metal/MTL4CommandAllocator.hpp
vendored
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4CommandAllocator.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
|
||||
class CommandAllocatorDescriptor : public NS::Copying<CommandAllocatorDescriptor>
|
||||
{
|
||||
public:
|
||||
static CommandAllocatorDescriptor* alloc();
|
||||
|
||||
CommandAllocatorDescriptor* init();
|
||||
|
||||
NS::String* label() const;
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
|
||||
class CommandAllocator : public NS::Referencing<CommandAllocator>
|
||||
{
|
||||
public:
|
||||
uint64_t allocatedSize();
|
||||
|
||||
MTL::Device* device() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
void reset();
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CommandAllocatorDescriptor* MTL4::CommandAllocatorDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::CommandAllocatorDescriptor>(_MTL_PRIVATE_CLS(MTL4CommandAllocatorDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CommandAllocatorDescriptor* MTL4::CommandAllocatorDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::CommandAllocatorDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::CommandAllocatorDescriptor::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandAllocatorDescriptor::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE uint64_t MTL4::CommandAllocator::allocatedSize()
|
||||
{
|
||||
return Object::sendMessage<uint64_t>(this, _MTL_PRIVATE_SEL(allocatedSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL4::CommandAllocator::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::CommandAllocator::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandAllocator::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
193
dist/include/metal_cpp/Metal/MTL4CommandBuffer.hpp
vendored
Normal file
193
dist/include/metal_cpp/Metal/MTL4CommandBuffer.hpp
vendored
Normal file
|
|
@ -0,0 +1,193 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4CommandBuffer.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 "MTL4RenderCommandEncoder.hpp"
|
||||
#include "MTLAccelerationStructureTypes.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class CommandAllocator;
|
||||
class CommandBufferOptions;
|
||||
class ComputeCommandEncoder;
|
||||
class CounterHeap;
|
||||
class MachineLearningCommandEncoder;
|
||||
class RenderCommandEncoder;
|
||||
class RenderPassDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
class Fence;
|
||||
class LogState;
|
||||
class ResidencySet;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class CommandBufferOptions : public NS::Copying<CommandBufferOptions>
|
||||
{
|
||||
public:
|
||||
static CommandBufferOptions* alloc();
|
||||
|
||||
CommandBufferOptions* init();
|
||||
|
||||
MTL::LogState* logState() const;
|
||||
void setLogState(const MTL::LogState* logState);
|
||||
};
|
||||
class CommandBuffer : public NS::Referencing<CommandBuffer>
|
||||
{
|
||||
public:
|
||||
void beginCommandBuffer(const MTL4::CommandAllocator* allocator);
|
||||
void beginCommandBuffer(const MTL4::CommandAllocator* allocator, const MTL4::CommandBufferOptions* options);
|
||||
|
||||
ComputeCommandEncoder* computeCommandEncoder();
|
||||
|
||||
MTL::Device* device() const;
|
||||
|
||||
void endCommandBuffer();
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
MachineLearningCommandEncoder* machineLearningCommandEncoder();
|
||||
|
||||
void popDebugGroup();
|
||||
|
||||
void pushDebugGroup(const NS::String* string);
|
||||
|
||||
RenderCommandEncoder* renderCommandEncoder(const MTL4::RenderPassDescriptor* descriptor);
|
||||
RenderCommandEncoder* renderCommandEncoder(const MTL4::RenderPassDescriptor* descriptor, MTL4::RenderEncoderOptions options);
|
||||
|
||||
void resolveCounterHeap(const MTL4::CounterHeap* counterHeap, NS::Range range, const MTL4::BufferRange bufferRange, const MTL::Fence* fenceToWait, const MTL::Fence* fenceToUpdate);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void useResidencySet(const MTL::ResidencySet* residencySet);
|
||||
void useResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count);
|
||||
|
||||
void writeTimestampIntoHeap(const MTL4::CounterHeap* counterHeap, NS::UInteger index);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::CommandBufferOptions* MTL4::CommandBufferOptions::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::CommandBufferOptions>(_MTL_PRIVATE_CLS(MTL4CommandBufferOptions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CommandBufferOptions* MTL4::CommandBufferOptions::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::CommandBufferOptions>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LogState* MTL4::CommandBufferOptions::logState() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LogState*>(this, _MTL_PRIVATE_SEL(logState));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBufferOptions::setLogState(const MTL::LogState* logState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLogState_), logState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::beginCommandBuffer(const MTL4::CommandAllocator* allocator)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(beginCommandBufferWithAllocator_), allocator);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::beginCommandBuffer(const MTL4::CommandAllocator* allocator, const MTL4::CommandBufferOptions* options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(beginCommandBufferWithAllocator_options_), allocator, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::ComputeCommandEncoder* MTL4::CommandBuffer::computeCommandEncoder()
|
||||
{
|
||||
return Object::sendMessage<MTL4::ComputeCommandEncoder*>(this, _MTL_PRIVATE_SEL(computeCommandEncoder));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL4::CommandBuffer::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::endCommandBuffer()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(endCommandBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::CommandBuffer::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::MachineLearningCommandEncoder* MTL4::CommandBuffer::machineLearningCommandEncoder()
|
||||
{
|
||||
return Object::sendMessage<MTL4::MachineLearningCommandEncoder*>(this, _MTL_PRIVATE_SEL(machineLearningCommandEncoder));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::popDebugGroup()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(popDebugGroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::pushDebugGroup(const NS::String* string)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderCommandEncoder* MTL4::CommandBuffer::renderCommandEncoder(const MTL4::RenderPassDescriptor* descriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL4::RenderCommandEncoder*>(this, _MTL_PRIVATE_SEL(renderCommandEncoderWithDescriptor_), descriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderCommandEncoder* MTL4::CommandBuffer::renderCommandEncoder(const MTL4::RenderPassDescriptor* descriptor, MTL4::RenderEncoderOptions options)
|
||||
{
|
||||
return Object::sendMessage<MTL4::RenderCommandEncoder*>(this, _MTL_PRIVATE_SEL(renderCommandEncoderWithDescriptor_options_), descriptor, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::resolveCounterHeap(const MTL4::CounterHeap* counterHeap, NS::Range range, const MTL4::BufferRange bufferRange, const MTL::Fence* fenceToWait, const MTL::Fence* fenceToUpdate)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resolveCounterHeap_withRange_intoBuffer_waitFence_updateFence_), counterHeap, range, bufferRange, fenceToWait, fenceToUpdate);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::useResidencySet(const MTL::ResidencySet* residencySet)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResidencySet_), residencySet);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::useResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResidencySets_count_), residencySets, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandBuffer::writeTimestampIntoHeap(const MTL4::CounterHeap* counterHeap, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(writeTimestampIntoHeap_atIndex_), counterHeap, index);
|
||||
}
|
||||
134
dist/include/metal_cpp/Metal/MTL4CommandEncoder.hpp
vendored
Normal file
134
dist/include/metal_cpp/Metal/MTL4CommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4CommandEncoder.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 "MTLCommandEncoder.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class CommandBuffer;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Fence;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
_MTL_OPTIONS(NS::UInteger, VisibilityOptions) {
|
||||
VisibilityOptionNone = 0,
|
||||
VisibilityOptionDevice = 1,
|
||||
VisibilityOptionResourceAlias = 1 << 1,
|
||||
};
|
||||
|
||||
class CommandEncoder : public NS::Referencing<CommandEncoder>
|
||||
{
|
||||
public:
|
||||
void barrierAfterEncoderStages(MTL::Stages afterEncoderStages, MTL::Stages beforeEncoderStages, MTL4::VisibilityOptions visibilityOptions);
|
||||
|
||||
void barrierAfterQueueStages(MTL::Stages afterQueueStages, MTL::Stages beforeStages, MTL4::VisibilityOptions visibilityOptions);
|
||||
|
||||
void barrierAfterStages(MTL::Stages afterStages, MTL::Stages beforeQueueStages, MTL4::VisibilityOptions visibilityOptions);
|
||||
|
||||
CommandBuffer* commandBuffer() const;
|
||||
|
||||
void endEncoding();
|
||||
|
||||
void insertDebugSignpost(const NS::String* string);
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
void popDebugGroup();
|
||||
|
||||
void pushDebugGroup(const NS::String* string);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void updateFence(const MTL::Fence* fence, MTL::Stages afterEncoderStages);
|
||||
|
||||
void waitForFence(const MTL::Fence* fence, MTL::Stages beforeEncoderStages);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL4::CommandEncoder::barrierAfterEncoderStages(MTL::Stages afterEncoderStages, MTL::Stages beforeEncoderStages, MTL4::VisibilityOptions visibilityOptions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(barrierAfterEncoderStages_beforeEncoderStages_visibilityOptions_), afterEncoderStages, beforeEncoderStages, visibilityOptions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::barrierAfterQueueStages(MTL::Stages afterQueueStages, MTL::Stages beforeStages, MTL4::VisibilityOptions visibilityOptions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(barrierAfterQueueStages_beforeStages_visibilityOptions_), afterQueueStages, beforeStages, visibilityOptions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::barrierAfterStages(MTL::Stages afterStages, MTL::Stages beforeQueueStages, MTL4::VisibilityOptions visibilityOptions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(barrierAfterStages_beforeQueueStages_visibilityOptions_), afterStages, beforeQueueStages, visibilityOptions);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CommandBuffer* MTL4::CommandEncoder::commandBuffer() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::CommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::endEncoding()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(endEncoding));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::insertDebugSignpost(const NS::String* string)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(insertDebugSignpost_), string);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::CommandEncoder::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::popDebugGroup()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(popDebugGroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::pushDebugGroup(const NS::String* string)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::updateFence(const MTL::Fence* fence, MTL::Stages afterEncoderStages)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_afterEncoderStages_), fence, afterEncoderStages);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CommandEncoder::waitForFence(const MTL::Fence* fence, MTL::Stages beforeEncoderStages)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_beforeEncoderStages_), fence, beforeEncoderStages);
|
||||
}
|
||||
283
dist/include/metal_cpp/Metal/MTL4CommandQueue.hpp
vendored
Normal file
283
dist/include/metal_cpp/Metal/MTL4CommandQueue.hpp
vendored
Normal file
|
|
@ -0,0 +1,283 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// 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);
|
||||
}
|
||||
62
dist/include/metal_cpp/Metal/MTL4CommitFeedback.hpp
vendored
Normal file
62
dist/include/metal_cpp/Metal/MTL4CommitFeedback.hpp
vendored
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4CommitFeedback.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include <CoreFoundation/CoreFoundation.h>
|
||||
|
||||
#include <functional>
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class CommitFeedback;
|
||||
|
||||
using CommitFeedbackHandler = void (^)(MTL4::CommitFeedback*);
|
||||
using CommitFeedbackHandlerFunction = std::function<void(MTL4::CommitFeedback*)>;
|
||||
|
||||
class CommitFeedback : public NS::Referencing<CommitFeedback>
|
||||
{
|
||||
public:
|
||||
CFTimeInterval GPUEndTime() const;
|
||||
|
||||
CFTimeInterval GPUStartTime() const;
|
||||
|
||||
NS::Error* error() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE CFTimeInterval MTL4::CommitFeedback::GPUEndTime() const
|
||||
{
|
||||
return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(GPUEndTime));
|
||||
}
|
||||
|
||||
_MTL_INLINE CFTimeInterval MTL4::CommitFeedback::GPUStartTime() const
|
||||
{
|
||||
return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(GPUStartTime));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Error* MTL4::CommitFeedback::error() const
|
||||
{
|
||||
return Object::sendMessage<NS::Error*>(this, _MTL_PRIVATE_SEL(error));
|
||||
}
|
||||
345
dist/include/metal_cpp/Metal/MTL4Compiler.hpp
vendored
Normal file
345
dist/include/metal_cpp/Metal/MTL4Compiler.hpp
vendored
Normal file
|
|
@ -0,0 +1,345 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4Compiler.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 "MTLDefines.hpp"
|
||||
#include "MTLDevice.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
#include <functional>
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class BinaryFunction;
|
||||
class BinaryFunctionDescriptor;
|
||||
class CompilerDescriptor;
|
||||
class CompilerTask;
|
||||
class CompilerTaskOptions;
|
||||
class ComputePipelineDescriptor;
|
||||
class LibraryDescriptor;
|
||||
class MachineLearningPipelineDescriptor;
|
||||
class MachineLearningPipelineState;
|
||||
class PipelineDataSetSerializer;
|
||||
class PipelineDescriptor;
|
||||
class PipelineStageDynamicLinkingDescriptor;
|
||||
class RenderPipelineDynamicLinkingDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class ComputePipelineState;
|
||||
class Device;
|
||||
class DynamicLibrary;
|
||||
class Library;
|
||||
class RenderPipelineState;
|
||||
|
||||
using NewDynamicLibraryCompletionHandler = void (^)(MTL::DynamicLibrary*, NS::Error*);
|
||||
using NewDynamicLibraryCompletionHandlerFunction = std::function<void(MTL::DynamicLibrary*, NS::Error*)>;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
using NewComputePipelineStateCompletionHandler = void (^)(MTL::ComputePipelineState*, NS::Error*);
|
||||
using NewComputePipelineStateCompletionHandlerFunction = std::function<void(MTL::ComputePipelineState*, NS::Error*)>;
|
||||
using NewRenderPipelineStateCompletionHandler = void (^)(MTL::RenderPipelineState*, NS::Error*);
|
||||
using NewRenderPipelineStateCompletionHandlerFunction = std::function<void(MTL::RenderPipelineState*, NS::Error*)>;
|
||||
using NewBinaryFunctionCompletionHandler = void (^)(MTL4::BinaryFunction*, NS::Error*);
|
||||
using NewBinaryFunctionCompletionHandlerFunction = std::function<void(MTL4::BinaryFunction*, NS::Error*)>;
|
||||
using NewMachineLearningPipelineStateCompletionHandler = void (^)(MTL4::MachineLearningPipelineState*, NS::Error*);
|
||||
using NewMachineLearningPipelineStateCompletionHandlerFunction = std::function<void(MTL4::MachineLearningPipelineState*, NS::Error*)>;
|
||||
|
||||
class CompilerDescriptor : public NS::Copying<CompilerDescriptor>
|
||||
{
|
||||
public:
|
||||
static CompilerDescriptor* alloc();
|
||||
|
||||
CompilerDescriptor* init();
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
PipelineDataSetSerializer* pipelineDataSetSerializer() const;
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void setPipelineDataSetSerializer(const MTL4::PipelineDataSetSerializer* pipelineDataSetSerializer);
|
||||
};
|
||||
class CompilerTaskOptions : public NS::Copying<CompilerTaskOptions>
|
||||
{
|
||||
public:
|
||||
static CompilerTaskOptions* alloc();
|
||||
|
||||
CompilerTaskOptions* init();
|
||||
|
||||
NS::Array* lookupArchives() const;
|
||||
void setLookupArchives(const NS::Array* lookupArchives);
|
||||
};
|
||||
class Compiler : public NS::Referencing<Compiler>
|
||||
{
|
||||
public:
|
||||
MTL::Device* device() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
BinaryFunction* newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error);
|
||||
CompilerTask* newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL4::NewBinaryFunctionCompletionHandler completionHandler);
|
||||
|
||||
MTL::ComputePipelineState* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error);
|
||||
MTL::ComputePipelineState* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error);
|
||||
CompilerTask* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewComputePipelineStateCompletionHandler completionHandler);
|
||||
CompilerTask* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewComputePipelineStateCompletionHandler completionHandler);
|
||||
CompilerTask* newComputePipelineState(const MTL4::ComputePipelineDescriptor* pDescriptor, const MTL4::CompilerTaskOptions* options, const MTL4::NewComputePipelineStateCompletionHandlerFunction& function);
|
||||
|
||||
MTL::DynamicLibrary* newDynamicLibrary(const MTL::Library* library, NS::Error** error);
|
||||
MTL::DynamicLibrary* newDynamicLibrary(const NS::URL* url, NS::Error** error);
|
||||
CompilerTask* newDynamicLibrary(const MTL::Library* library, const MTL::NewDynamicLibraryCompletionHandler completionHandler);
|
||||
CompilerTask* newDynamicLibrary(const NS::URL* url, const MTL::NewDynamicLibraryCompletionHandler completionHandler);
|
||||
CompilerTask* newDynamicLibrary(const MTL::Library* pLibrary, const MTL::NewDynamicLibraryCompletionHandlerFunction& function);
|
||||
CompilerTask* newDynamicLibrary(const NS::URL* pURL, const MTL::NewDynamicLibraryCompletionHandlerFunction& function);
|
||||
|
||||
MTL::Library* newLibrary(const MTL4::LibraryDescriptor* descriptor, NS::Error** error);
|
||||
CompilerTask* newLibrary(const MTL4::LibraryDescriptor* descriptor, const MTL::NewLibraryCompletionHandler completionHandler);
|
||||
CompilerTask* newLibrary(const MTL4::LibraryDescriptor* pDescriptor, const MTL::NewLibraryCompletionHandlerFunction& function);
|
||||
|
||||
MachineLearningPipelineState* newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* descriptor, NS::Error** error);
|
||||
CompilerTask* newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* descriptor, const MTL4::NewMachineLearningPipelineStateCompletionHandler completionHandler);
|
||||
CompilerTask* newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* pDescriptor, const MTL4::NewMachineLearningPipelineStateCompletionHandlerFunction& function);
|
||||
|
||||
MTL::RenderPipelineState* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error);
|
||||
MTL::RenderPipelineState* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error);
|
||||
CompilerTask* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewRenderPipelineStateCompletionHandler completionHandler);
|
||||
CompilerTask* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewRenderPipelineStateCompletionHandler completionHandler);
|
||||
CompilerTask* newRenderPipelineState(const MTL4::PipelineDescriptor* pDescriptor, const MTL4::CompilerTaskOptions* options, const MTL4::NewRenderPipelineStateCompletionHandlerFunction& function);
|
||||
MTL::RenderPipelineState* newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* descriptor, const MTL::RenderPipelineState* pipeline, NS::Error** error);
|
||||
CompilerTask* newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* descriptor, const MTL::RenderPipelineState* pipeline, const MTL::NewRenderPipelineStateCompletionHandler completionHandler);
|
||||
CompilerTask* newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* pDescriptor, const MTL::RenderPipelineState* pPipeline, const MTL4::NewRenderPipelineStateCompletionHandlerFunction& function);
|
||||
|
||||
PipelineDataSetSerializer* pipelineDataSetSerializer() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::CompilerDescriptor* MTL4::CompilerDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::CompilerDescriptor>(_MTL_PRIVATE_CLS(MTL4CompilerDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerDescriptor* MTL4::CompilerDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::CompilerDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::CompilerDescriptor::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineDataSetSerializer* MTL4::CompilerDescriptor::pipelineDataSetSerializer() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineDataSetSerializer*>(this, _MTL_PRIVATE_SEL(pipelineDataSetSerializer));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CompilerDescriptor::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CompilerDescriptor::setPipelineDataSetSerializer(const MTL4::PipelineDataSetSerializer* pipelineDataSetSerializer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPipelineDataSetSerializer_), pipelineDataSetSerializer);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTaskOptions* MTL4::CompilerTaskOptions::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::CompilerTaskOptions>(_MTL_PRIVATE_CLS(MTL4CompilerTaskOptions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTaskOptions* MTL4::CompilerTaskOptions::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::CompilerTaskOptions>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::CompilerTaskOptions::lookupArchives() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(lookupArchives));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CompilerTaskOptions::setLookupArchives(const NS::Array* lookupArchives)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLookupArchives_), lookupArchives);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL4::Compiler::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::Compiler::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::BinaryFunction* MTL4::Compiler::newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL4::BinaryFunction*>(this, _MTL_PRIVATE_SEL(newBinaryFunctionWithDescriptor_compilerTaskOptions_error_), descriptor, compilerTaskOptions, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL4::NewBinaryFunctionCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newBinaryFunctionWithDescriptor_compilerTaskOptions_completionHandler_), descriptor, compilerTaskOptions, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineState* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_compilerTaskOptions_error_), descriptor, compilerTaskOptions, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineState* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_error_), descriptor, dynamicLinkingDescriptor, compilerTaskOptions, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewComputePipelineStateCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_compilerTaskOptions_completionHandler_), descriptor, compilerTaskOptions, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewComputePipelineStateCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_completionHandler_), descriptor, dynamicLinkingDescriptor, compilerTaskOptions, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* pDescriptor, const MTL4::CompilerTaskOptions* options, const MTL4::NewComputePipelineStateCompletionHandlerFunction& function)
|
||||
{
|
||||
__block MTL4::NewComputePipelineStateCompletionHandlerFunction blockFunction = function;
|
||||
return newComputePipelineState(pDescriptor, options, ^(MTL::ComputePipelineState* pPipeline, NS::Error* pError) { blockFunction(pPipeline, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DynamicLibrary* MTL4::Compiler::newDynamicLibrary(const MTL::Library* library, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::DynamicLibrary*>(this, _MTL_PRIVATE_SEL(newDynamicLibrary_error_), library, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DynamicLibrary* MTL4::Compiler::newDynamicLibrary(const NS::URL* url, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::DynamicLibrary*>(this, _MTL_PRIVATE_SEL(newDynamicLibraryWithURL_error_), url, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newDynamicLibrary(const MTL::Library* library, const MTL::NewDynamicLibraryCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newDynamicLibrary_completionHandler_), library, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newDynamicLibrary(const NS::URL* url, const MTL::NewDynamicLibraryCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newDynamicLibraryWithURL_completionHandler_), url, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newDynamicLibrary(const MTL::Library* pLibrary, const MTL::NewDynamicLibraryCompletionHandlerFunction& function)
|
||||
{
|
||||
__block MTL::NewDynamicLibraryCompletionHandlerFunction blockFunction = function;
|
||||
return newDynamicLibrary(pLibrary, ^(MTL::DynamicLibrary* pLibraryRef, NS::Error* pError) { blockFunction(pLibraryRef, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newDynamicLibrary(const NS::URL* pURL, const MTL::NewDynamicLibraryCompletionHandlerFunction& function)
|
||||
{
|
||||
__block MTL::NewDynamicLibraryCompletionHandlerFunction blockFunction = function;
|
||||
return newDynamicLibrary(pURL, ^(MTL::DynamicLibrary* pLibrary, NS::Error* pError) { blockFunction(pLibrary, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Library* MTL4::Compiler::newLibrary(const MTL4::LibraryDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(newLibraryWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newLibrary(const MTL4::LibraryDescriptor* descriptor, const MTL::NewLibraryCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newLibraryWithDescriptor_completionHandler_), descriptor, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newLibrary(const MTL4::LibraryDescriptor* pDescriptor, const MTL::NewLibraryCompletionHandlerFunction& function)
|
||||
{
|
||||
__block MTL::NewLibraryCompletionHandlerFunction blockFunction = function;
|
||||
return newLibrary(pDescriptor, ^(MTL::Library* pLibrary, NS::Error* pError) { blockFunction(pLibrary, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::MachineLearningPipelineState* MTL4::Compiler::newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL4::MachineLearningPipelineState*>(this, _MTL_PRIVATE_SEL(newMachineLearningPipelineStateWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* descriptor, const MTL4::NewMachineLearningPipelineStateCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newMachineLearningPipelineStateWithDescriptor_completionHandler_), descriptor, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* pDescriptor, const MTL4::NewMachineLearningPipelineStateCompletionHandlerFunction& function)
|
||||
{
|
||||
__block MTL4::NewMachineLearningPipelineStateCompletionHandlerFunction blockFunction = function;
|
||||
return newMachineLearningPipelineState(pDescriptor, ^(MTL4::MachineLearningPipelineState* pPipeline, NS::Error* pError) { blockFunction(pPipeline, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderPipelineState* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_compilerTaskOptions_error_), descriptor, compilerTaskOptions, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderPipelineState* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_error_), descriptor, dynamicLinkingDescriptor, compilerTaskOptions, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewRenderPipelineStateCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_compilerTaskOptions_completionHandler_), descriptor, compilerTaskOptions, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewRenderPipelineStateCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_completionHandler_), descriptor, dynamicLinkingDescriptor, compilerTaskOptions, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* pDescriptor, const MTL4::CompilerTaskOptions* options, const MTL4::NewRenderPipelineStateCompletionHandlerFunction& function)
|
||||
{
|
||||
__block MTL4::NewRenderPipelineStateCompletionHandlerFunction blockFunction = function;
|
||||
return newRenderPipelineState(pDescriptor, options, ^(MTL::RenderPipelineState* pPipeline, NS::Error* pError) { blockFunction(pPipeline, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderPipelineState* MTL4::Compiler::newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* descriptor, const MTL::RenderPipelineState* pipeline, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateBySpecializationWithDescriptor_pipeline_error_), descriptor, pipeline, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* descriptor, const MTL::RenderPipelineState* pipeline, const MTL::NewRenderPipelineStateCompletionHandler completionHandler)
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTask*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateBySpecializationWithDescriptor_pipeline_completionHandler_), descriptor, pipeline, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* pDescriptor, const MTL::RenderPipelineState* pPipeline, const MTL4::NewRenderPipelineStateCompletionHandlerFunction& function)
|
||||
{
|
||||
__block MTL4::NewRenderPipelineStateCompletionHandlerFunction blockFunction = function;
|
||||
return newRenderPipelineStateBySpecialization(pDescriptor, pPipeline, ^(MTL::RenderPipelineState* pPipelineRef, NS::Error* pError) { blockFunction(pPipelineRef, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineDataSetSerializer* MTL4::Compiler::pipelineDataSetSerializer() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineDataSetSerializer*>(this, _MTL_PRIVATE_SEL(pipelineDataSetSerializer));
|
||||
}
|
||||
63
dist/include/metal_cpp/Metal/MTL4CompilerTask.hpp
vendored
Normal file
63
dist/include/metal_cpp/Metal/MTL4CompilerTask.hpp
vendored
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4CompilerTask.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class Compiler;
|
||||
_MTL_ENUM(NS::Integer, CompilerTaskStatus) {
|
||||
CompilerTaskStatusNone = 0,
|
||||
CompilerTaskStatusScheduled = 1,
|
||||
CompilerTaskStatusCompiling = 2,
|
||||
CompilerTaskStatusFinished = 3,
|
||||
};
|
||||
|
||||
class CompilerTask : public NS::Referencing<CompilerTask>
|
||||
{
|
||||
public:
|
||||
Compiler* compiler() const;
|
||||
|
||||
CompilerTaskStatus status() const;
|
||||
|
||||
void waitUntilCompleted();
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::Compiler* MTL4::CompilerTask::compiler() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::Compiler*>(this, _MTL_PRIVATE_SEL(compiler));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CompilerTaskStatus MTL4::CompilerTask::status() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::CompilerTaskStatus>(this, _MTL_PRIVATE_SEL(status));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CompilerTask::waitUntilCompleted()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitUntilCompleted));
|
||||
}
|
||||
300
dist/include/metal_cpp/Metal/MTL4ComputeCommandEncoder.hpp
vendored
Normal file
300
dist/include/metal_cpp/Metal/MTL4ComputeCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,300 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4ComputeCommandEncoder.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 "MTL4CommandEncoder.hpp"
|
||||
#include "MTL4Counters.hpp"
|
||||
#include "MTLAccelerationStructure.hpp"
|
||||
#include "MTLAccelerationStructureTypes.hpp"
|
||||
#include "MTLBlitCommandEncoder.hpp"
|
||||
#include "MTLCommandEncoder.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLGPUAddress.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class AccelerationStructureDescriptor;
|
||||
class ArgumentTable;
|
||||
class CounterHeap;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class AccelerationStructure;
|
||||
class Buffer;
|
||||
class ComputePipelineState;
|
||||
class IndirectCommandBuffer;
|
||||
class Tensor;
|
||||
class TensorExtents;
|
||||
class Texture;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class ComputeCommandEncoder : public NS::Referencing<ComputeCommandEncoder, CommandEncoder>
|
||||
{
|
||||
public:
|
||||
void buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL4::BufferRange scratchBuffer);
|
||||
|
||||
void copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure);
|
||||
|
||||
void copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure);
|
||||
|
||||
void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size);
|
||||
void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin);
|
||||
void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options);
|
||||
|
||||
void copyFromTensor(const MTL::Tensor* sourceTensor, const MTL::TensorExtents* sourceOrigin, const MTL::TensorExtents* sourceDimensions, const MTL::Tensor* destinationTensor, const MTL::TensorExtents* destinationOrigin, const MTL::TensorExtents* destinationDimensions);
|
||||
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture);
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount);
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin);
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage);
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options);
|
||||
|
||||
void copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex);
|
||||
|
||||
void dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup);
|
||||
void dispatchThreadgroups(MTL::GPUAddress indirectBuffer, MTL::Size threadsPerThreadgroup);
|
||||
|
||||
void dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup);
|
||||
void dispatchThreads(MTL::GPUAddress indirectBuffer);
|
||||
|
||||
void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange);
|
||||
void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, MTL::GPUAddress indirectRangeBuffer);
|
||||
|
||||
void fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value);
|
||||
|
||||
void generateMipmaps(const MTL::Texture* texture);
|
||||
|
||||
void optimizeContentsForCPUAccess(const MTL::Texture* texture);
|
||||
void optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level);
|
||||
|
||||
void optimizeContentsForGPUAccess(const MTL::Texture* texture);
|
||||
void optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level);
|
||||
|
||||
void optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range);
|
||||
|
||||
void refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL4::BufferRange scratchBuffer);
|
||||
void refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL4::BufferRange scratchBuffer, MTL::AccelerationStructureRefitOptions options);
|
||||
|
||||
void resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range);
|
||||
|
||||
void setArgumentTable(const MTL4::ArgumentTable* argumentTable);
|
||||
|
||||
void setComputePipelineState(const MTL::ComputePipelineState* state);
|
||||
|
||||
void setImageblockWidth(NS::UInteger width, NS::UInteger height);
|
||||
|
||||
void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
|
||||
|
||||
MTL::Stages stages();
|
||||
|
||||
void writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL4::BufferRange buffer);
|
||||
|
||||
void writeTimestamp(MTL4::TimestampGranularity granularity, const MTL4::CounterHeap* counterHeap, NS::UInteger index);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL4::BufferRange scratchBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(buildAccelerationStructure_descriptor_scratchBuffer_), accelerationStructure, descriptor, scratchBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyAndCompactAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_), sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTensor(const MTL::Tensor* sourceTensor, const MTL::TensorExtents* sourceOrigin, const MTL::TensorExtents* sourceDimensions, const MTL::Tensor* destinationTensor, const MTL::TensorExtents* destinationOrigin, const MTL::TensorExtents* destinationDimensions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTensor_sourceOrigin_sourceDimensions_toTensor_destinationOrigin_destinationDimensions_), sourceTensor, sourceOrigin, sourceDimensions, destinationTensor, destinationOrigin, destinationDimensions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_toTexture_), sourceTexture, destinationTexture);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_), sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyIndirectCommandBuffer_sourceRange_destination_destinationIndex_), source, sourceRange, destination, destinationIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadgroups_threadsPerThreadgroup_), threadgroupsPerGrid, threadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::dispatchThreadgroups(MTL::GPUAddress indirectBuffer, MTL::Size threadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadgroupsWithIndirectBuffer_threadsPerThreadgroup_), indirectBuffer, threadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreads_threadsPerThreadgroup_), threadsPerGrid, threadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::dispatchThreads(MTL::GPUAddress indirectBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadsWithIndirectBuffer_), indirectBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, MTL::GPUAddress indirectRangeBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_), indirectCommandbuffer, indirectRangeBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(fillBuffer_range_value_), buffer, range, value);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::generateMipmaps(const MTL::Texture* texture)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(generateMipmapsForTexture_), texture);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_), texture);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_slice_level_), texture, slice, level);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_), texture);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_slice_level_), texture, slice, level);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeIndirectCommandBuffer_withRange_), indirectCommandBuffer, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL4::BufferRange scratchBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL4::BufferRange scratchBuffer, MTL::AccelerationStructureRefitOptions options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_options_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resetCommandsInBuffer_withRange_), buffer, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::setArgumentTable(const MTL4::ArgumentTable* argumentTable)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentTable_), argumentTable);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::setComputePipelineState(const MTL::ComputePipelineState* state)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineState_), state);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::setImageblockWidth(NS::UInteger width, NS::UInteger height)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setImageblockWidth_height_), width, height);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_atIndex_), length, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Stages MTL4::ComputeCommandEncoder::stages()
|
||||
{
|
||||
return Object::sendMessage<MTL::Stages>(this, _MTL_PRIVATE_SEL(stages));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL4::BufferRange buffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(writeCompactedAccelerationStructureSize_toBuffer_), accelerationStructure, buffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputeCommandEncoder::writeTimestamp(MTL4::TimestampGranularity granularity, const MTL4::CounterHeap* counterHeap, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(writeTimestampWithGranularity_intoHeap_atIndex_), granularity, counterHeap, index);
|
||||
}
|
||||
158
dist/include/metal_cpp/Metal/MTL4ComputePipeline.hpp
vendored
Normal file
158
dist/include/metal_cpp/Metal/MTL4ComputePipeline.hpp
vendored
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4ComputePipeline.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 "MTL4PipelineState.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class ComputePipelineDescriptor;
|
||||
class FunctionDescriptor;
|
||||
class StaticLinkingDescriptor;
|
||||
|
||||
class ComputePipelineDescriptor : public NS::Copying<ComputePipelineDescriptor, PipelineDescriptor>
|
||||
{
|
||||
public:
|
||||
static ComputePipelineDescriptor* alloc();
|
||||
|
||||
FunctionDescriptor* computeFunctionDescriptor() const;
|
||||
|
||||
ComputePipelineDescriptor* init();
|
||||
|
||||
NS::UInteger maxTotalThreadsPerThreadgroup() const;
|
||||
|
||||
MTL::Size requiredThreadsPerThreadgroup() const;
|
||||
|
||||
void reset();
|
||||
|
||||
void setComputeFunctionDescriptor(const MTL4::FunctionDescriptor* computeFunctionDescriptor);
|
||||
|
||||
void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup);
|
||||
|
||||
void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup);
|
||||
|
||||
void setStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* staticLinkingDescriptor);
|
||||
|
||||
void setSupportBinaryLinking(bool supportBinaryLinking);
|
||||
|
||||
void setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers);
|
||||
|
||||
void setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth);
|
||||
|
||||
StaticLinkingDescriptor* staticLinkingDescriptor() const;
|
||||
|
||||
bool supportBinaryLinking() const;
|
||||
|
||||
IndirectCommandBufferSupportState supportIndirectCommandBuffers() const;
|
||||
|
||||
bool threadGroupSizeIsMultipleOfThreadExecutionWidth() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::ComputePipelineDescriptor* MTL4::ComputePipelineDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::ComputePipelineDescriptor>(_MTL_PRIVATE_CLS(MTL4ComputePipelineDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::ComputePipelineDescriptor::computeFunctionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(computeFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::ComputePipelineDescriptor* MTL4::ComputePipelineDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::ComputePipelineDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::ComputePipelineDescriptor::maxTotalThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Size MTL4::ComputePipelineDescriptor::requiredThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputePipelineDescriptor::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputePipelineDescriptor::setComputeFunctionDescriptor(const MTL4::FunctionDescriptor* computeFunctionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputeFunctionDescriptor_), computeFunctionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputePipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputePipelineDescriptor::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputePipelineDescriptor::setStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* staticLinkingDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStaticLinkingDescriptor_), staticLinkingDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputePipelineDescriptor::setSupportBinaryLinking(bool supportBinaryLinking)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportBinaryLinking_), supportBinaryLinking);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputePipelineDescriptor::setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::ComputePipelineDescriptor::setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadGroupSizeIsMultipleOfThreadExecutionWidth_), threadGroupSizeIsMultipleOfThreadExecutionWidth);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::ComputePipelineDescriptor::staticLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::StaticLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(staticLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::ComputePipelineDescriptor::supportBinaryLinking() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportBinaryLinking));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::IndirectCommandBufferSupportState MTL4::ComputePipelineDescriptor::supportIndirectCommandBuffers() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::IndirectCommandBufferSupportState>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::ComputePipelineDescriptor::threadGroupSizeIsMultipleOfThreadExecutionWidth() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(threadGroupSizeIsMultipleOfThreadExecutionWidth));
|
||||
}
|
||||
138
dist/include/metal_cpp/Metal/MTL4Counters.hpp
vendored
Normal file
138
dist/include/metal_cpp/Metal/MTL4Counters.hpp
vendored
Normal file
|
|
@ -0,0 +1,138 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4Counters.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class CounterHeapDescriptor;
|
||||
_MTL_ENUM(NS::Integer, CounterHeapType) {
|
||||
CounterHeapTypeInvalid,
|
||||
CounterHeapTypeTimestamp,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, TimestampGranularity) {
|
||||
TimestampGranularityRelaxed = 0,
|
||||
TimestampGranularityPrecise = 1,
|
||||
};
|
||||
|
||||
struct TimestampHeapEntry
|
||||
{
|
||||
uint64_t timestamp;
|
||||
} _MTL_PACKED;
|
||||
|
||||
class CounterHeapDescriptor : public NS::Copying<CounterHeapDescriptor>
|
||||
{
|
||||
public:
|
||||
static CounterHeapDescriptor* alloc();
|
||||
|
||||
NS::UInteger count() const;
|
||||
|
||||
CounterHeapDescriptor* init();
|
||||
|
||||
void setCount(NS::UInteger count);
|
||||
|
||||
void setType(MTL4::CounterHeapType type);
|
||||
CounterHeapType type() const;
|
||||
};
|
||||
class CounterHeap : public NS::Referencing<CounterHeap>
|
||||
{
|
||||
public:
|
||||
NS::UInteger count() const;
|
||||
void invalidateCounterRange(NS::Range range);
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
NS::Data* resolveCounterRange(NS::Range range);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
CounterHeapType type() const;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CounterHeapDescriptor* MTL4::CounterHeapDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::CounterHeapDescriptor>(_MTL_PRIVATE_CLS(MTL4CounterHeapDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::CounterHeapDescriptor::count() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(count));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CounterHeapDescriptor* MTL4::CounterHeapDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::CounterHeapDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CounterHeapDescriptor::setCount(NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCount_), count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CounterHeapDescriptor::setType(MTL4::CounterHeapType type)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setType_), type);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CounterHeapType MTL4::CounterHeapDescriptor::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::CounterHeapType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::CounterHeap::count() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(count));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CounterHeap::invalidateCounterRange(NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(invalidateCounterRange_), range);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::CounterHeap::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Data* MTL4::CounterHeap::resolveCounterRange(NS::Range range)
|
||||
{
|
||||
return Object::sendMessage<NS::Data*>(this, _MTL_PRIVATE_SEL(resolveCounterRange_), range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::CounterHeap::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::CounterHeapType MTL4::CounterHeap::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::CounterHeapType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
49
dist/include/metal_cpp/Metal/MTL4FunctionDescriptor.hpp
vendored
Normal file
49
dist/include/metal_cpp/Metal/MTL4FunctionDescriptor.hpp
vendored
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal//MTL4FunctionDescriptor.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class FunctionDescriptor;
|
||||
|
||||
class FunctionDescriptor : public NS::Copying<FunctionDescriptor>
|
||||
{
|
||||
public:
|
||||
static FunctionDescriptor* alloc();
|
||||
|
||||
FunctionDescriptor* init();
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::FunctionDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::FunctionDescriptor>(_MTL_PRIVATE_CLS(MTL4FunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::FunctionDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::FunctionDescriptor>();
|
||||
}
|
||||
98
dist/include/metal_cpp/Metal/MTL4LibraryDescriptor.hpp
vendored
Normal file
98
dist/include/metal_cpp/Metal/MTL4LibraryDescriptor.hpp
vendored
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4LibraryDescriptor.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class LibraryDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class CompileOptions;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class LibraryDescriptor : public NS::Copying<LibraryDescriptor>
|
||||
{
|
||||
public:
|
||||
static LibraryDescriptor* alloc();
|
||||
|
||||
LibraryDescriptor* init();
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
MTL::CompileOptions* options() const;
|
||||
|
||||
void setName(const NS::String* name);
|
||||
|
||||
void setOptions(const MTL::CompileOptions* options);
|
||||
|
||||
void setSource(const NS::String* source);
|
||||
NS::String* source() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::LibraryDescriptor* MTL4::LibraryDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::LibraryDescriptor>(_MTL_PRIVATE_CLS(MTL4LibraryDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::LibraryDescriptor* MTL4::LibraryDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::LibraryDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::LibraryDescriptor::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CompileOptions* MTL4::LibraryDescriptor::options() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CompileOptions*>(this, _MTL_PRIVATE_SEL(options));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::LibraryDescriptor::setName(const NS::String* name)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setName_), name);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::LibraryDescriptor::setOptions(const MTL::CompileOptions* options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOptions_), options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::LibraryDescriptor::setSource(const NS::String* source)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSource_), source);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::LibraryDescriptor::source() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(source));
|
||||
}
|
||||
86
dist/include/metal_cpp/Metal/MTL4LibraryFunctionDescriptor.hpp
vendored
Normal file
86
dist/include/metal_cpp/Metal/MTL4LibraryFunctionDescriptor.hpp
vendored
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4LibraryFunctionDescriptor.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 "MTL4FunctionDescriptor.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class LibraryFunctionDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Library;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class LibraryFunctionDescriptor : public NS::Copying<LibraryFunctionDescriptor, FunctionDescriptor>
|
||||
{
|
||||
public:
|
||||
static LibraryFunctionDescriptor* alloc();
|
||||
|
||||
LibraryFunctionDescriptor* init();
|
||||
|
||||
MTL::Library* library() const;
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
void setLibrary(const MTL::Library* library);
|
||||
|
||||
void setName(const NS::String* name);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::LibraryFunctionDescriptor* MTL4::LibraryFunctionDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::LibraryFunctionDescriptor>(_MTL_PRIVATE_CLS(MTL4LibraryFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::LibraryFunctionDescriptor* MTL4::LibraryFunctionDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::LibraryFunctionDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Library* MTL4::LibraryFunctionDescriptor::library() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(library));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::LibraryFunctionDescriptor::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::LibraryFunctionDescriptor::setLibrary(const MTL::Library* library)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLibrary_), library);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::LibraryFunctionDescriptor::setName(const NS::String* name)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setName_), name);
|
||||
}
|
||||
204
dist/include/metal_cpp/Metal/MTL4LinkingDescriptor.hpp
vendored
Normal file
204
dist/include/metal_cpp/Metal/MTL4LinkingDescriptor.hpp
vendored
Normal file
|
|
@ -0,0 +1,204 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4LinkingDescriptor.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class PipelineStageDynamicLinkingDescriptor;
|
||||
class RenderPipelineDynamicLinkingDescriptor;
|
||||
class StaticLinkingDescriptor;
|
||||
|
||||
class StaticLinkingDescriptor : public NS::Copying<StaticLinkingDescriptor>
|
||||
{
|
||||
public:
|
||||
static StaticLinkingDescriptor* alloc();
|
||||
|
||||
NS::Array* functionDescriptors() const;
|
||||
|
||||
NS::Dictionary* groups() const;
|
||||
|
||||
StaticLinkingDescriptor* init();
|
||||
|
||||
NS::Array* privateFunctionDescriptors() const;
|
||||
|
||||
void setFunctionDescriptors(const NS::Array* functionDescriptors);
|
||||
|
||||
void setGroups(const NS::Dictionary* groups);
|
||||
|
||||
void setPrivateFunctionDescriptors(const NS::Array* privateFunctionDescriptors);
|
||||
};
|
||||
class PipelineStageDynamicLinkingDescriptor : public NS::Copying<PipelineStageDynamicLinkingDescriptor>
|
||||
{
|
||||
public:
|
||||
static PipelineStageDynamicLinkingDescriptor* alloc();
|
||||
|
||||
NS::Array* binaryLinkedFunctions() const;
|
||||
|
||||
PipelineStageDynamicLinkingDescriptor* init();
|
||||
|
||||
NS::UInteger maxCallStackDepth() const;
|
||||
|
||||
NS::Array* preloadedLibraries() const;
|
||||
|
||||
void setBinaryLinkedFunctions(const NS::Array* binaryLinkedFunctions);
|
||||
|
||||
void setMaxCallStackDepth(NS::UInteger maxCallStackDepth);
|
||||
|
||||
void setPreloadedLibraries(const NS::Array* preloadedLibraries);
|
||||
};
|
||||
class RenderPipelineDynamicLinkingDescriptor : public NS::Copying<RenderPipelineDynamicLinkingDescriptor>
|
||||
{
|
||||
public:
|
||||
static RenderPipelineDynamicLinkingDescriptor* alloc();
|
||||
|
||||
PipelineStageDynamicLinkingDescriptor* fragmentLinkingDescriptor() const;
|
||||
|
||||
RenderPipelineDynamicLinkingDescriptor* init();
|
||||
|
||||
PipelineStageDynamicLinkingDescriptor* meshLinkingDescriptor() const;
|
||||
|
||||
PipelineStageDynamicLinkingDescriptor* objectLinkingDescriptor() const;
|
||||
|
||||
PipelineStageDynamicLinkingDescriptor* tileLinkingDescriptor() const;
|
||||
|
||||
PipelineStageDynamicLinkingDescriptor* vertexLinkingDescriptor() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::StaticLinkingDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::StaticLinkingDescriptor>(_MTL_PRIVATE_CLS(MTL4StaticLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::StaticLinkingDescriptor::functionDescriptors() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functionDescriptors));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Dictionary* MTL4::StaticLinkingDescriptor::groups() const
|
||||
{
|
||||
return Object::sendMessage<NS::Dictionary*>(this, _MTL_PRIVATE_SEL(groups));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::StaticLinkingDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::StaticLinkingDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::StaticLinkingDescriptor::privateFunctionDescriptors() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(privateFunctionDescriptors));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::StaticLinkingDescriptor::setFunctionDescriptors(const NS::Array* functionDescriptors)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionDescriptors_), functionDescriptors);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::StaticLinkingDescriptor::setGroups(const NS::Dictionary* groups)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setGroups_), groups);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::StaticLinkingDescriptor::setPrivateFunctionDescriptors(const NS::Array* privateFunctionDescriptors)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrivateFunctionDescriptors_), privateFunctionDescriptors);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::PipelineStageDynamicLinkingDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::PipelineStageDynamicLinkingDescriptor>(_MTL_PRIVATE_CLS(MTL4PipelineStageDynamicLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::PipelineStageDynamicLinkingDescriptor::binaryLinkedFunctions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryLinkedFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::PipelineStageDynamicLinkingDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::PipelineStageDynamicLinkingDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::PipelineStageDynamicLinkingDescriptor::maxCallStackDepth() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCallStackDepth));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::PipelineStageDynamicLinkingDescriptor::preloadedLibraries() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(preloadedLibraries));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::PipelineStageDynamicLinkingDescriptor::setBinaryLinkedFunctions(const NS::Array* binaryLinkedFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryLinkedFunctions_), binaryLinkedFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::PipelineStageDynamicLinkingDescriptor::setMaxCallStackDepth(NS::UInteger maxCallStackDepth)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCallStackDepth_), maxCallStackDepth);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::PipelineStageDynamicLinkingDescriptor::setPreloadedLibraries(const NS::Array* preloadedLibraries)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreloadedLibraries_), preloadedLibraries);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::RenderPipelineDynamicLinkingDescriptor>(_MTL_PRIVATE_CLS(MTL4RenderPipelineDynamicLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::fragmentLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineStageDynamicLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(fragmentLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::RenderPipelineDynamicLinkingDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::meshLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineStageDynamicLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(meshLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::objectLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineStageDynamicLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(objectLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::tileLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineStageDynamicLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(tileLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::vertexLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineStageDynamicLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(vertexLinkingDescriptor));
|
||||
}
|
||||
66
dist/include/metal_cpp/Metal/MTL4MachineLearningCommandEncoder.hpp
vendored
Normal file
66
dist/include/metal_cpp/Metal/MTL4MachineLearningCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4MachineLearningCommandEncoder.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 "MTL4CommandEncoder.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class ArgumentTable;
|
||||
class MachineLearningPipelineState;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Heap;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class MachineLearningCommandEncoder : public NS::Referencing<MachineLearningCommandEncoder, CommandEncoder>
|
||||
{
|
||||
public:
|
||||
void dispatchNetwork(const MTL::Heap* heap);
|
||||
|
||||
void setArgumentTable(const MTL4::ArgumentTable* argumentTable);
|
||||
|
||||
void setPipelineState(const MTL4::MachineLearningPipelineState* pipelineState);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL4::MachineLearningCommandEncoder::dispatchNetwork(const MTL::Heap* heap)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchNetworkWithIntermediatesHeap_), heap);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MachineLearningCommandEncoder::setArgumentTable(const MTL4::ArgumentTable* argumentTable)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentTable_), argumentTable);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MachineLearningCommandEncoder::setPipelineState(const MTL4::MachineLearningPipelineState* pipelineState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPipelineState_), pipelineState);
|
||||
}
|
||||
172
dist/include/metal_cpp/Metal/MTL4MachineLearningPipeline.hpp
vendored
Normal file
172
dist/include/metal_cpp/Metal/MTL4MachineLearningPipeline.hpp
vendored
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4MachineLearningPipeline.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 "MTL4PipelineState.hpp"
|
||||
#include "MTLAllocation.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class FunctionDescriptor;
|
||||
class MachineLearningPipelineDescriptor;
|
||||
class MachineLearningPipelineReflection;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
class TensorExtents;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class MachineLearningPipelineDescriptor : public NS::Copying<MachineLearningPipelineDescriptor, PipelineDescriptor>
|
||||
{
|
||||
public:
|
||||
static MachineLearningPipelineDescriptor* alloc();
|
||||
|
||||
MachineLearningPipelineDescriptor* init();
|
||||
|
||||
MTL::TensorExtents* inputDimensionsAtBufferIndex(NS::Integer bufferIndex);
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
FunctionDescriptor* machineLearningFunctionDescriptor() const;
|
||||
|
||||
void reset();
|
||||
|
||||
void setInputDimensions(const MTL::TensorExtents* dimensions, NS::Integer bufferIndex);
|
||||
void setInputDimensions(const NS::Array* dimensions, NS::Range range);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void setMachineLearningFunctionDescriptor(const MTL4::FunctionDescriptor* machineLearningFunctionDescriptor);
|
||||
};
|
||||
class MachineLearningPipelineReflection : public NS::Referencing<MachineLearningPipelineReflection>
|
||||
{
|
||||
public:
|
||||
static MachineLearningPipelineReflection* alloc();
|
||||
|
||||
NS::Array* bindings() const;
|
||||
|
||||
MachineLearningPipelineReflection* init();
|
||||
};
|
||||
class MachineLearningPipelineState : public NS::Referencing<MachineLearningPipelineState, MTL::Allocation>
|
||||
{
|
||||
public:
|
||||
MTL::Device* device() const;
|
||||
|
||||
NS::UInteger intermediatesHeapSize() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
MachineLearningPipelineReflection* reflection() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::MachineLearningPipelineDescriptor* MTL4::MachineLearningPipelineDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::MachineLearningPipelineDescriptor>(_MTL_PRIVATE_CLS(MTL4MachineLearningPipelineDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::MachineLearningPipelineDescriptor* MTL4::MachineLearningPipelineDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::MachineLearningPipelineDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorExtents* MTL4::MachineLearningPipelineDescriptor::inputDimensionsAtBufferIndex(NS::Integer bufferIndex)
|
||||
{
|
||||
return Object::sendMessage<MTL::TensorExtents*>(this, _MTL_PRIVATE_SEL(inputDimensionsAtBufferIndex_), bufferIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::MachineLearningPipelineDescriptor::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::MachineLearningPipelineDescriptor::machineLearningFunctionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(machineLearningFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::setInputDimensions(const MTL::TensorExtents* dimensions, NS::Integer bufferIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInputDimensions_atBufferIndex_), dimensions, bufferIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::setInputDimensions(const NS::Array* dimensions, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInputDimensions_withRange_), dimensions, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::setMachineLearningFunctionDescriptor(const MTL4::FunctionDescriptor* machineLearningFunctionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMachineLearningFunctionDescriptor_), machineLearningFunctionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::MachineLearningPipelineReflection* MTL4::MachineLearningPipelineReflection::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::MachineLearningPipelineReflection>(_MTL_PRIVATE_CLS(MTL4MachineLearningPipelineReflection));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::MachineLearningPipelineReflection::bindings() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(bindings));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::MachineLearningPipelineReflection* MTL4::MachineLearningPipelineReflection::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::MachineLearningPipelineReflection>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL4::MachineLearningPipelineState::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::MachineLearningPipelineState::intermediatesHeapSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(intermediatesHeapSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::MachineLearningPipelineState::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::MachineLearningPipelineReflection* MTL4::MachineLearningPipelineState::reflection() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::MachineLearningPipelineReflection*>(this, _MTL_PRIVATE_SEL(reflection));
|
||||
}
|
||||
413
dist/include/metal_cpp/Metal/MTL4MeshRenderPipeline.hpp
vendored
Normal file
413
dist/include/metal_cpp/Metal/MTL4MeshRenderPipeline.hpp
vendored
Normal file
|
|
@ -0,0 +1,413 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4MeshRenderPipeline.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 "MTL4PipelineState.hpp"
|
||||
#include "MTL4RenderPipeline.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class FunctionDescriptor;
|
||||
class MeshRenderPipelineDescriptor;
|
||||
class RenderPipelineColorAttachmentDescriptorArray;
|
||||
class StaticLinkingDescriptor;
|
||||
|
||||
class MeshRenderPipelineDescriptor : public NS::Copying<MeshRenderPipelineDescriptor, PipelineDescriptor>
|
||||
{
|
||||
public:
|
||||
static MeshRenderPipelineDescriptor* alloc();
|
||||
|
||||
AlphaToCoverageState alphaToCoverageState() const;
|
||||
|
||||
AlphaToOneState alphaToOneState() const;
|
||||
|
||||
LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState() const;
|
||||
|
||||
RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const;
|
||||
|
||||
FunctionDescriptor* fragmentFunctionDescriptor() const;
|
||||
|
||||
StaticLinkingDescriptor* fragmentStaticLinkingDescriptor() const;
|
||||
|
||||
MeshRenderPipelineDescriptor* init();
|
||||
|
||||
bool isRasterizationEnabled() const;
|
||||
|
||||
NS::UInteger maxTotalThreadgroupsPerMeshGrid() const;
|
||||
|
||||
NS::UInteger maxTotalThreadsPerMeshThreadgroup() const;
|
||||
|
||||
NS::UInteger maxTotalThreadsPerObjectThreadgroup() const;
|
||||
|
||||
NS::UInteger maxVertexAmplificationCount() const;
|
||||
|
||||
FunctionDescriptor* meshFunctionDescriptor() const;
|
||||
|
||||
StaticLinkingDescriptor* meshStaticLinkingDescriptor() const;
|
||||
|
||||
bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth() const;
|
||||
|
||||
FunctionDescriptor* objectFunctionDescriptor() const;
|
||||
|
||||
StaticLinkingDescriptor* objectStaticLinkingDescriptor() const;
|
||||
|
||||
bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth() const;
|
||||
|
||||
NS::UInteger payloadMemoryLength() const;
|
||||
|
||||
NS::UInteger rasterSampleCount() const;
|
||||
|
||||
[[deprecated("please use isRasterizationEnabled instead")]]
|
||||
bool rasterizationEnabled() const;
|
||||
|
||||
MTL::Size requiredThreadsPerMeshThreadgroup() const;
|
||||
|
||||
MTL::Size requiredThreadsPerObjectThreadgroup() const;
|
||||
|
||||
void reset();
|
||||
|
||||
void setAlphaToCoverageState(MTL4::AlphaToCoverageState alphaToCoverageState);
|
||||
|
||||
void setAlphaToOneState(MTL4::AlphaToOneState alphaToOneState);
|
||||
|
||||
void setColorAttachmentMappingState(MTL4::LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState);
|
||||
|
||||
void setFragmentFunctionDescriptor(const MTL4::FunctionDescriptor* fragmentFunctionDescriptor);
|
||||
|
||||
void setFragmentStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* fragmentStaticLinkingDescriptor);
|
||||
|
||||
void setMaxTotalThreadgroupsPerMeshGrid(NS::UInteger maxTotalThreadgroupsPerMeshGrid);
|
||||
|
||||
void setMaxTotalThreadsPerMeshThreadgroup(NS::UInteger maxTotalThreadsPerMeshThreadgroup);
|
||||
|
||||
void setMaxTotalThreadsPerObjectThreadgroup(NS::UInteger maxTotalThreadsPerObjectThreadgroup);
|
||||
|
||||
void setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount);
|
||||
|
||||
void setMeshFunctionDescriptor(const MTL4::FunctionDescriptor* meshFunctionDescriptor);
|
||||
|
||||
void setMeshStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* meshStaticLinkingDescriptor);
|
||||
|
||||
void setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth);
|
||||
|
||||
void setObjectFunctionDescriptor(const MTL4::FunctionDescriptor* objectFunctionDescriptor);
|
||||
|
||||
void setObjectStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* objectStaticLinkingDescriptor);
|
||||
|
||||
void setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth);
|
||||
|
||||
void setPayloadMemoryLength(NS::UInteger payloadMemoryLength);
|
||||
|
||||
void setRasterSampleCount(NS::UInteger rasterSampleCount);
|
||||
|
||||
void setRasterizationEnabled(bool rasterizationEnabled);
|
||||
|
||||
void setRequiredThreadsPerMeshThreadgroup(MTL::Size requiredThreadsPerMeshThreadgroup);
|
||||
|
||||
void setRequiredThreadsPerObjectThreadgroup(MTL::Size requiredThreadsPerObjectThreadgroup);
|
||||
|
||||
void setSupportFragmentBinaryLinking(bool supportFragmentBinaryLinking);
|
||||
|
||||
void setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers);
|
||||
|
||||
void setSupportMeshBinaryLinking(bool supportMeshBinaryLinking);
|
||||
|
||||
void setSupportObjectBinaryLinking(bool supportObjectBinaryLinking);
|
||||
|
||||
bool supportFragmentBinaryLinking() const;
|
||||
|
||||
IndirectCommandBufferSupportState supportIndirectCommandBuffers() const;
|
||||
|
||||
bool supportMeshBinaryLinking() const;
|
||||
|
||||
bool supportObjectBinaryLinking() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::MeshRenderPipelineDescriptor* MTL4::MeshRenderPipelineDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::MeshRenderPipelineDescriptor>(_MTL_PRIVATE_CLS(MTL4MeshRenderPipelineDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::AlphaToCoverageState MTL4::MeshRenderPipelineDescriptor::alphaToCoverageState() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::AlphaToCoverageState>(this, _MTL_PRIVATE_SEL(alphaToCoverageState));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::AlphaToOneState MTL4::MeshRenderPipelineDescriptor::alphaToOneState() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::AlphaToOneState>(this, _MTL_PRIVATE_SEL(alphaToOneState));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::LogicalToPhysicalColorAttachmentMappingState MTL4::MeshRenderPipelineDescriptor::colorAttachmentMappingState() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::LogicalToPhysicalColorAttachmentMappingState>(this, _MTL_PRIVATE_SEL(colorAttachmentMappingState));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptorArray* MTL4::MeshRenderPipelineDescriptor::colorAttachments() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::RenderPipelineColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::MeshRenderPipelineDescriptor::fragmentFunctionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(fragmentFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::MeshRenderPipelineDescriptor::fragmentStaticLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::StaticLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(fragmentStaticLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::MeshRenderPipelineDescriptor* MTL4::MeshRenderPipelineDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::MeshRenderPipelineDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::isRasterizationEnabled() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isRasterizationEnabled));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::maxTotalThreadgroupsPerMeshGrid() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadgroupsPerMeshGrid));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::maxTotalThreadsPerMeshThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerMeshThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::maxTotalThreadsPerObjectThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerObjectThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::maxVertexAmplificationCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::MeshRenderPipelineDescriptor::meshFunctionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(meshFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::MeshRenderPipelineDescriptor::meshStaticLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::StaticLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(meshStaticLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::meshThreadgroupSizeIsMultipleOfThreadExecutionWidth() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(meshThreadgroupSizeIsMultipleOfThreadExecutionWidth));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::MeshRenderPipelineDescriptor::objectFunctionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(objectFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::MeshRenderPipelineDescriptor::objectStaticLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::StaticLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(objectStaticLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::objectThreadgroupSizeIsMultipleOfThreadExecutionWidth() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(objectThreadgroupSizeIsMultipleOfThreadExecutionWidth));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::payloadMemoryLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(payloadMemoryLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::rasterSampleCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(rasterSampleCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::rasterizationEnabled() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isRasterizationEnabled));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Size MTL4::MeshRenderPipelineDescriptor::requiredThreadsPerMeshThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(requiredThreadsPerMeshThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Size MTL4::MeshRenderPipelineDescriptor::requiredThreadsPerObjectThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(requiredThreadsPerObjectThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setAlphaToCoverageState(MTL4::AlphaToCoverageState alphaToCoverageState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToCoverageState_), alphaToCoverageState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setAlphaToOneState(MTL4::AlphaToOneState alphaToOneState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToOneState_), alphaToOneState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setColorAttachmentMappingState(MTL4::LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorAttachmentMappingState_), colorAttachmentMappingState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setFragmentFunctionDescriptor(const MTL4::FunctionDescriptor* fragmentFunctionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentFunctionDescriptor_), fragmentFunctionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setFragmentStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* fragmentStaticLinkingDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentStaticLinkingDescriptor_), fragmentStaticLinkingDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMaxTotalThreadgroupsPerMeshGrid(NS::UInteger maxTotalThreadgroupsPerMeshGrid)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadgroupsPerMeshGrid_), maxTotalThreadgroupsPerMeshGrid);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMaxTotalThreadsPerMeshThreadgroup(NS::UInteger maxTotalThreadsPerMeshThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerMeshThreadgroup_), maxTotalThreadsPerMeshThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMaxTotalThreadsPerObjectThreadgroup(NS::UInteger maxTotalThreadsPerObjectThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerObjectThreadgroup_), maxTotalThreadsPerObjectThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMeshFunctionDescriptor(const MTL4::FunctionDescriptor* meshFunctionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshFunctionDescriptor_), meshFunctionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMeshStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* meshStaticLinkingDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshStaticLinkingDescriptor_), meshStaticLinkingDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth_), meshThreadgroupSizeIsMultipleOfThreadExecutionWidth);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setObjectFunctionDescriptor(const MTL4::FunctionDescriptor* objectFunctionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectFunctionDescriptor_), objectFunctionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setObjectStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* objectStaticLinkingDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectStaticLinkingDescriptor_), objectStaticLinkingDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth_), objectThreadgroupSizeIsMultipleOfThreadExecutionWidth);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setPayloadMemoryLength(NS::UInteger payloadMemoryLength)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPayloadMemoryLength_), payloadMemoryLength);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setRequiredThreadsPerMeshThreadgroup(MTL::Size requiredThreadsPerMeshThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerMeshThreadgroup_), requiredThreadsPerMeshThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setRequiredThreadsPerObjectThreadgroup(MTL::Size requiredThreadsPerObjectThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerObjectThreadgroup_), requiredThreadsPerObjectThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setSupportFragmentBinaryLinking(bool supportFragmentBinaryLinking)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportFragmentBinaryLinking_), supportFragmentBinaryLinking);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setSupportMeshBinaryLinking(bool supportMeshBinaryLinking)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportMeshBinaryLinking_), supportMeshBinaryLinking);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setSupportObjectBinaryLinking(bool supportObjectBinaryLinking)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportObjectBinaryLinking_), supportObjectBinaryLinking);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::supportFragmentBinaryLinking() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportFragmentBinaryLinking));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::IndirectCommandBufferSupportState MTL4::MeshRenderPipelineDescriptor::supportIndirectCommandBuffers() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::IndirectCommandBufferSupportState>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::supportMeshBinaryLinking() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportMeshBinaryLinking));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::supportObjectBinaryLinking() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportObjectBinaryLinking));
|
||||
}
|
||||
85
dist/include/metal_cpp/Metal/MTL4PipelineDataSetSerializer.hpp
vendored
Normal file
85
dist/include/metal_cpp/Metal/MTL4PipelineDataSetSerializer.hpp
vendored
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4PipelineDataSetSerializer.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class PipelineDataSetSerializerDescriptor;
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, PipelineDataSetSerializerConfiguration) {
|
||||
PipelineDataSetSerializerConfigurationCaptureDescriptors = 1,
|
||||
PipelineDataSetSerializerConfigurationCaptureBinaries = 1 << 1,
|
||||
};
|
||||
|
||||
class PipelineDataSetSerializerDescriptor : public NS::Copying<PipelineDataSetSerializerDescriptor>
|
||||
{
|
||||
public:
|
||||
static PipelineDataSetSerializerDescriptor* alloc();
|
||||
|
||||
PipelineDataSetSerializerConfiguration configuration() const;
|
||||
|
||||
PipelineDataSetSerializerDescriptor* init();
|
||||
|
||||
void setConfiguration(MTL4::PipelineDataSetSerializerConfiguration configuration);
|
||||
};
|
||||
class PipelineDataSetSerializer : public NS::Referencing<PipelineDataSetSerializer>
|
||||
{
|
||||
public:
|
||||
bool serializeAsArchiveAndFlushToURL(const NS::URL* url, NS::Error** error);
|
||||
|
||||
NS::Data* serializeAsPipelinesScript(NS::Error** error);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::PipelineDataSetSerializerDescriptor* MTL4::PipelineDataSetSerializerDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::PipelineDataSetSerializerDescriptor>(_MTL_PRIVATE_CLS(MTL4PipelineDataSetSerializerDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineDataSetSerializerConfiguration MTL4::PipelineDataSetSerializerDescriptor::configuration() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineDataSetSerializerConfiguration>(this, _MTL_PRIVATE_SEL(configuration));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineDataSetSerializerDescriptor* MTL4::PipelineDataSetSerializerDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::PipelineDataSetSerializerDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::PipelineDataSetSerializerDescriptor::setConfiguration(MTL4::PipelineDataSetSerializerConfiguration configuration)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConfiguration_), configuration);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::PipelineDataSetSerializer::serializeAsArchiveAndFlushToURL(const NS::URL* url, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(serializeAsArchiveAndFlushToURL_error_), url, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Data* MTL4::PipelineDataSetSerializer::serializeAsPipelinesScript(NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<NS::Data*>(this, _MTL_PRIVATE_SEL(serializeAsPipelinesScriptWithError_), error);
|
||||
}
|
||||
150
dist/include/metal_cpp/Metal/MTL4PipelineState.hpp
vendored
Normal file
150
dist/include/metal_cpp/Metal/MTL4PipelineState.hpp
vendored
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4PipelineState.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPipeline.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class PipelineDescriptor;
|
||||
class PipelineOptions;
|
||||
_MTL_ENUM(NS::Integer, AlphaToOneState) {
|
||||
AlphaToOneStateDisabled = 0,
|
||||
AlphaToOneStateEnabled = 1,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, AlphaToCoverageState) {
|
||||
AlphaToCoverageStateDisabled = 0,
|
||||
AlphaToCoverageStateEnabled = 1,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, BlendState) {
|
||||
BlendStateDisabled = 0,
|
||||
BlendStateEnabled = 1,
|
||||
BlendStateUnspecialized = 2,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, IndirectCommandBufferSupportState) {
|
||||
IndirectCommandBufferSupportStateDisabled = 0,
|
||||
IndirectCommandBufferSupportStateEnabled = 1,
|
||||
};
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, ShaderReflection) {
|
||||
ShaderReflectionNone = 0,
|
||||
ShaderReflectionBindingInfo = 1,
|
||||
ShaderReflectionBufferTypeInfo = 1 << 1,
|
||||
};
|
||||
|
||||
class PipelineOptions : public NS::Copying<PipelineOptions>
|
||||
{
|
||||
public:
|
||||
static PipelineOptions* alloc();
|
||||
|
||||
PipelineOptions* init();
|
||||
|
||||
void setShaderReflection(MTL4::ShaderReflection shaderReflection);
|
||||
|
||||
void setShaderValidation(MTL::ShaderValidation shaderValidation);
|
||||
|
||||
ShaderReflection shaderReflection() const;
|
||||
|
||||
MTL::ShaderValidation shaderValidation() const;
|
||||
};
|
||||
class PipelineDescriptor : public NS::Copying<PipelineDescriptor>
|
||||
{
|
||||
public:
|
||||
static PipelineDescriptor* alloc();
|
||||
|
||||
PipelineDescriptor* init();
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
PipelineOptions* options() const;
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void setOptions(const MTL4::PipelineOptions* options);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::PipelineOptions* MTL4::PipelineOptions::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::PipelineOptions>(_MTL_PRIVATE_CLS(MTL4PipelineOptions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineOptions* MTL4::PipelineOptions::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::PipelineOptions>();
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::PipelineOptions::setShaderReflection(MTL4::ShaderReflection shaderReflection)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setShaderReflection_), shaderReflection);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::PipelineOptions::setShaderValidation(MTL::ShaderValidation shaderValidation)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setShaderValidation_), shaderValidation);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::ShaderReflection MTL4::PipelineOptions::shaderReflection() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::ShaderReflection>(this, _MTL_PRIVATE_SEL(shaderReflection));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ShaderValidation MTL4::PipelineOptions::shaderValidation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ShaderValidation>(this, _MTL_PRIVATE_SEL(shaderValidation));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineDescriptor* MTL4::PipelineDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::PipelineDescriptor>(_MTL_PRIVATE_CLS(MTL4PipelineDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineDescriptor* MTL4::PipelineDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::PipelineDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::PipelineDescriptor::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::PipelineOptions* MTL4::PipelineDescriptor::options() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::PipelineOptions*>(this, _MTL_PRIVATE_SEL(options));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::PipelineDescriptor::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::PipelineDescriptor::setOptions(const MTL4::PipelineOptions* options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOptions_), options);
|
||||
}
|
||||
340
dist/include/metal_cpp/Metal/MTL4RenderCommandEncoder.hpp
vendored
Normal file
340
dist/include/metal_cpp/Metal/MTL4RenderCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,340 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4RenderCommandEncoder.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 "MTL4CommandEncoder.hpp"
|
||||
#include "MTL4Counters.hpp"
|
||||
#include "MTLArgument.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLGPUAddress.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLRenderCommandEncoder.hpp"
|
||||
#include "MTLRenderPass.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class ArgumentTable;
|
||||
class CounterHeap;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class DepthStencilState;
|
||||
class IndirectCommandBuffer;
|
||||
class LogicalToPhysicalColorAttachmentMap;
|
||||
class RenderPipelineState;
|
||||
struct ScissorRect;
|
||||
struct VertexAmplificationViewMapping;
|
||||
struct Viewport;
|
||||
|
||||
}
|
||||
namespace MTL4
|
||||
{
|
||||
_MTL_OPTIONS(NS::UInteger, RenderEncoderOptions) {
|
||||
RenderEncoderOptionNone = 0,
|
||||
RenderEncoderOptionSuspending = 1,
|
||||
RenderEncoderOptionResuming = 1 << 1,
|
||||
};
|
||||
|
||||
class RenderCommandEncoder : public NS::Referencing<RenderCommandEncoder, CommandEncoder>
|
||||
{
|
||||
public:
|
||||
void dispatchThreadsPerTile(MTL::Size threadsPerTile);
|
||||
|
||||
void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength);
|
||||
void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, NS::UInteger instanceCount);
|
||||
void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance);
|
||||
void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, MTL::GPUAddress indirectBuffer);
|
||||
|
||||
void drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
|
||||
void drawMeshThreadgroups(MTL::GPUAddress indirectBuffer, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
|
||||
|
||||
void drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
|
||||
|
||||
void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount);
|
||||
void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount);
|
||||
void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance);
|
||||
void drawPrimitives(MTL::PrimitiveType primitiveType, MTL::GPUAddress indirectBuffer);
|
||||
|
||||
void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange);
|
||||
void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, MTL::GPUAddress indirectRangeBuffer);
|
||||
|
||||
void setArgumentTable(const MTL4::ArgumentTable* argumentTable, MTL::RenderStages stages);
|
||||
|
||||
void setBlendColor(float red, float green, float blue, float alpha);
|
||||
|
||||
void setColorAttachmentMap(const MTL::LogicalToPhysicalColorAttachmentMap* mapping);
|
||||
|
||||
void setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex);
|
||||
|
||||
void setCullMode(MTL::CullMode cullMode);
|
||||
|
||||
void setDepthBias(float depthBias, float slopeScale, float clamp);
|
||||
|
||||
void setDepthClipMode(MTL::DepthClipMode depthClipMode);
|
||||
|
||||
void setDepthStencilState(const MTL::DepthStencilState* depthStencilState);
|
||||
|
||||
void setDepthStoreAction(MTL::StoreAction storeAction);
|
||||
|
||||
void setDepthTestBounds(float minBound, float maxBound);
|
||||
|
||||
void setFrontFacingWinding(MTL::Winding frontFacingWinding);
|
||||
|
||||
void setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
|
||||
|
||||
void setRenderPipelineState(const MTL::RenderPipelineState* pipelineState);
|
||||
|
||||
void setScissorRect(MTL::ScissorRect rect);
|
||||
void setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count);
|
||||
|
||||
void setStencilReferenceValue(uint32_t referenceValue);
|
||||
void setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue);
|
||||
|
||||
void setStencilStoreAction(MTL::StoreAction storeAction);
|
||||
|
||||
void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index);
|
||||
|
||||
void setTriangleFillMode(MTL::TriangleFillMode fillMode);
|
||||
|
||||
void setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings);
|
||||
|
||||
void setViewport(MTL::Viewport viewport);
|
||||
void setViewports(const MTL::Viewport* viewports, NS::UInteger count);
|
||||
|
||||
void setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset);
|
||||
|
||||
NS::UInteger tileHeight() const;
|
||||
|
||||
NS::UInteger tileWidth() const;
|
||||
|
||||
void writeTimestamp(MTL4::TimestampGranularity granularity, MTL::RenderStages stage, const MTL4::CounterHeap* counterHeap, NS::UInteger index);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::dispatchThreadsPerTile(MTL::Size threadsPerTile)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadsPerTile_), threadsPerTile);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_), primitiveType, indexCount, indexType, indexBuffer, indexBufferLength);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, NS::UInteger instanceCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_instanceCount_), primitiveType, indexCount, indexType, indexBuffer, indexBufferLength, instanceCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_instanceCount_baseVertex_baseInstance_), primitiveType, indexCount, indexType, indexBuffer, indexBufferLength, instanceCount, baseVertex, baseInstance);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, MTL::GPUAddress indirectBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferLength_indirectBuffer_), primitiveType, indexType, indexBuffer, indexBufferLength, indirectBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadgroupsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawMeshThreadgroups(MTL::GPUAddress indirectBuffer, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreadgroupsWithIndirectBuffer_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), indirectBuffer, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_), primitiveType, vertexStart, vertexCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_), primitiveType, vertexStart, vertexCount, instanceCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_), primitiveType, vertexStart, vertexCount, instanceCount, baseInstance);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, MTL::GPUAddress indirectBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_indirectBuffer_), primitiveType, indirectBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, MTL::GPUAddress indirectRangeBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_), indirectCommandBuffer, indirectRangeBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setArgumentTable(const MTL4::ArgumentTable* argumentTable, MTL::RenderStages stages)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentTable_atStages_), argumentTable, stages);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setBlendColor(float red, float green, float blue, float alpha)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBlendColorRed_green_blue_alpha_), red, green, blue, alpha);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setColorAttachmentMap(const MTL::LogicalToPhysicalColorAttachmentMap* mapping)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorAttachmentMap_), mapping);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreAction_atIndex_), storeAction, colorAttachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setCullMode(MTL::CullMode cullMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCullMode_), cullMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthBias(float depthBias, float slopeScale, float clamp)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthBias_slopeScale_clamp_), depthBias, slopeScale, clamp);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthClipMode(MTL::DepthClipMode depthClipMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthClipMode_), depthClipMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthStencilState(const MTL::DepthStencilState* depthStencilState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilState_), depthStencilState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthStoreAction(MTL::StoreAction storeAction)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreAction_), storeAction);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthTestBounds(float minBound, float maxBound)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthTestMinBound_maxBound_), minBound, maxBound);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setFrontFacingWinding(MTL::Winding frontFacingWinding)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFrontFacingWinding_), frontFacingWinding);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectThreadgroupMemoryLength_atIndex_), length, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setRenderPipelineState(const MTL::RenderPipelineState* pipelineState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineState_), pipelineState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setScissorRect(MTL::ScissorRect rect)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScissorRect_), rect);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScissorRects_count_), scissorRects, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setStencilReferenceValue(uint32_t referenceValue)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilReferenceValue_), referenceValue);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilFrontReferenceValue_backReferenceValue_), frontReferenceValue, backReferenceValue);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setStencilStoreAction(MTL::StoreAction storeAction)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreAction_), storeAction);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_offset_atIndex_), length, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setTriangleFillMode(MTL::TriangleFillMode fillMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleFillMode_), fillMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexAmplificationCount_viewMappings_), count, viewMappings);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setViewport(MTL::Viewport viewport)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setViewport_), viewport);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setViewports(const MTL::Viewport* viewports, NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setViewports_count_), viewports, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibilityResultMode_offset_), mode, offset);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderCommandEncoder::tileHeight() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileHeight));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderCommandEncoder::tileWidth() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileWidth));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderCommandEncoder::writeTimestamp(MTL4::TimestampGranularity granularity, MTL::RenderStages stage, const MTL4::CounterHeap* counterHeap, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(writeTimestampWithGranularity_afterStage_intoHeap_atIndex_), granularity, stage, counterHeap, index);
|
||||
}
|
||||
280
dist/include/metal_cpp/Metal/MTL4RenderPass.hpp
vendored
Normal file
280
dist/include/metal_cpp/Metal/MTL4RenderPass.hpp
vendored
Normal file
|
|
@ -0,0 +1,280 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4RenderPass.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLRenderPass.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class RenderPassDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Buffer;
|
||||
class RasterizationRateMap;
|
||||
class RenderPassColorAttachmentDescriptorArray;
|
||||
class RenderPassDepthAttachmentDescriptor;
|
||||
class RenderPassStencilAttachmentDescriptor;
|
||||
struct SamplePosition;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class RenderPassDescriptor : public NS::Copying<RenderPassDescriptor>
|
||||
{
|
||||
public:
|
||||
static RenderPassDescriptor* alloc();
|
||||
|
||||
MTL::RenderPassColorAttachmentDescriptorArray* colorAttachments() const;
|
||||
|
||||
NS::UInteger defaultRasterSampleCount() const;
|
||||
|
||||
MTL::RenderPassDepthAttachmentDescriptor* depthAttachment() const;
|
||||
|
||||
NS::UInteger getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count);
|
||||
|
||||
NS::UInteger imageblockSampleLength() const;
|
||||
|
||||
RenderPassDescriptor* init();
|
||||
|
||||
MTL::RasterizationRateMap* rasterizationRateMap() const;
|
||||
|
||||
NS::UInteger renderTargetArrayLength() const;
|
||||
|
||||
NS::UInteger renderTargetHeight() const;
|
||||
|
||||
NS::UInteger renderTargetWidth() const;
|
||||
|
||||
void setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount);
|
||||
|
||||
void setDepthAttachment(const MTL::RenderPassDepthAttachmentDescriptor* depthAttachment);
|
||||
|
||||
void setImageblockSampleLength(NS::UInteger imageblockSampleLength);
|
||||
|
||||
void setRasterizationRateMap(const MTL::RasterizationRateMap* rasterizationRateMap);
|
||||
|
||||
void setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength);
|
||||
|
||||
void setRenderTargetHeight(NS::UInteger renderTargetHeight);
|
||||
|
||||
void setRenderTargetWidth(NS::UInteger renderTargetWidth);
|
||||
|
||||
void setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count);
|
||||
|
||||
void setStencilAttachment(const MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment);
|
||||
|
||||
void setSupportColorAttachmentMapping(bool supportColorAttachmentMapping);
|
||||
|
||||
void setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength);
|
||||
|
||||
void setTileHeight(NS::UInteger tileHeight);
|
||||
|
||||
void setTileWidth(NS::UInteger tileWidth);
|
||||
|
||||
void setVisibilityResultBuffer(const MTL::Buffer* visibilityResultBuffer);
|
||||
|
||||
void setVisibilityResultType(MTL::VisibilityResultType visibilityResultType);
|
||||
|
||||
MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment() const;
|
||||
|
||||
bool supportColorAttachmentMapping() const;
|
||||
|
||||
NS::UInteger threadgroupMemoryLength() const;
|
||||
|
||||
NS::UInteger tileHeight() const;
|
||||
|
||||
NS::UInteger tileWidth() const;
|
||||
|
||||
MTL::Buffer* visibilityResultBuffer() const;
|
||||
|
||||
MTL::VisibilityResultType visibilityResultType() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::RenderPassDescriptor* MTL4::RenderPassDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::RenderPassDescriptor>(_MTL_PRIVATE_CLS(MTL4RenderPassDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL4::RenderPassDescriptor::colorAttachments() const
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderPassColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::defaultRasterSampleCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(defaultRasterSampleCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL4::RenderPassDescriptor::depthAttachment() const
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderPassDepthAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(depthAttachment));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count)
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(getSamplePositions_count_), positions, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::imageblockSampleLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockSampleLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPassDescriptor* MTL4::RenderPassDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::RenderPassDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RasterizationRateMap* MTL4::RenderPassDescriptor::rasterizationRateMap() const
|
||||
{
|
||||
return Object::sendMessage<MTL::RasterizationRateMap*>(this, _MTL_PRIVATE_SEL(rasterizationRateMap));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::renderTargetArrayLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetArrayLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::renderTargetHeight() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetHeight));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::renderTargetWidth() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetWidth));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDefaultRasterSampleCount_), defaultRasterSampleCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setDepthAttachment(const MTL::RenderPassDepthAttachmentDescriptor* depthAttachment)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthAttachment_), depthAttachment);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setImageblockSampleLength(NS::UInteger imageblockSampleLength)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setImageblockSampleLength_), imageblockSampleLength);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setRasterizationRateMap(const MTL::RasterizationRateMap* rasterizationRateMap)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterizationRateMap_), rasterizationRateMap);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetArrayLength_), renderTargetArrayLength);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setRenderTargetHeight(NS::UInteger renderTargetHeight)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetHeight_), renderTargetHeight);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setRenderTargetWidth(NS::UInteger renderTargetWidth)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetWidth_), renderTargetWidth);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplePositions_count_), positions, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setStencilAttachment(const MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilAttachment_), stencilAttachment);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setSupportColorAttachmentMapping(bool supportColorAttachmentMapping)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportColorAttachmentMapping_), supportColorAttachmentMapping);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_), threadgroupMemoryLength);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setTileHeight(NS::UInteger tileHeight)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileHeight_), tileHeight);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setTileWidth(NS::UInteger tileWidth)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileWidth_), tileWidth);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setVisibilityResultBuffer(const MTL::Buffer* visibilityResultBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibilityResultBuffer_), visibilityResultBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPassDescriptor::setVisibilityResultType(MTL::VisibilityResultType visibilityResultType)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibilityResultType_), visibilityResultType);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL4::RenderPassDescriptor::stencilAttachment() const
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderPassStencilAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(stencilAttachment));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::RenderPassDescriptor::supportColorAttachmentMapping() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportColorAttachmentMapping));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::threadgroupMemoryLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::tileHeight() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileHeight));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::tileWidth() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileWidth));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Buffer* MTL4::RenderPassDescriptor::visibilityResultBuffer() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(visibilityResultBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::VisibilityResultType MTL4::RenderPassDescriptor::visibilityResultType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::VisibilityResultType>(this, _MTL_PRIVATE_SEL(visibilityResultType));
|
||||
}
|
||||
587
dist/include/metal_cpp/Metal/MTL4RenderPipeline.hpp
vendored
Normal file
587
dist/include/metal_cpp/Metal/MTL4RenderPipeline.hpp
vendored
Normal file
|
|
@ -0,0 +1,587 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4RenderPipeline.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 "MTL4PipelineState.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPixelFormat.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLRenderPipeline.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class FunctionDescriptor;
|
||||
class RenderPipelineBinaryFunctionsDescriptor;
|
||||
class RenderPipelineColorAttachmentDescriptor;
|
||||
class RenderPipelineColorAttachmentDescriptorArray;
|
||||
class RenderPipelineDescriptor;
|
||||
class StaticLinkingDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class VertexDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
_MTL_ENUM(NS::Integer, LogicalToPhysicalColorAttachmentMappingState) {
|
||||
LogicalToPhysicalColorAttachmentMappingStateIdentity = 0,
|
||||
LogicalToPhysicalColorAttachmentMappingStateInherited = 1,
|
||||
};
|
||||
|
||||
class RenderPipelineColorAttachmentDescriptor : public NS::Copying<RenderPipelineColorAttachmentDescriptor>
|
||||
{
|
||||
public:
|
||||
static RenderPipelineColorAttachmentDescriptor* alloc();
|
||||
|
||||
MTL::BlendOperation alphaBlendOperation() const;
|
||||
|
||||
BlendState blendingState() const;
|
||||
|
||||
MTL::BlendFactor destinationAlphaBlendFactor() const;
|
||||
|
||||
MTL::BlendFactor destinationRGBBlendFactor() const;
|
||||
|
||||
RenderPipelineColorAttachmentDescriptor* init();
|
||||
|
||||
MTL::PixelFormat pixelFormat() const;
|
||||
|
||||
void reset();
|
||||
|
||||
MTL::BlendOperation rgbBlendOperation() const;
|
||||
|
||||
void setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation);
|
||||
|
||||
void setBlendingState(MTL4::BlendState blendingState);
|
||||
|
||||
void setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor);
|
||||
|
||||
void setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor);
|
||||
|
||||
void setPixelFormat(MTL::PixelFormat pixelFormat);
|
||||
|
||||
void setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation);
|
||||
|
||||
void setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor);
|
||||
|
||||
void setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor);
|
||||
|
||||
void setWriteMask(MTL::ColorWriteMask writeMask);
|
||||
|
||||
MTL::BlendFactor sourceAlphaBlendFactor() const;
|
||||
|
||||
MTL::BlendFactor sourceRGBBlendFactor() const;
|
||||
|
||||
MTL::ColorWriteMask writeMask() const;
|
||||
};
|
||||
|
||||
class RenderPipelineColorAttachmentDescriptorArray : public NS::Copying<RenderPipelineColorAttachmentDescriptorArray>
|
||||
{
|
||||
public:
|
||||
static RenderPipelineColorAttachmentDescriptorArray* alloc();
|
||||
|
||||
RenderPipelineColorAttachmentDescriptorArray* init();
|
||||
|
||||
RenderPipelineColorAttachmentDescriptor* object(NS::UInteger attachmentIndex);
|
||||
|
||||
void reset();
|
||||
|
||||
void setObject(const MTL4::RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
|
||||
};
|
||||
|
||||
class RenderPipelineBinaryFunctionsDescriptor : public NS::Copying<RenderPipelineBinaryFunctionsDescriptor>
|
||||
{
|
||||
public:
|
||||
static RenderPipelineBinaryFunctionsDescriptor* alloc();
|
||||
|
||||
NS::Array* fragmentAdditionalBinaryFunctions() const;
|
||||
|
||||
RenderPipelineBinaryFunctionsDescriptor* init();
|
||||
|
||||
NS::Array* meshAdditionalBinaryFunctions() const;
|
||||
|
||||
NS::Array* objectAdditionalBinaryFunctions() const;
|
||||
|
||||
void reset();
|
||||
|
||||
void setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions);
|
||||
|
||||
void setMeshAdditionalBinaryFunctions(const NS::Array* meshAdditionalBinaryFunctions);
|
||||
|
||||
void setObjectAdditionalBinaryFunctions(const NS::Array* objectAdditionalBinaryFunctions);
|
||||
|
||||
void setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions);
|
||||
|
||||
void setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions);
|
||||
|
||||
NS::Array* tileAdditionalBinaryFunctions() const;
|
||||
|
||||
NS::Array* vertexAdditionalBinaryFunctions() const;
|
||||
};
|
||||
|
||||
class RenderPipelineDescriptor : public NS::Copying<RenderPipelineDescriptor, PipelineDescriptor>
|
||||
{
|
||||
public:
|
||||
static RenderPipelineDescriptor* alloc();
|
||||
|
||||
AlphaToCoverageState alphaToCoverageState() const;
|
||||
|
||||
AlphaToOneState alphaToOneState() const;
|
||||
|
||||
LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState() const;
|
||||
|
||||
RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const;
|
||||
|
||||
FunctionDescriptor* fragmentFunctionDescriptor() const;
|
||||
|
||||
StaticLinkingDescriptor* fragmentStaticLinkingDescriptor() const;
|
||||
|
||||
RenderPipelineDescriptor* init();
|
||||
|
||||
MTL::PrimitiveTopologyClass inputPrimitiveTopology() const;
|
||||
|
||||
bool isRasterizationEnabled() const;
|
||||
|
||||
NS::UInteger maxVertexAmplificationCount() const;
|
||||
|
||||
NS::UInteger rasterSampleCount() const;
|
||||
|
||||
[[deprecated("please use isRasterizationEnabled instead")]]
|
||||
bool rasterizationEnabled() const;
|
||||
|
||||
void reset();
|
||||
|
||||
void setAlphaToCoverageState(MTL4::AlphaToCoverageState alphaToCoverageState);
|
||||
|
||||
void setAlphaToOneState(MTL4::AlphaToOneState alphaToOneState);
|
||||
|
||||
void setColorAttachmentMappingState(MTL4::LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState);
|
||||
|
||||
void setFragmentFunctionDescriptor(const MTL4::FunctionDescriptor* fragmentFunctionDescriptor);
|
||||
|
||||
void setFragmentStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* fragmentStaticLinkingDescriptor);
|
||||
|
||||
void setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology);
|
||||
|
||||
void setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount);
|
||||
|
||||
void setRasterSampleCount(NS::UInteger rasterSampleCount);
|
||||
|
||||
void setRasterizationEnabled(bool rasterizationEnabled);
|
||||
|
||||
void setSupportFragmentBinaryLinking(bool supportFragmentBinaryLinking);
|
||||
|
||||
void setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers);
|
||||
|
||||
void setSupportVertexBinaryLinking(bool supportVertexBinaryLinking);
|
||||
|
||||
void setVertexDescriptor(const MTL::VertexDescriptor* vertexDescriptor);
|
||||
|
||||
void setVertexFunctionDescriptor(const MTL4::FunctionDescriptor* vertexFunctionDescriptor);
|
||||
|
||||
void setVertexStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* vertexStaticLinkingDescriptor);
|
||||
|
||||
bool supportFragmentBinaryLinking() const;
|
||||
|
||||
IndirectCommandBufferSupportState supportIndirectCommandBuffers() const;
|
||||
|
||||
bool supportVertexBinaryLinking() const;
|
||||
|
||||
MTL::VertexDescriptor* vertexDescriptor() const;
|
||||
|
||||
FunctionDescriptor* vertexFunctionDescriptor() const;
|
||||
|
||||
StaticLinkingDescriptor* vertexStaticLinkingDescriptor() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptor* MTL4::RenderPipelineColorAttachmentDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::RenderPipelineColorAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTL4RenderPipelineColorAttachmentDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlendOperation MTL4::RenderPipelineColorAttachmentDescriptor::alphaBlendOperation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BlendOperation>(this, _MTL_PRIVATE_SEL(alphaBlendOperation));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::BlendState MTL4::RenderPipelineColorAttachmentDescriptor::blendingState() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::BlendState>(this, _MTL_PRIVATE_SEL(blendingState));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlendFactor MTL4::RenderPipelineColorAttachmentDescriptor::destinationAlphaBlendFactor() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(destinationAlphaBlendFactor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlendFactor MTL4::RenderPipelineColorAttachmentDescriptor::destinationRGBBlendFactor() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(destinationRGBBlendFactor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptor* MTL4::RenderPipelineColorAttachmentDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::RenderPipelineColorAttachmentDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PixelFormat MTL4::RenderPipelineColorAttachmentDescriptor::pixelFormat() const
|
||||
{
|
||||
return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(pixelFormat));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlendOperation MTL4::RenderPipelineColorAttachmentDescriptor::rgbBlendOperation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BlendOperation>(this, _MTL_PRIVATE_SEL(rgbBlendOperation));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaBlendOperation_), alphaBlendOperation);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setBlendingState(MTL4::BlendState blendingState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBlendingState_), blendingState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDestinationAlphaBlendFactor_), destinationAlphaBlendFactor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDestinationRGBBlendFactor_), destinationRGBBlendFactor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRgbBlendOperation_), rgbBlendOperation);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSourceAlphaBlendFactor_), sourceAlphaBlendFactor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSourceRGBBlendFactor_), sourceRGBBlendFactor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setWriteMask(MTL::ColorWriteMask writeMask)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlendFactor MTL4::RenderPipelineColorAttachmentDescriptor::sourceAlphaBlendFactor() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(sourceAlphaBlendFactor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlendFactor MTL4::RenderPipelineColorAttachmentDescriptor::sourceRGBBlendFactor() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(sourceRGBBlendFactor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ColorWriteMask MTL4::RenderPipelineColorAttachmentDescriptor::writeMask() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ColorWriteMask>(this, _MTL_PRIVATE_SEL(writeMask));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptorArray* MTL4::RenderPipelineColorAttachmentDescriptorArray::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::RenderPipelineColorAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTL4RenderPipelineColorAttachmentDescriptorArray));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptorArray* MTL4::RenderPipelineColorAttachmentDescriptorArray::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::RenderPipelineColorAttachmentDescriptorArray>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptor* MTL4::RenderPipelineColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
|
||||
{
|
||||
return Object::sendMessage<MTL4::RenderPipelineColorAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptorArray::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptorArray::setObject(const MTL4::RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineBinaryFunctionsDescriptor* MTL4::RenderPipelineBinaryFunctionsDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::RenderPipelineBinaryFunctionsDescriptor>(_MTL_PRIVATE_CLS(MTL4RenderPipelineBinaryFunctionsDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::fragmentAdditionalBinaryFunctions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(fragmentAdditionalBinaryFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineBinaryFunctionsDescriptor* MTL4::RenderPipelineBinaryFunctionsDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::RenderPipelineBinaryFunctionsDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::meshAdditionalBinaryFunctions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(meshAdditionalBinaryFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::objectAdditionalBinaryFunctions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(objectAdditionalBinaryFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentAdditionalBinaryFunctions_), fragmentAdditionalBinaryFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setMeshAdditionalBinaryFunctions(const NS::Array* meshAdditionalBinaryFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshAdditionalBinaryFunctions_), meshAdditionalBinaryFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setObjectAdditionalBinaryFunctions(const NS::Array* objectAdditionalBinaryFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectAdditionalBinaryFunctions_), objectAdditionalBinaryFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileAdditionalBinaryFunctions_), tileAdditionalBinaryFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexAdditionalBinaryFunctions_), vertexAdditionalBinaryFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::tileAdditionalBinaryFunctions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(tileAdditionalBinaryFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::vertexAdditionalBinaryFunctions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexAdditionalBinaryFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineDescriptor* MTL4::RenderPipelineDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::RenderPipelineDescriptor>(_MTL_PRIVATE_CLS(MTL4RenderPipelineDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::AlphaToCoverageState MTL4::RenderPipelineDescriptor::alphaToCoverageState() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::AlphaToCoverageState>(this, _MTL_PRIVATE_SEL(alphaToCoverageState));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::AlphaToOneState MTL4::RenderPipelineDescriptor::alphaToOneState() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::AlphaToOneState>(this, _MTL_PRIVATE_SEL(alphaToOneState));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::LogicalToPhysicalColorAttachmentMappingState MTL4::RenderPipelineDescriptor::colorAttachmentMappingState() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::LogicalToPhysicalColorAttachmentMappingState>(this, _MTL_PRIVATE_SEL(colorAttachmentMappingState));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptorArray* MTL4::RenderPipelineDescriptor::colorAttachments() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::RenderPipelineColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::RenderPipelineDescriptor::fragmentFunctionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(fragmentFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::RenderPipelineDescriptor::fragmentStaticLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::StaticLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(fragmentStaticLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::RenderPipelineDescriptor* MTL4::RenderPipelineDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::RenderPipelineDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PrimitiveTopologyClass MTL4::RenderPipelineDescriptor::inputPrimitiveTopology() const
|
||||
{
|
||||
return Object::sendMessage<MTL::PrimitiveTopologyClass>(this, _MTL_PRIVATE_SEL(inputPrimitiveTopology));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::RenderPipelineDescriptor::isRasterizationEnabled() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isRasterizationEnabled));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPipelineDescriptor::maxVertexAmplificationCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::RenderPipelineDescriptor::rasterSampleCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(rasterSampleCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::RenderPipelineDescriptor::rasterizationEnabled() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isRasterizationEnabled));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setAlphaToCoverageState(MTL4::AlphaToCoverageState alphaToCoverageState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToCoverageState_), alphaToCoverageState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setAlphaToOneState(MTL4::AlphaToOneState alphaToOneState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToOneState_), alphaToOneState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setColorAttachmentMappingState(MTL4::LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorAttachmentMappingState_), colorAttachmentMappingState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setFragmentFunctionDescriptor(const MTL4::FunctionDescriptor* fragmentFunctionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentFunctionDescriptor_), fragmentFunctionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setFragmentStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* fragmentStaticLinkingDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentStaticLinkingDescriptor_), fragmentStaticLinkingDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInputPrimitiveTopology_), inputPrimitiveTopology);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setSupportFragmentBinaryLinking(bool supportFragmentBinaryLinking)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportFragmentBinaryLinking_), supportFragmentBinaryLinking);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setSupportVertexBinaryLinking(bool supportVertexBinaryLinking)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportVertexBinaryLinking_), supportVertexBinaryLinking);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setVertexDescriptor(const MTL::VertexDescriptor* vertexDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexDescriptor_), vertexDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setVertexFunctionDescriptor(const MTL4::FunctionDescriptor* vertexFunctionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFunctionDescriptor_), vertexFunctionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::RenderPipelineDescriptor::setVertexStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* vertexStaticLinkingDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexStaticLinkingDescriptor_), vertexStaticLinkingDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::RenderPipelineDescriptor::supportFragmentBinaryLinking() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportFragmentBinaryLinking));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::IndirectCommandBufferSupportState MTL4::RenderPipelineDescriptor::supportIndirectCommandBuffers() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::IndirectCommandBufferSupportState>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::RenderPipelineDescriptor::supportVertexBinaryLinking() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportVertexBinaryLinking));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::VertexDescriptor* MTL4::RenderPipelineDescriptor::vertexDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL::VertexDescriptor*>(this, _MTL_PRIVATE_SEL(vertexDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::RenderPipelineDescriptor::vertexFunctionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(vertexFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::RenderPipelineDescriptor::vertexStaticLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::StaticLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(vertexStaticLinkingDescriptor));
|
||||
}
|
||||
100
dist/include/metal_cpp/Metal/MTL4SpecializedFunctionDescriptor.hpp
vendored
Normal file
100
dist/include/metal_cpp/Metal/MTL4SpecializedFunctionDescriptor.hpp
vendored
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4SpecializedFunctionDescriptor.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 "MTL4FunctionDescriptor.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class FunctionDescriptor;
|
||||
class SpecializedFunctionDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class FunctionConstantValues;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class SpecializedFunctionDescriptor : public NS::Copying<SpecializedFunctionDescriptor, FunctionDescriptor>
|
||||
{
|
||||
public:
|
||||
static SpecializedFunctionDescriptor* alloc();
|
||||
|
||||
MTL::FunctionConstantValues* constantValues() const;
|
||||
|
||||
FunctionDescriptor* functionDescriptor() const;
|
||||
|
||||
SpecializedFunctionDescriptor* init();
|
||||
|
||||
void setConstantValues(const MTL::FunctionConstantValues* constantValues);
|
||||
|
||||
void setFunctionDescriptor(const MTL4::FunctionDescriptor* functionDescriptor);
|
||||
|
||||
void setSpecializedName(const NS::String* specializedName);
|
||||
NS::String* specializedName() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::SpecializedFunctionDescriptor* MTL4::SpecializedFunctionDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::SpecializedFunctionDescriptor>(_MTL_PRIVATE_CLS(MTL4SpecializedFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionConstantValues* MTL4::SpecializedFunctionDescriptor::constantValues() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionConstantValues*>(this, _MTL_PRIVATE_SEL(constantValues));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::SpecializedFunctionDescriptor::functionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(functionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::SpecializedFunctionDescriptor* MTL4::SpecializedFunctionDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::SpecializedFunctionDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::SpecializedFunctionDescriptor::setConstantValues(const MTL::FunctionConstantValues* constantValues)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValues_), constantValues);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::SpecializedFunctionDescriptor::setFunctionDescriptor(const MTL4::FunctionDescriptor* functionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionDescriptor_), functionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::SpecializedFunctionDescriptor::setSpecializedName(const NS::String* specializedName)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSpecializedName_), specializedName);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL4::SpecializedFunctionDescriptor::specializedName() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(specializedName));
|
||||
}
|
||||
86
dist/include/metal_cpp/Metal/MTL4StitchedFunctionDescriptor.hpp
vendored
Normal file
86
dist/include/metal_cpp/Metal/MTL4StitchedFunctionDescriptor.hpp
vendored
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4StitchedFunctionDescriptor.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 "MTL4FunctionDescriptor.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class StitchedFunctionDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class FunctionStitchingGraph;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class StitchedFunctionDescriptor : public NS::Copying<StitchedFunctionDescriptor, FunctionDescriptor>
|
||||
{
|
||||
public:
|
||||
static StitchedFunctionDescriptor* alloc();
|
||||
|
||||
NS::Array* functionDescriptors() const;
|
||||
|
||||
MTL::FunctionStitchingGraph* functionGraph() const;
|
||||
|
||||
StitchedFunctionDescriptor* init();
|
||||
|
||||
void setFunctionDescriptors(const NS::Array* functionDescriptors);
|
||||
|
||||
void setFunctionGraph(const MTL::FunctionStitchingGraph* functionGraph);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::StitchedFunctionDescriptor* MTL4::StitchedFunctionDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::StitchedFunctionDescriptor>(_MTL_PRIVATE_CLS(MTL4StitchedFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL4::StitchedFunctionDescriptor::functionDescriptors() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functionDescriptors));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingGraph* MTL4::StitchedFunctionDescriptor::functionGraph() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionStitchingGraph*>(this, _MTL_PRIVATE_SEL(functionGraph));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StitchedFunctionDescriptor* MTL4::StitchedFunctionDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::StitchedFunctionDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::StitchedFunctionDescriptor::setFunctionDescriptors(const NS::Array* functionDescriptors)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionDescriptors_), functionDescriptors);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::StitchedFunctionDescriptor::setFunctionGraph(const MTL::FunctionStitchingGraph* functionGraph)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionGraph_), functionGraph);
|
||||
}
|
||||
173
dist/include/metal_cpp/Metal/MTL4TileRenderPipeline.hpp
vendored
Normal file
173
dist/include/metal_cpp/Metal/MTL4TileRenderPipeline.hpp
vendored
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTL4TileRenderPipeline.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 "MTL4PipelineState.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class FunctionDescriptor;
|
||||
class StaticLinkingDescriptor;
|
||||
class TileRenderPipelineDescriptor;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class TileRenderPipelineColorAttachmentDescriptorArray;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class TileRenderPipelineDescriptor : public NS::Copying<TileRenderPipelineDescriptor, PipelineDescriptor>
|
||||
{
|
||||
public:
|
||||
static TileRenderPipelineDescriptor* alloc();
|
||||
|
||||
MTL::TileRenderPipelineColorAttachmentDescriptorArray* colorAttachments() const;
|
||||
|
||||
TileRenderPipelineDescriptor* init();
|
||||
|
||||
NS::UInteger maxTotalThreadsPerThreadgroup() const;
|
||||
|
||||
NS::UInteger rasterSampleCount() const;
|
||||
|
||||
MTL::Size requiredThreadsPerThreadgroup() const;
|
||||
|
||||
void reset();
|
||||
|
||||
void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup);
|
||||
|
||||
void setRasterSampleCount(NS::UInteger rasterSampleCount);
|
||||
|
||||
void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup);
|
||||
|
||||
void setStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* staticLinkingDescriptor);
|
||||
|
||||
void setSupportBinaryLinking(bool supportBinaryLinking);
|
||||
|
||||
void setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize);
|
||||
|
||||
void setTileFunctionDescriptor(const MTL4::FunctionDescriptor* tileFunctionDescriptor);
|
||||
|
||||
StaticLinkingDescriptor* staticLinkingDescriptor() const;
|
||||
|
||||
bool supportBinaryLinking() const;
|
||||
|
||||
bool threadgroupSizeMatchesTileSize() const;
|
||||
|
||||
FunctionDescriptor* tileFunctionDescriptor() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL4::TileRenderPipelineDescriptor* MTL4::TileRenderPipelineDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL4::TileRenderPipelineDescriptor>(_MTL_PRIVATE_CLS(MTL4TileRenderPipelineDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL4::TileRenderPipelineDescriptor::colorAttachments() const
|
||||
{
|
||||
return Object::sendMessage<MTL::TileRenderPipelineColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::TileRenderPipelineDescriptor* MTL4::TileRenderPipelineDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL4::TileRenderPipelineDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::TileRenderPipelineDescriptor::maxTotalThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL4::TileRenderPipelineDescriptor::rasterSampleCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(rasterSampleCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Size MTL4::TileRenderPipelineDescriptor::requiredThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* staticLinkingDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStaticLinkingDescriptor_), staticLinkingDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setSupportBinaryLinking(bool supportBinaryLinking)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportBinaryLinking_), supportBinaryLinking);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupSizeMatchesTileSize_), threadgroupSizeMatchesTileSize);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setTileFunctionDescriptor(const MTL4::FunctionDescriptor* tileFunctionDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileFunctionDescriptor_), tileFunctionDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::TileRenderPipelineDescriptor::staticLinkingDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::StaticLinkingDescriptor*>(this, _MTL_PRIVATE_SEL(staticLinkingDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::TileRenderPipelineDescriptor::supportBinaryLinking() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportBinaryLinking));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL4::TileRenderPipelineDescriptor::threadgroupSizeMatchesTileSize() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(threadgroupSizeMatchesTileSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL4::FunctionDescriptor* MTL4::TileRenderPipelineDescriptor::tileFunctionDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL4::FunctionDescriptor*>(this, _MTL_PRIVATE_SEL(tileFunctionDescriptor));
|
||||
}
|
||||
1887
dist/include/metal_cpp/Metal/MTLAccelerationStructure.hpp
vendored
Normal file
1887
dist/include/metal_cpp/Metal/MTLAccelerationStructure.hpp
vendored
Normal file
File diff suppressed because it is too large
Load diff
260
dist/include/metal_cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp
vendored
Normal file
260
dist/include/metal_cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,260 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLAccelerationStructureCommandEncoder.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 "MTLAccelerationStructure.hpp"
|
||||
#include "MTLCommandEncoder.hpp"
|
||||
#include "MTLDataType.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class AccelerationStructure;
|
||||
class AccelerationStructureDescriptor;
|
||||
class AccelerationStructurePassDescriptor;
|
||||
class AccelerationStructurePassSampleBufferAttachmentDescriptor;
|
||||
class AccelerationStructurePassSampleBufferAttachmentDescriptorArray;
|
||||
class Buffer;
|
||||
class CounterSampleBuffer;
|
||||
class Fence;
|
||||
class Heap;
|
||||
class Resource;
|
||||
|
||||
class AccelerationStructureCommandEncoder : public NS::Referencing<AccelerationStructureCommandEncoder, CommandEncoder>
|
||||
{
|
||||
public:
|
||||
void buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset);
|
||||
|
||||
void copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure);
|
||||
|
||||
void copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure);
|
||||
|
||||
void refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset);
|
||||
void refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset, MTL::AccelerationStructureRefitOptions options);
|
||||
|
||||
void sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier);
|
||||
|
||||
void updateFence(const MTL::Fence* fence);
|
||||
|
||||
void useHeap(const MTL::Heap* heap);
|
||||
void useHeaps(const MTL::Heap* const heaps[], NS::UInteger count);
|
||||
|
||||
void useResource(const MTL::Resource* resource, MTL::ResourceUsage usage);
|
||||
void useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage);
|
||||
|
||||
void waitForFence(const MTL::Fence* fence);
|
||||
|
||||
void writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset);
|
||||
void writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset, MTL::DataType sizeDataType);
|
||||
};
|
||||
class AccelerationStructurePassSampleBufferAttachmentDescriptor : public NS::Copying<AccelerationStructurePassSampleBufferAttachmentDescriptor>
|
||||
{
|
||||
public:
|
||||
static AccelerationStructurePassSampleBufferAttachmentDescriptor* alloc();
|
||||
|
||||
NS::UInteger endOfEncoderSampleIndex() const;
|
||||
|
||||
AccelerationStructurePassSampleBufferAttachmentDescriptor* init();
|
||||
|
||||
CounterSampleBuffer* sampleBuffer() const;
|
||||
|
||||
void setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex);
|
||||
|
||||
void setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer);
|
||||
|
||||
void setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex);
|
||||
NS::UInteger startOfEncoderSampleIndex() const;
|
||||
};
|
||||
class AccelerationStructurePassSampleBufferAttachmentDescriptorArray : public NS::Referencing<AccelerationStructurePassSampleBufferAttachmentDescriptorArray>
|
||||
{
|
||||
public:
|
||||
static AccelerationStructurePassSampleBufferAttachmentDescriptorArray* alloc();
|
||||
|
||||
AccelerationStructurePassSampleBufferAttachmentDescriptorArray* init();
|
||||
|
||||
AccelerationStructurePassSampleBufferAttachmentDescriptor* object(NS::UInteger attachmentIndex);
|
||||
void setObject(const MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
|
||||
};
|
||||
class AccelerationStructurePassDescriptor : public NS::Copying<AccelerationStructurePassDescriptor>
|
||||
{
|
||||
public:
|
||||
static AccelerationStructurePassDescriptor* accelerationStructurePassDescriptor();
|
||||
|
||||
static AccelerationStructurePassDescriptor* alloc();
|
||||
|
||||
AccelerationStructurePassDescriptor* init();
|
||||
|
||||
AccelerationStructurePassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(buildAccelerationStructure_descriptor_scratchBuffer_scratchBufferOffset_), accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyAndCompactAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset, MTL::AccelerationStructureRefitOptions options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_options_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::updateFence(const MTL::Fence* fence)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_), fence);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useHeap(const MTL::Heap* heap)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeap_), heap);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::waitForFence(const MTL::Fence* fence)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_), fence);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_), accelerationStructure, buffer, offset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset, MTL::DataType sizeDataType)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_sizeDataType_), accelerationStructure, buffer, offset, sizeDataType);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CounterSampleBuffer* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::sampleBuffer() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::init()
|
||||
{
|
||||
return NS::Object::init<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::setObject(const MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::accelerationStructurePassDescriptor()
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructurePassDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassDescriptor), _MTL_PRIVATE_SEL(accelerationStructurePassDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::AccelerationStructurePassDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::AccelerationStructurePassDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassDescriptor::sampleBufferAttachments() const
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
|
||||
}
|
||||
292
dist/include/metal_cpp/Metal/MTLAccelerationStructureTypes.hpp
vendored
Normal file
292
dist/include/metal_cpp/Metal/MTLAccelerationStructureTypes.hpp
vendored
Normal file
|
|
@ -0,0 +1,292 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLAccelerationStructureTypes.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "MTLDefines.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLResource.hpp"
|
||||
#include "MTLStageInputOutputDescriptor.hpp"
|
||||
|
||||
#include "../Foundation/Foundation.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wnested-anon-types"
|
||||
struct PackedFloat3
|
||||
{
|
||||
PackedFloat3();
|
||||
PackedFloat3(float x, float y, float z);
|
||||
|
||||
float& operator[](int idx);
|
||||
float operator[](int idx) const;
|
||||
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
};
|
||||
|
||||
float elements[3];
|
||||
};
|
||||
} _MTL_PACKED;
|
||||
#pragma clang diagnostic pop
|
||||
|
||||
struct PackedFloat4x3
|
||||
{
|
||||
PackedFloat4x3();
|
||||
PackedFloat4x3(const PackedFloat3& col0, const PackedFloat3& col1, const PackedFloat3& col2, const PackedFloat3& col3);
|
||||
|
||||
PackedFloat3& operator[](int idx);
|
||||
const PackedFloat3& operator[](int idx) const;
|
||||
|
||||
PackedFloat3 columns[4];
|
||||
} _MTL_PACKED;
|
||||
|
||||
struct AxisAlignedBoundingBox
|
||||
{
|
||||
AxisAlignedBoundingBox();
|
||||
AxisAlignedBoundingBox(PackedFloat3 p);
|
||||
AxisAlignedBoundingBox(PackedFloat3 min, PackedFloat3 max);
|
||||
|
||||
PackedFloat3 min;
|
||||
PackedFloat3 max;
|
||||
} _MTL_PACKED;
|
||||
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wnested-anon-types"
|
||||
struct PackedFloatQuaternion
|
||||
{
|
||||
PackedFloatQuaternion();
|
||||
PackedFloatQuaternion(float x, float y, float z, float w);
|
||||
|
||||
float& operator[](int idx);
|
||||
const float& operator[](int idx) const;
|
||||
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
float w;
|
||||
};
|
||||
|
||||
float elements[4];
|
||||
};
|
||||
|
||||
} _MTL_PACKED;
|
||||
#pragma clang diagnostic pop
|
||||
|
||||
struct ComponentTransform
|
||||
{
|
||||
PackedFloat3 scale;
|
||||
PackedFloat3 shear;
|
||||
PackedFloat3 pivot;
|
||||
PackedFloatQuaternion rotation;
|
||||
PackedFloat3 translation;
|
||||
} _MTL_PACKED;
|
||||
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
|
||||
struct BufferRange
|
||||
{
|
||||
BufferRange() = default;
|
||||
BufferRange(uint64_t bufferAddress);
|
||||
BufferRange(uint64_t bufferAddress, uint64_t length);
|
||||
|
||||
static MTL4::BufferRange Make(uint64_t bufferAddress, uint64_t length);
|
||||
|
||||
uint64_t bufferAddress;
|
||||
uint64_t length;
|
||||
} _MTL_PACKED;
|
||||
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::PackedFloat3::PackedFloat3()
|
||||
: x(0.0f)
|
||||
, y(0.0f)
|
||||
, z(0.0f)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::PackedFloat3::PackedFloat3(float _x, float _y, float _z)
|
||||
: x(_x)
|
||||
, y(_y)
|
||||
, z(_z)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE float& MTL::PackedFloat3::operator[](int idx)
|
||||
{
|
||||
return elements[idx];
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE float MTL::PackedFloat3::operator[](int idx) const
|
||||
{
|
||||
return elements[idx];
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::PackedFloat4x3::PackedFloat4x3()
|
||||
{
|
||||
columns[0] = PackedFloat3(0.0f, 0.0f, 0.0f);
|
||||
columns[1] = PackedFloat3(0.0f, 0.0f, 0.0f);
|
||||
columns[2] = PackedFloat3(0.0f, 0.0f, 0.0f);
|
||||
columns[3] = PackedFloat3(0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::PackedFloat4x3::PackedFloat4x3(const PackedFloat3& col0, const PackedFloat3& col1, const PackedFloat3& col2, const PackedFloat3& col3)
|
||||
{
|
||||
columns[0] = col0;
|
||||
columns[1] = col1;
|
||||
columns[2] = col2;
|
||||
columns[3] = col3;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::PackedFloat3& MTL::PackedFloat4x3::operator[](int idx)
|
||||
{
|
||||
return columns[idx];
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE const MTL::PackedFloat3& MTL::PackedFloat4x3::operator[](int idx) const
|
||||
{
|
||||
return columns[idx];
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
#if __apple_build_version__ > 16000026
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wnan-infinity-disabled"
|
||||
#endif // __apple_build_version__ > 16000026
|
||||
_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox()
|
||||
: min(INFINITY, INFINITY, INFINITY)
|
||||
, max(-INFINITY, -INFINITY, -INFINITY)
|
||||
{
|
||||
}
|
||||
#if __apple_build_version__ > 16000026
|
||||
#pragma clang diagnostic pop
|
||||
#endif // if __apple_build_version__ > 16000026
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox(PackedFloat3 p)
|
||||
: min(p)
|
||||
, max(p)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox(PackedFloat3 _min, PackedFloat3 _max)
|
||||
: min(_min)
|
||||
, max(_max)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::PackedFloatQuaternion::PackedFloatQuaternion()
|
||||
: x(0.0f)
|
||||
, y(0.0f)
|
||||
, z(0.0f)
|
||||
, w(0.0f)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::PackedFloatQuaternion::PackedFloatQuaternion(float x, float y, float z, float w)
|
||||
: x(x)
|
||||
, y(y)
|
||||
, z(z)
|
||||
, w(w)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE float& MTL::PackedFloatQuaternion::operator[](int idx)
|
||||
{
|
||||
return elements[idx];
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE const float& MTL::PackedFloatQuaternion::operator[](int idx) const
|
||||
{
|
||||
return elements[idx];
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL4::BufferRange::BufferRange(uint64_t bufferAddress)
|
||||
: bufferAddress(bufferAddress)
|
||||
, length(-1)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL4::BufferRange::BufferRange(uint64_t bufferAddress, uint64_t length)
|
||||
: bufferAddress(bufferAddress)
|
||||
, length(length)
|
||||
{
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL4::BufferRange MTL4::BufferRange::Make(uint64_t bufferAddress, uint64_t length)
|
||||
{
|
||||
return MTL4::BufferRange(bufferAddress, length);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
40
dist/include/metal_cpp/Metal/MTLAllocation.hpp
vendored
Normal file
40
dist/include/metal_cpp/Metal/MTLAllocation.hpp
vendored
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLAllocation.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Allocation : public NS::Referencing<Allocation>
|
||||
{
|
||||
public:
|
||||
NS::UInteger allocatedSize() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE NS::UInteger MTL::Allocation::allocatedSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(allocatedSize));
|
||||
}
|
||||
787
dist/include/metal_cpp/Metal/MTLArgument.hpp
vendored
Normal file
787
dist/include/metal_cpp/Metal/MTLArgument.hpp
vendored
Normal file
|
|
@ -0,0 +1,787 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLArgument.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 "MTLDataType.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTensor.hpp"
|
||||
#include "MTLTexture.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Argument;
|
||||
class ArrayType;
|
||||
class PointerType;
|
||||
class StructMember;
|
||||
class StructType;
|
||||
class TensorExtents;
|
||||
class TensorReferenceType;
|
||||
class TextureReferenceType;
|
||||
class Type;
|
||||
_MTL_ENUM(NS::UInteger, IndexType) {
|
||||
IndexTypeUInt16 = 0,
|
||||
IndexTypeUInt32 = 1,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, BindingType) {
|
||||
BindingTypeBuffer = 0,
|
||||
BindingTypeThreadgroupMemory = 1,
|
||||
BindingTypeTexture = 2,
|
||||
BindingTypeSampler = 3,
|
||||
BindingTypeImageblockData = 16,
|
||||
BindingTypeImageblock = 17,
|
||||
BindingTypeVisibleFunctionTable = 24,
|
||||
BindingTypePrimitiveAccelerationStructure = 25,
|
||||
BindingTypeInstanceAccelerationStructure = 26,
|
||||
BindingTypeIntersectionFunctionTable = 27,
|
||||
BindingTypeObjectPayload = 34,
|
||||
BindingTypeTensor = 37,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, ArgumentType) {
|
||||
ArgumentTypeBuffer = 0,
|
||||
ArgumentTypeThreadgroupMemory = 1,
|
||||
ArgumentTypeTexture = 2,
|
||||
ArgumentTypeSampler = 3,
|
||||
ArgumentTypeImageblockData = 16,
|
||||
ArgumentTypeImageblock = 17,
|
||||
ArgumentTypeVisibleFunctionTable = 24,
|
||||
ArgumentTypePrimitiveAccelerationStructure = 25,
|
||||
ArgumentTypeInstanceAccelerationStructure = 26,
|
||||
ArgumentTypeIntersectionFunctionTable = 27,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, BindingAccess) {
|
||||
BindingAccessReadOnly = 0,
|
||||
BindingAccessReadWrite = 1,
|
||||
BindingAccessWriteOnly = 2,
|
||||
ArgumentAccessReadOnly = 0,
|
||||
ArgumentAccessReadWrite = 1,
|
||||
ArgumentAccessWriteOnly = 2,
|
||||
};
|
||||
|
||||
class Type : public NS::Referencing<Type>
|
||||
{
|
||||
public:
|
||||
static Type* alloc();
|
||||
|
||||
DataType dataType() const;
|
||||
|
||||
Type* init();
|
||||
};
|
||||
class StructMember : public NS::Referencing<StructMember>
|
||||
{
|
||||
public:
|
||||
static StructMember* alloc();
|
||||
|
||||
NS::UInteger argumentIndex() const;
|
||||
|
||||
ArrayType* arrayType();
|
||||
|
||||
DataType dataType() const;
|
||||
|
||||
StructMember* init();
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
NS::UInteger offset() const;
|
||||
|
||||
PointerType* pointerType();
|
||||
|
||||
StructType* structType();
|
||||
|
||||
TensorReferenceType* tensorReferenceType();
|
||||
|
||||
TextureReferenceType* textureReferenceType();
|
||||
};
|
||||
class StructType : public NS::Referencing<StructType, Type>
|
||||
{
|
||||
public:
|
||||
static StructType* alloc();
|
||||
|
||||
StructType* init();
|
||||
|
||||
StructMember* memberByName(const NS::String* name);
|
||||
|
||||
NS::Array* members() const;
|
||||
};
|
||||
class ArrayType : public NS::Referencing<ArrayType, Type>
|
||||
{
|
||||
public:
|
||||
static ArrayType* alloc();
|
||||
|
||||
NS::UInteger argumentIndexStride() const;
|
||||
|
||||
NS::UInteger arrayLength() const;
|
||||
|
||||
ArrayType* elementArrayType();
|
||||
|
||||
PointerType* elementPointerType();
|
||||
|
||||
StructType* elementStructType();
|
||||
|
||||
TensorReferenceType* elementTensorReferenceType();
|
||||
|
||||
TextureReferenceType* elementTextureReferenceType();
|
||||
|
||||
DataType elementType() const;
|
||||
|
||||
ArrayType* init();
|
||||
|
||||
NS::UInteger stride() const;
|
||||
};
|
||||
class PointerType : public NS::Referencing<PointerType, Type>
|
||||
{
|
||||
public:
|
||||
BindingAccess access() const;
|
||||
|
||||
NS::UInteger alignment() const;
|
||||
|
||||
static PointerType* alloc();
|
||||
|
||||
NS::UInteger dataSize() const;
|
||||
|
||||
ArrayType* elementArrayType();
|
||||
|
||||
bool elementIsArgumentBuffer() const;
|
||||
|
||||
StructType* elementStructType();
|
||||
|
||||
DataType elementType() const;
|
||||
|
||||
PointerType* init();
|
||||
};
|
||||
class TextureReferenceType : public NS::Referencing<TextureReferenceType, Type>
|
||||
{
|
||||
public:
|
||||
BindingAccess access() const;
|
||||
|
||||
static TextureReferenceType* alloc();
|
||||
|
||||
TextureReferenceType* init();
|
||||
|
||||
bool isDepthTexture() const;
|
||||
|
||||
DataType textureDataType() const;
|
||||
|
||||
TextureType textureType() const;
|
||||
};
|
||||
class TensorReferenceType : public NS::Referencing<TensorReferenceType, Type>
|
||||
{
|
||||
public:
|
||||
BindingAccess access() const;
|
||||
|
||||
static TensorReferenceType* alloc();
|
||||
|
||||
TensorExtents* dimensions() const;
|
||||
|
||||
DataType indexType() const;
|
||||
|
||||
TensorReferenceType* init();
|
||||
|
||||
TensorDataType tensorDataType() const;
|
||||
};
|
||||
class Argument : public NS::Referencing<Argument>
|
||||
{
|
||||
public:
|
||||
BindingAccess access() const;
|
||||
|
||||
[[deprecated("please use isActive instead")]]
|
||||
bool active() const;
|
||||
|
||||
static Argument* alloc();
|
||||
|
||||
NS::UInteger arrayLength() const;
|
||||
|
||||
NS::UInteger bufferAlignment() const;
|
||||
|
||||
NS::UInteger bufferDataSize() const;
|
||||
|
||||
DataType bufferDataType() const;
|
||||
|
||||
PointerType* bufferPointerType() const;
|
||||
|
||||
StructType* bufferStructType() const;
|
||||
|
||||
NS::UInteger index() const;
|
||||
|
||||
Argument* init();
|
||||
|
||||
bool isActive() const;
|
||||
|
||||
bool isDepthTexture() const;
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
DataType textureDataType() const;
|
||||
|
||||
TextureType textureType() const;
|
||||
|
||||
NS::UInteger threadgroupMemoryAlignment() const;
|
||||
|
||||
NS::UInteger threadgroupMemoryDataSize() const;
|
||||
|
||||
ArgumentType type() const;
|
||||
};
|
||||
class Binding : public NS::Referencing<Binding>
|
||||
{
|
||||
public:
|
||||
BindingAccess access() const;
|
||||
|
||||
[[deprecated("please use isArgument instead")]]
|
||||
bool argument() const;
|
||||
|
||||
NS::UInteger index() const;
|
||||
|
||||
bool isArgument() const;
|
||||
|
||||
bool isUsed() const;
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
BindingType type() const;
|
||||
|
||||
[[deprecated("please use isUsed instead")]]
|
||||
bool used() const;
|
||||
};
|
||||
class BufferBinding : public NS::Referencing<BufferBinding, Binding>
|
||||
{
|
||||
public:
|
||||
NS::UInteger bufferAlignment() const;
|
||||
|
||||
NS::UInteger bufferDataSize() const;
|
||||
|
||||
DataType bufferDataType() const;
|
||||
|
||||
PointerType* bufferPointerType() const;
|
||||
|
||||
StructType* bufferStructType() const;
|
||||
};
|
||||
class ThreadgroupBinding : public NS::Referencing<ThreadgroupBinding, Binding>
|
||||
{
|
||||
public:
|
||||
NS::UInteger threadgroupMemoryAlignment() const;
|
||||
|
||||
NS::UInteger threadgroupMemoryDataSize() const;
|
||||
};
|
||||
class TextureBinding : public NS::Referencing<TextureBinding, Binding>
|
||||
{
|
||||
public:
|
||||
NS::UInteger arrayLength() const;
|
||||
|
||||
[[deprecated("please use isDepthTexture instead")]]
|
||||
bool depthTexture() const;
|
||||
bool isDepthTexture() const;
|
||||
|
||||
DataType textureDataType() const;
|
||||
|
||||
TextureType textureType() const;
|
||||
};
|
||||
class ObjectPayloadBinding : public NS::Referencing<ObjectPayloadBinding, Binding>
|
||||
{
|
||||
public:
|
||||
NS::UInteger objectPayloadAlignment() const;
|
||||
|
||||
NS::UInteger objectPayloadDataSize() const;
|
||||
};
|
||||
class TensorBinding : public NS::Referencing<TensorBinding, Binding>
|
||||
{
|
||||
public:
|
||||
TensorExtents* dimensions() const;
|
||||
|
||||
DataType indexType() const;
|
||||
|
||||
TensorDataType tensorDataType() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::Type* MTL::Type::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::Type>(_MTL_PRIVATE_CLS(MTLType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::Type::dataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(dataType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Type* MTL::Type::init()
|
||||
{
|
||||
return NS::Object::init<MTL::Type>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructMember* MTL::StructMember::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::StructMember>(_MTL_PRIVATE_CLS(MTLStructMember));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::StructMember::argumentIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(argumentIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArrayType* MTL::StructMember::arrayType()
|
||||
{
|
||||
return Object::sendMessage<MTL::ArrayType*>(this, _MTL_PRIVATE_SEL(arrayType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::StructMember::dataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(dataType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructMember* MTL::StructMember::init()
|
||||
{
|
||||
return NS::Object::init<MTL::StructMember>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::StructMember::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::StructMember::offset() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(offset));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PointerType* MTL::StructMember::pointerType()
|
||||
{
|
||||
return Object::sendMessage<MTL::PointerType*>(this, _MTL_PRIVATE_SEL(pointerType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructType* MTL::StructMember::structType()
|
||||
{
|
||||
return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(structType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorReferenceType* MTL::StructMember::tensorReferenceType()
|
||||
{
|
||||
return Object::sendMessage<MTL::TensorReferenceType*>(this, _MTL_PRIVATE_SEL(tensorReferenceType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TextureReferenceType* MTL::StructMember::textureReferenceType()
|
||||
{
|
||||
return Object::sendMessage<MTL::TextureReferenceType*>(this, _MTL_PRIVATE_SEL(textureReferenceType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructType* MTL::StructType::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::StructType>(_MTL_PRIVATE_CLS(MTLStructType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructType* MTL::StructType::init()
|
||||
{
|
||||
return NS::Object::init<MTL::StructType>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructMember* MTL::StructType::memberByName(const NS::String* name)
|
||||
{
|
||||
return Object::sendMessage<MTL::StructMember*>(this, _MTL_PRIVATE_SEL(memberByName_), name);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::StructType::members() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(members));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArrayType* MTL::ArrayType::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::ArrayType>(_MTL_PRIVATE_CLS(MTLArrayType));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ArrayType::argumentIndexStride() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(argumentIndexStride));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ArrayType::arrayLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArrayType* MTL::ArrayType::elementArrayType()
|
||||
{
|
||||
return Object::sendMessage<MTL::ArrayType*>(this, _MTL_PRIVATE_SEL(elementArrayType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PointerType* MTL::ArrayType::elementPointerType()
|
||||
{
|
||||
return Object::sendMessage<MTL::PointerType*>(this, _MTL_PRIVATE_SEL(elementPointerType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructType* MTL::ArrayType::elementStructType()
|
||||
{
|
||||
return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(elementStructType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorReferenceType* MTL::ArrayType::elementTensorReferenceType()
|
||||
{
|
||||
return Object::sendMessage<MTL::TensorReferenceType*>(this, _MTL_PRIVATE_SEL(elementTensorReferenceType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TextureReferenceType* MTL::ArrayType::elementTextureReferenceType()
|
||||
{
|
||||
return Object::sendMessage<MTL::TextureReferenceType*>(this, _MTL_PRIVATE_SEL(elementTextureReferenceType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::ArrayType::elementType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(elementType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArrayType* MTL::ArrayType::init()
|
||||
{
|
||||
return NS::Object::init<MTL::ArrayType>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ArrayType::stride() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(stride));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BindingAccess MTL::PointerType::access() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::PointerType::alignment() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(alignment));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PointerType* MTL::PointerType::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::PointerType>(_MTL_PRIVATE_CLS(MTLPointerType));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::PointerType::dataSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(dataSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArrayType* MTL::PointerType::elementArrayType()
|
||||
{
|
||||
return Object::sendMessage<MTL::ArrayType*>(this, _MTL_PRIVATE_SEL(elementArrayType));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::PointerType::elementIsArgumentBuffer() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(elementIsArgumentBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructType* MTL::PointerType::elementStructType()
|
||||
{
|
||||
return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(elementStructType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::PointerType::elementType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(elementType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PointerType* MTL::PointerType::init()
|
||||
{
|
||||
return NS::Object::init<MTL::PointerType>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BindingAccess MTL::TextureReferenceType::access() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TextureReferenceType* MTL::TextureReferenceType::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::TextureReferenceType>(_MTL_PRIVATE_CLS(MTLTextureReferenceType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TextureReferenceType* MTL::TextureReferenceType::init()
|
||||
{
|
||||
return NS::Object::init<MTL::TextureReferenceType>();
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::TextureReferenceType::isDepthTexture() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthTexture));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::TextureReferenceType::textureDataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(textureDataType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TextureType MTL::TextureReferenceType::textureType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BindingAccess MTL::TensorReferenceType::access() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorReferenceType* MTL::TensorReferenceType::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::TensorReferenceType>(_MTL_PRIVATE_CLS(MTLTensorReferenceType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorExtents* MTL::TensorReferenceType::dimensions() const
|
||||
{
|
||||
return Object::sendMessage<MTL::TensorExtents*>(this, _MTL_PRIVATE_SEL(dimensions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::TensorReferenceType::indexType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(indexType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorReferenceType* MTL::TensorReferenceType::init()
|
||||
{
|
||||
return NS::Object::init<MTL::TensorReferenceType>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorDataType MTL::TensorReferenceType::tensorDataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::TensorDataType>(this, _MTL_PRIVATE_SEL(tensorDataType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BindingAccess MTL::Argument::access() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Argument::active() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Argument* MTL::Argument::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::Argument>(_MTL_PRIVATE_CLS(MTLArgument));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Argument::arrayLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Argument::bufferAlignment() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferAlignment));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Argument::bufferDataSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferDataSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::Argument::bufferDataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(bufferDataType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PointerType* MTL::Argument::bufferPointerType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::PointerType*>(this, _MTL_PRIVATE_SEL(bufferPointerType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructType* MTL::Argument::bufferStructType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(bufferStructType));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Argument::index() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(index));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Argument* MTL::Argument::init()
|
||||
{
|
||||
return NS::Object::init<MTL::Argument>();
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Argument::isActive() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Argument::isDepthTexture() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthTexture));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Argument::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::Argument::textureDataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(textureDataType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TextureType MTL::Argument::textureType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Argument::threadgroupMemoryAlignment() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryAlignment));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Argument::threadgroupMemoryDataSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryDataSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArgumentType MTL::Argument::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ArgumentType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BindingAccess MTL::Binding::access() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Binding::argument() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isArgument));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Binding::index() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(index));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Binding::isArgument() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isArgument));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Binding::isUsed() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isUsed));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Binding::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BindingType MTL::Binding::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BindingType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Binding::used() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isUsed));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::BufferBinding::bufferAlignment() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferAlignment));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::BufferBinding::bufferDataSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferDataSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::BufferBinding::bufferDataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(bufferDataType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PointerType* MTL::BufferBinding::bufferPointerType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::PointerType*>(this, _MTL_PRIVATE_SEL(bufferPointerType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StructType* MTL::BufferBinding::bufferStructType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(bufferStructType));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ThreadgroupBinding::threadgroupMemoryAlignment() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryAlignment));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ThreadgroupBinding::threadgroupMemoryDataSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryDataSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::TextureBinding::arrayLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::TextureBinding::depthTexture() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthTexture));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::TextureBinding::isDepthTexture() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthTexture));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::TextureBinding::textureDataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(textureDataType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TextureType MTL::TextureBinding::textureType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ObjectPayloadBinding::objectPayloadAlignment() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(objectPayloadAlignment));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ObjectPayloadBinding::objectPayloadDataSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(objectPayloadDataSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorExtents* MTL::TensorBinding::dimensions() const
|
||||
{
|
||||
return Object::sendMessage<MTL::TensorExtents*>(this, _MTL_PRIVATE_SEL(dimensions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::TensorBinding::indexType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(indexType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::TensorDataType MTL::TensorBinding::tensorDataType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::TensorDataType>(this, _MTL_PRIVATE_SEL(tensorDataType));
|
||||
}
|
||||
235
dist/include/metal_cpp/Metal/MTLArgumentEncoder.hpp
vendored
Normal file
235
dist/include/metal_cpp/Metal/MTLArgumentEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,235 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLArgumentEncoder.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLDepthStencil.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class AccelerationStructure;
|
||||
class ArgumentEncoder;
|
||||
class Buffer;
|
||||
class ComputePipelineState;
|
||||
class Device;
|
||||
class IndirectCommandBuffer;
|
||||
class IntersectionFunctionTable;
|
||||
class RenderPipelineState;
|
||||
class SamplerState;
|
||||
class Texture;
|
||||
class VisibleFunctionTable;
|
||||
|
||||
static const NS::UInteger AttributeStrideStatic = NS::UIntegerMax;
|
||||
|
||||
class ArgumentEncoder : public NS::Referencing<ArgumentEncoder>
|
||||
{
|
||||
public:
|
||||
NS::UInteger alignment() const;
|
||||
|
||||
void* constantData(NS::UInteger index);
|
||||
|
||||
Device* device() const;
|
||||
|
||||
NS::UInteger encodedLength() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
ArgumentEncoder* newArgumentEncoder(NS::UInteger index);
|
||||
|
||||
void setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger index);
|
||||
|
||||
void setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger offset);
|
||||
void setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger startOffset, NS::UInteger arrayElement);
|
||||
|
||||
void setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index);
|
||||
void setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
|
||||
|
||||
void setComputePipelineState(const MTL::ComputePipelineState* pipeline, NS::UInteger index);
|
||||
void setComputePipelineStates(const MTL::ComputePipelineState* const pipelines[], NS::Range range);
|
||||
|
||||
void setDepthStencilState(const MTL::DepthStencilState* depthStencilState, NS::UInteger index);
|
||||
void setDepthStencilStates(const MTL::DepthStencilState* const depthStencilStates[], NS::Range range);
|
||||
|
||||
void setIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::UInteger index);
|
||||
void setIndirectCommandBuffers(const MTL::IndirectCommandBuffer* const buffers[], NS::Range range);
|
||||
|
||||
void setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger index);
|
||||
void setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void setRenderPipelineState(const MTL::RenderPipelineState* pipeline, NS::UInteger index);
|
||||
void setRenderPipelineStates(const MTL::RenderPipelineState* const pipelines[], NS::Range range);
|
||||
|
||||
void setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index);
|
||||
void setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range);
|
||||
|
||||
void setTexture(const MTL::Texture* texture, NS::UInteger index);
|
||||
void setTextures(const MTL::Texture* const textures[], NS::Range range);
|
||||
|
||||
void setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger index);
|
||||
void setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ArgumentEncoder::alignment() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(alignment));
|
||||
}
|
||||
|
||||
_MTL_INLINE void* MTL::ArgumentEncoder::constantData(NS::UInteger index)
|
||||
{
|
||||
return Object::sendMessage<void*>(this, _MTL_PRIVATE_SEL(constantDataAtIndex_), index);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::ArgumentEncoder::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ArgumentEncoder::encodedLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(encodedLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::ArgumentEncoder::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArgumentEncoder* MTL::ArgumentEncoder::newArgumentEncoder(NS::UInteger index)
|
||||
{
|
||||
return Object::sendMessage<MTL::ArgumentEncoder*>(this, _MTL_PRIVATE_SEL(newArgumentEncoderForBufferAtIndex_), index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAccelerationStructure_atIndex_), accelerationStructure, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger offset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentBuffer_offset_), argumentBuffer, offset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger startOffset, NS::UInteger arrayElement)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentBuffer_startOffset_arrayElement_), argumentBuffer, startOffset, arrayElement);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setComputePipelineState(const MTL::ComputePipelineState* pipeline, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineState_atIndex_), pipeline, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setComputePipelineStates(const MTL::ComputePipelineState* const pipelines[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineStates_withRange_), pipelines, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setDepthStencilState(const MTL::DepthStencilState* depthStencilState, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilState_atIndex_), depthStencilState, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setDepthStencilStates(const MTL::DepthStencilState* const depthStencilStates[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilStates_withRange_), depthStencilStates, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndirectCommandBuffer_atIndex_), indirectCommandBuffer, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setIndirectCommandBuffers(const MTL::IndirectCommandBuffer* const buffers[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndirectCommandBuffers_withRange_), buffers, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTable_atIndex_), intersectionFunctionTable, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTables_withRange_), intersectionFunctionTables, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setRenderPipelineState(const MTL::RenderPipelineState* pipeline, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineState_atIndex_), pipeline, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setRenderPipelineStates(const MTL::RenderPipelineState* const pipelines[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineStates_withRange_), pipelines, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerState_atIndex_), sampler, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerStates_withRange_), samplers, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setTexture(const MTL::Texture* texture, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTexture_atIndex_), texture, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setTextures(const MTL::Texture* const textures[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTextures_withRange_), textures, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atIndex_), visibleFunctionTable, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ArgumentEncoder::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withRange_), visibleFunctionTables, range);
|
||||
}
|
||||
152
dist/include/metal_cpp/Metal/MTLBinaryArchive.hpp
vendored
Normal file
152
dist/include/metal_cpp/Metal/MTLBinaryArchive.hpp
vendored
Normal file
|
|
@ -0,0 +1,152 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLBinaryArchive.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class BinaryArchiveDescriptor;
|
||||
class ComputePipelineDescriptor;
|
||||
class Device;
|
||||
class FunctionDescriptor;
|
||||
class Library;
|
||||
class MeshRenderPipelineDescriptor;
|
||||
class RenderPipelineDescriptor;
|
||||
class StitchedLibraryDescriptor;
|
||||
class TileRenderPipelineDescriptor;
|
||||
_MTL_ENUM(NS::UInteger, BinaryArchiveError) {
|
||||
BinaryArchiveErrorNone = 0,
|
||||
BinaryArchiveErrorInvalidFile = 1,
|
||||
BinaryArchiveErrorUnexpectedElement = 2,
|
||||
BinaryArchiveErrorCompilationFailure = 3,
|
||||
BinaryArchiveErrorInternalError = 4,
|
||||
};
|
||||
|
||||
_MTL_CONST(NS::ErrorDomain, BinaryArchiveDomain);
|
||||
class BinaryArchiveDescriptor : public NS::Copying<BinaryArchiveDescriptor>
|
||||
{
|
||||
public:
|
||||
static BinaryArchiveDescriptor* alloc();
|
||||
|
||||
BinaryArchiveDescriptor* init();
|
||||
|
||||
void setUrl(const NS::URL* url);
|
||||
NS::URL* url() const;
|
||||
};
|
||||
class BinaryArchive : public NS::Referencing<BinaryArchive>
|
||||
{
|
||||
public:
|
||||
bool addComputePipelineFunctions(const MTL::ComputePipelineDescriptor* descriptor, NS::Error** error);
|
||||
|
||||
bool addFunction(const MTL::FunctionDescriptor* descriptor, const MTL::Library* library, NS::Error** error);
|
||||
|
||||
bool addLibrary(const MTL::StitchedLibraryDescriptor* descriptor, NS::Error** error);
|
||||
|
||||
bool addMeshRenderPipelineFunctions(const MTL::MeshRenderPipelineDescriptor* descriptor, NS::Error** error);
|
||||
|
||||
bool addRenderPipelineFunctions(const MTL::RenderPipelineDescriptor* descriptor, NS::Error** error);
|
||||
|
||||
bool addTileRenderPipelineFunctions(const MTL::TileRenderPipelineDescriptor* descriptor, NS::Error** error);
|
||||
|
||||
Device* device() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
bool serializeToURL(const NS::URL* url, NS::Error** error);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, BinaryArchiveDomain);
|
||||
_MTL_INLINE MTL::BinaryArchiveDescriptor* MTL::BinaryArchiveDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::BinaryArchiveDescriptor>(_MTL_PRIVATE_CLS(MTLBinaryArchiveDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BinaryArchiveDescriptor* MTL::BinaryArchiveDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::BinaryArchiveDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BinaryArchiveDescriptor::setUrl(const NS::URL* url)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setUrl_), url);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::URL* MTL::BinaryArchiveDescriptor::url() const
|
||||
{
|
||||
return Object::sendMessage<NS::URL*>(this, _MTL_PRIVATE_SEL(url));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::BinaryArchive::addComputePipelineFunctions(const MTL::ComputePipelineDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addComputePipelineFunctionsWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::BinaryArchive::addFunction(const MTL::FunctionDescriptor* descriptor, const MTL::Library* library, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addFunctionWithDescriptor_library_error_), descriptor, library, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::BinaryArchive::addLibrary(const MTL::StitchedLibraryDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addLibraryWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::BinaryArchive::addMeshRenderPipelineFunctions(const MTL::MeshRenderPipelineDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addMeshRenderPipelineFunctionsWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::BinaryArchive::addRenderPipelineFunctions(const MTL::RenderPipelineDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addRenderPipelineFunctionsWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::BinaryArchive::addTileRenderPipelineFunctions(const MTL::TileRenderPipelineDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addTileRenderPipelineFunctionsWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::BinaryArchive::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::BinaryArchive::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::BinaryArchive::serializeToURL(const NS::URL* url, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(serializeToURL_error_), url, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BinaryArchive::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
226
dist/include/metal_cpp/Metal/MTLBlitCommandEncoder.hpp
vendored
Normal file
226
dist/include/metal_cpp/Metal/MTLBlitCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLBlitCommandEncoder.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 "MTLCommandEncoder.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Buffer;
|
||||
class CounterSampleBuffer;
|
||||
class Fence;
|
||||
class IndirectCommandBuffer;
|
||||
class Resource;
|
||||
class Tensor;
|
||||
class TensorExtents;
|
||||
class Texture;
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, BlitOption) {
|
||||
BlitOptionNone = 0,
|
||||
BlitOptionDepthFromDepthStencil = 1,
|
||||
BlitOptionStencilFromDepthStencil = 1 << 1,
|
||||
BlitOptionRowLinearPVRTC = 1 << 2,
|
||||
};
|
||||
|
||||
class BlitCommandEncoder : public NS::Referencing<BlitCommandEncoder, CommandEncoder>
|
||||
{
|
||||
public:
|
||||
void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin);
|
||||
void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options);
|
||||
void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size);
|
||||
|
||||
void copyFromTensor(const MTL::Tensor* sourceTensor, const MTL::TensorExtents* sourceOrigin, const MTL::TensorExtents* sourceDimensions, const MTL::Tensor* destinationTensor, const MTL::TensorExtents* destinationOrigin, const MTL::TensorExtents* destinationDimensions);
|
||||
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin);
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage);
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options);
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount);
|
||||
void copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture);
|
||||
|
||||
void copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex);
|
||||
|
||||
void fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value);
|
||||
|
||||
void generateMipmaps(const MTL::Texture* texture);
|
||||
|
||||
void getTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice, bool resetCounters, const MTL::Buffer* countersBuffer, NS::UInteger countersBufferOffset);
|
||||
|
||||
void optimizeContentsForCPUAccess(const MTL::Texture* texture);
|
||||
void optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level);
|
||||
|
||||
void optimizeContentsForGPUAccess(const MTL::Texture* texture);
|
||||
void optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level);
|
||||
|
||||
void optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range);
|
||||
|
||||
void resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range);
|
||||
|
||||
void resetTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice);
|
||||
|
||||
void resolveCounters(const MTL::CounterSampleBuffer* sampleBuffer, NS::Range range, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset);
|
||||
|
||||
void sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier);
|
||||
|
||||
void synchronizeResource(const MTL::Resource* resource);
|
||||
|
||||
void synchronizeTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level);
|
||||
|
||||
void updateFence(const MTL::Fence* fence);
|
||||
|
||||
void waitForFence(const MTL::Fence* fence);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_), sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTensor(const MTL::Tensor* sourceTensor, const MTL::TensorExtents* sourceOrigin, const MTL::TensorExtents* sourceDimensions, const MTL::Tensor* destinationTensor, const MTL::TensorExtents* destinationOrigin, const MTL::TensorExtents* destinationDimensions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTensor_sourceOrigin_sourceDimensions_toTensor_destinationOrigin_destinationDimensions_), sourceTensor, sourceOrigin, sourceDimensions, destinationTensor, destinationOrigin, destinationDimensions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_), sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_toTexture_), sourceTexture, destinationTexture);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyIndirectCommandBuffer_sourceRange_destination_destinationIndex_), source, sourceRange, destination, destinationIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(fillBuffer_range_value_), buffer, range, value);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::generateMipmaps(const MTL::Texture* texture)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(generateMipmapsForTexture_), texture);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::getTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice, bool resetCounters, const MTL::Buffer* countersBuffer, NS::UInteger countersBufferOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(getTextureAccessCounters_region_mipLevel_slice_resetCounters_countersBuffer_countersBufferOffset_), texture, region, mipLevel, slice, resetCounters, countersBuffer, countersBufferOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_), texture);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_slice_level_), texture, slice, level);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_), texture);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_slice_level_), texture, slice, level);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeIndirectCommandBuffer_withRange_), indirectCommandBuffer, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resetCommandsInBuffer_withRange_), buffer, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::resetTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resetTextureAccessCounters_region_mipLevel_slice_), texture, region, mipLevel, slice);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::resolveCounters(const MTL::CounterSampleBuffer* sampleBuffer, NS::Range range, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resolveCounters_inRange_destinationBuffer_destinationOffset_), sampleBuffer, range, destinationBuffer, destinationOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::synchronizeResource(const MTL::Resource* resource)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(synchronizeResource_), resource);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::synchronizeTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(synchronizeTexture_slice_level_), texture, slice, level);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::updateFence(const MTL::Fence* fence)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_), fence);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitCommandEncoder::waitForFence(const MTL::Fence* fence)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_), fence);
|
||||
}
|
||||
154
dist/include/metal_cpp/Metal/MTLBlitPass.hpp
vendored
Normal file
154
dist/include/metal_cpp/Metal/MTLBlitPass.hpp
vendored
Normal file
|
|
@ -0,0 +1,154 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLBlitPass.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class BlitPassDescriptor;
|
||||
class BlitPassSampleBufferAttachmentDescriptor;
|
||||
class BlitPassSampleBufferAttachmentDescriptorArray;
|
||||
class CounterSampleBuffer;
|
||||
|
||||
class BlitPassSampleBufferAttachmentDescriptor : public NS::Copying<BlitPassSampleBufferAttachmentDescriptor>
|
||||
{
|
||||
public:
|
||||
static BlitPassSampleBufferAttachmentDescriptor* alloc();
|
||||
|
||||
NS::UInteger endOfEncoderSampleIndex() const;
|
||||
|
||||
BlitPassSampleBufferAttachmentDescriptor* init();
|
||||
|
||||
CounterSampleBuffer* sampleBuffer() const;
|
||||
|
||||
void setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex);
|
||||
|
||||
void setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer);
|
||||
|
||||
void setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex);
|
||||
NS::UInteger startOfEncoderSampleIndex() const;
|
||||
};
|
||||
class BlitPassSampleBufferAttachmentDescriptorArray : public NS::Referencing<BlitPassSampleBufferAttachmentDescriptorArray>
|
||||
{
|
||||
public:
|
||||
static BlitPassSampleBufferAttachmentDescriptorArray* alloc();
|
||||
|
||||
BlitPassSampleBufferAttachmentDescriptorArray* init();
|
||||
|
||||
BlitPassSampleBufferAttachmentDescriptor* object(NS::UInteger attachmentIndex);
|
||||
void setObject(const MTL::BlitPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
|
||||
};
|
||||
class BlitPassDescriptor : public NS::Copying<BlitPassDescriptor>
|
||||
{
|
||||
public:
|
||||
static BlitPassDescriptor* alloc();
|
||||
|
||||
static BlitPassDescriptor* blitPassDescriptor();
|
||||
|
||||
BlitPassDescriptor* init();
|
||||
|
||||
BlitPassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::BlitPassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLBlitPassSampleBufferAttachmentDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::BlitPassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::BlitPassSampleBufferAttachmentDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CounterSampleBuffer* MTL::BlitPassSampleBufferAttachmentDescriptor::sampleBuffer() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::BlitPassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassSampleBufferAttachmentDescriptorArray::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::BlitPassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLBlitPassSampleBufferAttachmentDescriptorArray));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassSampleBufferAttachmentDescriptorArray::init()
|
||||
{
|
||||
return NS::Object::init<MTL::BlitPassSampleBufferAttachmentDescriptorArray>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
|
||||
{
|
||||
return Object::sendMessage<MTL::BlitPassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptorArray::setObject(const MTL::BlitPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::BlitPassDescriptor>(_MTL_PRIVATE_CLS(MTLBlitPassDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::blitPassDescriptor()
|
||||
{
|
||||
return Object::sendMessage<MTL::BlitPassDescriptor*>(_MTL_PRIVATE_CLS(MTLBlitPassDescriptor), _MTL_PRIVATE_SEL(blitPassDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::BlitPassDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassDescriptor::sampleBufferAttachments() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BlitPassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
|
||||
}
|
||||
119
dist/include/metal_cpp/Metal/MTLBuffer.hpp
vendored
Normal file
119
dist/include/metal_cpp/Metal/MTLBuffer.hpp
vendored
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLBuffer.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 "MTLDefines.hpp"
|
||||
#include "MTLGPUAddress.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLResource.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Buffer;
|
||||
class Device;
|
||||
class Tensor;
|
||||
class TensorDescriptor;
|
||||
class Texture;
|
||||
class TextureDescriptor;
|
||||
|
||||
class Buffer : public NS::Referencing<Buffer, Resource>
|
||||
{
|
||||
public:
|
||||
void addDebugMarker(const NS::String* marker, NS::Range range);
|
||||
|
||||
void* contents();
|
||||
|
||||
void didModifyRange(NS::Range range);
|
||||
|
||||
GPUAddress gpuAddress() const;
|
||||
|
||||
NS::UInteger length() const;
|
||||
|
||||
Buffer* newRemoteBufferViewForDevice(const MTL::Device* device);
|
||||
|
||||
Tensor* newTensor(const MTL::TensorDescriptor* descriptor, NS::UInteger offset, NS::Error** error);
|
||||
|
||||
Texture* newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset, NS::UInteger bytesPerRow);
|
||||
|
||||
Buffer* remoteStorageBuffer() const;
|
||||
|
||||
void removeAllDebugMarkers();
|
||||
|
||||
BufferSparseTier sparseBufferTier() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL::Buffer::addDebugMarker(const NS::String* marker, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addDebugMarker_range_), marker, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void* MTL::Buffer::contents()
|
||||
{
|
||||
return Object::sendMessage<void*>(this, _MTL_PRIVATE_SEL(contents));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Buffer::didModifyRange(NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(didModifyRange_), range);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::GPUAddress MTL::Buffer::gpuAddress() const
|
||||
{
|
||||
return Object::sendMessage<MTL::GPUAddress>(this, _MTL_PRIVATE_SEL(gpuAddress));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Buffer::length() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(length));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Buffer* MTL::Buffer::newRemoteBufferViewForDevice(const MTL::Device* device)
|
||||
{
|
||||
return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newRemoteBufferViewForDevice_), device);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Tensor* MTL::Buffer::newTensor(const MTL::TensorDescriptor* descriptor, NS::UInteger offset, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::Tensor*>(this, _MTL_PRIVATE_SEL(newTensorWithDescriptor_offset_error_), descriptor, offset, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Texture* MTL::Buffer::newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset, NS::UInteger bytesPerRow)
|
||||
{
|
||||
return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_offset_bytesPerRow_), descriptor, offset, bytesPerRow);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Buffer* MTL::Buffer::remoteStorageBuffer() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(remoteStorageBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Buffer::removeAllDebugMarkers()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(removeAllDebugMarkers));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BufferSparseTier MTL::Buffer::sparseBufferTier() const
|
||||
{
|
||||
return Object::sendMessage<MTL::BufferSparseTier>(this, _MTL_PRIVATE_SEL(sparseBufferTier));
|
||||
}
|
||||
217
dist/include/metal_cpp/Metal/MTLCaptureManager.hpp
vendored
Normal file
217
dist/include/metal_cpp/Metal/MTLCaptureManager.hpp
vendored
Normal file
|
|
@ -0,0 +1,217 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLCaptureManager.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class CaptureDescriptor;
|
||||
class CaptureManager;
|
||||
class CaptureScope;
|
||||
class CommandQueue;
|
||||
class Device;
|
||||
}
|
||||
|
||||
namespace MTL4
|
||||
{
|
||||
class CommandQueue;
|
||||
}
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
_MTL_ENUM(NS::Integer, CaptureError) {
|
||||
CaptureErrorNotSupported = 1,
|
||||
CaptureErrorAlreadyCapturing = 2,
|
||||
CaptureErrorInvalidDescriptor = 3,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, CaptureDestination) {
|
||||
CaptureDestinationDeveloperTools = 1,
|
||||
CaptureDestinationGPUTraceDocument = 2,
|
||||
};
|
||||
|
||||
class CaptureDescriptor : public NS::Copying<CaptureDescriptor>
|
||||
{
|
||||
public:
|
||||
static CaptureDescriptor* alloc();
|
||||
|
||||
NS::Object* captureObject() const;
|
||||
|
||||
CaptureDestination destination() const;
|
||||
|
||||
CaptureDescriptor* init();
|
||||
|
||||
NS::URL* outputURL() const;
|
||||
|
||||
void setCaptureObject(NS::Object* captureObject);
|
||||
|
||||
void setDestination(MTL::CaptureDestination destination);
|
||||
|
||||
void setOutputURL(const NS::URL* outputURL);
|
||||
};
|
||||
class CaptureManager : public NS::Referencing<CaptureManager>
|
||||
{
|
||||
public:
|
||||
static CaptureManager* alloc();
|
||||
|
||||
CaptureScope* defaultCaptureScope() const;
|
||||
|
||||
CaptureManager* init();
|
||||
|
||||
bool isCapturing() const;
|
||||
|
||||
CaptureScope* newCaptureScope(const MTL::Device* device);
|
||||
CaptureScope* newCaptureScope(const MTL::CommandQueue* commandQueue);
|
||||
CaptureScope* newCaptureScope(const MTL4::CommandQueue* commandQueue);
|
||||
|
||||
void setDefaultCaptureScope(const MTL::CaptureScope* defaultCaptureScope);
|
||||
|
||||
static CaptureManager* sharedCaptureManager();
|
||||
|
||||
bool startCapture(const MTL::CaptureDescriptor* descriptor, NS::Error** error);
|
||||
void startCapture(const MTL::Device* device);
|
||||
void startCapture(const MTL::CommandQueue* commandQueue);
|
||||
void startCapture(const MTL::CaptureScope* captureScope);
|
||||
|
||||
void stopCapture();
|
||||
|
||||
bool supportsDestination(MTL::CaptureDestination destination);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::CaptureDescriptor* MTL::CaptureDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::CaptureDescriptor>(_MTL_PRIVATE_CLS(MTLCaptureDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Object* MTL::CaptureDescriptor::captureObject() const
|
||||
{
|
||||
return Object::sendMessage<NS::Object*>(this, _MTL_PRIVATE_SEL(captureObject));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureDestination MTL::CaptureDescriptor::destination() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CaptureDestination>(this, _MTL_PRIVATE_SEL(destination));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureDescriptor* MTL::CaptureDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::CaptureDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::URL* MTL::CaptureDescriptor::outputURL() const
|
||||
{
|
||||
return Object::sendMessage<NS::URL*>(this, _MTL_PRIVATE_SEL(outputURL));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CaptureDescriptor::setCaptureObject(NS::Object* captureObject)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCaptureObject_), captureObject);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CaptureDescriptor::setDestination(MTL::CaptureDestination destination)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDestination_), destination);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CaptureDescriptor::setOutputURL(const NS::URL* outputURL)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOutputURL_), outputURL);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::CaptureManager>(_MTL_PRIVATE_CLS(MTLCaptureManager));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::defaultCaptureScope() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CaptureScope*>(this, _MTL_PRIVATE_SEL(defaultCaptureScope));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::init()
|
||||
{
|
||||
return NS::Object::init<MTL::CaptureManager>();
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CaptureManager::isCapturing() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isCapturing));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::newCaptureScope(const MTL::Device* device)
|
||||
{
|
||||
return Object::sendMessage<MTL::CaptureScope*>(this, _MTL_PRIVATE_SEL(newCaptureScopeWithDevice_), device);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::newCaptureScope(const MTL::CommandQueue* commandQueue)
|
||||
{
|
||||
return Object::sendMessage<MTL::CaptureScope*>(this, _MTL_PRIVATE_SEL(newCaptureScopeWithCommandQueue_), commandQueue);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::newCaptureScope(const MTL4::CommandQueue* commandQueue)
|
||||
{
|
||||
return Object::sendMessage<MTL::CaptureScope*>(this, _MTL_PRIVATE_SEL(newCaptureScopeWithMTL4CommandQueue_), commandQueue);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CaptureManager::setDefaultCaptureScope(const MTL::CaptureScope* defaultCaptureScope)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDefaultCaptureScope_), defaultCaptureScope);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::sharedCaptureManager()
|
||||
{
|
||||
return Object::sendMessage<MTL::CaptureManager*>(_MTL_PRIVATE_CLS(MTLCaptureManager), _MTL_PRIVATE_SEL(sharedCaptureManager));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CaptureManager::startCapture(const MTL::CaptureDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(startCaptureWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::Device* device)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(startCaptureWithDevice_), device);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::CommandQueue* commandQueue)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(startCaptureWithCommandQueue_), commandQueue);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::CaptureScope* captureScope)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(startCaptureWithScope_), captureScope);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CaptureManager::stopCapture()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(stopCapture));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CaptureManager::supportsDestination(MTL::CaptureDestination destination)
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsDestination_), destination);
|
||||
}
|
||||
91
dist/include/metal_cpp/Metal/MTLCaptureScope.hpp
vendored
Normal file
91
dist/include/metal_cpp/Metal/MTLCaptureScope.hpp
vendored
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLCaptureScope.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "MTLDefines.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
#include "../Foundation/Foundation.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class CaptureScope : public NS::Referencing<CaptureScope>
|
||||
{
|
||||
public:
|
||||
class Device* device() const;
|
||||
|
||||
NS::String* label() const;
|
||||
void setLabel(const NS::String* pLabel);
|
||||
|
||||
class CommandQueue* commandQueue() const;
|
||||
|
||||
void beginScope();
|
||||
void endScope();
|
||||
};
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::CaptureScope::device() const
|
||||
{
|
||||
return Object::sendMessage<Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CaptureScope::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE void MTL::CaptureScope::setLabel(const NS::String* pLabel)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), pLabel);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE MTL::CommandQueue* MTL::CaptureScope::commandQueue() const
|
||||
{
|
||||
return Object::sendMessage<CommandQueue*>(this, _MTL_PRIVATE_SEL(commandQueue));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE void MTL::CaptureScope::beginScope()
|
||||
{
|
||||
return Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(beginScope));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
_MTL_INLINE void MTL::CaptureScope::endScope()
|
||||
{
|
||||
return Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(endScope));
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
464
dist/include/metal_cpp/Metal/MTLCommandBuffer.hpp
vendored
Normal file
464
dist/include/metal_cpp/Metal/MTLCommandBuffer.hpp
vendored
Normal file
|
|
@ -0,0 +1,464 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLCommandBuffer.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include <CoreFoundation/CoreFoundation.h>
|
||||
#include <cstdint>
|
||||
|
||||
#include <functional>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class AccelerationStructureCommandEncoder;
|
||||
class AccelerationStructurePassDescriptor;
|
||||
class BlitCommandEncoder;
|
||||
class BlitPassDescriptor;
|
||||
class CommandBuffer;
|
||||
class CommandBufferDescriptor;
|
||||
class CommandQueue;
|
||||
class ComputeCommandEncoder;
|
||||
class ComputePassDescriptor;
|
||||
class Device;
|
||||
class Drawable;
|
||||
class Event;
|
||||
class LogContainer;
|
||||
class LogState;
|
||||
class ParallelRenderCommandEncoder;
|
||||
class RenderCommandEncoder;
|
||||
class RenderPassDescriptor;
|
||||
class ResidencySet;
|
||||
class ResourceStateCommandEncoder;
|
||||
class ResourceStatePassDescriptor;
|
||||
_MTL_ENUM(NS::UInteger, CommandBufferStatus) {
|
||||
CommandBufferStatusNotEnqueued = 0,
|
||||
CommandBufferStatusEnqueued = 1,
|
||||
CommandBufferStatusCommitted = 2,
|
||||
CommandBufferStatusScheduled = 3,
|
||||
CommandBufferStatusCompleted = 4,
|
||||
CommandBufferStatusError = 5,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, CommandBufferError) {
|
||||
CommandBufferErrorNone = 0,
|
||||
CommandBufferErrorInternal = 1,
|
||||
CommandBufferErrorTimeout = 2,
|
||||
CommandBufferErrorPageFault = 3,
|
||||
CommandBufferErrorBlacklisted = 4,
|
||||
CommandBufferErrorAccessRevoked = 4,
|
||||
CommandBufferErrorNotPermitted = 7,
|
||||
CommandBufferErrorOutOfMemory = 8,
|
||||
CommandBufferErrorInvalidResource = 9,
|
||||
CommandBufferErrorMemoryless = 10,
|
||||
CommandBufferErrorDeviceRemoved = 11,
|
||||
CommandBufferErrorStackOverflow = 12,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, CommandEncoderErrorState) {
|
||||
CommandEncoderErrorStateUnknown = 0,
|
||||
CommandEncoderErrorStateCompleted = 1,
|
||||
CommandEncoderErrorStateAffected = 2,
|
||||
CommandEncoderErrorStatePending = 3,
|
||||
CommandEncoderErrorStateFaulted = 4,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, DispatchType) {
|
||||
DispatchTypeSerial = 0,
|
||||
DispatchTypeConcurrent = 1,
|
||||
};
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, CommandBufferErrorOption) {
|
||||
CommandBufferErrorOptionNone = 0,
|
||||
CommandBufferErrorOptionEncoderExecutionStatus = 1,
|
||||
};
|
||||
|
||||
using CommandBufferHandler = void (^)(CommandBuffer*);
|
||||
using HandlerFunction = std::function<void(CommandBuffer*)>;
|
||||
|
||||
class CommandBufferDescriptor : public NS::Copying<CommandBufferDescriptor>
|
||||
{
|
||||
public:
|
||||
static CommandBufferDescriptor* alloc();
|
||||
|
||||
CommandBufferErrorOption errorOptions() const;
|
||||
|
||||
CommandBufferDescriptor* init();
|
||||
|
||||
LogState* logState() const;
|
||||
|
||||
bool retainedReferences() const;
|
||||
|
||||
void setErrorOptions(MTL::CommandBufferErrorOption errorOptions);
|
||||
|
||||
void setLogState(const MTL::LogState* logState);
|
||||
|
||||
void setRetainedReferences(bool retainedReferences);
|
||||
};
|
||||
class CommandBufferEncoderInfo : public NS::Referencing<CommandBufferEncoderInfo>
|
||||
{
|
||||
public:
|
||||
NS::Array* debugSignposts() const;
|
||||
|
||||
CommandEncoderErrorState errorState() const;
|
||||
|
||||
NS::String* label() const;
|
||||
};
|
||||
class CommandBuffer : public NS::Referencing<CommandBuffer>
|
||||
{
|
||||
public:
|
||||
CFTimeInterval GPUEndTime() const;
|
||||
|
||||
CFTimeInterval GPUStartTime() const;
|
||||
|
||||
AccelerationStructureCommandEncoder* accelerationStructureCommandEncoder();
|
||||
AccelerationStructureCommandEncoder* accelerationStructureCommandEncoder(const MTL::AccelerationStructurePassDescriptor* descriptor);
|
||||
|
||||
void addCompletedHandler(const MTL::CommandBufferHandler block);
|
||||
void addCompletedHandler(const MTL::HandlerFunction& function);
|
||||
|
||||
void addScheduledHandler(const MTL::CommandBufferHandler block);
|
||||
void addScheduledHandler(const MTL::HandlerFunction& function);
|
||||
|
||||
BlitCommandEncoder* blitCommandEncoder();
|
||||
BlitCommandEncoder* blitCommandEncoder(const MTL::BlitPassDescriptor* blitPassDescriptor);
|
||||
|
||||
CommandQueue* commandQueue() const;
|
||||
|
||||
void commit();
|
||||
|
||||
ComputeCommandEncoder* computeCommandEncoder(const MTL::ComputePassDescriptor* computePassDescriptor);
|
||||
ComputeCommandEncoder* computeCommandEncoder();
|
||||
ComputeCommandEncoder* computeCommandEncoder(MTL::DispatchType dispatchType);
|
||||
|
||||
Device* device() const;
|
||||
|
||||
void encodeSignalEvent(const MTL::Event* event, uint64_t value);
|
||||
|
||||
void encodeWait(const MTL::Event* event, uint64_t value);
|
||||
|
||||
void enqueue();
|
||||
|
||||
NS::Error* error() const;
|
||||
CommandBufferErrorOption errorOptions() const;
|
||||
|
||||
CFTimeInterval kernelEndTime() const;
|
||||
|
||||
CFTimeInterval kernelStartTime() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
LogContainer* logs() const;
|
||||
|
||||
ParallelRenderCommandEncoder* parallelRenderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor);
|
||||
|
||||
void popDebugGroup();
|
||||
|
||||
void presentDrawable(const MTL::Drawable* drawable);
|
||||
void presentDrawableAfterMinimumDuration(const MTL::Drawable* drawable, CFTimeInterval duration);
|
||||
|
||||
void presentDrawableAtTime(const MTL::Drawable* drawable, CFTimeInterval presentationTime);
|
||||
|
||||
void pushDebugGroup(const NS::String* string);
|
||||
|
||||
RenderCommandEncoder* renderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor);
|
||||
|
||||
ResourceStateCommandEncoder* resourceStateCommandEncoder();
|
||||
ResourceStateCommandEncoder* resourceStateCommandEncoder(const MTL::ResourceStatePassDescriptor* resourceStatePassDescriptor);
|
||||
|
||||
bool retainedReferences() const;
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
CommandBufferStatus status() const;
|
||||
|
||||
void useResidencySet(const MTL::ResidencySet* residencySet);
|
||||
void useResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count);
|
||||
|
||||
void waitUntilCompleted();
|
||||
|
||||
void waitUntilScheduled();
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::CommandBufferDescriptor* MTL::CommandBufferDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::CommandBufferDescriptor>(_MTL_PRIVATE_CLS(MTLCommandBufferDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandBufferErrorOption MTL::CommandBufferDescriptor::errorOptions() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CommandBufferErrorOption>(this, _MTL_PRIVATE_SEL(errorOptions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandBufferDescriptor* MTL::CommandBufferDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::CommandBufferDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LogState* MTL::CommandBufferDescriptor::logState() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LogState*>(this, _MTL_PRIVATE_SEL(logState));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CommandBufferDescriptor::retainedReferences() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(retainedReferences));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBufferDescriptor::setErrorOptions(MTL::CommandBufferErrorOption errorOptions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setErrorOptions_), errorOptions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBufferDescriptor::setLogState(const MTL::LogState* logState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLogState_), logState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBufferDescriptor::setRetainedReferences(bool retainedReferences)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRetainedReferences_), retainedReferences);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::CommandBufferEncoderInfo::debugSignposts() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(debugSignposts));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandEncoderErrorState MTL::CommandBufferEncoderInfo::errorState() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CommandEncoderErrorState>(this, _MTL_PRIVATE_SEL(errorState));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CommandBufferEncoderInfo::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE CFTimeInterval MTL::CommandBuffer::GPUEndTime() const
|
||||
{
|
||||
return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(GPUEndTime));
|
||||
}
|
||||
|
||||
_MTL_INLINE CFTimeInterval MTL::CommandBuffer::GPUStartTime() const
|
||||
{
|
||||
return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(GPUStartTime));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructureCommandEncoder* MTL::CommandBuffer::accelerationStructureCommandEncoder()
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructureCommandEncoder*>(this, _MTL_PRIVATE_SEL(accelerationStructureCommandEncoder));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructureCommandEncoder* MTL::CommandBuffer::accelerationStructureCommandEncoder(const MTL::AccelerationStructurePassDescriptor* descriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructureCommandEncoder*>(this, _MTL_PRIVATE_SEL(accelerationStructureCommandEncoderWithDescriptor_), descriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::addCompletedHandler(const MTL::CommandBufferHandler block)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addCompletedHandler_), block);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::addCompletedHandler(const MTL::HandlerFunction& function)
|
||||
{
|
||||
__block HandlerFunction blockFunction = function;
|
||||
addCompletedHandler(^(MTL::CommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); });
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::addScheduledHandler(const MTL::CommandBufferHandler block)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addScheduledHandler_), block);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::addScheduledHandler(const MTL::HandlerFunction& function)
|
||||
{
|
||||
__block HandlerFunction blockFunction = function;
|
||||
addScheduledHandler(^(MTL::CommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitCommandEncoder* MTL::CommandBuffer::blitCommandEncoder()
|
||||
{
|
||||
return Object::sendMessage<MTL::BlitCommandEncoder*>(this, _MTL_PRIVATE_SEL(blitCommandEncoder));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::BlitCommandEncoder* MTL::CommandBuffer::blitCommandEncoder(const MTL::BlitPassDescriptor* blitPassDescriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::BlitCommandEncoder*>(this, _MTL_PRIVATE_SEL(blitCommandEncoderWithDescriptor_), blitPassDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandQueue* MTL::CommandBuffer::commandQueue() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CommandQueue*>(this, _MTL_PRIVATE_SEL(commandQueue));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::commit()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(commit));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder(const MTL::ComputePassDescriptor* computePassDescriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputeCommandEncoder*>(this, _MTL_PRIVATE_SEL(computeCommandEncoderWithDescriptor_), computePassDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder()
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputeCommandEncoder*>(this, _MTL_PRIVATE_SEL(computeCommandEncoder));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder(MTL::DispatchType dispatchType)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputeCommandEncoder*>(this, _MTL_PRIVATE_SEL(computeCommandEncoderWithDispatchType_), dispatchType);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::CommandBuffer::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::encodeSignalEvent(const MTL::Event* event, uint64_t value)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(encodeSignalEvent_value_), event, value);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::encodeWait(const MTL::Event* event, uint64_t value)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(encodeWaitForEvent_value_), event, value);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::enqueue()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(enqueue));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Error* MTL::CommandBuffer::error() const
|
||||
{
|
||||
return Object::sendMessage<NS::Error*>(this, _MTL_PRIVATE_SEL(error));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandBufferErrorOption MTL::CommandBuffer::errorOptions() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CommandBufferErrorOption>(this, _MTL_PRIVATE_SEL(errorOptions));
|
||||
}
|
||||
|
||||
_MTL_INLINE CFTimeInterval MTL::CommandBuffer::kernelEndTime() const
|
||||
{
|
||||
return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(kernelEndTime));
|
||||
}
|
||||
|
||||
_MTL_INLINE CFTimeInterval MTL::CommandBuffer::kernelStartTime() const
|
||||
{
|
||||
return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(kernelStartTime));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CommandBuffer::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LogContainer* MTL::CommandBuffer::logs() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LogContainer*>(this, _MTL_PRIVATE_SEL(logs));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ParallelRenderCommandEncoder* MTL::CommandBuffer::parallelRenderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::ParallelRenderCommandEncoder*>(this, _MTL_PRIVATE_SEL(parallelRenderCommandEncoderWithDescriptor_), renderPassDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::popDebugGroup()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(popDebugGroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::presentDrawable(const MTL::Drawable* drawable)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentDrawable_), drawable);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::presentDrawableAfterMinimumDuration(const MTL::Drawable* drawable, CFTimeInterval duration)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentDrawable_afterMinimumDuration_), drawable, duration);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::presentDrawableAtTime(const MTL::Drawable* drawable, CFTimeInterval presentationTime)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentDrawable_atTime_), drawable, presentationTime);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::pushDebugGroup(const NS::String* string)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::RenderCommandEncoder* MTL::CommandBuffer::renderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderCommandEncoder*>(this, _MTL_PRIVATE_SEL(renderCommandEncoderWithDescriptor_), renderPassDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceStateCommandEncoder* MTL::CommandBuffer::resourceStateCommandEncoder()
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceStateCommandEncoder*>(this, _MTL_PRIVATE_SEL(resourceStateCommandEncoder));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceStateCommandEncoder* MTL::CommandBuffer::resourceStateCommandEncoder(const MTL::ResourceStatePassDescriptor* resourceStatePassDescriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceStateCommandEncoder*>(this, _MTL_PRIVATE_SEL(resourceStateCommandEncoderWithDescriptor_), resourceStatePassDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CommandBuffer::retainedReferences() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(retainedReferences));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandBufferStatus MTL::CommandBuffer::status() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CommandBufferStatus>(this, _MTL_PRIVATE_SEL(status));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::useResidencySet(const MTL::ResidencySet* residencySet)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResidencySet_), residencySet);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::useResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResidencySets_count_), residencySets, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::waitUntilCompleted()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitUntilCompleted));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandBuffer::waitUntilScheduled()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitUntilScheduled));
|
||||
}
|
||||
117
dist/include/metal_cpp/Metal/MTLCommandEncoder.hpp
vendored
Normal file
117
dist/include/metal_cpp/Metal/MTLCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLCommandEncoder.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, ResourceUsage) {
|
||||
ResourceUsageRead = 1,
|
||||
ResourceUsageWrite = 1 << 1,
|
||||
ResourceUsageSample = 1 << 2,
|
||||
};
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, BarrierScope) {
|
||||
BarrierScopeBuffers = 1,
|
||||
BarrierScopeTextures = 1 << 1,
|
||||
BarrierScopeRenderTargets = 1 << 2,
|
||||
};
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, Stages) {
|
||||
StageVertex = 1,
|
||||
StageFragment = 1 << 1,
|
||||
StageTile = 1 << 2,
|
||||
StageObject = 1 << 3,
|
||||
StageMesh = 1 << 4,
|
||||
StageResourceState = 1 << 26,
|
||||
StageDispatch = 1 << 27,
|
||||
StageBlit = 1 << 28,
|
||||
StageAccelerationStructure = 1 << 29,
|
||||
StageMachineLearning = 1 << 30,
|
||||
StageAll = 9223372036854775807,
|
||||
};
|
||||
|
||||
class CommandEncoder : public NS::Referencing<CommandEncoder>
|
||||
{
|
||||
public:
|
||||
void barrierAfterQueueStages(MTL::Stages afterQueueStages, MTL::Stages beforeStages);
|
||||
|
||||
Device* device() const;
|
||||
|
||||
void endEncoding();
|
||||
|
||||
void insertDebugSignpost(const NS::String* string);
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
void popDebugGroup();
|
||||
|
||||
void pushDebugGroup(const NS::String* string);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL::CommandEncoder::barrierAfterQueueStages(MTL::Stages afterQueueStages, MTL::Stages beforeStages)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(barrierAfterQueueStages_beforeStages_), afterQueueStages, beforeStages);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::CommandEncoder::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandEncoder::endEncoding()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(endEncoding));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandEncoder::insertDebugSignpost(const NS::String* string)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(insertDebugSignpost_), string);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CommandEncoder::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandEncoder::popDebugGroup()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(popDebugGroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandEncoder::pushDebugGroup(const NS::String* string)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandEncoder::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
158
dist/include/metal_cpp/Metal/MTLCommandQueue.hpp
vendored
Normal file
158
dist/include/metal_cpp/Metal/MTLCommandQueue.hpp
vendored
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLCommandQueue.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class CommandBuffer;
|
||||
class CommandBufferDescriptor;
|
||||
class CommandQueueDescriptor;
|
||||
class Device;
|
||||
class LogState;
|
||||
class ResidencySet;
|
||||
|
||||
class CommandQueue : public NS::Referencing<CommandQueue>
|
||||
{
|
||||
public:
|
||||
void addResidencySet(const MTL::ResidencySet* residencySet);
|
||||
void addResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count);
|
||||
|
||||
CommandBuffer* commandBuffer();
|
||||
CommandBuffer* commandBuffer(const MTL::CommandBufferDescriptor* descriptor);
|
||||
CommandBuffer* commandBufferWithUnretainedReferences();
|
||||
|
||||
Device* device() const;
|
||||
|
||||
void insertDebugCaptureBoundary();
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
void removeResidencySet(const MTL::ResidencySet* residencySet);
|
||||
void removeResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
class CommandQueueDescriptor : public NS::Copying<CommandQueueDescriptor>
|
||||
{
|
||||
public:
|
||||
static CommandQueueDescriptor* alloc();
|
||||
|
||||
CommandQueueDescriptor* init();
|
||||
|
||||
LogState* logState() const;
|
||||
|
||||
NS::UInteger maxCommandBufferCount() const;
|
||||
|
||||
void setLogState(const MTL::LogState* logState);
|
||||
|
||||
void setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL::CommandQueue::addResidencySet(const MTL::ResidencySet* residencySet)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addResidencySet_), residencySet);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandQueue::addResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addResidencySets_count_), residencySets, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBuffer()
|
||||
{
|
||||
return Object::sendMessage<MTL::CommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBuffer(const MTL::CommandBufferDescriptor* descriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::CommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBufferWithDescriptor_), descriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBufferWithUnretainedReferences()
|
||||
{
|
||||
return Object::sendMessage<MTL::CommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBufferWithUnretainedReferences));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::CommandQueue::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandQueue::insertDebugCaptureBoundary()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(insertDebugCaptureBoundary));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CommandQueue::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandQueue::removeResidencySet(const MTL::ResidencySet* residencySet)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(removeResidencySet_), residencySet);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandQueue::removeResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(removeResidencySets_count_), residencySets, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandQueue::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandQueueDescriptor* MTL::CommandQueueDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::CommandQueueDescriptor>(_MTL_PRIVATE_CLS(MTLCommandQueueDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CommandQueueDescriptor* MTL::CommandQueueDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::CommandQueueDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LogState* MTL::CommandQueueDescriptor::logState() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LogState*>(this, _MTL_PRIVATE_SEL(logState));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::CommandQueueDescriptor::maxCommandBufferCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCommandBufferCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandQueueDescriptor::setLogState(const MTL::LogState* logState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLogState_), logState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CommandQueueDescriptor::setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCommandBufferCount_), maxCommandBufferCount);
|
||||
}
|
||||
324
dist/include/metal_cpp/Metal/MTLComputeCommandEncoder.hpp
vendored
Normal file
324
dist/include/metal_cpp/Metal/MTLComputeCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,324 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLComputeCommandEncoder.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 "MTLCommandBuffer.hpp"
|
||||
#include "MTLCommandEncoder.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class AccelerationStructure;
|
||||
class Buffer;
|
||||
class ComputePipelineState;
|
||||
class CounterSampleBuffer;
|
||||
class Fence;
|
||||
class Heap;
|
||||
class IndirectCommandBuffer;
|
||||
class IntersectionFunctionTable;
|
||||
class Resource;
|
||||
class SamplerState;
|
||||
class Texture;
|
||||
class VisibleFunctionTable;
|
||||
|
||||
struct DispatchThreadgroupsIndirectArguments
|
||||
{
|
||||
uint32_t threadgroupsPerGrid[3];
|
||||
} _MTL_PACKED;
|
||||
|
||||
struct DispatchThreadsIndirectArguments
|
||||
{
|
||||
uint32_t threadsPerGrid[3];
|
||||
uint32_t threadsPerThreadgroup[3];
|
||||
} _MTL_PACKED;
|
||||
|
||||
struct StageInRegionIndirectArguments
|
||||
{
|
||||
uint32_t stageInOrigin[3];
|
||||
uint32_t stageInSize[3];
|
||||
} _MTL_PACKED;
|
||||
|
||||
class ComputeCommandEncoder : public NS::Referencing<ComputeCommandEncoder, CommandEncoder>
|
||||
{
|
||||
public:
|
||||
void dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup);
|
||||
void dispatchThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerThreadgroup);
|
||||
|
||||
void dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup);
|
||||
|
||||
DispatchType dispatchType() const;
|
||||
|
||||
void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange);
|
||||
void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset);
|
||||
|
||||
void memoryBarrier(MTL::BarrierScope scope);
|
||||
void memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count);
|
||||
|
||||
void sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier);
|
||||
|
||||
void setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex);
|
||||
|
||||
void setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index);
|
||||
void setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
|
||||
void setBufferOffset(NS::UInteger offset, NS::UInteger index);
|
||||
void setBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
|
||||
|
||||
void setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
|
||||
void setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range);
|
||||
|
||||
void setBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
|
||||
void setBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index);
|
||||
|
||||
void setComputePipelineState(const MTL::ComputePipelineState* state);
|
||||
|
||||
void setImageblockWidth(NS::UInteger width, NS::UInteger height);
|
||||
|
||||
void setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex);
|
||||
void setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
|
||||
|
||||
void setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index);
|
||||
void setSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
|
||||
void setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range);
|
||||
void setSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range);
|
||||
|
||||
void setStageInRegion(MTL::Region region);
|
||||
void setStageInRegion(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
|
||||
|
||||
void setTexture(const MTL::Texture* texture, NS::UInteger index);
|
||||
void setTextures(const MTL::Texture* const textures[], NS::Range range);
|
||||
|
||||
void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
|
||||
|
||||
void setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger bufferIndex);
|
||||
void setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range);
|
||||
|
||||
void updateFence(const MTL::Fence* fence);
|
||||
|
||||
void useHeap(const MTL::Heap* heap);
|
||||
void useHeaps(const MTL::Heap* const heaps[], NS::UInteger count);
|
||||
|
||||
void useResource(const MTL::Resource* resource, MTL::ResourceUsage usage);
|
||||
void useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage);
|
||||
|
||||
void waitForFence(const MTL::Fence* fence);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadgroups_threadsPerThreadgroup_), threadgroupsPerGrid, threadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerThreadgroup_), indirectBuffer, indirectBufferOffset, threadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreads_threadsPerThreadgroup_), threadsPerGrid, threadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DispatchType MTL::ComputeCommandEncoder::dispatchType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DispatchType>(this, _MTL_PRIVATE_SEL(dispatchType));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_), indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::memoryBarrier(MTL::BarrierScope scope)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(memoryBarrierWithScope_), scope);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(memoryBarrierWithResources_count_), resources, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setBufferOffset(NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBufferOffset_atIndex_), offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBufferOffset_attributeStride_atIndex_), offset, stride, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffers_offsets_attributeStrides_withRange_), buffers, offsets, strides, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBytes_length_atIndex_), bytes, length, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBytes_length_attributeStride_atIndex_), bytes, length, stride, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setComputePipelineState(const MTL::ComputePipelineState* state)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineState_), state);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setImageblockWidth(NS::UInteger width, NS::UInteger height)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setImageblockWidth_height_), width, height);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerState_atIndex_), sampler, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerStates_withRange_), samplers, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setStageInRegion(MTL::Region region)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStageInRegion_), region);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setStageInRegion(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStageInRegionWithIndirectBuffer_indirectBufferOffset_), indirectBuffer, indirectBufferOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setTexture(const MTL::Texture* texture, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTexture_atIndex_), texture, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setTextures(const MTL::Texture* const textures[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTextures_withRange_), textures, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_atIndex_), length, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger bufferIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atBufferIndex_), visibleFunctionTable, bufferIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withBufferRange_), visibleFunctionTables, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::updateFence(const MTL::Fence* fence)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_), fence);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::useHeap(const MTL::Heap* heap)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeap_), heap);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputeCommandEncoder::waitForFence(const MTL::Fence* fence)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_), fence);
|
||||
}
|
||||
169
dist/include/metal_cpp/Metal/MTLComputePass.hpp
vendored
Normal file
169
dist/include/metal_cpp/Metal/MTLComputePass.hpp
vendored
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLComputePass.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 "MTLCommandBuffer.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class ComputePassDescriptor;
|
||||
class ComputePassSampleBufferAttachmentDescriptor;
|
||||
class ComputePassSampleBufferAttachmentDescriptorArray;
|
||||
class CounterSampleBuffer;
|
||||
|
||||
class ComputePassSampleBufferAttachmentDescriptor : public NS::Copying<ComputePassSampleBufferAttachmentDescriptor>
|
||||
{
|
||||
public:
|
||||
static ComputePassSampleBufferAttachmentDescriptor* alloc();
|
||||
|
||||
NS::UInteger endOfEncoderSampleIndex() const;
|
||||
|
||||
ComputePassSampleBufferAttachmentDescriptor* init();
|
||||
|
||||
CounterSampleBuffer* sampleBuffer() const;
|
||||
|
||||
void setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex);
|
||||
|
||||
void setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer);
|
||||
|
||||
void setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex);
|
||||
NS::UInteger startOfEncoderSampleIndex() const;
|
||||
};
|
||||
class ComputePassSampleBufferAttachmentDescriptorArray : public NS::Referencing<ComputePassSampleBufferAttachmentDescriptorArray>
|
||||
{
|
||||
public:
|
||||
static ComputePassSampleBufferAttachmentDescriptorArray* alloc();
|
||||
|
||||
ComputePassSampleBufferAttachmentDescriptorArray* init();
|
||||
|
||||
ComputePassSampleBufferAttachmentDescriptor* object(NS::UInteger attachmentIndex);
|
||||
void setObject(const MTL::ComputePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
|
||||
};
|
||||
class ComputePassDescriptor : public NS::Copying<ComputePassDescriptor>
|
||||
{
|
||||
public:
|
||||
static ComputePassDescriptor* alloc();
|
||||
|
||||
static ComputePassDescriptor* computePassDescriptor();
|
||||
|
||||
DispatchType dispatchType() const;
|
||||
|
||||
ComputePassDescriptor* init();
|
||||
|
||||
ComputePassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
|
||||
|
||||
void setDispatchType(MTL::DispatchType dispatchType);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::ComputePassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLComputePassSampleBufferAttachmentDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ComputePassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::ComputePassSampleBufferAttachmentDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CounterSampleBuffer* MTL::ComputePassSampleBufferAttachmentDescriptor::sampleBuffer() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ComputePassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassSampleBufferAttachmentDescriptorArray::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::ComputePassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLComputePassSampleBufferAttachmentDescriptorArray));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassSampleBufferAttachmentDescriptorArray::init()
|
||||
{
|
||||
return NS::Object::init<MTL::ComputePassSampleBufferAttachmentDescriptorArray>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptorArray::setObject(const MTL::ComputePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::ComputePassDescriptor>(_MTL_PRIVATE_CLS(MTLComputePassDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::computePassDescriptor()
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePassDescriptor*>(_MTL_PRIVATE_CLS(MTLComputePassDescriptor), _MTL_PRIVATE_SEL(computePassDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DispatchType MTL::ComputePassDescriptor::dispatchType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DispatchType>(this, _MTL_PRIVATE_SEL(dispatchType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::ComputePassDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassDescriptor::sampleBufferAttachments() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePassDescriptor::setDispatchType(MTL::DispatchType dispatchType)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDispatchType_), dispatchType);
|
||||
}
|
||||
439
dist/include/metal_cpp/Metal/MTLComputePipeline.hpp
vendored
Normal file
439
dist/include/metal_cpp/Metal/MTLComputePipeline.hpp
vendored
Normal file
|
|
@ -0,0 +1,439 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLComputePipeline.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 "MTLAllocation.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPipeline.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class ComputePipelineDescriptor;
|
||||
class ComputePipelineReflection;
|
||||
class ComputePipelineState;
|
||||
class Device;
|
||||
class Function;
|
||||
class FunctionHandle;
|
||||
class IntersectionFunctionTable;
|
||||
class IntersectionFunctionTableDescriptor;
|
||||
class LinkedFunctions;
|
||||
class PipelineBufferDescriptorArray;
|
||||
class StageInputOutputDescriptor;
|
||||
class VisibleFunctionTable;
|
||||
class VisibleFunctionTableDescriptor;
|
||||
|
||||
}
|
||||
namespace MTL4
|
||||
{
|
||||
class BinaryFunction;
|
||||
|
||||
}
|
||||
namespace MTL
|
||||
{
|
||||
class ComputePipelineReflection : public NS::Referencing<ComputePipelineReflection>
|
||||
{
|
||||
public:
|
||||
static ComputePipelineReflection* alloc();
|
||||
|
||||
NS::Array* arguments() const;
|
||||
|
||||
NS::Array* bindings() const;
|
||||
|
||||
ComputePipelineReflection* init();
|
||||
};
|
||||
class ComputePipelineDescriptor : public NS::Copying<ComputePipelineDescriptor>
|
||||
{
|
||||
public:
|
||||
static ComputePipelineDescriptor* alloc();
|
||||
|
||||
NS::Array* binaryArchives() const;
|
||||
|
||||
PipelineBufferDescriptorArray* buffers() const;
|
||||
|
||||
Function* computeFunction() const;
|
||||
|
||||
ComputePipelineDescriptor* init();
|
||||
|
||||
NS::Array* insertLibraries() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
LinkedFunctions* linkedFunctions() const;
|
||||
|
||||
NS::UInteger maxCallStackDepth() const;
|
||||
|
||||
NS::UInteger maxTotalThreadsPerThreadgroup() const;
|
||||
|
||||
NS::Array* preloadedLibraries() const;
|
||||
|
||||
Size requiredThreadsPerThreadgroup() const;
|
||||
|
||||
void reset();
|
||||
|
||||
void setBinaryArchives(const NS::Array* binaryArchives);
|
||||
|
||||
void setComputeFunction(const MTL::Function* computeFunction);
|
||||
|
||||
void setInsertLibraries(const NS::Array* insertLibraries);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions);
|
||||
|
||||
void setMaxCallStackDepth(NS::UInteger maxCallStackDepth);
|
||||
|
||||
void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup);
|
||||
|
||||
void setPreloadedLibraries(const NS::Array* preloadedLibraries);
|
||||
|
||||
void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup);
|
||||
|
||||
void setShaderValidation(MTL::ShaderValidation shaderValidation);
|
||||
|
||||
void setStageInputDescriptor(const MTL::StageInputOutputDescriptor* stageInputDescriptor);
|
||||
|
||||
void setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions);
|
||||
|
||||
void setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers);
|
||||
|
||||
void setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth);
|
||||
|
||||
ShaderValidation shaderValidation() const;
|
||||
|
||||
StageInputOutputDescriptor* stageInputDescriptor() const;
|
||||
|
||||
bool supportAddingBinaryFunctions() const;
|
||||
|
||||
bool supportIndirectCommandBuffers() const;
|
||||
|
||||
bool threadGroupSizeIsMultipleOfThreadExecutionWidth() const;
|
||||
};
|
||||
class ComputePipelineState : public NS::Referencing<ComputePipelineState, Allocation>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
FunctionHandle* functionHandle(const NS::String* name);
|
||||
FunctionHandle* functionHandle(const MTL4::BinaryFunction* function);
|
||||
FunctionHandle* functionHandle(const MTL::Function* function);
|
||||
|
||||
ResourceID gpuResourceID() const;
|
||||
|
||||
NS::UInteger imageblockMemoryLength(MTL::Size imageblockDimensions);
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
NS::UInteger maxTotalThreadsPerThreadgroup() const;
|
||||
|
||||
ComputePipelineState* newComputePipelineStateWithBinaryFunctions(const NS::Array* additionalBinaryFunctions, NS::Error** error);
|
||||
ComputePipelineState* newComputePipelineState(const NS::Array* functions, NS::Error** error);
|
||||
|
||||
IntersectionFunctionTable* newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor);
|
||||
|
||||
VisibleFunctionTable* newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor);
|
||||
|
||||
ComputePipelineReflection* reflection() const;
|
||||
|
||||
Size requiredThreadsPerThreadgroup() const;
|
||||
|
||||
ShaderValidation shaderValidation() const;
|
||||
|
||||
NS::UInteger staticThreadgroupMemoryLength() const;
|
||||
|
||||
bool supportIndirectCommandBuffers() const;
|
||||
|
||||
NS::UInteger threadExecutionWidth() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::ComputePipelineReflection* MTL::ComputePipelineReflection::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::ComputePipelineReflection>(_MTL_PRIVATE_CLS(MTLComputePipelineReflection));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::ComputePipelineReflection::arguments() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(arguments));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::ComputePipelineReflection::bindings() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(bindings));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineReflection* MTL::ComputePipelineReflection::init()
|
||||
{
|
||||
return NS::Object::init<MTL::ComputePipelineReflection>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineDescriptor* MTL::ComputePipelineDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::ComputePipelineDescriptor>(_MTL_PRIVATE_CLS(MTLComputePipelineDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::binaryArchives() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::ComputePipelineDescriptor::buffers() const
|
||||
{
|
||||
return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(buffers));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Function* MTL::ComputePipelineDescriptor::computeFunction() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(computeFunction));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineDescriptor* MTL::ComputePipelineDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::ComputePipelineDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::insertLibraries() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(insertLibraries));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::ComputePipelineDescriptor::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LinkedFunctions* MTL::ComputePipelineDescriptor::linkedFunctions() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(linkedFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ComputePipelineDescriptor::maxCallStackDepth() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCallStackDepth));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ComputePipelineDescriptor::maxTotalThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::preloadedLibraries() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(preloadedLibraries));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Size MTL::ComputePipelineDescriptor::requiredThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setComputeFunction(const MTL::Function* computeFunction)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputeFunction_), computeFunction);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setInsertLibraries(const NS::Array* insertLibraries)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInsertLibraries_), insertLibraries);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLinkedFunctions_), linkedFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setMaxCallStackDepth(NS::UInteger maxCallStackDepth)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCallStackDepth_), maxCallStackDepth);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setPreloadedLibraries(const NS::Array* preloadedLibraries)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreloadedLibraries_), preloadedLibraries);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setShaderValidation(MTL::ShaderValidation shaderValidation)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setShaderValidation_), shaderValidation);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setStageInputDescriptor(const MTL::StageInputOutputDescriptor* stageInputDescriptor)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStageInputDescriptor_), stageInputDescriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAddingBinaryFunctions_), supportAddingBinaryFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ComputePipelineDescriptor::setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadGroupSizeIsMultipleOfThreadExecutionWidth_), threadGroupSizeIsMultipleOfThreadExecutionWidth);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ShaderValidation MTL::ComputePipelineDescriptor::shaderValidation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ShaderValidation>(this, _MTL_PRIVATE_SEL(shaderValidation));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::ComputePipelineDescriptor::stageInputDescriptor() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StageInputOutputDescriptor*>(this, _MTL_PRIVATE_SEL(stageInputDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::ComputePipelineDescriptor::supportAddingBinaryFunctions() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAddingBinaryFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::ComputePipelineDescriptor::supportIndirectCommandBuffers() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::ComputePipelineDescriptor::threadGroupSizeIsMultipleOfThreadExecutionWidth() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(threadGroupSizeIsMultipleOfThreadExecutionWidth));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::ComputePipelineState::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionHandle* MTL::ComputePipelineState::functionHandle(const NS::String* name)
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionHandle*>(this, _MTL_PRIVATE_SEL(functionHandleWithName_), name);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionHandle* MTL::ComputePipelineState::functionHandle(const MTL4::BinaryFunction* function)
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionHandle*>(this, _MTL_PRIVATE_SEL(functionHandleWithBinaryFunction_), function);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionHandle* MTL::ComputePipelineState::functionHandle(const MTL::Function* function)
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionHandle*>(this, _MTL_PRIVATE_SEL(functionHandleWithFunction_), function);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceID MTL::ComputePipelineState::gpuResourceID() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ComputePipelineState::imageblockMemoryLength(MTL::Size imageblockDimensions)
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockMemoryLengthForDimensions_), imageblockDimensions);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::ComputePipelineState::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ComputePipelineState::maxTotalThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineState* MTL::ComputePipelineState::newComputePipelineStateWithBinaryFunctions(const NS::Array* additionalBinaryFunctions, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithBinaryFunctions_error_), additionalBinaryFunctions, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineState* MTL::ComputePipelineState::newComputePipelineState(const NS::Array* functions, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithAdditionalBinaryFunctions_error_), functions, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IntersectionFunctionTable* MTL::ComputePipelineState::newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::IntersectionFunctionTable*>(this, _MTL_PRIVATE_SEL(newIntersectionFunctionTableWithDescriptor_), descriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::VisibleFunctionTable* MTL::ComputePipelineState::newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::VisibleFunctionTable*>(this, _MTL_PRIVATE_SEL(newVisibleFunctionTableWithDescriptor_), descriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ComputePipelineReflection* MTL::ComputePipelineState::reflection() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ComputePipelineReflection*>(this, _MTL_PRIVATE_SEL(reflection));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Size MTL::ComputePipelineState::requiredThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ShaderValidation MTL::ComputePipelineState::shaderValidation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ShaderValidation>(this, _MTL_PRIVATE_SEL(shaderValidation));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ComputePipelineState::staticThreadgroupMemoryLength() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(staticThreadgroupMemoryLength));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::ComputePipelineState::supportIndirectCommandBuffers() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::ComputePipelineState::threadExecutionWidth() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadExecutionWidth));
|
||||
}
|
||||
243
dist/include/metal_cpp/Metal/MTLCounters.hpp
vendored
Normal file
243
dist/include/metal_cpp/Metal/MTLCounters.hpp
vendored
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLCounters.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLResource.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class CounterSampleBufferDescriptor;
|
||||
class CounterSet;
|
||||
class Device;
|
||||
_MTL_ENUM(NS::Integer, CounterSampleBufferError) {
|
||||
CounterSampleBufferErrorOutOfMemory = 0,
|
||||
CounterSampleBufferErrorInvalid = 1,
|
||||
CounterSampleBufferErrorInternal = 2,
|
||||
};
|
||||
|
||||
using CommonCounter = NS::String*;
|
||||
using CommonCounterSet = NS::String*;
|
||||
|
||||
static const NS::UInteger CounterErrorValue = static_cast<NS::UInteger>(~0ULL);
|
||||
static const NS::UInteger CounterDontSample = static_cast<NS::UInteger>(-1);
|
||||
_MTL_CONST(NS::ErrorDomain, CounterErrorDomain);
|
||||
_MTL_CONST(CommonCounter, CommonCounterTimestamp);
|
||||
_MTL_CONST(CommonCounter, CommonCounterTessellationInputPatches);
|
||||
_MTL_CONST(CommonCounter, CommonCounterVertexInvocations);
|
||||
_MTL_CONST(CommonCounter, CommonCounterPostTessellationVertexInvocations);
|
||||
_MTL_CONST(CommonCounter, CommonCounterClipperInvocations);
|
||||
_MTL_CONST(CommonCounter, CommonCounterClipperPrimitivesOut);
|
||||
_MTL_CONST(CommonCounter, CommonCounterFragmentInvocations);
|
||||
_MTL_CONST(CommonCounter, CommonCounterFragmentsPassed);
|
||||
_MTL_CONST(CommonCounter, CommonCounterComputeKernelInvocations);
|
||||
_MTL_CONST(CommonCounter, CommonCounterTotalCycles);
|
||||
_MTL_CONST(CommonCounter, CommonCounterVertexCycles);
|
||||
_MTL_CONST(CommonCounter, CommonCounterTessellationCycles);
|
||||
_MTL_CONST(CommonCounter, CommonCounterPostTessellationVertexCycles);
|
||||
_MTL_CONST(CommonCounter, CommonCounterFragmentCycles);
|
||||
_MTL_CONST(CommonCounter, CommonCounterRenderTargetWriteCycles);
|
||||
_MTL_CONST(CommonCounterSet, CommonCounterSetTimestamp);
|
||||
_MTL_CONST(CommonCounterSet, CommonCounterSetStageUtilization);
|
||||
_MTL_CONST(CommonCounterSet, CommonCounterSetStatistic);
|
||||
struct CounterResultTimestamp
|
||||
{
|
||||
uint64_t timestamp;
|
||||
} _MTL_PACKED;
|
||||
|
||||
struct CounterResultStageUtilization
|
||||
{
|
||||
uint64_t totalCycles;
|
||||
uint64_t vertexCycles;
|
||||
uint64_t tessellationCycles;
|
||||
uint64_t postTessellationVertexCycles;
|
||||
uint64_t fragmentCycles;
|
||||
uint64_t renderTargetCycles;
|
||||
} _MTL_PACKED;
|
||||
|
||||
struct CounterResultStatistic
|
||||
{
|
||||
uint64_t tessellationInputPatches;
|
||||
uint64_t vertexInvocations;
|
||||
uint64_t postTessellationVertexInvocations;
|
||||
uint64_t clipperInvocations;
|
||||
uint64_t clipperPrimitivesOut;
|
||||
uint64_t fragmentInvocations;
|
||||
uint64_t fragmentsPassed;
|
||||
uint64_t computeKernelInvocations;
|
||||
} _MTL_PACKED;
|
||||
|
||||
class Counter : public NS::Referencing<Counter>
|
||||
{
|
||||
public:
|
||||
NS::String* name() const;
|
||||
};
|
||||
class CounterSet : public NS::Referencing<CounterSet>
|
||||
{
|
||||
public:
|
||||
NS::Array* counters() const;
|
||||
|
||||
NS::String* name() const;
|
||||
};
|
||||
class CounterSampleBufferDescriptor : public NS::Copying<CounterSampleBufferDescriptor>
|
||||
{
|
||||
public:
|
||||
static CounterSampleBufferDescriptor* alloc();
|
||||
|
||||
CounterSet* counterSet() const;
|
||||
|
||||
CounterSampleBufferDescriptor* init();
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
NS::UInteger sampleCount() const;
|
||||
|
||||
void setCounterSet(const MTL::CounterSet* counterSet);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void setSampleCount(NS::UInteger sampleCount);
|
||||
|
||||
void setStorageMode(MTL::StorageMode storageMode);
|
||||
StorageMode storageMode() const;
|
||||
};
|
||||
class CounterSampleBuffer : public NS::Referencing<CounterSampleBuffer>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
NS::Data* resolveCounterRange(NS::Range range);
|
||||
|
||||
NS::UInteger sampleCount() const;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, CounterErrorDomain);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterTimestamp);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterTessellationInputPatches);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterVertexInvocations);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterPostTessellationVertexInvocations);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterClipperInvocations);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterClipperPrimitivesOut);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterFragmentInvocations);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterFragmentsPassed);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterComputeKernelInvocations);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterTotalCycles);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterVertexCycles);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterTessellationCycles);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterPostTessellationVertexCycles);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterFragmentCycles);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterRenderTargetWriteCycles);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounterSet, CommonCounterSetTimestamp);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounterSet, CommonCounterSetStageUtilization);
|
||||
_MTL_PRIVATE_DEF_CONST(MTL::CommonCounterSet, CommonCounterSetStatistic);
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Counter::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::CounterSet::counters() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(counters));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CounterSet::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CounterSampleBufferDescriptor* MTL::CounterSampleBufferDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::CounterSampleBufferDescriptor>(_MTL_PRIVATE_CLS(MTLCounterSampleBufferDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CounterSet* MTL::CounterSampleBufferDescriptor::counterSet() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CounterSet*>(this, _MTL_PRIVATE_SEL(counterSet));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CounterSampleBufferDescriptor* MTL::CounterSampleBufferDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::CounterSampleBufferDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CounterSampleBufferDescriptor::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::CounterSampleBufferDescriptor::sampleCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sampleCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setCounterSet(const MTL::CounterSet* counterSet)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCounterSet_), counterSet);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setSampleCount(NS::UInteger sampleCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setStorageMode(MTL::StorageMode storageMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StorageMode MTL::CounterSampleBufferDescriptor::storageMode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StorageMode>(this, _MTL_PRIVATE_SEL(storageMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::CounterSampleBuffer::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CounterSampleBuffer::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Data* MTL::CounterSampleBuffer::resolveCounterRange(NS::Range range)
|
||||
{
|
||||
return Object::sendMessage<NS::Data*>(this, _MTL_PRIVATE_SEL(resolveCounterRange_), range);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::CounterSampleBuffer::sampleCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sampleCount));
|
||||
}
|
||||
129
dist/include/metal_cpp/Metal/MTLDataType.hpp
vendored
Normal file
129
dist/include/metal_cpp/Metal/MTLDataType.hpp
vendored
Normal file
|
|
@ -0,0 +1,129 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLDataType.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
_MTL_ENUM(NS::UInteger, DataType) {
|
||||
DataTypeNone = 0,
|
||||
DataTypeStruct = 1,
|
||||
DataTypeArray = 2,
|
||||
DataTypeFloat = 3,
|
||||
DataTypeFloat2 = 4,
|
||||
DataTypeFloat3 = 5,
|
||||
DataTypeFloat4 = 6,
|
||||
DataTypeFloat2x2 = 7,
|
||||
DataTypeFloat2x3 = 8,
|
||||
DataTypeFloat2x4 = 9,
|
||||
DataTypeFloat3x2 = 10,
|
||||
DataTypeFloat3x3 = 11,
|
||||
DataTypeFloat3x4 = 12,
|
||||
DataTypeFloat4x2 = 13,
|
||||
DataTypeFloat4x3 = 14,
|
||||
DataTypeFloat4x4 = 15,
|
||||
DataTypeHalf = 16,
|
||||
DataTypeHalf2 = 17,
|
||||
DataTypeHalf3 = 18,
|
||||
DataTypeHalf4 = 19,
|
||||
DataTypeHalf2x2 = 20,
|
||||
DataTypeHalf2x3 = 21,
|
||||
DataTypeHalf2x4 = 22,
|
||||
DataTypeHalf3x2 = 23,
|
||||
DataTypeHalf3x3 = 24,
|
||||
DataTypeHalf3x4 = 25,
|
||||
DataTypeHalf4x2 = 26,
|
||||
DataTypeHalf4x3 = 27,
|
||||
DataTypeHalf4x4 = 28,
|
||||
DataTypeInt = 29,
|
||||
DataTypeInt2 = 30,
|
||||
DataTypeInt3 = 31,
|
||||
DataTypeInt4 = 32,
|
||||
DataTypeUInt = 33,
|
||||
DataTypeUInt2 = 34,
|
||||
DataTypeUInt3 = 35,
|
||||
DataTypeUInt4 = 36,
|
||||
DataTypeShort = 37,
|
||||
DataTypeShort2 = 38,
|
||||
DataTypeShort3 = 39,
|
||||
DataTypeShort4 = 40,
|
||||
DataTypeUShort = 41,
|
||||
DataTypeUShort2 = 42,
|
||||
DataTypeUShort3 = 43,
|
||||
DataTypeUShort4 = 44,
|
||||
DataTypeChar = 45,
|
||||
DataTypeChar2 = 46,
|
||||
DataTypeChar3 = 47,
|
||||
DataTypeChar4 = 48,
|
||||
DataTypeUChar = 49,
|
||||
DataTypeUChar2 = 50,
|
||||
DataTypeUChar3 = 51,
|
||||
DataTypeUChar4 = 52,
|
||||
DataTypeBool = 53,
|
||||
DataTypeBool2 = 54,
|
||||
DataTypeBool3 = 55,
|
||||
DataTypeBool4 = 56,
|
||||
DataTypeTexture = 58,
|
||||
DataTypeSampler = 59,
|
||||
DataTypePointer = 60,
|
||||
DataTypeR8Unorm = 62,
|
||||
DataTypeR8Snorm = 63,
|
||||
DataTypeR16Unorm = 64,
|
||||
DataTypeR16Snorm = 65,
|
||||
DataTypeRG8Unorm = 66,
|
||||
DataTypeRG8Snorm = 67,
|
||||
DataTypeRG16Unorm = 68,
|
||||
DataTypeRG16Snorm = 69,
|
||||
DataTypeRGBA8Unorm = 70,
|
||||
DataTypeRGBA8Unorm_sRGB = 71,
|
||||
DataTypeRGBA8Snorm = 72,
|
||||
DataTypeRGBA16Unorm = 73,
|
||||
DataTypeRGBA16Snorm = 74,
|
||||
DataTypeRGB10A2Unorm = 75,
|
||||
DataTypeRG11B10Float = 76,
|
||||
DataTypeRGB9E5Float = 77,
|
||||
DataTypeRenderPipeline = 78,
|
||||
DataTypeComputePipeline = 79,
|
||||
DataTypeIndirectCommandBuffer = 80,
|
||||
DataTypeLong = 81,
|
||||
DataTypeLong2 = 82,
|
||||
DataTypeLong3 = 83,
|
||||
DataTypeLong4 = 84,
|
||||
DataTypeULong = 85,
|
||||
DataTypeULong2 = 86,
|
||||
DataTypeULong3 = 87,
|
||||
DataTypeULong4 = 88,
|
||||
DataTypeVisibleFunctionTable = 115,
|
||||
DataTypeIntersectionFunctionTable = 116,
|
||||
DataTypePrimitiveAccelerationStructure = 117,
|
||||
DataTypeInstanceAccelerationStructure = 118,
|
||||
DataTypeBFloat = 121,
|
||||
DataTypeBFloat2 = 122,
|
||||
DataTypeBFloat3 = 123,
|
||||
DataTypeBFloat4 = 124,
|
||||
DataTypeDepthStencilState = 139,
|
||||
DataTypeTensor = 140,
|
||||
};
|
||||
|
||||
}
|
||||
41
dist/include/metal_cpp/Metal/MTLDefines.hpp
vendored
Normal file
41
dist/include/metal_cpp/Metal/MTLDefines.hpp
vendored
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLDefines.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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/NSDefines.hpp"
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
#define _MTL_EXPORT _NS_EXPORT
|
||||
#define _MTL_EXTERN _NS_EXTERN
|
||||
#define _MTL_INLINE _NS_INLINE
|
||||
#define _MTL_PACKED _NS_PACKED
|
||||
|
||||
#define _MTL_CONST(type, name) _NS_CONST(type, name)
|
||||
#define _MTL_ENUM(type, name) _NS_ENUM(type, name)
|
||||
#define _MTL_OPTIONS(type, name) _NS_OPTIONS(type, name)
|
||||
|
||||
#define _MTL_VALIDATE_SIZE(ns, name) _NS_VALIDATE_SIZE(ns, name)
|
||||
#define _MTL_VALIDATE_ENUM(ns, name) _NS_VALIDATE_ENUM(ns, name)
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
277
dist/include/metal_cpp/Metal/MTLDepthStencil.hpp
vendored
Normal file
277
dist/include/metal_cpp/Metal/MTLDepthStencil.hpp
vendored
Normal file
|
|
@ -0,0 +1,277 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLDepthStencil.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class DepthStencilDescriptor;
|
||||
class Device;
|
||||
class StencilDescriptor;
|
||||
_MTL_ENUM(NS::UInteger, CompareFunction) {
|
||||
CompareFunctionNever = 0,
|
||||
CompareFunctionLess = 1,
|
||||
CompareFunctionEqual = 2,
|
||||
CompareFunctionLessEqual = 3,
|
||||
CompareFunctionGreater = 4,
|
||||
CompareFunctionNotEqual = 5,
|
||||
CompareFunctionGreaterEqual = 6,
|
||||
CompareFunctionAlways = 7,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, StencilOperation) {
|
||||
StencilOperationKeep = 0,
|
||||
StencilOperationZero = 1,
|
||||
StencilOperationReplace = 2,
|
||||
StencilOperationIncrementClamp = 3,
|
||||
StencilOperationDecrementClamp = 4,
|
||||
StencilOperationInvert = 5,
|
||||
StencilOperationIncrementWrap = 6,
|
||||
StencilOperationDecrementWrap = 7,
|
||||
};
|
||||
|
||||
class StencilDescriptor : public NS::Copying<StencilDescriptor>
|
||||
{
|
||||
public:
|
||||
static StencilDescriptor* alloc();
|
||||
|
||||
StencilOperation depthFailureOperation() const;
|
||||
|
||||
StencilOperation depthStencilPassOperation() const;
|
||||
|
||||
StencilDescriptor* init();
|
||||
|
||||
uint32_t readMask() const;
|
||||
|
||||
void setDepthFailureOperation(MTL::StencilOperation depthFailureOperation);
|
||||
|
||||
void setDepthStencilPassOperation(MTL::StencilOperation depthStencilPassOperation);
|
||||
|
||||
void setReadMask(uint32_t readMask);
|
||||
|
||||
void setStencilCompareFunction(MTL::CompareFunction stencilCompareFunction);
|
||||
|
||||
void setStencilFailureOperation(MTL::StencilOperation stencilFailureOperation);
|
||||
|
||||
void setWriteMask(uint32_t writeMask);
|
||||
|
||||
CompareFunction stencilCompareFunction() const;
|
||||
|
||||
StencilOperation stencilFailureOperation() const;
|
||||
|
||||
uint32_t writeMask() const;
|
||||
};
|
||||
class DepthStencilDescriptor : public NS::Copying<DepthStencilDescriptor>
|
||||
{
|
||||
public:
|
||||
static DepthStencilDescriptor* alloc();
|
||||
|
||||
StencilDescriptor* backFaceStencil() const;
|
||||
|
||||
CompareFunction depthCompareFunction() const;
|
||||
|
||||
[[deprecated("please use isDepthWriteEnabled instead")]]
|
||||
bool depthWriteEnabled() const;
|
||||
|
||||
StencilDescriptor* frontFaceStencil() const;
|
||||
|
||||
DepthStencilDescriptor* init();
|
||||
|
||||
bool isDepthWriteEnabled() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
void setBackFaceStencil(const MTL::StencilDescriptor* backFaceStencil);
|
||||
|
||||
void setDepthCompareFunction(MTL::CompareFunction depthCompareFunction);
|
||||
|
||||
void setDepthWriteEnabled(bool depthWriteEnabled);
|
||||
|
||||
void setFrontFaceStencil(const MTL::StencilDescriptor* frontFaceStencil);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
class DepthStencilState : public NS::Referencing<DepthStencilState>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
ResourceID gpuResourceID() const;
|
||||
|
||||
NS::String* label() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::StencilDescriptor* MTL::StencilDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::StencilDescriptor>(_MTL_PRIVATE_CLS(MTLStencilDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::depthFailureOperation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(depthFailureOperation));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::depthStencilPassOperation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(depthStencilPassOperation));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StencilDescriptor* MTL::StencilDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::StencilDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE uint32_t MTL::StencilDescriptor::readMask() const
|
||||
{
|
||||
return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(readMask));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StencilDescriptor::setDepthFailureOperation(MTL::StencilOperation depthFailureOperation)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthFailureOperation_), depthFailureOperation);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StencilDescriptor::setDepthStencilPassOperation(MTL::StencilOperation depthStencilPassOperation)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilPassOperation_), depthStencilPassOperation);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StencilDescriptor::setReadMask(uint32_t readMask)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setReadMask_), readMask);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StencilDescriptor::setStencilCompareFunction(MTL::CompareFunction stencilCompareFunction)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilCompareFunction_), stencilCompareFunction);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StencilDescriptor::setStencilFailureOperation(MTL::StencilOperation stencilFailureOperation)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilFailureOperation_), stencilFailureOperation);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StencilDescriptor::setWriteMask(uint32_t writeMask)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CompareFunction MTL::StencilDescriptor::stencilCompareFunction() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CompareFunction>(this, _MTL_PRIVATE_SEL(stencilCompareFunction));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::stencilFailureOperation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(stencilFailureOperation));
|
||||
}
|
||||
|
||||
_MTL_INLINE uint32_t MTL::StencilDescriptor::writeMask() const
|
||||
{
|
||||
return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(writeMask));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DepthStencilDescriptor* MTL::DepthStencilDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::DepthStencilDescriptor>(_MTL_PRIVATE_CLS(MTLDepthStencilDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StencilDescriptor* MTL::DepthStencilDescriptor::backFaceStencil() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StencilDescriptor*>(this, _MTL_PRIVATE_SEL(backFaceStencil));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CompareFunction MTL::DepthStencilDescriptor::depthCompareFunction() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CompareFunction>(this, _MTL_PRIVATE_SEL(depthCompareFunction));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::DepthStencilDescriptor::depthWriteEnabled() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthWriteEnabled));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StencilDescriptor* MTL::DepthStencilDescriptor::frontFaceStencil() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StencilDescriptor*>(this, _MTL_PRIVATE_SEL(frontFaceStencil));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DepthStencilDescriptor* MTL::DepthStencilDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::DepthStencilDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::DepthStencilDescriptor::isDepthWriteEnabled() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthWriteEnabled));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::DepthStencilDescriptor::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::DepthStencilDescriptor::setBackFaceStencil(const MTL::StencilDescriptor* backFaceStencil)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBackFaceStencil_), backFaceStencil);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::DepthStencilDescriptor::setDepthCompareFunction(MTL::CompareFunction depthCompareFunction)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthCompareFunction_), depthCompareFunction);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::DepthStencilDescriptor::setDepthWriteEnabled(bool depthWriteEnabled)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthWriteEnabled_), depthWriteEnabled);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::DepthStencilDescriptor::setFrontFaceStencil(const MTL::StencilDescriptor* frontFaceStencil)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFrontFaceStencil_), frontFaceStencil);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::DepthStencilDescriptor::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::DepthStencilState::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceID MTL::DepthStencilState::gpuResourceID() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::DepthStencilState::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
1493
dist/include/metal_cpp/Metal/MTLDevice.hpp
vendored
Normal file
1493
dist/include/metal_cpp/Metal/MTLDevice.hpp
vendored
Normal file
File diff suppressed because it is too large
Load diff
90
dist/include/metal_cpp/Metal/MTLDrawable.hpp
vendored
Normal file
90
dist/include/metal_cpp/Metal/MTLDrawable.hpp
vendored
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLDrawable.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include <CoreFoundation/CoreFoundation.h>
|
||||
|
||||
#include <CoreFoundation/CoreFoundation.h>
|
||||
#include <functional>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Drawable;
|
||||
|
||||
using DrawablePresentedHandler = void (^)(MTL::Drawable*);
|
||||
using DrawablePresentedHandlerFunction = std::function<void(MTL::Drawable*)>;
|
||||
|
||||
class Drawable : public NS::Referencing<Drawable>
|
||||
{
|
||||
public:
|
||||
void addPresentedHandler(const MTL::DrawablePresentedHandler block);
|
||||
void addPresentedHandler(const MTL::DrawablePresentedHandlerFunction& function);
|
||||
|
||||
NS::UInteger drawableID() const;
|
||||
|
||||
void present();
|
||||
void presentAfterMinimumDuration(CFTimeInterval duration);
|
||||
|
||||
void presentAtTime(CFTimeInterval presentationTime);
|
||||
|
||||
CFTimeInterval presentedTime() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL::Drawable::addPresentedHandler(const MTL::DrawablePresentedHandler block)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addPresentedHandler_), block);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Drawable::addPresentedHandler(const MTL::DrawablePresentedHandlerFunction& function)
|
||||
{
|
||||
__block DrawablePresentedHandlerFunction blockFunction = function;
|
||||
addPresentedHandler(^(Drawable* pDrawable) { blockFunction(pDrawable); });
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Drawable::drawableID() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(drawableID));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Drawable::present()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(present));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Drawable::presentAfterMinimumDuration(CFTimeInterval duration)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentAfterMinimumDuration_), duration);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Drawable::presentAtTime(CFTimeInterval presentationTime)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentAtTime_), presentationTime);
|
||||
}
|
||||
|
||||
_MTL_INLINE CFTimeInterval MTL::Drawable::presentedTime() const
|
||||
{
|
||||
return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(presentedTime));
|
||||
}
|
||||
78
dist/include/metal_cpp/Metal/MTLDynamicLibrary.hpp
vendored
Normal file
78
dist/include/metal_cpp/Metal/MTLDynamicLibrary.hpp
vendored
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLDynamicLibrary.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
_MTL_ENUM(NS::UInteger, DynamicLibraryError) {
|
||||
DynamicLibraryErrorNone = 0,
|
||||
DynamicLibraryErrorInvalidFile = 1,
|
||||
DynamicLibraryErrorCompilationFailure = 2,
|
||||
DynamicLibraryErrorUnresolvedInstallName = 3,
|
||||
DynamicLibraryErrorDependencyLoadFailure = 4,
|
||||
DynamicLibraryErrorUnsupported = 5,
|
||||
};
|
||||
|
||||
class DynamicLibrary : public NS::Referencing<DynamicLibrary>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
NS::String* installName() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
bool serializeToURL(const NS::URL* url, NS::Error** error);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::Device* MTL::DynamicLibrary::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::DynamicLibrary::installName() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(installName));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::DynamicLibrary::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::DynamicLibrary::serializeToURL(const NS::URL* url, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(serializeToURL_error_), url, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::DynamicLibrary::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
170
dist/include/metal_cpp/Metal/MTLEvent.hpp
vendored
Normal file
170
dist/include/metal_cpp/Metal/MTLEvent.hpp
vendored
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLEvent.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include <cstdint>
|
||||
#include <dispatch/dispatch.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
class SharedEvent;
|
||||
class SharedEventHandle;
|
||||
class SharedEventListener;
|
||||
|
||||
using SharedEventNotificationBlock = void (^)(SharedEvent* pEvent, std::uint64_t value);
|
||||
using SharedEventNotificationFunction = std::function<void(SharedEvent* pEvent, std::uint64_t value)>;
|
||||
|
||||
class Event : public NS::Referencing<Event>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
NS::String* label() const;
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
class SharedEventListener : public NS::Referencing<SharedEventListener>
|
||||
{
|
||||
public:
|
||||
static SharedEventListener* alloc();
|
||||
|
||||
dispatch_queue_t dispatchQueue() const;
|
||||
|
||||
SharedEventListener* init();
|
||||
SharedEventListener* init(const dispatch_queue_t dispatchQueue);
|
||||
|
||||
static SharedEventListener* sharedListener();
|
||||
};
|
||||
class SharedEvent : public NS::Referencing<SharedEvent, Event>
|
||||
{
|
||||
public:
|
||||
SharedEventHandle* newSharedEventHandle();
|
||||
|
||||
void notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationBlock block);
|
||||
void notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationFunction& function);
|
||||
|
||||
void setSignaledValue(uint64_t signaledValue);
|
||||
uint64_t signaledValue() const;
|
||||
bool waitUntilSignaledValue(uint64_t value, uint64_t milliseconds);
|
||||
};
|
||||
class SharedEventHandle : public NS::SecureCoding<SharedEventHandle>
|
||||
{
|
||||
public:
|
||||
static SharedEventHandle* alloc();
|
||||
|
||||
SharedEventHandle* init();
|
||||
|
||||
NS::String* label() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::Device* MTL::Event::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Event::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Event::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::SharedEventListener>(_MTL_PRIVATE_CLS(MTLSharedEventListener));
|
||||
}
|
||||
|
||||
_MTL_INLINE dispatch_queue_t MTL::SharedEventListener::dispatchQueue() const
|
||||
{
|
||||
return Object::sendMessage<dispatch_queue_t>(this, _MTL_PRIVATE_SEL(dispatchQueue));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::init()
|
||||
{
|
||||
return NS::Object::init<MTL::SharedEventListener>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::init(const dispatch_queue_t dispatchQueue)
|
||||
{
|
||||
return Object::sendMessage<MTL::SharedEventListener*>(this, _MTL_PRIVATE_SEL(initWithDispatchQueue_), dispatchQueue);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::sharedListener()
|
||||
{
|
||||
return Object::sendMessage<MTL::SharedEventListener*>(_MTL_PRIVATE_CLS(MTLSharedEventListener), _MTL_PRIVATE_SEL(sharedListener));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEvent::newSharedEventHandle()
|
||||
{
|
||||
return Object::sendMessage<MTL::SharedEventHandle*>(this, _MTL_PRIVATE_SEL(newSharedEventHandle));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::SharedEvent::notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationBlock block)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(notifyListener_atValue_block_), listener, value, block);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::SharedEvent::notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationFunction& function)
|
||||
{
|
||||
__block MTL::SharedEventNotificationFunction callback = function;
|
||||
notifyListener(listener, value, ^void(SharedEvent* pEvent, std::uint64_t innerValue) { callback(pEvent, innerValue); });
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::SharedEvent::setSignaledValue(uint64_t signaledValue)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSignaledValue_), signaledValue);
|
||||
}
|
||||
|
||||
_MTL_INLINE uint64_t MTL::SharedEvent::signaledValue() const
|
||||
{
|
||||
return Object::sendMessage<uint64_t>(this, _MTL_PRIVATE_SEL(signaledValue));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::SharedEvent::waitUntilSignaledValue(uint64_t value, uint64_t milliseconds)
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(waitUntilSignaledValue_timeoutMS_), value, milliseconds);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEventHandle::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::SharedEventHandle>(_MTL_PRIVATE_CLS(MTLSharedEventHandle));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEventHandle::init()
|
||||
{
|
||||
return NS::Object::init<MTL::SharedEventHandle>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::SharedEventHandle::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
55
dist/include/metal_cpp/Metal/MTLFence.hpp
vendored
Normal file
55
dist/include/metal_cpp/Metal/MTLFence.hpp
vendored
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLFence.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
|
||||
class Fence : public NS::Referencing<Fence>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
NS::String* label() const;
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::Device* MTL::Fence::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Fence::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Fence::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
76
dist/include/metal_cpp/Metal/MTLFunctionConstantValues.hpp
vendored
Normal file
76
dist/include/metal_cpp/Metal/MTLFunctionConstantValues.hpp
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLFunctionConstantValues.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 "MTLDataType.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class FunctionConstantValues;
|
||||
|
||||
class FunctionConstantValues : public NS::Copying<FunctionConstantValues>
|
||||
{
|
||||
public:
|
||||
static FunctionConstantValues* alloc();
|
||||
|
||||
FunctionConstantValues* init();
|
||||
|
||||
void reset();
|
||||
|
||||
void setConstantValue(const void* value, MTL::DataType type, NS::UInteger index);
|
||||
void setConstantValue(const void* value, MTL::DataType type, const NS::String* name);
|
||||
void setConstantValues(const void* values, MTL::DataType type, NS::Range range);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionConstantValues::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::FunctionConstantValues>(_MTL_PRIVATE_CLS(MTLFunctionConstantValues));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionConstantValues::init()
|
||||
{
|
||||
return NS::Object::init<MTL::FunctionConstantValues>();
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionConstantValues::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionConstantValues::setConstantValue(const void* value, MTL::DataType type, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValue_type_atIndex_), value, type, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionConstantValues::setConstantValue(const void* value, MTL::DataType type, const NS::String* name)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValue_type_withName_), value, type, name);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionConstantValues::setConstantValues(const void* values, MTL::DataType type, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValues_type_withRange_), values, type, range);
|
||||
}
|
||||
153
dist/include/metal_cpp/Metal/MTLFunctionDescriptor.hpp
vendored
Normal file
153
dist/include/metal_cpp/Metal/MTLFunctionDescriptor.hpp
vendored
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLFunctionDescriptor.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class FunctionConstantValues;
|
||||
class FunctionDescriptor;
|
||||
class IntersectionFunctionDescriptor;
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, FunctionOptions) {
|
||||
FunctionOptionNone = 0,
|
||||
FunctionOptionCompileToBinary = 1,
|
||||
FunctionOptionStoreFunctionInMetalPipelinesScript = 1 << 1,
|
||||
FunctionOptionStoreFunctionInMetalScript = 1 << 1,
|
||||
FunctionOptionFailOnBinaryArchiveMiss = 1 << 2,
|
||||
FunctionOptionPipelineIndependent = 1 << 3,
|
||||
};
|
||||
|
||||
class FunctionDescriptor : public NS::Copying<FunctionDescriptor>
|
||||
{
|
||||
public:
|
||||
static FunctionDescriptor* alloc();
|
||||
|
||||
NS::Array* binaryArchives() const;
|
||||
|
||||
FunctionConstantValues* constantValues() const;
|
||||
|
||||
static FunctionDescriptor* functionDescriptor();
|
||||
|
||||
FunctionDescriptor* init();
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
FunctionOptions options() const;
|
||||
|
||||
void setBinaryArchives(const NS::Array* binaryArchives);
|
||||
|
||||
void setConstantValues(const MTL::FunctionConstantValues* constantValues);
|
||||
|
||||
void setName(const NS::String* name);
|
||||
|
||||
void setOptions(MTL::FunctionOptions options);
|
||||
|
||||
void setSpecializedName(const NS::String* specializedName);
|
||||
NS::String* specializedName() const;
|
||||
};
|
||||
class IntersectionFunctionDescriptor : public NS::Copying<IntersectionFunctionDescriptor, FunctionDescriptor>
|
||||
{
|
||||
public:
|
||||
static IntersectionFunctionDescriptor* alloc();
|
||||
|
||||
IntersectionFunctionDescriptor* init();
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::FunctionDescriptor>(_MTL_PRIVATE_CLS(MTLFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::FunctionDescriptor::binaryArchives() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionDescriptor::constantValues() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionConstantValues*>(this, _MTL_PRIVATE_SEL(constantValues));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::functionDescriptor()
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionDescriptor*>(_MTL_PRIVATE_CLS(MTLFunctionDescriptor), _MTL_PRIVATE_SEL(functionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::FunctionDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::FunctionDescriptor::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionOptions MTL::FunctionDescriptor::options() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionOptions>(this, _MTL_PRIVATE_SEL(options));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionDescriptor::setConstantValues(const MTL::FunctionConstantValues* constantValues)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValues_), constantValues);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionDescriptor::setName(const NS::String* name)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setName_), name);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionDescriptor::setOptions(MTL::FunctionOptions options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOptions_), options);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionDescriptor::setSpecializedName(const NS::String* specializedName)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSpecializedName_), specializedName);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::FunctionDescriptor::specializedName() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(specializedName));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IntersectionFunctionDescriptor* MTL::IntersectionFunctionDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::IntersectionFunctionDescriptor>(_MTL_PRIVATE_CLS(MTLIntersectionFunctionDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IntersectionFunctionDescriptor* MTL::IntersectionFunctionDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::IntersectionFunctionDescriptor>();
|
||||
}
|
||||
65
dist/include/metal_cpp/Metal/MTLFunctionHandle.hpp
vendored
Normal file
65
dist/include/metal_cpp/Metal/MTLFunctionHandle.hpp
vendored
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLFunctionHandle.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLLibrary.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Device;
|
||||
|
||||
class FunctionHandle : public NS::Referencing<FunctionHandle>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
FunctionType functionType() const;
|
||||
|
||||
ResourceID gpuResourceID() const;
|
||||
|
||||
NS::String* name() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::Device* MTL::FunctionHandle::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionType MTL::FunctionHandle::functionType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionType>(this, _MTL_PRIVATE_SEL(functionType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceID MTL::FunctionHandle::gpuResourceID() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::FunctionHandle::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
101
dist/include/metal_cpp/Metal/MTLFunctionLog.hpp
vendored
Normal file
101
dist/include/metal_cpp/Metal/MTLFunctionLog.hpp
vendored
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLFunctionLog.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Function;
|
||||
class FunctionLogDebugLocation;
|
||||
_MTL_ENUM(NS::UInteger, FunctionLogType) {
|
||||
FunctionLogTypeValidation = 0,
|
||||
};
|
||||
|
||||
class LogContainer : public NS::Referencing<LogContainer, NS::FastEnumeration>
|
||||
{
|
||||
};
|
||||
class FunctionLogDebugLocation : public NS::Referencing<FunctionLogDebugLocation>
|
||||
{
|
||||
public:
|
||||
NS::URL* URL() const;
|
||||
|
||||
NS::UInteger column() const;
|
||||
|
||||
NS::String* functionName() const;
|
||||
|
||||
NS::UInteger line() const;
|
||||
};
|
||||
class FunctionLog : public NS::Referencing<FunctionLog>
|
||||
{
|
||||
public:
|
||||
FunctionLogDebugLocation* debugLocation() const;
|
||||
|
||||
NS::String* encoderLabel() const;
|
||||
|
||||
Function* function() const;
|
||||
|
||||
FunctionLogType type() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE NS::URL* MTL::FunctionLogDebugLocation::URL() const
|
||||
{
|
||||
return Object::sendMessage<NS::URL*>(this, _MTL_PRIVATE_SEL(URL));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::FunctionLogDebugLocation::column() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(column));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::FunctionLogDebugLocation::functionName() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(functionName));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::FunctionLogDebugLocation::line() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(line));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionLogDebugLocation* MTL::FunctionLog::debugLocation() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionLogDebugLocation*>(this, _MTL_PRIVATE_SEL(debugLocation));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::FunctionLog::encoderLabel() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(encoderLabel));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Function* MTL::FunctionLog::function() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(function));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionLogType MTL::FunctionLog::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionLogType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
319
dist/include/metal_cpp/Metal/MTLFunctionStitching.hpp
vendored
Normal file
319
dist/include/metal_cpp/Metal/MTLFunctionStitching.hpp
vendored
Normal file
|
|
@ -0,0 +1,319 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLFunctionStitching.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class FunctionStitchingAttributeAlwaysInline;
|
||||
class FunctionStitchingFunctionNode;
|
||||
class FunctionStitchingGraph;
|
||||
class FunctionStitchingInputNode;
|
||||
class StitchedLibraryDescriptor;
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, StitchedLibraryOptions) {
|
||||
StitchedLibraryOptionNone = 0,
|
||||
StitchedLibraryOptionFailOnBinaryArchiveMiss = 1,
|
||||
StitchedLibraryOptionStoreLibraryInMetalPipelinesScript = 1 << 1,
|
||||
};
|
||||
|
||||
class FunctionStitchingAttribute : public NS::Referencing<FunctionStitchingAttribute>
|
||||
{
|
||||
};
|
||||
class FunctionStitchingAttributeAlwaysInline : public NS::Referencing<FunctionStitchingAttributeAlwaysInline, FunctionStitchingAttribute>
|
||||
{
|
||||
public:
|
||||
static FunctionStitchingAttributeAlwaysInline* alloc();
|
||||
|
||||
FunctionStitchingAttributeAlwaysInline* init();
|
||||
};
|
||||
class FunctionStitchingNode : public NS::Copying<FunctionStitchingNode>
|
||||
{
|
||||
};
|
||||
class FunctionStitchingInputNode : public NS::Referencing<FunctionStitchingInputNode, FunctionStitchingNode>
|
||||
{
|
||||
public:
|
||||
static FunctionStitchingInputNode* alloc();
|
||||
|
||||
NS::UInteger argumentIndex() const;
|
||||
|
||||
FunctionStitchingInputNode* init();
|
||||
FunctionStitchingInputNode* init(NS::UInteger argument);
|
||||
|
||||
void setArgumentIndex(NS::UInteger argumentIndex);
|
||||
};
|
||||
class FunctionStitchingFunctionNode : public NS::Referencing<FunctionStitchingFunctionNode, FunctionStitchingNode>
|
||||
{
|
||||
public:
|
||||
static FunctionStitchingFunctionNode* alloc();
|
||||
|
||||
NS::Array* arguments() const;
|
||||
|
||||
NS::Array* controlDependencies() const;
|
||||
|
||||
FunctionStitchingFunctionNode* init();
|
||||
FunctionStitchingFunctionNode* init(const NS::String* name, const NS::Array* arguments, const NS::Array* controlDependencies);
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
void setArguments(const NS::Array* arguments);
|
||||
|
||||
void setControlDependencies(const NS::Array* controlDependencies);
|
||||
|
||||
void setName(const NS::String* name);
|
||||
};
|
||||
class FunctionStitchingGraph : public NS::Copying<FunctionStitchingGraph>
|
||||
{
|
||||
public:
|
||||
static FunctionStitchingGraph* alloc();
|
||||
|
||||
NS::Array* attributes() const;
|
||||
|
||||
NS::String* functionName() const;
|
||||
|
||||
FunctionStitchingGraph* init();
|
||||
FunctionStitchingGraph* init(const NS::String* functionName, const NS::Array* nodes, const MTL::FunctionStitchingFunctionNode* outputNode, const NS::Array* attributes);
|
||||
|
||||
NS::Array* nodes() const;
|
||||
|
||||
FunctionStitchingFunctionNode* outputNode() const;
|
||||
|
||||
void setAttributes(const NS::Array* attributes);
|
||||
|
||||
void setFunctionName(const NS::String* functionName);
|
||||
|
||||
void setNodes(const NS::Array* nodes);
|
||||
|
||||
void setOutputNode(const MTL::FunctionStitchingFunctionNode* outputNode);
|
||||
};
|
||||
class StitchedLibraryDescriptor : public NS::Copying<StitchedLibraryDescriptor>
|
||||
{
|
||||
public:
|
||||
static StitchedLibraryDescriptor* alloc();
|
||||
|
||||
NS::Array* binaryArchives() const;
|
||||
|
||||
NS::Array* functionGraphs() const;
|
||||
|
||||
NS::Array* functions() const;
|
||||
|
||||
StitchedLibraryDescriptor* init();
|
||||
|
||||
StitchedLibraryOptions options() const;
|
||||
|
||||
void setBinaryArchives(const NS::Array* binaryArchives);
|
||||
|
||||
void setFunctionGraphs(const NS::Array* functionGraphs);
|
||||
|
||||
void setFunctions(const NS::Array* functions);
|
||||
|
||||
void setOptions(MTL::StitchedLibraryOptions options);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::FunctionStitchingAttributeAlwaysInline* MTL::FunctionStitchingAttributeAlwaysInline::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::FunctionStitchingAttributeAlwaysInline>(_MTL_PRIVATE_CLS(MTLFunctionStitchingAttributeAlwaysInline));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingAttributeAlwaysInline* MTL::FunctionStitchingAttributeAlwaysInline::init()
|
||||
{
|
||||
return NS::Object::init<MTL::FunctionStitchingAttributeAlwaysInline>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::FunctionStitchingInputNode>(_MTL_PRIVATE_CLS(MTLFunctionStitchingInputNode));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::FunctionStitchingInputNode::argumentIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(argumentIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::init()
|
||||
{
|
||||
return NS::Object::init<MTL::FunctionStitchingInputNode>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::init(NS::UInteger argument)
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionStitchingInputNode*>(this, _MTL_PRIVATE_SEL(initWithArgumentIndex_), argument);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionStitchingInputNode::setArgumentIndex(NS::UInteger argumentIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentIndex_), argumentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::FunctionStitchingFunctionNode>(_MTL_PRIVATE_CLS(MTLFunctionStitchingFunctionNode));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::FunctionStitchingFunctionNode::arguments() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(arguments));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::FunctionStitchingFunctionNode::controlDependencies() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(controlDependencies));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::init()
|
||||
{
|
||||
return NS::Object::init<MTL::FunctionStitchingFunctionNode>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::init(const NS::String* name, const NS::Array* arguments, const NS::Array* controlDependencies)
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionStitchingFunctionNode*>(this, _MTL_PRIVATE_SEL(initWithName_arguments_controlDependencies_), name, arguments, controlDependencies);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::FunctionStitchingFunctionNode::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setArguments(const NS::Array* arguments)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArguments_), arguments);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setControlDependencies(const NS::Array* controlDependencies)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlDependencies_), controlDependencies);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setName(const NS::String* name)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setName_), name);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::FunctionStitchingGraph>(_MTL_PRIVATE_CLS(MTLFunctionStitchingGraph));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::FunctionStitchingGraph::attributes() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(attributes));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::FunctionStitchingGraph::functionName() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(functionName));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::init()
|
||||
{
|
||||
return NS::Object::init<MTL::FunctionStitchingGraph>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::init(const NS::String* functionName, const NS::Array* nodes, const MTL::FunctionStitchingFunctionNode* outputNode, const NS::Array* attributes)
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionStitchingGraph*>(this, _MTL_PRIVATE_SEL(initWithFunctionName_nodes_outputNode_attributes_), functionName, nodes, outputNode, attributes);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::FunctionStitchingGraph::nodes() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(nodes));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingGraph::outputNode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionStitchingFunctionNode*>(this, _MTL_PRIVATE_SEL(outputNode));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionStitchingGraph::setAttributes(const NS::Array* attributes)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAttributes_), attributes);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionStitchingGraph::setFunctionName(const NS::String* functionName)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionName_), functionName);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionStitchingGraph::setNodes(const NS::Array* nodes)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setNodes_), nodes);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::FunctionStitchingGraph::setOutputNode(const MTL::FunctionStitchingFunctionNode* outputNode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOutputNode_), outputNode);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StitchedLibraryDescriptor* MTL::StitchedLibraryDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::StitchedLibraryDescriptor>(_MTL_PRIVATE_CLS(MTLStitchedLibraryDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::StitchedLibraryDescriptor::binaryArchives() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::StitchedLibraryDescriptor::functionGraphs() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functionGraphs));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::StitchedLibraryDescriptor::functions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StitchedLibraryDescriptor* MTL::StitchedLibraryDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::StitchedLibraryDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StitchedLibraryOptions MTL::StitchedLibraryDescriptor::options() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StitchedLibraryOptions>(this, _MTL_PRIVATE_SEL(options));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StitchedLibraryDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StitchedLibraryDescriptor::setFunctionGraphs(const NS::Array* functionGraphs)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionGraphs_), functionGraphs);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StitchedLibraryDescriptor::setFunctions(const NS::Array* functions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctions_), functions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::StitchedLibraryDescriptor::setOptions(MTL::StitchedLibraryOptions options)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOptions_), options);
|
||||
}
|
||||
36
dist/include/metal_cpp/Metal/MTLGPUAddress.hpp
vendored
Normal file
36
dist/include/metal_cpp/Metal/MTLGPUAddress.hpp
vendored
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLGPUAddress.hpp
|
||||
//
|
||||
// Copyright 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
|
||||
|
||||
#ifdef __METAL_VERSION__
|
||||
|
||||
#include <metal_stdlib>
|
||||
|
||||
#else
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
#endif // __METAL_VERSION__
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
using GPUAddress = uint64_t;
|
||||
}
|
||||
3120
dist/include/metal_cpp/Metal/MTLHeaderBridge.hpp
vendored
Normal file
3120
dist/include/metal_cpp/Metal/MTLHeaderBridge.hpp
vendored
Normal file
File diff suppressed because it is too large
Load diff
318
dist/include/metal_cpp/Metal/MTLHeap.hpp
vendored
Normal file
318
dist/include/metal_cpp/Metal/MTLHeap.hpp
vendored
Normal file
|
|
@ -0,0 +1,318 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLHeap.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 "MTLAllocation.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLResource.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class AccelerationStructure;
|
||||
class AccelerationStructureDescriptor;
|
||||
class Buffer;
|
||||
class Device;
|
||||
class HeapDescriptor;
|
||||
class Texture;
|
||||
class TextureDescriptor;
|
||||
_MTL_ENUM(NS::Integer, HeapType) {
|
||||
HeapTypeAutomatic = 0,
|
||||
HeapTypePlacement = 1,
|
||||
HeapTypeSparse = 2,
|
||||
};
|
||||
|
||||
class HeapDescriptor : public NS::Copying<HeapDescriptor>
|
||||
{
|
||||
public:
|
||||
static HeapDescriptor* alloc();
|
||||
|
||||
CPUCacheMode cpuCacheMode() const;
|
||||
|
||||
HazardTrackingMode hazardTrackingMode() const;
|
||||
|
||||
HeapDescriptor* init();
|
||||
|
||||
SparsePageSize maxCompatiblePlacementSparsePageSize() const;
|
||||
|
||||
ResourceOptions resourceOptions() const;
|
||||
|
||||
void setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode);
|
||||
|
||||
void setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode);
|
||||
|
||||
void setMaxCompatiblePlacementSparsePageSize(MTL::SparsePageSize maxCompatiblePlacementSparsePageSize);
|
||||
|
||||
void setResourceOptions(MTL::ResourceOptions resourceOptions);
|
||||
|
||||
void setSize(NS::UInteger size);
|
||||
|
||||
void setSparsePageSize(MTL::SparsePageSize sparsePageSize);
|
||||
|
||||
void setStorageMode(MTL::StorageMode storageMode);
|
||||
|
||||
void setType(MTL::HeapType type);
|
||||
|
||||
NS::UInteger size() const;
|
||||
SparsePageSize sparsePageSize() const;
|
||||
|
||||
StorageMode storageMode() const;
|
||||
|
||||
HeapType type() const;
|
||||
};
|
||||
class Heap : public NS::Referencing<Heap, Allocation>
|
||||
{
|
||||
public:
|
||||
CPUCacheMode cpuCacheMode() const;
|
||||
|
||||
NS::UInteger currentAllocatedSize() const;
|
||||
|
||||
Device* device() const;
|
||||
|
||||
HazardTrackingMode hazardTrackingMode() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
NS::UInteger maxAvailableSize(NS::UInteger alignment);
|
||||
|
||||
AccelerationStructure* newAccelerationStructure(NS::UInteger size);
|
||||
AccelerationStructure* newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor);
|
||||
AccelerationStructure* newAccelerationStructure(NS::UInteger size, NS::UInteger offset);
|
||||
AccelerationStructure* newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor, NS::UInteger offset);
|
||||
|
||||
Buffer* newBuffer(NS::UInteger length, MTL::ResourceOptions options);
|
||||
Buffer* newBuffer(NS::UInteger length, MTL::ResourceOptions options, NS::UInteger offset);
|
||||
|
||||
Texture* newTexture(const MTL::TextureDescriptor* descriptor);
|
||||
Texture* newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset);
|
||||
|
||||
ResourceOptions resourceOptions() const;
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
PurgeableState setPurgeableState(MTL::PurgeableState state);
|
||||
|
||||
NS::UInteger size() const;
|
||||
|
||||
StorageMode storageMode() const;
|
||||
|
||||
HeapType type() const;
|
||||
|
||||
NS::UInteger usedSize() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::HeapDescriptor* MTL::HeapDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::HeapDescriptor>(_MTL_PRIVATE_CLS(MTLHeapDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CPUCacheMode MTL::HeapDescriptor::cpuCacheMode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CPUCacheMode>(this, _MTL_PRIVATE_SEL(cpuCacheMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::HazardTrackingMode MTL::HeapDescriptor::hazardTrackingMode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::HazardTrackingMode>(this, _MTL_PRIVATE_SEL(hazardTrackingMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::HeapDescriptor* MTL::HeapDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::HeapDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SparsePageSize MTL::HeapDescriptor::maxCompatiblePlacementSparsePageSize() const
|
||||
{
|
||||
return Object::sendMessage<MTL::SparsePageSize>(this, _MTL_PRIVATE_SEL(maxCompatiblePlacementSparsePageSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceOptions MTL::HeapDescriptor::resourceOptions() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceOptions>(this, _MTL_PRIVATE_SEL(resourceOptions));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::HeapDescriptor::setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCpuCacheMode_), cpuCacheMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::HeapDescriptor::setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setHazardTrackingMode_), hazardTrackingMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::HeapDescriptor::setMaxCompatiblePlacementSparsePageSize(MTL::SparsePageSize maxCompatiblePlacementSparsePageSize)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCompatiblePlacementSparsePageSize_), maxCompatiblePlacementSparsePageSize);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::HeapDescriptor::setResourceOptions(MTL::ResourceOptions resourceOptions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResourceOptions_), resourceOptions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::HeapDescriptor::setSize(NS::UInteger size)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSize_), size);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::HeapDescriptor::setSparsePageSize(MTL::SparsePageSize sparsePageSize)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSparsePageSize_), sparsePageSize);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::HeapDescriptor::setStorageMode(MTL::StorageMode storageMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::HeapDescriptor::setType(MTL::HeapType type)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setType_), type);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::HeapDescriptor::size() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(size));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::SparsePageSize MTL::HeapDescriptor::sparsePageSize() const
|
||||
{
|
||||
return Object::sendMessage<MTL::SparsePageSize>(this, _MTL_PRIVATE_SEL(sparsePageSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StorageMode MTL::HeapDescriptor::storageMode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StorageMode>(this, _MTL_PRIVATE_SEL(storageMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::HeapType MTL::HeapDescriptor::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL::HeapType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CPUCacheMode MTL::Heap::cpuCacheMode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CPUCacheMode>(this, _MTL_PRIVATE_SEL(cpuCacheMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Heap::currentAllocatedSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(currentAllocatedSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::Heap::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::HazardTrackingMode MTL::Heap::hazardTrackingMode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::HazardTrackingMode>(this, _MTL_PRIVATE_SEL(hazardTrackingMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Heap::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Heap::maxAvailableSize(NS::UInteger alignment)
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxAvailableSizeWithAlignment_), alignment);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(NS::UInteger size)
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithSize_), size);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithDescriptor_), descriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(NS::UInteger size, NS::UInteger offset)
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithSize_offset_), size, offset);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor, NS::UInteger offset)
|
||||
{
|
||||
return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithDescriptor_offset_), descriptor, offset);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Buffer* MTL::Heap::newBuffer(NS::UInteger length, MTL::ResourceOptions options)
|
||||
{
|
||||
return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_), length, options);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Buffer* MTL::Heap::newBuffer(NS::UInteger length, MTL::ResourceOptions options, NS::UInteger offset)
|
||||
{
|
||||
return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_offset_), length, options, offset);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Texture* MTL::Heap::newTexture(const MTL::TextureDescriptor* descriptor)
|
||||
{
|
||||
return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_), descriptor);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Texture* MTL::Heap::newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset)
|
||||
{
|
||||
return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_offset_), descriptor, offset);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceOptions MTL::Heap::resourceOptions() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceOptions>(this, _MTL_PRIVATE_SEL(resourceOptions));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Heap::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PurgeableState MTL::Heap::setPurgeableState(MTL::PurgeableState state)
|
||||
{
|
||||
return Object::sendMessage<MTL::PurgeableState>(this, _MTL_PRIVATE_SEL(setPurgeableState_), state);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Heap::size() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(size));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::StorageMode MTL::Heap::storageMode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::StorageMode>(this, _MTL_PRIVATE_SEL(storageMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::HeapType MTL::Heap::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL::HeapType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Heap::usedSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(usedSize));
|
||||
}
|
||||
182
dist/include/metal_cpp/Metal/MTLIOCommandBuffer.hpp
vendored
Normal file
182
dist/include/metal_cpp/Metal/MTLIOCommandBuffer.hpp
vendored
Normal file
|
|
@ -0,0 +1,182 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLIOCommandBuffer.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Buffer;
|
||||
class IOCommandBuffer;
|
||||
class IOFileHandle;
|
||||
class SharedEvent;
|
||||
class Texture;
|
||||
_MTL_ENUM(NS::Integer, IOStatus) {
|
||||
IOStatusPending = 0,
|
||||
IOStatusCancelled = 1,
|
||||
IOStatusError = 2,
|
||||
IOStatusComplete = 3,
|
||||
};
|
||||
|
||||
using IOCommandBufferHandler = void (^)(MTL::IOCommandBuffer*);
|
||||
using IOCommandBufferHandlerFunction = std::function<void(MTL::IOCommandBuffer*)>;
|
||||
|
||||
class IOCommandBuffer : public NS::Referencing<IOCommandBuffer>
|
||||
{
|
||||
public:
|
||||
void addBarrier();
|
||||
|
||||
void addCompletedHandler(const MTL::IOCommandBufferHandler block);
|
||||
void addCompletedHandler(const MTL::IOCommandBufferHandlerFunction& function);
|
||||
|
||||
void commit();
|
||||
|
||||
void copyStatusToBuffer(const MTL::Buffer* buffer, NS::UInteger offset);
|
||||
|
||||
void enqueue();
|
||||
|
||||
NS::Error* error() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
void loadBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset);
|
||||
|
||||
void loadBytes(const void* pointer, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset);
|
||||
|
||||
void loadTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level, MTL::Size size, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Origin destinationOrigin, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset);
|
||||
|
||||
void popDebugGroup();
|
||||
|
||||
void pushDebugGroup(const NS::String* string);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
void signalEvent(const MTL::SharedEvent* event, uint64_t value);
|
||||
|
||||
IOStatus status() const;
|
||||
|
||||
void tryCancel();
|
||||
|
||||
void wait(const MTL::SharedEvent* event, uint64_t value);
|
||||
void waitUntilCompleted();
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::addBarrier()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addBarrier));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::addCompletedHandler(const MTL::IOCommandBufferHandler block)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addCompletedHandler_), block);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::addCompletedHandler(const MTL::IOCommandBufferHandlerFunction& function)
|
||||
{
|
||||
__block MTL::IOCommandBufferHandlerFunction blockFunction = function;
|
||||
addCompletedHandler(^(MTL::IOCommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); });
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::commit()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(commit));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::copyStatusToBuffer(const MTL::Buffer* buffer, NS::UInteger offset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyStatusToBuffer_offset_), buffer, offset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::enqueue()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(enqueue));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Error* MTL::IOCommandBuffer::error() const
|
||||
{
|
||||
return Object::sendMessage<NS::Error*>(this, _MTL_PRIVATE_SEL(error));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::IOCommandBuffer::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::loadBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(loadBuffer_offset_size_sourceHandle_sourceHandleOffset_), buffer, offset, size, sourceHandle, sourceHandleOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::loadBytes(const void* pointer, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(loadBytes_size_sourceHandle_sourceHandleOffset_), pointer, size, sourceHandle, sourceHandleOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::loadTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level, MTL::Size size, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Origin destinationOrigin, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(loadTexture_slice_level_size_sourceBytesPerRow_sourceBytesPerImage_destinationOrigin_sourceHandle_sourceHandleOffset_), texture, slice, level, size, sourceBytesPerRow, sourceBytesPerImage, destinationOrigin, sourceHandle, sourceHandleOffset);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::popDebugGroup()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(popDebugGroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::pushDebugGroup(const NS::String* string)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::signalEvent(const MTL::SharedEvent* event, uint64_t value)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(signalEvent_value_), event, value);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IOStatus MTL::IOCommandBuffer::status() const
|
||||
{
|
||||
return Object::sendMessage<MTL::IOStatus>(this, _MTL_PRIVATE_SEL(status));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::tryCancel()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(tryCancel));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::wait(const MTL::SharedEvent* event, uint64_t value)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForEvent_value_), event, value);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandBuffer::waitUntilCompleted()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitUntilCompleted));
|
||||
}
|
||||
211
dist/include/metal_cpp/Metal/MTLIOCommandQueue.hpp
vendored
Normal file
211
dist/include/metal_cpp/Metal/MTLIOCommandQueue.hpp
vendored
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLIOCommandQueue.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Buffer;
|
||||
class IOCommandBuffer;
|
||||
class IOCommandQueueDescriptor;
|
||||
class IOScratchBuffer;
|
||||
class IOScratchBufferAllocator;
|
||||
_MTL_ENUM(NS::Integer, IOPriority) {
|
||||
IOPriorityHigh = 0,
|
||||
IOPriorityNormal = 1,
|
||||
IOPriorityLow = 2,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, IOCommandQueueType) {
|
||||
IOCommandQueueTypeConcurrent = 0,
|
||||
IOCommandQueueTypeSerial = 1,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, IOError) {
|
||||
IOErrorURLInvalid = 1,
|
||||
IOErrorInternal = 2,
|
||||
};
|
||||
|
||||
_MTL_CONST(NS::ErrorDomain, IOErrorDomain);
|
||||
class IOCommandQueue : public NS::Referencing<IOCommandQueue>
|
||||
{
|
||||
public:
|
||||
IOCommandBuffer* commandBuffer();
|
||||
IOCommandBuffer* commandBufferWithUnretainedReferences();
|
||||
|
||||
void enqueueBarrier();
|
||||
|
||||
NS::String* label() const;
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
class IOScratchBuffer : public NS::Referencing<IOScratchBuffer>
|
||||
{
|
||||
public:
|
||||
Buffer* buffer() const;
|
||||
};
|
||||
class IOScratchBufferAllocator : public NS::Referencing<IOScratchBufferAllocator>
|
||||
{
|
||||
public:
|
||||
IOScratchBuffer* newScratchBuffer(NS::UInteger minimumSize);
|
||||
};
|
||||
class IOCommandQueueDescriptor : public NS::Copying<IOCommandQueueDescriptor>
|
||||
{
|
||||
public:
|
||||
static IOCommandQueueDescriptor* alloc();
|
||||
|
||||
IOCommandQueueDescriptor* init();
|
||||
|
||||
NS::UInteger maxCommandBufferCount() const;
|
||||
|
||||
NS::UInteger maxCommandsInFlight() const;
|
||||
|
||||
IOPriority priority() const;
|
||||
|
||||
IOScratchBufferAllocator* scratchBufferAllocator() const;
|
||||
|
||||
void setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount);
|
||||
|
||||
void setMaxCommandsInFlight(NS::UInteger maxCommandsInFlight);
|
||||
|
||||
void setPriority(MTL::IOPriority priority);
|
||||
|
||||
void setScratchBufferAllocator(const MTL::IOScratchBufferAllocator* scratchBufferAllocator);
|
||||
|
||||
void setType(MTL::IOCommandQueueType type);
|
||||
IOCommandQueueType type() const;
|
||||
};
|
||||
class IOFileHandle : public NS::Referencing<IOFileHandle>
|
||||
{
|
||||
public:
|
||||
NS::String* label() const;
|
||||
void setLabel(const NS::String* label);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, IOErrorDomain);
|
||||
_MTL_INLINE MTL::IOCommandBuffer* MTL::IOCommandQueue::commandBuffer()
|
||||
{
|
||||
return Object::sendMessage<MTL::IOCommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBuffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IOCommandBuffer* MTL::IOCommandQueue::commandBufferWithUnretainedReferences()
|
||||
{
|
||||
return Object::sendMessage<MTL::IOCommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBufferWithUnretainedReferences));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandQueue::enqueueBarrier()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(enqueueBarrier));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::IOCommandQueue::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandQueue::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Buffer* MTL::IOScratchBuffer::buffer() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(buffer));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IOScratchBuffer* MTL::IOScratchBufferAllocator::newScratchBuffer(NS::UInteger minimumSize)
|
||||
{
|
||||
return Object::sendMessage<MTL::IOScratchBuffer*>(this, _MTL_PRIVATE_SEL(newScratchBufferWithMinimumSize_), minimumSize);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IOCommandQueueDescriptor* MTL::IOCommandQueueDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::IOCommandQueueDescriptor>(_MTL_PRIVATE_CLS(MTLIOCommandQueueDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IOCommandQueueDescriptor* MTL::IOCommandQueueDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::IOCommandQueueDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IOCommandQueueDescriptor::maxCommandBufferCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCommandBufferCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IOCommandQueueDescriptor::maxCommandsInFlight() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCommandsInFlight));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IOPriority MTL::IOCommandQueueDescriptor::priority() const
|
||||
{
|
||||
return Object::sendMessage<MTL::IOPriority>(this, _MTL_PRIVATE_SEL(priority));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IOScratchBufferAllocator* MTL::IOCommandQueueDescriptor::scratchBufferAllocator() const
|
||||
{
|
||||
return Object::sendMessage<MTL::IOScratchBufferAllocator*>(this, _MTL_PRIVATE_SEL(scratchBufferAllocator));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandQueueDescriptor::setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCommandBufferCount_), maxCommandBufferCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandQueueDescriptor::setMaxCommandsInFlight(NS::UInteger maxCommandsInFlight)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCommandsInFlight_), maxCommandsInFlight);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandQueueDescriptor::setPriority(MTL::IOPriority priority)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPriority_), priority);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandQueueDescriptor::setScratchBufferAllocator(const MTL::IOScratchBufferAllocator* scratchBufferAllocator)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScratchBufferAllocator_), scratchBufferAllocator);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOCommandQueueDescriptor::setType(MTL::IOCommandQueueType type)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setType_), type);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IOCommandQueueType MTL::IOCommandQueueDescriptor::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL::IOCommandQueueType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::IOFileHandle::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IOFileHandle::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
94
dist/include/metal_cpp/Metal/MTLIOCompressor.hpp
vendored
Normal file
94
dist/include/metal_cpp/Metal/MTLIOCompressor.hpp
vendored
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLIOCompressor.hpp
|
||||
//
|
||||
// Copyright 2020-2024 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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLDevice.hpp"
|
||||
|
||||
#include "../Foundation/Foundation.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
using IOCompressionContext=void*;
|
||||
|
||||
_MTL_ENUM(NS::Integer, IOCompressionStatus) {
|
||||
IOCompressionStatusComplete = 0,
|
||||
IOCompressionStatusError = 1,
|
||||
};
|
||||
|
||||
size_t IOCompressionContextDefaultChunkSize();
|
||||
|
||||
IOCompressionContext IOCreateCompressionContext(const char* path, IOCompressionMethod type, size_t chunkSize);
|
||||
|
||||
void IOCompressionContextAppendData(IOCompressionContext context, const void* data, size_t size);
|
||||
|
||||
IOCompressionStatus IOFlushAndDestroyCompressionContext(IOCompressionContext context);
|
||||
|
||||
}
|
||||
|
||||
#if defined(MTL_PRIVATE_IMPLEMENTATION)
|
||||
|
||||
namespace MTL::Private {
|
||||
|
||||
MTL_DEF_FUNC(MTLIOCompressionContextDefaultChunkSize, size_t (*)(void));
|
||||
|
||||
MTL_DEF_FUNC( MTLIOCreateCompressionContext, void* (*)(const char*, MTL::IOCompressionMethod, size_t) );
|
||||
|
||||
MTL_DEF_FUNC( MTLIOCompressionContextAppendData, void (*)(void*, const void*, size_t) );
|
||||
|
||||
MTL_DEF_FUNC( MTLIOFlushAndDestroyCompressionContext, MTL::IOCompressionStatus (*)(void*) );
|
||||
|
||||
}
|
||||
|
||||
_NS_EXPORT size_t MTL::IOCompressionContextDefaultChunkSize()
|
||||
{
|
||||
return MTL::Private::MTLIOCompressionContextDefaultChunkSize();
|
||||
}
|
||||
|
||||
_NS_EXPORT void* MTL::IOCreateCompressionContext(const char* path, IOCompressionMethod type, size_t chunkSize)
|
||||
{
|
||||
if ( MTL::Private::MTLIOCreateCompressionContext )
|
||||
{
|
||||
return MTL::Private::MTLIOCreateCompressionContext( path, type, chunkSize );
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
_NS_EXPORT void MTL::IOCompressionContextAppendData(void* context, const void* data, size_t size)
|
||||
{
|
||||
if ( MTL::Private::MTLIOCompressionContextAppendData )
|
||||
{
|
||||
MTL::Private::MTLIOCompressionContextAppendData( context, data, size );
|
||||
}
|
||||
}
|
||||
|
||||
_NS_EXPORT MTL::IOCompressionStatus MTL::IOFlushAndDestroyCompressionContext(void* context)
|
||||
{
|
||||
if ( MTL::Private::MTLIOFlushAndDestroyCompressionContext )
|
||||
{
|
||||
return MTL::Private::MTLIOFlushAndDestroyCompressionContext( context );
|
||||
}
|
||||
return MTL::IOCompressionStatusError;
|
||||
}
|
||||
|
||||
#endif
|
||||
376
dist/include/metal_cpp/Metal/MTLIndirectCommandBuffer.hpp
vendored
Normal file
376
dist/include/metal_cpp/Metal/MTLIndirectCommandBuffer.hpp
vendored
Normal file
|
|
@ -0,0 +1,376 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLIndirectCommandBuffer.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLResource.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class IndirectCommandBufferDescriptor;
|
||||
class IndirectComputeCommand;
|
||||
class IndirectRenderCommand;
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, IndirectCommandType) {
|
||||
IndirectCommandTypeDraw = 1,
|
||||
IndirectCommandTypeDrawIndexed = 1 << 1,
|
||||
IndirectCommandTypeDrawPatches = 1 << 2,
|
||||
IndirectCommandTypeDrawIndexedPatches = 1 << 3,
|
||||
IndirectCommandTypeConcurrentDispatch = 1 << 5,
|
||||
IndirectCommandTypeConcurrentDispatchThreads = 1 << 6,
|
||||
IndirectCommandTypeDrawMeshThreadgroups = 1 << 7,
|
||||
IndirectCommandTypeDrawMeshThreads = 1 << 8,
|
||||
};
|
||||
|
||||
struct IndirectCommandBufferExecutionRange
|
||||
{
|
||||
uint32_t location;
|
||||
uint32_t length;
|
||||
} _MTL_PACKED;
|
||||
|
||||
class IndirectCommandBufferDescriptor : public NS::Copying<IndirectCommandBufferDescriptor>
|
||||
{
|
||||
public:
|
||||
static IndirectCommandBufferDescriptor* alloc();
|
||||
|
||||
IndirectCommandType commandTypes() const;
|
||||
|
||||
bool inheritBuffers() const;
|
||||
|
||||
bool inheritCullMode() const;
|
||||
|
||||
bool inheritDepthBias() const;
|
||||
|
||||
bool inheritDepthClipMode() const;
|
||||
|
||||
bool inheritDepthStencilState() const;
|
||||
|
||||
bool inheritFrontFacingWinding() const;
|
||||
|
||||
bool inheritPipelineState() const;
|
||||
|
||||
bool inheritTriangleFillMode() const;
|
||||
|
||||
IndirectCommandBufferDescriptor* init();
|
||||
|
||||
NS::UInteger maxFragmentBufferBindCount() const;
|
||||
|
||||
NS::UInteger maxKernelBufferBindCount() const;
|
||||
|
||||
NS::UInteger maxKernelThreadgroupMemoryBindCount() const;
|
||||
|
||||
NS::UInteger maxMeshBufferBindCount() const;
|
||||
|
||||
NS::UInteger maxObjectBufferBindCount() const;
|
||||
|
||||
NS::UInteger maxObjectThreadgroupMemoryBindCount() const;
|
||||
|
||||
NS::UInteger maxVertexBufferBindCount() const;
|
||||
|
||||
void setCommandTypes(MTL::IndirectCommandType commandTypes);
|
||||
|
||||
void setInheritBuffers(bool inheritBuffers);
|
||||
|
||||
void setInheritCullMode(bool inheritCullMode);
|
||||
|
||||
void setInheritDepthBias(bool inheritDepthBias);
|
||||
|
||||
void setInheritDepthClipMode(bool inheritDepthClipMode);
|
||||
|
||||
void setInheritDepthStencilState(bool inheritDepthStencilState);
|
||||
|
||||
void setInheritFrontFacingWinding(bool inheritFrontFacingWinding);
|
||||
|
||||
void setInheritPipelineState(bool inheritPipelineState);
|
||||
|
||||
void setInheritTriangleFillMode(bool inheritTriangleFillMode);
|
||||
|
||||
void setMaxFragmentBufferBindCount(NS::UInteger maxFragmentBufferBindCount);
|
||||
|
||||
void setMaxKernelBufferBindCount(NS::UInteger maxKernelBufferBindCount);
|
||||
|
||||
void setMaxKernelThreadgroupMemoryBindCount(NS::UInteger maxKernelThreadgroupMemoryBindCount);
|
||||
|
||||
void setMaxMeshBufferBindCount(NS::UInteger maxMeshBufferBindCount);
|
||||
|
||||
void setMaxObjectBufferBindCount(NS::UInteger maxObjectBufferBindCount);
|
||||
|
||||
void setMaxObjectThreadgroupMemoryBindCount(NS::UInteger maxObjectThreadgroupMemoryBindCount);
|
||||
|
||||
void setMaxVertexBufferBindCount(NS::UInteger maxVertexBufferBindCount);
|
||||
|
||||
void setSupportColorAttachmentMapping(bool supportColorAttachmentMapping);
|
||||
|
||||
void setSupportDynamicAttributeStride(bool supportDynamicAttributeStride);
|
||||
|
||||
void setSupportRayTracing(bool supportRayTracing);
|
||||
|
||||
bool supportColorAttachmentMapping() const;
|
||||
|
||||
bool supportDynamicAttributeStride() const;
|
||||
|
||||
bool supportRayTracing() const;
|
||||
};
|
||||
class IndirectCommandBuffer : public NS::Referencing<IndirectCommandBuffer, Resource>
|
||||
{
|
||||
public:
|
||||
ResourceID gpuResourceID() const;
|
||||
|
||||
IndirectComputeCommand* indirectComputeCommand(NS::UInteger commandIndex);
|
||||
|
||||
IndirectRenderCommand* indirectRenderCommand(NS::UInteger commandIndex);
|
||||
|
||||
void reset(NS::Range range);
|
||||
|
||||
NS::UInteger size() const;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IndirectCommandBufferDescriptor* MTL::IndirectCommandBufferDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::IndirectCommandBufferDescriptor>(_MTL_PRIVATE_CLS(MTLIndirectCommandBufferDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IndirectCommandType MTL::IndirectCommandBufferDescriptor::commandTypes() const
|
||||
{
|
||||
return Object::sendMessage<MTL::IndirectCommandType>(this, _MTL_PRIVATE_SEL(commandTypes));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritBuffers() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritBuffers));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritCullMode() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritCullMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritDepthBias() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritDepthBias));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritDepthClipMode() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritDepthClipMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritDepthStencilState() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritDepthStencilState));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritFrontFacingWinding() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritFrontFacingWinding));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritPipelineState() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritPipelineState));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritTriangleFillMode() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritTriangleFillMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IndirectCommandBufferDescriptor* MTL::IndirectCommandBufferDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::IndirectCommandBufferDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxFragmentBufferBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxFragmentBufferBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxKernelBufferBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxKernelBufferBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxKernelThreadgroupMemoryBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxKernelThreadgroupMemoryBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxMeshBufferBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxMeshBufferBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxObjectBufferBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxObjectBufferBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxObjectThreadgroupMemoryBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxObjectThreadgroupMemoryBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxVertexBufferBindCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexBufferBindCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setCommandTypes(MTL::IndirectCommandType commandTypes)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCommandTypes_), commandTypes);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritBuffers(bool inheritBuffers)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritBuffers_), inheritBuffers);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritCullMode(bool inheritCullMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritCullMode_), inheritCullMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritDepthBias(bool inheritDepthBias)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritDepthBias_), inheritDepthBias);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritDepthClipMode(bool inheritDepthClipMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritDepthClipMode_), inheritDepthClipMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritDepthStencilState(bool inheritDepthStencilState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritDepthStencilState_), inheritDepthStencilState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritFrontFacingWinding(bool inheritFrontFacingWinding)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritFrontFacingWinding_), inheritFrontFacingWinding);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritPipelineState(bool inheritPipelineState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritPipelineState_), inheritPipelineState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritTriangleFillMode(bool inheritTriangleFillMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritTriangleFillMode_), inheritTriangleFillMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxFragmentBufferBindCount(NS::UInteger maxFragmentBufferBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxFragmentBufferBindCount_), maxFragmentBufferBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxKernelBufferBindCount(NS::UInteger maxKernelBufferBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxKernelBufferBindCount_), maxKernelBufferBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxKernelThreadgroupMemoryBindCount(NS::UInteger maxKernelThreadgroupMemoryBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxKernelThreadgroupMemoryBindCount_), maxKernelThreadgroupMemoryBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxMeshBufferBindCount(NS::UInteger maxMeshBufferBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxMeshBufferBindCount_), maxMeshBufferBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxObjectBufferBindCount(NS::UInteger maxObjectBufferBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxObjectBufferBindCount_), maxObjectBufferBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxObjectThreadgroupMemoryBindCount(NS::UInteger maxObjectThreadgroupMemoryBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxObjectThreadgroupMemoryBindCount_), maxObjectThreadgroupMemoryBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxVertexBufferBindCount(NS::UInteger maxVertexBufferBindCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexBufferBindCount_), maxVertexBufferBindCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setSupportColorAttachmentMapping(bool supportColorAttachmentMapping)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportColorAttachmentMapping_), supportColorAttachmentMapping);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setSupportDynamicAttributeStride(bool supportDynamicAttributeStride)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportDynamicAttributeStride_), supportDynamicAttributeStride);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setSupportRayTracing(bool supportRayTracing)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportRayTracing_), supportRayTracing);
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::supportColorAttachmentMapping() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportColorAttachmentMapping));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::supportDynamicAttributeStride() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportDynamicAttributeStride));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::supportRayTracing() const
|
||||
{
|
||||
return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportRayTracing));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceID MTL::IndirectCommandBuffer::gpuResourceID() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IndirectComputeCommand* MTL::IndirectCommandBuffer::indirectComputeCommand(NS::UInteger commandIndex)
|
||||
{
|
||||
return Object::sendMessage<MTL::IndirectComputeCommand*>(this, _MTL_PRIVATE_SEL(indirectComputeCommandAtIndex_), commandIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IndirectRenderCommand* MTL::IndirectCommandBuffer::indirectRenderCommand(NS::UInteger commandIndex)
|
||||
{
|
||||
return Object::sendMessage<MTL::IndirectRenderCommand*>(this, _MTL_PRIVATE_SEL(indirectRenderCommandAtIndex_), commandIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectCommandBuffer::reset(NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resetWithRange_), range);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IndirectCommandBuffer::size() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(size));
|
||||
}
|
||||
272
dist/include/metal_cpp/Metal/MTLIndirectCommandEncoder.hpp
vendored
Normal file
272
dist/include/metal_cpp/Metal/MTLIndirectCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,272 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLIndirectCommandEncoder.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 "MTLArgument.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLRenderCommandEncoder.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Buffer;
|
||||
class ComputePipelineState;
|
||||
class RenderPipelineState;
|
||||
|
||||
class IndirectRenderCommand : public NS::Referencing<IndirectRenderCommand>
|
||||
{
|
||||
public:
|
||||
void clearBarrier();
|
||||
|
||||
void drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride);
|
||||
|
||||
void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance);
|
||||
|
||||
void drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
|
||||
|
||||
void drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
|
||||
|
||||
void drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride);
|
||||
|
||||
void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance);
|
||||
|
||||
void reset();
|
||||
|
||||
void setBarrier();
|
||||
|
||||
void setCullMode(MTL::CullMode cullMode);
|
||||
|
||||
void setDepthBias(float depthBias, float slopeScale, float clamp);
|
||||
|
||||
void setDepthClipMode(MTL::DepthClipMode depthClipMode);
|
||||
|
||||
void setDepthStencilState(const MTL::DepthStencilState* depthStencilState);
|
||||
|
||||
void setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index);
|
||||
|
||||
void setFrontFacingWinding(MTL::Winding frontFacingWindning);
|
||||
|
||||
void setMeshBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index);
|
||||
|
||||
void setObjectBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index);
|
||||
|
||||
void setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
|
||||
|
||||
void setRenderPipelineState(const MTL::RenderPipelineState* pipelineState);
|
||||
|
||||
void setTriangleFillMode(MTL::TriangleFillMode fillMode);
|
||||
|
||||
void setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index);
|
||||
void setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
|
||||
};
|
||||
class IndirectComputeCommand : public NS::Referencing<IndirectComputeCommand>
|
||||
{
|
||||
public:
|
||||
void clearBarrier();
|
||||
|
||||
void concurrentDispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup);
|
||||
|
||||
void concurrentDispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup);
|
||||
|
||||
void reset();
|
||||
|
||||
void setBarrier();
|
||||
|
||||
void setComputePipelineState(const MTL::ComputePipelineState* pipelineState);
|
||||
|
||||
void setImageblockWidth(NS::UInteger width, NS::UInteger height);
|
||||
|
||||
void setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index);
|
||||
void setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
|
||||
|
||||
void setStageInRegion(MTL::Region region);
|
||||
|
||||
void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::clearBarrier()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(clearBarrier));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadgroupsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_), primitiveType, vertexStart, vertexCount, instanceCount, baseInstance);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setBarrier()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBarrier));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setCullMode(MTL::CullMode cullMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCullMode_), cullMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setDepthBias(float depthBias, float slopeScale, float clamp)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthBias_slopeScale_clamp_), depthBias, slopeScale, clamp);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setDepthClipMode(MTL::DepthClipMode depthClipMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthClipMode_), depthClipMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setDepthStencilState(const MTL::DepthStencilState* depthStencilState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilState_), depthStencilState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBuffer_offset_atIndex_), buffer, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setFrontFacingWinding(MTL::Winding frontFacingWindning)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFrontFacingWinding_), frontFacingWindning);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setMeshBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBuffer_offset_atIndex_), buffer, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setObjectBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBuffer_offset_atIndex_), buffer, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectThreadgroupMemoryLength_atIndex_), length, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setRenderPipelineState(const MTL::RenderPipelineState* pipelineState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineState_), pipelineState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setTriangleFillMode(MTL::TriangleFillMode fillMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleFillMode_), fillMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_atIndex_), buffer, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectRenderCommand::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::clearBarrier()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(clearBarrier));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::concurrentDispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(concurrentDispatchThreadgroups_threadsPerThreadgroup_), threadgroupsPerGrid, threadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::concurrentDispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(concurrentDispatchThreads_threadsPerThreadgroup_), threadsPerGrid, threadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::reset()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::setBarrier()
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBarrier));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::setComputePipelineState(const MTL::ComputePipelineState* pipelineState)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineState_), pipelineState);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::setImageblockWidth(NS::UInteger width, NS::UInteger height)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setImageblockWidth_height_), width, height);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setKernelBuffer_offset_atIndex_), buffer, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setKernelBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::setStageInRegion(MTL::Region region)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStageInRegion_), region);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IndirectComputeCommand::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_atIndex_), length, index);
|
||||
}
|
||||
173
dist/include/metal_cpp/Metal/MTLIntersectionFunctionTable.hpp
vendored
Normal file
173
dist/include/metal_cpp/Metal/MTLIntersectionFunctionTable.hpp
vendored
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLIntersectionFunctionTable.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLResource.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
#include <cstdint>
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Buffer;
|
||||
class FunctionHandle;
|
||||
class IntersectionFunctionTableDescriptor;
|
||||
class VisibleFunctionTable;
|
||||
|
||||
_MTL_OPTIONS(NS::UInteger, IntersectionFunctionSignature) {
|
||||
IntersectionFunctionSignatureNone = 0,
|
||||
IntersectionFunctionSignatureInstancing = 1,
|
||||
IntersectionFunctionSignatureTriangleData = 1 << 1,
|
||||
IntersectionFunctionSignatureWorldSpaceData = 1 << 2,
|
||||
IntersectionFunctionSignatureInstanceMotion = 1 << 3,
|
||||
IntersectionFunctionSignaturePrimitiveMotion = 1 << 4,
|
||||
IntersectionFunctionSignatureExtendedLimits = 1 << 5,
|
||||
IntersectionFunctionSignatureMaxLevels = 1 << 6,
|
||||
IntersectionFunctionSignatureCurveData = 1 << 7,
|
||||
IntersectionFunctionSignatureIntersectionFunctionBuffer = 1 << 8,
|
||||
IntersectionFunctionSignatureUserData = 1 << 9,
|
||||
};
|
||||
|
||||
struct IntersectionFunctionBufferArguments
|
||||
{
|
||||
uint64_t intersectionFunctionBuffer;
|
||||
uint64_t intersectionFunctionBufferSize;
|
||||
uint64_t intersectionFunctionStride;
|
||||
} _MTL_PACKED;
|
||||
|
||||
class IntersectionFunctionTableDescriptor : public NS::Copying<IntersectionFunctionTableDescriptor>
|
||||
{
|
||||
public:
|
||||
static IntersectionFunctionTableDescriptor* alloc();
|
||||
|
||||
NS::UInteger functionCount() const;
|
||||
|
||||
IntersectionFunctionTableDescriptor* init();
|
||||
|
||||
static IntersectionFunctionTableDescriptor* intersectionFunctionTableDescriptor();
|
||||
|
||||
void setFunctionCount(NS::UInteger functionCount);
|
||||
};
|
||||
class IntersectionFunctionTable : public NS::Referencing<IntersectionFunctionTable, Resource>
|
||||
{
|
||||
public:
|
||||
ResourceID gpuResourceID() const;
|
||||
|
||||
void setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index);
|
||||
void setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
|
||||
|
||||
void setFunction(const MTL::FunctionHandle* function, NS::UInteger index);
|
||||
void setFunctions(const MTL::FunctionHandle* const functions[], NS::Range range);
|
||||
|
||||
void setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index);
|
||||
void setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range);
|
||||
|
||||
void setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index);
|
||||
void setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range);
|
||||
|
||||
void setVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex);
|
||||
void setVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range bufferRange);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::IntersectionFunctionTableDescriptor>(_MTL_PRIVATE_CLS(MTLIntersectionFunctionTableDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::IntersectionFunctionTableDescriptor::functionCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(functionCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::IntersectionFunctionTableDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::intersectionFunctionTableDescriptor()
|
||||
{
|
||||
return Object::sendMessage<MTL::IntersectionFunctionTableDescriptor*>(_MTL_PRIVATE_CLS(MTLIntersectionFunctionTableDescriptor), _MTL_PRIVATE_SEL(intersectionFunctionTableDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTableDescriptor::setFunctionCount(NS::UInteger functionCount)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionCount_), functionCount);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ResourceID MTL::IntersectionFunctionTable::gpuResourceID() const
|
||||
{
|
||||
return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setFunction(const MTL::FunctionHandle* function, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunction_atIndex_), function, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setFunctions(const MTL::FunctionHandle* const functions[], NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctions_withRange_), functions, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaqueCurveIntersectionFunctionWithSignature_atIndex_), signature, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaqueCurveIntersectionFunctionWithSignature_withRange_), signature, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_), signature, index);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_withRange_), signature, range);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::IntersectionFunctionTable::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range bufferRange)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withBufferRange_), functionTables, bufferRange);
|
||||
}
|
||||
786
dist/include/metal_cpp/Metal/MTLLibrary.hpp
vendored
Normal file
786
dist/include/metal_cpp/Metal/MTLLibrary.hpp
vendored
Normal file
|
|
@ -0,0 +1,786 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLLibrary.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 "MTLDataType.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLFunctionDescriptor.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLTypes.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class Argument;
|
||||
class ArgumentEncoder;
|
||||
class Attribute;
|
||||
class CompileOptions;
|
||||
class Device;
|
||||
class Function;
|
||||
class FunctionConstant;
|
||||
class FunctionConstantValues;
|
||||
class FunctionDescriptor;
|
||||
class FunctionReflection;
|
||||
class IntersectionFunctionDescriptor;
|
||||
class VertexAttribute;
|
||||
_MTL_ENUM(NS::UInteger, PatchType) {
|
||||
PatchTypeNone = 0,
|
||||
PatchTypeTriangle = 1,
|
||||
PatchTypeQuad = 2,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, FunctionType) {
|
||||
FunctionTypeVertex = 1,
|
||||
FunctionTypeFragment = 2,
|
||||
FunctionTypeKernel = 3,
|
||||
FunctionTypeVisible = 5,
|
||||
FunctionTypeIntersection = 6,
|
||||
FunctionTypeMesh = 7,
|
||||
FunctionTypeObject = 8,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, LanguageVersion) {
|
||||
LanguageVersion1_0 = 65536,
|
||||
LanguageVersion1_1 = 65537,
|
||||
LanguageVersion1_2 = 65538,
|
||||
LanguageVersion2_0 = 131072,
|
||||
LanguageVersion2_1 = 131073,
|
||||
LanguageVersion2_2 = 131074,
|
||||
LanguageVersion2_3 = 131075,
|
||||
LanguageVersion2_4 = 131076,
|
||||
LanguageVersion3_0 = 196608,
|
||||
LanguageVersion3_1 = 196609,
|
||||
LanguageVersion3_2 = 196610,
|
||||
LanguageVersion4_0 = 262144,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, LibraryType) {
|
||||
LibraryTypeExecutable = 0,
|
||||
LibraryTypeDynamic = 1,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, LibraryOptimizationLevel) {
|
||||
LibraryOptimizationLevelDefault = 0,
|
||||
LibraryOptimizationLevelSize = 1,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, CompileSymbolVisibility) {
|
||||
CompileSymbolVisibilityDefault = 0,
|
||||
CompileSymbolVisibilityHidden = 1,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, MathMode) {
|
||||
MathModeSafe = 0,
|
||||
MathModeRelaxed = 1,
|
||||
MathModeFast = 2,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::Integer, MathFloatingPointFunctions) {
|
||||
MathFloatingPointFunctionsFast = 0,
|
||||
MathFloatingPointFunctionsPrecise = 1,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, LibraryError) {
|
||||
LibraryErrorUnsupported = 1,
|
||||
LibraryErrorInternal = 2,
|
||||
LibraryErrorCompileFailure = 3,
|
||||
LibraryErrorCompileWarning = 4,
|
||||
LibraryErrorFunctionNotFound = 5,
|
||||
LibraryErrorFileNotFound = 6,
|
||||
};
|
||||
|
||||
using AutoreleasedArgument = MTL::Argument*;
|
||||
using FunctionCompletionHandlerFunction = std::function<void(MTL::Function* pFunction, NS::Error* pError)>;
|
||||
|
||||
class VertexAttribute : public NS::Referencing<VertexAttribute>
|
||||
{
|
||||
public:
|
||||
[[deprecated("please use isActive instead")]]
|
||||
bool active() const;
|
||||
|
||||
static VertexAttribute* alloc();
|
||||
|
||||
NS::UInteger attributeIndex() const;
|
||||
|
||||
DataType attributeType() const;
|
||||
|
||||
VertexAttribute* init();
|
||||
|
||||
bool isActive() const;
|
||||
|
||||
bool isPatchControlPointData() const;
|
||||
|
||||
bool isPatchData() const;
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
[[deprecated("please use isPatchControlPointData instead")]]
|
||||
bool patchControlPointData() const;
|
||||
|
||||
[[deprecated("please use isPatchData instead")]]
|
||||
bool patchData() const;
|
||||
};
|
||||
class Attribute : public NS::Referencing<Attribute>
|
||||
{
|
||||
public:
|
||||
[[deprecated("please use isActive instead")]]
|
||||
bool active() const;
|
||||
|
||||
static Attribute* alloc();
|
||||
|
||||
NS::UInteger attributeIndex() const;
|
||||
|
||||
DataType attributeType() const;
|
||||
|
||||
Attribute* init();
|
||||
|
||||
bool isActive() const;
|
||||
|
||||
bool isPatchControlPointData() const;
|
||||
|
||||
bool isPatchData() const;
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
[[deprecated("please use isPatchControlPointData instead")]]
|
||||
bool patchControlPointData() const;
|
||||
|
||||
[[deprecated("please use isPatchData instead")]]
|
||||
bool patchData() const;
|
||||
};
|
||||
class FunctionConstant : public NS::Referencing<FunctionConstant>
|
||||
{
|
||||
public:
|
||||
static FunctionConstant* alloc();
|
||||
|
||||
NS::UInteger index() const;
|
||||
|
||||
FunctionConstant* init();
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
bool required() const;
|
||||
|
||||
DataType type() const;
|
||||
};
|
||||
class Function : public NS::Referencing<Function>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
NS::Dictionary* functionConstantsDictionary() const;
|
||||
|
||||
FunctionType functionType() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
NS::String* name() const;
|
||||
|
||||
ArgumentEncoder* newArgumentEncoder(NS::UInteger bufferIndex);
|
||||
ArgumentEncoder* newArgumentEncoder(NS::UInteger bufferIndex, const MTL::AutoreleasedArgument* reflection);
|
||||
|
||||
FunctionOptions options() const;
|
||||
|
||||
NS::Integer patchControlPointCount() const;
|
||||
|
||||
PatchType patchType() const;
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
NS::Array* stageInputAttributes() const;
|
||||
|
||||
NS::Array* vertexAttributes() const;
|
||||
};
|
||||
class CompileOptions : public NS::Copying<CompileOptions>
|
||||
{
|
||||
public:
|
||||
static CompileOptions* alloc();
|
||||
|
||||
bool allowReferencingUndefinedSymbols() const;
|
||||
|
||||
CompileSymbolVisibility compileSymbolVisibility() const;
|
||||
|
||||
bool enableLogging() const;
|
||||
|
||||
bool fastMathEnabled() const;
|
||||
|
||||
CompileOptions* init();
|
||||
|
||||
NS::String* installName() const;
|
||||
|
||||
LanguageVersion languageVersion() const;
|
||||
|
||||
NS::Array* libraries() const;
|
||||
|
||||
LibraryType libraryType() const;
|
||||
|
||||
MathFloatingPointFunctions mathFloatingPointFunctions() const;
|
||||
|
||||
MathMode mathMode() const;
|
||||
|
||||
NS::UInteger maxTotalThreadsPerThreadgroup() const;
|
||||
|
||||
LibraryOptimizationLevel optimizationLevel() const;
|
||||
|
||||
NS::Dictionary* preprocessorMacros() const;
|
||||
|
||||
bool preserveInvariance() const;
|
||||
|
||||
Size requiredThreadsPerThreadgroup() const;
|
||||
|
||||
void setAllowReferencingUndefinedSymbols(bool allowReferencingUndefinedSymbols);
|
||||
|
||||
void setCompileSymbolVisibility(MTL::CompileSymbolVisibility compileSymbolVisibility);
|
||||
|
||||
void setEnableLogging(bool enableLogging);
|
||||
|
||||
void setFastMathEnabled(bool fastMathEnabled);
|
||||
|
||||
void setInstallName(const NS::String* installName);
|
||||
|
||||
void setLanguageVersion(MTL::LanguageVersion languageVersion);
|
||||
|
||||
void setLibraries(const NS::Array* libraries);
|
||||
|
||||
void setLibraryType(MTL::LibraryType libraryType);
|
||||
|
||||
void setMathFloatingPointFunctions(MTL::MathFloatingPointFunctions mathFloatingPointFunctions);
|
||||
|
||||
void setMathMode(MTL::MathMode mathMode);
|
||||
|
||||
void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup);
|
||||
|
||||
void setOptimizationLevel(MTL::LibraryOptimizationLevel optimizationLevel);
|
||||
|
||||
void setPreprocessorMacros(const NS::Dictionary* preprocessorMacros);
|
||||
|
||||
void setPreserveInvariance(bool preserveInvariance);
|
||||
|
||||
void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup);
|
||||
};
|
||||
class FunctionReflection : public NS::Referencing<FunctionReflection>
|
||||
{
|
||||
public:
|
||||
static FunctionReflection* alloc();
|
||||
|
||||
NS::Array* bindings() const;
|
||||
|
||||
FunctionReflection* init();
|
||||
};
|
||||
class Library : public NS::Referencing<Library>
|
||||
{
|
||||
public:
|
||||
Device* device() const;
|
||||
|
||||
NS::Array* functionNames() const;
|
||||
|
||||
NS::String* installName() const;
|
||||
|
||||
NS::String* label() const;
|
||||
|
||||
Function* newFunction(const NS::String* functionName);
|
||||
Function* newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, NS::Error** error);
|
||||
void newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, void (^completionHandler)(MTL::Function*, NS::Error*));
|
||||
void newFunction(const MTL::FunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*));
|
||||
Function* newFunction(const MTL::FunctionDescriptor* descriptor, NS::Error** error);
|
||||
void newFunction(const NS::String* pFunctionName, const MTL::FunctionConstantValues* pConstantValues, const MTL::FunctionCompletionHandlerFunction& completionHandler);
|
||||
void newFunction(const MTL::FunctionDescriptor* pDescriptor, const MTL::FunctionCompletionHandlerFunction& completionHandler);
|
||||
|
||||
void newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*));
|
||||
Function* newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, NS::Error** error);
|
||||
void newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* pDescriptor, const MTL::FunctionCompletionHandlerFunction& completionHandler);
|
||||
|
||||
FunctionReflection* reflectionForFunction(const NS::String* functionName);
|
||||
|
||||
void setLabel(const NS::String* label);
|
||||
|
||||
LibraryType type() const;
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE bool MTL::VertexAttribute::active() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::VertexAttribute* MTL::VertexAttribute::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::VertexAttribute>(_MTL_PRIVATE_CLS(MTLVertexAttribute));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::VertexAttribute::attributeIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(attributeIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::VertexAttribute::attributeType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(attributeType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::VertexAttribute* MTL::VertexAttribute::init()
|
||||
{
|
||||
return NS::Object::init<MTL::VertexAttribute>();
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::VertexAttribute::isActive() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::VertexAttribute::isPatchControlPointData() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchControlPointData));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::VertexAttribute::isPatchData() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchData));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::VertexAttribute::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::VertexAttribute::patchControlPointData() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchControlPointData));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::VertexAttribute::patchData() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchData));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Attribute::active() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Attribute* MTL::Attribute::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::Attribute>(_MTL_PRIVATE_CLS(MTLAttribute));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::Attribute::attributeIndex() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(attributeIndex));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::Attribute::attributeType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(attributeType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Attribute* MTL::Attribute::init()
|
||||
{
|
||||
return NS::Object::init<MTL::Attribute>();
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Attribute::isActive() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Attribute::isPatchControlPointData() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchControlPointData));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Attribute::isPatchData() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchData));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Attribute::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Attribute::patchControlPointData() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchControlPointData));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::Attribute::patchData() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchData));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionConstant* MTL::FunctionConstant::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::FunctionConstant>(_MTL_PRIVATE_CLS(MTLFunctionConstant));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::FunctionConstant::index() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(index));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionConstant* MTL::FunctionConstant::init()
|
||||
{
|
||||
return NS::Object::init<MTL::FunctionConstant>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::FunctionConstant::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::FunctionConstant::required() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(required));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::DataType MTL::FunctionConstant::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::Function::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Dictionary* MTL::Function::functionConstantsDictionary() const
|
||||
{
|
||||
return Object::sendMessage<NS::Dictionary*>(this, _MTL_PRIVATE_SEL(functionConstantsDictionary));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionType MTL::Function::functionType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionType>(this, _MTL_PRIVATE_SEL(functionType));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Function::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Function::name() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArgumentEncoder* MTL::Function::newArgumentEncoder(NS::UInteger bufferIndex)
|
||||
{
|
||||
return Object::sendMessage<MTL::ArgumentEncoder*>(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithBufferIndex_), bufferIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::ArgumentEncoder* MTL::Function::newArgumentEncoder(NS::UInteger bufferIndex, const MTL::AutoreleasedArgument* reflection)
|
||||
{
|
||||
return Object::sendMessage<MTL::ArgumentEncoder*>(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithBufferIndex_reflection_), bufferIndex, reflection);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionOptions MTL::Function::options() const
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionOptions>(this, _MTL_PRIVATE_SEL(options));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Integer MTL::Function::patchControlPointCount() const
|
||||
{
|
||||
return Object::sendMessage<NS::Integer>(this, _MTL_PRIVATE_SEL(patchControlPointCount));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::PatchType MTL::Function::patchType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::PatchType>(this, _MTL_PRIVATE_SEL(patchType));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Function::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::Function::stageInputAttributes() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(stageInputAttributes));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::Function::vertexAttributes() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexAttributes));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CompileOptions* MTL::CompileOptions::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::CompileOptions>(_MTL_PRIVATE_CLS(MTLCompileOptions));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CompileOptions::allowReferencingUndefinedSymbols() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(allowReferencingUndefinedSymbols));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CompileSymbolVisibility MTL::CompileOptions::compileSymbolVisibility() const
|
||||
{
|
||||
return Object::sendMessage<MTL::CompileSymbolVisibility>(this, _MTL_PRIVATE_SEL(compileSymbolVisibility));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CompileOptions::enableLogging() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(enableLogging));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CompileOptions::fastMathEnabled() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(fastMathEnabled));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::CompileOptions* MTL::CompileOptions::init()
|
||||
{
|
||||
return NS::Object::init<MTL::CompileOptions>();
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::CompileOptions::installName() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(installName));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LanguageVersion MTL::CompileOptions::languageVersion() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LanguageVersion>(this, _MTL_PRIVATE_SEL(languageVersion));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::CompileOptions::libraries() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(libraries));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LibraryType MTL::CompileOptions::libraryType() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LibraryType>(this, _MTL_PRIVATE_SEL(libraryType));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::MathFloatingPointFunctions MTL::CompileOptions::mathFloatingPointFunctions() const
|
||||
{
|
||||
return Object::sendMessage<MTL::MathFloatingPointFunctions>(this, _MTL_PRIVATE_SEL(mathFloatingPointFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::MathMode MTL::CompileOptions::mathMode() const
|
||||
{
|
||||
return Object::sendMessage<MTL::MathMode>(this, _MTL_PRIVATE_SEL(mathMode));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::UInteger MTL::CompileOptions::maxTotalThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LibraryOptimizationLevel MTL::CompileOptions::optimizationLevel() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LibraryOptimizationLevel>(this, _MTL_PRIVATE_SEL(optimizationLevel));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Dictionary* MTL::CompileOptions::preprocessorMacros() const
|
||||
{
|
||||
return Object::sendMessage<NS::Dictionary*>(this, _MTL_PRIVATE_SEL(preprocessorMacros));
|
||||
}
|
||||
|
||||
_MTL_INLINE bool MTL::CompileOptions::preserveInvariance() const
|
||||
{
|
||||
return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(preserveInvariance));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Size MTL::CompileOptions::requiredThreadsPerThreadgroup() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setAllowReferencingUndefinedSymbols(bool allowReferencingUndefinedSymbols)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAllowReferencingUndefinedSymbols_), allowReferencingUndefinedSymbols);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setCompileSymbolVisibility(MTL::CompileSymbolVisibility compileSymbolVisibility)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCompileSymbolVisibility_), compileSymbolVisibility);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setEnableLogging(bool enableLogging)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEnableLogging_), enableLogging);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setFastMathEnabled(bool fastMathEnabled)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFastMathEnabled_), fastMathEnabled);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setInstallName(const NS::String* installName)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstallName_), installName);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setLanguageVersion(MTL::LanguageVersion languageVersion)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLanguageVersion_), languageVersion);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setLibraries(const NS::Array* libraries)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLibraries_), libraries);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setLibraryType(MTL::LibraryType libraryType)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLibraryType_), libraryType);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setMathFloatingPointFunctions(MTL::MathFloatingPointFunctions mathFloatingPointFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMathFloatingPointFunctions_), mathFloatingPointFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setMathMode(MTL::MathMode mathMode)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMathMode_), mathMode);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setOptimizationLevel(MTL::LibraryOptimizationLevel optimizationLevel)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOptimizationLevel_), optimizationLevel);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setPreprocessorMacros(const NS::Dictionary* preprocessorMacros)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreprocessorMacros_), preprocessorMacros);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setPreserveInvariance(bool preserveInvariance)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreserveInvariance_), preserveInvariance);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::CompileOptions::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionReflection* MTL::FunctionReflection::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::FunctionReflection>(_MTL_PRIVATE_CLS(MTLFunctionReflection));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::FunctionReflection::bindings() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(bindings));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionReflection* MTL::FunctionReflection::init()
|
||||
{
|
||||
return NS::Object::init<MTL::FunctionReflection>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Device* MTL::Library::device() const
|
||||
{
|
||||
return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::Library::functionNames() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functionNames));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Library::installName() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(installName));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::String* MTL::Library::label() const
|
||||
{
|
||||
return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Function* MTL::Library::newFunction(const NS::String* functionName)
|
||||
{
|
||||
return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(newFunctionWithName_), functionName);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Function* MTL::Library::newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(newFunctionWithName_constantValues_error_), name, constantValues, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Library::newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, void (^completionHandler)(MTL::Function*, NS::Error*))
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newFunctionWithName_constantValues_completionHandler_), name, constantValues, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Library::newFunction(const MTL::FunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*))
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newFunctionWithDescriptor_completionHandler_), descriptor, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Function* MTL::Library::newFunction(const MTL::FunctionDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(newFunctionWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Library::newFunction(const NS::String* pFunctionName, const MTL::FunctionConstantValues* pConstantValues, const MTL::FunctionCompletionHandlerFunction& completionHandler)
|
||||
{
|
||||
__block MTL::FunctionCompletionHandlerFunction blockCompletionHandler = completionHandler;
|
||||
newFunction(pFunctionName, pConstantValues, ^(MTL::Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Library::newFunction(const MTL::FunctionDescriptor* pDescriptor, const MTL::FunctionCompletionHandlerFunction& completionHandler)
|
||||
{
|
||||
__block MTL::FunctionCompletionHandlerFunction blockCompletionHandler = completionHandler;
|
||||
newFunction(pDescriptor, ^(MTL::Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Library::newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*))
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newIntersectionFunctionWithDescriptor_completionHandler_), descriptor, completionHandler);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::Function* MTL::Library::newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, NS::Error** error)
|
||||
{
|
||||
return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(newIntersectionFunctionWithDescriptor_error_), descriptor, error);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Library::newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* pDescriptor, const MTL::FunctionCompletionHandlerFunction& completionHandler)
|
||||
{
|
||||
__block MTL::FunctionCompletionHandlerFunction blockCompletionHandler = completionHandler;
|
||||
newIntersectionFunction(pDescriptor, ^(MTL::Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::FunctionReflection* MTL::Library::reflectionForFunction(const NS::String* functionName)
|
||||
{
|
||||
return Object::sendMessage<MTL::FunctionReflection*>(this, _MTL_PRIVATE_SEL(reflectionForFunctionWithName_), functionName);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::Library::setLabel(const NS::String* label)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LibraryType MTL::Library::type() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LibraryType>(this, _MTL_PRIVATE_SEL(type));
|
||||
}
|
||||
110
dist/include/metal_cpp/Metal/MTLLinkedFunctions.hpp
vendored
Normal file
110
dist/include/metal_cpp/Metal/MTLLinkedFunctions.hpp
vendored
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLLinkedFunctions.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
|
||||
class LinkedFunctions : public NS::Copying<LinkedFunctions>
|
||||
{
|
||||
public:
|
||||
static LinkedFunctions* alloc();
|
||||
|
||||
NS::Array* binaryFunctions() const;
|
||||
NS::Array* functions() const;
|
||||
|
||||
NS::Dictionary* groups() const;
|
||||
|
||||
LinkedFunctions* init();
|
||||
|
||||
static LinkedFunctions* linkedFunctions();
|
||||
|
||||
NS::Array* privateFunctions() const;
|
||||
|
||||
void setBinaryFunctions(const NS::Array* binaryFunctions);
|
||||
|
||||
void setFunctions(const NS::Array* functions);
|
||||
|
||||
void setGroups(const NS::Dictionary* groups);
|
||||
|
||||
void setPrivateFunctions(const NS::Array* privateFunctions);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::LinkedFunctions>(_MTL_PRIVATE_CLS(MTLLinkedFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::LinkedFunctions::binaryFunctions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::LinkedFunctions::functions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functions));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Dictionary* MTL::LinkedFunctions::groups() const
|
||||
{
|
||||
return Object::sendMessage<NS::Dictionary*>(this, _MTL_PRIVATE_SEL(groups));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::init()
|
||||
{
|
||||
return NS::Object::init<MTL::LinkedFunctions>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::linkedFunctions()
|
||||
{
|
||||
return Object::sendMessage<MTL::LinkedFunctions*>(_MTL_PRIVATE_CLS(MTLLinkedFunctions), _MTL_PRIVATE_SEL(linkedFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Array* MTL::LinkedFunctions::privateFunctions() const
|
||||
{
|
||||
return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(privateFunctions));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::LinkedFunctions::setBinaryFunctions(const NS::Array* binaryFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryFunctions_), binaryFunctions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::LinkedFunctions::setFunctions(const NS::Array* functions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctions_), functions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::LinkedFunctions::setGroups(const NS::Dictionary* groups)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setGroups_), groups);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::LinkedFunctions::setPrivateFunctions(const NS::Array* privateFunctions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrivateFunctions_), privateFunctions);
|
||||
}
|
||||
111
dist/include/metal_cpp/Metal/MTLLogState.hpp
vendored
Normal file
111
dist/include/metal_cpp/Metal/MTLLogState.hpp
vendored
Normal file
|
|
@ -0,0 +1,111 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLLogState.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 "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class LogStateDescriptor;
|
||||
_MTL_ENUM(NS::Integer, LogLevel) {
|
||||
LogLevelUndefined = 0,
|
||||
LogLevelDebug = 1,
|
||||
LogLevelInfo = 2,
|
||||
LogLevelNotice = 3,
|
||||
LogLevelError = 4,
|
||||
LogLevelFault = 5,
|
||||
};
|
||||
|
||||
_MTL_ENUM(NS::UInteger, LogStateError) {
|
||||
LogStateErrorInvalidSize = 1,
|
||||
LogStateErrorInvalid = 2,
|
||||
};
|
||||
|
||||
using LogHandlerFunction = std::function<void(NS::String* subsystem, NS::String* category, MTL::LogLevel logLevel, NS::String* message)>;
|
||||
|
||||
_MTL_CONST(NS::ErrorDomain, LogStateErrorDomain);
|
||||
class LogState : public NS::Referencing<LogState>
|
||||
{
|
||||
public:
|
||||
void addLogHandler(void (^block)(NS::String*, NS::String*, MTL::LogLevel, NS::String*));
|
||||
void addLogHandler(const MTL::LogHandlerFunction& handler);
|
||||
};
|
||||
class LogStateDescriptor : public NS::Copying<LogStateDescriptor>
|
||||
{
|
||||
public:
|
||||
static LogStateDescriptor* alloc();
|
||||
|
||||
NS::Integer bufferSize() const;
|
||||
|
||||
LogStateDescriptor* init();
|
||||
|
||||
LogLevel level() const;
|
||||
|
||||
void setBufferSize(NS::Integer bufferSize);
|
||||
|
||||
void setLevel(MTL::LogLevel level);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, LogStateErrorDomain);
|
||||
_MTL_INLINE void MTL::LogState::addLogHandler(void (^block)(NS::String*, NS::String*, MTL::LogLevel, NS::String*))
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addLogHandler_), block);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::LogState::addLogHandler(const MTL::LogHandlerFunction& handler)
|
||||
{
|
||||
__block LogHandlerFunction function = handler;
|
||||
addLogHandler(^void(NS::String* subsystem, NS::String* category, MTL::LogLevel logLevel, NS::String* message) { function(subsystem, category, logLevel, message); });
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LogStateDescriptor* MTL::LogStateDescriptor::alloc()
|
||||
{
|
||||
return NS::Object::alloc<MTL::LogStateDescriptor>(_MTL_PRIVATE_CLS(MTLLogStateDescriptor));
|
||||
}
|
||||
|
||||
_MTL_INLINE NS::Integer MTL::LogStateDescriptor::bufferSize() const
|
||||
{
|
||||
return Object::sendMessage<NS::Integer>(this, _MTL_PRIVATE_SEL(bufferSize));
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LogStateDescriptor* MTL::LogStateDescriptor::init()
|
||||
{
|
||||
return NS::Object::init<MTL::LogStateDescriptor>();
|
||||
}
|
||||
|
||||
_MTL_INLINE MTL::LogLevel MTL::LogStateDescriptor::level() const
|
||||
{
|
||||
return Object::sendMessage<MTL::LogLevel>(this, _MTL_PRIVATE_SEL(level));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::LogStateDescriptor::setBufferSize(NS::Integer bufferSize)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBufferSize_), bufferSize);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::LogStateDescriptor::setLevel(MTL::LogLevel level)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLevel_), level);
|
||||
}
|
||||
83
dist/include/metal_cpp/Metal/MTLParallelRenderCommandEncoder.hpp
vendored
Normal file
83
dist/include/metal_cpp/Metal/MTLParallelRenderCommandEncoder.hpp
vendored
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//
|
||||
// Metal/MTLParallelRenderCommandEncoder.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 "MTLCommandEncoder.hpp"
|
||||
#include "MTLDefines.hpp"
|
||||
#include "MTLHeaderBridge.hpp"
|
||||
#include "MTLPrivate.hpp"
|
||||
#include "MTLRenderPass.hpp"
|
||||
|
||||
namespace MTL
|
||||
{
|
||||
class RenderCommandEncoder;
|
||||
|
||||
class ParallelRenderCommandEncoder : public NS::Referencing<ParallelRenderCommandEncoder, CommandEncoder>
|
||||
{
|
||||
public:
|
||||
RenderCommandEncoder* renderCommandEncoder();
|
||||
|
||||
void setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex);
|
||||
void setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex);
|
||||
|
||||
void setDepthStoreAction(MTL::StoreAction storeAction);
|
||||
void setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
|
||||
|
||||
void setStencilStoreAction(MTL::StoreAction storeAction);
|
||||
void setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
|
||||
};
|
||||
|
||||
}
|
||||
_MTL_INLINE MTL::RenderCommandEncoder* MTL::ParallelRenderCommandEncoder::renderCommandEncoder()
|
||||
{
|
||||
return Object::sendMessage<MTL::RenderCommandEncoder*>(this, _MTL_PRIVATE_SEL(renderCommandEncoder));
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreAction_atIndex_), storeAction, colorAttachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreActionOptions_atIndex_), storeActionOptions, colorAttachmentIndex);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setDepthStoreAction(MTL::StoreAction storeAction)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreAction_), storeAction);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreActionOptions_), storeActionOptions);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setStencilStoreAction(MTL::StoreAction storeAction)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreAction_), storeAction);
|
||||
}
|
||||
|
||||
_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
|
||||
{
|
||||
Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreActionOptions_), storeActionOptions);
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Reference in a new issue