🤰🏿 👠 🙎🏽 परछाइयों में झाँकना या अगली दुनिया की खोज करना 🌖 👩‍👦 👨‍💼

असेंबलर मेरी पसंदीदा भाषा है ... लेकिन जीवन इतना छोटा है।

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

खुद को जानते हुए, मुझे यकीन है कि खेल को शायद ही इसका मूर्त रूप मिलेगा, लेकिन शायद कुछ जनता इस कांटेदार रास्ते पर मेरी उपलब्धियों में दिलचस्पी लेगी। और तो चलिए शुरू करते हैं।

अंतिम चक्र के अंत में, मुझे यह समझ में आया कि सीपीयू पर ग्राफिक्स की गणना करना पिछली शताब्दी से पहले से ही था, लेकिन प्राकृतिक रुकावट ने जोर दिया: सभी संभावनाओं का उपयोग नहीं किया गया था, दिलचस्प समाधान के लिए अभी भी विकल्प थे।

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

पास्कल

const tile_size = 32; //   tile_size1 : single = 0.03125; // 1/32 -    block_size = 4; // /    Size_X:Byte = 32; //    X Size_Y:Byte = 24; //    Y //--------------------------------- function is_no_empty(x,y:Integer):Integer; begin if (x>=0) AND (x<Size_X) AND (y>=0) AND (y<Size_Y) then begin if map[x,y]=1 then begin is_no_empty:=1; end else if map[x,y]=2 then begin is_no_empty:=2; end else is_no_empty:=0; end else is_no_empty:=-1; end; //--------------------------------- function crossing(r_view, x,y:Single; xi,yj, i,j:Integer):Byte; var di,dj,ddi,ddj :Shortint; //   k,i2,j2 :integer; //    key:Boolean; last_k, transp_key :Byte; sum_lenX,sum_lenY, Dx,Dy,Dx1,DY1, l :Single; //  sec1,cosec1, temp_x,temp_y, dx0,dy0 :Single; //   i0,j0 :Integer; //       begin temp_x := i*block_size; temp_y := j*block_size; i0 := trunc(temp_x * tile_size1); j0 := trunc(temp_y * tile_size1); l := sqrt(sqr(temp_y-y) + sqr(temp_x-x)) + 0.0000001; transp_key := 0; //     if is_no_empty(xi,yj)>0 then inc(transp_key); if (xi=i0) and (yj=j0) then begin crossing := min(255,transp_key*64+ l * r_view); exit; end; dx0 := (temp_x-x)/l+0.0000001; dy0 := (temp_y-y)/l+0.0000001; key := False; last_k :=0; //   if dx0<0 then begin di :=-1; ddi:= 0; end else begin di := 1; ddi:= 1; end; if dy0<0 then begin dj :=-1; ddj:= 0; end else begin dj := 1; ddj:= 1; end; sum_lenX := 0; sum_lenY := 0; sec1 := 1/dx0; cosec1 := 1/dy0; //       Y temp_x := x-(xi+ddi) * tile_size ; temp_y := y-(yj+ddj) * tile_size ; Dx := sqrt(sqr(temp_x) + sqr(temp_x * sec1 * dy0)); DY := sqrt(sqr(temp_y) + sqr(temp_y * cosec1 * dx0)); //      Y Dx1 := abs(tile_size * sec1); Dy1 := abs(tile_size * cosec1); repeat if sum_lenX+DX < sum_lenY+DY then begin xi += di; k := is_no_empty(xi,yj); sum_lenX += DX; if DX<>Dx1 then DX := Dx1; end else begin yj += dj; k := is_no_empty(xi,yj); sum_lenY += DY; if DY<>Dy1 then DY := Dy1; end; if key Then begin if (xi<>i2) Or (yj<>j2) then begin //  (  ) if last_k=1 then begin crossing := 255; exit; end; //   (  ) if transp_key>2 then begin crossing := 255; exit; end; inc(transp_key); key:= false; end; end; if k>0 then begin i2:=xi; j2:=yj; key:=true; last_k:=k; end; //    if (xi=i0) and (yj=j0) then begin crossing := min(255, transp_key*64+ l * r_view); exit; end; until k=-1; //     end; //--------------------------------- .................. x0:= mouse_x; y0:= mouse_y; //       x1 := x0 div tile_size; y1 := y0 div tile_size; koef := tile_size div block_size; //      (     ) for j:=0 to Size_Y * koef do for i:=0 to Size_X * koef do picture_mask.SetPixel(i, j, BGRA(0,0,0,crossing(x0, y0, x1, y1, i, j))); ..................

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

गणना को कम करने और बाद में चौरसाई को लागू करने के लिए मैक्रोब्लॉक्स में पिक्सेल को समूहित करने से प्रदर्शन में बहुत सुधार नहीं हुआ। प्रभाव स्पष्ट रूप से शब्द को पसंद नहीं करता था।

एल्गोरिथ्म पूरी तरह से समानांतर था, लेकिन यह बहुत सारी धाराओं का उपयोग करने के लिए समझ में नहीं आया, प्रभाव बेहतर चित्र गुणवत्ता के साथ, पिछले लेख की तुलना में बहुत खराब लग रहा था।
यह एक मृत अंत बन गया। मुझे स्वीकार करना पड़ा, मेरी आँखों में ग्राफिक्स की गणना में सीपीयू स्वयं समाप्त हो गया है। पर्दा।

पाचन क्रिया १

पिछले एक दशक में, सामान्य प्रयोजन के प्रोसेसर के विकास में लगभग कोई प्रगति नहीं हुई है। यदि उपयोगकर्ता द्वारा संपर्क किया जाता है, तो अधिकतम ध्यान देने योग्य प्रदर्शन में वृद्धि प्रति कोर 30% से अधिक नहीं है। प्रगति, इसे हल्के ढंग से करने के लिए, नगण्य है। यदि हम वेक्टर निर्देशों की लंबाई, और कन्वेयर ब्लॉकों के कुछ त्वरण के विस्तार को छोड़ देते हैं, तो यह कामकाजी पंक्तियों की संख्या में वृद्धि है। थ्रेड्स के साथ सुरक्षित काम अभी भी एक खुशी है, और सभी कार्यों को सफलतापूर्वक समानांतर नहीं किया जा सकता है। मैं एक कार्यशील कोर रखना चाहूंगा, भले ही वह 5-10 से अधिक तेज हो, लेकिन अफसोस और ओह, जैसा कि वे कहते हैं।
यहाँ हैबे पर लेख "डार्क" सिलिकॉन के युग में जीवन की एक उत्कृष्ट श्रृंखला है , जो वर्तमान मामलों के लिए कुछ आवश्यक शर्तें बताती है, लेकिन स्वर्ग से पृथ्वी पर भी लौटती है। अगले दशक में, आप प्रति कोर कंप्यूटिंग में कोई महत्वपूर्ण वृद्धि की उम्मीद नहीं कर सकते हैं। लेकिन हम GPU कोर की संख्या और उनके समग्र त्वरण के आगे विकास की उम्मीद कर सकते हैं। मेरे पुराने लैपटॉप पर भी, अनुमानित कुल GPU प्रदर्शन एक सीपीयू धागे की तुलना में 20 गुना अधिक है। यहां तक कि अगर आप सभी 4 प्रोसेसर कोर को प्रभावी ढंग से लोड करते हैं, तो भी हम जितना चाहेंगे उतना कम है।
मैं अतीत के ग्राफिक्स के डेवलपर्स को श्रद्धांजलि देता हूं, जिन्होंने हार्डवेयर त्वरक, वास्तविक स्वामी के बिना अपनी उत्कृष्ट कृतियों को बनाया।

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

पाचन २

कई दोस्त मुझसे पूछते हैं कि मैं पास्कल में क्यों लिखता हूं? जाहिर है, यह एक लुप्तप्राय भाषा है, इसका समुदाय लगातार गिर रहा है, लगभग कोई विकास नहीं है। निम्न स्तर के सिस्टम इंजीनियर C, और Java, Python, Ruby, या जो भी अभी अपने चरम पर हैं, पसंद करते हैं।
मेरे लिए, पास्कल पहले प्यार के समान है। दो दशक पहले, टर्बो पास्कल 5.5 के दिनों में, यह मेरी आत्मा में डूब गया और तब से मेरे साथ चल रहा है, डेल्फी हो या हाल के वर्षों में लाज़र । मुझे भाषा की पूर्वानुमेयता, सापेक्ष निम्न स्तर (प्रोसेसर को सम्मिलित करना और प्रोसेसर निर्देश को देखना) पसंद है, सी के साथ संगतता। मुख्य बात यह है कि कोड को इकट्ठा किया जाता है और समस्याओं के बिना निष्पादित किया जाता है, लेकिन यह फैशनेबल नहीं है, यह पुराना है, और कुछ विशेषताएं हैं, यह बकवास है। अफवाह यह है, ऐसे लोग हैं जो अभी भी LISP पर लिख रहे हैं, लेकिन सामान्य तौर पर आधी सदी के लिए।

तो, चलो विकास में गोता लगाएँ। एक परीक्षण कदम के लिए, हम छायांकन के सटीक यथार्थवादी मॉडल नहीं लेंगे, लेकिन जो हमने पहले ही कोशिश कर चुके हैं, उसे लागू करने का प्रयास करें, लेकिन GPU के प्रदर्शन के साथ, ताकि एक स्पष्ट तुलना के लिए बात की जा सके।

प्रारंभ में, मैंने एक वस्तु के लिए त्रिकोणों का उपयोग करते हुए लगभग इस आकृति की छाया प्राप्त करने के बारे में सोचा।

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

यदि आप स्क्रीन की सीमाओं से परे त्रिकोण का विस्तार करते हैं, तो इसका परिणाम यह है:

छाया की सीमाएँ बहुत कठोर निकलीं और आगे भी बढ़ीं। लेकिन सुपरस्मैपलिंग का उपयोग किए बिना एक स्वीकार्य परिणाम प्राप्त करने का एक तरीका है, यह चिकनी सीमाओं का उपयोग कर रहा है। ऐसा करने के लिए, योजना को थोड़ा बदल दें। सर्कल के स्पर्शरेखा के चौराहे पर बहुभुज के कोने पारदर्शी बनाएंगे।

परिणाम बेहतर है, लेकिन यह अभी भी अप्राकृतिक दिखता है।

नरमता देने के लिए सर्कल को थोड़ा चिकना करें, और रैखिक से शक्ति में ढाल का रूप भी बदलें।

यह एक स्वीकार्य परिणाम है।
और अंत में, प्रपत्र में बाधाओं का अनुकरण करने वाली वस्तुओं को जोड़ें।

शेडर कोड

//

#version 330 core
layout (location = 0) in vec2 aVertexPosition;
void main(void) {
gl_Position = vec4(aVertexPosition.xy, 0, 1.0);
}

//

#version 330 core
layout (points) in;
layout (triangle_strip, max_vertices = 5) out;
uniform mat4 uModelViewMatrix;
uniform float uRadius;
uniform vec2 uHeroPoint;
out float fTransparency;
out vec2 vCenter;
void main(){
vCenter = gl_in[0].gl_Position.xy;
vec2 d = uHeroPoint - vCenter;
float l = length(d);
float i = uRadius / l;
float ii = i*i;
float ij = i * sqrt(1 - ii);
vec2 p1 = vec2(vCenter.x + dx*ii - dy*ij , vCenter.y + dx*ij + dy*ii);
vec2 p2 = vec2(vCenter.x + dx*ii + dy*ij , vCenter.y - dx*ij + dy*ii);
d = uHeroPoint - p1;
vec2 p3 = vec2(p1 - d/length(d)*1000000);
d = uHeroPoint - p2;
vec2 p4 = vec2(p2 - d/length(d)*1000000);
fTransparency = 0;
gl_Position = uModelViewMatrix * vec4(p1, 0, 1);
EmitVertex();
fTransparency = 1;
gl_Position = uModelViewMatrix * vec4(p3, 0, 1);
EmitVertex();
gl_Position = uModelViewMatrix * vec4(vCenter, 0, 1);
EmitVertex();
gl_Position = uModelViewMatrix * vec4(p4, 0, 1);
EmitVertex();
fTransparency = 0;
gl_Position = uModelViewMatrix * vec4(p2, 0, 1);
EmitVertex();
EndPrimitive();
}

//

#version 330 core
precision mediump float;
varying float fTransparency;
varying vec2 vCenter;
uniform float uRadius;
uniform vec2 uScreenHalfSize;
uniform float uShadowTransparency;
uniform float uShadowSmoothness;
out vec4 FragColor;
void main(){
float l = distance(vec2((gl_FragCoord.xy - uScreenHalfSize.xy)/uScreenHalfSize.y), vCenter.xy);
if (l<uRadius) {discard;}
else {FragColor = vec4(0, 0, 0, min(pow(fTransparency, uShadowSmoothness), (l-uRadius)/uRadius*10)*uShadowTransparency);}
}

मुझे उम्मीद है कि यह जानकारीपूर्ण था

आपका विनम्र सेवक, पिक्सेल पीड़ा, रिबिल्डर।

मैं एक छोटा डेमो संलग्न कर रहा हूं। (EXE Windows)

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

परछाइयों में झाँकना या अगली दुनिया की खोज करना

More articles: