PDA

Դիտել ողջ տարբերակը : Խաղի ծրագրավորում Directx-ով , C++ լեզվի օգնությամբ



Zte77
29.09.2009, 16:46
Մենք կանցնենք այս թեմաները.
1. Windows-ի ծրագրավորման հիմունքեր.
2. Directx 9.
3. Direct3D-ի ինիցիալիզացիան.
4. Նկարում ենք 2D- օբեկտ.
5. Մատրիցաներ.
6. Էկրանի վրա 3D- օբեկտի դուրս բերում.
7. Խորը բուֆֆեր կամ Z- բուֆֆեր.
8. Լույս և նյութեր.
9. Տեքտը Direct3D- ում.
10. Նյութերի տեղադրում.
11. Մուլտի նյութերի տեղադրում.
12. X- ֆայլի բեռնավորում.
13. DirectInput-ի ինիցիալիզացիա.
14. Աշխատանք ստեղնաշարի հետ.
15. Մկնիկ.

Առաջինը պտի իմանաք C++ հետո անցեք Directx-ին.Օրինակ կարող եք ձեր մոտ քաշել այս գիրքը հաերեն լեզվով C++ մասին http://ifolder.ru/14227612




Ամբողջը սկսվում է WinMain ( ) –ից

Բոլոր Windows- ի ծրագրերը սկսում են կատարվել WinMain ( ) ֆունկցիաից:
Բոլորը, ինչ ել ուզում եք կատարել ձեր ծրագրում, կատարվում է Winmain ( )- ում:
Ստեղծվում է պատուհան, կատարվում իրադարձությունների մշակում և դուրս բերում էկրանի վրա:
Հիմա ես ուզում եմ գրել մի ծրագիր որը դուրս կբերի փոքր պատուհանում մեր հաղորդագրությունը.

http://pic.ipicture.ru/uploads/090929/ebM4NxFze4.jpg


Պրոեկտի ստեղծում
C++ 6 ում մտեք File -> New և մտեկ Projects վկլադկաի վրա և ընտրեք Win32 Application.Project name- ում մուտքագրեք ձեր պրոեկտի անունը և Location-ում ընտրեք ֆայլերի պահպանման տեղը.Սխմեք OK և ոչ մի բան չփոխելով սխմեք FINISH, և OK.Նոր մենք ստեծեցինք մեր պրոեկտը.
Իսկ հիմա մենք պետկ է ստեղծենկ ֆայլ վորի մեջ մենք կգրենք մեր ծրագիրը.
Մտեք File -> New և Files վկլադկաի մեջ ընտրեք C++ Source File, File name –ում գրեք ձեր ֆայլի անունը և սխմեք ՕK, եվ էկրանի վրա դուրս կբերի սպիտակ տերթ որի մեջ մենք կգրենք մեր ծրագիրը. Մանրամասն կարող եք նաել վերը նշված գրքում.

C++ 2005 կամ C++ 2008- ում մտեք File -> New Project ձախ կողմում ընտրեք win32 և աջ կողմում Win32 Project name – մեջ ընտրեք պրոեկտի անունե և Location-ում ձեր պրոեկտի տեղը և սխմեք OK -> Next և սխմեք Empty Project -> Finish.Նոր մենք ստեղծեցինք մեր պրոեկտը մնացելը ստեղծել ֆայլը. Ձախ կողմում աջ կլիկով սխմեք Source Files պապկաի վրա և սխմեք Add -> New Item.Ձախ կողմում սխմեք Code- ի վրա և աջ կողմում սխմեք C++ File ( .cpp ), name-ի մեջ գրեք ձեր ֆայլի անունը և սխմեք OK.Մանրամասն կարող եք նաել վերը նշված գրքում.



Մուտքագրեք այս ծրագիրը.



#include <windows.h>

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
MessageBox(NULL, "Hello, Win32 world!", "Hello from Message Box", MB_OK);
return 0;
}

Ծրագիրը կարող եք քաշել այստեղից http://ifolder.ru/14237622



Պրոեկտի կոմպիլացիա
C++ 6 Եթե ծրագիրե պատրաստը, և ուզում ենք այն աշխատեցնել ապա մենյուից ընտրեք Builde ցանկը և բացվաց ցուցակից ընտրել Compile ( մեր ֆայլի անունը ).
Եվ ընտրեք Builde ցանկը և բացվաց ցուցակից ընտրել ! execute ( մեր ֆայլի
անունը ). Եթե ծրագրում սխալներ չկան, ապա այն աշխատացնելուց հետո
կտեսնենք փոքր պատուհան վորի մեջ գրված կլինի մեր հաղորդագրությունը.
Մանրամասն կարող եք նաել վերը նշված գրքում

C++ 2005 կամ C++ 2008 մենք պտի նաստրոյկեկի մեջ մի բան փոխենք որ սխալ չտա և ըտենց մենուի մեյ ընտրեք Project -> (մեր ֆայլի անունը ) Properties…, բացեք Configuration Properties -> General և աջ կողմում Character Set – մեջ Use Unicode Character Set սխմելով վրեն փոխեք Not set- ի վրա և սխմեք OK:
Եթե ծրագիրե պատրաստը, և ուզում ենք այն աշխատեցնել
ապա մենյուից ընտրեք Builde ցանկը և բացվաց ցուցակից ընտրել Builde Solution .
Եվ ընտրեք Debuge ցանկը և բացվաց ցուցակից ընտրել Start Without Debugging. Եթե ծրագրում սխալներ չկան, ապա այն աշխատացնելուց հետո
կտեսնենք փոքր պատուհան վորի մեջ գրված կլինի մեր հաղորդագրությունը.
Մանրամասն կարող եք նաել վերը նշված գրքում


http://pic.ipicture.ru/uploads/090929/RQeCul84T5.jpg


Ծրագրի պարզաբանում

Առաջին տողում գտնվում է

#include <windows.h>

Այս դիրեկտիվան ծրագրին միացնում է Windows-ի գլխավոր ֆայլի վերնագիրը(ավելի մանրամասն կարող եք իմանալ վերը նշվաց գրքից ).

Հետո գալիս է WinMain ( ) ֆունկցիաի վերնագիրը

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
Ֆունկցիան վերադարձնում նշանակությունը որպես int տիպ, այսինքն նրանից է միշտ սկվում աշխատանքը.

HINSTANCE hinstance – դեսկրիպտոր, որը Windows-ը տալիս է միացված ծրագրին.
HINSTANCE hprevinstance – այս պարամետրը Win32-ում չի օգտագործվում և միշտ ստանում 0 արժեք.
LPSTR lpcmdline – ցուցիչ տողի վրա, որի մեջ տպվում է ծրագրի արգումենտը եթե այն միացված է կոմանդաին տողի ռեժիմի մեջ.Ծրագիրը կարելի է միացնել կոմանդաին տողի ռեժիմի մեջ – Start -> Run(Пуск -> Выполнить ), և կոմանդաին տողի մեջ մուտքագրվում է ծրագրի անունը իսկ պրոբելից հետո ցույցեք տալի արգումենտների ցուցակը որոնք բաժանված են պրոբելներով.Եվ այս ձևով ծրագրի միացումը մնում է էկզոտիկ.Ամենաշատը այսօր ծրագրերը միանում են երկու անգամ սխմելով ֆայլի վրա, բայց այս ձևը մեզ թույլ չի տալի ծրագրին ուղարկել որևը արգումենտ.
Int ncmdshow – ամբողջ նշանակություն, որը կարող է ուղարկվել ShowWindow ֆունկցիային.Այս պարամետրը կնայվի մյուս դասում.

Պարզաբանելով ֆունկցիաի վերնագիրը կանցնենք նրա մարմնին.

Ֆունկցիան ունի հետևյալ պրոտոտիպ

MessageBox(NULL, "Hello, Win32 world!", "Hello from Message Box", MB_OK);

Նրա պարամետրերը ինտրեպետացվում են հետևյալ ձև:

hWnd – մայրական պատուհանի դեսկրիպտոր, ինքը ստանում է NULL (զրո ) արժեք եթե չունի մայրական պատուհան.
lpText – ցուցիչ տողի վրա , որը պարունակում հաղորդագրության տեքտ .
lpCaption - ցուցիչ տողի վրա, որը պարունակում է դիալոգաին պատոհանի վերնագրի տեքստ.
uType - այս պարամետրը պարունակում է դրոշների կոմբինացիան, որը տալիս է
կնոպկեկի քանաքությունը և տիպը, նաև պիկտոգրամմա ( փոքր նկար վերնագրի ձախ կողմում ).

Մյուս դասում մենք կգրենք պատուհան մեր ուզաց չափերով և նաստրոյկեկով որը օգտագործվում է 3D օբեկտների, տեկստի և այլն էկրանի դուրս բերման համար ինչպես խաղերում.Եվ մեզ ամպայման պետք կգա Directx- ը որի ծավալը 550 մեգաբայթ է կարող եք քաշել այստեղից
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=b66e14b8-8505-4b17-bf80-edb2df5abad4
ասեմ ձեզ որ առանց դրա դուք չեք կարող ստեղծել խաղ.

իմ մեիլը [email protected]

Legolas
29.09.2009, 17:05
C++ 2005 կամ C++ 2008 մենք պտի նաստրոյկեկի մեջ մի բան փոխենք որ սխալ չտա և ըտենց մենուի մեյ ընտրեք Project -> (մեր ֆայլի անունը ) Properties…, բացեք Configuration Properties -> General և աջ կողմում Character Set – մեջ Use Unicode Character Set սխմելով վրեն փոխեք Not set- ի վրա և սխմեք OK:

մի անգամ այս պռոբլեմը իմ մոտ կար, միչև գտա ... ահագին ջղայանցա:D
շատ օգտակար է, շնորհակալություն, կսպասեմ շարունակությանը:

_DEATH_
29.09.2009, 17:17
win32 api ահագին սովորել եմ, մի հատ անգլերեն գիրք էր կեժամում կարդացի, երկու օրում մի հատ 1500 տողանոց ծրագիր գրեցի, հետո էտ նույն ծրագիրը Քյուտով գրեցի 152 տող, դրանից հետո էլ ոչ մի անգամ win api-ով ծրագիր չեմ գրել ու դժվար էլ գրեմ…

aerosmith
29.09.2009, 17:18
Ապրես , շատ լավ թեմայես բացել:
Կարծում եմ C++ վին.ծրագրավորում սովորել ցանկացողներին ահագին կոգնի…
Միայն շարունակական կդարձնես այս թեման…

Yellow Raven
29.09.2009, 17:18
Կսպասեմ շարունակությանը:)

_DEATH_
29.09.2009, 17:25
Ով ուզում ա սովորի Win32 API-ն ու անգլերեն գիտի խորհուրդ եմ տալիս կարդալ այս (http://www.winprog.org/tutorial/start.html) tutorial-ը: Սկսելու համար ավելի լավ նյութ դժար թե ճարեք…

aerosmith
29.09.2009, 17:28
անձամբ ես կասեմ, որ անգլերենմ չիմանալը էդքան էլ չի խոչնդոտում ծրագրավորում սովորելուն…
որտև եթե սովորողը, գոնե մի քիչ էլ ծրագրավորումից տեղյակա, ուրեմն իրան հերիքա մենակ բերված օրինակները հեղինակների կողմից

_DEATH_
29.09.2009, 17:33
անձամբ ես կասեմ, որ անգլերենմ չիմանալը էդքան էլ չի խոչնդոտում ծրագրավորում սովորելուն…
որտև եթե սովորողը, գոնե մի քիչ էլ ծրագրավորումից տեղյակա, ուրեմն իրան հերիքա մենակ բերված օրինակները հեղինակների կողմից

Դե լեզուն կարող ա, բայց win api-ն դժվար թե առանց տեխնիկական անգլերեն իմանալու մեկը կարողանա էտ իմ ասածով նորմալ մի բան սովորի: Որովհետև լրիվ տրամաբանությունից հեռու բան ա, մենակ պտի կարդաս ինչը ինչի համար ա ու ինչը ոնց ա արվում: Իսկ օրինակը ոչ մի բան չի ասում, որովհետև "պարզ" անգլերենից շատ հեռու ա:

Zte77
30.09.2009, 13:32
Այսօր մենք կսետղցենք այսպիսի պատուհան
http://pic.ipicture.ru/uploads/090930/TRM8SxnvwN.jpg
Մեր նայաց ծրագիրը կարող եք բեռնավորել(քաշել) ստեղից http://ifolder.ru/14252971

Windows- ի ծրագրավորման հիմունքներ

Մինչև որ մենք կանցնենք գրաֆիկաի ծրագրավորման Directx – ի օգնությամբ,մեզ անհրաժեշտ է ստեղծել ծրագրի կարկաս , որը հանդիսանում է մակերես 3D – ի դուրս բերմանը.Ստեղծելով ժրագրի կարկաս մենք կարող ենք անցնել գրաֆիկաի ծրագրավորմանը նկարելով տարբեր 3D- օբեկտներ.


Windows-ի ընդհանուր հաղորդագրության մոդել

Windows-ը շատ հետքաքրքիր օպեռացիոն համակարգ է և բոլոր ծրագրերի հետ շփումը կառուցվում է իրադարձությունների մոդելով.Ցանկացած պատուհան իր գոյության ժամանակ շփվում է Windows-ի հետ հահորդագրություններով.
Այսպիսի հաղորդագրությունները կարողեն լինել անվերջ.Որպեսզի սիստեմացնենկ նրանց, գոյություն ունի իրադարձությունների հերթ, որը կատարվում է հասարակ ցիկլով.Ամեն մի ստացաց հաղորդագրություն սպասում է իր հերթին մշակման համար, որից հետո հանվում է Windows-ի օպեռացիոն համակարգով.Քանի որ Windows-ը շատ մեծ և բազմակարգանի օպեռացիոն համակարգ է, ապա ծրագրերը ինչ որ մի ժամանակաշրջանում կարող են լինել շատ,նշանակում է , և ստացող հաղորդագրությունները նոյնպես.

Նկ1 վրա ցույց է տրված ծրագրի իրադարձությունների համագործակցություն.
http://pic.ipicture.ru/uploads/090930/bNTzZSZtlb.jpg


Իրադարձությունների մոդելից դուրս է գալի որ մեզ անհրաժեշտ է ստեղծել հաղորդագրությունների մշակող սարք.Սկզբից մենք կստեղծենք WinMain ( )ֆունկցիա որի մեջ կատարվում է պատուհանի ստեղծումը և հաղորդագրությունների մշակում.Այս պատճառով սկզբից մենք կստեղծենկ WinMain ( ) ֆունկցիա, որի մեջ կնկարագրենկ windowsclass դասս(class), որի մեջ ցույց կտանկ պատուհանի չափը,ձևը և ֆոնը.
Հետո մենք կստեղծենք պատուհան CreateWindowEx ( ) ֆունկցիայի օգնությամբ.Հետո կգրանցենք, և վերջում կստեղծենք իրադարձությունների մշակող սարք.


Գլխավոր WinMain ( ) ֆունկցիա

Առաջինը մենք պետկ է միացնենկ գլխավոր վերնագրի windows.h ֆաիլ.

#include <windows.h>

Հետո գալիս է գլխավոր մուտքի ֆունկցիա բոլոր Windows-ի հավելվածների(приложение) համար:WinMain ( ) որի պրոտոտիպը ունի հետևյալ տեսք

Int WINAPI WinMain (
HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
Int ncmdshow )

WinMain ( ) ֆունկցիան ունի հետևյալ պարամետրեր.

Hinstance – դա ստեղծվող պատուհանի դեսկրիպտոր, այսինքն handle.Դա կարելի է ասել ձեր ստեղծվող պատուհանի նշանը.
Hprevinstance – այս պարամետրը արդեն չի օգտագործվում և միշտ ստանում է 0.
Lpcmdline – ցուցիչ կոմանդաին տողի վրա.
Ncmdshow – այս նշանակությունը ցույց է տալիս, ինչպես է ստեղծվող պատուհանը ցույց է տրվելու մոնիտորի էկրանի վրա ստեղծման ժամանակ.

windowsclass –ի դասի պարզաբանում

Հետո մեզ անհրաժեշտ է ստեղծել windowsclass դաս.Դաս – դա այն է որ մեզ տալիս է տարբերել պատուհանի տեսքը և նշանակությունը.Հաճախ ասում են որ պատուհանները իրարից տարբերվում են դասերով.Windows-ը արդեն ունի որոշված դասեր և մնում է պահպանել ինֆորմացիա windowsclass – ի դասի ստեղծումը WNDCLASSEX ստրուկտուրայում.



WNDCLASSEX windowsclass // մեր դասը(class)

Իսկ հիմա կնաենք WNDCLASSEX ստրուկտուրա, որը անհրաժեշտ է պատուհանի ստեղծման համար:

typedef struct {
UINT cbSize;
UINT style;
WNDPROC lpfnWndProc;
int cbClsExtra;
int cbWndExtra;
HINSTANCE hInstance;
HICON hIcon;
HCURSOR hCursor;
HBRUSH hbrBackground;
LPCTSTR lpszMenuName;
LPCTSTR lpszClassName;
HICON hIconSm;
}WNDCLASSEX, *PWNDCLASSEX;

Ստրուկտուրան ունի հետևյալ պարամետրերը.

cbSize – դա ստեղծվող ստրուկտուրաի չափը, windowclass.cbSize = sizeof ( windowclass ),
եթե մոռացելեք sizeof ( ) ֆունկցիայով մենք ստանում ենք ինչ որ մի բանի չափ.
Style – ունի պատուհանի ձևի տարբեր դրոշներ որոնց կարելի է կոմբինացնել լոգիկ ИЛИ “|” , լրացնում ենք style տող:

windowsclass.style = CS_HREDRAW | CS_VREDRAW;

Կոմբինացնելով տարբեր դրոշներ.Ուսումնասիրենք օգտագործվող դրոշներ.Եթե ուզում եք իմանալ ավելին ապա դուք կարող եք դիմել Win32Api.

CS_VREDRAW - եթե պատուհանի բարձրությունը փոխվում է կամ պատուհանը տեղափոխվել է ապա անհրաժեշտ է պատուհանը վերանկարել.
CS_HREDRAW – եթե պատուհանի լայնությունը փոխվում է կամ պատուհանը տեղափոխվել է ապա անհրաժեշտ է պատուհանը վերանկարել.
CS_OWNDC – ամեն մի պատուհանի համար տվյալ դասի համար տրվում է իր սարքի կոնտեկստ.
CS_DBLCLKS – երբ կատարվել է երկու կլիկ մկնիկով, պատուհանին հաղորդվում է 2 անգամ սղմում մկնիկով ինֆորմացիա.

lpfnWndProc – դա ցուցիչ է ֆունկցիաի հակառակ կանչմանը.Ամեն մի Windows-ի հավելվածում(приложение) գոյություն ունի իրադարձությունների մշակման ցիկլ որի աշխատանքի ժամանակ կատարվում է MainWinProc – ի կանչում.
Երկու հատ տող cbClsExtra և cbWndExtra, նախատեսված են լրացուցիչ ինֆորմացիաի պահպանման համար.Սակայն նրանց հազվադեպ են օգտագործում, մեզ Directx –ում այն պետկ չի գալու.Այս պատճառով գրում ենք. Windowsclass.cbClsExtra = 0; windowsclass.cbWndExtra = 0;
hinstance – պարամետր, որը պատասխանում է ստեղծվող նմուշի հավելվածին.որը հաղորդվում է WiMain ( ) ֆունկցիայով. Windowsclass.hInstance = hinstance;
hIcon – ծառայում է ձեր հավելվածում պիկտոգրամաի( փոքր նկար վերնագրի ձախ կողմում ) որոշման համար.LoadIcon ( ) ֆունկցիաի օգնությամբ կարելի է բեռնավորել սեփական կամ Windows-ի պիկտոգրամմա.LoadIcon ( ) –ի պրոտոտիպը ունի հետևյալ տեսք.
HICON LoadIcon ( HINSTANCE hinstance, LPCTSTR IconName );
Hinstance – հավելվածի նմուշ, որպեսզի բեռնավորենք ստանդարտ պիկտոգրամմա, օգտագործվում է NULL նշանակություն;
LpIconName – դա բեռնավորվող պիկտոգրամմաի աղբյուրի ինդենտիֆիկատորն է.Այստեղ մենք օգտագործում ենք IDI_APPLICATION .Պրոտոտիպը հետևյալն է
Windowsclass.hIcon = LoadIcon ( hinstance, IDI_APPLICATION );

hCursor – Այս պարամետրը պատասխանում է կուրսորի համար.Ինքը գրվում է հետևյալ ձև
windowsclass.hCursor = LoadCursor ( NULL, IDC_ARROW );
hbrBackground – այս ստրուկտուրաի տողը ,պատասխանում է պատուհանի ֆոնի գույնի համար.Որպեսզի ներկենք ֆոնը մեր ուզաց գույնով, պետկ է օգտագործել GetStockObject ( ) ֆունկցիա, որը ընդունում է մեկ դրոշի պարամետր, որը որոշում է վրձինի գույնը.Որպեսզի ֆոնը ներկենք սերիյ գույնի կգրենք սա;
windowclass.hbrBackground = ( HBRUSH ) GetStockObject ( WHITE_BRUSH );
Կարելի է ներկել նաև ոևրիշ դրոշներով, նրանց ցուցակը:
GRAY_BRUSH – սերիյ վրձին.
BLACK_BRUSH – սև վրձին.
WHITE_BRUSH – սպիտակ գույնն է որով մենք ներկում ենք մեր պատուհանի ֆոնը.
LTGRAY_BRUSH – բաց – սերիյ վրձին.
DKGRAY-BRUSH – մութ – սերիյ վրձին.
HOLLOW_BRUSH – դատարկ վրձին.

lpszMenuName – տող, որը անհրաժեշտ է ստանդարտ մենյուն պատուհանին միացնելու համար.Մեր մոտ դրված է NULL նշանակություն, քանի որ մենք չենք օգտագործելու մենյուն մեր պրոեկտենեորւմ: windowsclass.lpszMenuName = NULL.
lpszClassName – տրվում է մեր պատուհանի դասի անվանումը , ստեղծվող հավելվածի համար: Windowsclass.lpszClassName = “WINDOWSCLASS”;
hIconSm – սա ստեղծվող փոքր պիկտոգրամմաի դեսկրիպտորն է, որը դուրս է բերվում պանելի խնդրի վրա .
windosclass.hIconSm = LoadIcon ( NULL, IDI_APPLICATION );

Վերջացնելով բոլոր տողերի լրացումը նաենք թե ինչ է ստացվել:



windowsclass.cbSize = sizeof(WNDCLASSEX);
windowsclass.style = CS_DBLCLKS | CS_OWNDC |
CS_HREDRAW | CS_VREDRAW;
windowsclass.lpfnWndProc = MainWinProc;
windowsclass.cbClsExtra = 0;
windowsclass.cbWndExtra = 0;
windowsclass.hInstance = hinstance;
windowsclass.hIcon = LoadIcon(hinstance, IDI_APPLICATION);
windowsclass.hCursor = LoadCursor(NULL, IDC_ARROW);
windowsclass.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
windowsclass.lpszMenuName = NULL;
windowsclass.lpszClassName = "WINDOWSCLASS";
windowsclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);



Դրանից հետո երբ դուք լրացրել եք և պահպանել եք նշանակությունները windosclass փոփոխականում, windowsclass – ը պետկ է գրանցել.Արվում է դա RegistrerClassEx ( ) ֆունկցիայով. RegisterClassEx ( & windowsclass ); // գրանցում ենք ստեղծված դաս(class ).


Ստեղծում ենք պատուհան

Դրանից հետո երբ դասը(class) գրանցված է,կարելի է ստեղծել պատուհան.Դա արվում է CreateWindowEx ( ) ֆունկցիայով.Նրա տեսքը հետևյալնը:



HWND CreateWindowEx(

DWORD dwExStyle,
LPCTSTR lpClassName,
LPCTSTR lpWindowName,
DWORD dwStyle,
int x,
int y,
int nWidth,
int nHeight,
HWND hWndParent,
HMENU hMenu,
HINSTANCE hInstance,
LPVOID lpParam
);



CreateWindowEx ֆունկցիայի պարամետրերը հետևյալն են:

dwExStyle - պատուհանի ձևի դրոշներ,կարելի է ասել որ չի օգտագործվում և ստանում է NULL.
LpClassName – դա ստեղծվող պատուհանի անվանումն է, մեր դեպքում “WINDOWSCLASS”.
LpWindowName – դա մեր պատուհանի վերնագիրն է ստեղ կարող եք գրել ինչ ուզում եք, մենք կոգտագոծենք “Bazain patuhan Directx-i hamar”.

Dwstyle- դա դրոշ է, որը նկարագրում է պատուհանի ձևը և վարքը.
Ահա և նրանց մի քանիսը:
WS_OVERLAPPED – պատուհան շերտի վերնագրով և րամկա.
WS_VISIBLE – սկզբնականից տեսնվող պատուհան.
WS_CAPTION – պատուհան շերտի վերնագրով ( ինքը իր մեջ ընկալում է WS_BORDER ձև ).
WS_BORDER – պատուհան բարակ րամկաով.
WS_ICONIC – պատուհանը սկզբնականից փոքրացված է.
WS_OVERLAPPEDWINDOW – ծածկվող պատուհան ( որը իր մեջ ընկալում է հետևյալ վեցը ձև: WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU, WS_THICKFRAME, WS_MINIMIZEBOX –նրան մենք և կոգտագործենք.
WS_MINIMIZE – սկզբնականից մինիմիզացվաց պատուհան.
WS_MAXIMIZE – սկզբնականից մակսիմազված պատուհան.
WS _MAXIMIZEBOX – պատուհան MAXIMIZE կնոպկայով .
WS_MINIMIZEBOX – պատուհան MINIMIZE կնոպկայով.

x, y – դա վերևի ձախ անկյունի պատուհանի դիրքն է.Նրանց կորդինատները կդնենք x -300 ,y – 150.
nwidth և nheight - պատուհանի լայնությունը և բարձրությունը.Մենք կդնենք 500 և 400.
hwndParent – մայրական պատուհանի դեսկրիպտոր,եթե մայրական պատուհան չկա ապա օգտագործվում է NULL նշանակություն.
Hmenu – մենուի դեսկրիպտոր, եթե դուք ունեք մենու կարող եք ցույց տալ նրան.Եթե մենյուն չկա ապա դրվում է NULL նշանակություն.
Hinstance – ձեր պատուհանի նմուշն է, օգտագործում է hinstance նշանակություն.

Այս պահին մեզ հայտնի է ֆունկցիայի բոլոր նշանակությունները.Ստեղծենք պատուհան.
Կհայտարարենք պատուհանի դեսկրիպտոր և կկանչենք CreatWindowEx ( ) ֆունկցիա.

HWND hwnd;
hwnd = CreateWindowEx(NULL, // պատուհանի ձևը
"WINDOWSCLASS", // դաս(class)
"Урок 1. Базовое Окно для DirectX ", // պատւհանիանվանում окна
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
300,150, // վերևի ձախ անկյուն
500,400, // լայնություն և բարձրություն
NULL, // մայրական պատուհանի դեսկրիպտոր
NULL, // մենուի դեսկրիպտոր
hinstance, // նմուշի դեսկրիպտոր
NULL)))
http://pic.ipicture.ru/uploads/090930/J5zL6zCL6c.jpg
Դրանից հետո երբ պատուհանը ստեղծված է ,Նրան պետկ է դուրս բերել և թարմացնել.
Դա կատարվում երկու ֆունկցիաներով.


ShowWindow( hwnd, SW_SHOWDEFAULT ); //Կնկարենք պատուհան
UpdateWindow( hwnd ); //Կթարմացնենք պատուհան

Zte77
30.09.2009, 13:35
Իրադարձությունների մշակում Windows-ում

Windows- ում իրադարձությունները մշակվում են ձեր ստեղծաց իրադարձությունների մշակիչ սարքով.Հավելվածի աշխատանքի ժամանակ գեներացվում են տարբեր հաղորդագրություններ որոնք հաղորդվում են հերթ.Որից հետո իրադարձությունների մշակիչը վերցնում է նրանց և հաղորդում է MainWinProc ( ) ֆունկցիային մշակման համար.

Նաենք MainWinProc – ի պրոտոտիպը.

LRESULT CALLBACK MainWinProc ( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )

MainWinProc –ի պարամետրերը հետևյալն են.

Hwnd – պատուհանի դեսկրիպտոր.
Msg – իրադարձությունների ինդենտիֆիկատոր, որը պետկ է հաղորդվի MainWinProc ( ) ֆունկցիային մշակման համար.
wparam և lparam - դա իրադարձությունների մշակման լրացուցիչ պարամետրերն են.Իրադարձությունների մշակիչ գրելու համար հաճախ օգտագործվում է switch ( msg ) կոնստրուկցիան.Նաենք մի քանի հաղորդագրություն ,որոնք կարող են պետկ գալ խաղի ստեղծման համար.

WM_PAINT – այդ հաղորդագրությունը ուղարկվում է երբ մեզ պետկ է վերանկարել ամբողջ պատուհանը, որը կարող էր տեղփոված լինել կամ չափ է փոխվել.
WM_DESTROY - այդ հաղորդագրությունը ուղարկվում է Windows, երբ պատուհանը պետկ է փագվի.
WM_QUIT - դրանից հետո կանչվում է այդ հաղորդագրությունը, որը և փագում է պատուհանը.

Միավորելով իրար մենք կստանանք MainWinProc ( ) ֆունկցիա.


LRESULT CALLBACK MainWinProc(HWND hwnd,
UINT msg, WPARAM wparam,
LPARAM lparam)
{

switch(msg)
{


case WM_PAINT:
break;

case WM_DESTROY:
{
PostQuitMessage(0);
return(0);
} break;

}

return (DefWindowProc(hwnd, msg, wparam, lparam));
}


PostQuitMessage ( 0 ) ֆունկցիան QUIT ֆունկցիաին դնում է հերթին. Որը և կփագի ձեր պատուհանը.DefWindowProc ( ) ֆունկցիան մշակում է այն հաղորդագրությունները որոնք դուք չեք օգտագործում.


Գլխավոր իրադարձությունների մշակիչ

Կնաենք գլխավոր իրադարձությունների մշակիչ, որը օգտագործվում է հետևյալ օրինակում:

while(GetMessage(&msg,NULL,0,0))
{

TranslateMessage(&msg);

DispatchMessage(&msg);
}

While ցիկլը կատարվում է եդքան մինչև GetMessage ( ) ֆունկցիան վերադարձնում ոչ զրո նշանակություն.Ցիկլի աշխատանքը կատարվում է հետևյալ ձև երբ ստանում ենք հերթից հաղորդագրություն ինքը մշակվում է TranslateMessage ( ) ֆունկցիայով և հաղորդվում է DispatchMessage ( ) ֆունկցիային, որը կանշում է MainWinProc ( ) ֆունկցիա մշակմա համար, հաղորդելով նրան ամբողջ պետկական ինֆորմացիա.

Հիմա նաեք թե ինչ է մեր մոտ ստացվել.
Մեր նայաց ծրագիրը կարող եք բեռնավորել(քաշել) ստեղից http://ifolder.ru/14252971

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

#include <windows.h> // Միացնում ենք Windows-ի վերնագրի ֆաիլ
#include "resource.h"

//----------------------------------------------------------------------------------------
// Ֆունկցիա
// MainWinProc()
//Ստեղ կատարվում է իրադարձությունների մշակում
//----------------------------------------------------------------------------------------

LRESULT CALLBACK MainWinProc(HWND hwnd, //Պատուհանի դեսկրիպտոր
UINT msg, //հաղորդագրության ինդենտիֆ.
WPARAM wparam, //լրացուցիչ ինֆորմացիա
LPARAM lparam) // լրացուցիչ ինֆորմացիա
{

switch(msg)
{


case WM_PAINT:
break;

case WM_DESTROY:
{
PostQuitMessage(0);
return(0);
} break;

}

return (DefWindowProc(hwnd, msg, wparam, lparam));
}
//---------------------------------------------------------------------------------------
// Ֆունկցիա
// WinMain()
//---------------------------------------------------------------------------------------

int WINAPI WinMain( HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{

WNDCLASSEX windowsclass; // Ստեղծում ենք դաս(class)
HWND hwnd; // Ստեղծում ենք պատուհանի դեսկրիպտոր
MSG msg; // Հաղորդագրություն


// Определим класс окна WNDCLASSEX
windowsclass.cbSize = sizeof(WNDCLASSEX);
windowsclass.style = CS_DBLCLKS | CS_OWNDC |
CS_HREDRAW | CS_VREDRAW;
windowsclass.lpfnWndProc = MainWinProc;
windowsclass.cbClsExtra = 0;
windowsclass.cbWndExtra = 0;
windowsclass.hInstance = hinstance;
windowsclass.hIcon = LoadIcon(hinstance, IDI_APPLICATION);
windowsclass.hCursor = LoadCursor(NULL, IDC_ARROW);
windowsclass.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
windowsclass.lpszMenuName = NULL;
windowsclass.lpszClassName = "WINDOWSCLASS";
windowsclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

// Կգրանցենք դասը(class)
if (!RegisterClassEx(&windowsclass))
return(0);

// Երբ դասը(class) գրանցված է կարելի է ստեղծել պատուհան

if (!(hwnd = CreateWindowEx(NULL, // պատուհանի ձևը
"WINDOWSCLASS", // դաս(class).
" Bazain patuhan Directx-i hamar ", // անվանում о
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
300,150, // վերևի ձախ անկյու
500,400, // լայնություն և բարձրություն
NULL, // մայրական պատուհանի դեսկրիպտոր
NULL, // մենուի դեսկրիպտոր
hinstance, // հավելվածի նմուշի դեսկրիպտոր
NULL))) //
return(0);


ShowWindow( hwnd, SW_SHOWDEFAULT ); //Կնկարենք պատուհան
UpdateWindow( hwnd ); //Կթարմացնենք պատուհանը

while(GetMessage(&msg,NULL,0,0))
{

TranslateMessage(&msg);

DispatchMessage(&msg);
}


return(msg.wParam);

}

Կոմպիլացիաից հետո կտեսնեք դա
http://pic.ipicture.ru/uploads/090930/TRM8SxnvwN.jpg

Մյուս դասում մենք կավելացնենք մեր պատուհանի կոդին Directx- ի կոդը.Եվ մյուս դասում մենք կվերջացնենք պատուհանի ստեղծելը և կանցնենք գրաֆիկաի ծրագրավորմանը , 3D օբեկտների դուրս բերում մեր ստեղծաց պատուհանում.

Chuk
30.09.2009, 13:57
Մոդերատորական. «I.դաս: Խաղի ծրագրավորում Directx-ով , C++ լեզվի օգնությամբ», «2.դաս խաղի ծրագրավորում Directx –ով, C++ լեզվի օգնությամբ:Ստեղծում ենք պատուհան(1)» և «2.դաս խաղի ծրագրավորում Directx –ով, C++ լեզվի օգնությամբ:Ստեղծում ենք պատուհան(2)» թեմաները միացվել են իրար ընդհանուր «Խաղի ծրագրավորում Directx-ով , C++ լեզվի օգնությամբ» վերնագրի տակ, որպեսզի ավելորդ խառնաշփոթ չստեղծվի, հետաքրքրվողի համար հարմար լինի օգտվելը:

d4rkme551ah
30.09.2009, 14:27
Ավելի ճիշտ կլինի տեղափոխել բլոգ:

Legolas
30.09.2009, 15:46
Նման նյութերը գուգլում շատ են, բայց սրանք դրանց նկատմամբ ունեն մի մեծ առավելություն՝ հայերեն են:
Ուշադրություն դարձրու նաև ճիշտ հայերեն շարադրանքին, այդպես ավելի հաճելի է կարդալ:

Zte77
30.09.2009, 16:11
Նման նյութերը գուգլում շատ են, բայց սրանք դրանց նկատմամբ ունեն մի մեծ առավելություն՝ հայերեն են:
Ուշադրություն դարձրու նաև ճիշտ հայերեն շարադրանքին, այդպես ավելի հաճելի է կարդալ:

Ետ իմ մոտ դրանիցա որ ռուսերենը ավելի լավ գիդեմ քան թե հաերենը

Legolas
01.10.2009, 11:03
Ետ իմ մոտ դրանիցա որ ռուսերենը ավելի լավ գիդեմ քան թե հաերենը

վոոոոոոոոոոոոոյ, նու տագդա նալիվայ, պագավարիմ,
պռա մուժսկիե ձելա
ի պռա ժենսկիե ծելա
:drinks

իսկ եթե լուրջ, համ գրի օգտակար նյութերը, համ ուշադրություն դարձրու հայերենին,
մենք ծրագրավորում ու հայերեն կսովորենք, դու՝ հայերեն: :D
Վերջիվերջո սա հայերեն սովորելու մեծ դարբնոց ա:

xaker00
01.10.2009, 20:37
Ամբողջը սկսվում է WinMain ( ) –ից

Բոլոր Windows- ի ծրագրերը սկսում են կատարվել WinMain ( ) ֆունկցիաից:
Բոլորը, ինչ ել ուզում եք կատարել ձեր ծրագրում, կատարվում է Winmain ( )- ում:
Ստեղծվում է պատուհան, կատարվում իրադարձությունների մշակում և դուրս բերում էկրանի վրա:
Հիմա ես ուզում եմ գրել մի ծրագիր որը դուրս կբերի փոքր պատուհանում մեր հաղորդագրությունը.



Պրոեկտի ստեղծում
C++ 6 ում մտեք File -> New և մտեկ Projects վկլադկաի վրա և ընտրեք Win32 Application.Project name- ում մուտքագրեք ձեր պրոեկտի անունը և Location-ում ընտրեք ֆայլերի պահպանման տեղը.Սխմեք OK և ոչ մի բան չփոխելով սխմեք FINISH, և OK.Նոր մենք ստեծեցինք մեր պրոեկտը.
Իսկ հիմա մենք պետկ է ստեղծենկ ֆայլ վորի մեջ մենք կգրենք մեր ծրագիրը.
Մտեք File -> New և Files վկլադկաի մեջ ընտրեք C++ Source File, File name –ում գրեք ձեր ֆայլի անունը և սխմեք ՕK, եվ էկրանի վրա դուրս կբերի սպիտակ տերթ որի մեջ մենք կգրենք մեր ծրագիրը. Մանրամասն կարող եք նաել վերը նշված գրքում.

C++ 2005 կամ C++ 2008- ում մտեք File -> New Project ձախ կողմում ընտրեք win32 և աջ կողմում Win32 Project name – մեջ ընտրեք պրոեկտի անունե և Location-ում ձեր պրոեկտի տեղը և սխմեք OK -> Next և սխմեք Empty Project -> Finish.Նոր մենք ստեղծեցինք մեր պրոեկտը մնացելը ստեղծել ֆայլը. Ձախ կողմում աջ կլիկով սխմեք Source Files պապկաի վրա և սխմեք Add -> New Item.Ձախ կողմում սխմեք Code- ի վրա և աջ կողմում սխմեք C++ File ( .cpp ), name-ի մեջ գրեք ձեր ֆայլի անունը և սխմեք OK.Մանրամասն կարող եք նաել վերը նշված գրքում.



Մուտքագրեք այս ծրագիրը.



#include <windows.h>

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
MessageBox(NULL, "Hello, Win32 world!", "Hello from Message Box", MB_OK);
return 0;
}

Ծրագիրը կարող եք քաշել այստեղից http://ifolder.ru/14237622


Պրոեկտի կոմպիլացիա
C++ 6 Եթե ծրագիրե պատրաստը, և ուզում ենք այն աշխատեցնել ապա մենյուից ընտրեք Builde ցանկը և բացվաց ցուցակից ընտրել Compile ( մեր ֆայլի անունը ).
Եվ ընտրեք Builde ցանկը և բացվաց ցուցակից ընտրել ! execute ( մեր ֆայլի
անունը ). Եթե ծրագրում սխալներ չկան, ապա այն աշխատացնելուց հետո
կտեսնենք փոքր պատուհան վորի մեջ գրված կլինի մեր հաղորդագրությունը.
Մանրամասն կարող եք նաել վերը նշված գրքում

C++ 2005 կամ C++ 2008 մենք պտի նաստրոյկեկի մեջ մի բան փոխենք որ սխալ չտա և ըտենց մենուի մեյ ընտրեք Project -> (մեր ֆայլի անունը ) Properties…, բացեք Configuration Properties -> General և աջ կողմում Character Set – մեջ Use Unicode Character Set սխմելով վրեն փոխեք Not set- ի վրա և սխմեք OK:
Եթե ծրագիրե պատրաստը, և ուզում ենք այն աշխատեցնել
ապա մենյուից ընտրեք Builde ցանկը և բացվաց ցուցակից ընտրել Builde Solution .
Եվ ընտրեք Debuge ցանկը և բացվաց ցուցակից ընտրել Start Without Debugging. Եթե ծրագրում սխալներ չկան, ապա այն աշխատացնելուց հետո
կտեսնենք փոքր պատուհան վորի մեջ գրված կլինի մեր հաղորդագրությունը.
Մանրամասն կարող եք նաել վերը նշված գրքում


Նկարի չափսը փոխված է: Նկարն իրական չափերով տեսնելու համար սեղմեք այստեղ: Նկարի իրական չափերն են 1024x768:


Ծրագրի պարզաբանում

Առաջին տողում գտնվում է

#include <windows.h>

Այս դիրեկտիվան ծրագրին միացնում է Windows-ի գլխավոր ֆայլի վերնագիրը(ավելի մանրամասն կարող եք իմանալ վերը նշվաց գրքից ).

Հետո գալիս է WinMain ( ) ֆունկցիաի վերնագիրը

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
Ֆունկցիան վերադարձնում նշանակությունը որպես int տիպ, այսինքն նրանից է միշտ սկվում աշխատանքը.

HINSTANCE hinstance – դեսկրիպտոր, որը Windows-ը տալիս է միացված ծրագրին.
HINSTANCE hprevinstance – այս պարամետրը Win32-ում չի օգտագործվում և միշտ ստանում 0 արժեք.
LPSTR lpcmdline – ցուցիչ տողի վրա, որի մեջ տպվում է ծրագրի արգումենտը եթե այն միացված է կոմանդաին տողի ռեժիմի մեջ.Ծրագիրը կարելի է միացնել կոմանդաին տողի ռեժիմի մեջ – Start -> Run(Пуск -> Выполнить ), և կոմանդաին տողի մեջ մուտքագրվում է ծրագրի անունը իսկ պրոբելից հետո ցույցեք տալի արգումենտների ցուցակը որոնք բաժանված են պրոբելներով.Եվ այս ձևով ծրագրի միացումը մնում է էկզոտիկ.Ամենաշատը այսօր ծրագրերը միանում են երկու անգամ սխմելով ֆայլի վրա, բայց այս ձևը մեզ թույլ չի տալի ծրագրին ուղարկել որևը արգումենտ.
Int ncmdshow – ամբողջ նշանակություն, որը կարող է ուղարկվել ShowWindow ֆունկցիային.Այս պարամետրը կնայվի մյուս դասում.

Պարզաբանելով ֆունկցիաի վերնագիրը կանցնենք նրա մարմնին.

Ֆունկցիան ունի հետևյալ պրոտոտիպ

MessageBox(NULL, "Hello, Win32 world!", "Hello from Message Box", MB_OK);

Նրա պարամետրերը ինտրեպետացվում են հետևյալ ձև:

hWnd – մայրական պատուհանի դեսկրիպտոր, ինքը ստանում է NULL (զրո ) արժեք եթե չունի մայրական պատուհան.
lpText – ցուցիչ տողի վրա , որը պարունակում հաղորդագրության տեքտ .
lpCaption - ցուցիչ տողի վրա, որը պարունակում է դիալոգաին պատոհանի վերնագրի տեքստ.
uType - այս պարամետրը պարունակում է դրոշների կոմբինացիան, որը տալիս է
կնոպկեկի քանաքությունը և տիպը, նաև պիկտոգրամմա ( փոքր նկար վերնագրի ձախ կողմում ).

Մյուս դասում մենք կգրենք պատուհան մեր ուզաց չափերով և նաստրոյկեկով որը օգտագործվում է 3D օբեկտների, տեկստի և այլն էկրանի դուրս բերման համար ինչպես խաղերում.Եվ մեզ ամպայման պետք կգա Directx- ը որի ծավալը 550 մեգաբայթ է կարող եք քաշել այստեղից
http://www.microsoft.com/downloads/d...0-edb2df5abad4
ասեմ ձեզ որ առանց դրա դուք չեք կարող ստեղծել խաղ.


ստացվեց....

_DEATH_
01.10.2009, 21:48
ստացվեց....

Գոնե copy-past անելուց բացի չալարեիր նոր պռոյեկտ սարքեիր 152 kb չէր լինի:

Zte77
02.10.2009, 13:27
Մենք այսոր կստեղծենք պատուհան օգտագործելով Directx 9 SDK
http://pic.ipicture.ru/uploads/091002/fZmgiofSR9.jpg

Մեր նայաց ծրագիրը կարող եք բեռնավորել ստեղից http://depositfiles.com/files/tntma31tm


Մեզ անպայման պետկ է Directx 9.Microsoft – ի սայտում նրա ծավալը 550 մեգաբայթ է,
99% օրինակներն են.Ես առանձրացրեցի օրինակները Directx- ից և ստացվեց 17 մեգաբայթ հետո կցեցի առհիվի մեջ և ստացվեց ընդհամենը 2 մեգաբայթ.
Directx- ը կարող եք քաշել ստեղից http://depositfiles.com/files/t5t2k6zkp կամ http://openfile.ru/411658/ կամ http://jamber.info/files/download/a550682348.html


Առաջինը բեռնավորում եք directx- ը , դուրս եք հանում Directx9 պապկեն


Ստեղծում եք պրոեկտ և ֆայլ.
Հետո մեզ պետկ է միացնել մեր Directx – ը արվում է դա այսպես.


C++ 6 – ի ժամանակ

Մտնում եք Tools -> Options , սղմում եք Directories – ի վրա և Show Directories for բացւմ եք և դնում եք Include files – ի վրա.
Directories: -ի կողքը սխմեք new և նշանով ընտրեք ձեր Directx9 պապկաի Include պապկեն.
http://pic.ipicture.ru/uploads/091002/A15mZuKAfT.jpg

Հետո սղմում եք Show Directories for և դնում եք Library files և ցույց եք տալի Direct9 պապկաի Lib պապկաի մեջ x86 պապկեն.
http://pic.ipicture.ru/uploads/091002/fTkMIKj43q.jpg

Նոր մենք միացրել էինք Directx9- ի պապկեն ,իսկ հիմա մենք պետկ է միացնենք Directx9- ի ֆայլերը կոմպիլացիաի ժամանակ .Մտնում եք Project -> Seetengs. և սղմում եք link – ի վրա object /library modules մեյ ավելացնում եք d3d9.lib d3dx9.lib winmm.lib առանձնացնելով իրար պրոբելներով.
http://pic.ipicture.ru/uploads/091002/Ts7o3pc5ZG.jpg

C++ 2005- ի ժամանակ

Մտնում ենք Tools -> Options բացում եք Project and Solutions -> VC++ Directories.
Ձախ կողմում սղմում եք և Show Directories for վրա և դնում եք Include files սխմում եք New և նշանով ընտրեք ձեր Directx9 պապկաի Include պապկեն.
http://pic.ipicture.ru/uploads/091002/T4ZKj2xxDa.jpg

Հետո սղմում եք Show Directories for և դնում եք Library files և ցույց եք տալի Direct9 պապկաի Lib պապկաի մեջ x86 պապկեն.
http://pic.ipicture.ru/uploads/091002/1iRZlOoHjT.jpg

Նոր մենք միացրել էինք Directx9- ի պապկեն ,իսկ հիմա մենք պետկ է միացնենք Directx9- ի ֆայլերը կոմպիլացիաի ժամանակ .Մտնում եք Project -> (մեր ֆայլի անունը) Properties…, Բացում եք Configuration Properties և Linker -> Input. Ձախ կողմում Additional Dependencies մեյ ավելացնում եք d3d9.lib d3dx9.lib winmm.lib առանձնացնելով իրար պրոբելներով.
http://pic.ipicture.ru/uploads/091002/AkAIUz4T3r.jpg

Մեր նայաց ծրագիրը կարող եք քաշել ստեղից http://depositfiles.com/files/tntma31tm

