J´essai desesperement de réaliser mon rêve, d´apprendre directX. ( J´arrete pas openGL hein). Et là rien que pour un device c´est la galère. Je suit la doc du SDK. Ya des tuto simple mais le retour en arrière ( ddraw) c´est pas tchak. Je sais vraiment plus quoi faire. Comment vous faites pour mémoriser toutes ces données vous. A titre d´exemple voila le code pour une miserable fenetre.

//------------------------------------------------
-----------------------------
/ / File: CreateDevice.cpp
/ /
/ / Desc: This is the first tutorial for using Direct3D. In this tutorial, all
/ / we are doing is creating a Direct3D device and using it to clear the
/ / window.
/ /
/ / Copyright ( c) Microsoft Corporation. All rights reserved.

//------------------------------------------------
-----------------------------

1. include < d3d9.h>

//------------------------------------------------
-----------------------------
/ / Global variables

//------------------------------------------------
-----------------------------
LPDIRECT3D9 g_pD3D = NULL; / / Used to create the D3DDevice
LPDIRECT3DDEVICE9 g_pd3dDevice = NULL; / / Our rendering device

//------------------------------------------------
-----------------------------
/ / Name: InitD3D()
/ / Desc: Initializes Direct3D

//------------------------------------------------
-----------------------------
HRESULT InitD3D( HWND hWnd )
{
/ / Create the D3D object, which is needed to create the D3DDevice.
if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;

/ / Set up the structure used to create the D3DDevice. Most parameters are
/ / zeroed out. We set Windowed to TRUE, since we want to do D3D in a
/ / window, and then set the SwapEffect to " discard", which is the most
/ / efficient method of presenting the back buffer to the display. And
/ / we request a back buffer format that matches the current desktop display
/ / format.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &3dpp, sizeof(d3dpp) ) ;
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

/ / Create the Direct3D device. Here we are using the default adapter ( most
/ / systems only have one, unless they have multiple graphics hardware cards
/ / installed) and requesting the HAL ( which is saying we want the hardware
/ / device rather than a software one). Software vertex processing is
/ / specified since we know it will work on all cards. On cards that support
/ / hardware vertex processing, though, we would see a big performance gain
/ / by specifying hardware vertex processing.
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&3dpp, &_pd3dDevice ) ) )
{
return E_FAIL;
}

/ / Device state would normally be set here

return S_OK;
}

//------------------------------------------------
-----------------------------
/ / Name: Cleanup()
/ / Desc: Releases all previously initialized objects

//------------------------------------------------
-----------------------------
VOID Cleanup()
{
if( g_pd3dDevice ! = NULL)
g_pd3dDevice->Release();

if( g_pD3D ! = NULL)
g_pD3D->Release();
}

//------------------------------------------------
-----------------------------
/ / Name: Render()
/ / Desc: Draws the scene

//------------------------------------------------
-----------------------------
VOID Render()
{
if( NULL == g_pd3dDevice )
return;

/ / Clear the backbuffer to a blue color
g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 ) ;

/ / Begin the scene
if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
{
/ / Rendering of scene objects can happen here

/ / End the scene
g_pd3dDevice->EndScene();
}

/ / Present the backbuffer contents to the display
g_pd3dDevice->Present( NULL, NULL, NULL, NULL ) ;
}

//------------------------------------------------
-----------------------------
/ / Name: MsgProc()
/ / Desc: The window´s message handler

//------------------------------------------------
-----------------------------
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
switch( msg )
{
case WM_DESTROY:
Cleanup();
PostQuitMessage( 0 ) ;
return 0;

case WM_PAINT:
Render();
ValidateRect( hWnd, NULL ) ;
return 0;
}

return DefWindowProc( hWnd, msg, wParam, lParam ) ;
}

//------------------------------------------------
-----------------------------
/ / Name: WinMain()
/ / Desc: The application´s entry point

//------------------------------------------------
-----------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
/ / Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
" D3D Tutorial", NULL };
RegisterClassEx( & ) ;

/ / Create the application´s window
HWND hWnd = CreateWindow( " D3D Tutorial", " D3D Tutorial 01: CreateDevice",
WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,
GetDesktopWindow(), NULL, wc.hInstance, NULL ) ;

/ / Initialize Direct3D
if( SUCCEEDED( InitD3D( hWnd ) ) )
{
/ / Show the window
ShowWindow( hWnd, SW_SHOWDEFAULT ) ;
UpdateWindow( hWnd ) ;

/ / Enter the message loop
MSG msg;
while( GetMessage( &, NULL, 0, 0 ) )
{
TranslateMessage( & ) ;
DispatchMessage( & ) ;
}
}

UnregisterClass( " D3D Tutorial", wc.hInstance ) ;
return 0;
}

Vous avez appris l´API windows en premier?

J´ai horreur de ce genre d´usine a gaz. C´est pour cela que j´utilise des libs graphique haut niveaux, pour pas a avoir a toucher a ce caca la ( J´ai passé l´age de mettre les mains dans le camboui).

