स्रोत इंजन स्टाइल रस्सी रेंडरिंग

Question

मैं एक 3 डी ग्राफिक्स इंजन बना रहा हूं और आवश्यकताओं में से एक रस्सी है जो वाल्व के स्रोत इंजन में व्यवहार करती है।

तो स्रोत इंजन में, रस्सी का एक वर्ग एक क्वाड होता है जो कैमरे का सामना करने के लिए इसकी दिशा धुरी के साथ घूमता है, इसलिए यदि रस्सी का वर्ग + जेड दिशा में है, तो यह ज़ेड अक्ष के साथ घुमाएगा, इसलिए यह है चेहरा कैमरे की केंद्र स्थिति का सामना कर रहा है।

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

मैं पहले से ही इस billboarding तकनीक पर आधारित बोर्ड स्प्राइट प्रतिपादन के लिए एक मैट्रिक्स है: Constructing a Billboard Matrix और इस समय मैं यह रीटूल करने ताकि ठीक है, ऊपर, फॉरवर्ड वेक्टर रस्सी खंड की दिशा वेक्टर से मेल की कोशिश कर रहा हूँ।

मेरी रस्सी कई वर्गों से बना है, प्रत्येक खंड दो त्रिकोणों से बना आयताकार है, जैसा कि मैंने ऊपर कहा है, मैं स्थिति और वर्गों को सही प्राप्त कर सकता हूं, यह कैमरे का सामना करने के लिए घूर्णन कर रहा है जिससे मुझे बहुत कुछ मिल रहा है समस्याओं का

यह ओपन ES2 में है और सी

में

मैं Model_beam.cpp में डूम 3 की किरण प्रतिपादन कोड का अध्ययन किया है लिखा है, विधि का इस्तेमाल किया वहाँ normals के आधार पर ऑफसेट गणना करने के लिए नहीं बल्कि मैट्रिक्स का उपयोग करने से है, इसलिए मैं मेरे सी कोड में एक समान तकनीक बनाई है और यह काम करता है, कम से कम यह, उतना ही काम करता है जितना मुझे इसकी आवश्यकता है।

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

आगे की मदद बहुत अच्छी होगी हालांकि यह सही नहीं है!

धन्यवाद

Answer 1

चेक बाहर this related stackoverflow post on billboards in OpenGL यह हवाला देते एक lighthouse3d ट्यूटोरियल एक बहुत अच्छा पढ़ा है। यहाँ तकनीक की मुख्य बिंदु निम्न हैं:

void billboardCylindricalBegin(
       float camX, float camY, float camZ, 
       float objPosX, float objPosY, float objPosZ) { 

     float lookAt[3],objToCamProj[3],upAux[3]; 
     float modelview[16],angleCosine; 

     glPushMatrix(); 

    // objToCamProj is the vector in world coordinates from the 
    // local origin to the camera projected in the XZ plane 
     objToCamProj[0] = camX - objPosX ; 
     objToCamProj[1] = 0; 
     objToCamProj[2] = camZ - objPosZ ; 

    // This is the original lookAt vector for the object 
    // in world coordinates 
     lookAt[0] = 0; 
     lookAt[1] = 0; 
     lookAt[2] = 1; 


    // normalize both vectors to get the cosine directly afterwards 
     mathsNormalize(objToCamProj); 

    // easy fix to determine wether the angle is negative or positive 
    // for positive angles upAux will be a vector pointing in the 
    // positive y direction, otherwise upAux will point downwards 
    // effectively reversing the rotation. 

     mathsCrossProduct(upAux,lookAt,objToCamProj); 

    // compute the angle 
     angleCosine = mathsInnerProduct(lookAt,objToCamProj); 

    // perform the rotation. The if statement is used for stability reasons 
    // if the lookAt and objToCamProj vectors are too close together then 
    // |angleCosine| could be bigger than 1 due to lack of precision 
     if ((angleCosine < 0.99990) && (angleCosine > -0.9999)) 
      glRotatef(acos(angleCosine)*180/3.14,upAux[0], upAux[1], upAux[2]); 
    }