Zte77
02.10.2009, 13:30
Այս դասում մենք կծանոթանանք Directx 9 գրադարանի հետ, որը իր մեջ միավորում է կոմպոնենտներ: գրաֆիկայի, ձայնի, վիդեոի, մուտքի սարքերի հետ աշխատելու համար.
Ինչ է Directx – ը ? Պատկերացրեք մի դեպք: դուք ստեղծում եք մի խաղ և ուզում եք որ խաղը աշխատի տարբեր համակարգիչների վրա.Եվ դրա համար ձեզ պետկ է հաշվի առնել բոլոր մտածվաց և չմտածվաց սարքավորումներ: վիդեոի, ձայնի, ցանցի քարտեր, մկնիկներ, և ստեղնաշարեր.Ավելի հեշտ է ստեղծել ստանդարտ, որի օգնությամբ կոդի գրելը, օրինակ մուտքագրման սարքի համար կարելի է անել , մեկ անգամ, և կաշխատի միշտ և ամենուր .Դրանին և հասնում է Microsoft- ը արդեն 10 –ից ավելի տարի.
Directx –ը դա մուլտիմեդիայի գրադարանն է,որը հնարավորություն է տալիս աշխատել ուղղակի, համակարգչի ապարատարային սարքավորումների հետ.Չօգտագործելով Win32 ստանդարտ պլատֆորմա որը աշխատում է դանդաղ.

Directx 9 բաժանվում է կոմպոնենտների որոնք պատասխանում են տարբեր աշխատանքներին.
Directx Graphics;
DirectInput;
DirectSound;
DirectPlay;

Նկ1 ցույց է տրված ընդհանուր սխեմա Directx 9-ի համագործակցությունը համակարգչի ապարատային սարքավորման հետ.

http://pic.ipicture.ru/uploads/091002/6v8ESUxa8t.jpg (http://ipicture.ru/)



Մենք կծանոթանանք Direct3D-ին որի մեջ մտնում է Directx Graphics,DirectInput, DirectMusic, DirectSound.

Direct3D – պատասխանում է եռաչափ գրաֆիկայի հետ աշխատելու համար.
DirectInput – Այս կոմպոնենտը պատասխանում է բոլոր մուտքգրման սարքավորումների համար: ստեղնաշար, մկնիկ , դժօյստիկ և այլն.
DirectSound – Այս Directx 9 մասը պատասխանում է ձայնի համար.
DirectPlay – թույլ է տալիս աշխատել լոկալ կամ ինտերնետի կապով սետեվոյ խաղերի ծրագրավորման համար.

HAL – Directx 9 իր մեջ ընկալում է սարքավորման աբստրակցիա HAL ( Hardware Abstraction Layer- սարքավորման աբստրակցիայի աստիճան.
Սարքավորման աբստրակցիայի աստիճանով HAL տեղի է ունենում հավելվածի(приложение) համագործակցությունը համակարգչի սարքավորման հետ.

Direct3D 9

Ամենակարեվոր Direct3D –ում ռենդերինգի պրոցեսն է.Ռենդերինգ – դա եռաչափ օբեկտի վիզուալիզացիան էկրանի վրա.Ռենդերինգը բաղկացած է մի քանի մեխանիզմներից – տեսսելացիա, տրանսֆորմացիա, լույս և րաստերիզացիա.

Տեսսելացիա – դա մեխանիզմ է որը կատարում է մակերեսի բաժանում պոլիգոնների վրա.
Պոլիգոն – դա տարածություննէ որը սահմանախակվում է անկյուններով.Direct3D – ում հաճախ պոլիգոնը դա եռանկյունն է.

Լույս – որտեղ օբեկտները ունեն գույն, որը կապված է լույսի աղբյուրից.
Ռաստերիզացիա – դա ամենադժվար մեխանիզմ է, որը և նկարումը ամբողջ բեմը, որը կատարում է տեկստուրաի տեղադրում, Z-ի բուֆֆերիզացիա, ստվերի տեղադրում, ալֆա խառնում.

Բեմի կառուցում Direct3D- ում

Մինչև որ մենք անցնենք գրաֆիկաի ծրագրավորմանը , ուսումնասիրենք բեմի կառուցումը.

Պատուհանի ստեղծում – դա այն է ինչով մենք զբաղվում էինք 2-րդ դասում.Ստեղծելով պատուհան, դուք ստեղծում եք դզեզ համար աշխատանքի մակերես.
Direct3D ինիցիալիզացիան - Ստեղ դուք ստեղծում եք ցուցիչներ ինտերֆեյսների վրա,ինիցիալիզացվում է Direct3D,տրվում են ներկայացման պարամետրերը և ստեղծվում է Direct3D սարքավորում.Direct3D կարելի է ասել դա ձեր համակարգչի ապարատային և ծրագրային մաս է.
Այսինքն դուք տալիս եք էկրանի թույլատվությունը(разрешение), կադրերի փոխանակման խաճախություն, ստանում եք վիդեօքարտի ինֆորմացիա, տեղադրում եք, թե ինչպես է վիդեոադապտերը մշակելու է նրան տրված ինֆորմացիա,տալիս ենք բուֆֆերի հետևի ֆորմատ,տալիս եք խորը բուֆֆերի պարամետրերը, այսինք այն ինչ կապված է ձեր համակարգչի ապարատային և ծրագրային նաստրոյկեկը.

Օբեկտի ստեղծում – Բոլոր օբեկտները բաղկացած են պոլիգոններից.Խաճախ դա եռանկյուն է.
Ամեն մի պոլիգոն բաղկացած է երեք անկյուններից կամ կետերից.Direct3D – ում անվանում են գագաթ.Գագաթը կոորդինատներում տրվում է երեք սռնիով(ось) X, Y, Z.
Լույս, նյութ և տեկստուրա – Բեմը կարելի է կառուցել ռեալ ներկայացնելով էկրանի վրա, եթե օգտագործվում է լոյսը և նյութը.Ստեղծելով տարբեր լույսերի աղբյուրներ օրինակ լամպ, կրակ, և տվելով օբեկտին նյութը դուք կտաք նկարվող բեմին ռեալիզմ.
Օբեկտի Ռենդերինգ – Կարելիէ նկարել բեմը էկրանի վրա, տվելով տարբեր նշանակություններ բոլոր ռենդերինգի կոմպոնենտներին.

Direct3D 9 ինտերֆեյսները

Idirect3D9;
Idirect3Ddevice9
Idirect3DvertexBuffer;
Idirect3DindexBuffer;
Idirect3Dtexture9;

Idirect3D9 – ամենագլխավոր ինտերֆեյսն է.Սա առաջին օբյեկտնը որը դուք պետկ է ստեղծեք. Օբեկտի ինտեռֆեյսը ստեղծվում է Direct3Dcreate9( ) ֆունկցիայով.

Ididrectd3Ddevice9 - դրանից հետո երբ ստեղծված է օբեկտի գլխավոր ինտերֆեյսը Idirect3D9, ստեղծվում սարքավորման ինտերֆեյսը Direct3D9.Ես են անգամ ասում էի, սա ապարատային և ծրագարային նաստրոյկեկ են, որը ստեղծում է Direct3D որով և նկարվում է ամբողջ բեմը.Այս ինտերֆեյսը միշտ երկրորդով CreateDevice( ) ֆունկցիայով.
Idirect3DindexBuffer – ինտերֆեյսնա որով ստեծվում է գագաթների բուֆֆեր.Ինքը ստեղծվում է CreateVertexBuffer ֆունկցիայով.
Idirect3DindexBuffer – օգտագործելով այս ինտերֆեյսը, դուք կարող եք ստեղծել ինդեկսային բուֆֆեր,
Որը թույլ է տալիս ինդեկսացնել օբեկտի գագաթները.Օրինակ դուք ունեք ուղղանկյուն, որը բաղկացած է երկու եռանկյուններից,որտեղ չորսհատ գագաթ է, ունեն նույն կոորդինատները, ինդեկսային բւֆֆերի օգնությամբ կարելի է ինդեկսացնել գագաթները և խուսափել կրկնվելուց.

Idirect3Dtexture9 – ինչպես երևում է անվանումից այս ինտերֆեյսը պատասխանում է տեկստուրների համար.


Ստեղծում ենք ինտերֆեյսի ցուցիչ

LPDIRECT3D9 pDirect3D = NULL;

Սա ցուցիչ է գլխավոր ինտերֆեյսի վրա, 3D գրաֆիկայի հետ աշխատելու համար.

Բոլոր ստեղծվող ցուցիչների ինտեֆեյսներին անհրաժեշտ է տալ NULL նշանակություն,որը զրոյացնում է ցուցիչը.

LPDIRECT3DDEVICE pDirect3DDevice =NULL;

Այսպես ստեղծվում է ցուցիչ Direc3D9 ինտերֆեյսի սարքավորմանը.,3D գրաֆիկայի հետ աշխատելու համար.

Ուսումնասիրենք ամբողջ InitialDirect3D ( ) ֆունկցիան, դնելով նրա մեջ ինիցիալիզացիայի կոդը


HRESULT InitialDirect3D( HWND hwnd )
{

if( NULL == ( pDirect3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;

D3DDISPLAYMODE Display;
if( FAILED( pDirect3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &Display ) ) )
return E_FAIL;

D3DPRESENT_PARAMETERS Direct3DParametr;
ZeroMemory( &Direct3DParametr, sizeof(Direct3DParametr) );
Direct3DParametr.Windowed = TRUE;
Direct3DParametr.SwapEffect = D3DSWAPEFFECT_DISCARD;
Direct3DParametr.BackBufferFormat = Display.Format;

if( FAILED( pDirect3D -> CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&Direct3DParametr, &pDirect3DDevice ) ) )
{
return E_FAIL;
}

return S_OK;
}


Կոնստրուկցիայի մեջ

if( NULL == ( pDirect3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )

Direct3Dcreate ( ) ֆունկցիայով ստեղծվում գլխավոր ցուցիչ Idirect3D9 ( ) ինտերֆեյսի վրա.Ֆունկցիան օգտագօրծում է միայն մի մակրոս D3D_SDK_VERSION.

Հետո մենք պետկ է ստանանք ինֆորմացիա դիսպլեի վիզուալ ցուցադրման ռեժիմ.Ստեղ նկատի ունենք էկրանի թույլատվությունը.Մեզ անհրաժեշտ է իմանալ այդ ինֆորմացիան, որպեսզի պատժենահանենք տվյալ նաստրոյկեկը հետևի բւֆֆերում.Direct3D- ում այն ինչ դուրս է բերվում էկրանին,սկզբում նկարվում է հետևի բուֆֆերում, հետո պատճենահանվում է առաջնային բւֆֆեր

D3DDISOLAYMODE Display;


Մենք հայտարարումենք փոփոխական D3DDISPLAYMODE ստրուկտուրայի վրա.Ինքը կօգտագործվի հետևի բւֆֆերի ստեղծման համար .
Հետո GetAdapterDisplayMode ( ) ֆունկցիայով մենք ստանում ենք դիսպլեի ֆորմատ.

Պրոտոտիպը ունի հետևյալ տեսք

HRESULT GetAdapterDisplayMode(
UINT Adapter,
D3DDISPLAYMODE * pMode
);

Adapter – դիսպլեի վիդեոադապտորն է, D3DADAPTER_DEFAULT նշանակությունը օգտագործում է առաջնաին ադապտոր.
pMode – սա ցուցիչ է D3DDISPLAYMODE ստրուկտուրայի վրա.

Կգրենք հետևյալը
if( FAILED( pDirect3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &Display ) ) )
return E_FAIL;

Հետո ստեղծվում պարամետրերի օբեկտ Direct3Dparametr, մուտքագրելով նրա տողերը կարելի է որոշել, թե վոնցե իրեն պահելու մեր 3D օբեկտը.
D3DPRESENT_PARAMETERS pDirect3Dparametr;

Մաքրում է ստեղծվող ստրուկտուրան.Առաջին պարամետրը Direct3Dparametr դա հասցեե որը պետկ է մաքրվի.
Երկրորդ պարամետրը – Sizeof (Direct3Dparametr ) սա այն չափն է որը պետկ է մաքրվի.
ZeroMemory պրոտոտիպը ունի հետևյալ տեսք.

VOID ZeroMemory (
PVOID Destination,
SIZE_T Length );

Ֆունկցիան ZeroMemort( ) ունի հետևյալ պարամետրերը

Destination – ցուցիչ հիշողության բլոկի սկզբնական հասցեին.
Length – հիշողության բլոկի չափն է.

Նաենք D3DPRESENT ստրուկտուրա


typedef struct D3DPRESENT_PARAMETERS {
UINT BackBufferWidth, BackBufferHeight;
D3DFORMAT BackBufferFormat;
UINT BackBufferCount;
D3DMULTISAMPLE_TYPE MultiSampleType;
DWORD MultiSampleQuality;
D3DSWAPEFFECT SwapEffect;
HWND hDeviceWindow;
BOOL Windowed;
BOOL EnableAutoDepthStencil;
D3DFORMAT AutoDepthStencilFormat;
DWORD Flags;
UINT FullScreen_RefreshRateInHz;
UINT PresentationInterval;
} D3DPRESENT _PARAMETERS, *LPD3DPRESENT_PARAMETERS;





Այս օրինակում մենք կօգտագործենք միայն երեք պարամետր.

Direct3DParametr.Windowed = TRUE;
Direct3DParametr.SwapEffect = D3DSWAPEFFECT_DISCARD;
Direct3DParametr.BackBufferFormat = Display.Format;


Windowed – սա վիդեոռեժիմ է, TRUE նշանակություն նշանակում է պատուհային ռեժիմ իսկ FALSE պատուհանը բացված է ամբողջ էկրանի վրա.
BackBufferFormat - հետևի բւֆֆերի տարածքի ֆորմատ .որը իրականացվում է Display.Format.
Swapeffect – այս պարամետրը օգտագործվում բւֆֆերների փոխանակման համար.

Հետո մենք կստեղծենկ օբեկտ ինտերֆեյսի սարքավորման համար CreateDevice ( ) ֆունկցիայի օգնությամբ.

CreateDevice ( ) –ի պրոտոտիպը


HRESULT CreateDevice(
UINT Adapter,
D3DDEVTYPE DeviceType,
HWND hFocusWindow,
DWORD BehaviorFlags,
D3DPRESENT_PARAMETERS * pPresentationParameters,
IDirect3DDevice9 ** ppReturnedDeviceInterface
);

CreateDevice ( ) ֆունկցիան ունի հետևյալ պարամետրերը.

Adapter - սա ձեր վիդեօքարտն է.
DeviceTupe - որոշում է ձեր սարքի տիպը.D3DDEVTYPE_HAL – օգտագործվում է ապարատային հնարավորությունները.Ընտրենք այս պարամետրը գրաֆիկան արագացնելու համար.
hFocusname – Պատուհանի դեսկրիպտոր.
BehaviorFlags – ցույց է տալի թե ինպես է գագաթները մշակվելու են.
D3DCREATE_HARDARE_VERTEXPROCESSING – այս անգամ կօգտագործվի վիդեքարտը, և կատարվում է ապարատային մշակում.
D3DCREATE_SOFTWARE_VERTEXPROCESSING – Ծրագրային մշակում.

pPresentationParameters – ցուցիչ D3DPRESENT_PARAMETERS ստրուկտուրայի վրա.դա Direct3Dparametr.
ppReturnedDeviceInterface – ցուցիչ pDirect3Ddevice ինտեֆեյսի վրա.

Նաենք թե ինչ է ստացվել
pDirect3D -> CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&Direct3DParametr, &pDirect3DDevice ) ;


Դրանից հետո երբ ստեղծել էինք InitialDirect3D ( ) ֆունկցիա նրան պետկ է դնել WinMain ( ) ֆունկցիայի մեջ.

if( SUCCEEDED( InitialDirect3D( hwnd ) ) )
{

ShowWindow( hwnd, SW_SHOWDEFAULT );
UpdateWindow( hwnd );


while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}

Zte77
02.10.2009, 13:31
Ռենդերինգ կամ նկարում ենք պատուհանում



Ռենդերինգ – դա եռաչափ օբեկտների նկարման պրոցեսն է.Առայժմ մենք հլը չենք սովորել նկարել 3D – օբեկտներ այս պատճառով կնկարենք ինչ որ մի գույն .Այս նպատակի համար ստեղծենկ RenderingDirect3D ( ) ֆունկցիա որը կնկարի մեր պատուհանում.

Եկեք սկզբից մաքրենք հետևի բւֆֆերը Clear ( ) ֆունկցիայով.



HRESULT Clear(
DWORD Count,
CONST D3DRECT * pRects,
DWORD Flags,
D3DCOLOR Color,
float Z,
DWORD Stencil
);


Clear ( ) ֆունկցիան ունի հետևյալ պարամետրերը.

Count – սա ուղղանկյան զանգվածի (массив) համարնա,եթե դնենք 0 ապա կօգտագործվի ամբողջ տարածքը.
pRect – նշանակում է ուղղանկյունների զանգվածի հասցե.
Flags – պարամետր, որը որոշում է որ մակերեսները պտի մաքրվեն.
D3DCLEAR_TARGET – մաքրել մակերեսի բւֆֆերը մինչև գույնը Color պարամետրում.

Color – այս պարամետրում օգտագործվում է հասարակ գույնի մակրոս D3DCOLOR_XRGB( 255,255,0 ) այս դեպքում դեղին գույնի.

Z- այս պարամետրը տալիս է Z- բւֆֆերի նշանակությունը.գրենք 1.0

Stencil – բւֆֆերի տրաֆարետի նշանակություն, այս պարամետրը կբացատրվի միքիչ ուշ և դնենք 0.

Clear – ի ֆունկցիան
pDirect3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255,255,0), 1.0f, 0 );

Բեմի դուրս բերման ժամանակ կանչվում է BeginScene ( ) ֆունկցիան
և բեմը վերջանում է EndScene ( ) ֆունկցիայով.

Այն ինչ մենք նկարել ենք հետևի բուֆֆերում դուրս կբերենք էկրանի վրա Present ( ) ֆունկցիայով.

pDirect3DDevice->Present( NULL, NULL, NULL, NULL );

հիմա միացնենք իրար և կստանանք RenderingDirect3D ( ) ֆունկցիա.


VOID RenderingDirect3D()
{

if(pDirect3DDevice == NULL)
return;

pDirect3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255,255,0), 1.0f, 0 );

pDirect3DDevice->BeginScene();

pDirect3DDevice->EndScene();
pDirect3DDevice->Present( NULL, NULL, NULL, NULL );

}

Ստեղծելով ֆունկցիա որը կատարում է Ռենդերինգ տեղադրենք նրան հաղորդագրությունների հերթին

switch(msg)
{

case WM_PAINT:

RenderingDirect3D();
ValidateRect( hwnd, NULL );
return(0);

case WM_DESTROY:

DeleteDirect3D();
PostQuitMessage(0);
return(0);

}

Բաց ենք թողնում բեռնված րեսուրսները

VOID DeleteDirect3D()
{
if( pDirect3DDevice != NULL)
pDirect3DDevice->Release();

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

Release ( ) ֆունկցիան նշանակում է ջնջել.


Մեր նայաց ծրագիրը կարող եք բեռնավորել(քաշել) ստեղից

Հիմա նաենք թե ինչ է ստացվել մեր մոտ

Մեր նայաց ծրագիրը կարող եք բեռնավորել ստեղից http://depositfiles.com/files/tntma31tm

//-----------------------------------------------------------------------------------
// InitialDirect3D.CPP
//-----------------------------------------------------------------------------------

#include <windows.h>
#include <d3d9.h>


//-----------------------------------------------------------------------------------
LPDIRECT3D9 pDirect3D = NULL;
LPDIRECT3DDEVICE9 pDirect3DDevice = NULL;


//-----------------------------------------------------------------------------------
// Функция
// InitialD3D()
// Инициализация Direct3D
//-----------------------------------------------------------------------------------

HRESULT InitialDirect3D( HWND hwnd )
{

if( NULL == ( pDirect3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return E_FAIL;

D3DDISPLAYMODE Display;
if( FAILED( pDirect3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &Display ) ) )
return E_FAIL;

D3DPRESENT_PARAMETERS Direct3DParametr;
ZeroMemory( &Direct3DParametr, sizeof(Direct3DParametr) );
Direct3DParametr.Windowed = TRUE;
Direct3DParametr.SwapEffect = D3DSWAPEFFECT_DISCARD;
Direct3DParametr.BackBufferFormat = Display.Format;

if( FAILED( pDirect3D -> CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&Direct3DParametr, &pDirect3DDevice ) ) )
{
return E_FAIL;
}

return S_OK;
}
// RenderingDirect3D()
//
//-----------------------------------------------------------------------------------
VOID RenderingDirect3D()
{

if(pDirect3DDevice == NULL)
return;

pDirect3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255,255,0), 1.0f, 0 );

