🆔 💅🏿 🍱 पोस्टकार्ड के आकार का रे ट्रेसर डिक्रिप्शन 🎈 🐵 🤘

"उन्होंने इसे फिर से किया!" - पिक्सर फ्लायर ^[1] के पीछे देखने पर यह पहली बात है, जो कोड से पूरी तरह भरी हुई थी। एंड्रयू केन्सलर के अलावा किसी अन्य द्वारा निचले दाएं कोने में निर्माण और अभिव्यक्ति के एक क्लस्टर पर हस्ताक्षर किए गए थे। जो लोग उसे नहीं जानते हैं, उनके लिए मैं कहूंगा: एंड्रयू एक प्रोग्रामर है, जिसने 2009 में 1337-बाइट बिजनेस कार्ड के आकार के रे ट्रेसर का आविष्कार किया था।

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

स्रोत कोड

फ्लायर के सामने पिक्सर भर्ती विभाग के लिए एक विज्ञापन है। रिवर्स साइड पर C ++ कोड के 2,037 बाइट्स छपे हैं, जो छोटी से छोटी संभावित सतह पर कब्जा करने के लिए बाधित है।

#include <stdlib.h> // card > pixar.ppm #include <stdio.h> #include <math.h> #define R return #define O operator typedef float F;typedef int I;struct V{F x,y,z;V(F v=0){x=y=z=v;}V(F a,F b,F c=0){x=a;y=b;z=c;}V O+(V r){RV(x+rx,y+ry,z+rz);}VO*(V r){RV(x*rx,y*r. y,z*rz);}FO%(V r){R x*r.x+y*r.y+z*rz;}VO!(){R*this*(1/sqrtf(*this%*this) );}};FL(F l,F r){R l<r?l:r;}FU(){R(F)rand()/RAND_MAX;}FB(V p,V l,V h){l=p +l*-1;h=h+p*-1;RL(L(L(lx,hx),L(ly,hy)),L(lz,hz));}FS(V p,I&m){F d=1\ e9;V f=p;fz=0;char l[]="5O5_5W9W5_9_COC_AOEOA_E_IOQ_I_QOUOY_Y_]OWW[WaOa_aW\ eWa_e_cWiO";for(I i=0;i<60;i+=4){V b=V(l[i]-79,l[i+1]-79)*.5,e=V(l[i+2]-79,l [i+3]-79)*.5+b*-1,o=f+(b+e*L(-L((b+f*-1)%e/(e%e),0),1))*-1;d=L(d,o%o);}d=sq\ rtf(d);V a[]={V(-11,6),V(11,6)};for(I i=2;i--;){V o=f+a[i]*-1;d=L(d,ox>0?f\ absf(sqrtf(o%o)-2):(o.y+=oy>0?-2:2,sqrtf(o%o)));}d=powf(powf(d,8)+powf(pz, 8),.125)-.5;m=1;F r=L(-L(B(p,V(-30,-.5,-30),V(30,18,30)),B(p,V(-25,17,-25),V (25,20,25))),B(V(fmodf(fabsf(px),8),py,pz),V(1.5,18.5,-25),V(6.5,20,25))) ;if(r<d)d=r,m=2;F s=19.9-py;if(s<d)d=s,m=3;R d;}IM(V o,V d,V&h,V&n){I m,s= 0;F t=0,c;for(;t<100;t+=c)if((c=S(h=o+d*t,m))<.01||++s>99)R n=!V(S(h+V(.01,0 ),s)-c,S(h+V(0,.01),s)-c,S(h+V(0,0,.01),s)-c),m;R 0;}VT(V o,V d){V h,n,r,t= 1,l(!V(.6,.6,1));for(I b=3;b--;){I m=M(o,d,h,n);if(!m)break;if(m==1){d=d+n*( n%d*-2);o=h+d*.1;t=t*.2;}if(m==2){F i=n%l,p=6.283185*U(),c=U(),s=sqrtf(1-c), g=nz<0?-1:1,u=-1/(g+nz),v=nx*ny*u;d=V(v,g+ny*ny*u,-ny)*(cosf(p)*s)+V( 1+g*nx*nx*u,g*v,-g*nx)*(sinf(p)*s)+n*sqrtf(c);o=h+d*.1;t=t*.2;if(i>0&&M(h +n*.1,l,h,n)==3)r=r+t*V(500,400,100)*i;}if(m==3){r=r+t*V(50,80,100);break;}} R r;}I main(){I w=960,h=540,s=16;V e(-22,5,25),g=!(V(-3,4,0)+e*-1),l=!V(gz, 0,-gx)*(1./w),u(gy*lz-gz*ly,gz*lx-gx*lz,gx*ly-gy*lx);printf("P\ 6 %d %d 255 ",w,h);for(I y=h;y--;)for(I x=w;x--;){V c;for(I p=s;p--;)c=c+T(e ,!(g+l*(xw/2+U())+u*(yh/2+U())));c=c*(1./s)+14./241;V o=c+1;c=V(cx/ox,c. y/oy,cz/oz)*255;printf("%c%c%c",(I)cx,(I)cy,(I)cz);}}// Andrew Kensler

