😞 🥂 〽️ DirectX 9 प्लेटफ़ॉर्म पर पार्टिकल सिस्टम डेवलपमेंट। पार्ट I ⛹️ 🧛🏾 🛌🏻

यह पोस्ट आपके स्वयं के विकास के बारे में होगी, और काफी उत्पादक (मेरे कंप्यूटर पर, वास्तविक समय में 1,000,000 कण चुपचाप खींचे और एनिमेटेड हैं), एक कण प्रणाली। हम सी ++ में लिखेंगे, डायरेक्टएक्स 9 को एक मंच के रूप में उपयोग किया जाएगा।

दूसरा भाग यहाँ उपलब्ध है ।

विज़ुअलाइज़ेशन फ़्रेम (क्लिक करने योग्य) में से एक का उदाहरण:

शुरुआत के लिए, यह कहने लायक है कि यह C ++ और DirectX9 क्यों है, और सामान्य रूप से XNA, या GDI, नहीं कहते हैं। निर्णय लेने से पहले, मैंने कई विकल्पों की कोशिश की: HTML + JS (जब मैंने कॉन्सेप्ट विकसित किया है), C # और GDI, C ++ और GDI, C # और XNA। इन सभी विकल्पों ने आवश्यक प्रदर्शन (50,000 से अधिक कणों का वास्तविक समय प्रतिपादन) को प्राप्त करने की अनुमति नहीं दी, इसलिए मैंने अधिक गंभीर विकल्पों पर विचार करना शुरू कर दिया। पहली बात जो दिमाग में आई वह थी डायरेक्टड्रा, लेकिन कोई भी इसे लंबे समय से विकसित नहीं कर रहा है, इसलिए पसंद डायरेक्ट 3 डी पर गिर गई। आप OpenGL का उपयोग कर सकते हैं, लेकिन D3D किसी तरह मेरे करीब है।

0. अवधारणा और आवश्यकताओं

सिस्टम आकर्षित करेगा और कणों को चेतन करेगा। हम कुछ सूत्र के अनुसार एनीमेशन का उत्पादन करेंगे (उदाहरण के लिए, मैंने सार्वभौमिक गुरुत्वाकर्षण के कानून का उपयोग किया)। आप वास्तविक समय में कुछ डेटा संचारित करके बाहर से सिस्टम के साथ बातचीत कर सकते हैं।

आवश्यकताओं।

हम चाहते हैं कि हमारी कण प्रणाली पर्याप्त रूप से उत्पादक हो, ताकि इसका उपयोग वास्तविक समय प्रतिपादन के लिए किया जा सके, यह सेटिंग में लचीला होना चाहिए, और यह स्प्राइट्स, विभिन्न प्रभावों और बाद के प्रभावों का उपयोग करने की अनुमति देता है।

आइए जाने क्रम में:
1. उत्पादकता। शायद C \ C ++ की तुलना में कुछ तेज़ी से ढूंढना मुश्किल होगा, और Direct3D का व्यापक रूप से कंप्यूटर गेम के विकास में उपयोग किया जाता है। हमारे पास निश्चित रूप से इसकी पर्याप्त क्षमताएं हैं।
2. वास्तविक समय प्रतिपादन। दरअसल इसके लिए Direct3D (OpenGL) का इस्तेमाल किया जाता है। चयनित उम्मीदवार उपयुक्त है।
3. अनुकूलन में लचीलापन। डायरेक्टएक्स में शेड्स जैसी अद्भुत चीज है। आप किसी भी चीज़ को फिर से लिखने के बिना उन्हें लागू कर सकते हैं लेकिन उन्हें।
4. स्प्राइट। डायरेक्टएक्स में, वे उपयोग करने में काफी आसान हैं। उपयुक्त है।
5. प्रभाव, पोस्ट प्रभाव। इसे लागू करने के लिए, shaders हमारी मदद करेंगे।

