GLSL में खेल "जीवन" के एमुलेटर

शुरुआत करने के लिए, एक छोटा शैक्षिक कार्यक्रम: एक , दो , तीन ।



शायद, मेरे जीवन में कम से कम एक बार खेल "जीवन" का एक एमुलेटर लिखा गया था।

शायद प्रोग्रामिंग सीखने के लिए, शायद मज़े के लिए, प्रयोग करने के लिए ...

किसी भी मामले में, कई लोकप्रिय प्रोग्रामिंग भाषाओं में कार्यान्वयन इस भाषा को सीखने के लिए एक सरल अभ्यास है।



लेकिन आज हम एक वीडियो कार्ड का उपयोग करके इस तरह के एमुलेटर को लागू करने की कोशिश करेंगे, क्योंकि गेम के एल्गोरिथ्म को समानांतर कंप्यूटिंग का उपयोग करके अच्छी तरह से लागू किया जाता है।

हम क्रमशः ओपन, शेड की भाषा - जीएलएसएल का उपयोग करते हैं। मुख्य कार्यक्रम C ++ में लिखा जाएगा

परिचय

तो चलिए शुरू करते हैं।

शुरुआत करने के लिए, आइए याद करें कि इस खेल में "पीढ़ीगत परिवर्तन" कैसे होता है।

प्रत्येक कोशिका के लिए, हम इसके जीवित पड़ोसियों की संख्या को देखते हैं। यदि यह 3 है और मूल सेल खाली है, तो सेल जीवन में आता है। यदि मूल कोशिका जीवित है, लेकिन पड़ोसियों की संख्या 2 या 3 नहीं है, तो यह मर जाता है।

जाहिर है, प्रत्येक सेल के लिए आप इन शर्तों को अलग से देख सकते हैं, आपको बस पिछले चरण में इसके राज्य और 8 पड़ोसियों की स्थिति को जानने की आवश्यकता है। इसके अलावा, अगली पीढ़ी के लिए संक्रमण "एक साथ" होता है, इसलिए, सबसे सरल कार्यान्वयन में, इस उद्देश्य के लिए दो दो आयामी सरणियों का उपयोग किया जाता है।



बेशक एक सरणी के साथ विकल्प है - उन कोशिकाओं को चिह्नित करें जो जीवन में आते हैं और मर जाते हैं, और फिर सरणी में डेटा परिवर्तन करते हैं। इस कार्यान्वयन में, हम दो फ्रेमबफ़र का उपयोग करेंगे, प्रत्येक एक बनावट (= दो आयामी सरणी) के साथ।

एक सरणी के साथ एक प्रकार काम नहीं करता है, उदाहरण के लिए, क्योंकि जब इसे प्रस्तुत करना पढ़ने और लिखने के लिए एक ही बनावट को असाइन करना असंभव है। इसके अलावा, इस विधि को सरणी से दो पास की आवश्यकता होती है।

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

प्रारंभ

फ़्रेमबफ़र और बनावट निर्माण

सबसे पहले, दो फ्रेमबफ़र बनाएं और प्रत्येक में बनावट जोड़ें।

एकल बफ़र आरंभीकरण कोड:



glGenFramebuffersEXT(1,&FrameBufferID);

glGenTextures(1,?ColorBufferID);

glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, FrameBufferID );

glBindTexture(GL_TEXTURE_2D,ColorBufferID);

glTexImage2D(GL_TEXTURE_2D,0,4,SizeX,SizeY,0,RGBA,GL_UNSIGNED_BYTE,0);

glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,ColorBufferID,0);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

glBindTexture(GL_TEXTURE_2D,0);

glDisable(GL_DEPTH_TEST);

glEnable(GL_TEXTURE_2D);

glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);









यहां हमने एक फ़्रेमबफ़र और बनावट बनाई, फिर glTexImage2D का उपयोग करके हमने बनावट का आकार और स्वरूप निर्धारित किया (बेशक, आप इन उद्देश्यों के लिए एक-घटक बनावट बना सकते हैं, और जब रेंडर कर रहे हैं, तो इसे shader में स्थानांतरित कर सकते हैं और डेटा से स्क्रीन पर रंगीन पिक्सेल प्रदर्शित कर सकते हैं, लेकिन सरलता के लिए हम इसे पसंद करेंगे। एक ही बनावट का उत्पादन, इसलिए तुरंत इस प्रारूप को सेट करें)।

निम्न glFramebufferTexture2DEXT फ़ंक्शन फ़्रेमबफ़र के लिए एक बनावट देता है।

अगला, हम बनावट के मापदंडों को समायोजित करते हैं - पड़ोसी बनावट के पिक्सल से पढ़ते समय शेडर में त्रुटियों से बचने के लिए निकटतम फ़िल्टरिंग।

सीमित क्षेत्र

जैसा कि आप जानते हैं, बहुत बार "जीवन" एमुलेटर के कंप्यूटर कार्यान्वयन में एक टॉरोइडल फ़ील्ड का उपयोग किया जाता है, अर्थात। बाएं किनारे दाईं ओर बंद हो जाता है, और ऊपर से नीचे।

यहां, GL_REPEAT हमें फ़ील्ड की ऐसी विशेषता देता है - जब आप किसी बनावट से पढ़ने की कोशिश करते हैं, तो इसके किनारे के बाहर का मूल्य दूसरे हाथ पर एक मान प्राप्त करेगा - अर्थात वास्तव में आपको क्या चाहिए।

क्षेत्र की कोशिकाओं का संपादन

GlTexSubImage2D फ़ंक्शन का उपयोग करके, आप आसानी से एक बनावट में डेटा को संशोधित कर सकते हैं। मान लें कि सेल "जीवित" है, तो सभी RGBA घटक 255 के बराबर होंगे, अन्यथा वे सभी 0 के बराबर हैं।

फिर कोड एक पिक्सेल बनावट बदलता है:



unsigned char buf[4]={val,val,val,val}; // val is 0 or 255

glBindTexture(GL_TEXTURE_2D,ColorBufferID);

glTexSubImage2D(GL_TEXTURE_2D,0,x,y,1,1,GL_RGBA,GL_UNSIGNED_BYTE,buf);

glBindTexture(GL_TEXTURE_2D,0);



लोड हो रहा है shaders

मैं यहाँ shader लोडिंग कोड नहीं दूंगा, क्योंकि वे इस मामले में सबसे सामान्य तरीके से भरी हुई हैं।

आप यहां शेड्स और फ्रेमबफर्स ​​के उपयोग के बारे में पढ़ सकते हैं ।

मुख्य शरीर

असल में, जो कुछ भी लिखा गया था, उसके लिए।

यहां, सादगी के लिए, एक बनावट को एक एकल रेंडरिंग पास दिया जाता है।

तदनुसार, आपको बारी-बारी से दो बफ़र्स की आवश्यकता है - हम एक से पढ़ते हैं, हम दूसरे को लिखते हैं।



glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, FrameBufferID );

glUseProgram ( ProgramObject );

float szx=sizex;

float szy=sizey;

glUniform1f( glGetUniformLocation (ProgramObject, "SizeX" ) , szx);

glUniform1f( glGetUniformLocation (ProgramObject, "SizeY" ) , szy);



glBindTexture(GL_TEXTURE_2D,ColorTextureID_2); //

glUniform1i( glGetUniformLocation (ProgramObject, "SourceTexture" ) , 0);



glViewport(0, 0, szx,szy);



glMatrixMode ( GL_PROJECTION );

glLoadIdentity ();

glOrtho ( 0, width, 0, height, -1, 1 );

glMatrixMode ( GL_MODELVIEW );

glLoadIdentity ();

DrawQuad(0,0,szx,szy,-1.0);



glBindTexture(GL_TEXTURE_2D,0);



glUseProgram ( 0 );

glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0 );









ड्राक्वाड फ़ंक्शन (हम सरलता के लिए एफएफपी का उपयोग करते हैं, एक अच्छे तरीके से आपको एक वर्टेक्स बफर बनाने की आवश्यकता है, आदि)



void DrawQuad (float x,float y, float w, float h ,float z)

{

glBegin ( GL_QUADS );

glTexCoord2f ( 0, 0 );

glVertex3f ( x, y ,z);



glTexCoord2f ( 1, 0 );

glVertex3f ( x+w, y ,z);



glTexCoord2f ( 1, 1 );

glVertex3f ( x+w, y+h ,z);



glTexCoord2f ( 0, 1 );

glVertex3f ( x, y+h ,z);

glEnd ();

}









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

और हां, shader कोड!

हम शीर्ष के शेडर में कुछ विशेष नहीं करते हैं, हमें शीर्ष परिवर्तन की आवश्यकता नहीं है।

void main(void)

{

gl_Position=ftransform(); //

gl_TexCoord[0] = gl_MultiTexCoord0; //

}









टुकड़े टुकड़े करना:

uniform sampler2D SourceTexture;



uniform float SizeX;

uniform float SizeY;



void main(void)

{

float deltax = 1.0/SizeX;

float deltay = 1.0/SizeY;

float Sum = texture2D(SourceTexture,gl_TexCoord[0].st+vec2( deltax, deltay)).r +

texture2D(SourceTexture,gl_TexCoord[0].st+vec2(-deltax, deltay)).r +

texture2D(SourceTexture,gl_TexCoord[0].st+vec2(-deltax,-deltay)).r +

texture2D(SourceTexture,gl_TexCoord[0].st+vec2( deltax,-deltay)).r +

texture2D(SourceTexture,gl_TexCoord[0].st+vec2( 0, deltay)).r +

texture2D(SourceTexture,gl_TexCoord[0].st+vec2( 0,-deltay)).r +

texture2D(SourceTexture,gl_TexCoord[0].st+vec2(-deltax, 0)).r +

texture2D(SourceTexture,gl_TexCoord[0].st+vec2( deltax, 0)).r ;

float center =texture2D(SourceTexture,gl_TexCoord[0].st).r;

float koef=0.0;



if(center>0.5) // - , ,

{

if(Sum>3.5 || Sum<1.5)koef=0.0;else koef=1.0; // ,

}

else

{

if(Sum>2.5 && Sum<3.5)koef=1.0; // Sum==3,

}

gl_FragColor=vec4(1.0,1.0,1.0,1.0)*koef;

}



स्रोत कोड

कार्यक्रम केवल लिनक्स (उबंटू 10.10) के तहत लिखा और लॉन्च किया गया था।

SDL लाइब्रेरी का उपयोग OpenGL संदर्भ को इनिशियलाइज़ करने के लिए किया जाता है।

तो, आप शायद विंडोज पर संकलन कर सकते हैं।

अगर कोई इकट्ठा करता है और उसे कहीं बाहर रखता है - बहुत-बहुत धन्यवाद।

सेटिंग्स फ़ाइल में, आप स्क्रीन रिज़ॉल्यूशन, फ़ील्ड आकार और फ़ील्ड की प्रारंभिक स्थिति को बदल सकते हैं।



narod.ru/disk/2930622001/LifeSim.zip.html