दिलचस्प!

@sunag हम इस तरह से कुछ में बहुत रुचि रखते हैं। मैं आपकी कैसे मदद कर सकता हूँ? मैं कम से कम मानक के लिए समर्थन जोड़ सकता हूं।

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

एक बनावट(tex1, uv1)
बी बनावट (टेक्स 2, यूवी 2)
सी ब्लेंड (ए, बी, मोड)
डी शोर (परम 1, परम 2)
ई ब्लेंड (सी, डी, मोड)

और फिर उस अंतिम नोड ई का उपयोग सामग्री के इनपुट के रूप में करें।

तो यह बहुत ही मनमाना है, केवल बनावट तक ही सीमित नहीं है।

मेरा लक्ष्य अगले कुछ हफ्तों में इसे बनाने में मदद करना होगा, उम्मीद है कि अगले सप्ताह में आपके साथ सहयोग करना या यदि संभव हो तो। मैं इसे यहां शेडरग्राफ लाइब्रेरी के माध्यम से कर रहा था: https://github.com/mrdoob/three.js/issues/7339 लेकिन मैं इसे सीधे थ्रीजेएस के भीतर बना रहा हूं। वास्तव में कोई भी समाधान तब तक अच्छा होता है जब तक वह लचीला होता है और काम करता है।

मैं आपके कोड के माध्यम से पढ़ रहा हूं, यह काफी अच्छी तरह से डिजाइन किया गया है। मेरे पास कुछ प्रारंभिक प्रतिक्रिया है। क्या मैं आधार के रूप में आपके कोड का उपयोग करके उस पर सहयोग करना शुरू कर सकता हूं?

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

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

(3) मेरे पास यूवी है बस एक और संदर्भ है, जिसे सामग्री द्वारा हल किया जाता है। और मेरे पास NodeTexture वास्तव में एक नोड इनपुट लेना चाहिए, इस प्रकार प्रक्रियात्मक रूप से उत्पन्न UVs के लिए अनुमति देता है।

(4) मैं NodeCube, NodeTextureCube को बाकी तीन.JS के अनुरूप होने के लिए कहूंगा। और मैं इस तर्क को हटा दूंगा कि वास्तव में इससे किरण कैसे जाती है। लेकिन मुझे मानक क्यूब मैप्स का विचार पसंद है, इसलिए मैं वास्तव में नोड्स में स्पेक्युलर या डिफ्यूज़ के लिए पर्यावरण क्वेरी नहीं डालूंगा, लेकिन आधार फोंग सामग्री में है, और आप केवल क्वेरी के लिए उपयोग किए जाने वाले सामान्य को नियंत्रित कर सकते हैं, या क्यूबमैप परिणाम स्वयं (इस प्रकार इसे एक प्रक्रियात्मक रूप से निर्धारित रंग होने की अनुमति देता है।) क्या इसका कोई मतलब है? तो मेरे पास सामग्री में सामान्य प्लग करने योग्य और घन बनावट प्लग करने योग्य (एक दिशा और पूर्वाग्रह/लॉड द्वारा पूछताछ योग्य, और एक रंग देता है)। इस प्रकार एक विकिरण मानचित्र को घन बनावट प्रदान कर सकता है और दूसरा स्पेक्युलर मानचित्र को। हम सिर्फ एक नोड स्वैप के रूप में @tschw के cubeToUV2 समारोह के साथ सच sampleCube बाहर स्वैप कर सकते हैं।

(5) मैं एक NodeFunction जोड़ने की कोशिश करूँगा जो किसी को आपके NodeOp के अतिरिक्त मापदंडों के साथ मनमाने कार्यों को कॉल करने की अनुमति देता है (या शायद उन्हें किसी फैशन में विलय किया जा सकता है।)

(6) मैं सभी वर्बोज़ NodeNormal, NodeTransform, NormalMap, आदि व्यक्तिगत वर्ग से छुटकारा पाऊंगा और बस कुछ सरल कंस्ट्रक्टर हैं जो एक नाम के साथ एक NodeReference बनाते हैं जिसे सामग्री द्वारा उपयुक्त के रूप में हल किया जाता है। NodeReference वर्दी, भिन्नता और साथ ही शेडर में गणना मूल्यों को हल कर सकता है।

(7) मुझे NodeEnvironment और NodeCube के बीच का अंतर समझ में नहीं आ रहा है। मुझे लगता है कि NodeEnvironment अधूरा हो सकता है?

(8) यह भ्रमित करने वाला है कि NodePhong को NodeMaterial से नहीं लिया गया है। हालाँकि मैं देख रहा हूँ कि NodeMaterial ShaderMaterial से लिया गया है। मुझे आश्चर्य है कि क्या आपने ShaderMaterial, GraphMaterial (या NodeGraphMaterial) से प्रत्यक्ष व्युत्पन्न कहा है जो अधिक समझ में आता है - क्योंकि सभी एक साथ नोड्स एक ग्राफ बनाते हैं, और यह वह ग्राफ है जो सामग्री बन जाता है, न कि एक व्यक्तिगत नोड।

(9) मैं शायद कुछ और विविध शब्दावली का सुझाव दूंगा। मैं रूट नोड, मटेरियल नोड को कॉल करूंगा, और कोई इससे PhongMaterialNode प्राप्त कर सकता है। मेरे पास वेक्टर 3 नोड, फ्लोटनोड, आदि है जो ValueNode से प्राप्त हुआ है - जरूरी नहीं कि स्थिर हो, लेकिन केवल एक मान हो। इस प्रकार कोई तीन फ्लोटनोड्स में एक वेक्टर 3 नोड में पाइप कर सकता है। मुझे लगता है कि आपके पास एक सहायक हो सकता है जो वर्तमान में 10 या उससे अधिक की बजाय इनमें से प्रत्येक एक पंक्ति या तो घोषित करेगा।

(10) मैं "नोड" नाम को कक्षा के नामों की शुरुआत से पीछे की ओर ले जाऊँगा क्योंकि यह थ्रीजेएस परियोजना के बाकी हिस्सों में भी ऐसा ही है।

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

(12) मैं NodePhong और NodePhongMaterial के बीच के अंतर के बीच भ्रमित हूं। मुझे नहीं पता था कि अब तक दोनों थे।

(13) इस तरह का कोड है:

THREE.NodeGLPosition.prototype = Object.create( THREE.Node.prototype );
THREE.NodeGLPosition.prototype.constructor = THREE.NodeGLPosition;

THREE.NodeGL.prototype.generate = function( material, shader ) {

लेकिन इस स्निपेट के ऊपर आपने पहले ही generate को NodeGL लिए परिभाषित किया है और आपने NodeGLPosition लिए एक को परिभाषित नहीं किया है - इस प्रकार मुझे लगता है कि यह एक कॉपी-पेस्ट-एडिट त्रुटि है।

(14) मैं NodeReflectUVW और NodeRefractVector से छुटकारा पाऊंगा और इसके बजाय बस इसे कुछ ऐसा बनाऊंगा जिसे कोई संदर्भ समाधान के माध्यम से सामग्री से अनुरोध कर सकता है। प्रतिबिंब वेक्टर की गणना सीधे आगे है। मैंने इसे अपनी अनमर्ज प्रायोगिक थ्रीजेएस शाखाओं में GeometryContext में जोड़ दिया है।

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

(16) मैं प्रकाश इनपुट के बारे में उलझन में हूँ - आमतौर पर किसी में रोशनी प्लग करने योग्य नहीं होती है, बल्कि प्रकाश मापदंडों को पूरी तरह से प्रकाश वर्ग में परिभाषित किया जाता है। मुझे लगता है कि आपको इस अतिरिक्त लचीलेपन की आवश्यकता है? आप इसकी कल्पना कैसे करते हैं।

@bhouston वाह, बहुत बहुत धन्यवाद।
मुझे उत्तर देने के लिए कई पदों की आवश्यकता होगी :)

मुझे काफी मनमाना ग्राफ बनाने में दिलचस्पी है, ताकि मध्यवर्ती नोड्स भी इनपुट ले सकें। तो आपके पास ऐसा ग्राफ हो सकता है जो इस तरह दिखता है:
एक बनावट(tex1, uv1)
बी बनावट (टेक्स 2, यूवी 2)
सी ब्लेंड (ए, बी, मोड)
डी शोर (परम 1, परम 2)
ई ब्लेंड (सी, डी, मोड)

वर्तमान में इस तरह वाक्यविन्यास। Uv1 ऑफ़सेट चेतन उदाहरण:
मुझे लगता है कि NodeMaterial to MaterialNode और THREE.PhongMaterialNode यह भी बेहतर होगा।

var uv2 = false;
var uv_offset = new THREE.NodeFloat(0);     
var uv = new THREE.NodeOperator( '+', new THREE.NodeUV( uv2 ), uv_offset);
var texture = new THREE.NodeTexture( imgTexture, uv );

nodematerial.color = t;

// onUpdate
uv_offset.number += .01;

मुझे लगता है कि आपके सुझाव के साथ क्रम को उलट दें (मोड, ए, बी) से (ए, बी, मोड) बेहतर हो जाएं। मैं रिफ्लेक्स मैप्स, क्यूबमैप और अन्य बनाने की प्रक्रिया में हूं ...

पर्यावरण और क्यूबमैप अधूरे हैं।

वर्तमान में यह बग अधिक हो सकता है क्योंकि प्रारूप कनवर्टर अभी भी अधूरा है। यह वेक्टर रूपांतरण द्वारा जिम्मेदार है। उदाहरण के लिए vec3 से vec4 या vec4।

https://github.com/sunag/sea3d/blob/gh-pages/Labs/Three.JS-NodeMaterial/index.html#L365

उदाहरण के लिए एक मिश्रण "बनावट": (मैंने इस कोड का परीक्षण नहीं किया है)
इसे तीन.नोडऑपरेटर के समान कार्यान्वित किया जा सकता है

https://github.com/sunag/sea3d/blob/gh-pages/Labs/Three.JS-NodeMaterial/index.html#L1105

THREE.NodeBlend = function( a, b, mode ) {

    THREE.NodeInput.call( this, 'blend' );

    this.mode = mode;
    this.a = a;
    this.b = b;

};

THREE.NodeBlend.prototype = Object.create( THREE.NodeInput.prototype );
THREE.NodeBlend.prototype.constructor = THREE.NodeBlend;

THREE.NodeBlend.prototype.generate = function( material, shader, output ) {

    var a = this.a.build( material, shader, output );
    var b = this.b.build( material, shader, output );

    switch(this.mode)
    {
        case 'multiply':

            return this.format( '(' + a + '*' + b + ')', this.a.type, output);

            break;
    }

    return a;

};

.generate() कोड जनरेटर के लिए जिम्मेदार है। यदि आप प्रदर्शन को खोए बिना एक से अधिक इनपुट में उपयोग करना चाहते हैं तो कैल्क्स कोड कैश में संग्रहीत होते हैं।

फिर भी मैं ऑप्टिमाइज़ेशन के लिए पॉइंटर्स या स्थिरांक सेट नहीं करता ...

संकलन शीर्ष और खंड कोड के लिए बिल्ड () में प्रचार द्वारा किया जाता है।

मैं आपको एक सहयोगी के रूप में रख सकता हूँ? यदि आप किसी भी तरह से कोड को संपादित करना चाहते हैं, तो मैं इस पर भी काम करूंगा।

मैं आपको एक सहयोगी के रूप में रख सकता हूँ? यदि आप किसी भी तरह से कोड को संपादित करना चाहते हैं, तो मैं इस पर भी काम करूंगा।

धन्यवाद! मैं आपके लिए पीआर बनाऊंगा ताकि आप परिवर्तनों को स्वीकृति दे सकें।

मैंने आपको (साथ ही @mrdoob , @WestLangley और @tschw) को मेरे एक साइड प्रोजेक्ट में जोड़ा है जो पुन: प्रयोज्य नोड्स और सामग्री परिभाषाओं के एक सेट को परिभाषित करने का प्रयास कर रहा है जो विभिन्न रेंडरर्स के बीच हस्तांतरणीय हो सकता है। यह आपके द्वारा बनाए गए इस शेडर ग्राफ़ सिस्टम पर मैप करने योग्य है।

मुझे नहीं लगता कि आपको रेपो पर ध्यान देना होगा यदि आप नहीं चाहते हैं तो मैंने आपको अभी तक पहुंच प्रदान की है। यही वह है जिसे मैं इसके शीर्ष पर लागू करने में रूचि रखता हूं।

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

मेरी इच्छा है कि रोशनी एक लाइटनोड हो। मेरी चिंता थ्री.जेएस के लिए पहले से विकसित कोड का उपयोग करना है।

(3) मेरे पास यूवी है बस एक और संदर्भ है, जिसे सामग्री द्वारा हल किया जाता है। और मेरे पास NodeTexture वास्तव में एक नोड इनपुट लेना चाहिए, इस प्रकार प्रक्रियात्मक रूप से उत्पन्न UVs के लिए अनुमति देता है।

आप यूवी को एक vec2 में बदल सकते हैं क्या यह होगा?

(5) मैं एक NodeFunction जोड़ने की कोशिश करूँगा जो किसी को आपके NodeOp के अतिरिक्त मापदंडों के साथ मनमाने कार्यों को कॉल करने की अनुमति देता है (या शायद उन्हें किसी फैशन में विलय किया जा सकता है।)

यह बहुत अच्छा होगा। मुख्य रूप से BlendNode के लिए।

(6) मैं सभी वर्बोज़ NodeNormal, NodeTransform, NormalMap, आदि व्यक्तिगत वर्ग से छुटकारा पाऊंगा और बस कुछ सरल कंस्ट्रक्टर हैं जो एक नाम के साथ एक NodeReference बनाते हैं जिसे सामग्री द्वारा उपयुक्त के रूप में हल किया जाता है। NodeReference वर्दी, भिन्नता और साथ ही शेडर में गणना मूल्यों को हल कर सकता है।

विचार की इस पंक्ति में मुझे लगता है कि MaterialNode भौतिक फोंग और भौतिक सामग्री का आधार हो सकता है।

(7) मुझे NodeEnvironment और NodeCube के बीच का अंतर समझ में नहीं आ रहा है। मुझे लगता है कि NodeEnvironment अधूरा हो सकता है?

मैं अभी भी इन नोड्स को समाप्त नहीं कर सकता।

(8) यह भ्रमित करने वाला है कि NodePhong को NodeMaterial से नहीं लिया गया है। हालाँकि मैं देख रहा हूँ कि NodeMaterial ShaderMaterial से लिया गया है। मुझे आश्चर्य है कि क्या आपने ShaderMaterial, GraphMaterial (या NodeGraphMaterial) से प्रत्यक्ष व्युत्पन्न कहा है जो अधिक समझ में आता है - क्योंकि सभी एक साथ नोड्स एक ग्राफ बनाते हैं, और यह वह ग्राफ है जो सामग्री बन जाता है, न कि एक व्यक्तिगत नोड।

NodeMaterial रूट नोड सामग्री होगी, शीर्ष और टुकड़े के लिए एक नोड का उपयोग करना आवश्यक है। NodePhong हाइब्रिड है और NodePhongMaterial केवल एक प्रॉक्सी क्लास है। इसके बाद इसे मर्ज किया जा सकता है।

(9) मैं शायद कुछ और विविध शब्दावली का सुझाव दूंगा। मैं रूट नोड, मटेरियल नोड को कॉल करूंगा, और कोई इससे PhongMaterialNode प्राप्त कर सकता है। मेरे पास वेक्टर 3 नोड, फ्लोटनोड, आदि है जो ValueNode से प्राप्त हुआ है - जरूरी नहीं कि स्थिर हो, लेकिन केवल एक मान हो। इस प्रकार कोई तीन फ्लोटनोड्स में एक वेक्टर 3 नोड में पाइप कर सकता है। मुझे लगता है कि आपके पास एक सहायक हो सकता है जो वर्तमान में 10 या उससे अधिक की बजाय इनमें से प्रत्येक एक पंक्ति या तो घोषित करेगा।

बढ़िया है।

(16) मैं प्रकाश इनपुट के बारे में उलझन में हूँ - आमतौर पर किसी में रोशनी प्लग करने योग्य नहीं होती है, बल्कि प्रकाश मापदंडों को पूरी तरह से प्रकाश वर्ग में परिभाषित किया जाता है। मुझे लगता है कि आपको इस अतिरिक्त लचीलेपन की आवश्यकता है? आप इसकी कल्पना कैसे करते हैं।

यह लाइटमैप या संभावित लाइटनोड के लिए होगा।

यह लाइटमैप या संभावित लाइटनोड के लिए होगा।

मुझे प्लग करने योग्य लाइटमैप का विचार पसंद है क्योंकि कोई इसके लिए यूवी को स्पष्ट रूप से परिभाषित कर सकता है। :)

@bhouston आज इस फ़ाइल में कई सुधारों को ठीक करें: लेकिन अभी भी बहुत कुछ करना
https://github.com/sunag/sea3d/blob/gh-pages/Labs/Three.JS-NodeMaterial/three.node.js

यह वह खेल का मैदान है जिसे मैं बना रहा हूं: कला: बनावट और बटन एक ड्रैग एंड ड्रॉप है, केवल क्रोम में काम करता है

http://sea3d.poonya.com/flow/

अद्भुत सामान! बकवास! यह खूबसूरत है।

क्या कोड को इस तरह से साझा करना संभव होगा कि मैं भी योगदान कर सकूं? एक सार्वजनिक पीआर या कुछ और के रूप में?

आप यहाँ Sea3D प्रोजेक्ट के साथ काम कर रहे हैं?

https://github.com/sunag/sea3d/tree/gh-pages/Labs/Three.JS-NodeMaterial

तो क्या मैं इसे केवल फोर्क कर सकता हूं और योगदान देना शुरू कर सकता हूं? क्या आप पीआर स्वीकार करेंगे? हम कैसे प्रभावी ढंग से सहयोग कर सकते हैं।

मैंने पूछा नहीं है, लेकिन @mrdoob शायद (?) इसे थ्रीजेएस प्रोजेक्ट के भीतर ही रखना पसंद करेंगे।

निश्चित रूप से!

तो क्या मैं इसे केवल फोर्क कर सकता हूं और योगदान देना शुरू कर सकता हूं? क्या आप पीआर स्वीकार करेंगे? हम कैसे प्रभावी ढंग से सहयोग कर सकते हैं।

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

आप यहाँ Sea3D प्रोजेक्ट के साथ काम कर रहे हैं?

मुझे लगता है कि उदाहरणों के साथ थ्री.जेएस के लिए पीआर बनाने में यह सब परिभाषित है।

@mrdoob सामग्री के नाम, तीन.MaterialNode या तीन.NodeMaterial के बारे में आप क्या कहते हैं?

यह एक प्रकार की सामग्री है, इसलिए इसे THREE.NodeMaterial होना चाहिए।

यूपी। मुझे लगता है कि मैं एक पीआर के करीब हूं?
https://github.com/sunag/sea3d/commit/55cf70aea38b2b72110abf96f7b96924dad81c54

परीक्षण के लिए इस क्यूबमैप को खेल के मैदान और किसी अन्य बनावट में खींचें
https://raw.githubusercontent.com/mrdoob/three.js/master/examples/textures/skyboxsun25degtest.png

http://sea3d.poonya.com/flow/

एक रिम शेडर उदाहरण

क्षेत्र प्रतिबिंब उदाहरण

यह बहुत बढ़िया है @sunag!

@भूस्टन धन्यवाद! आपको लगता है कि R74 में कनवर्ट करना मुश्किल होगा?

यह बहुत प्रभावशाली काम है! मुझे शेडरफोर्ज की याद दिलाता है।

बहुत अच्छा काम अब तक!

@ सुनग यह थोड़ा काम होगा, लेकिन मैं मदद करना चाहता हूं और

@GGAlanSmithee यह भी https://docs.unrealengine.com/latest/INT/Engine/Rendering/Materials/ExpressionReference/index.html

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

https://www.youtube.com/playlist?list=PLlH00768JwqG4__RRtKACofTztc0Owys8

यह थोड़ा काम का होगा, लेकिन मैं मदद करना चाहूंगा और R74 शेडर कोड में अधिकांश बड़े संरचनात्मक परिवर्तन मेरी गलती हैं। :)

@bhouston वाह। नए r74 परिवर्तनों के साथ यह बहुत अधिक साफ था। मैंने पहले भाग को समाप्त कर दिया है जो अभी भी मानक सामग्री गायब है। कोई भी समस्या जो मैं यहाँ पोस्ट करता हूँ:) धन्यवाद
https://github.com/sunag/sea3d/commit/d544ad7993272348f8bbea2337cdceb52159a6a8

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

@GGAlanSmithee मेरे पास

@richardanaya अद्भुत वीडियो। धन्यवाद!

@mrdoob आप इन फ़ाइलों को किस फ़ोल्डर में रखने की सलाह देते हैं? three.js रूट (src/materials/node) या उदाहरणों में?
https://github.com/sunag/sea3d/tree/gh-pages/Labs/Three.JS-NodeMaterial/node

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

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

मेरे लिए दोनों अच्छे लगते हैं। मैं फैसला @mrdoob पर

बीटीडब्ल्यू @ सुनग यदि संभव हो तो मैं अपवर्तन के लिए क्यूबमैप्स के साथ रहूंगा, यह आसान और अधिक सटीक है। मुझे लगता है कि लगभग हर कोई ऐसा ही करता है और हमें सटीक प्रतिबिंबों के लिए भी आरटीटी सामग्री की आवश्यकता होती है। मुझे लगता है कि इसे 128^2 या 256^2 पर तेजी से प्रस्तुत करने की जरूरत है।

बीटीडब्ल्यू @ सुनग यदि संभव हो तो मैं अपवर्तन के लिए क्यूबमैप्स के साथ रहूंगा, यह आसान और अधिक सटीक है। मुझे लगता है कि लगभग हर कोई ऐसा ही करता है और हमें सटीक प्रतिबिंबों के लिए भी आरटीटी सामग्री की आवश्यकता होती है। मुझे लगता है कि इसे 128^2 या 256^2 पर तेजी से प्रस्तुत करने की जरूरत है।

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

NodeStandard को एनालाइज करने के लिए CubeMap को खींचना आवश्यक है।
https://raw.githubusercontent.com/mrdoob/three.js/master/examples/textures/skyboxsun25degtest.png
http://sea3d.poonya.com/flow/

स्रोत:
https://github.com/sunag/sea3d/blob/gh-pages/Labs/Three.JS-NodeMaterial/node/NodeStandard.js

@mrdoob आप इन फ़ाइलों को किस फ़ोल्डर में रखने की सलाह देते हैं? three.js रूट (src/materials/node) या उदाहरणों में?

मैं इसे शुरू करने के लिए उदाहरणों में रखूंगा। एक बार जब यह अच्छी तरह से परिभाषित हो जाता है तो हम बाद में इसे src . में स्थानांतरित कर सकते हैं

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

मेरे लिए दोनों अच्छे लगते हैं। मैं फैसला @mrdoob पर

मुझे पहले से ही NodeMaterial ... शायद NodesMaterial ? NodeGraphMaterial ? @WestLangley कोई सुझाव?

हालांकि मैं वर्तमान नोड्स का नाम बदलूंगा ... NodeColor , NodeFloat , NodeTexture , ... से ColorNode , FloatNode , TextureNode

http://sea3d.poonya.dev/flow/

मैं इसे लोड करने के लिए नहीं मिल सकता

मैं इसे शुरू करने के लिए उदाहरणों में रखूंगा। एक बार जब यह अच्छी तरह से परिभाषित हो जाता है तो हम बाद में इसे src में ले जा सकते हैं: ब्लश:

@mrdoob यह बहुत अच्छा होगा।

हालांकि मैं वर्तमान नोड्स का नाम बदलूंगा ... NodeColor, NodeFloat, NodeTexture, ... को ColorNode, FloatNode, TextureNode

मैं इसे तब फॉरवर्ड करूंगा।

यह स्थानीय यूआरएल है: ब्लश:, इसे आजमाएं:
http://sea3d.poonya.com/flow/

@WestLangley कोई सुझाव?

मेरा सुझाव है THREE.FlowMaterial ।

मेरी दूसरी पसंद होगी THREE.CustomMaterial ।

पूरी तरह से यादृच्छिक दर्शक के रूप में। NodeMaterial मेरे लिए बहुत सहज लगता है, क्योंकि यही उन्हें Blender3D . में कहा जाता है

अगर @mrdoob को

NodeMaterial यह तो . है

यह प्रोजेक्ट कमाल का है! अभी ट्विटर पर डेमो देखा और यह बहुत प्रभावशाली है।

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

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

क्या इस नोडमटेरियल प्रकार को पूरी तरह से थ्री कोर के बाहर भी संभाला जा सकता है? किसी को अपने प्रोजेक्ट में इसका उपयोग करने के लिए आपको वास्तव में आउटपुट करना है एक RawShaderMaterial है।

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

मैंने एक छोटी सी समस्या पर ध्यान देने के बारे में सोचा:
"फ्लो" में एक दूसरे पर नोड्स खींचते समय कनेक्टर शीर्ष स्तर पर नहीं आते हैं।
हो सकता है कि यह समस्या अभी भी परतों या कुछ और की प्रतीक्षा कर रही हो।

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

यह एक विस्तृत उत्तर नहीं है, लेकिन कुछ समय पहले मैंने पोर्टेबल शेडर प्रारूप के लिए एक मोटा प्रस्ताव बनाया था जिसमें मेटाडेटा शामिल है, जैसे समान नाम, उनके प्रकार, उनके प्रकार Three.js, आदि। https://github.com /DelvarWorld/ShaderFrog-रनटाइम/ब्लॉब/मास्टर/THREE_SHADER_FORMAT.md

एक वास्तविक वातावरण में चलाने के लिए सभी शेडर को वास्तव में कच्चे शेडर स्रोत कोड की आवश्यकता होती है (चूंकि GPU इसे संकलित करता है) और, सुविधा के लिए, उपयोगकर्ता किन मूल्यों के साथ सेट कर सकता है। इस मोटे प्रस्ताव में प्रोग्रामेटिक रूप से एक शेडर बनाने की कोई धारणा शामिल नहीं है, यह जीएलएसएल और मेटाडेटा के लिए एक साधारण डिलीवरी है। यह Three.js के साथ संगत है क्योंकि आपको इसे अंत में RawShaderMaterial में रखना होगा।

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

क्या इस प्रस्तावित शेडर मानक का तीन में स्थान है? मुझे पता नहीं है। अभी यह शायद मेरे लिए थ्री कोर की तुलना में अधिक उपयोगी है, क्योंकि थ्री अपने स्वयं के शेड्स को अपने तरीके से बनाता है।

@DelvarWorld मैंने इस परियोजना को शेडर ग्राफ नोड्स का एक मानकीकृत सेट बनाने के लिए शुरू किया था:

https://github.com/OpenMaterialGraph/OpenMaterialGraph

यहां नोड विनिर्देश:

https://github.com/OpenMaterialGraph/OpenMaterialGraph/tree/master/spec/nodes

न्यूनतम बीएसडीएफ विनिर्देश यहां:

https://github.com/OpenMaterialGraph/OpenMaterialGraph/tree/master/spec/bsdfs

हालांकि यह शारीरिक रूप से आधारित प्रतिपादन की ओर उन्मुख है।

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

@bhouston ओह अच्छा, ऐसा लगता है कि हमारे पास बहुत सारी अतिव्यापी आवश्यकताएं हैं, उर्फ ​​​​डिफ़ॉल्ट मान, प्रदर्शन नाम, मानव पठनीय विवरण, आदि। मुझे नहीं पता कि भविष्य में क्या है, लेकिन यह मेरे लिए उपयोग करने के लिए एक मामूली आसान बदलाव होगा। आप जो प्रस्ताव देते हैं उसे अधिक प्रारूपित करें।

एक औपचारिक शेडर प्रारूप बहुत मायने रखता है। हालांकि इसे lib के साथ रहना चाहिए, ताकि यह इसके साथ आसानी से विकसित हो सके। किसी ऐसे व्यक्ति के लिए जो तीन.जेएस के लिए नया है, क्या कोई विशिष्ट कारण है कि ऐसा पहले से मौजूद नहीं है? संपादक के लिए दिलचस्प होना चाहिए अगर और कुछ नहीं।

*संपादित करें हो सकता है कि तीन.जेएस में कल्पना होने से इसका उद्देश्य विफल हो जाएगा यदि इसका मतलब अन्य प्रतिपादन पाइपों द्वारा उपभोग किया जाना है।

अभी यह शायद मेरे लिए थ्री कोर की तुलना में अधिक उपयोगी है, क्योंकि थ्री अपने स्वयं के शेड्स को अपने तरीके से बनाता है।

यदि आप एक बार NodeMaterial(*Flow) एक दृश्य भाषा होने पर THREE.NodeGL.prototype.generate अंदर संशोधन करते हैं तो आप उसी सामग्री को दूसरी भाषा में उत्पन्न कर सकते हैं। NodeBuilder इसका द्वार हो सकता है। वर्तमान में नोड्स के बीच डेटा का मध्यस्थ है।

मैंने नोडमटेरियल "कच्चे" का एक उदाहरण साफ़ किया: यह अभी भी कई बग उत्पन्न कर सकता है।
https://github.com/sunag/sea3d/blob/gh-pages/Labs/Three.JS-NodeMaterial/index.html#L179
https://github.com/sunag/sea3d/blob/gh-pages/Labs/Three.JS-NodeMaterial/node/NodeMaterial.js#L9

मुझे लगता है कि कणों के साथ इसे आगे बढ़ाने के लिए रूट नोड्स बनाए गए हैं। मल्टी-पास के लिए NodePass और PR के बाद NodeMaterialD मुझे कुछ दिनों में क्या करना चाहिए।

मैंने एक रनटाइम शेडर के बजाय एक THREE.ShaderFrogLoader का सुझाव दिया।

"फ्लो" में एक दूसरे पर नोड्स खींचते समय कनेक्टर शीर्ष स्तर पर नहीं आते हैं।

@MasterJames धन्यवाद! मैं इसे देख लूंगा।

:+1:

मैंने उदाहरण बनाना शुरू किया। मुझे इस सप्ताह समाप्त होने की उम्मीद है। :पसीना_मुस्कुराना:
http://sunag.github.io/sea3d/Labs/Three.JS-NodeMaterial/webgl_materials_nodes.html

विचार?

@sunag +1 : - )

+1!

यह तो कमाल है। मैं बादलों की तरह विस्थापन के बजाय पौधों + दीवार बनावट पर डिफ़ॉल्ट हूं। :) वह बस सुंदर है।

मैं बादलों की तरह विस्थापन के बजाय पौधों + दीवार बनावट पर डिफ़ॉल्ट हूं।

आप 'परतों' उदाहरण का उल्लेख करते हैं? फिर भी मैं हमारे लिए और उदाहरण पोस्ट करूंगा

जीपीयू सॉफ्ट-बॉडी

एक अलग दृष्टिकोण के साथ तुलना के लिए, Shader Frog ग्राफ संपादक अब लाइव है, और यह "किक द टायर्स" चरण में है। मैं यह रेखांकित करना चाहता हूं कि इसे तीन.जेएस कोर में किसी भी बदलाव की आवश्यकता नहीं है।

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

... और इसे एक प्रतिबिंब शेडर से गुणा करें ...

... शेडर ग्राफ का उपयोग करना ...

और टा-दा! एक प्रतिबिंब रिम शेडर ।

उदाहरण के लिए, आप किसी भी अन्य शेडर का उपयोग करके किन्हीं दो शेड्स को मास्क कर सकते हैं, और इसी तरह:

ध्यान दें कि इस प्रक्रिया के लिए आवश्यक केवल "नोड प्रकार" एक गुणा नोड है (शेडरफ्रॉग में अन्य हैं), जो लगभग पूरी तरह से जीएलएसएल से स्वतंत्र है। ShaderFrog किसी भी शेड के साथ काम कर सकता है, यही वजह है कि इसमें अनंत नोड प्रकार हैं। यह उन्नत प्रौद्योगिकी दृष्टिकोण थ्री.जेएस परिवर्तनों से स्वतंत्र इस हेरफेर की अनुमति देता है।

ShaderFrog के पास Three.js को प्रथम श्रेणी का निर्यात समर्थन मुफ्त में है। सभी तीन.जेएस स्रोत कोड को संशोधित किए बिना। Sea3D एक तृतीय पक्ष उत्पाद है, जैसे ShaderFrog। तीसरे पक्ष के उत्पाद यांत्रिकी को थ्री के मूल में रखना एक अनुचित लाभ की तरह लगता है और मैं इसे राजनीतिक रूप से नहीं समझता।

@DelvarWorld मैं वास्तव में तीसरे पक्ष की विशिष्ट तकनीक के रूप में नोड-आधारित शेडर निर्माण

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

@DelvarWorld कमाल है। मुझे नया संपादक पसंद है।

@DelvarWorld +1 बहुत बढ़िया! :- )

धन्यवाद! :)

मैं वास्तव में तीसरे पक्ष की विशिष्ट तकनीक के रूप में नोड-आधारित शेडर निर्माण अबास्ट्रक्शन नहीं देखता हूं।

मैं उदाहरण के लिए पीबीआर के लिए नोड सेटअप को समझता हूं

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

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

मुझे लगता है कि NodeMaterial और Flow के दो अलग-अलग फोकस हैं। फ्लो और शेडरफ्रॉग दोनों विजुअल एडिटर्स थर्ड पार्टी सॉल्यूशन हैं जो वर्तमान में क्लोज्ड सोर्स में हैं (मुझे लगता है कि मुख्य रूप से इसके लिए कलाकारों में) अन्य नोडमटेरियल थ्री.जेएस के लिए किए गए प्रोग्रामर के लिए एक ओपन-सोर्स शेडर एडिटर है। मैं @richardanaya से इस अर्थ में सहमत हूं कि ShaderFrog वांछित होने पर NodeMaterial से आगे जा सकता है। जैसे मुझे लगता है कि फ्लो को सिर्फ एक भौतिक संपादक होने की आवश्यकता नहीं है। मैं वास्तव में हमेशा की तरह भविष्य में ShaderFrog के महान सुधारों की आशा करता हूं।

पोंछ: कास्टिक-वोरोनोई
http://sunag.github.io/sea3d/Labs/Three.JS-NodeMaterial/webgl_materials_nodes.html

@ सुनग मैं आज रात आपके स्रोत कोड से

• मैं जल्द से जल्द एक पीआर देखना चाहता हूं। मैं मदद कर सकता हूँ। :)
• केवल मानक वाले (uv, uv2, सामान्य, स्थिति, आदि) के बजाय मनमानी विशेषताओं की अनुमति देना अच्छा हो सकता है। मुझे पता है कि बहुत सारे शेड्स स्पर्शरेखा vec4s से लाभ उठा सकते हैं, केवल 2 uvs से अधिक और कई रंग भी गुण। इस प्रकार मैं एक अनुरोधित विशेषता सरणी या कुछ में जरूरतों की स्थिति को सामान्यीकृत करूंगा।
• मैं नोड्स के कुछ संगठन को मुख्य नोडमटेरियल, बीआरडीएफ (फोंग, स्टैंडर्ड, आदि), बनावट नोड्स (नोडक्यूबटेक्चर, नोडटेक्चर), एक्सेसर (?) नोड्स (नोडपोजिशन, नोडनॉर्मल), गणित नोड्स (नोडऑपरेटर, आदि) में सुझाव दूंगा। ), उपयोगिता नोड्स (NodeSwitch, ...), और अतिरिक्त (?) (NodeVelocity, ...) मुझे लगता है कि इससे बहुत मदद मिलेगी।
• प्रोजेक्शन, व्यू और वर्ल्ड मैट्रिसेस के लिए मैट्रिक्स एक्सेसर्स रखना अच्छा होगा।
• आप कुछ ऑपरेटरों को याद कर रहे हैं: % ^ & << >> ~ |
• मुझे यकीन नहीं है कि जब कक्षा इतनी छोटी होती है तो मुझे NodePhongMaterial में मान दिखाई देता है, मुझे बस उपयोगकर्ताओं को NodePhong नोड का उपयोग करके NodeMaterial के साथ संयुक्त करना होगा (हालाँकि मुझे अभी भी वह नाम पसंद नहीं है, GraphMaterial बहुत कुछ महसूस करता है मेरे लिए अधिक प्रकृति, लेकिन मैं इसके साथ रह सकता हूं।)
• मैं NodeTimer -> NodeTime... को कॉल करूंगा लेकिन फिर से व्यक्तिगत वरीयता।
• मुझे आश्चर्य है कि कई चर नोड्स को एक में जोड़ने का कोई तरीका है जैसे आपने नोडमैथ #, नोडऑपरेटर के साथ किया है। ये बहुत समान लगते हैं: NodeViewPosition, NodeWorldPosition, NodeViewNormal, NodeTransformedNormal, NodeTransformedPosition, NodeProjectPosition...
• मैं NodeMath#, NodeOperator के लिए वैकल्पिक तर्कों का सेट एक ऐसे रूप में देखना चाहता हूं जो एक सूची हो, ताकि कोई इसके साथ ड्रॉपडाउन बॉक्स को आसानी से पॉप्युलेट कर सके। अभी क्योंकि वे सदस्य हैं जो सिर्फ कक्षाओं में पूंजीकृत हैं, उन्हें पहचानना थोड़ा कठिन है। मैं एक अच्छे समाधान के बारे में निश्चित नहीं हूं जो कोडिंग के लिए अभी भी सुविधाजनक है। हो सकता है कि कक्षा के सदस्यों के रूप में उनकी परिभाषाओं के बाद उन्हें सिर्फ एक सूची में एकत्रित किया जाए, तो बस उन सूचियों को जोड़ें?
• NodeTransformedNormal, NodeTransformedPosition मेरे लिए यह पता लगाना कठिन है कि कोड को देखे बिना वे क्या हैं। क्या वे विश्व अंतरिक्ष में हैं, अंतरिक्ष देखें, वस्तु स्थान? "रूपांतरित" एक बहुत ही सामान्य शब्द है, जिसका अर्थ है एक मैट्रिक्स से गुणा करना। मैं अब उनके लिए कोड देखूंगा ....
• मैं NodeUV और NodeColor को क्रमशः 2 और 1 चैनल तक सीमित होने के बजाय एक इंडेक्स लेने की अनुमति दूंगा। फिर से मैं इन निर्मित जेनेरिक को देखना चाहूंगा, वास्तव में आप विशिष्ट चैनलों के एक सेट के लिए हार्ड कोड किए जाने के बजाय एक स्ट्रिंग या कई प्रीसेट में से एक में गुजरते हैं। कुछ चरों के लिए आपके पास अभी भी कुछ समर्पित कोड पथ हो सकते हैं, लेकिन यह उन नामों के लिए कुछ सामान्य पर वापस आ जाएगा जिन्हें यह विशेष केस हैंडलिंग के लिए नहीं पहचानता है।

अधिक प्रतिक्रिया:

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

@bhouston वाह! शुक्रिया!

अनुरोध विशेषताएँ, फ़ोल्डरों का संगठन, NodeTime, NodePosition, NodeNormal, NodeView को संशोधित किया गया था। +3 उदाहरण भी जोड़े।

ऑपरेटरों और मैट्रिक्स में हमें integer और matrix रूपांतरणों के साथ संगतता जोड़नी होगी। इसके लिए फ्लोट/वेक्टर# जैसे स्वचालित तरीके से किया जाना है। अगले अपडेट के लिए हमारे पास काफ़ी काम है.. :sweat_smile:

कल मैं पीआर बनाऊंगा। मुझे अभी कुछ चीजों की समीक्षा करनी है।

@सुनाग :

मुझे विश्वास है कि यह एक बग है:

addGui( 'metalnessA', roughnessA.number, function( val ) {

                        roughnessA.number = val;

                    }, false, 0, 1 );

मुझे विश्वास है कि यह एक बग है:

धन्यवाद!

मुझे उदाहरण पृष्ठ पर जाने और पीबीआर नोड ग्राफ़ <3 . देखने के लिए बस चक्कर आया

<3
पिछले संशोधन के परिवर्तन
https://github.com/sunag/sea3d/commit/a2e3813b53902331e91dbc0f6bae0136a384ad0c

नोडमटेरियल रेव 4 + नोडपास

http://sunag.github.io/sea3d/Labs/Three.JS-NodeMaterial/webgl_postprocessing_nodes.html

अच्छा!

मैं पोस्ट-प्रोसेसिंग के लिए नोड्स का उपयोग करने का सुझाव देने जा रहा था लेकिन मैं पहले भाग के होने की प्रतीक्षा कर रहा था। धिक्कार है, यह सुंदर है!

नोडमटेरियल रेव 5 + लाइटनोड

http://sunag.github.io/sea3d/Labs/Three.JS-NodeMaterial/webgl_materials_nodes.html

त्वचा

तून छायांकन

++ color-adjustment और plush उदाहरण।

निइस!

subsurface scattering :sweat_smile:

यह एक तरह का शेडर है जो भविष्य के अपडेट में काम कर सकता है।

http://sunag.github.io/sea3d/Labs/Three.JS-NodeMaterial/webgl_materials_nodes.html

!

भयानक NodeMaterial के लिए धन्यवाद!

मेरे पास कई टिप्पणियां/बग हैं:

• अनुगामी व्हॉट्सएप ब्रेक फंक्शन नोड

var n1 = new THREE.FunctionNode(" float mul_2_float(float x) { return x*2.0; }"); // problem
var n2 = new THREE.FunctionNode("float mul_2_float(float x) { return x*2.0; }"); // ok

• फ़ंक्शन नोड में int पैरामीटर के साथ समस्या

फ्लोट पैरामीटर के साथ कार्य उदाहरण:

var floatFuncNode= new THREE.FunctionNode("float mul_2_float(float x) { return x*2.0; }");

var funcCallNode = new THREE.FunctionCallNode(floatFuncNode);
funcCallNode.inputs.x = new THREE.FloatNode(0.2);

var colorResNode = new THREE.OperatorNode(new THREE.ColorNode(0x00ff00),
    funcCallNode, THREE.OperatorNode.MUL);

var mat = new THREE.PhongNodeMaterial();
mat.color = colorResNode;

int पैरामीटर के साथ टूटा हुआ उदाहरण:

var intFuncNode= new THREE.FunctionNode("float mul_2_int(int x) { return float(x)*2.0; }");

var funcCallNode = new THREE.FunctionCallNode(intFuncNode);
funcCallNode.inputs.x = new THREE.IntNode(1);

var colorResNode = new THREE.OperatorNode(new THREE.ColorNode(0x00ff00),
    funcCallNode, THREE.OperatorNode.MUL);

var mat = new THREE.PhongNodeMaterial();
mat.color = colorResNode;

• सुझाव: FunctionCallNode कंस्ट्रक्टर में फ़ंक्शन पैरामीटर पास करें

//current:
var funcCallNode = new THREE.FunctionCallNode(floatFuncNode);
funcCallNode.inputs.param1 = new THREE.FloatNode(1);
funcCallNode.inputs.param2 = new THREE.ColorNode(0x0f0f0f);

// proposed:
var funcCallNode = new THREE.FunctionCallNode(floatFuncNode, 
    { param1: new THREE.FloatNode(1), param2: new THREE.ColorNode(0x0f0f0f) } );

// and, i think suitable in some cases: 
var funcCallNode = new THREE.FunctionCallNode(floatFuncNode, 
    [ new THREE.FloatNode(1), new THREE.ColorNode(0x0f0f0f) ] );

• क्या PhongNodeMaterial बंप मैप के साथ संगत है?

कुछ और नोट:

• स्थिति नोड के साथ समस्या। "कच्चे" NodeMaterial में खंड shader में LOCAL:

var material = new THREE.NodeMaterial(
        new THREE.RawNode( new THREE.PositionNode( THREE.PositionNode.PROJECTION ) ),
        new THREE.RawNode( new THREE.PositionNode( THREE.PositionNode.LOCAL ) )
    );

परिणामी शेड्स:

varying vec3 vPosition;
void main(){
gl_Position = (projectionMatrix * modelViewMatrix * vec4( position, 1.0 ));
vPosition = transformed;
}

varying vec3 vPosition;
void main(){
gl_FragColor = vec4(vPosition,0.0);
}

संभवतः "रूपांतरित" कार्यक्षमता को फोंग/स्टैंडआर्ट नोड सामग्री से नोडमटेरियल में ले जाया जाना चाहिए

• कॉन्स्टनोड उपयोग

    var material = new THREE.NodeMaterial(
        new THREE.RawNode( 
            new THREE.OperatorNode(
                new THREE.PositionNode( THREE.PositionNode.PROJECTION ),
                new THREE.ConstNode("float TWO = 2.0;"),
                THREE.OperatorNode.MUL)
            ),
        new THREE.RawNode( new THREE.ColorNode( 0xff0000 ) )
    );

उस स्थिति में परिणाम शेडर में होता है
gl_Position = ((प्रोजेक्शनमैट्रिक्स * मॉडलव्यूमैट्रिक्स * vec4 (स्थिति, 1.0)) * दो);
लेकिन दो स्थिरांक घोषित नहीं किया गया है। यह मेरी गलती है या बग?
साथ ही, ConstNode अर्धविराम संवेदनशील है, इसलिए "फ्लोट TWO = 2.0" को पार्स नहीं किया जाता है।

धन्यवाद @dimarudol ! यदि आप जल्द से जल्द मुक्त महसूस करना चाहते हैं तो नोट्स के साथ नया रिवीजन करें।

लेकिन दो स्थिरांक घोषित नहीं किया गया है। यह मेरी गलती है या बग?

मैं उपयोग के इस तरीके और सामग्री में उदाहरण के लिए material.include( node ) विचार करूंगा

उस समय वैश्विक स्थिरांक का प्रयास करें:

var TWO = new THREE.ConstNode("float TWO = 2.0;");
THREE.NodeLib.add( TWO ); // global

 var material = new THREE.NodeMaterial(
        new THREE.RawNode( 
            new THREE.OperatorNode(
                new THREE.PositionNode( THREE.PositionNode.PROJECTION ),
                TWO,
                THREE.OperatorNode.MUL)
            ),
        new THREE.RawNode( new THREE.ColorNode( 0xff0000 ) )
    );

हाय @ सुनग , मैं Sea3d Flow के साथ खेल रहा हूं और यह बहुत अच्छा लग रहा है। बस यह पूछना चाहता था कि क्या इसके लिए कहीं आधिकारिक रेपो है।
सादर।

नमस्ते @rraallvv , अभी नहीं, यह पहले से ही तैयार है। मैं जितनी जल्दी हो सके खबर पोस्ट करता हूं।

धन्यवाद @ सुनग , इसकी बहुत सराहना की जाती है।

हाय @सुनाग ! आपने वास्तव में अच्छा काम किया!
मेरे पास एक प्रश्न है: मेरी परियोजना के लिए आपके नोड्स संरचना का उपयोग करना बहुत अच्छा होगा, लेकिन मुझे प्रति शीर्ष रंग (और कस्टम प्रति वर्टेक्स फ्लोट वैल्यू) की आवश्यकता है, लेकिन आपके नोड्स सिस्टम में आपको केवल कलरनोड और फ्लोटनोड पूरे जाल पर लागू होता है .. क्या आपको लगता है कि बफ़रकोलोरनोड (तीन.बफ़रएट्रिब्यूट का उपयोग करके) जैसी किसी चीज़ को आसानी से लागू करने का कोई तरीका है?

उदाहरण के लिए मुझे यह दृश्य मिला है:

प्रत्येक शीर्ष का अपना रंग होता है। यह THREE.BufferAttribute और एक THREE.ShaderMaterial के साथ संभव है लेकिन आपके कोड में कोई समकक्ष नहीं है।

मुझे कुछ चाहिए होगा:
`चलो सामग्री = नया तीन। StandardNodeMaterial ();
चलो texColorMap = नया तीन। TextureNode (नया तीन। TextureLoader ()। लोड ("colorMap.jpg"));
चलो customData = नया तीन। BufferFloatNode (नया Float32Array (...), "डेटा"); // दूसरा पैरामीटर विशेषता का नाम है

चलो colorMap = नया तीन।FunctionNode([
"vec3 colorMap (sampler2D texColorMap, फ्लोट डेटा) {",
"वापसी vec3 (texture2D (texColorMap, customFunc (डेटा)));", // customFunc डेटा के आधार पर एक vec2 लौटाता है
"}"
]। शामिल हों ("एन"));

चलो colorMapCall = new THREE.FunctionCallNode(colorMap);
colorMapCall.inputs.texColorMap = texColorMap;

सामग्री। रंग = colorMapCall;
सामग्री.बिल्ड (); `

वैसे, ऐसा लगता है कि मैं FunctionNode के लिए sampler2D पैरामीटर का उपयोग नहीं कर सकता ...

क्या मैं कुछ भूल रहा हूँ ?
मुझे लगता है कि जरूरत पड़ने पर मैं मदद कर सकता हूं :)

@martinRenou धन्यवाद! हम्म, शायद अभी के लिए कुछ ऐसा:

bufferGeometry.addAttribute( 'color', new THREE.BufferAttribute( colors, 4 ) );
...
colorMapCall.inputs.data = new THREE.ColorsNode(); // send color.x to float slot

मैंने अभी तक नोड के साथ एक गतिशील ज्यामिति विशेषता निर्दिष्ट करने के बारे में नहीं सोचा था। लेकिन मुझे लगता है कि यह एक अच्छा विचार है ... शायद THREE.BufferAttributeNode जैसा कुछ ...

@sunag आपके उत्तर के लिए धन्यवाद :)
मैं वह कोशिश करूँगा। यदि यह आपके लिए ठीक है तो मैं तीन.बफरएट्रिब्यूट नोड पर काम शुरू करूंगा, अभी के लिए मैं अभी भी आपका कोड पढ़ रहा हूं और संरचना को समझने की कोशिश कर रहा हूं।

1. THREE.FunctionNode के संबंध में, जैसा कि मैंने कहा, मुझे वास्तव में अपने मापदंडों में एक नमूना 2D सेट करने की आवश्यकता है क्योंकि यह एक रंग मैप के रूप में उपयोग किया जाता है। पिक्सेल रंग की गणना बनावट 2 डी () के साथ की जाती है और बनावट 2 डी () के दूसरे पैरामीटर की गणना मेरे कस्टम डेटा का उपयोग करके की जाती है। (जो उदाहरण के लिए एक तापमान है)।
   मैं समझता हूँ कि vec3 मापदंडों का उपयोग करने का विचार उपयोगकर्ताओं के साथ मित्रवत होने के लिए था, लेकिन FunctionNode, sampler2D मापदंडों का भी समर्थन कर सकता है, क्या आपको नहीं लगता?
2. इसके अलावा, THREE.FunctionNode केवल खंड शेडर में लिखता है, लेकिन क्या वर्टेक्स शेडर में भी लिखने में सक्षम होना अच्छा नहीं होगा?

यह मेरा उपयोग मामला होगा, इसे IsoColor कहा जाता है, क्योंकि रंग डेटा (तापमान, दबाव ...) लाल -> उच्च तापमान, नीला -> निम्न तापमान के अनुरूप होता है:

1. मैं एक तीन लिखने के बारे में सोच रहा हूँ।IsoColorNode (जो मेरे आरेख के FunctionNode को प्रतिस्थापित करेगा), और अन्य नोड्स जो वैज्ञानिक विज़ुअलाइज़ेशन के लिए बहुत दिलचस्प होंगे। क्या आप उसमें रुचि रखते हैं? @mrdoob क्या आप भी रुचि लेंगे?

THREE.FunctionNode के संबंध में, जैसा कि मैंने कहा, मुझे वास्तव में अपने मापदंडों में एक नमूना 2D सेट करने की आवश्यकता है क्योंकि यह एक रंग मैप के रूप में उपयोग किया जाता है। पिक्सेल रंग की गणना बनावट 2 डी () के साथ की जाती है और बनावट 2 डी () के दूसरे पैरामीटर की गणना मेरे कस्टम डेटा का उपयोग करके की जाती है। (जो उदाहरण के लिए एक तापमान है)। मैं समझता हूँ कि vec3 मापदंडों का उपयोग करने का विचार उपयोगकर्ताओं के साथ मित्रवत होने के लिए था, लेकिन FunctionNode, sampler2D मापदंडों का भी समर्थन कर सकता है, क्या आपको नहीं लगता?

मैं अब आपकी ज़रूरत को समझता हूँ! मैं इसके लिए और @dimarudol के अन्य नोटों के लिए एक पीआर

इसके अलावा, THREE.FunctionNode केवल खंड शेडर में लिखता है, लेकिन क्या वर्टेक्स शेडर में भी लिखने में सक्षम होना अच्छा नहीं होगा?

मैंने इसका परीक्षण नहीं किया लेकिन मुझे ऐसा लगता है।

मैंने दो और उदाहरण जोड़े:

• sampler2D triangle-blur उदाहरण में हैं
• कस्टम BufferAttribute custom-attribute उदाहरण में हैं

यह काम कर रहा है लेकिन मैं अभी भी कोड में पॉलिश दूंगा ...

https://github.com/mrdoob/three.js/pull/9636

वाह ! आपने वास्तव में अच्छा काम किया है, यह मेरे लिए भी काम कर रहा है: मुस्कान:

आपके काम के लिए फिर से धन्यवाद!

हाय @सुनाग ,

अभी के लिए हमारे पास "शून्य" प्रकार के साथ FunctionNode नहीं हो सकता है क्योंकि हमें इसे सामग्री को पैरामीटर (रंग, अल्फा ...) के रूप में भेजने की आवश्यकता है। उदाहरण के लिए यदि मैं एक क्लिप प्लेन फंक्शननोड को लागू करना चाहता हूं, तो मैं बस इतना करना चाहता हूं कि इस तरह से एक शेडर भाग लिखें:

void clipPlane(vec4 plane){
 if(dot(position, plane.xyz) > plane.w) discard;
}

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

var clipPlane = new FunctionNode([
"void clipPlane(vec 4 plane){",
" if (dot(position, plane.xyz) > plane.w) discard;",
"}"].join("\n"));
var clipPlaneCall = new FunctionCallNode(clipPlane);
clipPlaneCall.inputs.plane = myVec4Node;

var threshold = new FunctionNode([
"void threshold(float upperBound, float lowerBound, float data){",
" if(data < lowerBound) discard;",
" if(data > upperBound) discard;",
"}"].join("\n"));
var thresholdCall = new FunctionCallNode(threshold);
thresholdCall.inputs.upperBound = myFloatNode1;
thresholdCall.inputs.lowerBound = myFloatNode2;
thresholdCall.inputs.data = myAttributeNode;

var myMaterial = new StandardNodeMaterial();
myMaterial.color = ...
myMaterial.alpha = ...

// voidFunctions is not a good name I'm not inspired...
myMaterial.voidFunctions = [clipPlaneCall, thresholdCall];

अधिक "डिज़ाइन" उदाहरण के लिए, यदि मैं इस बनावट के साथ अपने चायदानी पर छेद बनाना चाहता हूँ:

मैं ऐसा कुछ करना चाहता हूं:

var holes = new FunctionNode([
"void holes(vec3 texColor){",
" if (/*texColor too much dark*/) discard;",
"}"].join("\n"));
var holesCall = new FunctionCallNode(holes);
holesCall.inputs.texColor = new TextureNode(LoadTexture("holes-text.jpg"));

var myMaterial = new StandardNodeMaterial();
myMaterial.voidFunctions = [holesCall];
myMaterial.side = THREE.DoubleSide;

एक और बात यह है कि शेड्स में कार्यों के क्रम पर हमारा नियंत्रण नहीं है। अगर मेरे पास ऐसे कार्य हैं जो कम्यूटिव नहीं हैं, तो मेरे पास परिणाम पर नियंत्रण नहीं है ...

आइए इस उदाहरण को देखें:

var transparencyPlane = new FunctionNode([
"float transparencyPlane(vec 4 plane){",
" if (dot(position, plane.xyz) > plane.w) return 0.5.;",
" return 1.;",
"}"].join("\n"));
var transparencyPlaneCall = new FunctionCallNode(transparencyPlane);
transparencyPlaneCall.inputs.plane = myVec4Node;

var displacement = new FunctionNode([
"vec3 displacement(vec3 vector){",
" return position + vector;",
"}"].join("\n"));
var displacementCall = new FunctionCallNode(displacement);
displacementCall.inputs.vector = myVec3Node;

var myMaterial = new StandardNodeMaterial();
myMaterial.transform = displacementCall;
myMaterial.alpha = transparencyPlaneCall;

यदि कोई बिंदु पारदर्शिता तल के पीछे है और विस्थापन के कारण परे आता है, तो उस स्थिति में जिसे "transparencyPlaneCall" को "विस्थापन कॉल" अल्फा = 1 से पहले कहा जाता है, और जिस स्थिति में इसे अल्फा = 0.5 के बाद कहा जाता है।
तो मैं फ़ंक्शन कॉल का क्रम सेट करना चाहता हूं ... क्या आप जानते हैं कि मेरा क्या मतलब है?

नमस्ते @martinRenou

हम्म, लगभग void स्लॉट में उपयोग करने के लिए शायद ProxyNode करता है क्योंकि इसके लिए ऑर्डर का पालन करना होगा या कोड के प्रारंभ या अंत में प्रारंभ करना होगा, शायद functionsStart या functionsEnd स्लॉट...

alpha स्लॉट का उपयोग करना यदि alpha 0 है तो स्वचालित रूप से हटा दिया जाता है।
https://github.com/mrdoob/three.js/blob/dev/examples/js/nodes/materials/PhongNode.js#L180

तो मैं फ़ंक्शन कॉल का क्रम सेट करना चाहता हूं ...

एक अनुक्रम मौजूद है यहाँ देखें:
https://github.com/mrdoob/three.js/blob/dev/examples/js/nodes/materials/PhongNode.js#L122

फ़ंक्शन ऑर्डर स्वचालित रूप से सरल dependencies एल्गोरिथ्म का उपयोग करके किया जाता है, FunctionCall को पिछले स्लॉट में रखना चाहिए, color पहले है specular उदाहरण के लिए दूसरा है।

यह उदाहरण दो अलग-अलग शेडर कोड है: fragment से transparencyPlaneCall और vertex से displacementCall ।

यह मुझे लगता है कि इनपुट का विस्तार करने के लिए चर ( varying और स्थानीय) का उपयोग करें और केवल कॉन्स बहुत दिलचस्प होगा। शायद एक VarNode ...

हो गया r6 - https://github.com/mrdoob/three.js/pull/9636

यदि अल्फा 0 है तो अल्फा स्लॉट का उपयोग करना स्वचालित रूप से बंद हो जाता है।

इसके लिए खेद है, इसे नहीं देखा।

फ़ंक्शन ऑर्डर स्वचालित रूप से सरल निर्भरता एल्गोरिदम का उपयोग करके किया जाता है, फंक्शनकॉल को पिछले स्लॉट में रखना चाहिए, उदाहरण के लिए रंग पहला स्पेक्युलर दूसरा है।

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

यह उदाहरण दो अलग-अलग शेडर कोड है: फ्रैगमेंट टू ट्रांसपेरेंसीप्लेनकॉल और वर्टेक्स टू विस्थापनकॉल।

सही ! तो यह एक अच्छा उदाहरण नहीं था। मेरी गलती।

हो गया r6 - #9636

ठंडा ! आपके उत्तरों के लिए धन्यवाद।

यह मुझे लगता है कि इनपुट का विस्तार करने के लिए चर (अलग-अलग और स्थानीय) का उपयोग करें और केवल कॉन्स बहुत दिलचस्प होगा। शायद एक VarNode...

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

@ सुनग
मुझे लगता है कि वर्टेक्स शेडर में FunctionNode के साथ AttributeNode के उपयोग में कोई समस्या है।

अगर मेरे पास ऐसा कोड है:

var customData = new THREE.AttributeNode("data", "float");

var myFunc = new THREE.FunctionNode([
 "vec3 myFunc(float data){",
 " return vec3(data, 0., 0.);"
 "}"].join("\n"));
var myFuncCall = new THREE.FunctionCallNode(myFunc);
myFuncCall.inputs.data = customData;

material.transform = myFuncCall;

शेडर इस क्रम में लिखा गया है:

...
varying float nVdata;
attribute float data;
...
float myFunc(float data){
 return return vec3(data, 0., 0.);
}

void main(){
...
transformed = myFunc(nVdata); // We use nVdata but it is not initialized
...
nVdata = data;
...
}

डेटा के लिए nVdata को इनिशियलाइज़ करना एक साधारण फिक्स होगा?

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

हां! विचार शीर्ष / टुकड़ा shaders का उपयोग के साथ एक बेहतर संचार है varying के रूप में VarNode । यह keywords सुविधा के साथ अब बहुत अच्छा फिट बैठता है।

मैं एक न्यूनतम varying उदाहरण बनाता हूं लेकिन अभी तक void function का कोई समाधान नहीं है।

मुझे लगता है कि वर्टेक्स शेडर में FunctionNode के साथ AttributeNode के उपयोग में कोई समस्या है।

फिक्स्ड - https://github.com/mrdoob/three.js/pull/9681

हाय @ सुनग , मैंने आपका अलग-अलग उदाहरण देखा, और यह मेरे लिए अजीब लगता है कि अलग-अलग mtl.transform में आपने किया था ... हो सकता है कि जब आप शून्य कार्यों को बनाना संभव हो तो आप इसे बदल देंगे?
हालांकि, एक अच्छा विचार लगता है कि कीवर्ड में :स्माइली:

वास्तव में, मुझे लगता है कि उन भिन्नताओं को mtl.varyings (mtl.varyings एक सरणी है) में रखना एक अच्छा विचार होगा: mtl.varyings.push(myVar) । उसी विचार का उपयोग करते हुए, हम इस तरह से वर्टेक्स और फ्रैगमेंट शेडर्स में फ़ंक्शन डाल सकते हैं: mtl.vertexFunctions.push(myVertexFunctionCall) , उसी तरह mtl.fragmentFunctions ।

इस तरह हम उन भिन्नताओं पर बहुत सारी संगणनाएँ कर सकते हैं और फिर उनका उपयोग प्रभावों के लिए कर सकते हैं। वे कार्य शून्य कार्य होंगे।

NodeMaterialLoader https://github.com/mrdoob/three.js/pull/13070

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

@trusktr निश्चित रूप से सीमित है कि यह बिल्ड समय पर अधिक CPU और रनटाइम पर GPU की खपत करता है। नोड्स को इनपुट और आउटपुट मानों के अनुसार समायोजित किया जाता है, उदाहरण के लिए float से vec2 या vec3 का रूपांतरण स्वचालित है, और ऑप्टिमाइज़ेशन के लिए एक से अधिक बार उपयोग किए जाने पर कैश में स्टोर करें (देखें TempNode )।

स्क्रीनशॉट में प्रत्येक नोड एक वर्ग है, उदाहरण के लिए: PositionNode डिस्प्ले में है:
https://github.com/mrdoob/three.js/blob/789efa65bafe022e178c7e93e0985a7607a54403/examples/js/nodes/accessors/PositionNode.js#L5

@mrdoob @sunag क्या आप NodeMaterial कोड की वर्तमान स्थिति पर टिप्पणी करने के इच्छुक होंगे, और यह तीन.js रोडमैप के साथ कैसे फिट बैठता है?

सिद्धांत रूप में, हम अब कई चीजों के लिए नोड्स का उपयोग कर सकते हैं, जैसे:

• GlTF युक्ति/ग्लॉस PBR सामग्री को NodeStandardSGMaterial के रूप में लागू करें।
• प्रति-मानचित्र यूवी सेट और परिवर्तन का समर्थन करें
• इंस्टेंसिंग के साथ बिल्टिन सामग्री के उपयोग को सरल बनाएं

लेकिन सभी नोड फ़ाइलों के लिए GLTFLoader में निर्भरता जोड़ने का औचित्य साबित करना कठिन है। और शायद अधिक सक्रिय उपयोग के बिना नोड्स को src/* में डालने का औचित्य साबित करना मुश्किल है। मुर्गी का अंडा। मैं

NodeMaterial के लिए दीर्घकालिक योजना को जानना उपयोगी होगा, यह अनुमान लगाने के लिए कि कौन सी विशेषताएं संबंधित हैं (या नहीं हैं) ... क्या इसके लिए और विकास की आवश्यकता है? क्या ऐसी चीजें हैं जो अन्य योगदानकर्ता मदद के लिए कर सकते हैं?

@ सुनग हाँ, मुझे यह जानने के लिए भी उत्सुकता होगी कि क्या इस बिंदु पर आपकी कोई और योजना है।

सिद्धांत रूप में, हम अब कई चीजों के लिए नोड्स का उपयोग कर सकते हैं, जैसे:

• GlTF युक्ति/ग्लॉस PBR सामग्री को NodeStandardSGMaterial के रूप में लागू करें।
• प्रति-मानचित्र यूवी सेट और परिवर्तन का समर्थन करें
• इंस्टेंसिंग के साथ बिल्टिन सामग्री के उपयोग को सरल बनाएं

इन विशेष मुद्दों में अब उदाहरण हैं कि मौजूदा एपीआई के साथ कोर को संशोधित करने की आवश्यकता के बिना कैसे हल किया जाए:

इंस्टेंसिंग:
https://github.com/mrdoob/three.js/pull/10750 (पूर्ण विकसित, कोर को छूता है, लेकिन बंदर-पैच किया जा सकता है)
https://github.com/mrdoob/three.js/pull/14166 (onBeforeCompile के माध्यम से सरल, सामग्री एक्सटेंशन)
https://github.com/mrdoob/three.js/pull/14012 (मोकी-पैचिंग के माध्यम से सरल, पुस्तकालय विस्तार)

प्रति-मानचित्र-यूवी सेट
https://github.com/mrdoob/three.js/pull/14174

कल्पना-चमक अपने स्वयं के वर्ग के रूप में
https://github.com/mrdoob/three.js/pull/14099

शायद यह NodeMaterial को कोर में लाने के लिए तात्कालिकता की भावना को दूर करने का काम कर सकता है :)।

इस विषय का अनुसरण करने वालों के लिए, https://github.com/mrdoob/three.js/pull/14149 में कुछ चर्चा चल रही है

#14149 से धागे में शामिल होना:

tl; dr - NodeMaterial मुझे सामग्री प्रणाली के लिए एक बहुत ही आशाजनक अगला कदम लगता है। मुझे संदेह है कि NodeMaterial को अपनाना वर्तमान में कुछ चीजों द्वारा सीमित है:

• कई अलग-अलग फाइलों को शामिल करने का घर्षण
• एक दृश्य संपादक की कमी
• अपेक्षाकृत कुछ उदाहरण, डॉक्स

मैं इस सवाल को छोड़ दूंगा कि कब/क्या NodeMaterial src/ से @mrdoob और @sunag में होना चाहिए, लेकिन मुझे लगता है कि हमें उपरोक्त तीन मुद्दों को संबोधित करते हुए (कम से कम) आगे बढ़ना चाहिए। यह जानना भी सहायक होगा कि क्या अन्य लोग NodeMaterial को वर्तमान सामग्री प्रणाली या पूर्ण प्रतिस्थापन के विकल्प के रूप में देखते हैं।

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

@pailhead मैंने ए-फ़्रेम में वर्कफ़्लो समस्याओं का समाधान करने के लिए GLTFLoader को बनाए रखना शुरू किया, जिसमें से मैं एक डेवलपर भी हूं। मैं सहमत हूं कि एक अधिक उपयोगी सामग्री प्रणाली लक्ष्य है, किसी विशेष प्रारूप को लोड नहीं करना। नोड सामग्री को एकीकृत (या एकीकृत नहीं) करने का निर्णय तीन.जेएस लाइब्रेरी के अंतिम-उपयोगकर्ताओं के लिए योग्यता पर आधारित होना चाहिए - सुविधाएँ, लचीलापन, एक समझने योग्य एपीआई।

आप सही कह रहे हैं कि onBeforeCompile और onBeforeRender हुक असीम रूप से लचीले हैं; अंतर्निहित शेडर्स को आप कितनी दूर तक हेरफेर या बदल सकते हैं, इसकी कोई व्यावहारिक सीमा नहीं है। लेकिन दोनों प्राथमिक सामग्री एपीआई के समान ही त्रुटिपूर्ण हैं:

1. अपेक्षाकृत सरल सुविधाओं के लिए भी सामग्री API में WebGL सिंटैक्स को बाध्य करता है
2. कोर सामग्री शेडर्स के स्ट्रिंग हेरफेर पर निर्भर करता है, जिससे समय के साथ कोर सामग्री में परिवर्तन कठिन हो जाता है, और अधिक नाजुक हो जाता है
3. कलाकारों के लिए कम पहुंच योग्य
4. व्यावहारिक रूप से अपरिवर्तनीय

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

नोड सामग्री सही नहीं हैं, लेकिन वे अन्य ग्राफिक्स टूल में व्यापक रूप से अपनाई जाती हैं, और इसके प्रमुख लाभ हैं:

1. लचीला और रचना योग्य
2. जहां आवश्यक हो वहां सादे शेड्स तक पहुंच को हटाए बिना पुस्तकालय के आंतरिक वेबजीएल शेडर्स से अमूर्तता की एक परत को संरक्षित करता है
3. कलाकारों और गेम डेवलपर्स के लिए व्यापक रूप से लोकप्रिय सामग्री प्रतिनिधित्व
4. कम से कम कुछ हद तक क्रमबद्ध (हालांकि अन्य प्रारूपों में रूपांतरण अभी भी कठिन है)

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

• कई अलग-अलग फाइलों को शामिल करने का घर्षण

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

स्क्रिप्ट फ़ाइलों को मैन्युअल रूप से शामिल करने पर यह कैसे काम करेगा, इस बारे में चिंता करने के बजाय, मैं पेड़ को हिलाने और import/export ठीक से सक्षम होने के लिए और अधिक प्रयास करूंगा।

• एक दृश्य संपादक की कमी
• अपेक्षाकृत कुछ उदाहरण, डॉक्स

मुझे लगता है कि इसे कोर में आने से पहले ऐसा होना चाहिए। स्पेक्युलर ग्लॉस मटीरियल एक उदाहरण होना चाहिए जो GLTFLoader के साथ युग्मित न हो। तथ्य यह है कि यह /src या /examples में अप्रासंगिक होना चाहिए?

@donmccurdy

आप सही कह रहे हैं कि onBeforeCompile और onBeforeRender हुक असीम रूप से लचीले हैं; अंतर्निहित शेडर्स को आप कितनी दूर तक हेरफेर या बदल सकते हैं, इसकी कोई व्यावहारिक सीमा नहीं है।

मैं वास्तव में इसका दावा नहीं कर रहा हूं, मैं दावा कर रहा हूं कि onBeforeRender जैसा एक हुक संरचना कोड के लिए एक अलग दृष्टिकोण की अनुमति देता है, लेकिन इसका उपयोग नहीं किया जाना चाहिए क्योंकि इसका उपयोग अब GLTFLoader (इसलिए #14099)।

onBeforeCompile निश्चित रूप से सीमाएं हैं, और अनुचित रूप से नामित किया जा सकता है। इस संदर्भ में एक अच्छी बात यह है कि हालिया पीआर #14214 है। जैसे ही मैंने देखा कि क्या हुआ ( build() needsUpdate पक्ष में) मुझे पता था कि मैं वहां onBeforeCompile देखने जा रहा हूं। मैंने इसे onBeforeParse रूप में इस्तेमाल किया क्योंकि अगर मैं किसी भी #include <foo> कथन को प्रतिस्थापित नहीं करता, तो भी वे इस फ़ंक्शन के बाद और वास्तविक संकलन से पहले पार्स हो जाते हैं। इस पीआर में इसे onWillRefreshMaterial रूप में इस्तेमाल किया जा रहा है।

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

#14214 इस बात का एक बेहतरीन उदाहरण है कि NodeMaterial को कोर में क्यों नहीं होना चाहिए। कम से कम /renderer में किसी भी चीज़ के साथ युग्मित नहीं है, और इसके साथ बंडल नहीं किया गया है।

1. अपेक्षाकृत सरल सुविधाओं के लिए भी सामग्री API में WebGL सिंटैक्स को बाध्य करता है

मैंने इस मुद्दे को पहले सुना है लेकिन इस पर विस्तार से नहीं बताया गया था। यह समस्या क्यों है? वैसे भी "सामग्री एपीआई" क्या है? मैंने हमेशा इसे "यहां कुछ सामान्य सतह छायांकन सामग्री" के रूप में देखा है।

यदि आप एक गतिशील नक्शा चाहते हैं, तो मुझे कोई कारण नहीं दिखता कि क्यों material.map , या 'material.color' NodeTexture , GLSLTexture , TextureTexture नहीं ले सका।

myMaterial.color = new SomeNodeGraph() //outputs vec4 in the end

myMaterial.color = new GLSLInput() // inputs various documented variables, outputs some vec4

myMaterial.color = new THREE.Color()

myMaterial.color = new CustomColorGradientTopBottom() // dunno if its Node, GLSL, regular color whatever, i just know it's compatible with the slot

1. कोर सामग्री शेडर्स के स्ट्रिंग हेरफेर पर निर्भर करता है, जिससे समय के साथ कोर सामग्री में परिवर्तन कठिन हो जाता है, और अधिक नाजुक हो जाता है

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

आपके द्वारा बताए गए डेकोरेटर #14206 इस पीआर के कारण एक वर्ष से अधिक समय से रुके हुए हैं, जो स्वयं 3 वर्षों से ठप है। मेरी व्यक्तिपरक भावना यह है कि #14206 इन सज्जाकारों को लिखना संभव, कम थकाऊ और कम नाजुक बना देगा। यह कोड की 30 पंक्तियाँ हैं जो पूरी तरह से किसी भी चीज़ को प्रभावित नहीं करती हैं, जब तक कि इन प्रेत गुणों को परिभाषित नहीं किया जाता है। अगर हमें onBeforeCompile के रूप में खुद को लटकाने के लिए पहले से ही एक रस्सी दी गई है तो इसे थोड़ा और मानवीय क्यों न बनाएं? :मुस्कुराओ:

अंत में, मैं अपने लिए तय करना चाहूंगा कि नाजुक स्तर का स्वीकार्य स्तर क्या है और क्या नहीं।

1. कलाकारों के लिए कम पहुंच योग्य

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

एक कलाकार एक शेडर बना सकता है, एक इंजीनियर इसे "संकलित" करने के लिए कह सकता है ताकि लोडिंग प्रक्रिया को अनुकूलित किया जा सके। अकेले काम करने वाला एक कलाकार ग्राफ को लोड कर सकता है, यह मानते हुए कि यह किसी कारण से आसान है ("संकलित" अधिक प्रयास लेता है)।

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

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

1. व्यावहारिक रूप से अपरिवर्तनीय

मुझे इसके बारे में ज्यादा जानकारी नहीं है और मैंने यह तर्क पहले भी सुना है। अगर कोई मुझे समस्याग्रस्त क्षेत्रों में इंगित कर सकता है तो मुझे कुछ कोड देखने में खुशी होगी। समस्या के बारे में मेरी बहुत सीमित समझ (कोई नहीं के बगल में) के साथ, मुझे समझ में नहीं आता कि यह लिखने के लिए पर्याप्त क्यों नहीं है

"materialFoo": {
  "color":"#ff0000",
  "specularMap": "some_path.jpg",
  "glossiness": "0.5"
}

मान लें कि आपके पास NodeMaterial साथ निर्मित एक स्पेक ग्लॉस सामग्री है, आप पूरे ग्राफ को क्रमबद्ध नहीं करना चाहेंगे, केवल इनपुट? SpecGloss सामग्री का क्रमांकन जो भी हो, उसे वही दिखना चाहिए? मुझे शायद यहां बहुत कुछ याद आ रहा है, कुछ पॉइंटर्स की सराहना करेंगे।

पुन: क्रमांकन

क्या यह जोड़ना पर्याप्त होगा:

https://github.com/mrdoob/three.js/blob/dev/src/materials/Material.js#L160

customSerializer( data )

और फिर कुछ

SpecularGlossMaterial.prototype.toJSON = ()=>{
  Material.prototype.call(this, undefined, data =>{
    if ( this.roughness !== undefined ) data.roughness = this.roughness;
  })
}

specularMap वास्तव में क्रमबद्ध किया जाएगा क्योंकि यह हार्डकोड किया गया है:
https://github.com/mrdoob/three.js/blob/dev/src/materials/Material.js#L213

लेकिन यह थोड़े अजीब लगता है, Material वर्ग सभी अंतर्निर्मित सामग्रियों से आंतरिक के बारे में जानता है जो ऐसा लगता है?

@donmccurdy यदि आप यह चर्चा करना चाहते हैं तो इसे डेकोरेटर पीआर, # 14206 में करना बेहतर हो सकता है। ऑफ़लाइन मैं खाड़ी क्षेत्र में कहीं भी बियर या कॉफी पर एक कार्य सत्र के लिए उपलब्ध हूं: थोड़ा_स्माइलिंग_फेस:

सहमत हैं कि एकाधिक फ़ाइलें _ should't_ घर्षण हो, और यह NodeMaterial को src/ में डालने का तर्क नहीं है। यह केवल कई कारणों में से एक है, NodeMaterial का अभी तक अत्यधिक उपयोग नहीं किया गया है, और इसे हल करने के अन्य तरीके भी हैं। और मैं निश्चित रूप से सहमत हूं कि src/ में NodeMaterial डालने के लिए, या यहां तक ​​​​कि examples/js या एक अलग बिल्ड आउटपुट में गोद लेने को आगे बढ़ाने के लिए अधिक दस्तावेज़ एक शर्त होगी।

मैं सामान्य दिशा के रूप में NodeMaterial बारे में आशावादी हूं, हालांकि मुझे संदेह है कि src/ में समझ में आने से पहले कुछ और चीजों की आवश्यकता है। मैं onBeforeCompile का उपयोग करने के बारे में बहुत चिंतित हूं और सामग्री प्रणाली में नई सुविधाओं को रखने के लिए एक पथ के रूप में स्ट्रिंग हेरफेर, जैसा कि ऊपर वर्णित है, और विशेष रूप से जब हम WebGL2 और (अंततः) WebGPU का समर्थन करने की ओर

दूसरी ओर, ऐसा लगता है कि हम एक-दूसरे की चिंताओं और प्राथमिकताओं को समझते हैं, लेकिन फिर भी असहमत हैं। मैंने वह सब लिखा है जो मेरे पास इस बिंदु पर लिखने के लिए है, और मैं इसे कुछ समय के लिए बाहर बैठूंगा और दूसरों को इसमें शामिल होने दूंगा। इस पर गहन और विनम्र चर्चा के लिए धन्यवाद। मैं

मैं एक फैलाना बनावट पर गुणा के साथ एक परिवेश रोड़ा बनावट रखना चाहता हूं, इसलिए मैं यह कोशिश कर रहा हूं:

const aoNode = new OperatorNode(
        new Math1Node( aoTexture, Math1Node.INVERT ),
        aoScale,
        OperatorNode.MUL
    );
material.ao = aoNode;

यह मेरा एओ बनावट है

दुर्भाग्य से मैं अपने मॉडल पर परिवेश रोड़ा देख रहा हूं।

क्या आपके पास ऐसा करने का कोई विचार है?
आशा है कि यह मेरा प्रश्न पोस्ट करने के लिए सही जगह है।

धन्यवाद!

मैं मौजूदा नोड आधारित टूल से थ्रीजे में सामग्री तक मैपिंग की दिशा में सोचने में सक्षम होना चाहता हूं। नतीजतन मैं एक उचित दस्तावेज के साथ src/ में NodeMaterial देखना पसंद करूंगा।

@आईएआरआई

क्या आप कृपया मौजूदा नोड आधारित उपकरणों की सूची बना सकते हैं?

@donmccurdy

जवाब देने के लिए धन्यवाद :)

दुर्भाग्य से मुझे लगता है कि हम अभी भी एक दूसरे को नहीं समझते हैं। यदि आपके पास इस पोस्ट को पढ़ने का समय है, तो यह सामग्री:

मैं सामग्री प्रणाली में नई सुविधाओं को रखने के लिए पथ के रूप में onBeforeCompile और स्ट्रिंग हेरफेर का उपयोग करने के बारे में बहुत चिंतित हूं,

onBeforeCompile भयानक है, मैं सहमत हूं, इनमें से किसी भी धागे में शामिल होने का एकमात्र कारण यह है कि मैं #13198 चाहता हूं जिसे मैं onBeforeCompile के स्ट्रिंग मैनिपुलेशन से बेहतर मानता हूं।

यह तीन.जेएस में नई सुविधाओं को जोड़ने का पैटर्न नहीं होना चाहिए। इसे उपयोगकर्ताओं को अपने अनुप्रयोगों में नई सुविधाओं को जोड़ने की अनुमति देनी चाहिए। मुझे दुख है कि @bhouston ने इस सामान में से कुछ करने के लिए एक कांटा बनाए रखने पर कोई निष्कर्ष साझा नहीं किया। मुझे उत्सुकता होगी अगर उन्होंने शेडर्स को बदलने के लिए बेहतर ढांचा बनाया है, या वास्तव में इस सुविधा के लिए कोर को हैक कर लिया है।

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

onBeforeCompile ऐसा लगता है कि यह नोड सामग्री के लिए महत्वपूर्ण होगा, https://github.com/mrdoob/three.js/pull/14214 , इसलिए इसका उपयोग केवल स्ट्रिंग हेरफेर के लिए नहीं किया जाता है ।

मेरे पास ऐसा करने के लिए onBeforeCompile और NodeMaterial हैं, मैं तीसरे विकल्प का अनुरोध करता हूं। onBeforeCompile से बहुत अधिक सुविधाजनक और NodeMaterial से बहुत छोटा।

हाल के उदाहरणों के साथ:
https://github.com/mrdoob/three.js/pull/14206

पुरानी चर्चा:
https://github.com/mrdoob/three.js/pull/13198

@pailhead शुरुआत के लिए मैं कुछ बुनियादी ब्लेंडर साइकिल नोड्स के बारे में
मुझे यूनिटी शैडरग्राफ के साथ खेलना भी दिलचस्प लगेगा।

@claudioviola आप material.shadow में जोड़ सकते हैं या फैलाना material.color = diffuse * oclusion गुणा कर सकते हैं। अप्रत्यक्ष प्रकाश की निर्भरता, AmbientLight , HemisphereLight ...

@आईएआरआई

मैं ShaderGraph देखने के लिए 7.5 गीगा यूनिटी डाउनलोड कर रहा हूं: थोड़ा_स्माइलिंग_फेस:: मुझे यकीन नहीं है कि यह शेडर ग्राफ बनाने के लिए एक उपकरण के रूप में योग्य होगा, मुझे लगता है कि यह एकता के लिए शेडर ग्राफ बनाने के लिए एक उपकरण है। क्या ग्राफ़ को संलेखित करने के लिए कोई स्टैंडअलोन उपकरण हैं? मैं एक फ़ाइल की तरह क्या इस ग्राफ भी बचाता है देखना चाहते हैं, और यह कैसे Three.js करने पर स्थानांतरण और होगा NodeMaterial में /src ।

मुझे लगता है कि @pailhead इस वर्तमान बिंदु पर NodeMaterials के कोर में इस कदम के खिलाफ अलगाव में है। मुझे नहीं लगता कि @pailhead के साथ दिनों तक बहस करना सभी के लिए उपयोगी है। मुझे लगता है कि परियोजना को किसी एक व्यक्ति के लिए नहीं देखा जाना चाहिए।

यह जल्दबाजी नहीं की गई है और इसे मजबूर नहीं किया गया है। सुनग ने इस साल पहले जोड़ा था। अभी इसकी आवश्यकता है और अन्य विकल्पों पर काम नहीं हुआ है (जैसे विलय) तो चलिए इस रास्ते को आजमाते हैं।

हर प्रमुख उपकरण, 3DS मैक्स, UE4, ब्लेंडर, यूनिटी, माया, स्केचफैब, शेडर ग्राफ़ का उपयोग करते हैं। यह तर्क देना कि इस संबंध में तीन.जेएस को स्थायी नुकसान होना चाहिए, तीन.जेएस के लिए अनुचित लगता है।

मुझे यकीन नहीं है कि यह ग्राफ-आधारित शेडर सिस्टम इस समय सही है, लेकिन एक बार यह कोर में हो जाने के बाद, हम सभी इसके साथ काम करना जारी रख सकते हैं।

मैं इस बात पर जोर देता हूं कि हम आगे भी किसी न किसी रूप में PhoneMaterial, StandardMaterial, आदि के API का समर्थन करना जारी रखें ताकि हम तीन.js परियोजनाओं में से 95% को न तोड़ें, ऐसा करना गैर-जिम्मेदाराना होगा। ऐसे सरलीकृत सीधे आगे के इंटरफेस के साथ काम करना भी अच्छा है।

मेरे पास न तो क्षमता है और न ही इसे कोर में जाने से रोकने की इच्छा। मुझे उम्मीद है कि यह कुछ असंबंधित पीआर को अनब्लॉक कर सकता है, क्योंकि इसे अवरोधक के रूप में संदर्भित किया गया है। @bhouston , कभी भी आपके साथ बहस करने का मतलब नहीं था, मैं सिर्फ आपके कांटे और इसके अनुभवों के बारे में उत्सुक था।

जब मैं एक भूखे 3डी कलाकार के रूप में अपनी जरूरतों को पूरा करता हूं, तो मुझे नोड आधारित सभी चीजें पसंद हैं। Nuke मेरा पसंदीदा संगीतकार था, और मैं इस तरह के उपकरण बनाना सीखना चाहता हूँ। मैं बस यही चाहता हूं कि यह विशेष रूप से #14231 को अनब्लॉक करे। मैं इसे अपने लिए एक सीखने के मंच के रूप में उपयोग कर रहा हूं, लेकिन अगर यह विघटनकारी है तो मैं पोस्ट करना बंद कर दूंगा, धन्यवाद।

@pailhead मैंने इसके साथ कभी काम नहीं किया है, लेकिन आपने शायद पदार्थ डिजाइनर के बारे में सुना है? जहां तक ​​​​मैं समझता हूं, वह उपकरण ग्राफ/शेडर लिखने से भी आगे जाता है - लेकिन इसका मुख्य रूप से सामग्री के प्रक्रियात्मक डिजाइन पर ध्यान केंद्रित किया जाता है - शायद यह एक दिलचस्प सुराग है?

इसके अलावा, मैं अपने सिर के ऊपर से स्टैंडअलोन टूल नहीं जानता, लेकिन एक त्वरित Google खोज ने इन दोनों को प्राप्त किया:

• https://victhorlopez.github.io/editor/
• http://www.shaderplay.com/products/nodeflex/overview/overview.html
  दिलचस्प लग रहा है।

हालांकि, थ्रीजेएस नोड्स के लिए भी यह टूल है , जो मुझे 2015 से @mrdoob द्वारा एक ट्विटर पोस्ट में मिला - हालांकि ऐसा लगता है कि इसे कभी अपडेट नहीं किया गया है, मुझे आश्चर्य है कि क्यों ....

ऐसा लगता है कि उस उपकरण को यहां संदर्भित किया गया है, लेकिन मुझे कुछ भी निर्यात करने का कोई तरीका नहीं दिख रहा है। पहला लिंक अद्भुत लग रहा है, लेकिन आउटपुट बहुत सुंदर है, जीएलएसएल की तुलना में बहुत पठनीय नहीं है। मुझे आश्चर्य है कि क्या इसका उपयोग पहले से ही NodeMeterial , या यहां तक ​​​​कि ShaderMaterial को फिर से इकट्ठा करने के लिए किया जा सकता है।

मैंने एकता पर एक नज़र डाली, लेकिन मुझे वास्तव में शेडर ग्राफ़ टूल नहीं मिला,

बीटीडब्ल्यू अगर मैंने इसे किसी तरह से ब्लॉक कर दिया है, तो इसे हर तरह से अनब्लॉक कर दें। पीआर 2015 से है, मैंने पहली बार 8 दिन पहले जवाब दिया था।

(क्षमा करें, यह थोड़ा हटकर है ..)
@pailhead For Unity shadergraph: आपको लाइटवेट रेंडर पाइपलाइन टेम्प्लेट के साथ एक यूनिटी प्रोजेक्ट शुरू करने की आवश्यकता है। सुनिश्चित करें कि आप यूनिटी पैकेज मैनेजर खोलते हैं और जांचते हैं कि आप Render-pipelines.light पैकेज के नवीनतम संस्करण का उपयोग कर रहे हैं।
इसे स्थापित करने के लिए एक नया प्रोजेक्ट शुरू करने के लिए यहां एक ट्यूटोरियल है: https://youtu.be/Ar9eIn4z6XE?t=98

वह Sea3D प्रवाह सामग्री नोड संपादक (http://sea3d.poonya.com/flow/) @sunag द्वारा है, वही व्यक्ति जिसने NodeMaterial लिखा था।

बहुत बहुत धन्यवाद @sunag
मैं अप्रत्यक्ष प्रकाश कैसे प्राप्त कर सकता हूं? क्या यह रेंडरर में एक मूल्य है या मैं इसकी गणना कैसे कर सकता हूं?

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

Sea3D प्रवाह सामग्री नोड संपादक तीन.js संपादक के समान ही स्टैंडअलोन होगा, या इसका एक हिस्सा होगा? क्या इसे अब भी Sea3D नाम दिया जाएगा या कुछ और three.js संबंधित? उस दृश्य संपादक को तीन.जेएस समुदाय के लिए जारी करने के लिए @sunag धन्यवाद।

लेकिन मुझे इस बात का जरा सा भी अंदाजा नहीं है कि नोड्स के साथ कैसे संपर्क किया जाए।

@आईएआरआई

ऐसा लगता है कि आप GLSL को जानते हैं क्योंकि आप OutlinePass को पढ़ सकते हैं और समझ सकते हैं कि यह क्या करता है। आप यह देखने के लिए पर्याप्त समझते हैं कि आप इसे नोड्स के साथ प्राप्त नहीं कर सकते हैं। मैंने सोचा कि अगर आप इसे कोड करना जानते हैं, तो आपको पता चल जाएगा कि इसे कैसे नोड करना है। इससे भी अधिक, यदि आप नहीं जानते कि इसे कैसे कोडित किया जाए, तो आप इसे नोड करना जान सकते हैं। डिस्कनेक्ट कहां है?

मैंने 2016 से ये पोस्ट बिल्कुल नहीं देखीं। Shader Frog देखना दिलचस्प है। मुझे आश्चर्य है कि इसे विम बनाम एमएसीएस या कुछ के रूप में देखा जा सकता है। मुझे Sublime Text का इस्तेमाल करना पसंद है, आप कुछ और इस्तेमाल करना पसंद करते हैं। एक को शेडर फ्रॉग का उपयोग करना पसंद है, दूसरे को थ्री.जेएस के सी3डी संपादक का उपयोग करना पसंद है।

मुझे पसंद है कि कैसे शेडर मेंढक सिर्फ एक शेडर आउटपुट करता है, लेकिन यह सागर 3 डी की तरह खुला स्रोत नहीं है।

फिर यह है।

तीसरे पक्ष के उत्पाद यांत्रिकी को थ्री के मूल में रखना एक अनुचित लाभ की तरह लगता है और मैं इसे राजनीतिक रूप से नहीं समझता।

मेरे लिए, तथ्य यह है कि यह सब तीन परिवर्तनों के बिना पूरा किया जा सकता है, इसका मतलब है कि यह अनावश्यक है, और तीन.जेएस के बीच की रेखा को एक वेबग्ल रैपर एपीआई होने और अब कार्यान्वयन विशिष्ट सुविधाओं को चला रहा है। शेडर नोड डेटा संग्रहीत करना अत्यधिक ऐप विशिष्ट है और जहां तक ​​​​मुझे पता है कि वर्तमान में किसी भी सॉफ़्टवेयर के लिए कोई सामान्य नोड संपादक मानक प्रारूप नहीं है? एक को लागू करना दूसरे कार्यान्वयन के लिए हानिकारक हो सकता है।

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

मुझे लगता है कि @pailhead इस वर्तमान बिंदु पर NodeMaterials के कोर में इस कदम के खिलाफ अलगाव में है।
मुझे लगता है कि परियोजना को किसी एक व्यक्ति के लिए नहीं देखा जाना चाहिए।

धन्यवाद।

मुझे कोई कारण नहीं दिख रहा है कि इसे नोड्स के साथ ठीक उसी तरह हासिल नहीं किया जा सकता है जैसा कि आउटलाइनपास करता है - लेकिन एक तरह से जो पठनीय, समझने योग्य और मॉड्यूलर है जैसे कि भागों का पुन: उपयोग किया जा सकता है।
उदाहरण के लिए आउटपुट नोड्स क्यों नहीं होना चाहिए जो बफर और सामान को लिखते हैं।

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

क्या आप वेबपैक या कुछ और इस्तेमाल करते हैं?

बेवकूफ सरणी

यह केवल बेवकूफी है अगर आपको इसे एक .html फ़ाइल में आयात करना है। जब आप वेबपैक के साथ काम करते हैं और आपके पास आधुनिक JS सिंटैक्स होता है, तो आप अपने GLSL को .glsl, .vs, .fs फ़ाइलों में रख सकते हैं और सिंटैक्स हाइलाइटिंग आदि कर सकते हैं।

shader.fs:

void main(){
  gl_FragColor = vec4(1.);
} 

जावास्क्रिप्ट (देखो माँ, कोई बेवकूफ सरणियाँ नहीं)

import mShader from './shader.fs'

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

नोड्स का प्रयोग करें, ल्यूक!

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

@आईएआरआई

क्षमा करें, मैंने किसी भी तरह आपकी पोस्ट में कोई प्रश्न चिह्न नहीं देखा, इसलिए मुझे आपका प्रश्न याद आया।

यह निश्चित रूप से व्यक्तिगत कोडिंग प्राथमिकताओं के बारे में चर्चा नहीं होनी चाहिए, लेकिन इस तथ्य पर विचार किया जाना चाहिए कि अलग-अलग हैं। मैं "मैं यह शेडर कैसे बनाऊं" प्रश्नों की हड़बड़ी के बारे में थोड़ा चिंतित हूं।

पहले, यह बार काफी ऊंचा था, लोग बस i don't know glsl या जब वे "स्ट्रिंग्स में एक बेवकूफ सरणी" देखते हैं तो छोड़ देते हैं। लेकिन अगर यह कम है, तो हर कोई शेड्स लिखने की कोशिश करेगा।

मुझे आपका प्रश्न नहीं मिला, लेकिन मैं उत्सुक हूं कि यह क्या है। क्या यह:

मैं नोडमटेरियल के साथ टूनशैडर कैसे बना सकता हूं?

इस मामले में मैं उत्सुक हूं कि उत्तर क्या है।

आप नहीं कर सकते क्योंकि NodeMaterial कुछ अमूर्तता का समर्थन नहीं करता है।
आप नोड्स को जोड़ने के लिए, बस NodeMaterial का उपयोग कर सकते हैं

हो सकता है कि इस चर्चा को टूटने से फायदा हो? यह पदों की एक उच्च संख्या है, वास्तव में बहुत पीछे (2015)। NodeMaterial /examples में है, इसलिए आप शायद इससे अपना टून शेडर बना सकते हैं। हो सकता है कि आप विशेष रूप से स्टैक ओवरफ़्लो पर कोई अन्य मुद्दा या पोस्ट खोल सकें, और शेष बातचीत एक नए मुद्दे पर जा सकती है?

हम खुशी-खुशी इस चर्चा को कहीं और ले जा सकते हैं, जैसे कोई सुस्त चैनल या जो कुछ भी - मुझे वास्तव में लगता है कि यह यहां नहीं है, लेकिन ज्यादातर लोगों को परेशान करेगा।

इस विशेष मामले के लिए मंच सुस्त से बेहतर हो सकता है।

@pailhead , यह पूरी चर्चा उत्पादक होने से पटरी से उतर गई है। साथ ही इस मुद्दे को बंद कर सकते हैं और वास्तविक मुद्दे पर ध्यान केंद्रित एक नया बना सकते हैं।

@भूस्टन

सहमत, सिवाय इसके कि मुझे लगता है कि यह कई मुद्दे हैं।

• नोडमटेरियल को कैसे लागू करें
• क्या अन्य संबंधित और असंबंधित पीआर को अवरुद्ध किया जाना चाहिए
• उन लोगों को कैसे अनुमति दें जो कुछ शेडर प्रभावों को लागू करने के लिए शेडर लिखना नहीं जानते हैं

मैं नोडमटेरियल के साथ टूनशैडर कैसे बना सकता हूं?
इस मामले में मैं उत्सुक हूं कि उत्तर क्या है।
आप नहीं कर सकते क्योंकि NodeMaterial कुछ अमूर्तता का समर्थन नहीं करता है।
आप नोड्स को जोड़ने के लिए, बस NodeMaterial का उपयोग कर सकते हैं

ज़ोर - ज़ोर से हंसना। मैं @bhouston से सहमत हूं... यह केवल एक मजाक हो सकता है। आपके कहने से पहले आप उदाहरण webgl_materials_nodes देख सकते थे?

और यदि आप कोड का उपयोग करना चाहते हैं, तो FunctionNode का उपयोग करके अभिव्यक्ति देखें।

@ सुनग मुझे लगता है कि आपने मुझे गलत समझा। मैं उत्सुक था कि क्यों, यदि यह वर्तमान में /examples और /src है तो क्या इसे प्रथम श्रेणी का नागरिक बनाया जा रहा है। ऐसा लगता है कि यह मुद्दा 2015 में @AndrewRayCode द्वारा उठाया गया था।

मैंने अभी कहा है कि यह मुद्दा अतिभारित है, 2015 में बहुत पहले से और विभिन्न विभिन्न विषयों पर चर्चा करने से। अगर किसी ने पूछा "मैं whatever " तो उन्हें स्टैक ओवरफ्लो के लिए संदर्भित किया जाएगा।

अगर यह तीन.जेएस _ (तथ्य यह है कि एकता को विशेष रूप से इसके लिए कॉन्फ़िगर किया जाना है, मुझे कुछ हद तक डराता है) का एक बड़ा ओवरहाल होने जा रहा है, तो मुझे लगता है कि इस तरह के सवालों के लिए जीथब पर समर्पित एक जारी मुद्दा होना चाहिए - usage of NodeMaterial . जैसा कि, जो लोग यादृच्छिक चीजें मांग रहे हैं (# 14232) इस धागे को संदर्भित किया जा रहा है, यह संचार को गन्दा बनाता है :)

मुझे हाल ही में एक टून शेडर लिखना था, लेकिन यह लाइनों पर आधारित था, और विशेष रूप से @WestLangley की मोटी रेखाएं। तो यहां तक ​​​​कि "तून" शेडर खान की आवश्यकता के साथ भी पूरी तरह से अलग होता। इसमें वसा लाइनों को NodeMaterial पोर्ट करना भी शामिल होगा जो कि कौन जानता है कि कितना समय लग सकता है। ये सभी विभिन्न विषय हैं जो यहां जटिल हैं।

और यदि आप कोड का उपयोग करना चाहते हैं, तो FunctionNode का उपयोग करके अभिव्यक्ति देखें।

अगर मैं कोड करता हूं तो मैं उत्कृष्ट पाठ का उपयोग करूंगा, ShaderMaterial मेरे लिए ठीक है FunctionNode की कोई आवश्यकता नहीं है। अगर मैं दृश्य प्रभाव बनाता हूं, तो शायद मैं एक दृश्य संपादक को देखूंगा, लेकिन यह मेरी अपनी प्राथमिकता है। मैं यहां केवल इसलिए हूं क्योंकि इसने अन्य पीआर को अवरुद्ध कर दिया है :) मुझे बहुत पहले नहीं पता चला है कि यह वास्तव में जितनी जल्दी हो सके उतरने के लिए तीनों के सर्वोत्तम हित में है। इस बातचीत को सुलझाने से शायद जल्दबाज़ी में मदद मिलेगी। इसमें मैं @bhouston से सहमत हूं, यह जल्द योलॉड होना चाहिए!

धन्यवाद।

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

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

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

अस्वीकरण: मैं कुछ भी नहीं मांग रहा हूं, बस ऊपर से मेरे अस्पष्ट अनुरोध को स्पष्ट करने की उम्मीद है।
यहां किए जा रहे सभी कार्यों के लिए आप सभी का धन्यवाद - यह बिल्कुल अद्भुत है।

मुझसे नोड-आधारित शेडर कार्यान्वयन पर टिप्पणी करने के लिए https://github.com/mrdoob/three.js/issues/14232 थ्रेड में पूछा गया था। मुझे लगता है कि यह बहुत गरीब है। मुझे यह विचार पसंद है, लेकिन मेरे विचार से कार्यान्वयन पूरी तरह से अपर्याप्त है, इसलिए, चूंकि मैं इतना नकारात्मक हूं, इसलिए मैं कुछ ठोस कारण बताने जा रहा हूं।

understandability

नोड्स और विभिन्न उपयोगिता वर्गों के लिए कुछ कोड पढ़ने के बाद - मैं निश्चित रूप से कह सकता हूं कि इसे समझना एक बड़ी चुनौती है।

• चर नाम गैर-वर्णनात्मक हैं
• कोई टिप्पणी नहीं
• विधि के नाम अस्पष्ट या सर्वथा भ्रामक हैं। (उदाहरण के लिए आपको क्या लगता है कि विधि "बिल्ड" क्या करती है? - अनुमान लगाएं)

कोड संरचना सर्वथा अजीब है। इस स्निपेट पर विचार करें:
https://github.com/mrdoob/three.js/blob/e2b49c017b2d1f37ab34317033a27df7b5a71d4d/examples/js/nodes/FunctionNode.js#L39 -L50

आप इसके साथ ही हासिल कर सकते हैं:

return this.inputs.find(input => input.name === name);

"आकस्मिक वास्तुकला"

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

चिंताओ का विभाजन

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

• एक ग्राफ बनाएं
• मान्य
• मध्यवर्ती प्रतिनिधित्व बनाएँ
• अनुकूलन
• GLSL . को संकलित करें

यह बिल्कुल भी नहीं है जो आपको वर्तमान कोड में मिलेगा।

निष्कर्ष

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

@Usnul हम कभी भी थ्री.जेएस में इस तरह कोड नहीं करेंगे "इसे लौटाएं। इनपुट। ढूंढें (इनपुट => इनपुट। नाम === नाम);"

कारण यह है कि "=>" एक फ़ंक्शन बनाता है जिसे प्रत्येक इनपुट पर कॉल किया जाना चाहिए। फॉर-लूप या जबकि-लूप की तुलना में जावास्क्रिप्ट में फ़ंक्शन कॉल बहुत धीमी हैं। इस प्रकार हम हमेशा कॉलबैक ओरिएंटेड कोड के बजाय स्पष्ट लूप करते हैं। मुझे पता है कि यह अधिक क्रियात्मक है लेकिन यह आवश्यक है। All of Three..JS इस तरह और उद्देश्य पर है।

@ उस्नुल , आपकी डिज़ाइन संबंधी चिंताएँ बहुत उपयोगी हैं, क्या आप कुछ रिफैक्टरिंग में मदद कर सकते हैं? मुझे लगता है कि हर कोई आपके डिजाइन इनपुट और योगदान की सराहना करेगा। :)

कारण यह है कि "=>" एक फ़ंक्शन बनाता है जिसे प्रत्येक इनपुट पर कॉल किया जाना चाहिए। फॉर-लूप या जबकि-लूप की तुलना में जावास्क्रिप्ट में फ़ंक्शन कॉल बहुत धीमी हैं। इस प्रकार हम हमेशा कॉलबैक ओरिएंटेड कोड के बजाय स्पष्ट लूप करते हैं। मुझे पता है कि यह अधिक क्रियात्मक है लेकिन यह आवश्यक है। All of Three..JS इस तरह और उद्देश्य पर है।

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

for(var i=0, count=array.length; i<count; i++){
    var element = array[i];
    ...
}

या मान लें कि आपके पास कोड का एक टुकड़ा है जो फ़ॉर्म की 50 पंक्तियाँ लंबी है:

function complex(a){
  if(a){
      //do a ton of stuff
      ...
      return result;
  }
}

यह उतना पठनीय नहीं है जितना:

function complex(a){
  if(!a){
      //omg! not A?!11 
      return;
  }
  //do a ton of stuff
  ...
  return result;
}

@Usnul क्या आप इन्हें ध्यान में रखने के लिए कोड को

@usnul अगर आपको यह पसंद नहीं है तो आप इसे
मुझे नहीं पता कि अगर रेफ्रेक्टर्स होना चाहिए, जबकि यह उदाहरणों में है (या संभवतः एक और रेपो) या इसे सीधे स्रोत पर ले जाया जाना चाहिए क्योंकि @bhouston सुझाव दे रहा है।

@आईएआरआई

मैं वास्तव में glsl को बहुत अच्छी तरह से नहीं जानता , और मुझे यह भी लगता है - मेरे शब्दों को क्षमा करें - गधे में एक

लेकिन मुझे जो पता है ,

मैं यह दावा नहीं कर सकता कि मैं जीएलएसएल को भी अच्छी तरह जानता हूं, लेकिन मैं इसे अपनी समस्याओं को हल करने के लिए पर्याप्त जानता हूं। मैं जो जानता हूं, उससे मैं ज्यादातर सहमत हूं कि @usnul ने यहां क्या लिखा है, और @AndrewRayCode ने पहले क्या लिखा है। मुझे GLSL की तुलना में नोड चीज़

यदि आप जीएलएसएल को नहीं जानते हैं तो मुझे लगता है कि इसकी तुलना किसी और चीज से करना बहुत कठिन होगा। जैसा कि आपने इसे स्वयं लिखा है, यदि हम judge on what you know , और आपने इसे स्वयं you don't know glsl मुझे लगता है कि आपका इनपुट एक अस्वीकरण के साथ लिया जाना चाहिए :)

यह ऐसा है जैसे मैंने कहा:

जापान इस ग्रह पर सबसे खराब जगह है... लेकिन मैं वास्तव में कभी जापान नहीं गया"।

धन्यवाद।

विधि के नाम अस्पष्ट या सर्वथा भ्रामक हैं। (उदाहरण के लिए आपको क्या लगता है कि विधि "बिल्ड" क्या करती है? - अनुमान लगाएं)

वाह, मुझे यह भी एहसास नहीं हुआ कि यह नीचे ShaderMaterial है। मेरा अनुमान है कि यह सभी चीजें करता है जो THREE.WebGLRenderer शेडर टेम्पलेट्स के साथ करता है।

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

@pailhead उसका क्या मतलब है कि चीजों के बीच मध्यवर्ती स्तर हैं।

मुझे समझ में नहीं आता कि यह अलार्म क्यों है। @mrdoob कभी भी एक महान समाधान के अलावा कुछ और विलय नहीं करेगा। सभी महान पीआर, NodeMaterial में किसी से भी सुधार समुदाय के लिए बहुत उपयोगी हैं। यदि यह अभी भी मूल में विलय नहीं हुआ है, तो ऐसा इसलिए है क्योंकि हमें और अधिक काम के साथ सुधार करने की आवश्यकता है।

@ सुनग क्या इस परियोजना में आपकी मदद करने के लिए अन्य लोग कुछ खास कर सकते हैं? यदि आप दस्तावेज़ों के लिए तैयार हैं और उनकी समीक्षा कर सकते हैं, तो मैं दस्तावेज़ीकरण लिखने को तैयार हूँ।

@ सुनग क्या इस परियोजना में आपकी मदद करने के लिए अन्य लोग कुछ खास कर सकते हैं? यदि आप दस्तावेज़ों के लिए तैयार हैं और उनकी समीक्षा कर सकते हैं, तो मैं दस्तावेज़ीकरण लिखने को तैयार हूँ।

यह बहुत अच्छा होगा। निस्संदेह बहुत मदद करता है।

नोड आधारित सामग्री प्रणाली अद्भुत लगती है, यह अभिव्यक्ति की शक्ति का विस्तार करेगी।

हम मौजूदा सामग्री प्रणाली से कोर में नोड आधारित सामग्री प्रणाली में कैसे स्विच करेंगे? क्या हम दोनों दो प्रणालियों को बदल देंगे या मौजूदा एक को नोड एक से बदल देंगे?

क्षमा करें, शायद मुझे नहीं लगता कि मैं इस धागे को पकड़ पा रहा हूँ क्योंकि यह धागा बहुत बड़ा है...

क्या हम दोनों दो प्रणालियों को बदल देंगे या मौजूदा एक को नोड एक से बदल देंगे?

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

डब्ल्यूआईपी https://github.com/mrdoob/three.js/pull/14333

मुझे अपने प्रोजेक्ट में शैडोमैप दिखाना है।

मेरे पास एक दिशात्मक प्रकाश और 2 ज्यामिति वाला एक दृश्य है जो MeshStandardNodeMaterial का उपयोग कर रहा है।

मैंने स्विच ऑन कर दिया है
कास्टशैडो = प्रकाश के लिए सत्य
दोनों वस्तुओं के लिए कास्टशैडो और रिसीविंग शैडो।
छाया सक्षम = रेंडरर के लिए सही

यह काम क्यों नहीं करता?
क्या मुझे MeshStandardNodeMaterial की छाया संपत्ति का उपयोग करना है? क्या यही उद्देश्य है?

कोई मुझे मदद कर सकता है?
धन्यवाद!

@claudioviola
समर्थन प्रश्न स्टैक ओवरफ्लो के मंच पर जाते हैं।

@sunag क्या आपको लगता है कि NodeMaterial पर्याप्त स्थिर है इसलिए हम टाइपस्क्रिप्ट घोषणा फाइल प्रदान करने के साथ शुरू कर सकते हैं? यदि आप निकट भविष्य में बड़े एपीआई परिवर्तनों की योजना नहीं बना रहे हैं, तो मैं इस कार्य से शुरू करूंगा क्योंकि NodeMaterial बिना TS समर्थन वाले मॉड्यूल का अंतिम समूह है।

@sunag क्या आपको लगता है कि NodeMaterial पर्याप्त रूप से स्थिर है इसलिए हम टाइपस्क्रिप्ट डिक्लेरेशन फाइल प्रदान करने के साथ शुरुआत कर सकते हैं? यदि आप निकट भविष्य में बड़े एपीआई परिवर्तनों की योजना नहीं बना रहे हैं, तो मैं इस कार्य से शुरू करूंगा क्योंकि NodeMaterial बिना TS समर्थन वाले मॉड्यूल का अंतिम समूह है।

@ Mugen87 हां, परिवर्तनों की तुलना में अधिक परिवर्धन होना चाहिए। Add TS सपोर्ट बहुत अच्छा होगा। मैं

ठीक है, TS समर्थन अगली रिलीज़ के साथ तैयार है R017