@babylonjs/react-native 2.0.0 → 2.0.1

package/shared/BabylonNative/deps/metal-cpp-src/Metal/MTL4LibraryDescriptor.hpp

@@ -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));
+}

package/shared/BabylonNative/deps/metal-cpp-src/Metal/MTL4LibraryFunctionDescriptor.hpp

@@ -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);
+}

package/shared/BabylonNative/deps/metal-cpp-src/Metal/MTL4LinkingDescriptor.hpp

@@ -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));
+}

package/shared/BabylonNative/deps/metal-cpp-src/Metal/MTL4MachineLearningCommandEncoder.hpp

@@ -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);
+}

package/shared/BabylonNative/deps/metal-cpp-src/Metal/MTL4MachineLearningPipeline.hpp

@@ -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));
+}