मैं एक फ़ंक्शन लिखने की कोशिश कर रहा हूं जो माउस की स्थिति को XOZ (ग्राउंड प्लेन) पर एक समन्वय बिंदु पर एक ज्यामिति बनाने के लिए अनुवाद करेगा। समस्या यह है: सूत्र सही नहीं लगता। एक कैमरा पॉइंट (0, 0, 0, 1) को व्यूमैट्रिक्स से गुणा किया जाता है, जिसके परिणामस्वरूप (0, 0, 0) पॉइंट होता है। मैंने पहले ही lookAt() मैट्रिक्स से camEye को एक बिंदु के रूप में उपयोग करने का प्रयास किया है, लेकिन यह काम नहीं करता है। मुझे इसे कैसे कार्यान्वित करना चाहिए?

यहां एक कोड स्निपेट है:

    def screenToWorld(self, mouse_pos: QtGui.QVector2D):
        tmp = QtGui.QVector4D(
            2.0 * mouse_pos.x() / self.width() - 1.0,
            -2.0 * mouse_pos.y() / self.height() + 1.0,
            -1.0, 1.0
        )
        i_tmp = QtGui.QVector4D(
            (tmp * self.camera.projectionMatrix.inverted()[0]).toVector2D(), -1.0, 0.0
        )
        direction = QtGui.QVector3D(
            (i_tmp * self.camera.viewMatrix.inverted()[0]).toVector3D().normalized()
        )
        cam_pos = QtGui.QVector3D(
            (QtGui.QVector4D(0.0, 0.0, 0.0, 1.0) * self.camera.viewMatrix.inverted()[0]).toVector3D()
        )

        normal = QtGui.QVector3D(0.0, 1.0, 0.0)
        t = -QtGui.QVector3D.dotProduct(cam_pos, normal) / QtGui.QVector3D.dotProduct(direction, normal)
        result = cam_pos + direction * t

        return result

यहां एक तस्वीर है जिसे मैं हासिल करना चाहता हूं: यहां छवि विवरण दर्ज करें

0
Artem 7 अक्टूबर 2020, 14:18

1 उत्तर

सबसे बढ़िया उत्तर

ठीक है, मुझे आखिरकार मिल गया! समस्या गलत कैमरा स्थिति में थी। जैसा कि मैंने पढ़ा है, हम इसे उल्टे view matrix से प्राप्त कर सकते हैं। सूचकांकों वाले तत्व 41, 42, 43 हमारे कैमरे की स्थिति होगी, इसलिए मैंने हर बार कैमरा चलने पर एक क्लास वेरिएबल अपडेट किया:

self.__camPos = self.__viewMatrix.inverted()[0].column(3).toVector3D()

उसके बाद, सब कुछ एक आकर्षण की तरह काम करता है:

    def createRayDir(self, mouse_pos: QVector2D):
        # Normalized Coordinate Space
        x = 2.0 * mouse_pos.x() / self.__viewportSize.x() - 1
        y = 2.0 * mouse_pos.y() / self.__viewportSize.y() - 1

        clip = QVector4D(x, -y, -1.0, 1.0)
        proj = QVector4D((clip * self.__projectionMatrix.inverted()[0]).toVector2D(), -1.0, 0.0)

        return (proj * self.__viewMatrix).toVector3D().normalized()

    def getRayGridIntersecton(self, mouse_pos: QVector2D):
        ray_dir = self.createRayDir(mouse_pos)

        n = QVector3D(0.0, 1.0, 0.0)
        t = -QVector3D.dotProduct(self.__camPos, n) / QVector3D.dotProduct(ray_dir, n)

        return self.__camPos + ray_dir * t
0
Artem 12 अक्टूबर 2020, 10:29