👩‍🚒 🏼 👷🏼 2 डी स्थानिक दूरी पर हस्ताक्षर किए गए फ़ील्ड के साथ हेरफेर 🖖🏼 🛀🏻 🌜

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

विन्यास

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

यहां यह महत्वपूर्ण है कि आंकड़े उत्पन्न करने के लिए पदों का उपयोग करने से पहले परिवर्तनीय हिस्सा है।

Shader "Tutorial/036_SDF_Space_Manpulation/Type"{ Properties{ _InsideColor("Inside Color", Color) = (.5, 0, 0, 1) _OutsideColor("Outside Color", Color) = (0, .5, 0, 1) _LineDistance("Mayor Line Distance", Range(0, 2)) = 1 _LineThickness("Mayor Line Thickness", Range(0, 0.1)) = 0.05 [IntRange]_SubLines("Lines between major lines", Range(1, 10)) = 4 _SubLineThickness("Thickness of inbetween lines", Range(0, 0.05)) = 0.01 } SubShader{ //the material is completely non-transparent and is rendered at the same time as the other opaque geometry Tags{ "RenderType"="Opaque" "Queue"="Geometry"} Pass{ CGPROGRAM #include "UnityCG.cginc" #include "2D_SDF.cginc" #pragma vertex vert #pragma fragment frag struct appdata{ float4 vertex : POSITION; }; struct v2f{ float4 position : SV_POSITION; float4 worldPos : TEXCOORD0; }; v2f vert(appdata v){ v2f o; //calculate the position in clip space to render the object o.position = UnityObjectToClipPos(v.vertex); //calculate world position of vertex o.worldPos = mul(unity_ObjectToWorld, v.vertex); return o; } float scene(float2 position) { // manipulate position with cool methods here! float2 squarePosition = position; squarePosition = translate(squarePosition, float2(2, 2)); squarePosition = rotate(squarePosition, .125); float squareShape = rectangle(squarePosition, float2(1, 1)); float2 circlePosition = position; circlePosition = translate(circlePosition, float2(1, 1.5)); float circleShape = circle(circlePosition, 1); float combination = merge(circleShape, squareShape); return combination; } float4 _InsideColor; float4 _OutsideColor; float _LineDistance; float _LineThickness; float _SubLines; float _SubLineThickness; fixed4 frag(v2f i) : SV_TARGET{ float dist = scene(i.worldPos.xz); fixed4 col = lerp(_InsideColor, _OutsideColor, step(0, dist)); float distanceChange = fwidth(dist) * 0.5; float majorLineDistance = abs(frac(dist / _LineDistance + 0.5) - 0.5) * _LineDistance; float majorLines = smoothstep(_LineThickness - distanceChange, _LineThickness + distanceChange, majorLineDistance); float distanceBetweenSubLines = _LineDistance / _SubLines; float subLineDistance = abs(frac(dist / distanceBetweenSubLines + 0.5) - 0.5) * distanceBetweenSubLines; float subLines = smoothstep(_SubLineThickness - distanceChange, _SubLineThickness + distanceChange, subLineDistance); return col * majorLines * subLines; } ENDCG } } FallBack "Standard" }

और shader के साथ एक ही फ़ोल्डर में स्थित 2D_SDF.cginc फ़ंक्शन, जिसे हम विस्तारित करेंगे, पहले इस तरह दिखता है:

 #ifndef SDF_2D #define SDF_2D //transforms float2 rotate(float2 samplePosition, float rotation){ const float PI = 3.14159; float angle = rotation * PI * 2 * -1; float sine, cosine; sincos(angle, sine, cosine); return float2(cosine * samplePosition.x + sine * samplePosition.y, cosine * samplePosition.y - sine * samplePosition.x); } float2 translate(float2 samplePosition, float2 offset){ //move samplepoint in the opposite direction that we want to move shapes in return samplePosition - offset; } float2 scale(float2 samplePosition, float scale){ return samplePosition / scale; } //combinations ///basic float merge(float shape1, float shape2){ return min(shape1, shape2); } float intersect(float shape1, float shape2){ return max(shape1, shape2); } float subtract(float base, float subtraction){ return intersect(base, -subtraction); } float interpolate(float shape1, float shape2, float amount){ return lerp(shape1, shape2, amount); } /// round float round_merge(float shape1, float shape2, float radius){ float2 intersectionSpace = float2(shape1 - radius, shape2 - radius); intersectionSpace = min(intersectionSpace, 0); float insideDistance = -length(intersectionSpace); float simpleUnion = merge(shape1, shape2); float outsideDistance = max(simpleUnion, radius); return insideDistance + outsideDistance; } float round_intersect(float shape1, float shape2, float radius){ float2 intersectionSpace = float2(shape1 + radius, shape2 + radius); intersectionSpace = max(intersectionSpace, 0); float outsideDistance = length(intersectionSpace); float simpleIntersection = intersect(shape1, shape2); float insideDistance = min(simpleIntersection, -radius); return outsideDistance + insideDistance; } float round_subtract(float base, float subtraction, float radius){ return round_intersect(base, -subtraction, radius); } ///champfer float champfer_merge(float shape1, float shape2, float champferSize){ const float SQRT_05 = 0.70710678118; float simpleMerge = merge(shape1, shape2); float champfer = (shape1 + shape2) * SQRT_05; champfer = champfer - champferSize; return merge(simpleMerge, champfer); } float champfer_intersect(float shape1, float shape2, float champferSize){ const float SQRT_05 = 0.70710678118; float simpleIntersect = intersect(shape1, shape2); float champfer = (shape1 + shape2) * SQRT_05; champfer = champfer + champferSize; return intersect(simpleIntersect, champfer); } float champfer_subtract(float base, float subtraction, float champferSize){ return champfer_intersect(base, -subtraction, champferSize); } /// round border intersection float round_border(float shape1, float shape2, float radius){ float2 position = float2(shape1, shape2); float distanceFromBorderIntersection = length(position); return distanceFromBorderIntersection - radius; } float groove_border(float base, float groove, float width, float depth){ float circleBorder = abs(groove) - width; float grooveShape = subtract(circleBorder, base + depth); return subtract(base, grooveShape); } //shapes float circle(float2 samplePosition, float radius){ //get distance from center and grow it according to radius return length(samplePosition) - radius; } float rectangle(float2 samplePosition, float2 halfSize){ float2 componentWiseEdgeDistance = abs(samplePosition) - halfSize; float outsideDistance = length(max(componentWiseEdgeDistance, 0)); float insideDistance = min(max(componentWiseEdgeDistance.x, componentWiseEdgeDistance.y), 0); return outsideDistance + insideDistance; } #endif

अंतरिक्ष की पुनरावृत्ति

दर्पण प्रतिबिंब

सबसे सरल ऑपरेशनों में से एक दुनिया एक अक्ष के बारे में बता रही है। इसे y अक्ष के चारों ओर दर्पण करने के लिए, हम अपनी स्थिति के x घटक का निरपेक्ष मान लेते हैं। इस प्रकार, अक्ष के दाईं और बाईं ओर के निर्देशांक समान होंगे। (-1, 1) (1, 1) में बदल जाता है, और एक समन्वय मूल के रूप में (1, 1) का उपयोग करके एक सर्कल के अंदर हो जाता है और 0 से अधिक त्रिज्या के साथ होता है।

सबसे अधिक बार, इस फ़ंक्शन का उपयोग करने वाला कोड position = mirror(position); जैसा कुछ दिखाई देगा position = mirror(position); इसलिए हम इसे थोड़ा सरल कर सकते हैं। हम केवल तर्क के रूप में स्थिति तर्क को घोषित करेंगे। इस प्रकार, जब तर्क पर लिखते हैं, तो यह उस चर को भी बदल देगा जिसे हम फ़ंक्शन में पास करते हैं। वापसी मूल्य तब प्रकार शून्य हो सकता है, क्योंकि हम अभी भी वापसी मूल्य का उपयोग नहीं करते हैं।

 //in 2D_SDF.cginc void mirror(inout float2 position){ position.x = abs(position.x); }

 //in shader function mirror(position);

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

 //in shader function float rotation = _Time.y * 0.25; position = rotate(position, rotation); mirror(position); position = rotate(position, -rotation);

कोशिकाओं

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

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

 //in 2D_SDF.cginc void cells(inout float2 position, float2 period){ position = fmod(position, period); //negative positions lead to negative modulo position += period; //negative positions now have correct cell coordinates, positive input positions too high position = fmod(position, period); //second mod doesn't change values between 0 and period, but brings down values that are above period. }

 //in shader function cells(position, float2(3, 3));

कोशिकाओं के साथ समस्या यह है कि हम निरंतरता खो देते हैं जिसके लिए हम दूरी के क्षेत्रों से प्यार करते हैं। यह बुरा नहीं है अगर आकृतियाँ केवल कोशिकाओं के बीच में होती हैं, लेकिन इसके ऊपर दिखाए गए उदाहरण में महत्वपूर्ण कलाकृतियों को शामिल किया जा सकता है, जिनसे दूरी के खेतों का उपयोग कई कार्यों के लिए किया जाता है जिसमें दूरी के खेतों को आमतौर पर लागू किया जा सकता है।

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

सेल इंडेक्स की गणना करने के लिए, हम अवधि द्वारा स्थिति को विभाजित करते हैं। इस प्रकार, 0-1 पहली सेल है, 1-2 दूसरी है, और इसी तरह ... और हम इसे आसानी से समझ सकते हैं। सेल के सूचकांक को प्राप्त करने के लिए, हम तब मूल्य को गोल करते हैं और परिणाम वापस करते हैं। महत्वपूर्ण बात यह है कि हम कोशिकाओं को दोहराने के लिए शेष के साथ विभाजित करने से पहले सेल के सूचकांक की गणना करते हैं; अन्यथा, हमें हर जगह सूचकांक 0 मिलेगा, क्योंकि स्थिति अवधि से अधिक नहीं हो सकती है।

 //in 2D_SDF.cginc float2 cells(inout float2 position, float2 period){ position = fmod(position, period); //negative positions lead to negative modulo position += period; //negative positions now have correct cell coordinates, positive input positions too high position = fmod(position, period); //second mod doesn't change values between 0 and period, but brings down values that are above period. float2 cellIndex = position / period; cellIndex = floor(cellIndex); return cellIndex; }

इस जानकारी के साथ, हम कोशिकाओं को फ्लिप कर सकते हैं। यह समझने के लिए कि फ्लिप करने के लिए या नहीं, हम सेल इंडेक्स मोडुलो को विभाजित करते हैं। 2 इस ऑपरेशन का परिणाम वैकल्पिक रूप से 0 और 1 या -1 है जो हर दूसरे सेल में है। परिवर्तन को अधिक स्थायी बनाने के लिए, हम निरपेक्ष मूल्य लेते हैं और एक मान प्राप्त करते हैं जो 0 और 1 के बीच स्विच करता है।

सामान्य और फ़्लिप्ड पोज़िशन के बीच फ़्लिप करने के लिए इस मान का उपयोग करने के लिए, हमें एक फंक्शन की आवश्यकता होती है, जो वेल्यू 0 के लिए कुछ भी नहीं करता है, और जिस पोज़िशन में फ़्लिपिंग होता है, उस पोज़िशन को घटाता है। 1. यही है, हम फ्लिप वैरिएबल का उपयोग करके सामान्य से फ़्लिप पोज़िशन का रैखिक प्रक्षेप करते हैं। । चूंकि फ्लिप चर 2d वेक्टर है, इसके घटक व्यक्तिगत रूप से फ़्लिप किए जाते हैं।

 //in shader function float2 period = 3; float2 cell = cells(position, period); float2 flip = abs(fmod(cell, 2)); position = lerp(position, period - position, flip);

रेडियल कोशिकाएं

एक और महान विशेषता रेडियल पैटर्न में अंतरिक्ष की पुनरावृत्ति है।

इस प्रभाव को प्राप्त करने के लिए, हम पहले रेडियल स्थिति की गणना करते हैं। ऐसा करने के लिए, हम x अक्ष के केंद्र के सापेक्ष कोण और y अक्ष के साथ केंद्र से दूरी को सांकेतिक शब्दों में बदलते हैं।

 float2 radialPosition = float2(atan2(position.x, position.y), length(position));

फिर हम कोने को दोहराते हैं। चूंकि प्रत्येक टुकड़े के कोण की तुलना में पुनरावृत्ति की संख्या को स्थानांतरित करना बहुत आसान है, हम पहले प्रत्येक टुकड़े के आकार की गणना करते हैं। पूरा सर्कल 2 * pi है, इसलिए सही भाग पाने के लिए, हम 2 * pi को सेल आकार से विभाजित करते हैं।

 const float PI = 3.14159; float cellSize = PI * 2 / cells;

इस जानकारी के साथ, हम रेड सेल की स्थिति के x घटक को हर सेलसाइज़ इकाइयों में दोहरा सकते हैं। हम शेष के साथ विभाजन द्वारा पुनरावृत्ति करते हैं, इसलिए, पहले की तरह, हमें नकारात्मक संख्याओं के साथ समस्याएं मिलती हैं, जिन्हें शेष के साथ विभाजन के दो कार्यों की मदद से समाप्त किया जा सकता है।

 radialPosition.x = fmod(fmod(radialPosition.x, cellSize) + cellSize, cellSize);

फिर आपको नई स्थिति को सामान्य xy निर्देशांक पर वापस ले जाने की आवश्यकता है। यहाँ हम रेडियल स्थिति के x घटक के साथ sincos फ़ंक्शन का उपयोग करते हैं, कोण को x को स्थिति के समन्वय और y को समन्वय करने के लिए साइन लिखते हैं। इस कदम से हमें एक सामान्य स्थिति प्राप्त होती है। केंद्र से सही दिशा प्राप्त करने के लिए, आपको इसे रेडियल स्थिति के घटक y द्वारा गुणा करने की आवश्यकता है, जिसका अर्थ लंबाई है।

 //in 2D_SDF.cginc void radial_cells(inout float2 position, float cells){ const float PI = 3.14159; float cellSize = PI * 2 / cells; float2 radialPosition = float2(atan2(position.x, position.y), length(position)); radialPosition.x = fmod(fmod(radialPosition.x, cellSize) + cellSize, cellSize); sincos(radialPosition.x, position.x, position.y); position = position * radialPosition.y; }

 //in shader function float2 period = 6; radial_cells(position, period, false);

फिर हम सेल इंडेक्स और मिररिंग भी जोड़ सकते हैं, जैसा कि हमने नियमित कोशिकाओं के साथ किया था।

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

 //in 2D_SDF.cginc float cellIndex = fmod(floor(radialPosition.x / cellSize) + cells, cells); //at the end of the function: return cellIndex;

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

मिररिंग रेडियल समन्वय के लूप होने के बाद होनी चाहिए, लेकिन इससे पहले कि यह वापस अपनी सामान्य स्थिति में परिवर्तित हो जाए। हम यह पता लगाएंगे कि क्या हमें शेष के साथ सेल इंडेक्स को 2 से विभाजित करके वर्तमान सेल को फ्लिप करना होगा। आमतौर पर यह हमें शून्य और लोगों को देना चाहिए, लेकिन मेरे मामले में कई जुड़वां दिखाई देते हैं, जो अजीब है, और फिर भी हम इसे संभाल सकते हैं। Deuces को खत्म करने के लिए, हम बस फ्लिप वेरिएबल से 1 घटाते हैं, और फिर निरपेक्ष मान लेते हैं। इस प्रकार, शून्य और ड्यूज एक हो जाते हैं, और इकाइयां शून्य हो जाती हैं, जैसा कि हमें जरूरत है, केवल रिवर्स ऑर्डर में।

चूंकि शून्य और गलत क्रम में हैं, इसलिए हम उल्टे संस्करण से उल्टा संस्करण तक, और पहले की तरह उल्टा नहीं करते हैं। समन्वय को पलटने के लिए, हम केवल सेल आकार से स्थिति को घटाते हैं।

 //in 2D_SDF.cginc float radial_cells(inout float2 position, float cells, bool mirrorEverySecondCell = false){ const float PI = 3.14159; float cellSize = PI * 2 / cells; float2 radialPosition = float2(atan2(position.x, position.y), length(position)); float cellIndex = fmod(floor(radialPosition.x / cellSize) + cells, cells); radialPosition.x = fmod(fmod(radialPosition.x, cellSize) + cellSize, cellSize); if(mirrorEverySecondCell){ float flip = fmod(cellIndex, 2); flip = abs(flip-1); radialPosition.x = lerp(cellSize - radialPosition.x, radialPosition.x, flip); } sincos(radialPosition.x, position.x, position.y); position = position * radialPosition.y; return cellIndex; }

 //in shader function float2 period = 6; radial_cells(position, period, true);

स्‍पेसिंग स्‍पेस

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

सबसे पहले, हम x और y घटकों को फ़्लिप करके स्थिति में परिवर्तन की भयावहता की गणना करते हैं, और फिर उन्हें वॉबल आवृत्ति द्वारा गुणा करते हैं। फिर हम साइन को इस मूल्य से लेते हैं और इसे उस वॉबल की मात्रा से गुणा करते हैं जिसे हम जोड़ना चाहते हैं। उसके बाद, हम बस इस डगमगाने कारक को स्थिति में जोड़ते हैं और फिर से स्थिति पर परिणाम लागू करते हैं।

 //in 2D_SDF.cginc void wobble(inout float2 position, float2 frequency, float2 amount){ float2 wobble = sin(position.yx * frequency) * amount; position = position + wobble; }

 //in shader function wobble(position, 5, .05);

हम इस लहराते को भी बदल सकते हैं, इसकी स्थिति को बदल सकते हैं, ऑफसेट स्थिति पर लहराते हुए और वापस अंतरिक्ष में लौट सकते हैं। ताकि फ़्लोटिंग पॉइंट संख्या बहुत बड़ी न हो जाए, मैं बचे हुए pi * 2 के साथ विभाजन करता हूं वोबबल फ़्रीक्वेंसी के साथ, यह वॉयबल के साथ सहसंबंधित होता है (साइनसॉइड हर pi * 2 यूनिट को दोहराता है), इसलिए हम जंप और बहुत बड़े ऑफ़सेट करते हैं।

 //in shader function const float PI = 3.14159; float frequency = 5; float offset = _Time.y; offset = fmod(offset, PI * 2 / frequency); position = translate(position, offset); wobble(position, 5, .05); position = translate(position, -offset);

स्रोत कोड

2 डी एसडीएफ लाइब्रेरी

https://github.com/ronja-tutorials/ShaderTutorials/blob/master/Assets/036_SDF_space_manipulation/2D_SDF.cginc

 #ifndef SDF_2D #define SDF_2D //transforms float2 rotate(float2 samplePosition, float rotation){ const float PI = 3.14159; float angle = rotation * PI * 2 * -1; float sine, cosine; sincos(angle, sine, cosine); return float2(cosine * samplePosition.x + sine * samplePosition.y, cosine * samplePosition.y - sine * samplePosition.x); } float2 translate(float2 samplePosition, float2 offset){ //move samplepoint in the opposite direction that we want to move shapes in return samplePosition - offset; } float2 scale(float2 samplePosition, float scale){ return samplePosition / scale; } //combinations ///basic float merge(float shape1, float shape2){ return min(shape1, shape2); } float intersect(float shape1, float shape2){ return max(shape1, shape2); } float subtract(float base, float subtraction){ return intersect(base, -subtraction); } float interpolate(float shape1, float shape2, float amount){ return lerp(shape1, shape2, amount); } /// round float round_merge(float shape1, float shape2, float radius){ float2 intersectionSpace = float2(shape1 - radius, shape2 - radius); intersectionSpace = min(intersectionSpace, 0); float insideDistance = -length(intersectionSpace); float simpleUnion = merge(shape1, shape2); float outsideDistance = max(simpleUnion, radius); return insideDistance + outsideDistance; } float round_intersect(float shape1, float shape2, float radius){ float2 intersectionSpace = float2(shape1 + radius, shape2 + radius); intersectionSpace = max(intersectionSpace, 0); float outsideDistance = length(intersectionSpace); float simpleIntersection = intersect(shape1, shape2); float insideDistance = min(simpleIntersection, -radius); return outsideDistance + insideDistance; } float round_subtract(float base, float subtraction, float radius){ return round_intersect(base, -subtraction, radius); } ///champfer float champfer_merge(float shape1, float shape2, float champferSize){ const float SQRT_05 = 0.70710678118; float simpleMerge = merge(shape1, shape2); float champfer = (shape1 + shape2) * SQRT_05; champfer = champfer - champferSize; return merge(simpleMerge, champfer); } float champfer_intersect(float shape1, float shape2, float champferSize){ const float SQRT_05 = 0.70710678118; float simpleIntersect = intersect(shape1, shape2); float champfer = (shape1 + shape2) * SQRT_05; champfer = champfer + champferSize; return intersect(simpleIntersect, champfer); } float champfer_subtract(float base, float subtraction, float champferSize){ return champfer_intersect(base, -subtraction, champferSize); } /// round border intersection float round_border(float shape1, float shape2, float radius){ float2 position = float2(shape1, shape2); float distanceFromBorderIntersection = length(position); return distanceFromBorderIntersection - radius; } float groove_border(float base, float groove, float width, float depth){ float circleBorder = abs(groove) - width; float grooveShape = subtract(circleBorder, base + depth); return subtract(base, grooveShape); } // space repetition void mirror(inout float2 position){ position.x = abs(position.x); } float2 cells(inout float2 position, float2 period){ //find cell index float2 cellIndex = position / period; cellIndex = floor(cellIndex); //negative positions lead to negative modulo position = fmod(position, period); //negative positions now have correct cell coordinates, positive input positions too high position += period; //second mod doesn't change values between 0 and period, but brings down values that are above period. position = fmod(position, period); return cellIndex; } float radial_cells(inout float2 position, float cells, bool mirrorEverySecondCell = false){ const float PI = 3.14159; float cellSize = PI * 2 / cells; float2 radialPosition = float2(atan2(position.x, position.y), length(position)); float cellIndex = fmod(floor(radialPosition.x / cellSize) + cells, cells); radialPosition.x = fmod(fmod(radialPosition.x, cellSize) + cellSize, cellSize); if(mirrorEverySecondCell){ float flip = fmod(cellIndex, 2); flip = abs(flip-1); radialPosition.x = lerp(cellSize - radialPosition.x, radialPosition.x, flip); } sincos(radialPosition.x, position.x, position.y); position = position * radialPosition.y; return cellIndex; } void wobble(inout float2 position, float2 frequency, float2 amount){ float2 wobble = sin(position.yx * frequency) * amount; position = position + wobble; } //shapes float circle(float2 samplePosition, float radius){ //get distance from center and grow it according to radius return length(samplePosition) - radius; } float rectangle(float2 samplePosition, float2 halfSize){ float2 componentWiseEdgeDistance = abs(samplePosition) - halfSize; float outsideDistance = length(max(componentWiseEdgeDistance, 0)); float insideDistance = min(max(componentWiseEdgeDistance.x, componentWiseEdgeDistance.y), 0); return outsideDistance + insideDistance; } #endif

बुनियादी डेमो shader

 Shader "Tutorial/036_SDF_Space_Manpulation/Mirror"{ Properties{ _InsideColor("Inside Color", Color) = (.5, 0, 0, 1) _OutsideColor("Outside Color", Color) = (0, .5, 0, 1) _LineDistance("Mayor Line Distance", Range(0, 2)) = 1 _LineThickness("Mayor Line Thickness", Range(0, 0.1)) = 0.05 [IntRange]_SubLines("Lines between major lines", Range(1, 10)) = 4 _SubLineThickness("Thickness of inbetween lines", Range(0, 0.05)) = 0.01 } SubShader{ //the material is completely non-transparent and is rendered at the same time as the other opaque geometry Tags{ "RenderType"="Opaque" "Queue"="Geometry"} Pass{ CGPROGRAM #include "UnityCG.cginc" #include "2D_SDF.cginc" #pragma vertex vert #pragma fragment frag struct appdata{ float4 vertex : POSITION; }; struct v2f{ float4 position : SV_POSITION; float4 worldPos : TEXCOORD0; }; v2f vert(appdata v){ v2f o; //calculate the position in clip space to render the object o.position = UnityObjectToClipPos(v.vertex); //calculate world position of vertex o.worldPos = mul(unity_ObjectToWorld, v.vertex); return o; } float scene(float2 position) { // modify position here! float2 squarePosition = position; squarePosition = translate(squarePosition, float2(2, 2)); squarePosition = rotate(squarePosition, .125); float squareShape = rectangle(squarePosition, float2(1, 1)); float2 circlePosition = position; circlePosition = translate(circlePosition, float2(1, 1.5)); float circleShape = circle(circlePosition, 1); float combination = merge(circleShape, squareShape); return combination; } float4 _InsideColor; float4 _OutsideColor; float _LineDistance; float _LineThickness; float _SubLines; float _SubLineThickness; fixed4 frag(v2f i) : SV_TARGET{ float dist = scene(i.worldPos.xz); fixed4 col = lerp(_InsideColor, _OutsideColor, step(0, dist)); float distanceChange = fwidth(dist) * 0.5; float majorLineDistance = abs(frac(dist / _LineDistance + 0.5) - 0.5) * _LineDistance; float majorLines = smoothstep(_LineThickness - distanceChange, _LineThickness + distanceChange, majorLineDistance); float distanceBetweenSubLines = _LineDistance / _SubLines; float subLineDistance = abs(frac(dist / distanceBetweenSubLines + 0.5) - 0.5) * distanceBetweenSubLines; float subLines = smoothstep(_SubLineThickness - distanceChange, _SubLineThickness + distanceChange, subLineDistance); return col * majorLines * subLines; } ENDCG } } FallBack "Standard" //fallback adds a shadow pass so we get shadows on other objects }

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

2 डी स्थानिक दूरी पर हस्ताक्षर किए गए फ़ील्ड के साथ हेरफेर