अब उन सूक्ष्मताओं के बारे में जिन्हें पर्याप्त प्रदर्शन प्राप्त करने के लिए विचार किया जाना चाहिए। क्योंकि चूंकि कणों की संख्या बहुत बड़ी है, इसलिए उन्हें एक टुकड़े में रेंडर करने के लिए प्रस्तुत करना बेहतर होता है, ताकि प्रतिपादन कार्यों की बड़ी संख्या के कारण प्रदर्शन में न खोएं। खैर, मेमोरी का भी ध्यान रखा जाना चाहिए, इसलिए सबसे अच्छा विकल्प यह होगा कि आप डेटा को पॉइंट ऑफ एरे के रूप में स्टोर करें।

हमने सभी सैद्धांतिक प्रश्नों को हल किया, अब हम कार्यान्वयन के लिए पास होंगे।

1. Direct3D को प्रारंभ करना और एक कैमरा बनाना

काम करने के लिए, हमें वास्तविक विकास पर्यावरण \ _ कंपाइलर और डायरेक्टएक्स एसडीके की आवश्यकता है

आउटपुट डिवाइस और एक विंडो के बाद एक डायरेक्ट 3 डी 9 ऑब्जेक्ट बनाने के लिए पहली चीज जहां सब कुछ प्रदर्शित किया जाएगा।

छिपा हुआ पाठ

//      WNDCLASSEX wc = {sizeof(WNDCLASSEX), CS_VREDRAW|CS_HREDRAW|CS_OWNDC, WndProc, 0, 0, hInstance, NULL, NULL, (HBRUSH)(COLOR_WINDOW+1), NULL, L"RenderToTextureClass", NULL}; RegisterClassEx(&wc); //   HWND hMainWnd = CreateWindowW(L"RenderToTextureClass", L"Render to texture", WS_POPUP, 0, 0, Width, Height, NULL, NULL, hInstance, NULL); //   Direct3D LPDIRECT3D9 d3d = Direct3DCreate9(D3D_SDK_VERSION); //      D3DPRESENT_PARAMETERS PresentParams; memset(&PresentParams, 0, sizeof(D3DPRESENT_PARAMETERS)); PresentParams.Windowed = TRUE; //     //         . //       D3DSWAPEFFECT_DISCARD. PresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD; LPDIRECT3DDEVICE9 device = NULL; //   d3d->CreateDevice(D3DADAPTER_DEFAULT, //     D3DDEVTYPE_HAL, //    hMainWnd, //      D3DCREATE_HARDWARE_VERTEXPROCESSING, //      &PresentParams, // ,     &device); //   ,     , //  . device->SetRenderState(D3DRS_LIGHTING,FALSE); //      device->SetRenderState(D3DRS_ZENABLE, FALSE); //

उपरोक्त कोड में, हम एक नियमित विंडो बनाते हैं जिसमें रेंडरिंग होगी। अगला Direct3D ऑब्जेक्ट है। और अंत में, डिवाइस ऑब्जेक्ट, जिसे हम ड्राइंग के लिए उपयोग करेंगे।

हार्डवेयर त्वरण के बारे में कुछ शब्द। प्रोसेसर का उपयोग करके, वीडियो कार्ड का अनुकरण करते हुए कई गणनाएं की जा सकती हैं, लेकिन चूंकि एक साधारण प्रोसेसर इन उद्देश्यों के लिए बहुत उपयुक्त नहीं है (इसमें, सबसे अच्छा, 4 कोर, और वीडियो कार्ड दर्जनों, या यहां तक कि सैकड़ों का उपयोग करता है), तो यह प्रदर्शन को प्रभावित करेगा। कुछ मामलों में, बहुत ज्यादा। इसलिए, यदि संभव हो तो हार्डवेयर त्वरण का उपयोग करना बेहतर है।

इसके अलावा, प्रक्षेपण मैट्रीस और कैमरों की स्थापना के बारे में मत भूलना। संक्षेप में, प्रोजेक्शन मैट्रिक्स का उपयोग 3D डेटा को 2D में बदलने के लिए किया जाता है, और कैमरा वर्णन करता है कि हम क्या देखते हैं और हम कहाँ देखते हैं।

लेकिन यहां मैं एक सरलीकरण, ऑर्थोगोनल प्रोजेक्शन मैट्रिक्स का परिचय दूंगा, क्योंकि वास्तव में, हमारे कण सपाट बिंदु हैं, और उन्हें परिप्रेक्ष्य की विशेष गणना की आवश्यकता नहीं है, हम कैमरे के बिना कर सकते हैं। ऑर्थोगोनल प्रोजेक्शन में, Z को वास्तव में ध्यान में नहीं रखा जाता है, और अंतरिक्ष में स्थिति के आधार पर ऑब्जेक्ट आकार नहीं बदलते हैं।

 //   D3DXMATRIX matrixView; D3DXMATRIX matrixProjection; //   D3DXMatrixLookAtLH( &matrixView, &D3DXVECTOR3(0,0,0), &D3DXVECTOR3(0,0,1), &D3DXVECTOR3(0,1,0)); //   D3DXMatrixOrthoOffCenterLH(&matrixProjection, 0, Width, Height, 0, 0, 255); //      device->SetTransform(D3DTS_VIEW,&matrixView); device->SetTransform(D3DTS_PROJECTION,&matrixProjection);

2. उनके लिए कण और एक बफर बनाना

हमने पूरी तैयारी की, यह केवल कण बनाने और ड्राइंग शुरू करने के लिए बनी हुई है।

 struct VertexData { float x,y,z; }; struct Particle { float x, y, vx, vy; }; std::deque<Particle> particles;

वर्टेक्सडाटा का उपयोग जीपीयू (वर्टेक्स बफर) में कण डेटा को स्टोर करने के लिए किया जाता है, और इसमें हमारे कण के निर्देशांक होते हैं। इस संरचना का एक विशेष प्रारूप है, और वास्तव में ग्राफिक्स प्रोसेसर इससे जानकारी लेगा कि क्या और कहाँ आकर्षित करना है।
कण हमारे कण का प्रतिनिधित्व करेगा, और निर्देशांक और गति समाहित करता है।
कणों में , हमारे सभी कणों के बारे में जानकारी संग्रहीत की जाएगी। हम इस जानकारी का उपयोग कण गति की गणना के लिए करेंगे।

छिपा हुआ पाठ

 //      srand(clock()); Particle tmp; for( int i = 0; i<particleCount; ++i ) { tmp.x = rand()%Width; tmp.y = rand()%Height; particles.push_back( tmp ); } LPDIRECT3DVERTEXBUFFER9 pVertexObject = NULL; LPDIRECT3DVERTEXDECLARATION9 vertexDecl = NULL; size_t count = particles.size(); VertexData *vertexData = new VertexData[count]; for(size_t i=0; i<count; ++i) { vertexData[i].x = particles[i].x; vertexData[i].y = particles[i].y; vertexData[i].z = 0.f; vertexData[i].u = 0; vertexData[i].v = 0; } void *pVertexBuffer = NULL; //    device->CreateVertexBuffer( count*sizeof(VertexData), //    D3DUSAGE_WRITEONLY, //  GPU,         D3DFVF_XYZ, //     XYZ D3DPOOL_DEFAULT, //      &pVertexObject, //   ,     NULL); //  .  NULL //  ,       pVertexObject->Lock(0, count*sizeof(VertexData), &pVertexBuffer, 0); //     memcpy(pVertexBuffer, vertexData, count*sizeof(VertexData)); pVertexObject->Unlock(); delete[] vertexData; vertexData = nullptr; //      //    3 float,   0- ,    D3DVERTEXELEMENT9 decl[] = { { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, D3DDECL_END() }; //      device->CreateVertexDeclaration(decl, &vertexDecl);