faut bien que dans le code que tu postes, beaucoup relève de win32 ( nouvelle classe de fenetre, création de cette dernière, boucle de messages, etc.) et la complexité n´est donc pas à imputer à directX ( seule la création du LPDIRECT3DDEVICE9 dans ton cas).

Cela dit c´est sympa de connaitre tout le processus de création des applis win : dès qu´on veut faire des trucs un peu amusants, on est obligé de mettre les mains là-dedans ( ex. simple : faire que lors d´un resize, la fenetre conserve le meme aspect ratio). On peut le faire avec des trucs de plus haut niveau, mais on peut y voir des avantages ( dessiner sur une fenetre non rectangulaire, etc.) Bref, c´est pas non plus palpitant une fois ce bout de code en place, t´y toucheras quasiment plus, ensuite tu pourras vraiment t´amuser avec DX.

En attendant, je te conseille d´utiliser le wizard pour générer toute la partie init du code, c´est TRES fastidieux à faire ( rechercher un device compatible, énumerer les périphériques,etc.) c´est super chiant et on apprend rien... Un coup de wizard, et t´as directement une appli directx que t´as plus qu´à modifier pour tes besoins !

+voir

et quant à mémoriser, à force d´utiliser on trouve ça presque intuitif ; commence aussi à bien comprendre comment est construite la doc : elle est TRES grosse et on perd vite du temps à chercher. Sinon tu peux commencer avec les exemples du SDK, on apprend assez bien en comprennant ce qu´ils font, puis en les modifiants. Ensuite on intègre facilement ce qu´on a retenu dans son propre programme.

je suis fort d´accord avec LGV.

DX on est pas capable de faire un pti monde avec une fontaine en 2 heures comme en OpenGL.
a la difference, que, une fois ta fontaine finie, en OpenGL tu te dis " tiens ca serait joli une texture sur mon sol" et la tu comprends que il va te falloir une semaine a écrire le code pour charger un PNG avec channel alpha sur ton sol.
alors que en DirectX tout est incorporé.

bien sur ceux qui prennent parti vont tout de suite dire " OGL c pas fait pour ca, c une pure librairie de 3D pas un rammassi de 100aine de fonctions incompréhensibles et inutiles"
je pense pas que ce soit vrai.
pour moi DX est plus intègre que OGL.
un OLGiste doit avoir recours a 2 librairies au moins en plus pour faire un programme " complet" sans reprogrammer tout lui meme.
et ca devient un gros bordel, les constantes se mélanges, les notations divergent, les inclusions sont un casse tete, erreurs de linkage etc...
avec DirectX tout est incorporé et quand tu arrive au stade du stencil buffer ou des pixels shaders programmable tu n´a pas la barriere de l´implémentation.

drawback:
-DX est long a prendre en main
-que sous windows
-la version > = 9.0 ne marche plus sous win 95.
-ca demande a l´user de d/ler 30 Mo de runtime
( ou alors de les avoir sur un CD d´un autre jeu)
-c´est microsoft

mais bon, la qualité est derriere.
OGL est aussi de qualité, mais pas homogenement.
la prog est bien, c´est libre portable tout ca, c de SUN. mais ya pas toutes les possibilités et une grosse SDK tres bien présentée.

j´aimerais pas me faire geuler dessus par des pros OGListes je connais la valeur de cette API mais je pense que pour un programmeur non militant du monde libre, et qui as pas envie d´avoir les problemes de libs et d´avoir un grand nombre de fonctions disponibles, DX est qqch de tres bien pour lui.

maintenant du coté technique, j´ai mis plus d´un mois avant de bien cerner l´aspect Interface.
en fait DX est resolument tourné objet, il faut comprendre le principe a l´aide des exemples et au final ca va bien mieux.

une fois kon a mis en place notre fenetre et notre boucle de messages ( ca ne releve que de la Sdk Win32 et non de DX, vous faisiez koi alors avec OGL ? rien ? ben c peut etre Glut qui vous l´a permis, essayez OGL classique faudra faire exactement la meme chose) comme l´a dit LGV ca va bien mieux apres.

Moi je veut faire tout moi-même comme je fait avec openGL et GLUT en ce moment mais l´api win32 est beaucoup moins intuitive. Sinon les evenements, le WndProc j´ai compris. Il me manque le savoir pour savoir refaire cette fenetre.

Lightness2^10 : +1; tout pareil ! avec DX on a tout, on peut utiliser rapidement et se concentrer sur son prog, pas sur des fonctions utilitaires à l´interet plus que limité... et avoir en plus le son, la vidéo, le reseau, les périphériques de jeu, etc. ça en fait vraiment un framework intègre et complet.

MrGoto : c´est bien dans une certaine mesure de voulour tout faire. On comprend mieux, mais ça te prendra vite BEAUCOUP de temps ! . .. pour ta 1ere appli, fait tout à la main si tu veux, mais assez simpliste ( taille de fenetre fixe, pas de mode plein écran pour éviter les device lost, etc.). Ensuite, générère du code avec le wizard, et tu verras le nombre gigantesque de cas spéciaux à prendre en compte ( genre, y´a deux cartes graphiques, l´affichage se fait en mode overlay sur un 2e écran, le format que tu demandes n´est pas dispo, etc.) !

