Affichage d'un Sprite avec D3D9

Version imprimable

Bonjour à tous,

Je m'initie à DirectX 3D avec C++ Builder6.

Pour cela, j'ai consulté divers tutoriaux et j'ai écrit le programme très simple suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class TMainForm : public TForm
{
__published:	// Composants gérés par l'EDI
  void __fastcall FormCreate(TObject *Sender);
  void __fastcall FormDestroy(TObject *Sender);
private:	// Déclarations de l'utilisateur
  LPDIRECT3D9 FD3D;
  LPDIRECT3DDEVICE9 FDevice; // Our rendering device
  HRESULT __fastcall InitD3D( HWND hWnd );
  LPDIRECT3DTEXTURE9 FSpriteTexture;
  LPD3DXSPRITE FSprite;
  void __fastcall Cleanup();
  void __fastcall Render(TObject *Sender, bool &Done);
public:		// Déclarations de l'utilisateur
        __fastcall TMainForm(TComponent* Owner);
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
//---------------------------------------------------------------------------
__fastcall TMainForm::TMainForm(TComponent* Owner)
        : TForm(Owner)
{
  FDevice = NULL;
  FD3D = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::FormDestroy(TObject *Sender)
{
  Cleanup();        
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::FormCreate(TObject *Sender)
{
  if( !SUCCEEDED( InitD3D( Handle )))
    Close();
}
//-----------------------------------------------------------------------------
HRESULT __fastcall TMainForm::InitD3D( HWND hWnd )
{
  // Create the D3D object, which is needed to create the D3DDevice.
  if( NULL == ( FD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
    return E_FAIL;
 
  // Remplissage des valeurs de la structure
  D3DPRESENT_PARAMETERS params;
  // Mise à zéro de toutes les valeurs de la structure }
  ZeroMemory( &params, sizeof( params ) );
  params.Windowed = TRUE;
  params.SwapEffect = D3DSWAPEFFECT_DISCARD;
  params.BackBufferFormat = D3DFMT_UNKNOWN;
 
  // Création du dispositif
  if( FAILED( FD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &params, &FDevice ) ) )
    return E_FAIL;
 
  // Création de la texture du sprite
  if (D3D_OK != D3DXCreateTextureFromFile(FDevice, "Ball.png", &FSpriteTexture))
    return E_FAIL;
 
  // Création du sprite
  if( FAILED( D3DXCreateSprite(FDevice, &FSprite)))
    return E_FAIL;
 
  /* Nous branchons un gestionnaire d'évènement sur l'évènement OnIdle de
  l'application */
  Application->OnIdle = Render;
 
  return S_OK;
}
//---------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
void __fastcall TMainForm::Cleanup()
{
  if( FDevice != NULL )
    FDevice->Release();
 
  if( FD3D != NULL )
    FD3D->Release();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::Render(TObject *Sender, bool &Done)
{
  // Tracé du fond
  Cardinal dxColor;
  dxColor = D3DCOLOR_XRGB(0, 0, 255); // bleu pour le fond
  FDevice->Clear(0, NULL, D3DCLEAR_TARGET, dxColor, 1, 0);
 
  // Le tracé du sprite nécessite un vecteur de points réels
  D3DXVECTOR3 dxVector;
  dxVector.x=10.0f;
  dxVector.y=20.0f;
  dxVector.z=0.0f;
 
  // Begin the scene
  if( SUCCEEDED( FDevice->BeginScene() ) )
  {
    FSprite->Begin(D3DXSPRITE_ALPHABLEND);
    FSprite->Draw(FSpriteTexture, NULL, NULL, &dxVector, 0xFFFFFFFF);
    FSprite->End();
    FDevice->EndScene();
  }
 
  // DirectX doit maintenant transférer le contenu du buffer vers l'affichage
  FDevice->Present(NULL, NULL, NULL, NULL);
 
  /* Ne pas oublier de mettre Done à false pour que la méthode soit
    appelée à nouveau */
  Done = false;
}
//---------------------------------------------------------------------------

Quelqu'un peut-il me dire pourquoi ce p..... de sprite ne s'affiche pas?

L'exemple qui précède est traduit du code delphi suivant qui marche nickel

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
unit MainFrm;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Direct3D9, D3DX9;
 
type
  TMainForm = class(TForm)
    procedure FormCreate(Sender: TObject);
    function InitD3D(hWnd : HWND): HRESULT;
  private
    { Private declarations }
    FD3D: IDirect3D9;
    FDevice: IDirect3DDevice9;
    FSpriteTexture: IDirect3DTexture9;
    FSprite: ID3DXSprite;
 
    procedure Render(Sender: TObject; var Done: Boolean);
  public
    { Public declarations }
  end;
 
var
  MainForm: TMainForm;
 
 
implementation
uses
  ActiveX;
 
{$R *.dfm}
 
procedure TMainForm.FormCreate(Sender: TObject);
begin
  InitD3D(Handle);
end;
 
function TMainForm.InitD3D(hWnd : HWND): HRESULT;
var
  params: TD3DPresentParameters;
begin
  { Création de l'instance IDirect3D9 }
  FD3D:= Direct3DCreate9(D3D_SDK_VERSION);
 
  { Mise à zéro de toutes les valeurs de la structure }
  FillChar(params, SizeOf(params), 0);
 
  { Remplissage des valeurs de la structure }
  with params do
  begin
    SwapEffect:= D3DSWAPEFFECT_DISCARD; // Obligatoire
    Windowed:= true;
  end;
 
  { Création du dispositif }
  FD3D.CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, self.handle,
    D3DCREATE_SOFTWARE_VERTEXPROCESSING, @params, FDevice);
 
  { Création de la texture du sprite }
  D3DXCreateTextureFromFile(FDevice, 'Ball.png', FSpriteTexture);
 
  { Création du sprite }
  D3DXCreateSprite(FDevice, FSprite);
 
  { Nous branchons un gestionnaire d'évènement sur l'évènement OnIdle de
    l'application }
  Application.OnIdle:= Render;
 
  Result := S_OK;
end;
 
procedure TMainForm.Render(Sender: TObject; var Done: Boolean);
var
  dxcolor: Cardinal;
  dxVector: TD3DXVector2;
  desc: D3DSURFACE_DESC;
begin
  { Tracé du fond, un simple effacement dans notre exemple }
  dxColor:= D3DCOLOR_XRGB(0, 0, 255); // bleu pour le fond
  FDevice.Clear(0, nil, D3DCLEAR_TARGET, dxColor, 1, 0);
 
  { Le tracé du sprite nécessite un vecteur de points réels }
  dxVector.x:= 10.0;
  dxVector.y:= 20.0;
 
  FDevice.BeginScene; // Il faut indiquer au dispositif que nous allons tracer
  FSprite._Begin; // Idem pour le sprite
  FSprite.Draw(FSpriteTexture, nil, nil, nil, 0, @dxVector, $FFFFFFFF);
  FSprite._End; // Fin du tracé
  FDevice.EndScene; // Idem
 
  { DirectX doit maintenant transférer le contenu du buffer vers l'affichage }
  FDevice.Present(nil, nil, 0, nil);
 
  { Ne pas oublier de mettre Done à false pour que la méthode soit
    appelée à nouveau }
  Done:= false;
end;
 
end.

Cependant une différence importante :

L'interface FSprite.Draw() est différente dans les 2 codes!
Pour delphi, un paramètre de plus et TD3DXVector2 à la place de D3DXVECTOR3!

Pour builder, l'interface provient du fichier microsoft d3dx9core.h :
STDMETHOD(Draw)(THIS_ LPDIRECT3DTEXTURE9 pTexture, CONST RECT *pSrcRect, CONST D3DXVECTOR3 *pCenter, CONST D3DXVECTOR3 *pPosition, D3DCOLOR Color) PURE;

Pour delphi, l'interface provient du fichier D3DX9.pas :
function Draw(pSrcTexture: IDirect3DTexture9; pSrcRect: PRect;
pScaling, pRotationCenter: PD3DXVector2; Rotation: Single;
pTranslation: PD3DXVector2; Color: TD3DColor): HResult; stdcall;

15/06/2009, 19h11
engrobel

Bon, je pense que me suis trompé de forum. Je vai poser ma question chez les spécialistes des jeux 2D/3D.
@+:zoubi:
15/06/2009, 19h24
gandf

Si tu veux, je peux regarder ce que j'ai en stock. Sachant que le code en question (si je le retrouve) n'affiche qu'un triangle à l'écran et qui plus est salement aliasé.

Sinon, tu as Asphyre si tu cherches un bonne librairie DirectX pour C++Builder.

C'était juste pour faire un test et cela affiche un triangle a l'écran. A la base, le code permettait afficher un cube composés de triangles. Je l'ai réduit pour comprendre pourquoi il y avait un aliasing si fort.

Voici le bout de code que j'ai :
.h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//---------------------------------------------------------------------------
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include "msMath.h"
#include "D3D9.h"
#include <d3dx9.h>
#include <dxerr9.h>
 
struct CUSTOMVERTEX
{
float x, y, z, rhw; // la position transformée du vertex
DWORD color;        // la couleur du vertex
};
 
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)
 
struct CUSTOMVERTEX2
{
D3DXVECTOR3 position;
D3DXVECTOR3 normal;
};
#define D3DFVF_CUSTOMVERTEX2 (D3DFVF_XYZ|D3DFVF_NORMAL)
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Composants gérés par l'EDI
        TButton *Button1;
        void __fastcall FormCreate(TObject *Sender);
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
        void __fastcall FormPaint(TObject *Sender);
        void __fastcall Button1Click(TObject *Sender);
private:	// Déclarations de l'utilisateur
                D3DDISPLAYMODE d3ddm;
                D3DPRESENT_PARAMETERS d3dpp;
                IDirect3DDevice9 *objet_periph3D;
                LPDIRECT3D9 objet_D3D;
                IDirect3DVertexBuffer9 *VERBUFF;
                D3DFORMAT formatdepixel;
                IDirect3DVertexShader9 *VERSHAD;
public:		// Déclarations de l'utilisateur
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#pragma warn -com. 
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
if (NULL == (objet_D3D = Direct3DCreate9(D3D_SDK_VERSION))) // création d'un périphérique D3Dx9
   {
   MessageDlg("Erreur lors de la création du périphérique.", mtError, TMsgDlgButtons() << mbOK, 0);
   }
if (objet_D3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm) == D3DERR_INVALIDCALL) // création d'un récupérateur de résolution
   {
   MessageDlg("Impossible de créer l'objet associé au périphérique 3D qui récupère la résolution en cours.", mtError, TMsgDlgButtons() << mbOK, 0);
   return;
   }
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = true;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; // objet permettant le paramétrage du périphérique D3Dx9
d3dpp.BackBufferWidth = 300;
d3dpp.BackBufferHeight = 300;
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.BackBufferCount = 1;
formatdepixel = D3DFMT_A8R8G8B8;
d3dpp.BackBufferFormat = formatdepixel;
if (objet_D3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, Form1->Handle, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &objet_periph3D) != D3D_OK) // et maintenant on cré l'objet direct3D
   {
   formatdepixel = D3DFMT_R8G8B8;
   d3dpp.BackBufferFormat = formatdepixel;
   if (objet_D3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, Form1->Handle, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &objet_periph3D) != D3D_OK)
      {
      formatdepixel = D3DFMT_R5G6B5;
      d3dpp.BackBufferFormat = formatdepixel;
      if (objet_D3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, Form1->Handle, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &objet_periph3D) != D3D_OK)
         {
         MessageDlg("Impossible de créer l'objet associé au périphérique 3D (résolution incorrecte).", mtError, TMsgDlgButtons() << mbOK, 0);
         return;
         }
      }
   }                                                                                  
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
if (objet_D3D != NULL) // on détruit les périphérique D3Dx9
   {
   objet_D3D->Release();
   }
if (objet_periph3D != NULL)
   {
   objet_periph3D->Release();
   }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender)
{
objet_periph3D->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0, 0); // on efface le back buffer en le remplissant de pixel de couleur noir
objet_periph3D->BeginScene();  // mise en place du verrou sur le back buffer pour modification
 
objet_periph3D->EndScene(); // fin d'écriture dans le back buffer (cela enlève le vérou)
objet_periph3D->Present(NULL, NULL, NULL, NULL); // affiche le back buffer à l'écran
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
CUSTOMVERTEX g_Vertices[] =
{
    {150, 50, 0.5, 1, 0xffff0000,},
    { 250, 250, 0.5, 1, 0xff00ff00,},
    { 50, 250, 0.5, 1, 0xff00ffff,},
};                           
if (objet_periph3D->CreateVertexBuffer(3*sizeof(CUSTOMVERTEX), 0, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &VERBUFF, NULL) != D3D_OK)
   {
   MessageDlg("Impossible de créer le vertex buffer.", mtError, TMsgDlgButtons() << mbOK, 0);
   return;
   }
void *pVertices;
if (VERBUFF->Lock(0, sizeof(g_Vertices), &pVertices, 0) == D3DERR_INVALIDCALL)
   {
   MessageDlg("Impossible de bloquer le vertex buffer.", mtError, TMsgDlgButtons() << mbOK, 0);
   return;
   }
memcpy(pVertices, g_Vertices, sizeof(g_Vertices));
VERBUFF->Unlock();
objet_periph3D->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1, 0);
objet_periph3D->BeginScene();
objet_periph3D->SetStreamSource(0, VERBUFF, sizeof(CUSTOMVERTEX), sizeof(CUSTOMVERTEX));
objet_periph3D->SetFVF(D3DFVF_CUSTOMVERTEX);
objet_periph3D->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);
objet_periph3D->EndScene();
objet_periph3D->Present(NULL, NULL, NULL, NULL);
}
//---------------------------------------------------------------------------

