DirectX 12 Header

[SonnyBoyPro]

Hallo zusammen,

da mir am verlängerten Wochenende fad war, hab ich die DirectX 12 Header aus der aktuellen SDK 10.0.10075.0 nach Pascal transferiert.
Mit dabei sind auch meine 10er und 11er Header, weil die Versionen von JSB unter FPC nicht funktionieren (kein Corba-Interface).

Über Rückmeldungen würde ich mich freuen!

Viel Spaß!

PS: getestet sind sie die 12er Units noch nicht, da ich zur zeit noch mit Win7 und DX11 arbeite. Aber Win10 ist in der virtuellen Maschine schon installiert, vielleicht folgt ja ein Code-Beispiel in den nächsten Tagen :)
Zumindest meldet Delphi 2010 und FPC aber mal keinen Fehler 8-)

[Medium]

Ich bin zwar leider schon ein paar Jahre aus dem Thema raus, aber ich will dir trotzdem sehr herzlich danken!

Ich kann mich noch SEHR gut daran erinnern, wie schwer es damals war brauchbare Header für Delphi zu bekommen. Der ganze Themenkomplex DirectX scheint selten mit Delphi in Berührung zu kommen, von daher ist dies eine sehr willkommene Rarität! Auch wenn ich nicht glaube, dass hier überhaupt jemand mit nacktem DX arbeitet. Mit Delphi kaum wer, daher sei nicht traurig, wenn hier vermutlich nicht allzuviel Response kommt. Die, die es wirklich suchen und brauchen aber werden Luftsprünge machen :party:

[TiGü]

Großartige Arbeit, das war bestimmt aufwendiger als man denkt.

Ich wollte es gerade mal ein bisschen testen, aber irgendetwas bringt mein XE7 aus den Tritt:

Code:

[dcc32 Error] D2D1.pas(2819): E2003 Undeclared identifier: 'PWICImageParameters'
[dcc32 Error] D2D1.pas(2821): E2005 'PWICImageParameters' is not a type identifier
[dcc32 Error] D2D1.pas(2822): E2005 'PWICImageParameters' is not a type identifier

Delphi-Quellcode:

    { part of WinCodec.h, but cross reference problem }

    IWICImageEncoder = interface(IUnknown)
        ['{04C75BF8-3CE1-473B-ACC5-3CC4F5E94999}']
        function WriteFrame(pImage: ID2D1Image; pFrameEncode: IWICBitmapFrameEncode;
            pImageParameters: PWICImageParameters): HResult; stdcall;
        function WriteFrameThumbnail(pImage: ID2D1Image; pFrameEncode: IWICBitmapFrameEncode;
            pImageParameters: PWICImageParameters): HResult; stdcall;
        function WriteThumbnail(pImage: ID2D1Image; pEncoder: IWICBitmapEncoder; pImageParameters: PWICImageParameters): HResult; stdcall;
    end;

Was aber merkwürdig ist, weil per Strg+Linksklick oder "Find Declaration" richtig zur Zeile 605 in deiner WinCodec.pas gesprungen wird.
Verstehe ich am heutigen Morgen mit nur einen Kaffee noch nicht.

Gab es einen speziellen Grund dafür, dass du den const-Parameter für Interfaces und Records weggelassen hast?

[SonnyBoyPro]

Eigentlich nicht,
ich hab versucht die Headers 1:1 zu übersetzen.

Bei den JSB sind einige Funktionen denen lt. MSDN Arrays übergeben werden (eigentlich Zeiger auf das erste Element) als einfache Typen
deklariert.

In FPC wäre die Routine so möglich:

Delphi-Quellcode:

 { part of WinCodec.h, but cross reference problem }

    IWICImageEncoder = interface(IUnknown)
        ['{04C75BF8-3CE1-473B-ACC5-3CC4F5E94999}']
        function WriteFrame(pImage: ID2D1Image; pFrameEncode: IWICBitmapFrameEncode;
            const pImageParameters: TWICImageParameters): HResult; stdcall;
        function WriteFrameThumbnail(pImage: ID2D1Image; pFrameEncode: IWICBitmapFrameEncode;
            const pImageParameters: TWICImageParameters): HResult; stdcall;
        function WriteThumbnail(pImage: ID2D1Image; pEncoder: IWICBitmapEncoder; const pImageParameters: TWICImageParameters): HResult; stdcall;
    end;

da FPC davon ausgeht das bei StdCall CONST Parameter by Referenz übergeben werden.

Auch wenn speziell die Übergabe von Arrays als Pointer bei FPC irgendwie "anders" ist sollte obiges bei Delphi auch gleich funktionieren?

[SonnyBoyPro]

Bin gerade noch auf einen Fehler in IWICImagingFactory2 draufgekommen

Delphi-Quellcode:

{ part of WinCodec.h, but cross reference problem }
    IWICImagingFactory2 = interface(IWICImagingFactory)
        ['{7B816B45-1996-4476-B132-DE9E247C8AF0}']
        function CreateImageEncoder(pD2DDevice: ID2D1Device; out ppWICImageEncoder: IWICImageEncoder): HResult; stdcall;
    end;

da fehlte ein "out", da ja der ImageEncoder zurückgegeben wird...

[TiGü]

Hm, merkwürdig...ich habe nur eine Kleinigkeit an den Headern geändert, bspw. den out-Parameter in IWICImagingFactory2.CreateImageEncoder hinzugefügt und schon gibt es eine sehr lange Liste an Fehlermeldungen, dass einige Typen nicht gefunden werden, obwohl die Deklarationsauflösung funktioniert.
Hängt vielleicht mit irgendwelchen IFDEFs zusammen?! Werde ich nicht schlau draus...

Code:

[dcc32 Error] D3D11.pas(737): E2003 Undeclared identifier: 'TDXGI_FORMAT'
[dcc32 Error] D3D11.pas(1027): E2007 Constant or type identifier expected
[dcc32 Error] D3D11.pas(1032): E2005 'TDXGI_FORMAT' is not a type identifier
[dcc32 Error] D3D11.pas(1053): E2007 Constant or type identifier expected
[dcc32 Error] D3D11.pas(1054): E2003 Undeclared identifier: 'TDXGI_SAMPLE_DESC'
[dcc32 Error] D3D11.pas(1059): E2005 'TDXGI_FORMAT' is not a type identifier
[dcc32 Error] D3D11.pas(1080): E2007 Constant or type identifier expected
...
usw.

Zitat:

Eigentlich nicht,
ich hab versucht die Headers 1:1 zu übersetzen.

Die meisten C++-Header sind mit den _In_-Parameter versehen (https://msdn.microsoft.com/en-us/lib...vs.110%29.aspx).
In Delphi würde das meiner Meinung nach am besten mit den const-Parameter übersetzt werden.
Zumindest hat dies Emba auch bei den bisherigen DirectX-Headern so gehalten.
Zum Beispiel hier aus d2d1.h:

Code:

interface DX_DECLARE_INTERFACE("a2296057-ea42-4099-983b-539fb6505426") ID2D1Bitmap  : public ID2D1Image
{
    
    
    //
    // Returns the size of the bitmap in resolution independent units.
    //
    STDMETHOD_(D2D1_SIZE_F, GetSize)(
        ) CONST PURE;
    
    
    //
    // Returns the size of the bitmap in resolution dependent units, (pixels).
    //
    STDMETHOD_(D2D1_SIZE_U, GetPixelSize)(
        ) CONST PURE;
    
    
    //
    // Retrieve the format of the bitmap.
    //
    STDMETHOD_(D2D1_PIXEL_FORMAT, GetPixelFormat)(
        ) CONST PURE;
    
    
    //
    // Return the DPI of the bitmap.
    //
    STDMETHOD_(void, GetDpi)(
        _Out_ FLOAT *dpiX,
        _Out_ FLOAT *dpiY 
        ) CONST PURE;
    
    STDMETHOD(CopyFromBitmap)(
        _In_opt_ CONST D2D1_POINT_2U *destPoint,
        _In_ ID2D1Bitmap *bitmap,
        _In_opt_ CONST D2D1_RECT_U *srcRect 
        ) PURE;
    
    STDMETHOD(CopyFromRenderTarget)(
        _In_opt_ CONST D2D1_POINT_2U *destPoint,
        _In_ ID2D1RenderTarget *renderTarget,
        _In_opt_ CONST D2D1_RECT_U *srcRect 
        ) PURE;
    
    STDMETHOD(CopyFromMemory)(
        _In_opt_ CONST D2D1_RECT_U *dstRect,
        _In_ CONST void *srcData,
        UINT32 pitch 
        ) PURE;
}; // interface ID2D1Bitmap

Dazu das Delphi Gegenstück aus Winapi.D2D1:

Delphi-Quellcode:

// +-----------------------------------------------------------------------------
//
//  Interface:
//      ID2D1Bitmap
//
//  Synopsis:
//      Root bitmap resource, linearly scaled on a draw call.
//
// ------------------------------------------------------------------------------
  {$HPPEMIT 'DECLARE_DINTERFACE_TYPE(ID2D1Bitmap);'}
  ID2D1Bitmap = interface(ID2D1Resource)
    [SID_ID2D1Bitmap]
    // Returns the size of the bitmap in resolution independent units.
    procedure GetSize(out size: TD2D1SizeF); stdcall;

    // Returns the size of the bitmap in resolution dependent units, (pixels).
    procedure GetPixelSize(out pixelSize: TD2D1SizeU); stdcall;

    // Retrieve the format of the bitmap.
    procedure GetPixelFormat(out pixelFormat: TD2D1PixelFormat); stdcall;

    // Return the DPI of the bitmap.
    procedure GetDpi(out dpiX, dpiY: Single); stdcall;

    function CopyFromBitmap(var destPoint: D2D1_POINT_2U; const bitmap: ID2D1Bitmap;
      var srcRect: D2D1_RECT_U): HResult; stdcall;

    function CopyFromRenderTarget(var destPoint: D2D1_POINT_2U;
      const renderTarget: ID2D1RenderTarget; var srcRect: D2D1_RECT_U): HResult; stdcall;

    function CopyFromMemory(var dstRect: D2D1_RECT_U; srcData: Pointer;
      pitch: Cardinal): HResult; stdcall;
  end;
  {$EXTERNALSYM ID2D1Bitmap}

[SonnyBoyPro]

bin gerade (negativ) fasziniert....

hab probiert bei dem ID2D1Bitmap die Deklarationen zu ändern

Delphi-Quellcode:

ID2D1Bitmap = interface(ID2D1Image)
        ['{a2296057-ea42-4099-983b-539fb6505426}']
        function GetSize(): TD2D1_SIZE_F; stdcall;
        function GetPixelSize(): TD2D1_SIZE_U; stdcall;
        function GetPixelFormat(): TD2D1_PIXEL_FORMAT; stdcall;
        procedure GetDpi(out dpiX: single; out dpiY: single); stdcall;
//        function CopyFromBitmap( destPoint: PD2D1_POINT_2U; bitmap: ID2D1Bitmap;  srcRect: PD2D1_RECT_U): HResult; stdcall;  // <- funkt
        function CopyFromBitmap(const destPoint: PD2D1_POINT_2U; bitmap: ID2D1Bitmap; const srcRect: PD2D1_RECT_U): HResult; stdcall;// <- funkt
//        function CopyFromBitmap(const destPoint: TD2D1_POINT_2U; bitmap: ID2D1Bitmap; const srcRect: TD2D1_RECT_U): HResult; stdcall;// <- funkt
//        function CopyFromBitmap(destPoint: TD2D1_POINT_2U; bitmap: ID2D1Bitmap; srcRect: TD2D1_RECT_U): HResult; stdcall;  <- das crasht, weil ja kein Pointer übergeben wird
        function CopyFromRenderTarget(const destPoint: TD2D1_POINT_2U; renderTarget: ID2D1RenderTarget; const srcRect: TD2D1_RECT_U): HResult; stdcall;
        function CopyFromMemory(dstRect: PD2D1_RECT_U; srcData: Pointer; pitch: UINT32): HResult; stdcall;
    end;

Ergebis: alle 3 Varianten funktionieren (nur die 4te nicht in der das Record direkt übergeben wird, logo)


hab mal so probiert zu verwenden

Delphi-Quellcode:

 procedure TSkin.LoadSkin(DXDevice: TDXDevice; AFilename: WideString);
var
  dp:TD2D1_POINT_2U;
  ar: TD2D1_RECT_U;
  hr: HResult;

begin
    if FDLLHandle <> 0 then
        FreeLibrary(FDLLHandle);

    FDLLHandle := LoadLibraryW(pWideChar(AFilename));

    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'Button', 56, 56, FButton);
    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'InnerLabel', 54, 55, FInnerLabel);
    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'InnerLabelSelected', 54, 55, FInnerLabelSelected);

    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'ButtonSelected', 56, 56, FButtonSelected);
    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'Background', 1920, 1080, FBackground);
    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'ImageButton', 56, 56, FImageButton);
    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'ImageButtonSelected', 56, 56, FImageButtonSelected);

    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'CheckboxChecked', 18, 18, FCheckBoxChecked);
    D2DFunctions.LoadBitmapFromResource(DXDevice, FDLLHandle, 'CheckboxUnchecked', 18, 18, FCheckBoxUnChecked);

    dp.x:=12;
    dp.y:=2;
    ar.left:=0;
    ar.top:=0;
    ar.right:=50;
    ar.bottom:=50;
    hr:=FButtonSelected.CopyFromBitmap(@dp,FButton,@ar);
//    hr:=FButtonSelected.CopyFromBitmap(dp,FButton,ar);
    if hr=0 then OutputDebugString('suuüa');


end;

Aufruf von CopyFromBitmap je nach Deklartion im Header.
Ergebnis siehe Anhang.

Unterscheiden sich hier Delphi und FPC wirklich so stark?
Ich hab ja die Header unter FPC in Verwendung. Z.B. gingen bei den DX10 Headern von JSB keine Effects weil das keine "echten" IUnknown interfaces sind, sondern welche denen die Referenzierung fehlt, JSB hat die mit class und die funktionen als virtual abstract deklariert.
Das geht unter FPC nicht, dafür gibts dort das CORBA interface, das hat keine Referenzzählung.

Welches Betriebssystem verwendest Du? 32 oder 64bit?

[Memnarch]

Vielen dank für die mühe :)
Könntest du vllt ein GitRepo(z.B. auf GitHub) eröffnen und dort dein Delphi-DX12 projekt einpflegen? Bin mir sicher, dass es einige gibt, die sich dafür interessieren. So ist es auch möglich, dass andere Fehler melden oder per Pull-Request gleich an dich schicken.

Grüße
Memnarch

[mkinzler]

Z.B. bei uns

http://www.delphipraxis.net/182276-d...-projekte.html

[SonnyBoyPro]

Gute Idee,

nun erreichbar unter

https://github.com/CMCHTPC/DelphiDX12



ich hoffe ich hab alles richtig eingestellte ... :-D

[Memnarch]

Sehr cool :D
Ich war mal so frei, den Link zu deinem Repo in der Delphi Developers Community auf G+ zu teilen :)

[SonnyBoyPro]

Paßt :-D :thumb:

[TiGü]

Zitat:

Zitat von SonnyBoyPro (Beitrag 1304672)

Welches Betriebssystem verwendest Du? 32 oder 64bit?

Windows 7, 64-Bit...aber was hat das mit meinen Kompilierungsproblemen zu tun?

@alle anderen Delphi-Benutzer:
Könnt ihr ein leeres Testprojekt mit hinzugefügten Headern kompilieren oder steigt euer XE(1-8) auch bei der einen oder anderen Stelle aus?

[SonnyBoyPro]

So, hab jetzt probiert unter XE2 zu kompilieren.
--> auch Fehler

WinCodec.pas in WinCodec2.pas umbenannt (und in D2D1.pas auch die uses Klausel angepaßt) und die Sache mit kompilieren hat funktioniert.
Scheinbar gibts da ein Problem mit dem Auflösen der WinCodec? :?:

[TiGü]

Ein Namespace-Problem also!
Deine Bezeichner beißen sich mit den Delphi eigenen Headern im Winapi-Namespace.
Um es zu kompilieren, musste ich neben der Wincodec.pas noch die DXGI.pas und D2D1.pas umbenennen.
Zwar löst die IDE richtig zu deinen Headern auf, aber der Compiler denkt bei einen nacktem "D2D1" in der uses-Klausel wohl zuerst an "Winapi.D2D1".

Kann Free Pascal auch diese Pseudo-Namespaces mit Punkt in der Unit?
Vielleicht führst du deine eigenen Namespaces ein, damit das nicht kollidiert?

[SonnyBoyPro]

Hab den Namespace auf DX12 geändert.
Aktualisierte Files sind auf GitHub.

[TiGü]

Du musst noch die Namen in den Units selber und die Uses-Klauseln anpassen!

[SonnyBoyPro]

Hab die betroffenen Units noch ergänzt. Also zumindest funktionieren die jetzt unter XE2.

[TiGü]

Interessehalber habe ich mir den letzten Stand von GitHub gezogen und versucht zu kompilieren.
Leider scheitert mein XE7 bei vielen Enum-Deklarationen, wo 32-Bit Länge forciert wird.
Zwar ist überall {$Z4} definiert, aber nichts geht.

Auch solche Werte werden angemeckert:

Delphi-Quellcode:

    TD2D1_PROPERTY = (
        D2D1_PROPERTY_CLSID = $80000000,

[SMO]

Zitat:

Zitat von TiGü (Beitrag 1315786)

Interessehalber habe ich mir den letzten Stand von GitHub gezogen und versucht zu kompilieren.
Leider scheitert mein XE7 bei vielen Enum-Deklarationen, wo 32-Bit Länge forciert wird.

Bei XE6 geht das, man bekommt allerdings die Warnung "W1012 Constant expression violates subrange bounds".
Probier's mal mit einem Typecast auf Integer (D2D1_PROPERTY_CLSID = Integer($80000000)), dann sollte es klappen.

[DualCoreCpu]

Danke @SonnyBoyPro!

Ich kann diese Header gebrauchen. Ich verwende Windows10 64 Bit, das ja DirectX12 an Bord hat. Da will ich keine älterten Header verwenden, ich habe schon Übersetzungsfehler mit den alten Headern, die bei FPC 3.0.2 dabei sind. Soll heißen, der Compiler läuft durch, aber das Programm, das mein DirectX verwendet, funktioniert anschließend nicht. Will schauen, ob mir da die aktuellen DirectX Header weiter helfen. Sollte eigentlich der Fall sein.