pDirect3DDevice->BeginScene();

pDirect3DDevice->EndScene();

pDirect3DDevice->Present( NULL, NULL, NULL, NULL );

}
// DeleteDirect3D()
//-----------------------------------------------------------------------------------
VOID DeleteDirect3D()
{
if( pDirect3DDevice != NULL)
pDirect3DDevice->Release();

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

// MainWinProc()
//-----------------------------------------------------------------------------------

LRESULT CALLBACK MainWinProc(HWND hwnd,
UINT msg,
WPARAM wparam,
LPARAM lparam)
{

switch(msg)
{

case WM_PAINT:

RenderingDirect3D();
ValidateRect( hwnd, NULL );
return(0);

case WM_DESTROY:

DeleteDirect3D();
PostQuitMessage(0);
return(0);

}

return (DefWindowProc(hwnd, msg, wparam, lparam));

}

// WinMain
// //-----------------------------------------------------------------------------------

int WINAPI WinMain( HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{

WNDCLASSEX windowsclass;
HWND hwnd;
MSG msg;

// Определим класс окна WNDCLASSEX
windowsclass.cbSize = sizeof(WNDCLASSEX);
windowsclass.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
windowsclass.lpfnWndProc = MainWinProc;
windowsclass.cbClsExtra = 0;
windowsclass.cbWndExtra = 0;
windowsclass.hInstance = hinstance;
windowsclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
windowsclass.hCursor = LoadCursor(NULL, IDC_ARROW);
windowsclass.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
windowsclass.lpszMenuName = NULL;
windowsclass.lpszClassName = "WINDOWSCLASS";
windowsclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

if (!RegisterClassEx(&windowsclass))
return(0);


if (!(hwnd = CreateWindowEx(NULL,
"WINDOWSCLASS",
"Direct3D-I Inicalizacia",
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
300,150,
500,400,
NULL,
NULL,
hinstance,
NULL)))
return(0);


if( SUCCEEDED( InitialDirect3D( hwnd ) ) )
{

ShowWindow( hwnd, SW_SHOWDEFAULT );
UpdateWindow( hwnd );


while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}

return 0;
}

Կոմպիլացիայից հետո կտեսնեք սա
http://pic.ipicture.ru/uploads/091002/fZmgiofSR9.jpg

Եվ այսպես մենք վերջացրել ենք պատուհանինիս տեղծելը և եկելը ժամանակը գրաֆիկաի ծրագրավորմանը!!! մյուս դասում մենք կնկարենք մեր պատուհանում եռանկյուն և ուղղանկյուն.
http://pic.ipicture.ru/uploads/091002/qqWAGdV9LU.jpg
http://pic.ipicture.ru/uploads/091002/rFoAk75j4d.jpg

xaker00
02.10.2009, 14:08
Գոնե copy-past անելուց բացի չալարեիր նոր պռոյեկտ սարքեիր 152 kb չէր լինի:
յանմ ինչ՞

_DEATH_
02.10.2009, 15:59
յանմ ինչ՞

յանմ լրիվ անիմաստ էր որ կցել էիր կոմպիլացիա արածդ, ցանկացած մարդ էլ կարա copy-past անի…

d4rkme551ah
02.10.2009, 22:28
Zte77
Լավ բան ես անում, բայց շատ դժվարա գրածտ կարդալ: Օգտագործիր ֆոռումի տեգերը, օրինակի կոդի համար կա CODE տեգը: И вообще, обрати внимание на форматирование текста: Ու մի հարց.


while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}

Այստեղ պատկերը թարմացվելու է միայն WM_PAINT հաղորդագրության դեպքում, իսկ մնացած ժամանակ տռեդը սպասելու է նոր հաղորդագրության: Սա հարմար է միայն այն դեպքւմ, եթե քո բեմադրությունը (scene lol) համեմատաբար ստատիկ է:
Այստեղ ավելի ճիշտ է օգտագործել հետևյալ ցիկլը


PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
RenderingDirect3D();
}

Այս դեպքում տռեդը իր ազատ ժամանակը օգտագործում է ռենդեռի վրա, իսկ անիմացիայի դեպքում առանձ դրա չի լինի:

Zte77
02.10.2009, 23:37
Հա գիդեմ բայց այս օրինակում ետի կարեվոր չի, քանի որ ես էկրանի վրա 3D օբեկտ չեմ նկարում, բայց մյուս օրինակում եռանկյունի դուրս բերման ժամանակ կօգտագործվի

օրինակ, եթե մենք ուզում ենք պատուհանում դուրս բերել եռանկյուն, սրանով

while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}

Կոմպիլացաիաի ժամանակ պատուհանը մի վարկյանով դուրս կբերվի և միանգամից ինքն իրեն կփագվի.Դա կայանում է նրանում որ Getmessage ( ) ֆունկցիան նախատեսված չի ռեալ ժամանակում աշխատելու համար.Այ դրա համար մենք պետկ է փոխենք PeekMessage ( ) -ի վրա.PeekMessage ( ) ֆունկցիաի աշխատում է այսպես, եթե կա հաղորդագրություն մշակում է, եթե չկա սպասում է.

d4rkme551ah
02.10.2009, 23:51
PeekMessage ( ) ֆունկցիաի աշխատում է այսպես, եթե կա հաղորդագրություն մշակում է, եթե չկա սպասում է
Երևի սխալվեցիր, այդպես աշխատում է GetMessage-ը, իսկ PeekMessage-ը չի սպասում, այլ միանգամից շարունակում է ծրագրի կատարումը, անկախ այն բանից message կա հերթում, թե չէ:

Zte77
02.10.2009, 23:57
Դու Directx -ից ինչ գիրք ես կարդացել, օրինակ ես երկու գիրք եմ կարդում Ламот и Горнаков Directx- i մասին և ընտեղ գրած է եթե կա հաղորդագրություն մշակում է, եթե չկա սպասում է.

d4rkme551ah
03.10.2009, 00:11
Դու Directx -ից ինչ գիրք ես կարդացել, օրինակ ես երկու գիրք եմ կարդում Ламот и Горнаков Directx- i մասին և ընտեղ գրած է եթե կա հաղորդագրություն մշակում է, եթե չկա սպասում է.
Դե դա DirectX-ի հետ այդքան էլ կապ չունի: Ըստ հավաստի աղբյուրների. (http://msdn.microsoft.com/en-us/library/ms644936%28VS.85%29.aspx)


The GetMessage function retrieves a message from the calling thread's message queue. The function dispatches incoming sent messages until a posted message is available for retrieval.

Unlike GetMessage, the PeekMessage function does not wait for a message to be posted before returning.

Zte77
03.10.2009, 00:11
http://pic.ipicture.ru/uploads/091003/1CC52RZlLT.jpg

d4rkme551ah
03.10.2009, 00:17
Zte77
Ամեն ինչ ճիշտ է, GetMessage-ը սպասում է, PeekMessage-ը ոչ:

Zte77
03.10.2009, 00:18
Հա ճիշտա ծրագիրը շարունակում է կատարվել, PeekMessage - ը սպասումը հաջորդ հաղորդագրությանը

Zte77
03.10.2009, 00:23
Միհատ կարդա սխալա գրած?
http://pic.ipicture.ru/uploads/091003/QTOH7pg0Va.jpg

Zte77
03.10.2009, 00:30
կարողա ждем дальше նրա փոխարեն идем дальше.Դե ռուսական ֆորումներում ասում էին որ այս գրքում սխալա բացատրվում.Դու ասա սխալա գրած.

d4rkme551ah
03.10.2009, 00:30
Միհատ կարդա սխալա գրած?
http://pic.ipicture.ru/uploads/091003/QTOH7pg0Va.jpg
Ինչ հետաքրքիր է:) Սա հավանաբար OCR-ի դեֆեկտ է: Պետք է լիներ идем дальше, բայց и տառը սխալ է ճանաչվել:

Zte77
03.10.2009, 00:32
Ուրեմն ֆորումներում ճիշտ էին ասում.

Zte77
03.10.2009, 00:50
Շնորհակալ եմ, մի բան ել հարցնեմ ստեղ շնորհակալություն վոնց են ասում.

d4rkme551ah
03.10.2009, 00:53
Zte77
Ընդհանրապես ես նայում եմ Alan Thorn-ի գրքով (http://www.ozon.ru/context/detail/id/3571238/), եթե հավես է լինում: Բայց իմ մոտ անգլերեն տարբերակն է, վատը չի, գրեթե բոլոր ասպեկտները քննարկվում է:

d4rkme551ah
03.10.2009, 01:01
http://rghost.ru/501634/image.png (http://rghost.ru/501634.view)
Այսպես, բայց այդ հնարավորությունը եթե չեմ սխալվում հայտնվում է 15 հաղորդագրությունից հետո:
Ինձ շնորհակալություն հայտնելու կարիք ամենևին չկա, այդպիսի բաներին ուշադրություն չեմ դարձնում:)

xaker00
03.10.2009, 18:08
Շնորհակալ եմ, մի բան ել հարցնեմ ստեղ շնորհակալություն վոնց են ասում
դա ամենահեշտն է... ։) ամեն գրառումից հետո, կա դզեռքի պատկեր... դա սեխմի