winrt-Windows.Graphics.DirectX.Direct3D11.Interop 3.2.1__tar.gz → 4.1.0__tar.gz

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/LICENSE

@@ -0,0 +1,22 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Copyright (c) 2021-2026 David Lechner <david@pybricks.com>
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+
+include interop.h

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: winrt-Windows.Graphics.DirectX.Direct3D11.Interop
+Version: 4.1.0
+Summary: Creates a Direct3D 11 device, and converts between DXGI devices and surfaces and the IDirect3DDevice and IDirect3DSurface that WinRT APIs take.
+License-Expression: MIT
+Project-URL: Documentation, https://pywinrt.readthedocs.io
+Project-URL: Repository, https://github.com/pywinrt/pywinrt
+Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/interop/winrt-Windows.Graphics.DirectX.Direct3D11.Interop/CHANGELOG.md
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: winrt-runtime<5,>=4.0.0
+Requires-Dist: winrt-Windows.Graphics.DirectX.Direct3D11>=4!10.0.28000.2705
+Dynamic: license-file
+
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Windows.Graphics.DirectX.Direct3D11.Interop
+
+Creates a Direct3D 11 device, and converts between DXGI devices and surfaces and the `IDirect3DDevice` and `IDirect3DSurface` that WinRT APIs take.
+
+This package provides the `winrt.windows.graphics.directx.direct3d11.interop` module.
+
+```
+pip install winrt-Windows.Graphics.DirectX.Direct3D11.Interop
+```
+
+installs it with `winrt-Windows.Graphics.DirectX.Direct3D11`.

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/README.md

@@ -0,0 +1,13 @@
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Windows.Graphics.DirectX.Direct3D11.Interop
+
+Creates a Direct3D 11 device, and converts between DXGI devices and surfaces and the `IDirect3DDevice` and `IDirect3DSurface` that WinRT APIs take.
+
+This package provides the `winrt.windows.graphics.directx.direct3d11.interop` module.
+
+```
+pip install winrt-Windows.Graphics.DirectX.Direct3D11.Interop
+```
+
+installs it with `winrt-Windows.Graphics.DirectX.Direct3D11`.

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/interop.h

@@ -0,0 +1,175 @@
+// WARNING: Please don't edit this file. It was copied from interop/interop.h
+// by scripts/generate-pyproject.py.
+
+// What an interop module needs to exchange WinRT objects and errors with
+// winrt-runtime.
+//
+// An interop module shares no C ABI with the runtime and includes none of its
+// headers. A WinRT object crosses as an interface pointer capsule, which
+// winrt.runtime.interop.as_interface() makes from a projected object and
+// winrt.runtime.interop.wrap_interface() makes a projected object from, and a
+// failed call raises the exception that winrt.runtime.interop.hresult_error()
+// builds. The capsule's name and those three functions are the whole
+// contract, so this header can change freely.
+//
+// scripts/generate-pyproject.py copies this file into each interop package,
+// so that its source distribution builds on its own.
+
+#pragma once
+
+#include <Python.h>
+
+#include <windows.h>
+
+#include <oleauto.h>
+
+#include <cstddef>
+
+namespace interop
+{
+    /// The name every interface pointer capsule carries, in the runtime and in
+    /// every interop module alike. One holds a reference to a COM interface,
+    /// which its destructor releases.
+    inline constexpr char interface_capsule_name[] = "winrt.interface";
+
+    /// Releases the GIL for as long as it is in scope.
+    ///
+    /// A call into an object in another apartment, or one that sends a window
+    /// on another thread a message, waits for that thread, which may itself
+    /// be waiting for the GIL to run a Python handler.
+    class gil_released
+    {
+      public:
+        gil_released() noexcept : state{PyEval_SaveThread()}
+        {
+        }
+
+        gil_released(gil_released const&) = delete;
+        gil_released& operator=(gil_released const&) = delete;
+
+        ~gil_released() noexcept
+        {
+            PyEval_RestoreThread(state);
+        }
+
+      private:
+        PyThreadState* state;
+    };
+
+    /// The destructor of an interface pointer capsule this module made, which
+    /// may hold the last reference to the object.
+    inline void release_interface(PyObject* capsule) noexcept
+    {
+        auto const abi = PyCapsule_GetPointer(capsule, interface_capsule_name);
+        if (!abi)
+        {
+            PyErr_WriteUnraisable(capsule);
+            return;
+        }
+
+        gil_released const guard;
+        static_cast<IUnknown*>(abi)->Release();
+    }
+
+    /// Hands @p abi, and the reference that comes with it, to a new interface
+    /// pointer capsule. The reference is released if that fails.
+    inline PyObject* new_interface_capsule(IUnknown* abi) noexcept
+    {
+        auto const capsule
+            = PyCapsule_New(abi, interface_capsule_name, release_interface);
+        if (!capsule)
+        {
+            abi->Release();
+        }
+
+        return capsule;
+    }
+
+    /// Raises what winrt.runtime.interop.hresult_error() makes of @p hr and
+    /// @p info, the error info of the call that failed with it, which may be
+    /// @c nullptr. The reference to @p info moves in.
+    /// @returns nullptr, for the caller to return.
+    inline PyObject* set_hresult_error(HRESULT hr, IErrorInfo* info) noexcept
+    {
+        auto const capsule = info ? new_interface_capsule(info) : Py_NewRef(Py_None);
+        if (!capsule)
+        {
+            return nullptr;
+        }
+
+        auto const runtime = PyImport_ImportModule("winrt.runtime.interop");
+        if (!runtime)
+        {
+            Py_DECREF(capsule);
+            return nullptr;
+        }
+
+        auto const error = PyObject_CallMethod(
+            runtime, "hresult_error", "lO", static_cast<long>(hr), capsule);
+        Py_DECREF(runtime);
+        Py_DECREF(capsule);
+        if (!error)
+        {
+            return nullptr;
+        }
+
+        PyErr_SetObject(reinterpret_cast<PyObject*>(Py_TYPE(error)), error);
+        Py_DECREF(error);
+
+        return nullptr;
+    }
+
+    /// Raises what winrt.runtime.interop.hresult_error() makes of @p hr and of
+    /// the error info that the call that just failed with it left on this
+    /// thread.
+    /// @returns nullptr, for the caller to return.
+    inline PyObject* set_hresult_error(HRESULT hr) noexcept
+    {
+        // The error info belongs to the thread and the next failure replaces
+        // it, so it is taken before anything else can fail.
+        IErrorInfo* info{};
+        if (GetErrorInfo(0, &info) != S_OK)
+        {
+            info = nullptr;
+        }
+
+        return set_hresult_error(hr, info);
+    }
+
+    /// The @p I interface of what the interface pointer capsule @p capsule
+    /// holds, which the caller owns a reference to.
+    /// @returns false with a Python exception set when @p capsule is not one
+    /// or what it holds does not implement @p I.
+    template<typename I>
+    bool query_capsule(PyObject* capsule, I** result) noexcept
+    {
+        auto const abi = PyCapsule_GetPointer(capsule, interface_capsule_name);
+        if (!abi)
+        {
+            return false;
+        }
+
+        auto const hr = static_cast<IUnknown*>(abi)->QueryInterface(
+            __uuidof(I), reinterpret_cast<void**>(result));
+        if (FAILED(hr))
+        {
+            set_hresult_error(hr);
+            return false;
+        }
+
+        return true;
+    }
+
+    /// The slots of an interop module that has nothing to set up when it is
+    /// executed. It keeps no state, but it exchanges objects and errors with
+    /// winrt-runtime, which refuses any interpreter but the main one, so it
+    /// says the same.
+    inline PyModuleDef_Slot module_slots[]{
+#ifdef Py_mod_multiple_interpreters
+        {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},
+#endif
+#ifdef Py_mod_gil
+        {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+        {}};
+} // namespace interop

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/py.Windows.Graphics.DirectX.Direct3D11.Interop.cpp

@@ -0,0 +1,339 @@
+#include "interop.h"
+
+#include <d3d11.h>
+
+#include <cstdint>
+#include <memory>
+
+#if __has_include("windows.graphics.directx.direct3d11.interop.h")
+#include <windows.graphics.directx.direct3d11.interop.h>
+
+#ifdef __MINGW32__
+// mingw-w64 generates this header from an .idl that is missing this
+// function, so declare it here. Everything else the header needs is
+// there, including the C++ IDirect3DDxgiInterfaceAccess and its uuid.
+extern "C" HRESULT __stdcall CreateDirect3D11SurfaceFromDXGISurface(
+    ::IDXGISurface* dgxiSurface, ::IInspectable** graphicsSurface);
+#endif
+
+#else
+// some environments like MSYS2 don't have the interop header
+#include <dxgi.h>
+#include <inspectable.h>
+#include <unknwn.h>
+
+// https://gist.github.com/kennykerr/15a62c8218254bc908de672e5ed405fa
+
+extern "C"
+{
+    HRESULT __stdcall CreateDirect3D11DeviceFromDXGIDevice(
+        ::IDXGIDevice* dxgiDevice, ::IInspectable** graphicsDevice);
+
+    HRESULT __stdcall CreateDirect3D11SurfaceFromDXGISurface(
+        ::IDXGISurface* dgxiSurface, ::IInspectable** graphicsSurface);
+}
+
+DEFINE_GUID(
+    IID__x_Windows_Graphics_DirectX_Direct3D11_IDirect3DDxgiInterfaceAccess,
+    // clang-format off
+    0xA9B3D012, 0x3DF2, 0x4EE3, 0xB8, 0xD1, 0x86, 0x95, 0xF4, 0x57, 0xD3, 0xC1
+    // clang-format on
+);
+
+namespace Windows::Graphics::DirectX::Direct3D11
+{
+    MIDL_INTERFACE("A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1")
+    IDirect3DDxgiInterfaceAccess : ::IUnknown
+    {
+        virtual HRESULT STDMETHODCALLTYPE GetInterface(
+            REFIID riid, _COM_Outptr_ void** p) noexcept = 0;
+    };
+} // namespace Windows::Graphics::DirectX::Direct3D11
+
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(
+    Windows::Graphics::DirectX::Direct3D11::IDirect3DDxgiInterfaceAccess,
+    // clang-format off
+    0xA9B3D012, 0x3DF2, 0x4EE3, 0xB8, 0xD1, 0x86, 0x95, 0xF4, 0x57, 0xD3, 0xC1
+    // clang-format on
+);
+#endif
+#endif
+
+// https://learn.microsoft.com/en-us/windows/win32/api/windows.graphics.directx.direct3d11.interop/
+
+namespace
+{
+    using ::Windows::Graphics::DirectX::Direct3D11::IDirect3DDxgiInterfaceAccess;
+
+    struct release_com
+    {
+        void operator()(::IUnknown* p) const noexcept
+        {
+            p->Release();
+        }
+    };
+
+    /// Owns a reference to a COM interface, which it releases.
+    template<typename I>
+    using com_owner = std::unique_ptr<I, release_com>;
+
+    PyObject* create_direct3d11_device_from_dxgi_device(
+        PyObject* /*unused*/, PyObject* dxgi_device_obj) noexcept
+    {
+        auto const dxgi_device
+            = static_cast<IDXGIDevice*>(PyLong_AsVoidPtr(dxgi_device_obj));
+        if (!dxgi_device && PyErr_Occurred())
+        {
+            return nullptr;
+        }
+
+        ::IInspectable* d3d_device{};
+
+        auto const hr = CreateDirect3D11DeviceFromDXGIDevice(dxgi_device, &d3d_device);
+        if (FAILED(hr))
+        {
+            return interop::set_hresult_error(hr);
+        }
+
+        return interop::new_interface_capsule(d3d_device);
+    }
+
+    /// PyLong_AsInt32() as Python 3.14 has it, which is how winrt-runtime
+    /// converts an enum that is not a flags enum.
+    /// @returns false with a Python error set.
+    bool as_int32(PyObject* obj, std::int32_t* value) noexcept
+    {
+#if PY_VERSION_HEX >= 0x030E0000
+        return PyLong_AsInt32(obj, value) == 0;
+#else
+        // a long is 32 bits on Windows, so this raises OverflowError for what
+        // does not fit, as PyLong_AsInt32() does
+        auto const result = PyLong_AsLong(obj);
+        if (result == -1 && PyErr_Occurred())
+        {
+            return false;
+        }
+
+        *value = result;
+        return true;
+#endif
+    }
+
+    /// PyLong_AsUInt32() as Python 3.14 has it, which is how winrt-runtime
+    /// converts a flags enum: a negative number raises ValueError and one too
+    /// large OverflowError.
+    /// @returns false with a Python error set.
+    bool as_uint32(PyObject* obj, std::uint32_t* value) noexcept
+    {
+#if PY_VERSION_HEX >= 0x030E0000
+        return PyLong_AsUInt32(obj, value) == 0;
+#else
+        // This goes when the oldest Python supported is 3.14.
+        auto const result = PyLong_AsLongLong(obj);
+        if (result == -1 && PyErr_Occurred())
+        {
+            return false;
+        }
+
+        if (result < 0)
+        {
+            PyErr_SetString(PyExc_ValueError, "Cannot convert negative int");
+            return false;
+        }
+
+        if (result > UINT32_MAX)
+        {
+            PyErr_SetString(
+                PyExc_OverflowError, "Python int too large to convert to C uint32_t");
+            return false;
+        }
+
+        *value = static_cast<std::uint32_t>(result);
+        return true;
+#endif
+    }
+
+    // https://learn.microsoft.com/en-us/windows/win32/api/d3d11/nf-d3d11-d3d11createdevice
+    PyObject* create_direct3d11_device(PyObject* /*unused*/, PyObject* args) noexcept
+    {
+        PyObject* driver_type_obj;
+        PyObject* flags_obj;
+
+        if (!PyArg_ParseTuple(args, "OO", &driver_type_obj, &flags_obj))
+        {
+            return nullptr;
+        }
+
+        std::int32_t driver_type;
+        if (!as_int32(driver_type_obj, &driver_type))
+        {
+            return nullptr;
+        }
+
+        // Only a value of D3D_DRIVER_TYPE may be cast to it. UNKNOWN and
+        // SOFTWARE are among them, and D3D11CreateDevice refuses them, since
+        // there is neither an adapter nor a software rasterizer.
+        if (driver_type < D3D_DRIVER_TYPE_UNKNOWN || driver_type > D3D_DRIVER_TYPE_WARP)
+        {
+            PyErr_Format(
+                PyExc_ValueError,
+                "%d is not a valid D3dDriverType",
+                static_cast<int>(driver_type));
+            return nullptr;
+        }
+
+        std::uint32_t flags;
+        if (!as_uint32(flags_obj, &flags))
+        {
+            return nullptr;
+        }
+
+        ID3D11Device* d3d11_device_abi{};
+        HRESULT hr;
+
+        {
+            // creating a hardware device can take tens of milliseconds
+            interop::gil_released const guard;
+            hr = D3D11CreateDevice(
+                nullptr,
+                static_cast<D3D_DRIVER_TYPE>(driver_type),
+                nullptr,
+                flags,
+                nullptr,
+                0,
+                D3D11_SDK_VERSION,
+                &d3d11_device_abi,
+                nullptr,
+                nullptr);
+        }
+
+        // Neither this nor QueryInterface() sets error info, so whatever is on
+        // the thread was left by some earlier call and is not taken.
+        if (FAILED(hr))
+        {
+            return interop::set_hresult_error(hr, nullptr);
+        }
+
+        // An error is raised before these are released, when the function
+        // returns, so a release cannot replace the error info it takes.
+        com_owner<ID3D11Device> const d3d11_device{d3d11_device_abi};
+
+        IDXGIDevice* dxgi_device_abi{};
+        hr = d3d11_device->QueryInterface(
+            __uuidof(IDXGIDevice), reinterpret_cast<void**>(&dxgi_device_abi));
+        if (FAILED(hr))
+        {
+            return interop::set_hresult_error(hr, nullptr);
+        }
+
+        com_owner<IDXGIDevice> const dxgi_device{dxgi_device_abi};
+
+        ::IInspectable* d3d_device{};
+        hr = CreateDirect3D11DeviceFromDXGIDevice(dxgi_device.get(), &d3d_device);
+        if (FAILED(hr))
+        {
+            return interop::set_hresult_error(hr);
+        }
+
+        return interop::new_interface_capsule(d3d_device);
+    }
+
+    PyObject* create_direct3d11_surface_from_dxgi_surface(
+        PyObject* /*unused*/, PyObject* dxgi_surface_obj) noexcept
+    {
+        auto const dxgi_surface
+            = static_cast<IDXGISurface*>(PyLong_AsVoidPtr(dxgi_surface_obj));
+        if (!dxgi_surface && PyErr_Occurred())
+        {
+            return nullptr;
+        }
+
+        ::IInspectable* d3d_surface{};
+
+        auto const hr
+            = CreateDirect3D11SurfaceFromDXGISurface(dxgi_surface, &d3d_surface);
+        if (FAILED(hr))
+        {
+            return interop::set_hresult_error(hr);
+        }
+
+        return interop::new_interface_capsule(d3d_surface);
+    }
+
+    /// The @p I interface that the Direct3D object in @p capsule wraps, as an
+    /// integer that owns a reference to it.
+    template<typename I>
+    PyObject* get_dxgi_interface(PyObject* capsule) noexcept
+    {
+        IDirect3DDxgiInterfaceAccess* access{};
+        if (!interop::query_capsule(capsule, &access))
+        {
+            return nullptr;
+        }
+
+        I* result{};
+
+        auto const hr
+            = access->GetInterface(__uuidof(I), reinterpret_cast<void**>(&result));
+        access->Release();
+        if (FAILED(hr))
+        {
+            return interop::set_hresult_error(hr);
+        }
+
+        auto const value = PyLong_FromVoidPtr(result);
+        if (!value)
+        {
+            result->Release();
+        }
+
+        return value;
+    }
+
+    PyObject* get_dxgi_device_from_object(
+        PyObject* /*unused*/, PyObject* capsule) noexcept
+    {
+        return get_dxgi_interface<IDXGIDevice>(capsule);
+    }
+
+    PyObject* get_dxgi_surface_from_object(
+        PyObject* /*unused*/, PyObject* capsule) noexcept
+    {
+        return get_dxgi_interface<IDXGISurface>(capsule);
+    }
+
+    PyMethodDef module_methods[]{
+        {"create_direct3d11_device", create_direct3d11_device, METH_VARARGS, nullptr},
+        {"create_direct3d11_device_from_dxgi_device",
+         create_direct3d11_device_from_dxgi_device,
+         METH_O,
+         nullptr},
+        {"create_direct3d11_surface_from_dxgi_surface",
+         create_direct3d11_surface_from_dxgi_surface,
+         METH_O,
+         nullptr},
+        {"get_dxgi_device_from_object", get_dxgi_device_from_object, METH_O, nullptr},
+        {"get_dxgi_surface_from_object", get_dxgi_surface_from_object, METH_O, nullptr},
+        {}};
+
+    PyDoc_STRVAR(
+        module_doc,
+        "Interop functions for use with IDirect3DDevice and IDirect3DSurface.");
+
+    PyModuleDef module_def
+        = {PyModuleDef_HEAD_INIT,
+           "_winrt_windows_graphics_directx_direct3d11_interop",
+           module_doc,
+           0,
+           module_methods,
+           interop::module_slots,
+           nullptr,
+           nullptr,
+           nullptr};
+} // namespace
+
+PyMODINIT_FUNC PyInit__winrt_windows_graphics_directx_direct3d11_interop(void) noexcept
+{
+    return PyModuleDef_Init(&module_def);
+}

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+
+[build-system]
+requires = ["setuptools>=78"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "winrt-Windows.Graphics.DirectX.Direct3D11.Interop"
+description = "Creates a Direct3D 11 device, and converts between DXGI devices and surfaces and the IDirect3DDevice and IDirect3DSurface that WinRT APIs take."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: Free Threading :: 2 - Beta",
+    "Typing :: Typed",
+]
+dynamic = ["version", "dependencies"]
+requires-python = ">=3.11"
+
+[project.urls]
+Documentation = "https://pywinrt.readthedocs.io"
+Repository = "https://github.com/pywinrt/pywinrt"
+Changelog = "https://github.com/pywinrt/pywinrt/blob/main/interop/winrt-Windows.Graphics.DirectX.Direct3D11.Interop/CHANGELOG.md"
+
+[tool.setuptools.dynamic]
+version = { file = "version.txt" }
+dependencies = { file = "requirements.txt" }
+
+[tool.setuptools.packages.find]
+include = ["winrt*"]
+
+[tool.setuptools.package-data]
+"*" = ["*.pyi", "py.typed"]
+
+[tool.cibuildwheel]
+# don't build for PyPy
+skip = "pp*"
+# suppress warnings about ARM64 testing
+test-skip = "*-win_arm64"
+test-command = "python -c \"import winrt._winrt_windows_graphics_directx_direct3d11_interop\""
+
+[tool.cibuildwheel.windows]
+archs = ["x86", "AMD64", "ARM64"]
+# nothing here is copied in after the build, so there is no repair step
+repair-wheel-command = ""

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/requirements.txt

@@ -0,0 +1,4 @@
+# This file is generated by scripts/generate-pyproject.py
+
+winrt-runtime>=4.0.0,<5
+winrt-Windows.Graphics.DirectX.Direct3D11>=4!10.0.28000.2705

{winrt_windows_graphics_directx_direct3d11_interop-3.2.1 → winrt_windows_graphics_directx_direct3d11_interop-4.1.0}/setup.py

@@ -1,16 +1,25 @@
 # WARNING: Please don't edit this file. It was automatically generated.
+# setuptools does not annotate the build_ext methods this file overrides.
+# pyright: reportUnknownMemberType=false
 
 from setuptools import Extension, setup
 from setuptools.command.build_ext import build_ext
-from winrt_sdk import get_include_dirs
+
+INCLUDE_DIRS: list[str] = []
 
 
 class build_ext_ex(build_ext):
-    def build_extension(self, ext):
+    def build_extension(self, ext: Extension) -> None:
+        # nothing in the projection uses dynamic_cast or typeid, so disabling
+        # RTTI costs nothing and makes the module about 15% smaller
         if self.compiler.compiler_type == "msvc":
-            ext.extra_compile_args = ["/std:c++20", "/permissive-"]
+            ext.extra_compile_args = ["/std:c++20", "/permissive-", "/GR-"]
         elif self.compiler.compiler_type == "mingw32":
-            ext.extra_compile_args = ["-std=c++20", "-D_WIN32_WINNT=_WIN32_WINNT_WIN10"]
+            ext.extra_compile_args = [
+                "-std=c++20",
+                "-fno-rtti",
+                "-D_WIN32_WINNT=_WIN32_WINNT_WIN10",
+            ]
             # GCC 15 complains about some things that it didn't in the past
             ext.extra_compile_args += ["-Wno-strict-aliasing", "-Wno-template-body"]
             ext.extra_link_args = ["-loleaut32"]
@@ -26,7 +35,7 @@ setup(
         Extension(
             "winrt._winrt_windows_graphics_directx_direct3d11_interop",
             sources=["py.Windows.Graphics.DirectX.Direct3D11.Interop.cpp"],
-            include_dirs=get_include_dirs(),
+            include_dirs=INCLUDE_DIRS,
             libraries=["windowsapp", "D3D11"],
         )
     ],

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/version.txt

@@ -0,0 +1 @@
+4.1.0

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/winrt/_winrt_windows_graphics_directx_direct3d11_interop.pyi

@@ -0,0 +1,11 @@
+from winrt.runtime.interop import InterfaceCapsule
+
+def create_direct3d11_device(driver_type: int, flags: int, /) -> InterfaceCapsule: ...
+def create_direct3d11_device_from_dxgi_device(
+    dxgi_device: int, /
+) -> InterfaceCapsule: ...
+def create_direct3d11_surface_from_dxgi_surface(
+    dxgi_surface: int, /
+) -> InterfaceCapsule: ...
+def get_dxgi_device_from_object(capsule: InterfaceCapsule, /) -> int: ...
+def get_dxgi_surface_from_object(capsule: InterfaceCapsule, /) -> int: ...

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/winrt/windows/graphics/directx/direct3d11/interop/__init__.py

@@ -0,0 +1,131 @@
+from enum import IntEnum, IntFlag
+from uuid import UUID
+
+import winrt.runtime.interop as _runtime
+import winrt._winrt_windows_graphics_directx_direct3d11_interop as _native
+from winrt.system import Object
+from winrt.windows.graphics.directx.direct3d11 import IDirect3DDevice, IDirect3DSurface
+
+__all__ = [
+    "create_direct3d11_device",
+    "create_direct3d11_device_from_dxgi_device",
+    "create_direct3d11_surface_from_dxgi_surface",
+    "get_dxgi_device_from_object",
+    "get_dxgi_surface_from_object",
+    "D3dDriverType",
+    "D3d11CreateDeviceFlag",
+]
+
+_IID_IINSPECTABLE = UUID("AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90")
+
+
+# https://learn.microsoft.com/en-us/windows/win32/api/d3dcommon/ne-d3dcommon-d3d_driver_type
+# UNKNOWN and SOFTWARE are left out, since they need an adapter or a software
+# rasterizer that create_direct3d11_device() does not take.
+class D3dDriverType(IntEnum):
+    HARDWARE = 1
+    REFERENCE = 2
+    NULL = 3
+    WARP = 5
+
+
+# https://learn.microsoft.com/en-us/windows/win32/api/d3d11/ne-d3d11-d3d11_create_device_flag
+# SWITCH_TO_REF is left out, since Direct3D 11 does not support it.
+class D3d11CreateDeviceFlag(IntFlag):
+    SINGLE_THREADED = 0x1
+    DEBUG = 0x2
+    PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x8
+    BGRA_SUPPORT = 0x20
+    DEBUGGABLE = 0x40
+    PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 0x80
+    DISABLE_GPU_TIMEOUT = 0x100
+    VIDEO_SUPPORT = 0x800
+
+
+def create_direct3d11_device(
+    *,
+    driver_type: D3dDriverType = D3dDriverType.HARDWARE,
+    flags: D3d11CreateDeviceFlag = D3d11CreateDeviceFlag.BGRA_SUPPORT,
+) -> IDirect3DDevice:
+    """
+    Creates a Direct3D 11 device on the default adapter and wraps it in an
+    IDirect3DDevice.
+
+    Args:
+        driver_type: The driver to create the device with.
+        flags: The flags to create the device with. Windows.Graphics.Capture
+            needs BGRA_SUPPORT, which the default includes.
+
+    Returns:
+        A Direct3DDevice instance that wraps the new device.
+    """
+    return _runtime.wrap_interface(
+        _native.create_direct3d11_device(driver_type, flags),
+        IDirect3DDevice,
+    )
+
+
+def create_direct3d11_device_from_dxgi_device(dxgi_device: int, /) -> IDirect3DDevice:
+    """
+    Creates an instance of IDirect3DDevice from an IDXGIDevice.
+
+    Args:
+        dxgi_device (IDXGIDevice*): The IDXGIDevice to create the Direct3DDevice
+            from.
+
+    Returns:
+        A Direct3DDevice instance that wraps the DXGIDevice.
+    """
+    return _runtime.wrap_interface(
+        _native.create_direct3d11_device_from_dxgi_device(dxgi_device),
+        IDirect3DDevice,
+    )
+
+
+def create_direct3d11_surface_from_dxgi_surface(
+    dxgi_surface: int, /
+) -> IDirect3DSurface:
+    """
+    Creates an instance of IDirect3DSurface from an IDXGISurface.
+
+    Args:
+        dxgi_surface (IDXGISurface*): The IDXGISurface to create the
+            Direct3DSurface from.
+
+    Returns:
+        A Direct3DSurface instance that wraps the DXGISurface.
+    """
+    return _runtime.wrap_interface(
+        _native.create_direct3d11_surface_from_dxgi_surface(dxgi_surface),
+        IDirect3DSurface,
+    )
+
+
+def get_dxgi_device_from_object(device: Object, /) -> int:
+    """
+    Retrieves the IDXGIDevice from a Direct3D object.
+
+    Args:
+        device: The WinRT object to retrieve the IDXGIDevice from.
+
+    Returns:
+        Pointer to IDXGIDevice interface of the WinRT object.
+    """
+    return _native.get_dxgi_device_from_object(
+        _runtime.as_interface(device, _IID_IINSPECTABLE)
+    )
+
+
+def get_dxgi_surface_from_object(surface: Object, /) -> int:
+    """
+    Retrieves the IDXGISurface from a Direct3D object.
+
+    Args:
+        surface: The WinRT object to retrieve the IDXGISurface from.
+
+    Returns:
+        Pointer to IDXGISurface interface of the WinRT object.
+    """
+    return _native.get_dxgi_surface_from_object(
+        _runtime.as_interface(surface, _IID_IINSPECTABLE)
+    )

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: winrt-Windows.Graphics.DirectX.Direct3D11.Interop
+Version: 4.1.0
+Summary: Creates a Direct3D 11 device, and converts between DXGI devices and surfaces and the IDirect3DDevice and IDirect3DSurface that WinRT APIs take.
+License-Expression: MIT
+Project-URL: Documentation, https://pywinrt.readthedocs.io
+Project-URL: Repository, https://github.com/pywinrt/pywinrt
+Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/interop/winrt-Windows.Graphics.DirectX.Direct3D11.Interop/CHANGELOG.md
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: winrt-runtime<5,>=4.0.0
+Requires-Dist: winrt-Windows.Graphics.DirectX.Direct3D11>=4!10.0.28000.2705
+Dynamic: license-file
+
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Windows.Graphics.DirectX.Direct3D11.Interop
+
+Creates a Direct3D 11 device, and converts between DXGI devices and surfaces and the `IDirect3DDevice` and `IDirect3DSurface` that WinRT APIs take.
+
+This package provides the `winrt.windows.graphics.directx.direct3d11.interop` module.
+
+```
+pip install winrt-Windows.Graphics.DirectX.Direct3D11.Interop
+```
+
+installs it with `winrt-Windows.Graphics.DirectX.Direct3D11`.

{winrt_windows_graphics_directx_direct3d11_interop-3.2.1 → winrt_windows_graphics_directx_direct3d11_interop-4.1.0}/winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/SOURCES.txt

@@ -1,12 +1,17 @@
+LICENSE
+MANIFEST.in
 README.md
+interop.h
 py.Windows.Graphics.DirectX.Direct3D11.Interop.cpp
 pyproject.toml
-pywinrt-version.txt
+requirements.txt
 setup.py
+version.txt
 winrt/_winrt_windows_graphics_directx_direct3d11_interop.pyi
 winrt/windows/graphics/directx/direct3d11/interop/__init__.py
 winrt/windows/graphics/directx/direct3d11/interop/py.typed
 winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/PKG-INFO
 winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/SOURCES.txt
 winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/dependency_links.txt
+winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/requires.txt
 winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/top_level.txt

winrt_windows_graphics_directx_direct3d11_interop-4.1.0/winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/requires.txt

@@ -0,0 +1,2 @@
+winrt-runtime<5,>=4.0.0
+winrt-Windows.Graphics.DirectX.Direct3D11>=4!10.0.28000.2705

winrt_windows_graphics_directx_direct3d11_interop-3.2.1/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.4
-Name: winrt-Windows.Graphics.DirectX.Direct3D11.Interop
-Version: 3.2.1
-Summary: Python projection of Windows Runtime (WinRT) APIs
-License-Expression: MIT
-Project-URL: Documentation, https://pywinrt.readthedocs.io
-Project-URL: Repository, https://github.com/pywinrt/pywinrt
-Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Intended Audience :: Developers
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-
-<!-- warning: Please don't edit this file. It was automatically generated. -->
-
-# winrt-Windows.Graphics.DirectX.Direct3D11.Interop
-
-Windows Runtime (WinRT) APIs for for the `Windows.Graphics.DirectX.Direct3D11.Interop` namespace.
-
-This package provides the `winrt.windows.graphics.directx.direct3d11.interop` module.

winrt_windows_graphics_directx_direct3d11_interop-3.2.1/README.md

@@ -1,7 +0,0 @@
-<!-- warning: Please don't edit this file. It was automatically generated. -->
-
-# winrt-Windows.Graphics.DirectX.Direct3D11.Interop
-
-Windows Runtime (WinRT) APIs for for the `Windows.Graphics.DirectX.Direct3D11.Interop` namespace.
-
-This package provides the `winrt.windows.graphics.directx.direct3d11.interop` module.

winrt_windows_graphics_directx_direct3d11_interop-3.2.1/py.Windows.Graphics.DirectX.Direct3D11.Interop.cpp

@@ -1,217 +0,0 @@
-#if __has_include("windows.graphics.directx.direct3d11.interop.h")
-#include <windows.graphics.directx.direct3d11.interop.h>
-#else
-// some environments like MSYS2 don't have the interop header
-#include <dxgi.h>
-#include <inspectable.h>
-#include <unknwn.h>
-
-// https://gist.github.com/kennykerr/15a62c8218254bc908de672e5ed405fa
-
-extern "C"
-{
-    HRESULT __stdcall CreateDirect3D11DeviceFromDXGIDevice(
-        ::IDXGIDevice* dxgiDevice, ::IInspectable** graphicsDevice);
-
-    HRESULT __stdcall CreateDirect3D11SurfaceFromDXGISurface(
-        ::IDXGISurface* dgxiSurface, ::IInspectable** graphicsSurface);
-}
-
-DEFINE_GUID(
-    IID__x_Windows_Graphics_DirectX_Direct3D11_IDirect3DDxgiInterfaceAccess,
-    // clang-format off
-    0xA9B3D012, 0x3DF2, 0x4EE3, 0xB8, 0xD1, 0x86, 0x95, 0xF4, 0x57, 0xD3, 0xC1
-    // clang-format on
-);
-
-namespace Windows::Graphics::DirectX::Direct3D11
-{
-    MIDL_INTERFACE("A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1")
-    IDirect3DDxgiInterfaceAccess : ::IUnknown
-    {
-        virtual HRESULT STDMETHODCALLTYPE GetInterface(
-            REFIID riid, _COM_Outptr_ void** p) noexcept
-            = 0;
-    };
-} // namespace Windows::Graphics::DirectX::Direct3D11
-
-#ifdef __CRT_UUID_DECL
-__CRT_UUID_DECL(
-    Windows::Graphics::DirectX::Direct3D11::IDirect3DDxgiInterfaceAccess,
-    // clang-format off
-    0xA9B3D012, 0x3DF2, 0x4EE3, 0xB8, 0xD1, 0x86, 0x95, 0xF4, 0x57, 0xD3, 0xC1
-    // clang-format on
-);
-#endif
-#endif
-
-#include <winrt/Windows.Graphics.DirectX.Direct3D11.h>
-#include "pybase.h"
-#include "py.Windows.Graphics.DirectX.Direct3D11.h"
-
-// https://learn.microsoft.com/en-us/windows/win32/api/windows.graphics.directx.direct3d11.interop/
-
-namespace py::cpp::Windows::Graphics::DirectX::Direct3D11::Interop
-{
-    static PyObject* create_direct3d11_device_from_dxgi_device(
-        PyObject* /*unused*/, PyObject* dxgi_device_obj) noexcept
-    {
-        try
-        {
-            auto dxgi_device
-                = reinterpret_cast<IDXGIDevice*>(PyLong_AsVoidPtr(dxgi_device_obj));
-
-            if (!dxgi_device && PyErr_Occurred())
-            {
-                return nullptr;
-            }
-
-            winrt::com_ptr<::IInspectable> d3d_device;
-            winrt::check_hresult(
-                CreateDirect3D11DeviceFromDXGIDevice(dxgi_device, d3d_device.put()));
-
-            return py::convert(
-                d3d_device.as<
-                    winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice>());
-        }
-        catch (...)
-        {
-            py::to_PyErr();
-            return nullptr;
-        }
-    }
-
-    PyDoc_STRVAR(
-        create_direct3d11_device_from_dxgi_device_doc,
-        R"(Creates an instance of IDirect3DDevice from an IDXGIDevice.
-
-Args:
-    dxgi_device (IDXGIDevice*): The IDXGIDevice to create the Direct3DDevice from.
-
-Returns:
-    A Direct3DDevice instance that wraps the DXGIDevice.
-)");
-
-    static PyObject* create_direct3d11_surface_from_dxgi_surface(
-        PyObject* /*unused*/, PyObject* dxgi_surface_obj) noexcept
-    {
-        try
-        {
-            auto dxgi_surface
-                = reinterpret_cast<IDXGISurface*>(PyLong_AsVoidPtr(dxgi_surface_obj));
-
-            if (!dxgi_surface && PyErr_Occurred())
-            {
-                return nullptr;
-            }
-
-            winrt::com_ptr<::IInspectable> d3d_surface;
-            winrt::check_hresult(CreateDirect3D11SurfaceFromDXGISurface(
-                dxgi_surface, d3d_surface.put()));
-
-            return py::convert(
-                d3d_surface.as<
-                    winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DSurface>());
-        }
-        catch (...)
-        {
-            py::to_PyErr();
-            return nullptr;
-        }
-    }
-
-    PyDoc_STRVAR(
-        create_direct3d11_surface_from_dxgi_surface_doc,
-        R"(Creates an instance of IDirect3DSurface from an IDXGISurface.
-
-Args:
-    dxgi_surface (IDXGISurface*): The IDXGISurface to create the Direct3DSurface from.
-
-Returns:
-    A Direct3DSurface instance that wraps the DXGISurface.
-)");
-
-    static PyObject* get_dxgi_device_from_object(
-        PyObject* /*unused*/, PyObject* py_obj) noexcept
-    {
-        try
-        {
-            auto object
-                = py::convert_to<winrt::Windows::Foundation::IInspectable>(py_obj);
-            auto access = object.as<::Windows::Graphics::DirectX::Direct3D11::
-                                        IDirect3DDxgiInterfaceAccess>();
-            winrt::com_ptr<IDXGIDevice> result;
-            winrt::check_hresult(
-                access->GetInterface(winrt::guid_of<IDXGIDevice>(), result.put_void()));
-
-            return PyLong_FromVoidPtr(result.detach());
-        }
-        catch (...)
-        {
-            py::to_PyErr();
-            return nullptr;
-        }
-    }
-
-    static PyObject* get_dxgi_surface_from_object(
-        PyObject* /*unused*/, PyObject* py_obj) noexcept
-    {
-        try
-        {
-            auto object
-                = py::convert_to<winrt::Windows::Foundation::IInspectable>(py_obj);
-            auto access = object.as<::Windows::Graphics::DirectX::Direct3D11::
-                                        IDirect3DDxgiInterfaceAccess>();
-            winrt::com_ptr<IDXGISurface> result;
-            winrt::check_hresult(access->GetInterface(
-                winrt::guid_of<IDXGISurface>(), result.put_void()));
-
-            return PyLong_FromVoidPtr(result.detach());
-        }
-        catch (...)
-        {
-            py::to_PyErr();
-            return nullptr;
-        }
-    }
-
-    static PyMethodDef module_methods[]{
-        {"create_direct3d11_device_from_dxgi_device",
-         create_direct3d11_device_from_dxgi_device,
-         METH_O,
-         create_direct3d11_device_from_dxgi_device_doc},
-        {"create_direct3d11_surface_from_dxgi_surface",
-         create_direct3d11_surface_from_dxgi_surface,
-         METH_O,
-         create_direct3d11_surface_from_dxgi_surface_doc},
-        {"get_dxgi_device_from_object", get_dxgi_device_from_object, METH_O, nullptr},
-        {"get_dxgi_surface_from_object", get_dxgi_surface_from_object, METH_O, nullptr},
-        {}};
-
-    PyDoc_STRVAR(
-        module_doc,
-        "Interop functions for use with IDirect3DDevice and IDirect3DSurface.");
-
-    static PyModuleDef module_def
-        = {PyModuleDef_HEAD_INIT,
-           "_winrt_windows_graphics_directx_direct3d11_interop",
-           module_doc,
-           0,
-           module_methods,
-           nullptr,
-           nullptr,
-           nullptr,
-           nullptr};
-} // namespace py::cpp::Windows::Graphics::DirectX::Direct3D11::Interop
-
-PyMODINIT_FUNC PyInit__winrt_windows_graphics_directx_direct3d11_interop(void) noexcept
-{
-    using namespace py::cpp::Windows::Graphics::DirectX::Direct3D11::Interop;
-
-    if (py::import_winrt_runtime() == -1)
-    {
-        return nullptr;
-    }
-
-    return PyModule_Create(&module_def);
-}

winrt_windows_graphics_directx_direct3d11_interop-3.2.1/pyproject.toml

@@ -1,45 +0,0 @@
-# WARNING: Please don't edit this file. It was automatically generated.
-
-[build-system]
-requires = ["setuptools>=78", "winrt-sdk"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "winrt-Windows.Graphics.DirectX.Direct3D11.Interop"
-description = "Python projection of Windows Runtime (WinRT) APIs"
-readme = "README.md"
-license = "MIT"
-classifiers = [
-    "Operating System :: Microsoft :: Windows",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: Implementation :: CPython",
-    "Intended Audience :: Developers",
-]
-dynamic = ["version"]
-requires-python = ">=3.9"
-
-[project.urls]
-# Homepage = "https://github.com/pywinrt/pywinrt"
-Documentation = "https://pywinrt.readthedocs.io"
-Repository = "https://github.com/pywinrt/pywinrt"
-Changelog = "https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md"
-
-[tool.setuptools.dynamic]
-version = { file = "pywinrt-version.txt" }
-
-[tool.setuptools.package-data]
-"*" = ["*.pyi", "py.typed"]
-
-[tool.cibuildwheel]
-# use local winrt-sdk build dependency
-environment = { PYTHONPATH="../../winrt-sdk/src" }
-# don't install winrt-sdk from PyPI
-build-frontend = { name = "build[uv]", args = ["--skip-dependency-check", "--no-isolation"] }
-before-build = "uv pip install setuptools"
-# don't build for PyPy
-skip = "pp*"
-# suppress warnings about ARM64 testing
-test-skip = "*-win_arm64"
-
-[tool.cibuildwheel.windows]
-archs = ["x86", "AMD64", "ARM64"]

winrt_windows_graphics_directx_direct3d11_interop-3.2.1/pywinrt-version.txt

@@ -1 +0,0 @@
-3.2.1

winrt_windows_graphics_directx_direct3d11_interop-3.2.1/winrt/_winrt_windows_graphics_directx_direct3d11_interop.pyi

@@ -1,46 +0,0 @@
-from winrt.windows.graphics.directx.direct3d11 import IDirect3DDevice
-from winrt.system import Object
-
-def create_direct3d11_device_from_dxgi_device(dxgi_device: int) -> IDirect3DDevice:
-    """
-    Creates an instance of IDirect3DDevice from an IDXGIDevice.
-
-    Args:
-        dxgi_device (IDXGIDevice*): The IDXGIDevice to create the Direct3DDevice from.
-
-    Returns:
-        A Direct3DDevice instance that wraps the DXGIDevice.
-    """
-
-def create_direct3d11_surface_from_dxgi_surface(dxgi_surface: int) -> int:
-    """
-    Creates an instance of IDirect3DSurface from an IDXGISurface.
-
-    Args:
-        dxgi_surface (IDXGISurface*): The IDXGISurface to create the Direct3DSurface from.
-
-    Returns:
-        Pointer to IDirect3DSurface interface of the IDXGISurface.
-    """
-
-def get_dxgi_device_from_object(object: Object) -> int:
-    """
-    Retrieves the IDXGIDevice from a Direct3D object.
-
-    Args:
-        object: The WinRT object to retrieve the IDXGIDevice from.
-
-    Returns:
-        Pointer to IDXGIDevice interface of the WinRT object.
-    """
-
-def get_dxgi_surface_from_object(object: Object) -> int:
-    """
-    Retrieves the IDXGISurface from a Direct3D object.
-
-    Args:
-        object: The WinRT object to retrieve the IDXGISurface from.
-
-    Returns:
-        Pointer to IDXGISurface interface of the WinRT object.
-    """

winrt_windows_graphics_directx_direct3d11_interop-3.2.1/winrt/windows/graphics/directx/direct3d11/interop/__init__.py

@@ -1,13 +0,0 @@
-from winrt._winrt_windows_graphics_directx_direct3d11_interop import (
-    create_direct3d11_device_from_dxgi_device,
-    create_direct3d11_surface_from_dxgi_surface,
-    get_dxgi_device_from_object,
-    get_dxgi_surface_from_object,
-)
-
-__all__ = [
-    "create_direct3d11_device_from_dxgi_device",
-    "create_direct3d11_surface_from_dxgi_surface",
-    "get_dxgi_device_from_object",
-    "get_dxgi_surface_from_object",
-]

winrt_windows_graphics_directx_direct3d11_interop-3.2.1/winrt_Windows.Graphics.DirectX.Direct3D11.Interop.egg-info/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.4
-Name: winrt-Windows.Graphics.DirectX.Direct3D11.Interop
-Version: 3.2.1
-Summary: Python projection of Windows Runtime (WinRT) APIs
-License-Expression: MIT
-Project-URL: Documentation, https://pywinrt.readthedocs.io
-Project-URL: Repository, https://github.com/pywinrt/pywinrt
-Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Intended Audience :: Developers
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-
-<!-- warning: Please don't edit this file. It was automatically generated. -->
-
-# winrt-Windows.Graphics.DirectX.Direct3D11.Interop
-
-Windows Runtime (WinRT) APIs for for the `Windows.Graphics.DirectX.Direct3D11.Interop` namespace.
-
-This package provides the `winrt.windows.graphics.directx.direct3d11.interop` module.