मैं कुछ बिंदुओं पर टिप्पणी करूंगा।
बफर बनाते समय, हम पैरामीटर डी 3 डीयूएसएजीईएजडब्लूआरआई को पास करते हैं, जीपीयू को बताते हुए कि हम बफर से डेटा नहीं पढ़ेंगे। यह GPU को आवश्यक अनुकूलन करने की अनुमति देगा, और प्रतिपादन की गति बढ़ाएगा।
वर्टेक्डेक्लेरेशन का उपयोग आमतौर पर शेड्स के साथ काम करने के लिए किया जाता है। यदि शेड्स की आवश्यकता नहीं है, तो आप इस ऑब्जेक्ट को बनाए बिना कर सकते हैं।

3. कण प्रतिपादन

अब कणों को खींचने की जरूरत है। यह बहुत सरलता से किया जाता है:

 //    device->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0f, 0 ); //    device->SetStreamSource(0, pVertexObject, 0, sizeof(VertexData)); // ,     device->SetVertexDeclaration(vertexDecl); device->BeginScene(); //  device->DrawPrimitive(D3DPRIMITIVETYPE::D3DPT_POINTLIST, //    -  0, //   0-  particles.size()); //   ,     device->EndScene();

एक महत्वपूर्ण नोट: ड्राइंग शुरू होने से पहले हर बार बिगिनसेन () को बुलाया जाना चाहिए, और अंत के बाद एंडस्कीन () ।

एनीमेशन

और निश्चित रूप से, एनीमेशन के बिना, अन्यथा यह किस प्रकार की कण प्रणाली है। उदाहरण के रूप में, मैंने गुरुत्वाकर्षण के नियम का उपयोग किया।

छिपा हुआ पाठ

 //    POINT pos; GetCursorPos(&pos); RECT rc; GetClientRect(hMainWnd, &rc); ScreenToClient(hMainWnd, &pos); const int mx = pos.x; const int my = pos.y; const auto size = particles.size(); float force; float distSquare; VertexData *pVertexBuffer; //   ,   pVertexObject->Lock(0, 0, (void**)&pVertexBuffer, D3DLOCK_DISCARD); for(int i = 0; i < size; ++i ) { auto &x = particles[i].x; auto &y = particles[i].y; distSquare= pow( x - mx, 2 ) + pow( y - my, 2 ); if( dist < 20 ) { force = 0; } else { force = G / distSquare; } const float xForce = (mx - x) * force; const float yForce = (my - y) * force; particles[i].vx *= Resistance; particles[i].vy *= Resistance; particles[i].vx += xForce; particles[i].vy += yForce; x+= particles[i].vx; y+= particles[i].vy; if( x > Width ) x -= Width; else if( x < 0 ) x += Width; if( y > Height ) y -= Height; else if( y < 0 ) y += Height; pVertexBuffer[i].x = particles[i].x; pVertexBuffer[i].y = particles[i].y; } pVertexObject->Unlock();

बफ़र को ब्लॉक करते समय, मैंने डी 3 डीएलओके_डिसकार्ड फ्लैग को निर्दिष्ट किया, यह जीपीयू को पुराने बफर से ड्राइंग कणों को जारी रखने की अनुमति देता है। उसी समय, वे हमारे लिए एक नया लौटाते हैं। यह छोटी सी चाल डाउनटाइम को कम करती है।

इस पर, लेख का पहला भाग समाप्त हो गया। अगले भाग में कणों की बनावट, वर्टेक्स और पिक्सेल शेड्स, साथ ही प्रभाव और बाद के प्रभावों का वर्णन किया जाएगा। इसके अलावा दूसरे भाग के अंत में आपको डेमो और उसके पूर्ण स्रोत कोड के लिंक दिखाई देंगे।

DirectX 9 प्लेटफ़ॉर्म पर पार्टिकल सिस्टम डेवलपमेंट। पार्ट I

0. अवधारणा और आवश्यकताओं

आवश्यकताओं।

1. Direct3D को प्रारंभ करना और एक कैमरा बनाना

2. उनके लिए कण और एक बफर बनाना

3. कण प्रतिपादन

एनीमेशन

More articles: