🌛 💆🏼 💃🏼 सी में रेंडरिंग रेंडरिंग 🧖🏻 🎵 🔕

उच्च-स्तरीय प्रोग्रामिंग भाषाओं में से एक में विकसित होने का अनुभव होने के साथ-साथ कंप्यूटर विज्ञान के विभिन्न क्षेत्रों के कार्यों में रुचि होने के कारण, मुझे अंततः एक अन्य टूल, सी प्रोग्रामिंग भाषा में महारत हासिल करने का अवसर मिला। अपने स्वयं के अनुभव के आधार पर, व्यावहारिक समस्याओं को हल करने के लिए आवेदन करने पर ज्ञान बेहतर प्राप्त होता है। इसलिए, रे स्क्रैचिंग रेंडरिंग को स्क्रैच से लागू करने का निर्णय लिया गया (क्योंकि मैं स्कूल के समय से कंप्यूटर ग्राफिक्स का शौकीन रहा हूं)।

इस लेख में मैं अपने दृष्टिकोण और परिणामों को साझा करना चाहता हूं।

किरण अनुरेखण के बारे में कुछ शब्द

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

पुनरावर्ती रे ढलाई == रे अनुरेखण

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

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

प्रत्येक पिक्सेल के रंग की गणना दूसरों से स्वतंत्र रूप से की जा सकती है (क्योंकि कैमरे से निकलने वाली किरणें किसी भी तरह से एक दूसरे को प्रभावित नहीं करती हैं - उन्हें समानांतर में संसाधित किया जा सकता है)
एल्गोरिथ्म में वस्तुओं की ज्यामिति पर प्रतिबंध नहीं है (आप आदिमों के एक समृद्ध सेट का उपयोग कर सकते हैं: विमान, गोले, सिलेंडर, आदि)

रेंडर आर्किटेक्चर

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

विभिन्न प्राथमिकताओं के साथ काम करने के लिए एक रेंडर कैसे सिखाना है?

राईट्रेस्टिंग एल्गोरिथम ऑब्जेक्ट्स की ज्यामिति से स्वतंत्र है: ऑब्जेक्ट की संरचना रेंडरर के लिए महत्वपूर्ण नहीं है, वास्तव में, किरण के साथ आकृति के चौराहों की गणना करने के लिए केवल फ़ंक्शन की आवश्यकता होती है।

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

C प्रोग्रामिंग भाषा में OOP प्रतिमान में प्रोग्रामिंग के लिए वाक्य रचना नहीं है, लेकिन इस मामले में, संरचना और फ़ंक्शन पॉइंटर्स बचाव में आते हैं ।

रेंडर सामान्यीकृत संरचनाओं (ऑब्जेक्ट 3 डी) के साथ संचालित होता है जिसमें एक डेटा क्षेत्र के लिए एक पॉइंटर होता है जिसमें 3 डी ऑब्जेक्ट के वास्तविक मापदंडों को संग्रहीत किया जाता है, साथ ही उन फ़ंक्शन को इंगित किया जाता है जो इस डेटा क्षेत्र को सही ढंग से संसाधित कर सकते हैं।

रेंडर स्रोतों से Object3d संरचना का विवरण

typedef struct { //    ,     //   :  ,  (   ),   //   :  , ,  .. void * data; //   ,    , //     data Boolean (*intersect)(const void * data, const Point3d ray_start_point, const Vector3d ray, //         Point3d * const intersection_point); //      //       //      //       :) Color (*get_color)(const void * data, const Point3d intersection_point); //       (   ) //      -      //  ,    -      Vector3d (*get_normal_vector)(const void * data, const Point3d intersection_point); //     Object3d //    ,    // ,   void (*release_data)(void * data); } Object3d;

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

एक उदाहरण के रूप में: रेंडर स्रोतों से कोड क्षेत्र

sphere.c

 // ...  typedef struct { Point3d center; Float radius; Color color; } Sphere; // ...   // ""  Object3d * new_sphere(const Point3d center, const Float radius, const Color color) { Sphere * sphere = malloc(sizeof(Sphere)); sphere->center = center; sphere->radius = radius; sphere->color = color; //      3D  Object3d * obj = malloc(sizeof(Object3d)); obj->data = sphere; //  ,      Sphere obj->get_color = get_sphere_color; obj->get_normal_vector = get_sphere_normal_vector; obj->intersect = intersect_sphere; obj->release_data = release_sphere_data; return obj; } //     //        static Color get_sphere_color(const void * data, const Point3d intersection_point) { const Sphere * sphere = data; return sphere->color; } //          //    Bump Mapping static Vector3d get_sphere_normal_vector(const void * data, const Point3d intersection_point) { const Sphere * sphere = data; // vector3dp -  ,       Vector3d n = vector3dp(sphere->center, intersection_point); normalize_vector(&n); return n; } //     static Boolean intersect_sphere(const void * data, const Point3d ray_start_point, const Vector3d ray, Point3d * const intersection_point) { const Sphere * sphere = data; //        -     //         GitHub } // ""  void release_sphere_data(void * data) { Sphere * sphere = data; //      -       free(sphere); }

उनके कार्यान्वयन की परवाह किए बिना विभिन्न प्राइमेटिव के साथ कैसे काम किया जाए, इसका एक उदाहरण

 void example(void) { Object3d * objects[2]; //  ,     (10, 20, 30)   100 objects[0] = new_sphere(point3d(10, 20, 30), 100, rgb(255, 0, 0)); //     (0, 0, 0), (100, 0, 0)  (0, 100, 0) objects[1] = new_triangle(point3d(0, 0, 0), point3d(100, 0, 0), point3d(0, 100, 0), rgb(0, 255, 0)); Point3d camera = point3d(0, 0, -100); Vector3d ray = vector3df(0, -1, 0); int i; for(i = 0; i < 2; i++) { Object3d * obj = objects[i]; Point3d intersection_point; if(obj->intersect(obj->data, camera, ray, &intersection_point)) { //            Color c = obj->get_color(obj->data, intersection_point); //  -  :-) // ,      //     ,      objects! } } }

न्याय की खातिर, यह ध्यान देने योग्य है कि इस तरह की वास्तुकला बिंदुओं के साथ बहुत सारे करतब दिखाती है।

गति प्रदान करना

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

प्रारंभ में, प्रतिपादन की गति केवल उन दृश्यों के लिए संतोषजनक थी, जिनमें एक हजार से कम बहुभुज थे। चूंकि मेरे पास 4-कोर प्रोसेसर है, इसलिए इसे समानांतर करके रेंडरिंग को गति देने का निर्णय लिया गया।

पॉसिक्स थ्रेड्स

पहली छाप: जावा थ्रेड्स के शब्दार्थ pthreads के बहुत करीब हैं। इसलिए, POSIX थ्रेड मॉडल को समझने में कोई विशेष समस्याएं नहीं थीं। मेरा थ्रेड पूल दर्ज करने का निर्णय लिया गया :-)

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

रेंडरिंग एनकैप्सुलेटिंग फंक्शन सिग्नेचर

 void render_scene(const Scene * const scene, const Camera * const camera, Canvas * canvas, const int num_threads); //  Scene  3D ,  ,      //  Camera  ,      //  Canvas  2   -

इस फ़ंक्शन में रेंडरिंग चक्र और थ्रेड पूल को जोड़ने वाला कोड शामिल था, जिनमें से कर्तव्यों में शामिल थे:

कैनवास को कई भागों में विभाजित करें
कैनवास के प्रत्येक भाग के लिए प्रतिपादन के लिए एक अलग कार्य बनता है
सभी कार्यों को पूल में भेजें और पूरा होने की प्रतीक्षा करें

लेकिन, दुर्भाग्य से, एक 2-कोर लैपटॉप पर, रेंडर समय-समय पर दुर्घटनाग्रस्त हो गया या एबॉर्ट ट्रैप 6 त्रुटि के साथ दुर्घटनाग्रस्त हो गया (और यह 4-कोर लैपटॉप पर कभी नहीं हुआ)। मैंने इस उदास बग को ठीक करने की कोशिश की, लेकिन जल्द ही एक और अधिक आकर्षक समाधान मिल गया।

OpenMP

OpenMP कार्यों को बनाने और वितरित करने का ध्यान रखता है, और रेंडरिंग के पूरा होने की प्रतीक्षा में एक बाधा का भी आयोजन करता है। सिंगल-थ्रेडेड कोड को समानांतर करने के लिए बस कुछ निर्देश जोड़ना पर्याप्त है, और होवरिंग वाले कीड़े गायब हो गए हैं :-)

स्रोत प्रतिपादन कार्य

 void render_scene(const Scene * const scene, const Camera * const camera, Canvas * canvas, const int num_threads) { const int width = canvas->width; const int height = canvas->height; const Float focus = camera->focus; //    omp_set_num_threads(num_threads); int x; int y; //   ,      :-) #pragma omp parallel private(x, y) #pragma omp for collapse(2) schedule(dynamic, CHUNK) for(x = 0; x < width; x++) { for(y = 0; y < height; y++) { const Vector3d ray = vector3df(x, y, focus); const Color col = trace(scene, camera, ray); set_pixel(i, j, col, canvas); } } }

रेंडरिंग में थोड़ी तेजी आई, लेकिन, अफसोस, एक हजार से अधिक आदिम दृश्यों वाले दृश्यों को अभी भी बहुत धीरे-धीरे प्रस्तुत किया गया था।

प्रिमिटिव्स के साथ एक किरण के चौराहे का गर्भपात एक अपेक्षाकृत संसाधन-गहन प्रक्रिया है। समस्या यह है कि प्रत्येक किरण चौराहों के लिए दृश्य के सभी प्राइमेटिव्स के साथ जांच की जाती है (किरण द्वारा निकटतम निकटतम आदिम खोज की जाती है)। क्या किसी तरह से उन वस्तुओं को बाहर करना संभव है जिनके साथ किरण बिल्कुल प्रतिच्छेद नहीं करती है?

केडी-ट्री

आइए वस्तुओं को दो भागों में विभाजित करते हैं: "बाएं" और "दाएं" (हम क्रमशः एल और आर के रूप में दर्शाते हैं:)

चूंकि हम दृश्य को समन्वय अक्षों के समानांतर भागों में विभाजित करते हैं, इसलिए हम अपेक्षाकृत जल्दी गणना कर सकते हैं कि दृश्य का कौन सा हिस्सा किरण पार करता है। निम्नलिखित विकल्प संभव हैं:

बीम दृश्य L के केवल भाग को पार करता है
आप भाग R में निहित वस्तुओं को नहीं देख सकते हैं
(चित्र में बीम 1)
बीम आर के केवल भाग को पार करता है
आप भाग एल में निहित वस्तुओं को नहीं देख सकते हैं
(चित्र में बीम 3)
किरण पहले दृश्य L के भाग को पार करती है, और फिर दृश्य R के भाग को
पहले हम दृश्य L के भाग से संबंधित वस्तुओं को देखते हैं - यदि प्रतिच्छेदन पाया गया था, तो दृश्य R के भाग से संबंधित वस्तुओं को नहीं देखा जा सकता है। यदि किरण भाग L से किसी भी वस्तु को पार नहीं करती है, तो आपको भाग R से वस्तुओं को देखना होगा
(चित्र में बीम 2)
किरण पहले दृश्य R के भाग को पार करती है, और फिर दृश्य L के भाग को
पिछले संस्करण की तरह एक ही प्रतिच्छेदन खोज तर्क (केवल पहले हम दृश्य आर के हिस्से पर विचार करते हैं)

लेकिन, ठीक उसी तरह से, देखे गए बहुभुजों की संख्या को कम करने के लिए, आप पुन: दृश्य को छोटे वर्गों में विभाजित करना जारी रख सकते हैं। परिणामी पदानुक्रमिक संरचना जिसमें दृश्य खंड होते हैं, उनसे जुड़ी प्राइमेटरीज को केडी-ट्री कहा जाता है।

उदाहरण के लिए, आइए बीम 2 को ट्रेस करने की प्रक्रिया को देखें:

किरण पहले दृश्य के बाएं खंड (L) को पार करती है, फिर दाएं - R को
भाग L से - किरण केवल LL खंड को पार करती है
एलएल खंड में कोई वस्तु नहीं है
दृश्य के दाहिने आधे भाग पर जाएं - आर
दृश्य के ठीक आधे भाग में, किरण पहले आरएल खंड को पार करती है, और फिर आरआर
आरएल दृश्य के हिस्से में, ऑब्जेक्ट के साथ बीम का चौराहा मिला
ट्रेस पूरा

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

भूतल क्षेत्र हेयुरिस्टिक

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

आइए कार्रवाई में हेयुरोलॉजी को देखने के लिए एक सरल उदाहरण का उपयोग करें:

इस प्रकार, एसएएच का उपयोग आपको रिक्त स्थान और 3 डी वस्तुओं को प्रभावी ढंग से अलग करने की अनुमति देता है - जिसका प्रतिपादन प्रदर्शन पर बहुत सकारात्मक प्रभाव पड़ता है।

टिप्पणियों

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

प्राप्त परिणाम अलग-अलग दृश्यों के लिए अलग-अलग होते हैं (चूंकि केडी-पेड़ का निर्माण आदिमों की सापेक्ष स्थिति पर निर्भर करता है)। ग्राफ़ प्राइमर की संख्या पर छवि के 1 पिक्सेल प्रति चौराहों की औसत संख्या की निर्भरता को दर्शाते हैं:

आप देख सकते हैं कि यह मान दृश्य में निहित आदिमों की संख्या से बहुत कम है (यदि कोई केडी-ट्री नहीं थे, तो हमारे पास एक रैखिक निर्भरता होगी, क्योंकि प्रत्येक किरण के लिए हमें सभी एन आदिम के साथ चौराहे की तलाश करनी होगी)। वास्तव में, केडी-ट्री का उपयोग करते हुए, हमने O (N) से O (लॉग (N)) में रीट्रैगिंग के लिए एल्गोरिथ्म की जटिलता को कम कर दिया है।

न्याय के लिए, यह ध्यान देने योग्य है कि इस समाधान का एक नुकसान केडी-पेड़ के निर्माण की संसाधन खपत है। लेकिन स्थिर दृश्यों के लिए - यह महत्वपूर्ण नहीं है: उन्होंने दृश्य को लोड किया, पेड़ के निर्माण की प्रतीक्षा की - और आप दृश्य के चारों ओर कैमरे के साथ यात्रा कर सकते हैं :-)

16386 त्रिकोण वाले दृश्य:

मॉडल डाउनलोड करें

बड़ी संख्या में आदिमों को प्रस्तुत करने के लिए सीखने के बाद, 3 डी मॉडल को लोड करने की इच्छा प्रकट हुई। एक काफी सरल और व्यापक प्रारूप चुना गया था - OBJ : मॉडल को एक पाठ फ़ाइल में संग्रहीत किया जाता है जिसमें कोने की सूची और बहुभुजों की सूची होती है (प्रत्येक बहुभुज को कोने की सूची से बिंदुओं द्वारा परिभाषित किया जाता है)।

एक बहुत ही सरल मॉडल का एक उदाहरण: tetrahedron.obj

# टेट्राहेड्रॉन

# वर्टेक्स:
v 1.00 1.00 1.00
v 2.00 1.00 1.00
v 1.00 2.00 1.00
v 1.00 1.00 2.00

# त्रिकोण:
च 1 3 2
च 1 4 3
च 1 2 4
f 2 3 4

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

प्रस्तुतिकरण स्रोतों से त्रिभुज 3 डी संरचना

 typedef struct { //   Point3d p1; Point3d p2; Point3d p3; //  ,     //      -       Vector3d norm; Color color; Material material; //    -   ,    color Canvas * texture; //   //   ,    Point2d t1; Point2d t2; Point2d t3; //     //        Vector3d n1; Vector3d n2; Vector3d n3; //      //      } Triangle3d;

प्रस्तुत दृश्य का एक उदाहरण जिसमें लगभग 19,000 बहुभुज हैं:

लगभग 22,000 बहुभुजों वाले प्रदान किए गए दृश्य का एक उदाहरण:

मज़े के लिए, मैंने एक स्काईबॉक्स जोड़ने और कार मॉडल लोड करने का फैसला किया:

इस दृश्य में लगभग 100,000 बहुभुज हैं (कुछ ही मिनटों में एक kd पेड़ बनाया गया था)

निष्कर्ष

मुझे खुशी है कि मैंने सी का अध्ययन करते हुए इस कार्य को चुना - क्योंकि, इसने मुझे भाषा पारिस्थितिकी तंत्र के विभिन्न पहलुओं को सीखने और सुंदर परिणाम प्राप्त करने की अनुमति दी।

Github रेंडर सोर्स: github.com/lagodiuk/raytracing-render (प्रोजेक्ट डिस्क्रिप्शन में- डेमो कैसे शुरू करें)।

अध्ययन की प्रक्रिया में, 2 पुस्तकों ने मुझे बहुत मदद की:

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

इसके अलावा, मैं सी की कुछ बारीकियों पर सलाह के लिए dmytrish को धन्यवाद देना चाहता हूं, और खिड़की के दृश्य को प्रदर्शित करने के लिए और कैमरे को स्थानांतरित करने और घुमाने के लिए कीबोर्ड का उपयोग करने के लिए (GLUT का उपयोग करके) रेंडर करने के लिए लिखित सीमा के लिए धन्यवाद करना चाहता हूं।

मैं एक बहुत ही उपयोगी संसाधन की भी सिफारिश करना चाहता हूं: रे- modcing.ru - यहां, एक सुलभ रूप में, विभिन्न एल्गोरिदम का उपयोग किया जाता है जो कि फोटोरेलिस्टिक रेंडरिंग के लिए उपयोग किया जाता है (विशेष रूप से, केडी-ट्री और एसएएच)।

पुनश्च
रेंडर के विकास के दौरान बनाए गए कई वीडियो:

कोहरे में Sierpinski पिरामिड

घन, आदमी, लालटेन, चायदानी और Sierpinski पिरामिड :-)

युपीडी:
यह पेड़ के निर्माण में तेजी लाने के लिए निकला। टिप्पणी धागा में विवरण: habrahabr.ru/post/187720/#comment_6580722

UPD 2:
टिप्पणियों के इस धागे में चर्चा के बाद: habrahabr.ru/post/187720/#comment_6579384 - एंटी-अलियासिंग लागू किया गया था। विचारों के लिए सभी को धन्यवाद। अब प्रदान की गई छवियां बहुत सुंदर लगती हैं :)

सी में रेंडरिंग रेंडरिंग