oui voila je me disai pareil. Mais là je me paume trop dans le wizard.

Je me dit que comme là ya quasiment que de l´api win32 autant suivre des tut a son propos. Ahlala j´ai tellement de chose à faire...

courage, la prise en main est longue...

Je ne pense pas que dx soit plus long a prendre en main. C´est juste la creation de la fenetre qui fait peur. Les concepts entre les dx ou opengl sont les meme. Arriver a dessiner un triangle avec dx ou opengl c´est la meme chose. Sur le net il y a plein de " glut" like pour creer des fenetres windows et ne pas s´en oqp.

Je ne vais pas repondre a lightness mais on voit qd meme bien son parti pris... Comme ca sert a rien de faire une guerre opengl/directx je ne dirais qu´une chose :
Un programme bien fait, separe totalement le code " rendu" du reste. Si tout est separe, alors apres utiliser directx pour afficher un triangle ou opengl c´est la meme chose. Rendre transparent l´utilisation de dx ou opengl c´est une bonne habitude a prendre des le debut.

Moi je ne vois pas ce qu´il y a de fastidieux dans le source que tu viens de poster. On ne peut pas faire plus simple, si, en utilisant la SDL tu as 1 seule fonction qui te crée ta fenetre, mais alors après tu n´as plus aucun controle dessus, c´est assez dommage.

Depuis DirectX8, la création du Device est réduite à une seule fonction, heureusement car la c´etait VRAIMENT fastidieux, il fallait se créer toutes surfaces a la main en prenant soin de tout bien detecter et parametrer, et là c´etait chiant.

Maintenant il n´y a plus que 2 fonctions : 1 Ppour initialiser DirectX et 1 pour initialiser Direct3D, je ne vois pas comment on peut faire simple.

Quand a la gestion de la fenetre, c´est comme çà sous Windows, c´est comme çà sous X11, c´est de la prog evenementielle, moi j´aime bien, c´est propre et pratique. Ca vous gonfle tout les parametres a passer au CreateWindow ? ce code est le B.A. BA d´une application windows, un simple copier-coller suffit. Alors vous allez me dire : pourquoi ne pas faire une fonction qui crée la fenetre tout seul ? bah moi je suis pas d´accord, selon mon appli j´ai besoin d´une fenetre qui se resize, ou qui soit de taille fixe, avec ou sans border, un menu, peut etre un icone, peut etre pas... toutes les options sont importantes je ne vois pas comment on peut s´en passer.

Et pour finir, entre nous, je trouve que donner un avis sur une API en se basant sur 30 lignes de code de son Init, c´est un peu leger quand meme...

" pourquoi ne pas faire une fonction qui crée la fenetre tout seul ? . ... on peut s´en passer"

Tu peux te faire un prog qui genere le code tout seul selon les parametres selectionnes, c´est mieux qu´un copier coller et c´est moins fatiguant, pcq t´as pas a retoucher a ce que tu viens de coller.
J´ai fait ca moi, et j´ai generalement jamais a me preoccuper de tout ce qui est code windows.

Tu veux dire que tu as fait un programme qui génére le code pour la fenetre windows ? Un genre de Wizard ?

g rien a redire sur ce qui a été dit, pour moi tout est correct ici.

I_am_the_law > " parti pris"
oué ta raison dsl mais je peu pas cacher mes convictions.

Dino+the_law>
alors koi?
chacun copie ou retape bien ce qu´il veut non

aller @#

Un genre de Wizard ?

Bin avec VC++ tu peux créer tes propres Project Wizard dans New>Projects tu choisis Custom AppWizard. A toi en suite d´y mettre ce que tu veux dedans, générer le code que tu veux ( paramétré par des dialogs si besoin) un peu comme le font la plupart des SDK ( le SDK de DirectX 9, le SDK pour Maya etc...)

Un genre de Wizard ?

Oui sauf que je savais pas qu´on pouvait faire ses propres wizard et les mettre ds vc. Faudra que je regarde ca
Je lancais le prog a la main et j´ajoutais ensuite le fichier cree ds le projet.

Je savais pas non plus pour le Wizard sous Visual Studio.

Merci du tips Aiton

de nada

si vous d´autres tips sympas :

La sélection carrée ( fonction un peu cachée faut dire) :

ALT+sélection à la souris d´un bloc ca donne une sélection carrée bien pratique dans certaines situations ( remplissage de tableaux etc...)

T´as bien retenu le cour de microsoft et du comique du Tablet PC.

J´arrive à créer une fenetre purement win32.
Maintenant c´est chiant les objet les device et tout. Vous avez pas une bonne adresse d´un tut qui explique bien. Parce que là la doc microsoft me sort par les trou de nez.
Même si vous voulez faire un tutorial sur un device directX9 ya pas de souci