🐷 🆙 ❄️ 256-बाइट असेंबलर नियंत्रित ढाल हेलिक्स (k29) 👇🏻 😬 🏥

यह लेख कई सौ बाइट वजन वाले एक असेंबलर ग्राफिकल एप्लिकेशन बनाने के बारे में है। 420 बाइट्स का एक पूर्ण कार्य संस्करण बनाने के बाद, मुझे यह सब सामान 256 बाइट्स में रटना था। परिणाम आप वीडियो पर देख सकते हैं। लेख निर्माण प्रक्रिया और कामकाज के सामान्य सिद्धांतों का वर्णन करता है।

चेतावनी: यदि आपको मिर्गी के दौरे पड़ते हैं - तो न देखें।

Win7 और Vista में काम नहीं करेगा। Windows XP / 2000/98 की आवश्यकता है।

निष्पादन योग्य फ़ाइल डाउनलोड करें: ड्रॉपबॉक्स में k29.com (256 बाइट्स)
डाउनलोड स्रोत: ड्रॉपबॉक्स में k29.asm (FASM के साथ संकलन)

नियंत्रण कुंजी:
1. आर, जी, बी - रंग घटकों को सक्षम और अक्षम करें
2. <-, अंतरिक्ष, -> - रोटेशन की दिशा और गति को बदलें
3. उत्तर प्रदेश, नीचे - सर्पिल के पैमाने को बदलें
4. * 1,1,2,3,4,5,6,7,8,9 - सर्पिल में शाखाओं की संख्या बदलें
5. ईएससी - निकास

उपसंहार

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

1. शुरुआत

मुझे हमेशा से ही लोकतंत्र के साथ काम करने में दिलचस्पी रही है, खासकर सैकड़ों बाइट्स में श्रेणियां। DirectX / OpenGL का उपयोग करके 64 किलोग्राम में एक कार्यक्रम लिखना एक बात है, और काफी दूसरी बात - 512/256/128 बाइट्स तक, सीधे वीडियो मेमोरी का उपयोग करना, आदि। यहां आपको पहले से ही सहज स्तर पर कोडांतरक के ज्ञान और समझ की आवश्यकता है। वॉल्यूम के संदर्भ में कोड को अनुकूलित करने में सक्षम होना आवश्यक है, और इसलिए मशीन प्रोग्रामिंग भाषा की सभी सूक्ष्मताओं को समझने और उन्हें ध्यान में रखना चाहिए। हम ऐसा कुछ करने की कोशिश करेंगे। मैंने पहले कभी असेंबलर में नहीं लिखा था, लेकिन मैं मौजूदा कोड का पता लगाने में सक्षम था। हम मानेंगे कि यह लेख मेरी तरह असेंबलर में शुरुआती लोगों के लिए लक्षित है। इसलिए, मैं समस्या का सही समाधान होने का दिखावा नहीं करता।

2. लक्ष्य चयन

अब आपको एक कार्य के साथ आने और इसे लागू करने की आवश्यकता है। मैं तुरंत पास्कल में अपने स्कूल के वर्षों में लिखे गए एक छोटे से कार्यक्रम के साथ आया। यह कार्यक्रम असहमति के लिए सरल था (2 कोड स्क्रीन - 50 लाइनें), लेकिन एक ही समय में इसे वितरित किया गया। कार्यक्रम ने ग्राफिक मोड (320x200x256) पूर्ण स्क्रीन में एक घूर्णन सर्पिल चित्रित किया। सभी 256 रंगों को शामिल किया गया था, एक चिकनी रंग परिवर्तन के लिए। यह आश्चर्यजनक था कि सर्पिल बिना किसी दृश्य के घूमते हुए चलता है। यह कई वीडियो पृष्ठों के उपयोग द्वारा समझाया जा सकता है, यदि रोटेशन की गति के लिए नहीं। जाहिर है, एक सर्पिल खींचने के लिए, वास्तविक संख्याओं के साथ गणना आवश्यक है, जो एक महत्वपूर्ण देरी का भी परिचय देती है। सर्पिल प्रति सेकंड 3-5 क्रांतियों की गति से घूमता है (चित्र 2.1 देखें)।

[चित्र। 2.1। तीन "हाथों" के साथ एक सर्पिल का एक स्नैपशॉट

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

0	# 000000	काला (सर्पिल दिखाई नहीं देता)
1	# 0000FF	नीला
2	# 00FF00	चमकीला हरा
3	# 00FFFF	फ़िरोज़ा
4	# Ff0000	लाल
5	# FF00FF	बैंगनी
6	# FFFF00	पीला
7	#FFFFFF	सफेद

चूंकि स्क्रीन पर डिस्प्ले के लिए RGB कलर मॉडल का उपयोग किया जाता है, इसलिए इन आठ रंगों को संबंधित रंग घटकों को मिलाकर प्राप्त किया जा सकता है (3 डेटा बिट्स 8 अलग-अलग मानों को एनकोड कर सकते हैं)। कार्यक्रम ने इसी रंग घटकों को चालू / बंद करने के लिए 'आर', 'जी' और 'बी' कीज़ का उपयोग किया।

कार्यक्रम पास्कल में टर्बो पास्कल 7.0 विकास के माहौल में लिखा गया था। कार्यक्रम के कुछ कार्यों को कोडांतरक आवेषण के रूप में लागू किया गया था। उदाहरण के लिए, पैलेट से एक विशिष्ट तत्व के लिए आरजीबी मान सेट करने का कार्य। स्कूल बार कोड (स्वरूपण इतना बदल गया कि किसी के मानस को घायल नहीं किया जा सकता):

program P_16_B_4; uses crt,graph,MUSE_OTH,MT_MAIN; const koef1=3;{   } koef2=3;{   } var gd,gm,gmx,gmy,i,flag,x0,y0,x,y:integer; r,alpha:extended; k,int:longint; key:char;rr,gg,bb:byte; ints:string; mas:array[0..255,1..3] of byte; BEGIN gd:=installuserdriver('SVGA256m.BGI',NIL);gm:=2; initgraph(gd,gm,''); gmx:=getmaxx; gmy:=getmaxy; flag:=1;k:=1; for i:=0 to 255 do begin setRGBpalette(i,k,k,k); mas[i,1]:=k;mas[i,2]:=k;mas[i,3]:=k; k:=k+flag; if k=63 then flag:=-1 else if k=0 then flag:=1; end; setcolor(63); settextstyle(1,horizdir,2); settextjustify(centertext,centertext); outtextxy(gmx div 2,gmy div 2-textheight('!<06@')*2 div 2, '!<06@ freeware'); outtextxy(gmx div 2,gmy div 2+textheight('!<06@') div 2, '! ! ! Press "R", "G", "B", " " or "Esc" ! ! !'); x0:=gmx div 2; y0:=gmy div 2; r:=400; repeat alpha:=0; repeat x:=round(x0+r*cos(alpha/180*Pi)); y:=round(y0-r*sin(alpha/180*Pi)); putpixel(x,y,round(r*koef2+alpha*256/360*koef1/2) mod 128); alpha:=alpha+20/(r+1); until alpha>=360; if keypressed then halt; r:=r-1; until r<=0; k:=1;flag:=-1;rr:=1;gg:=1;bb:=1;int:=0; repeat str(int SHR 2,ints); while byte(ints[0])<4 do insert('0',ints,1); if int and 3=0 then SAVE_MONITOR((gmx+1) div 2-75,(gmy+1) div 2-75,(gmx+1) div 2+74, (gmy+1) div 2+74,'c:\AVATAR\'+ints+'.bmp'); if keypressed then begin key:=readkey; if key=' ' then flag:=-flag else if upcase(key)='R' then rr:=not(rr) and 1 else if upcase(key)='G' then gg:=not(gg) and 1 else if upcase(key)='B' then bb:=not(bb) and 1 else if key=#27 then break; end; for i:=0 to 127 do setRGBpalette(i,mas[(i+k+512) mod 256,1]*rr, mas[(i+k+512) mod 256,2]*gg, mas[(i+k+512) mod 256,3]*bb); inc(k,flag);k:=k mod 256; inc(int); until false; closegraph; END.

3. एल्गोरिथ्म का विकास

सबसे पहले, आइए जानें कि कार्यक्रम कैसे कार्य करता है और हमें किन कार्यों को लिखने की आवश्यकता है। एल्गोरिथम का औपचारिक विवरण:

1) निम्नलिखित मूल्यों के साथ पैलेट की प्रारंभिक भरने: (0,0,0) ... (63,63,63) ... (0,0,0)। दूसरे शब्दों में, पैलेट के 256 से अधिक तत्व, रंग आसानी से काले से सफेद में बदल जाता है और फिर से काले रंग में लौट आता है। इस ग्राफिक मोड में, 256 रंगों तक का समर्थन किया जाता है, प्रत्येक रंग में तीन रंग घटक होते हैं। रंग घटकों में से प्रत्येक को छह बिट्स (0 से 63 की संख्या) द्वारा परिभाषित किया गया है। सफेद रंग रंग घटकों (63.63.63) के वेक्टर से मेल खाता है, और क्रमशः काले रंग के लिए, (0.0.0)।

2) एक सर्पिल खींचना स्क्रीन के सभी पिक्सल के माध्यम से एक मार्ग शामिल करता है और उन्हें डेटा के साथ भरता है। सर्पिल सूत्र काफी सरल है - यह केवल एक वेक्टर (मूल्यों की एक जोड़ी: दूरी और कोण) पर निर्भर करता है जो स्क्रीन के केंद्र से एक विशिष्ट पिक्सेल की ओर इशारा करता है। दूसरे शब्दों में, रंग केवल वेक्टर की लंबाई और चयनित गुणांक वाले वेक्टर के कोण पर निर्भर करता है। विभिन्न गुणांक के माध्यम से छंटनी, एक सर्पिल की "शाखाओं" और मोड़ की एक अलग डिग्री दोनों प्राप्त कर सकते हैं।

3) पैलेट की चक्रीय पारी एक स्थिति से। यह सर्पिल रोटेशन का भ्रम देता है। यही है, 256 रंग तत्वों को बदलते हुए, हमें पूर्ण क्रांति का 1 / (256 * k) सर्पिल बदलाव मिलता है। जहाँ k सर्पिल की "शाखाओं" की संख्या है। इस प्रकार, हमने सर्पिल को घुमाने के लिए स्क्रीन के सभी पिक्सल को फिर से तैयार करने से परहेज किया। वास्तव में, हम एक स्थिति से नहीं हटेंगे, बदलाव की दिशा और दिशा एक विशेष पूर्णांक चर में संग्रहीत की जाती है। यह हमें सर्पिल के रोटेशन की दिशा और गति को गतिशील रूप से बदलने की अनुमति देगा।

4) टेस्ट कीस्ट्रोक्स। R, G, और B कुंजियों को दबाने पर प्रत्येक कुंजी को निर्दिष्ट रंग घटक चालू या बंद हो जाएगा। दाएं / बाएं कुंजियों को दबाने से चर के मूल्य में वृद्धि / घट जाती है, जिसका उपयोग पैलेट को स्थानांतरित करते समय स्पष्ट रूप से किया जाता है। बिंदु 3 पर जाएं।

4. एल्गोरिथ्म का कार्यान्वयन

खैर, अब हम परिभाषित करते हैं कि हमें असेंबलर में कौन से कार्य लिखने हैं। जाहिर है, ये होंगे: प्रारंभिक भरने का कार्य, सर्पिल प्रदान करने का कार्य, पैलेट का चक्रीय शिफ्ट फ़ंक्शन, और कार्यक्रम का मुख्य कार्य, जो उपरोक्त कार्यों को कॉल करने के अलावा कीबोर्ड नियंत्रण कुंजी पर कीस्ट्रोक्स का सत्यापन प्रदान करेगा। एल्गोरिथम फ़्लोचार्ट:

[चित्र। 4.1। प्रवाह संचित्र]

विकिपीडिया पर उपलब्ध असेंबलर कंपाइलर और क्रिस कास्पर्सकी और ईवा रोको की किताब "द आर्ट ऑफ डिसैम्बेंबलिंग" के बारे में पढ़ने के बाद, मैंने एफएएसएम संकलक के पक्ष में अपनी पसंद बनाई। मैं नोटपैड ++ में कोड लिखूंगा, और इसमें से मैं सिंटैक्स हाइलाइटिंग के साथ लेख को निर्यात करूंगा।

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

4.1। पैलेट प्रारंभिक कार्य

हम निम्नलिखित मूल्यों के साथ पैलेट भरने जा रहे हैं: (0,0,0), ... (63,63,63), ... (0,0,0)। यह गणना करना आसान है कि उनमें से केवल 127 हैं, सभी 256 तत्वों की समान भरने के लिए हम 2 समान तत्वों को भरेंगे: (0,0,0), (0,0,0), ... (63,63,63), (63 , 63.63), ... (0,0,0), (0,0,0)। हम एक उच्च स्तरीय औपचारिक भाषा में एल्गोरिथ्म लिखते हैं:

 for (int i = 0; i <= 127; i++) { setPalette(i, i/2, i/2, i/2); setPalette(255-i, i/2, i/2, i/2); }

अब कोड कोड टिप्पणी के साथ:

एक	बी	सी	डी

A. हम स्टैक पर सेव करते हैं और स्टैक से रिस्टोर करते हैं जो फंक्शन में उपयोग किए जाते हैं।
B. CX रजिस्टर 0 से 127 समावेशी चक्र में चलता है।
C. हम पैरामीटर बनाते हैं और सेटपलेट फ़ंक्शन को कॉल करते हैं। एएल में हम रंग इंडेक्स को लोड करते हैं, एएच में हम आधे इंडेक्स के बराबर चमक मूल्य को लोड करते हैं।
D. सभी बिट्स के इन्वेंट्री ऑपरेशन का उपयोग करके इंडेक्स को (255-i) बदलें और सेटपलेट फ़ंक्शन को कॉल करें।

4.2। सर्पिल प्रतिपादन कार्य

चलो ढाल सर्पिल विवरण फ़ंक्शन के बारे में सोचते हैं।
केवल त्रिज्या के आधार पर एक समारोह ढाल हलकों देता है:

 pixel[x][y] = k1*sqrt(x*x + y*y);

[चित्र। 4.1। ग्रेडिएंट सर्किल]

केवल कोण पर निर्भर एक कार्य केंद्र से ढाल किरणें देता है:

 pixel[x][y] = k1*arctan(x/y);

[चित्र। 4.2। ढाल किरणें]

फ़ंक्शन, जो त्रिज्या और कोण पर रैखिक रूप से निर्भर करता है, हमें वांछित ढाल सर्पिल देगा:

 pixel[x][y] = k1*sqrt(x*x + y*y) + k2*k3*arctan(x/y));

[चित्र। 4.3। स्नातक सर्पिल]

सर्पिल के 360 डिग्री सही ड्राइंग के लिए आवश्यक गुणांक का चयन करना केवल आवश्यक है। गुणांक k1 केवल सर्पिल के मोड़ की डिग्री को प्रभावित करता है। 360 डिग्री की सही भरने के लिए, हम निम्न प्रकार से गुणांक k3 चुनते हैं:

 k3 = 128 / 3.1415927;

[चित्र। 4.4। सही 360 डिग्री ढाल सर्पिल]

गुणांक k2 पूर्णांक मान लेगा: 1, 2, 3, 4 ... इस गुणांक को बदलते हुए, हमें सर्पिल पर समान संख्या में शाखाएं मिलती हैं। एक, दो और पांच के बराबर k2 के साथ ढाल सर्पिल के उदाहरण अंजीर में प्रस्तुत किए जाते हैं। 4.5, 4.6 और 4.7:

[चित्र। 4.5। एकल शाखा सर्पिल]

[चित्र। 4.6। दो शाखाओं वाला सर्पिल]

[चित्र। 4.7। पांच-शाखा सर्पिल]

छद्म भाषा सर्पिल प्रतिपादन कोड:
(शून्य द्वारा विभाजन सहित संभावित त्रुटियों को छोड़कर)

 for (int y = 0; y < 200; y++) for (int x = 0; x < 320; x++) { y -= 100; x -= 160; int color = k1*sqrt(x*x + y*y) + k2*128/3.1415927*arctan(x/y); y += 100; x += 160; pixel[x][y] = color; }

अब हम कोडांतरक एल्गोरिथ्म को लागू करते हैं।

एक	बी	सी	डी	ए

A. हम स्टैक पर सेव करते हैं और स्टैक से रिस्टोर करते हैं जो फंक्शन में उपयोग किए जाते हैं।
B. रजिस्टर एएक्स 0 से 199 तक के चक्र में चलता है।
C. बीएक्स रजिस्टर 0 से 319 तक के चक्र में चलता है।
D. सहेजें AX और BX स्टैक पर। हम स्क्रीन पर सर्पिल के केंद्र के निर्देशांक को संरेखित करते हैं, 320x200 के एक संकल्प के लिए हम केंद्र को मध्य में स्थानांतरित करते हैं - (160, 100)। स्टैक से AX और BX को पुनर्स्थापित करें।
ई। हम वर्ग एएक्स, रजिस्टरों एएक्स और बीएक्स के मूल्यों को स्वैप करते हैं, और फिर से स्क्वायर एएक्स। हमारे पास निर्देशांक के एएक्स और बीएक्स वर्गों में रजिस्टर हैं। रजिस्टरों के मूल्यों को जोड़ें और परिणाम को डीएक्स में लोड करें।

रूट की गणना आवेदन कोड के आकार को कम करने के पक्ष में बलिदान किया जा सकता है। स्टैक पर बचत करना और वेक्टर की लंबाई की गणना करते समय रजिस्टर AX और BX को वापस करना अच्छा होगा:

 push ax push bx ; dx = ax^2 + bx^2 mul ax, ax xchg ax, bx mul ax, ax add ax, bx mov dx, ax pop bx pop ax

अब कोड जो दिए गए पाप और कोस के कोण उच्चारण की गणना करता है:

 ;    * k2 ; dx += arctan(alpha * k2) mov [cos], ax mov [sin], bx finit fild word [cos] fild word [sin] fpatan fimul word [k2] fimul word [glad1] fidiv word [glad2] fist word [tmp] add dx, [tmp]

4.3। टेस्ट कीस्ट्रोक्स

 ;     mov ah, 0Bh ; AX := 0B00h int 21h cmp al, 0ffh jmp_loop_pal_exit: jne loop_pal_out ;     mov ah, 08h int 21h label_push_space: cmp al, ' ' jne label_push_left mov ch, 0 label_push_left: cmp al, 75 jne label_push_right dec ch .......

मुझे लगता है कि कोड पहले से ही सभी को मिला है)) वही है जहां यह पूरी तरह से निहित है: http://codepad.org/mEDX1Z2X

आप अतिरिक्त नियंत्रण कुंजी को हटाकर कोड की मात्रा को और कम कर सकते हैं। मुझे लगता है कि यदि आप सभी नियंत्रण बाहर फेंक देते हैं, तो यह आसानी से 128 बाइट्स में फिट हो सकता है। लेकिन नियंत्रण के बिना यह इतना दिलचस्प नहीं है।

256-बाइट असेंबलर नियंत्रित ढाल हेलिक्स (k29)