क्या वह काम भी करता है?

कोड के साथ इसके लॉन्च के लिए एक निर्देश है। विचार मानक आउटपुट को किसी फ़ाइल में पुनर्निर्देशित करने का है। विस्तार से, हम मान सकते हैं कि आउटपुट स्वरूप एक पाठ छवि प्रारूप है जिसे नेटपीबीएम ^[2] कहा जाता है।

  $ clang -o card2 -O3 raytracer.cpp
 $ समय ।/card> pixar.ppm

 वास्तविक 2m58.524
 उपयोगकर्ता 2m57.567s
 sys 0m0.415s

दो मिनट और अड़तालीस सेकंड ^[3] के बाद, निम्न छवि उत्पन्न होती है। यह आश्चर्यजनक है कि इसके लिए कितना कम कोड आवश्यक है।

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

हम कोड को भागों में तोड़ देंगे

CLION में इनपुट पास करना कोड को प्रारूपित करता है ( यहां आउटपुट देखें) और इसे छोटे भागों / कार्यों में तोड़ देता है।

  #include <stdlib.h> // card> pixar.ppm 
  # अलग करें 
  # पिन करें <math.h>

  # डेफिन आर वापसी 
  # ओफिन हे ऑपरेटर 
  typedef float F; टाइपडीफ int int I;

  संरचना V {F x, y, z; V (F v = 0) {x = y = z = v;} V (F a, F b, F 
  c = 0) {x = a; y = b; z = c;} V O + (V r) {RV (x + rx, y + ry, z + rz);} VO * (V r) {RV; x * आरएक्स, वाई * आर। 
  y, z * rz);} FO% (V r) {R x * r.x + y * r.y + z * rz।} VO! () {R * this * (1 / sqrtf (* this%) * यह) 
  );}};

  FL (F l, F r) {R l <r? L: r;} FU () {R (F) रैंड () / RAND_MAX;} FB (V p, V l, V h) {l = p 
  + l * -1; h = h + p * -1; RL (L (L (Lx, hx), L (ly, hy)), L (lz, hz));};

  FS (V p, I & m) {F d = 1 \ 
  e9; V f = p; fz = 0; char l [] = "5O5_5W9W5_9_COC_AOEOA_E_IOQ_I_QOUOY_Y_] OWW [WaOa_aW \ _ 
  eWa_e_cWiO "; के लिए (I i = 0; मैं <60; मैं + = 4) {V b = V (l [i] -79, l [i + 1] -79) *। 5, e = V (l [] i + 2] -79, एल 
  [i + 3] -79) *। 5 + बी * -1, ओ = एफ + (बी + ई * एल (एल - (बी + एफ * -1)% ई / (ई% ई), 0), 1)) * - 1; d = L (d, o% o);} d = sq \ _ 
  rtf (d); V a [] = {V (-11.6), V (11.6)}, के लिए (I i = 2; i -;) {V o = f + a [i] * -1; डी = एल (डी, ऑक्स> 0? एफ * 
  absf (sqrtf (o% o) -2) :( o.y + = oy> 0; -2: 2, sqrtf (o% o));} d = powf (powf (d, 8) + powf (pz) । 
  8), 125) -। 5; एम = 1; एफ आर = एल (एल (बी (पी, वी -30, - 5, -30), वी (30,18,30), बी। (पी, वी (-25.17, -25), वी 
  (25,20,25))), B (V (fmodf (fbsf) (px), 8), py, pz), V (1.5,18.5, -25), V (6.5,20,25)) 
  , अगर (r <d) d = r, m = 2; F s = 19.9-py; अगर (s <d) d = s, m = 3; R d;};

  IM (V o, V d, V & h, V & n) {I m, s = 
  0; एफ टी = 0, सी; के लिए (?; टी <100; टी + = सी) अगर ((सी = एस (एच = ओ + डी * टी, एम)) <। 01 || ++ s> 99) आर n =! वी (एस (एच + वी (.01,0) 
  ), s) -c, S (h + V (0, .01), s) -c, S (h + V (0,0, .01), s) -c), m; R 0;}

  वीटी (वी ओ, वी डी) {वी एच, एन, आर, टी = 
  1, l (! V (.6, .6,1)); के लिए (I b = 3; b -;) {I m = M (o, d, h, n); if (! M) ब्रेक , अगर (m == 1) {d = d + n * ( 
  n% d * -2); o = h + d * .1; t = t * .2;} अगर (m == 2) {F i = n% l, p = 6.283185 * U (), c = U (), s = sqrtf (1-c), 
  g = nz <0? -1: 1, u = -1 / (g + nz), v = nx *y * u; d = V (v, g + ny * ny * u, -ny) * (cosf) (p) * s) + V ( 
  1 + g * nx * nx * u, g * v, -g * nx) * (sinf (p) * s) + n * sqrtf (c); o = h + d * .1; t = t *। 2; यदि (i> 0 && M (h) 
  + n * .1, l, h, n) == 3) r = r + t * V (500,400,400)) * i;} अगर (m == 3) {r = r + t * V (50,80,100) ; विराम;}} 
  R r;}

  I मुख्य () {I w = 960, h = 540, s = 16; V e (-22,5,25), g =! (((-3,4,0) + e * -1), l =! वी (gz, 
  0, -gx) * (1./w), u (gy * lz-gz * ly, gz * lx-gx * lz, gx * ly-gy * lx); printf ("P \") 
  6% d% d 255 ", w, h); के लिए (I y = h; y -;) के लिए (I x = w; x -;) {V c; के लिए (I p = s; p- -;) सी = सी + टी (ई) 
  ; (g + l * (xw / 2 + U ()) + u * (yh / 2 + U ()))); c = c * (1./s) + 14. / 241; V o = c + 1; c = V (cx / ox, c) 
  y / oy, cz / oz) * 255; प्रिंटफ ("% c% c% c", (I) cx, (I) साइबर, (I) cz);})

  // एंड्रयू केसलर

प्रत्येक अनुभाग को शेष लेख में विस्तार से वर्णित किया गया है:
■ - साधारण चाल, ■ - वेक्टर वर्ग, ■ - सहायक कोड, ■ - डेटाबेस, ■ - रे मार्चिंग, ■ - नमूना, ■ - मुख्य कोड।

#Define और typedef के साथ सामान्य ट्रिक

कॉमन ट्रिक्स कोड की मात्रा को कम करने के लिए #define और typedef का उपयोग कर रहे हैं। यहां हम एफ = फ्लोट, आई = इंट, आर = रिटर्न, और ओ = ऑपरेटर को दर्शाते हैं। रिवर्स इंजीनियरिंग तुच्छ है।

कक्षा वी

इसके बाद कक्षा V आता है, जिसे मैंने Vec का नाम दिया (भले ही, जैसा कि हम नीचे देखेंगे, इसका उपयोग RGB चैनल को फ़्लोट प्रारूप में संग्रहीत करने के लिए भी किया जाता है)।

 struct Vec { float x, y, z; Vec(float v = 0) { x = y = z = v; } Vec(float a, float b, float c = 0) { x = a; y = b; z = c;} Vec operator+(Vec r) { return Vec(x + rx, y + ry, z + rz); } Vec operator*(Vec r) { return Vec(x * rx, y * ry, z * rz); } // dot product float operator%(Vec r) { return x * rx + y * ry + z * rz; } // inverse square root Vec operator!() {return *this * (1 / sqrtf(*this % *this) );} };

ध्यान दें कि कोई घटाव ऑपरेटर (-) नहीं है, इसलिए "X = A - B" लिखने के बजाय, "X = A + B * -1" का उपयोग किया जाता है। उलटा वर्गमूल बाद में वैक्टर को सामान्य करने के लिए काम आता है।

मुख्य समारोह

main () एकमात्र ऐसा चरित्र है जिसे बाधित नहीं किया जा सकता है क्योंकि इसे libc लाइब्रेरी के _start फ़ंक्शन द्वारा कहा जाता है। यह आमतौर पर इसके साथ शुरू करने के लायक है, क्योंकि इस तरह से काम करना आसान होगा। पहले पत्रों के अर्थ निकालने में मुझे थोड़ा समय लगा, लेकिन फिर भी कुछ पठनीय बनाने में कामयाब रहा।

 int main() { int w = 960, h = 540, samplesCount = 16; Vec position(-22, 5, 25); Vec goal = !(Vec(-3, 4, 0) + position * -1); Vec left = !Vec(goal.z, 0, -goal.x) * (1. / w); // Cross-product to get the up vector Vec up(goal.y * left.z - goal.z * left.y, goal.z * left.x - goal.x * left.z, goal.x * left.y - goal.y * left.x); printf("P6 %d %d 255 ", w, h); for (int y = h; y--;) for (int x = w; x--;) { Vec color; for (int p = samplesCount; p--;) color = color + Trace(position, !(goal + left * (x - w / 2 + randomVal())+ up * (y - h / 2 + randomVal()))); // Reinhard tone mapping color = color * (1. / samplesCount) + 14. / 241; Vec o = color + 1; color = Vec(color.x / ox, color.y / oy, color.z / oz) * 255; printf("%c%c%c", (int) color.x, (int) color.y, (int) color.z); } }

ध्यान दें कि फ्लोट लिटरल में "एफ" अक्षर नहीं होता है, और अंतरिक्ष को बचाने के लिए आंशिक भाग को छोड़ दिया जाता है। नीचे उसी चाल का उपयोग किया जाता है, जहां पूर्णांक भाग गिरा दिया जाता है (फ्लोट x = .5)। ब्रेक की स्थिति के अंदर डाली गई एक पुनरावृति अभिव्यक्ति के साथ भी असामान्य "के लिए" निर्माण है।

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

सबसे महत्वपूर्ण हिस्सा नमूना है, जो सैद्धांतिक रूप से प्रतिपादन और पुनरावृत्ति को गति देने के लिए 1 पर सेट किया जा सकता है। यहां 1 से 2048 तक के नमूना मूल्यों के साथ नमूना रेंडरिंग हैं।

स्पायलर हेडिंग

128

256

512

1024

2048

हेल्पर कोड

कोड का एक और सरल टुकड़ा सहायक कार्य है। इस मामले में, हमारे पास एक तुच्छ फ़ंक्शन मिनट (), अंतराल में एक यादृच्छिक मूल्य जनरेटर [0,1] और एक बहुत अधिक दिलचस्प बॉक्सटेस्ट () है, जो दुनिया को काटने के लिए उपयोग किए जाने वाले कंस्ट्रक्टिव सॉलिड ज्यामिति (सीएसजी) प्रणाली का हिस्सा है। CSG की चर्चा अगले भाग में है।

 float min(float l, float r) { return l < r ? l : r; } float randomVal() { return (float) rand() / RAND_MAX; } // Rectangle CSG equation. Returns minimum signed distance from // space carved by lowerLeft vertex and opposite rectangle // vertex upperRight. float BoxTest(Vec position, Vec lowerLeft, Vec upperRight) { lowerLeft = position + lowerLeft * -1; upperRight = upperRight + position * -1; return -min( min( min(lowerLeft.x, upperRight.x), min(lowerLeft.y, upperRight.y) ), min(lowerLeft.z, upperRight.z)); }

रचनात्मक वॉल्यूमेट्रिक ज्यामिति के कार्य

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

 // Signed distance point(p) to sphere(c,r) float testSphere(Vec p, Vec c, float r) { Vec delta = c - p; float distance = sqrtf(delta%delta); return radius - distance; } Vec A {4, 6}; Vec B {3, 2}; Vec C {4, 2}; float r = 2.; testSphere(A, C, r); // == -1 (outside) testSphere(B, C, r); // == 1 (inside)

TestSphere () फ़ंक्शन A के लिए -1 रिटर्न देता है (जो कि, यह बाहर है) और B के लिए 1 (यानी यह अंदर है)। दूरियों पर संकेत सिर्फ एक चाल है, जिससे आप एक ही मूल्य के मामले में एक के बजाय दो टुकड़ों की जानकारी प्राप्त कर सकते हैं। एक समान प्रकार के फ़ंक्शन को एक समांतर चतुर्भुज का वर्णन करने के लिए भी लिखा जा सकता है (यह फ़ंक्शन बॉक्सटेस्ट में ऐसा ही किया जाता है)।

  // Signed distance point(p) to Box(c1,c2) float testRectangle(Vec p, Vec c1, Vec c2) { c1 = p + c1 * -1; c2 = c2 + position * -1; return min( min( min(c1.x, c2.x), min(c1.y, c2.y)), min(c1.z, c2.z)); } Vec A {3, 3}; Vec B {4, 6}; Vec C1 {2, 2}; Vec C2 {5, 4}; testRectangle(A, C1, C2); // 1.41 (inside) testRectangle(B, C1, C2); // -2.23 (outside)

अब देखते हैं कि यदि आप रिटर्न वैल्यू का चिन्ह फ्लिप करते हैं तो क्या होगा।

  // Signed distance point(p) to carved box(c1,c2) float testCarveBox(Vec p, Vec c1, Vec c2) { c1 = p + c1 * -1; c2 = c2 + position * -1; return -min( min( min(c1.x, c2.x), min(c1.y, c2.y)), min(c1.z, c2.z)); } Vec A {3, 3}; Vec B {4, 6}; Vec C1 {2, 2}; Vec C2 {5, 4}; testCarveBox(A, C1, C2); // == -1.41 (outside) testCarveBox(B, C1, C2); // == 2.23 (inside)

अब हम किसी ठोस वस्तु का वर्णन नहीं करते हैं, बल्कि पूरी दुनिया को ठोस घोषित करते हैं और उसमें खाली जगह काट देते हैं। ईंटों के निर्माण के रूप में फ़ंक्शंस का उपयोग किया जा सकता है, जो संयुक्त होने पर अधिक जटिल रूपों का वर्णन कर सकता है। तार्किक जोड़ ऑपरेटर (न्यूनतम फ़ंक्शन) का उपयोग करके हम आयतों की एक जोड़ी को एक के ऊपर एक काट सकते हैं और परिणाम इस तरह दिखेगा।

  // Signed distance point to room float testRoom(Vec p) { Vec C1 {2, 4}; Vec C2 {5, 2}; // Lower room Vec C3 {3, 5}; Vec C4 {4, 4}; // Upper room // min() is the union of the two carved volumes. return min(testCarvedBox(p, C1, C2), testCarvedBox(p, C3, C4)); } Vec A {3, 3}; Vec B {4, 6}; testRoom(A, C1, C2); // == -1.41 (outside) testRoom(B, C1, C2); // == 1.00 (inside)

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

अब, CSG के शक्तिशाली ज्ञान में महारत हासिल करने के बाद, हम कोड पर लौट सकते हैं और डेटाबेस फ़ंक्शन पर विचार कर सकते हैं, जिससे निपटना सबसे मुश्किल है।

 #define HIT_NONE 0 #define HIT_LETTER 1 #define HIT_WALL 2 #define HIT_SUN 3 // Sample the world using Signed Distance Fields. float QueryDatabase(Vec position, int &hitType) { float distance = 1e9; Vec f = position; // Flattened position (z=0) fz = 0; char letters[15*4+1] = // 15 two points lines "5O5_" "5W9W" "5_9_" // P (without curve) "AOEO" "COC_" "A_E_" // I "IOQ_" "I_QO" // X "UOY_" "Y_]O" "WW[W" // A "aOa_" "aWeW" "a_e_" "cWiO"; // R (without curve) for (int i = 0; i < sizeof(letters); i += 4) { Vec begin = Vec(letters[i] - 79, letters[i + 1] - 79) * .5; Vec e = Vec(letters[i + 2] - 79, letters[i + 3] - 79) * .5 + begin * -1; Vec o = f + (begin + e * min(-min((begin + f * -1) % e / (e % e), 0), 1) ) * -1; distance = min(distance, o % o); // compare squared distance. } distance = sqrtf(distance); // Get real distance, not square distance. // Two curves (for P and R in PixaR) with hard-coded locations. Vec curves[] = {Vec(-11, 6), Vec(11, 6)}; for (int i = 2; i--;) { Vec o = f + curves[i] * -1; distance = min(distance, ox > 0 ? fabsf(sqrtf(o % o) - 2) : (oy += oy > 0 ? -2 : 2, sqrtf(o % o)) ); } distance = powf(powf(distance, 8) + powf(position.z, 8), .125) - .5; hitType = HIT_LETTER; float roomDist ; roomDist = min(// min(A,B) = Union with Constructive solid geometry //-min carves an empty space -min(// Lower room BoxTest(position, Vec(-30, -.5, -30), Vec(30, 18, 30)), // Upper room BoxTest(position, Vec(-25, 17, -25), Vec(25, 20, 25)) ), BoxTest( // Ceiling "planks" spaced 8 units apart. Vec(fmodf(fabsf(position.x), 8), position.y, position.z), Vec(1.5, 18.5, -25), Vec(6.5, 20, 25) ) ); if (roomDist < distance) distance = roomDist, hitType = HIT_WALL; float sun = 19.9 - position.y ; // Everything above 19.9 is light source. if (sun < distance)distance = sun, hitType = HIT_SUN; return distance; }

आप यहां समांतर चतुर्भुज "कटिंग" का कार्य देख सकते हैं, जिसमें पूरे कमरे के निर्माण के लिए केवल दो आयतों का उपयोग किया जाता है (हमारा मस्तिष्क बाकी काम करता है, यह दीवारों का प्रतिनिधित्व करता है)। क्षैतिज सीढ़ी शेष विभाजन का उपयोग करके थोड़ा अधिक जटिल CSG फ़ंक्शन है। और अंत में, PIXAR शब्द एक मूल और डेल्टा जोड़ी के साथ 15 लाइनों से बना है और P और R अक्षर में घटता के लिए दो विशेष मामले हैं।

रे मार्चिंग

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

 // Perform signed sphere marching // Returns hitType 0, 1, 2, or 3 and update hit position/normal int RayMarching(Vec origin, Vec direction, Vec &hitPos, Vec &hitNorm) { int hitType = HIT_NONE; int noHitCount = 0; float d; // distance from closest object in world. // Signed distance marching for (float total_d=0; total_d < 100; total_d += d) if ((d = QueryDatabase(hitPos = origin + direction * total_d, hitType)) < .01 || ++noHitCount > 99) return hitNorm = !Vec(QueryDatabase(hitPos + Vec(.01, 0), noHitCount) - d, QueryDatabase(hitPos + Vec(0, .01), noHitCount) - d, QueryDatabase(hitPos + Vec(0, 0, .01), noHitCount) - d) , hitType; // Weird return statement where a variable is also updated. return 0; }

दूरी के आधार पर किरण मार्चिंग का विचार निकटतम वस्तु की दूरी को आगे बढ़ाना है। अंत में, किरण सतह पर इस कदर पहुंच जाएगी कि इसे घटना का बिंदु माना जा सकता है।

ध्यान दें कि किरण मार्चिंग सतह के साथ एक सच्चे चौराहे को वापस नहीं करता है, लेकिन एक सन्निकटन। इसीलिए d <0.01f होने पर कोड में मार्चिंग रुक जाती है।

यह सब एक साथ लाना: नमूना लेना

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

 Vec Trace(Vec origin, Vec direction) { Vec sampledPosition, normal, color, attenuation = 1; Vec lightDirection(!Vec(.6, .6, 1)); // Directional light for (int bounceCount = 3; bounceCount--;) { int hitType = RayMarching(origin, direction, sampledPosition, normal); if (hitType == HIT_NONE) break; // No hit. This is over, return color. if (hitType == HIT_LETTER) { // Specular bounce on a letter. No color acc. direction = direction + normal * ( normal % direction * -2); origin = sampledPosition + direction * 0.1; attenuation = attenuation * 0.2; // Attenuation via distance traveled. } if (hitType == HIT_WALL) { // Wall hit uses color yellow? float incidence = normal % lightDirection; float p = 6.283185 * randomVal(); float c = randomVal(); float s = sqrtf(1 - c); float g = normal.z < 0 ? -1 : 1; float u = -1 / (g + normal.z); float v = normal.x * normal.y * u; direction = Vec(v, g + normal.y * normal.y * u, -normal.y) * (cosf(p) * s) + Vec(1 + g * normal.x * normal.x * u, g * v, -g * normal.x) * (sinf(p) * s) + normal * sqrtf(c); origin = sampledPosition + direction * .1; attenuation = attenuation * 0.2; if (incidence > 0 && RayMarching(sampledPosition + normal * .1, lightDirection, sampledPosition, normal) == HIT_SUN) color = color + attenuation * Vec(500, 400, 100) * incidence; } if (hitType == HIT_SUN) { // color = color + attenuation * Vec(50, 80, 100); break; // Sun Color } } return color; }

अनुमत बीम प्रतिबिंब की अधिकतम संख्या को बदलने के लिए मैंने इस फ़ंक्शन के साथ थोड़ा प्रयोग किया। मान "2" अक्षरों को आश्चर्यजनक रूप से सुंदर लैक्केरेड वैन्टब्लैक रंग ^{[4] देता है} ।