D3D9 Hook bzw. als "proxy.dll"

[GOOFY009]

Hallo Leute,

ich versuche gerade die Proxy.dll von Michael Koch (Link ) nach Delphi zu portieren, da ich im Netzt nichts brauchbares in Delphi gefunden habe.

Leider sind meine Kentnisse in C++ eher "bescheiden" (eigentlich gegen NULL). Was mich aber nicht abhalten soll es dennoch irgendwie zu schaffen ;-) .

Zu Beginn würde es mir schon einmal reichen, die Originalfunktion aus der im SystemDir liegenden d3d9.dll zu laden und an das aufrufende Programm zurück zu geben.

Das Laden der Function stellt dabei kein Problem da.... nur wenn ich die Funktion

Delphi-Quellcode:

oDirect3D9_Create := GetProcAddress(gl_hOriginalDll, 'Direct3DCreate9');

aufrufe (Rückgabe ist ein Pointer) und dann mit

Delphi-Quellcode:

ppIDirect3D9_orig := IDirect3D9(oDirect3D9_Create(SDKVersion));
result := ppIDirect3D9_orig;

zurück geben will, habe ich ein Problem.

ppIDirect3D9_orig wird mir als Pointer(xxxxx) of IDirect3D9 angezeigt und damit kommt es zum Absturz des Programms/der Dll.

Ich habe auch hier schon im Forum gesucht und habe dabei diesen Beitrag gefunden, welcher mir aber nicht wirklich geholfen hat.

Wenn also jemmand eine Idee hätte oder vieleicht sogar vor dem gleichen Problem stand und mir helfen könnte
würde ich mich über entsprechene Hilfe/Tips sehr freuen.

Zum Abschluß noch der Code der DLL :

Delphi-Quellcode:

library d3d9;

uses
  Windows,
  SysUtils,
  Classes,
  Direct3D9,
  d3dx9,
  my_IDirect3DDevice9 in 'my_IDirect3DDevice9.pas',
  my_IDirect3D9 in 'my_IDirect3D9.pas',
  tools in 'tools.pas',
  global_var in 'global_var.pas';

type
  TDirect3DCreate9 = function(SDKVersion: LongWord): Pointer; stdcall;

var
  oDirect3D9_Create  : TDirect3DCreate9 = nil;
  ppIDirect3D9_orig  : IDirect3D9;

{$R *.res}


function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9;
begin
  if gl_hOriginalDll =  0 then LoadOriginalDLL;

  oDirect3D9_Create := GetProcAddress(gl_hOriginalDll, 'Direct3DCreate9');

  ppIDirect3D9_orig := IDirect3D9(oDirect3D9_Create(SDKVersion));

  result := ppIDirect3D9_orig;

end;

procedure InitInstance;
begin
  gl_hOriginalDll := 0;
end;

procedure ExitInstance;
begin
  if gl_hOriginalDll <> 0 then begin
    FreeLibrary(gl_hOriginalDll);
    gl_hOriginalDll := 0;
  end;
end;

procedure DLLEntryPoint(reason : Integer);
begin
  case reason of
    DLL_PROCESS_DETACH :
      begin
        ExitInstance;
      end;
    DLL_PROCESS_ATTACH :
      begin
        InitInstance;
      end;
    DLL_THREAD_DETACH  : exit;
    DLL_THREAD_ATTACH  : exit;
  end;
end;

exports

Direct3DCreate9;

begin
  DLLProc := @DLLEntryPoint;
  DLLEntryPoint(DLL_PROCESS_ATTACH);

end.

Bei der ersten Quelle gibt es auch den Quellcode in C++ wenn benötigt.


CU
GOOFY

[brechi]

Wenn du einen Wrapper schreibst, muss die deine Exportierte Funktion genauso aufgebaut sein, wie die, die du importierst.

Heißt also:

Delphi-Quellcode:

type
  TDirect3DCreate9 = function(SDKVersion: LongWord): IDirect3D9; stdcall; 
var
  OrigDirect3DCreate9: TDirect3DCreate9;

function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9; stdcall;
begin
  Result := OrigDirect3DCreate9(...);
  // eventl. Result zwischenspeichern und weiterverarbeiten
end;

Und in ProcessAttach solltest dann schon mit GetProcAddress die origianle funktion holen

[GOOFY009]

Hi!

Danke für den Hinweis. Der Fehler hatte sich wohl durchs viele "Herumprobieren" eingeschlichen.
Hier der nun funktionierende Code:

Delphi-Quellcode:

library d3d9;

uses
  Windows,
  SysUtils,
  Classes,
  DirectCreate in 'DirectCreate.pas';

{$R *.res}

exports

Direct3DCreate9;

procedure DLLEntryPoint(reason : Integer);
begin
  case reason of
    DLL_PROCESS_DETACH :
      begin
        ExitInstance;
      end;
    DLL_PROCESS_ATTACH :
      begin
        InitInstance;
      end;
    DLL_THREAD_DETACH  : exit;
    DLL_THREAD_ATTACH  : exit;
  end;
end;

begin
  DLLProc := @DLLEntryPoint;
  DLLEntryPoint(DLL_PROCESS_ATTACH);
end.

Delphi-Quellcode:

unit DirectCreate;

interface

uses
  Windows,
  SysUtils,
  Classes,
  ShareMem,
  Direct3D9,
  d3dx9;

var
  gl_hOriginalDll        : THandle;

  Direct3DCreate9original: function(SDKVersion: cardinal): Pointer; stdcall;
  function Direct3DCreate9(SDKVersion: cardinal): Pointer; stdcall;

  procedure LoadOriginalDLL;
  procedure InitInstance;
  procedure ExitInstance;

implementation

function Direct3DCreate9(SDKVersion: LongWord): Pointer;
begin
  if gl_hOriginalDll =  0 then LoadOriginalDLL;
  @Direct3DCreate9original := GetProcAddress(gl_hOriginalDll, 'Direct3DCreate9');;
  result := Direct3DCreate9original(SDKVersion);
end;

procedure LoadOriginalDLL;
var
  SystemPath: array[0..MAX_PATH] of char;
  SysDir : String;
begin
  GetSystemDirectory(SystemPath, SizeOf(SystemPath));
  SysDir := SystemPath+'\d3d9.dll';
  gl_hOriginalDll := LoadLibrary(PChar(SysDir));
end;

procedure InitInstance;
begin
  gl_hOriginalDll := 0;
end;

procedure ExitInstance;
begin
  if gl_hOriginalDll <> 0 then begin
    FreeLibrary(gl_hOriginalDll);
    gl_hOriginalDll := 0;
  end;
end;

end.

Das funktioniert nun soweit. Jetzt müsste ich noch heraus bekommen, wie man das IDirect3D9 überschreibt um Zugriff auf die einzellnen Funktionen zu bekommen. Das Aufrufende Programm bekomm ja einen Pointer(xxxxx) of IDirect3D9 zurück ?!

Der C++ Aufruf sieht so aus :

Code:

   // Create my IDirect3D8 object and store pointer to original object there.
   // note: the object will delete itself once Ref count is zero (similar to COM objects)
   gl_pmyIDirect3D9 = new myIDirect3D9(pIDirect3D9_orig);
   
   // Return pointer to hooking Object instead of "real one"
   return (gl_pmyIDirect3D9);

Un die dazu gehörige Klasse (nur ein Teil sonst wird es zu lang):

Code:

// myIDirect3D9.cpp

#include "StdAfx.h"

myIDirect3D9::myIDirect3D9(IDirect3D9 *pOriginal)
{
    m_pIDirect3D9 = pOriginal;
}

myIDirect3D9::~myIDirect3D9(void)
{
}

HRESULT  __stdcall myIDirect3D9::QueryInterface(REFIID riid, void** ppvObj)
{
    *ppvObj = NULL;

   // call this to increase AddRef at original object
   // and to check if such an interface is there

   HRESULT hRes = m_pIDirect3D9->QueryInterface(riid, ppvObj); 

   if (hRes == NOERROR) // if OK, send our "fake" address
   {
      *ppvObj = this;
   }
   
   return hRes;
}

ULONG    __stdcall myIDirect3D9::AddRef(void)
{
    return(m_pIDirect3D9->AddRef());
}

ULONG    __stdcall myIDirect3D9::Release(void)
{
    extern myIDirect3D9* gl_pmyIDirect3D9;

   // call original routine
   ULONG count = m_pIDirect3D9->Release();
   
    // in case no further Ref is there, the Original Object has deleted itself
   // so do we here
   if (count == 0) 
   {
      gl_pmyIDirect3D9 = NULL;
         delete(this); 
   }

   return(count);
}

HRESULT __stdcall myIDirect3D9::RegisterSoftwareDevice(void* pInitializeFunction)
{
    return(m_pIDirect3D9->RegisterSoftwareDevice(pInitializeFunction));
}