18/06/2009, 19h45
engrobel

Bonjour gandf,

En fait, avec la librairie clootie, je n'ai pas de problème pour afficher des objets 3D. J'ai réussi à porter tous les tutoriaux de microsoft qui sont en 3D!.
Mais avec les sprites ça coince!

J'ai donc suivi ton conseil et essayé Asphyre.
En compilant le projet sous CB6, je suis tombé sur le même problème que tu as rencontré le 2/2/2006 avec AsphyreMatrix (Fonctionnalité de langage non supportée : 'propriété de type tableau').

Le forum ne dit pas comment tu as résolu le problème.
18/06/2009, 20h22
gandf

En fait, j'ai ce qu'il faut sur mon site :

http://www.flyonsoft.com/index.php?o...lphi&Itemid=53

Et il faut suivre l'instruction sur la page en question. Par contre, ce n'est pas la dernière version (Asphyre Sphinx) mais la version 3.10. J'ai modifié le code pascal. Par contre, je n'ai pas testé l'installation sur un autre pc. Si tu essaies de l'installer, ce serait simpa de m'indiquer si cela fonctionne.

J'ai pas tout testé, j'ai essayé un exemple (un cube qui bouge avec un Timer pour régler le FPs max).

Si tu veux, je peux te passer aussi mon projet exemple pour voir à quoi cela ressemble.

