एकता में GPU रे ट्रेसिंग - भाग 3

[ पहला और दूसरा भाग।]


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

त्रिकोण

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

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

लेख के कोड को आसानी से HLSL shader कोड में पोर्ट किया जा सकता है:

static const float EPSILON = 1e-8; bool IntersectTriangle_MT97(Ray ray, float3 vert0, float3 vert1, float3 vert2, inout float t, inout float u, inout float v) { // find vectors for two edges sharing vert0 float3 edge1 = vert1 - vert0; float3 edge2 = vert2 - vert0; // begin calculating determinant - also used to calculate U parameter float3 pvec = cross(ray.direction, edge2); // if determinant is near zero, ray lies in plane of triangle float det = dot(edge1, pvec); // use backface culling if (det < EPSILON) return false; float inv_det = 1.0f / det; // calculate distance from vert0 to ray origin float3 tvec = ray.origin - vert0; // calculate U parameter and test bounds u = dot(tvec, pvec) * inv_det; if (u < 0.0 || u > 1.0f) return false; // prepare to test V parameter float3 qvec = cross(tvec, edge1); // calculate V parameter and test bounds v = dot(ray.direction, qvec) * inv_det; if (v < 0.0 || u + v > 1.0f) return false; // calculate t, ray intersects triangle t = dot(edge2, qvec) * inv_det; return true; } 

इस फ़ंक्शन का उपयोग करने के लिए, हमें एक त्रिकोण की किरण और तीन कोने चाहिए। रिटर्न वैल्यू हमें बताता है कि क्या त्रिकोण इंटरसेक्टेड है। चौराहे के मामले में, तीन अतिरिक्त मानों की गणना की जाती है: t बीम के साथ चौराहे बिंदु तक की दूरी का वर्णन करता है, और u / v त्रिभुज पर चौराहे बिंदु के स्थान को निर्धारित करने वाले तीन बायरसेंट्रिक निर्देशांक में से दो हैं (अंतिम निर्देशांक की गणना w = 1 - u - v ) के रूप में की जा सकती है। यदि आप अभी तक barycentric निर्देशांक से परिचित नहीं हैं, तो Scratchapixel पर उनकी उत्कृष्ट व्याख्या पढ़ें।

बहुत अधिक देरी के बिना, चलो एक त्रिकोण को कोड में दर्शाए गए कोने के साथ ट्रेस करें! शेड में Trace फ़ंक्शन ढूंढें और इसमें निम्न कोड टुकड़ा जोड़ें:

 // Trace single triangle float3 v0 = float3(-150, 0, -150); float3 v1 = float3(150, 0, -150); float3 v2 = float3(0, 150 * sqrt(2), -150); float t, u, v; if (IntersectTriangle_MT97(ray, v0, v1, v2, t, u, v)) { if (t > 0 && t < bestHit.distance) { bestHit.distance = t; bestHit.position = ray.origin + t * ray.direction; bestHit.normal = normalize(cross(v1 - v0, v2 - v0)); bestHit.albedo = 0.00f; bestHit.specular = 0.65f * float3(1, 0.4f, 0.2f); bestHit.smoothness = 0.9f; bestHit.emission = 0.0f; } } 

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


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

त्रिभुज मेष

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

कंप्यूटर ग्राफिक्स में, मेष को कई बफ़र्स द्वारा परिभाषित किया जाता है, जिनमें से सबसे महत्वपूर्ण शीर्ष और सूचकांक बफ़र हैं। वर्टेक्स बफर , ऑब्जेक्ट स्पेस में प्रत्येक वर्टेक्स की स्थिति का वर्णन करने वाले 3 डी वैक्टर की एक सूची है (इसका अर्थ है कि ऑब्जेक्ट को ले जाने, घुमाने या स्केल करने पर ऐसे मूल्यों को बदलने की आवश्यकता नहीं है - वे मैट्रिक्स गुणा का उपयोग करके मक्खी पर ऑब्जेक्ट स्पेस से वर्ल्ड स्पेस में परिवर्तित हो जाते हैं) । एक इंडेक्स बफर पूर्णांक मानों की एक सूची है जो इंडेक्स हैं जो वर्टेक्स बफर को इंगित करते हैं। हर तीन इंडेक्स एक त्रिकोण बनाते हैं। उदाहरण के लिए, यदि सूचकांक बफर [0, 1, 2, 0, 2, 3] है, तो इसमें दो त्रिकोण हैं: पहले त्रिकोण में शीर्ष बफर में पहले, दूसरे और तीसरे कोने शामिल हैं, और दूसरे त्रिकोण में पहले, तीसरे शामिल हैं और चौथा शिखर। इसलिए, सूचकांक बफर भी पूर्वोक्त ट्रैवर्सल ऑर्डर को निर्धारित करता है। वर्टेक्स बफ़र्स और इंडेक्स के अलावा, अतिरिक्त बफ़र हो सकते हैं जो प्रत्येक वर्टेक्स में अन्य जानकारी जोड़ते हैं। सबसे आम अतिरिक्त बफ़र मानदंड , बनावट निर्देशांक (जिसे टेक्सकोर्ड्स या बस यूवी कहा जाता है), साथ ही शीर्ष रंग भी संग्रहीत करते हैं ।

GameObjects का उपयोग करना

सबसे पहले, हमें यह पता लगाना होगा कि कौन से गेम ऑबजेक्ट्स को रे ट्रेसिंग प्रक्रिया का हिस्सा बनना चाहिए। एक भोला समाधान केवल FindObjectOfType<MeshRenderer>() उपयोग करने के लिए होगा, लेकिन कुछ अधिक लचीला और तेज़ करें। आइए एक नया RayTracingObject घटक जोड़ें:

 using UnityEngine; [RequireComponent(typeof(MeshRenderer))] [RequireComponent(typeof(MeshFilter))] public class RayTracingObject : MonoBehaviour { private void OnEnable() { RayTracingMaster.RegisterObject(this); } private void OnDisable() { RayTracingMaster.UnregisterObject(this); } } 

यह घटक प्रत्येक ऑब्जेक्ट में जोड़ा जाता है जिसे हम किरण अनुरेखण के लिए उपयोग करना चाहते हैं और RayTracingMaster का उपयोग करके उनके पंजीकरण में लगे हुए हैं। विज़ार्ड में निम्न कार्य जोड़ें:

 private static bool _meshObjectsNeedRebuilding = false; private static List<RayTracingObject> _rayTracingObjects = new List<RayTracingObject>(); public static void RegisterObject(RayTracingObject obj) { _rayTracingObjects.Add(obj); _meshObjectsNeedRebuilding = true; } public static void UnregisterObject(RayTracingObject obj) { _rayTracingObjects.Remove(obj); _meshObjectsNeedRebuilding = true; } 

सब कुछ ठीक चल रहा है - अब हम जानते हैं कि किन वस्तुओं का पता लगाने की आवश्यकता है। लेकिन फिर मुश्किल हिस्सा आता है: हम यूनिटी मेश (मैट्रिक्स, वर्टेक्स बफ़र्स और इंडेक्स - उन्हें याद रखें?) से सभी डेटा एकत्र करने जा रहे हैं, उन्हें हमारी खुद की डेटा संरचनाओं में लिखें और उन्हें GPU में लोड करें ताकि shader उनका उपयोग कर सके। आइए विज़ार्ड में डेटा संरचनाओं और बफ़र्स को C # साइड में परिभाषित करके शुरू करें:

 struct MeshObject { public Matrix4x4 localToWorldMatrix; public int indices_offset; public int indices_count; } private static List<MeshObject> _meshObjects = new List<MeshObject>(); private static List<Vector3> _vertices = new List<Vector3>(); private static List<int> _indices = new List<int>(); private ComputeBuffer _meshObjectBuffer; private ComputeBuffer _vertexBuffer; private ComputeBuffer _indexBuffer; 

... और अब हम भी यही करते हैं। क्या आपको इसकी आदत है?

 struct MeshObject { float4x4 localToWorldMatrix; int indices_offset; int indices_count; }; StructuredBuffer<MeshObject> _MeshObjects; StructuredBuffer<float3> _Vertices; StructuredBuffer<int> _Indices; 

डेटा संरचनाएं तैयार हैं, और हम उन्हें वास्तविक डेटा से भर सकते हैं। हम सभी मेषों के सभी शीर्षों को एक बड़ी List<Vector3> में इकट्ठा करते हैं, और सभी अनुक्रमित बड़ी List<int> । शीर्षकों के साथ कोई समस्या नहीं है, लेकिन सूचकांकों को बदलने की आवश्यकता है ताकि वे हमारे बड़े बफर में सही शीर्ष पर इंगित करते रहें। कल्पना करें कि हमने पहले से ही 1000 कोने से वस्तुओं को जोड़ा है, और अब हम एक सरल जाल क्यूब जोड़ते हैं। पहले त्रिकोण में सूचकांक [0, 1, 2] शामिल हो सकते हैं, लेकिन चूंकि हमारे पास पहले से ही बफर में 1000 कोने थे, इसलिए हमें घन में कोने जोड़ने से पहले सूचकांक को स्थानांतरित करना होगा। यही है, वे [1000, 1001, 1002] में बदल जाएंगे। यहाँ कोड में ऐसा दिखता है:

 private void RebuildMeshObjectBuffers() { if (!_meshObjectsNeedRebuilding) { return; } _meshObjectsNeedRebuilding = false; _currentSample = 0; // Clear all lists _meshObjects.Clear(); _vertices.Clear(); _indices.Clear(); // Loop over all objects and gather their data foreach (RayTracingObject obj in _rayTracingObjects) { Mesh mesh = obj.GetComponent<MeshFilter>().sharedMesh; // Add vertex data int firstVertex = _vertices.Count; _vertices.AddRange(mesh.vertices); // Add index data - if the vertex buffer wasn't empty before, the // indices need to be offset int firstIndex = _indices.Count; var indices = mesh.GetIndices(0); _indices.AddRange(indices.Select(index => index + firstVertex)); // Add the object itself _meshObjects.Add(new MeshObject() { localToWorldMatrix = obj.transform.localToWorldMatrix, indices_offset = firstIndex, indices_count = indices.Length }); } CreateComputeBuffer(ref _meshObjectBuffer, _meshObjects, 72); CreateComputeBuffer(ref _vertexBuffer, _vertices, 12); CreateComputeBuffer(ref _indexBuffer, _indices, 4); } 

हम RebuildMeshObjectBuffers में RebuildMeshObjectBuffers कहते हैं, और OnDisable में नए बफ़र्स को मुक्त करने के लिए मत भूलना। यहाँ दो सहायक कार्य हैं जिनका उपयोग मैंने ऊपर के कोड में बफर हैंडलिंग को आसान बनाने के लिए किया है:

 private static void CreateComputeBuffer<T>(ref ComputeBuffer buffer, List<T> data, int stride) where T : struct { // Do we already have a compute buffer? if (buffer != null) { // If no data or buffer doesn't match the given criteria, release it if (data.Count == 0 || buffer.count != data.Count || buffer.stride != stride) { buffer.Release(); buffer = null; } } if (data.Count != 0) { // If the buffer has been released or wasn't there to // begin with, create it if (buffer == null) { buffer = new ComputeBuffer(data.Count, stride); } // Set data on the buffer buffer.SetData(data); } } private void SetComputeBuffer(string name, ComputeBuffer buffer) { if (buffer != null) { RayTracingShader.SetBuffer(0, name, buffer); } } 

महान, हमने बफ़र्स बनाए और वे आवश्यक डेटा से भरे हैं! अब हमें सिर्फ इस shader को रिपोर्ट करने की आवश्यकता है। निम्न कोड SetShaderParameters जोड़ें (और नए सहायक कार्यों के लिए धन्यवाद, हम गोले बफर के कोड को कम कर सकते हैं):

 SetComputeBuffer("_Spheres", _sphereBuffer); SetComputeBuffer("_MeshObjects", _meshObjectBuffer); SetComputeBuffer("_Vertices", _vertexBuffer); SetComputeBuffer("_Indices", _indexBuffer); 

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

मेष अनुरेखण

चलो उसे इंतजार नहीं है। शेडर में, हमारे पास पहले से ही एक व्यक्तिगत त्रिकोण का ट्रेस कोड है, और मेष वास्तव में, बहुत सारे त्रिकोण हैं। यहाँ केवल एक नया पहलू यह है कि हम मैट्रिक्स का उपयोग ऑब्जेक्ट स्पेस से वर्ल्ड स्पेस में बिल्ट-इन mul फंक्शन (मल्टीप्ल के लिए छोटा) का उपयोग करके करने के लिए करते हैं। मैट्रिक्स में ऑब्जेक्ट का अनुवाद, रोटेशन और स्केल होता है। इसका आकार 4 × 4 है, इसलिए गुणन के लिए हमें 4d वेक्टर की आवश्यकता होती है। पहले तीन घटक (x, y, z) को वर्टेक्स बफर से लिया गया है। हम चौथे घटक (डब्ल्यू) को 1 पर सेट करते हैं क्योंकि हम एक बिंदु के साथ काम कर रहे हैं। यदि यह दिशा थी, तो हम मैट्रिक्स में सभी अनुवाद और पैमाने को अनदेखा करने के लिए इसमें 0 लिखेंगे। क्या यह आपके लिए भ्रामक है? फिर इस ट्यूटोरियल को कम से कम आठ बार पढ़ें। यहाँ shader कोड है:

 void IntersectMeshObject(Ray ray, inout RayHit bestHit, MeshObject meshObject) { uint offset = meshObject.indices_offset; uint count = offset + meshObject.indices_count; for (uint i = offset; i < count; i += 3) { float3 v0 = (mul(meshObject.localToWorldMatrix, float4(_Vertices[_Indices[i]], 1))).xyz; float3 v1 = (mul(meshObject.localToWorldMatrix, float4(_Vertices[_Indices[i + 1]], 1))).xyz; float3 v2 = (mul(meshObject.localToWorldMatrix, float4(_Vertices[_Indices[i + 2]], 1))).xyz; float t, u, v; if (IntersectTriangle_MT97(ray, v0, v1, v2, t, u, v)) { if (t > 0 && t < bestHit.distance) { bestHit.distance = t; bestHit.position = ray.origin + t * ray.direction; bestHit.normal = normalize(cross(v1 - v0, v2 - v0)); bestHit.albedo = 0.0f; bestHit.specular = 0.65f; bestHit.smoothness = 0.99f; bestHit.emission = 0.0f; } } } } 

हम यह सब कार्रवाई में देखने से सिर्फ एक कदम दूर हैं। आइए Trace फ़ंक्शन को थोड़ा पुनर्गठन करें और मेष वस्तुओं का एक निशान जोड़ें:

 RayHit Trace(Ray ray) { RayHit bestHit = CreateRayHit(); uint count, stride, i; // Trace ground plane IntersectGroundPlane(ray, bestHit); // Trace spheres _Spheres.GetDimensions(count, stride); for (i = 0; i < count; i++) { IntersectSphere(ray, bestHit, _Spheres[i]); } // Trace mesh objects _MeshObjects.GetDimensions(count, stride); for (i = 0; i < count; i++) { IntersectMeshObject(ray, bestHit, _MeshObjects[i]); } return bestHit; } 

परिणाम

वह सब है! आइए कुछ सरल मेषों को जोड़ते हैं (एकता आदिम ठीक हैं), उन्हें RayTracingObject घटक दें और जादू का निरीक्षण करें। अभी तक विस्तृत मेश का उपयोग न करें (कई सौ त्रिकोणों से अधिक)! हमारे shader में अनुकूलन की कमी है, और यदि आप इसे ज़्यादा करते हैं, तो प्रति पिक्सेल कम से कम एक नमूने को ट्रेस करने में सेकंड या मिनट लग सकते हैं। परिणामस्वरूप, सिस्टम GPU ड्राइवर को बंद कर देगा, एकता इंजन क्रैश हो सकता है, और कंप्यूटर को पुनरारंभ करने की आवश्यकता होगी।


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

रुचि के लिए, मैंने स्टैनफोर्ड बनी को मॉर्गन मैकगवायर आर्काइव से डाउनलोड किया और ब्लेंडर पैकेज के डिकिमेट संशोधक का उपयोग करके मैंने कोने की संख्या 431 तक घटा दी। आप इंटर्सेक्टमेशऑबजेक्ट शेडर फ़ंक्शन में लाइटिंग मापदंडों और हार्ड-कोड सामग्री के साथ प्रयोग कर सकते हैं। यहाँ सुंदर नरम छाया के साथ ढांकता हुआ खरगोश और ग्रेफ़िट्टी शेल्टर में थोड़ा फैला हुआ वैश्विक प्रकाश है:


... और यहां केप हिल के मजबूत दिशात्मक प्रकाश के तहत एक धातु का खरगोश है, जो फर्श के तल पर डिस्को चमकता है:


... और यहां दो छोटे खरगोशों को नीले आकाश केरा 9 डुस्क के तहत बड़े पत्थर सुजैन के नीचे छिपाया गया है (मैं दूसरी वस्तु के लिए वैकल्पिक सामग्री निर्धारित करता हूं, अगर इंडेक्स शिफ्ट शून्य के बराबर है, तो जांच करें):

आगे क्या है?

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

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

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