UINT __stdcall myIDirect3D9::GetAdapterCount(void)
{
    return(m_pIDirect3D9->GetAdapterCount());
}

Wie bereits erwähnt... bin für jede Hilfe / Anregung offen... :mrgreen:

CU
GOOFY

[Apollonius]

Du schreibst selbst eine Klasse, die IDirect3D9 implementiert. AddRef und Release kannst du implementieren, indem du von TInterfacedObject ableitest, QueryInterface wahrscheinlich auch, und den Rest schreibst du entweder selbst oder delegierst an das ursprüngliche IDirect3D9. In deiner Direct3DCreate9-Funktion gibst du dann nicht mehr das ursprüngliche Interface zurück, sondern eine Instanz deiner eigenen Klasse, wobei du da wieder auf den RefCount aufpassen musst.

[GOOFY009]

Danke für die schnelle Antwort !

Zitat:

Zitat von Apollonius

Du schreibst selbst eine Klasse, die IDirect3D9 implementiert. AddRef und Release kannst du implementieren, indem du von TInterfacedObject ableitest, QueryInterface wahrscheinlich auch, und den Rest schreibst du entweder selbst oder delegierst an das ursprüngliche IDirect3D9.

Die Klasse habe ich schon geschrieben.

Zitat:

Zitat von Apollonius

In deiner Direct3DCreate9-Funktion gibst du dann nicht mehr das ursprüngliche Interface zurück, sondern eine Instanz deiner eigenen Klasse, wobei du da wieder auf den RefCount aufpassen musst.

Wie stelle ich das an "..eine Instanz deiner eigenen Klasse" zurück zugeben ??? Die Direct3DCreate9-Funktion gibt ja einen Pointer (ohne erkennbare Zuweisung auf IDirect3D9) zurück.

Delphi-Quellcode:

result := Direct3DCreate9original(SDKVersion);

Und was muss ich beim RefCount beachten ?


Fragen über Fragen...... und schon einmal Danke für jede weitere Hilfe.

CU
GOOFY

[Apollonius]

Ich schreibe das jetzt mal ohne Testen herunter. Deine Klasse dürfte ungefähr so aussehen:

Delphi-Quellcode:

TMyDirect3D9 = class(TInterfacedObject, IDirect3D9)
private
  fOrgDirect3D9: IDirect3D9;
public
  constructor Create(org: IDirect3D9);
  
  //Diese Prozedur einfach an fOrgDirect3D9.Direct3DProc1 weiterleiten
  procedure Direct3DProc1;
  procedure Direct3DProc2;
  //...  
end;

Deine exportierte Funktion muss dann so aussehen:

Delphi-Quellcode:

var MyDirect3D9: IDirect3D9;

function Direct3DCreate9(SDKVersion: LongWord): Pointer;
begin
  if MyDirect3D9 = nil then
    MyDirect3D9 := TMyDirect3D9.Create(Direct3DCreate9original(SDKVersion));
  
  //Jetzt einmal den RefCount erhöhen
  MyDirect3D9._AddRef;
  return Pointer(MyDirect3D9);
end;

Dieses RefCount-Gemurkse ist nur deshalb notwendig, weil die Entwickler von Direct3D sich anscheinend nicht an COM-Regeln gehalten haben. Normalerweise gilt nämlich, dass man Interfaces nie als Rückgabewert, sondern nur als out-Parameter zurückgibt. Dann ergeben sich auch keine Probleme.

[Dezipaitor]

Interfaces über einen Rückgaberwert zu liefern ist in Delphi ohne Probleme möglich und nichts problematisches, wenn man Delphi nicht austrickst. Dazu gehört, dass man nur mit dem Interface arbeitet und keine durch Create erzeugte Instanz besitzt. Zudem umgehen untypisierte Zeiger als Deckmantel für Interfaces die Referenzzählung (Wozu hier überhaupt?).

In C++ wird es eben nur mit OUT gemacht, weil jede COM Methode HRESULT zurückgeben muss; In Delphi gibt es dazu ja die Exceptions. Das sollte man bei der Interfacedeklaration berücksichtigen. Stichwort: safecall.

[GOOFY009]

@ Apollonius

So hatte ich mir das auch gedacht.... nur funktioniert das leider so nicht !

Wenn ich den Post von Dezipaitor richtig "deute", dann wiederspricht es dem was du (und auch ich) uns so vorgestellt hatten wie es funtionieren sollte ?!

@Dezipaitor

Mag sein das es heute schon etwas spät ist und der Arbeitstag lang war aber irgendwie hab ich deinen Post, trotz mehrfachen lesens, nicht verstanden :gruebel:

Vieleicht könntest Du mir mal etwas "einfacher" auf die Sprünge helfen (vieleicht mit einem Beispiel)?
Ansonsten werde ich am Mittwoch, wenn ich frei habe und etwas besser ausgeschlafen habe, mich noch mal dran setzten....

Auf jeden Fall mal Danke für eure Hilfe bisher....

CU GOOFY

[Dezipaitor]

Wenn du das Interface in einen Zeiger verwandelst, dann musst du selbst _AddRef benutzen, weil Delphi dann dies nicht mehr automatisch für dich übernimmt. Das ist völlig unabhängig, wie die Variable verwendet wird, ob per Result oder var- bzw. out-Parameter.
Wenn du den ResultZeiger durch den Interfacename ersetzt, dann solltest du kein _AddRef benötigen.

[MisterNiceGuy]

OT: Ich find das Thema total spannend, hoffe du bekommst es hin :)

[Apollonius]

Was heißt denn jetzt "funktioniert nicht"? Hast du das mal debuggt?
Christian, der Funktionsprototyp darf nicht verändert werden. Wenn man als Result ein Interface, dynamisches Array, String oder Variant verwendet, wird intern ein out-Parameter verwendet - man verändert also die Aufrufkonvention.

[Dezipaitor]

Um was geht es? COM Methoden oder Standardfunktionen?
Der Result ist hier ein Pointer, original ist ein Interface.

[Apollonius]

Naja, die C++-Deklaration sieht so aus:

Code:

IDirect3D9 * Direct3DCreate9(
  UINT SDKVersion
);

Und wenn ich in Delphi schreibe

Delphi-Quellcode:

function Direct3DCreate9(SDKVersion: Cardinal): IDirect3D9; stdcall;

dürfte das in C++ so heraus kommen:

Code:

void Direct3DCreate9(UINT SDKVersion, IDirect3D9** result);

Sofern ich mich nicht irre, werden Typen mit RefCount (d.h. finalisierungsbedürftige Typen) immer als out-Parameter zurückgegeben.
Nebenbei bemerkt scheint beim Threadersteller ein stdcall verloren gegangen zu sein.

[Dezipaitor]

Ich bezog mich garnicht auf die Übersetzung, sondern nur, dass man Interfaces als Result zurückgeben kann.

Aber stimmt schon, wenn man es übersetzt dann über einen Pointer. D.h. die Routine muss gekapselt werden und die neue Routine darf nur öffentlich sein.

Allerdings, der Header definiert das stdcall garnicht.

[Apollonius]

Stimmt, das stdcall fehlt - sehr seltsam. Register ist es allerdings auf keinen Fall.

[Remko]

I think this is a Delphi bug, I remember it because I had a problem with some other winapi call that returned an interface.
I quickly tested this (I used IUnknown because I don't have DirectX):

Delphi-Quellcode:

function Direct3DCreate9(SDKVersion: Cardinal): IUnknown; stdcall; external 'd3d9.dll';

procedure TForm2.Button1Click(Sender: TObject);
var
  Unknown: IUnknown;
begin
  Unknown := Direct3DCreate9(32);
end;

When I look in the CPU window we can see the problem:

Delphi-Quellcode:

Unit2.pas.31: Unknown := Direct3DCreate9(32);
004A3B0F 6A20             push $20
004A3B11 8D45F8           lea eax,[ebp-$08]
004A3B14 50               push eax
004A3B15 E8CEFFFFFF       call Direct3DCreate9

For some reason Delphi put's the result (which is in eax when using stdcall) on stack (push eax).

If I declare like this it looks ok:

Delphi-Quellcode:

function Direct3DCreate9(SDKVersion: Cardinal): Pointer; stdcall; external 'd3d9.dll';

procedure TForm2.Button1Click(Sender: TObject);
var
  Unknown: IUnknown;
begin
  Pointer(Unknown) := Direct3DCreate9(32);
end;

The CPU window shows:

Delphi-Quellcode:

Unit2.pas.31: Pointer(Unknown) := Direct3DCreate9(32);
004A3B0F 6A20             push $20
004A3B11 E8D2FFFFFF       call Direct3DCreate9
004A3B16 8945F8           mov [ebp-$08],eax

[Apollonius]

Delphi doesn't really put the result on stack - it uses an out Parameter. You see that the calling routine pushes the address ebp - 8 which is the address of the Unknown variable.
I think that the modified signature using an out-parameter instead of the usual result is reasonable from a design standpoint. Returning an interface in eax is always bad - and never happens in the usual COM context - because it poses a severe problem with respect to exception handling. If an exception occurs when the called routine returns, the interface cannot be released correctly because it is lost when the exception is thrown. Using the Delphi design, on the other hand, the caller retains a reference to the interface and will release it due to the auto-generated try-finally.
To sum it up, the Delphi semantics is different to the C++ semantics and perhaps different from naive expectations, but it is the best way to do it in my opinion. The error is on the side of the Direct3D developers because they designed their function to break COM rules.

[Remko]

Well, the way I see it it's not a design discussion (although I agree that the Delphi (Safecall) solution is elegant) but what's happening here is that Delphi put's 2 pointers on stack while the dll expects only one. Another example where this happens is SHOpenRegStream2.

[Apollonius]

Sure, as I said, you cannot naively translate from/to C++. But SHOpenRegStream2 poses the very same exception problem I described above - I regard this as a bug. By forcing you to think about untyped pointers and reference counting, Delphi doesn't hide this bug. Delphi's interfaces are made to be fail-safe with the automatic reference counting - but this safety simply cannot be provided in the case of SHOpenRegStream2 et al., and Delphi doesn't give any illusions about this.

[Dezipaitor]

hat niemand die Deklaration

Delphi-Quellcode:

function(SDKVersion: LongWord): ^IDirect3D9; stdcall

mal ausprobiert?

[UPDATE]
Ich meinte mit ^

[Apollonius]

Ich glaube nicht. :mrgreen: Wird aber nicht funktionieren, weil, wie Remko und ich festgestellt haben, Delphi da etwas anderes draus bastelt.

[Remko]

The only workaround I see is by declaring result as pointer...

[GOOFY009]

WOW,
hätte ja nicht gedacht, dass mein "kleines" Problem zu einem doch etwas "größerem" Entwickelt.

Ich habe dem Post mal meine momentanen Sourcen inkl. DirectX Headern und dem Testprogramm CreateDevice angehängt.
Vieleicht kann sich das ja mal jemand anschauen und findet vieleicht so den Fehler bzw. eine Lösung des Problems.

Beim Rückgabewert habe ich bisher mehrere Varianten probiert... die letzten 2 schienen mir am ehesten "Funktional" zu sein,
brachten aber leider keinen Erfolg.

1. Variante :

Delphi-Quellcode:

function Direct3DCreate9(SDKVersion: cardinal): IDirect3D9; stdcall;

.....

function Direct3DCreate9(SDKVersion: LongWord): IDirect3D9;
begin
  if gl_hOriginalDll =  0 then LoadOriginalDLL;
  @Direct3DCreate9original := GetProcAddress(gl_hOriginalDll, 'Direct3DCreate9');
  pmyIDirect3D9 :=  myIDirect3D9.Create;
  pmyIDirect3D9.myIDirect3D9(IDirect3D9(Direct3DCreate9original(SDKVersion)));
  pmyIDirect3D9._AddRef;
  result := pmyIDirect3D9 as IDirect3D9;
end;

2. Variante :

Delphi-Quellcode:

function Direct3DCreate9(SDKVersion: cardinal): Pointer; stdcall;

.....

function Direct3DCreate9(SDKVersion: LongWord): Pointer;
begin
  if gl_hOriginalDll =  0 then LoadOriginalDLL;
  @Direct3DCreate9original := GetProcAddress(gl_hOriginalDll, 'Direct3DCreate9');
  pmyIDirect3D9 :=  myIDirect3D9.Create;
  pmyIDirect3D9.myIDirect3D9(IDirect3D9(Direct3DCreate9original(SDKVersion)));
  pmyIDirect3D9._AddRef;
  result := pmyIDirect3D9;
end;

Beides wird vom Aufrufenden Programm (CreateDevice) mit "Runtime error 216 at xxxx" quittiert.

Ein eigenes Interface zu schreiben, welches von IDirect3D9 abstammt, bringt ja nix weil ich ja die DirectX-Funktionen vom aufrufenden Programm abfangen, in meiner DLL verarbeiten und dann an die originale d3d9.dll weitergeben möchte. Ergo brauche ich ja eine eigene Klasse.
Wäre schon übel wenn das ganze scheitert, nur weil der Compiler von Delphi hier einen "Fehler" macht......(wenn ich die anderen Posts richtig verstanden habe).

Ich werd mal auf jeden Fall weiter im Netzt suchen und das eine oder andere dann vieleicht Probieren. Die Hoffnung stirbt bekanntlich ja zu letzt......

CU GOOFY

[Apollonius]

Die Variable pmyIDirect3D9 muss den Typen IDirect3D9 haben! Sonst gibst du den falschen Zeiger zurück. Daneben solltest du AddRef und Release einfach von TInterfacedObject erben und nicht verändern.

[GOOFY009]

Hi !
Unglaublich aber wahr....

Zitat:

Zitat von Apollonius

Die Variable pmyIDirect3D9 muss den Typen IDirect3D9 haben!

Nach dem ich das angepasst hate und die Create Funktion der Klasse zwecks Übergabe des Ursprungsparameters erweitert hatte
funktioniert das Ganze jetzt !!!

SUPER !!! Danke !!!

Irgendwie hatte ich mich bei pmyIDirect3D9 total auf die Klasse "versteift".

Jetzt kann ich mich daran machen die myIDirect3DDevice9 Klasse zu schreiben um dann letztlich vollen Zugriff
auf DirectX im aufrufenden Programm zu haben um dort meine Ausgaben zu platzieren.

Für mich ist dieser Topic ertsmal gelöst. Sollte Interesse an der weitern Entwicklung vorhanden sein, so würde ich natürlich weiterhin meine Ergebnisse hier zur Verfügung stellen.

Danke nochmal an alle die geholfen haben. Vieleicht (hoffentlich nicht ;-) ) muss ich ja doch nochmal wegen eines Problems "vorbei kommen".

