घुमावदार आयताकार

Question

हेई दोस्तों के शीर्षकों की गणना, मैं घुमावदार आयताकार (2 डी) के शीर्षकों की गणना करने की कोशिश कर रहा हूं।

आयताकार घुमाया नहीं गया है, तो यह इतना आसान है, मैंने उस भाग को समझ लिया।

यदि आयताकार घुमाया गया है, तो मैंने शिखर की गणना करने के दो संभावित तरीकों के बारे में सोचा। 1) चित्रित करें कि स्थानीय स्थान पर स्थानीय/ऑब्जेक्ट/मॉडल स्पेस (जिन्हें मैंने नीचे निकाला है) से शिखर को कैसे परिवर्तित किया जाए। मुझे ईमानदारी से कोई सुराग नहीं है, और यदि यह सबसे अच्छा तरीका है तो मुझे लगता है कि अगर मैं इसे समझ सकता हूं तो मैं उससे बहुत कुछ सीखूंगा ...

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

यहाँ समारोह है कि कोने अब तक की गणना करता है, किसी भी मदद

void Rect::calculateVertices() 
{ 
    if(m_orientation == 0) // if no rotation 
    { 
     setVertices(
     &Vertex((m_position.x - (m_width/2) * m_scaleX), (m_position.y + (m_height/2) * m_scaleY), m_position.z), 
     &Vertex((m_position.x + (m_width/2) * m_scaleX), (m_position.y + (m_height/2) * m_scaleY), m_position.z), 
     &Vertex((m_position.x + (m_width/2) * m_scaleX), (m_position.y - (m_height/2) * m_scaleY), m_position.z), 
     &Vertex((m_position.x - (m_width/2) * m_scaleX), (m_position.y - (m_height/2) * m_scaleY), m_position.z)); 
    } 
    else 
    { 
     // if the rectangle has been rotated.. 
    } 

    //GLfloat theta = RAD_TO_DEG(atan(((m_width/2) * m_scaleX)/((m_height/2) * m_scaleY))); 
    //LOG->writeLn(&theta); 

} 

Answer 1

मैं सिर्फ प्रत्येक बिंदु परिणत हो गया, हर एक के लिए एक ही रोटेशन मैट्रिक्स को लागू करने के लिए धन्यवाद है। यदि यह एक 2 डी प्लानर रोटेशन है, यह इस तरह दिखेगा:

x' = x*cos(t) - y*sin(t) 
y' = x*sin(t) + y*cos(t) 

जहां (एक्स, वाई) मूल अंक, कर रहे हैं (एक्स ', वाई') घुमाया निर्देशांक हैं, और टी कोण में मापा जाता है एक्स-अक्ष से रेडियंस। घूर्णन लिखित रूप में विपरीत दिशा में है।

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

Answer 2

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

// Get the original/default vertex angles 
GLfloat vertex1_theta = RAD_TO_DEG(atan(
      (m_height/2 * m_scaleY) 
      /(m_width/2 * m_scaleX))); 
GLfloat vertex2_theta = -vertex1_theta; // lower right vertex 
GLfloat vertex3_theta = vertex1_theta - 180; // lower left vertex 
GLfloat vertex4_theta = 180 - vertex1_theta; // upper left vertex 

// Now get the rotated vertex angles 
vertex1_theta += rotation_angle; 
vertex2_theta += rotation_angle; 
vertex3_theta += rotation_angle; 
vertex4_theta += rotation_angle; 

//Calculate the distance from the center (same for each vertex) 
GLfloat r = sqrt(pow(m_width/2*m_scaleX, 2) + pow(m_height/2*m_scaleY, 2)); 

/* Calculate each vertex (I'm not familiar with OpenGL, DEG_TO_RAD 
* might be a constant instead of a macro) 
*/ 
vertexN_x = m_position.x + cos(DEG_TO_RAD(vertexN_theta)) * r; 
vertexN_y = m_position.y + sin(DEG_TO_RAD(vertexN_theta)) * r; 

// Now you would draw the rectangle, proceeding from vertex1 to vertex4. 

जाहिर है अधिक, आवश्यकता से longwinded स्पष्टता के लिए। बेशक, एक रूपांतरण मैट्रिक्स का उपयोग करके डफिमो का समाधान शायद अधिक सुरुचिपूर्ण और कुशल है :)

संपादित करें: अब मेरा कोड वास्तव में काम करना चाहिए। मैंने (width/height) से (height/width) बदल दिया और शिखर की गणना करने के लिए आयताकार के केंद्र से लगातार त्रिज्या का उपयोग किया। http://pastebin.com/f1c76308c