Depuis C++Builder 209, la plupart des fonctionnalités de Delphi non pris en charge par C++Builder sont maintenant supportées. Personnellement, j'ai C++Builder 6 et BDS 2006. La version Sphinx est une librairie, elle n'a plus de composants visuels. Je ne sais pas si cela sera ainsi désormais ou si c'est par manque de temps qu'il ne les a pas intégré.
18/06/2009, 22h14
engrobel

gandf, sur ton site tu expliques qu'il faut modifier GuiControls.hpp. Mais lors de la compilation du module AsphyreMatrix, le module GuiControls.pas n'est pas encore compilé et donc le fichier GuiControls.hpp n'existe encore pas!
18/06/2009, 22h23
gandf

Oui, il faut compiler et installer le tout et ensuite, il te génère le fichier qu'il faut modifier. Je sais corriger le problème en C++ mais je ne connais pas la solution en Delphi.

D'ailleurs, c'est ce que j'ai mis, il faut le compiler et l'installer et ensuite, il faut modifier le fichier hpp qu'il a générer.

Il me semble que le problème est une histoire de classe qui fait référence à une autre qui fait référence à la 1ère.

En bref, compile et installe puis modifie le hpp posant problème.
18/06/2009, 22h51
engrobel

Je ne vois pas comment installer un package qui ne compile pas!
Si je tente d'installer le package, BC6 essaie de recompiler et s'arrête sur la même erreur. Et toujours pas de fichier GuiControls.hpp!
18/06/2009, 23h21
gandf

Effectivement, j'ai du me tromper dans mes versions. Je vais essayer de l'installer sur ma version 2006 et je mettrai la bonne version.
19/06/2009, 00h30
gandf

J'ai mis à jour mon article et j'ai mis une image de ce que l'on doit obtenir sur la palette de composants. Il ne faut pas compiler le pack BASS, je n'ai jamais pu le compiler.

Voici un nouveau lien pour le télécharger :
http://www.flyonsoft.com/asphyre.rar

C'est mon dossier qui fonctionne sur C++Builder 6.
Je n'arrive pas à l'installer sur la version 2006. Mais il compile parfaitement dans Delphi 2006 et il me fait une erreur interne de compilateur avec la version 2006 sans m'indiquer de ligne.

Il fonctionne sur la version 6 de C++Builder.

Et voici aussi un des exemple compilé. Par contre, je ne sais pas trop ce que j'ai fait pour avoir un bug de texture sachant que jai posé un maximum de composants sur la fiche pour vérifier d'eventuels erreurs de compilation.
http://www.flyonsoft.com/test.rar
20/06/2009, 08h38
engrobel

Cette version compile sans problème.
Je vais donc pouvoir tester le produit.

Merci pour ton aide.