CU

GOOFY

[Remko]

Just a tip: if you want to define a function where you are not going to modify the results or when you do not know the number of parameters or the type (or are just too lazy too declare them all ;-) you can declare it like this:

Delphi-Quellcode:

var
  FunctionPtr: Pointer;

GetProcedureAddress(FunctionPtr, 'my.dll', 'SomeExternalFunction');

procedure SomeExternalFunction;
asm
   jmp dword ptr FunctionPtr;
end;

exports SomeExternalFunction;

[TKC]

Zitat:

Zitat von GOOFY009

Hi !
Unglaublich aber wahr....

Zitat:

Zitat von Apollonius

Die Variable pmyIDirect3D9 muss den Typen IDirect3D9 haben!

Nach dem ich das angepasst hate und die Create Funktion der Klasse zwecks Übergabe des Ursprungsparameters erweitert hatte
funktioniert das Ganze jetzt !!!

SUPER !!! Danke !!!

Irgendwie hatte ich mich bei pmyIDirect3D9 total auf die Klasse "versteift".

Jetzt kann ich mich daran machen die myIDirect3DDevice9 Klasse zu schreiben um dann letztlich vollen Zugriff
auf DirectX im aufrufenden Programm zu haben um dort meine Ausgaben zu platzieren.

Für mich ist dieser Topic ertsmal gelöst. Sollte Interesse an der weitern Entwicklung vorhanden sein, so würde ich natürlich weiterhin meine Ergebnisse hier zur Verfügung stellen.

Danke nochmal an alle die geholfen haben. Vieleicht (hoffentlich nicht ;-) ) muss ich ja doch nochmal wegen eines Problems "vorbei kommen".

CU

GOOFY

Hi,
wärst du so nett den geänderten Quelltext nochmal bereitzustellen ?
Ich fand es bis jetzt ziemlich lehrreich für mich.

[GOOFY009]

Hi !

Kein Problem, mach ich gerne. Hab die Dateien mal angehängt und sollten so funktionieren.
Da mein Projekt mittlerweile um einiges "gewachsen" ist habe ich mal nur die die Dateien reingepackt,
welche für dich Interessant sein dürften.

Kann sein das Du da vieleicht das eine oder andere (event. für dich unnötige Variablen etc) löschen musst
aber der Quelltext sollte dich zu einer funktionierenden d3d9.dll führen.

Es gibt auch noch eine funktionierende Swapchain die wohl einige Programme (die auf DX9 aufbauen)
benötigen um seinen eigenen Anzeigen im fremden Programm anzuzeigen benötigen.

Sollte die noch gebraucht werden, einfach noch mal melden. Ich brauche diese für mein Projekt letztlich doch nicht.
Habe ich aber erst festgestellt nach dem ich das Teil fertig hatte :lol:


CU

GOOFY