मैं 3D मॉडल के आसपास रूपरेखा कैसे बना सकता हूं?

Question

मैं 3D मॉडल के आसपास रूपरेखा कैसे बना सकता हूं? मैं हाल के पोकेमॉन गेम में प्रभावों की तरह कुछ का उल्लेख कर रहा हूं, जो कि उनके चारों ओर एक एकल-पिक्सेल रूपरेखा दिखाई देते हैं:

Comments

क्या आप OpenGL का उपयोग कर रहे हैं? यदि हां, तो आपको Google पर खोजना चाहिए कि ओपनगेल के साथ मॉडल के लिए रूपरेखा कैसे तैयार की जाए।

— १

यदि आप उन विशेष छवियों का जिक्र कर रहे हैं जो आप वहां डालते हैं, तो मैं 95% निश्चितता के साथ कह सकता हूं कि जो हाथ से बने 2 डी स्प्राइट हैं, न कि 3 डी मॉडल

— पांडा पजामा

@PandaPajama: नहीं, वे लगभग निश्चित रूप से 3 डी मॉडल हैं। वहाँ कुछ तख्ते में कुछ ढलान होना चाहिए कि मैं हाथ से तैयार स्प्राइट से उम्मीद नहीं करूंगा, और वैसे भी मूल रूप से इन-गेम 3 डी मॉडल कैसे दिखते हैं। मुझे लगता है कि मैं उन विशिष्ट छवियों के लिए 100% गारंटी नहीं दे सकता, लेकिन मैं सोच भी नहीं सकता कि कोई भी उन्हें फेकने के प्रयास में क्यों जाएगा।

— सीए मैककैन

कौन सा खेल है, विशेष रूप से? यह बहुत खूबसूरत लग रहा है।

— वेजर्ड

@Vegard अपनी पीठ पर एक शलजम के साथ प्राणी खेल पोकीमॉन से एक बुलबसौर है।

— दामियन येरिक

Answer 1

मुझे नहीं लगता कि यहां कोई अन्य उत्तर पोकेमोन एक्स / वाई में प्रभाव प्राप्त करेगा। मुझे ठीक से पता नहीं है कि यह कैसे किया जाता है, लेकिन मुझे एक तरीका सूझा, जो ऐसा लगता है जैसे वे खेल में बहुत कुछ करते हैं।

पोकेमॉन एक्स / वाई में, सिल्हूट किनारों के आसपास और अन्य गैर-सिल्हूट किनारों (जैसे कि रायचू के कान निम्नलिखित स्क्रीनशॉट में उनके सिर से मिलते हैं) के दोनों ओर रूपरेखा तैयार की जाती है।

ब्लेंडर में रायचू की जाली को देखते हुए, आप कान को देख सकते हैं (ऊपर नारंगी में हाइलाइट किया गया है) बस एक अलग, डिस्कनेक्ट की गई वस्तु है जो सिर को काटती है, सतह के मानदंडों में अचानक परिवर्तन पैदा करती है।

उसके आधार पर, मैंने मानदंडों के आधार पर रूपरेखा तैयार करने की कोशिश की, जिसमें दो पासों में प्रतिपादन की आवश्यकता होती है:

पहला पास : रूपरेखा के बिना मॉडल (बनावट और सील-शेडेड) को रेंडर करें, और एक दूसरे रेंडर लक्ष्य के लिए कैमरा-स्पेस मानदंडों को प्रस्तुत करें।

दूसरा पास : पहले पास से नॉर्म्स पर एक फुल-स्क्रीन एज डिटेक्शन फ़िल्टर करें।

नीचे दिए गए पहले दो चित्र पहले पास के आउटपुट दिखाते हैं। तीसरा अपने आप में रूपरेखा है, और अंतिम अंतिम संयुक्त परिणाम है।

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

// first render target from the first pass
uniform sampler2D uTexColor;
// second render target from the first pass
uniform sampler2D uTexNormals;

uniform vec2 uResolution;

in vec2 fsInUV;

out vec4 fsOut0;

void main(void)
{
  float dx = 1.0 / uResolution.x;
  float dy = 1.0 / uResolution.y;

  vec3 center = sampleNrm( uTexNormals, vec2(0.0, 0.0) );

  // sampling just these 3 neighboring fragments keeps the outline thin.
  vec3 top = sampleNrm( uTexNormals, vec2(0.0, dy) );
  vec3 topRight = sampleNrm( uTexNormals, vec2(dx, dy) );
  vec3 right = sampleNrm( uTexNormals, vec2(dx, 0.0) );

  // the rest is pretty arbitrary, but seemed to give me the
  // best-looking results for whatever reason.

  vec3 t = center - top;
  vec3 r = center - right;
  vec3 tr = center - topRight;

  t = abs( t );
  r = abs( r );
  tr = abs( tr );

  float n;
  n = max( n, t.x );
  n = max( n, t.y );
  n = max( n, t.z );
  n = max( n, r.x );
  n = max( n, r.y );
  n = max( n, r.z );
  n = max( n, tr.x );
  n = max( n, tr.y );
  n = max( n, tr.z );

  // threshold and scale.
  n = 1.0 - clamp( clamp((n * 2.0) - 0.8, 0.0, 1.0) * 1.5, 0.0, 1.0 );

  fsOut0.rgb = texture(uTexColor, fsInUV).rgb * (0.1 + 0.9*n);
}

और पहले पास को प्रस्तुत करने से पहले मैं मानदंडों को स्पष्ट करता हूं जो कैमरे से दूर होने वाले वेक्टर का लक्ष्य प्रस्तुत करते हैं:

glDrawBuffer( GL_COLOR_ATTACHMENT1 );
Vec3f clearVec( 0.0, 0.0, -1.0f );
// from normalized vector to rgb color; from [-1,1] to [0,1]
clearVec = (clearVec + Vec3f(1.0f, 1.0f, 1.0f)) * 0.5f;
glClearColor( clearVec.x, clearVec.y, clearVec.z, 0.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

मैं कहीं पढ़ता हूं (मैं टिप्पणियों में एक लिंक डालूंगा) कि निनटेंडो 3 डीएस शेड्स के बजाय एक निश्चित-फ़ंक्शन पाइपलाइन का उपयोग करता है, इसलिए मुझे लगता है कि यह खेल में बिल्कुल ऐसा नहीं हो सकता है, लेकिन अभी के लिए मैं ' मुझे यकीन है कि मेरा तरीका काफी करीब है।

Comments

निंटेंडो 3 डीएस हार्डवेयर के बारे में जानकारी: लिंक

— केटीसी

बहुत अच्छा समाधान! आप अपनी छाया में गहराई को कैसे ध्यान में रखेंगे? (उदाहरण के लिए एक और के सामने एक विमान के मामले में, दोनों एक ही सामान्य ताकि कोई रूपरेखा तैयार किया जाएगा है)

— Ingham

@ingham यह मामला एक जैविक चरित्र पर पर्याप्त रूप से सामने आता है जिसे मुझे इसे संभालने की आवश्यकता नहीं थी, और ऐसा लगता है कि असली गेम इसे संभालता नहीं है। असली खेल में आप कभी-कभी आउटलाइन को गायब होते देख सकते हैं जब मानदंड समान होते हैं, लेकिन मुझे नहीं लगता कि लोग आमतौर पर इसे नोटिस करेंगे।

— केटीसी

मैं एक 3DS के बारे में थोड़ा संदेह कर रहा हूं कि वह जैसे shader- आधारित फुल-स्क्रीन प्रभाव को चलाने में सक्षम हो। इसका shader समर्थन अल्पविकसित है (यदि इसके पास कोई है)।

— तारा

Answer 2

यह प्रभाव विशेष रूप से उन खेलों में आम है जो सीएल छायांकन प्रभाव का उपयोग करते हैं, लेकिन वास्तव में कुछ ऐसा है जो सीएल छायांकन शैली के स्वतंत्र रूप से लागू किया जा सकता है।

आप जो वर्णन कर रहे हैं, उसे "फीचर एज रेंडरिंग" कहा जाता है, और यह एक मॉडल के विभिन्न आकृति और रूपरेखाओं को उजागर करने की सामान्य प्रक्रिया में है। विषय पर कई तकनीकें उपलब्ध हैं और कई कागजात हैं।

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

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

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

आप इंटरनेट पर विभिन्न उदाहरणों के साथ आगे की चर्चा, विवरण और कागजात पा सकते हैं। उदाहरण के लिए:

• http://www.marctenbosch.com/npr_edges/
• http://www.j3l7h.de/publications/halo_web.pdf
• http://graphics.cs.williams.edu/papers/EdgesNPAR04/index.html

Comments

मैं पुष्टि कर सकता हूं कि स्टैंसिल विधि (flipcode.com से) काम करती है और वास्तव में अच्छी लगती है। आप स्क्रीन निर्देशांक में मोटाई दे सकते हैं, इसलिए रूपरेखा की मोटाई मॉडल के आकार पर निर्भर नहीं करती है (न ही मॉडल के आकार पर)।

— वेजर्ड

एक तकनीक जिसका आपने उल्लेख नहीं किया, वह है पोस्ट-प्रोसेसिंग बॉर्डर-शेडिंग प्रभाव जिसका उपयोग अक्सर सीएल-शेडिंग के साथ किया जाता है जो उच्च dz/dxऔर / याdz/dy

— bcrist

Answer 3

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

स्क्रीन अंतरिक्ष / पिक्सेल शेडर दृष्टिकोण को लागू करने में धीमी और कठिन हो जाते हैं अच्छी तरह से है, लेकिन OTOH अपनी दुनिया में कोने की संख्या दोगुनी हो नहीं है। इसलिए यदि आप उच्च पाली कार्य कर रहे हैं, तो उस दृष्टिकोण के लिए सबसे अच्छा विकल्प चुनें। ज्यामिति के प्रसंस्करण के लिए आधुनिक सांत्वना और डेस्कटॉप क्षमता को देखते हुए, मैं 2 का एक पहलू के बारे में चिंता नहीं चाहते हैं सब पर । कार्टून-शैली = सुनिश्चित रूप से कम पाली, इस प्रकार ज्यामिति की नकल करना सबसे आसान है।

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

।

Comments

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

— क्रॉम्स्टर का कहना है कि मोनिका

@KromStern कुछ उदाहरणों में , कोने के सबसेट को समायोजित करने के लिए हाथ से स्केल करने की आवश्यकता होती है। संशोधित उत्तर।

— इंजीनियर

यह अपने स्थानीय सतह के साथ बाहर सामान्य कोने खिसकाने के लिए आम है, लेकिन इस विस्तार रूपरेखा कठिन किनारों के साथ विभाजित करने के लिए जाल पैदा कर सकता है

— DMGregory

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

— जेट ब्लू

Answer 4

के लिए चिकनी मॉडल (बहुत महत्वपूर्ण), इस प्रभाव काफी सरल है। आपके टुकड़े / पिक्सेल शेडर में आपको टुकड़े टुकड़े होने के सामान्य की आवश्यकता होगी। यदि यह लंबवत के बहुत करीब है ( dot(surface_normal,view_vector) <= .01- आपको उस सीमा के साथ खेलने की आवश्यकता हो सकती है) तो उसके सामान्य रंग के बजाय टुकड़े के रंग को रंग दें।

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

हाइलाइट सतह के किसी भी हिस्से पर होगा जहां यह सामने की ओर से पीछे की ओर स्थित है, जिसमें "इनर किनारों" (जैसे कि ग्रीन पोकेमॉन पर पैर, या इसके सिर - कुछ अन्य तकनीकें शामिल हैं, उन पर कोई रूपरेखा नहीं जोड़ेंगे) )।

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

Answer 5

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

आंतरिक पंक्तियों को करने का दूसरा तरीका मैंने उसी खेल से सीखा। अपने यूवी मानचित्र में, अपनी बनावट को यू या वी अक्ष के साथ संरेखित करें, विशेष रूप से उन क्षेत्रों में जहां आप एक आंतरिक रेखा चाहते हैं। या तो अक्ष के साथ एक काली रेखा खींचना, और आंतरिक रेखा बनाने के लिए अपने यूवी निर्देशांक को उस रेखा से अंदर या बाहर ले जाना।

बेहतर स्पष्टीकरण के लिए जीडीसी से वीडियो देखें: https://www.youtube.com/watch?v=yhGjCzxJV3E

Answer 6

एक रूपरेखा बनाने के तरीकों में से एक हमारे मॉडल सामान्य वैक्टर का उपयोग करना है। सामान्य वैक्टर वे वैक्टर होते हैं जो उनकी सतह के लंबवत होते हैं (सतह से दूर की ओर इशारा करते हुए)। यहां ट्रिक आपके चरित्र मॉडल को दो भागों में विभाजित करने के लिए है। कैमरे के सामने आने वाले कोने और वे कोने जो कैमरे से दूर हो रहे हैं। हम उन्हें क्रमशः FRONT और BACK कहेंगे।

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

Shader "Custom/OutlineShader" {
    Properties {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _Outline("Outline Thickness", Range(0.0, 0.3)) = 0.002
        _OutlineColor("Outline Color", Color) = (0,0,0,1)
    }

    CGINCLUDE
    #include "UnityCG.cginc"

    sampler2D _MainTex;
    half4 _MainTex_ST;

    half _Outline;
    half4 _OutlineColor;

    struct appdata {
        half4 vertex : POSITION;
        half4 uv : TEXCOORD0;
        half3 normal : NORMAL;
        fixed4 color : COLOR;
    };

    struct v2f {
        half4 pos : POSITION;
        half2 uv : TEXCOORD0;
        fixed4 color : COLOR;
    };
    ENDCG

    SubShader 
    {
        Tags {
            "RenderType"="Opaque"
            "Queue" = "Transparent"
        }

        Pass{
            Name "OUTLINE"

            Cull Front

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            v2f vert(appdata v)
            {
                v2f o;
                o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
                half3 norm = mul((half3x3)UNITY_MATRIX_IT_MV, v.normal);
                half2 offset = TransformViewToProjection(norm.xy);
                o.pos.xy += offset * o.pos.z * _Outline;
                o.color = _OutlineColor;
                return o;
            }

            fixed4 frag(v2f i) : COLOR
            {
                fixed4 o;
                o = i.color;
                return o;
            }
            ENDCG
        }

        Pass 
        {
            Name "TEXTURE"

            Cull Back
            ZWrite On
            ZTest LEqual

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            v2f vert(appdata v)
            {
                v2f o;
                o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                o.color = v.color;
                return o;
            }

            fixed4 frag(v2f i) : COLOR 
            {
                fixed4 o;
                o = tex2D(_MainTex, i.uv.xy);
                return o;
            }
            ENDCG
        }
    } 
}

लाइन 41: "कल्ट फ्रंट" सेटिंग, शेडर को सामने वाले कोने पर एक पुलिंग प्रदर्शन करने के लिए कहती है। इसका मतलब है कि हम इस पास में सामने वाले सभी सामने वाले को अनदेखा कर देंगे। हम BACK के पक्ष में रह गए हैं जिसे हम थोड़ा हेरफेर करना चाहते हैं।

लाइन्स 51-53: उनके सामान्य वैक्टर के साथ आगे बढ़ने का गणित।

लाइन 54: शेड गुण में परिभाषित हमारी पसंद के रंग के लिए शीर्ष रंग निर्धारित करना।

उपयोगी लिंक: http://wiki.unity3d.com/index.php/Silhouette-Outilt_Diffuse

---

अपडेट करें

एक और उदाहरण

   Shader "Custom/CustomOutline" {
            Properties {
                _Color ("Color", Color) = (1,1,1,1)
                _Outline ("Outline Color", Color) = (0,0,0,1)
                _MainTex ("Albedo (RGB)", 2D) = "white" {}
                _Glossiness ("Smoothness", Range(0,1)) = 0.5
                _Size ("Outline Thickness", Float) = 1.5
            }
            SubShader {
                Tags { "RenderType"="Opaque" }
                LOD 200

                // render outline

                Pass {
                Stencil {
                    Ref 1
                    Comp NotEqual
                }

                Cull Off
                ZWrite Off

                    CGPROGRAM
                    #pragma vertex vert
                    #pragma fragment frag
                    #include "UnityCG.cginc"
                    half _Size;
                    fixed4 _Outline;
                    struct v2f {
                        float4 pos : SV_POSITION;
                    };
                    v2f vert (appdata_base v) {
                        v2f o;
                        v.vertex.xyz += v.normal * _Size;
                        o.pos = UnityObjectToClipPos (v.vertex);
                        return o;
                    }
                    half4 frag (v2f i) : SV_Target
                    {
                        return _Outline;
                    }
                    ENDCG
                }

                Tags { "RenderType"="Opaque" }
                LOD 200

                // render model

                Stencil {
                    Ref 1
                    Comp always
                    Pass replace
                }


                CGPROGRAM
                // Physically based Standard lighting model, and enable shadows on all light types
                #pragma surface surf Standard fullforwardshadows
                // Use shader model 3.0 target, to get nicer looking lighting
                #pragma target 3.0
                sampler2D _MainTex;
                struct Input {
                    float2 uv_MainTex;
                };
                half _Glossiness;
                fixed4 _Color;
                void surf (Input IN, inout SurfaceOutputStandard o) {
                    // Albedo comes from a texture tinted by color
                    fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
                    o.Albedo = c.rgb;
                    // Metallic and smoothness come from slider variables
                    o.Smoothness = _Glossiness;
                    o.Alpha = c.a;
                }
                ENDCG
            }
            FallBack "Diffuse"
        }

Comments

अपडेटेड उदाहरण में स्टैंसिल बफर का उपयोग क्यों?

— तारा

आह अब मैं समझ गया। दूसरा उदाहरण एक दृष्टिकोण का उपयोग करता है जो केवल बाहरी रूपरेखा बनाता है, पहले के विपरीत। आप अपने उत्तर में इसका उल्लेख करना चाह सकते हैं।

— तारा

Answer 7

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