Multiply vec3 mit MAT4 GLM mit

Question

Im Moment konvertiere ich die vec3-vec4, multipliziere es mit der Matrix, und es dann zu vec3 zurückgeworfen

Code:

glm::vec3 transformed = glm::vec3(matrix * glm::vec4(point, 0.0)) 

Es funktioniert, aber Ich denke, es ist nicht der beste Weg, es zu berechnen. Ist es möglich, einen mat4 auf einen vec3 anzuwenden, ohne ihn auf vec4 und zurück zu werfen?

Answer 1

Wenn mit OpenGL arbeiten, ist es sehr ratsam, mit homogeneous coordinates zu bleiben. Für 3D-Raum sind dies 4D-Vektoren, wobei normalerweise das vierte Element gleich 1 ist. Wenn Sie dies tun, sind alle Ihre Berechnungen im 4-dimensionalen Raum, so dass keine Konvertierungen benötigt werden.

Beachten Sie auch, dass Sie in Ihrem Beispiel tatsächlich jede Übersetzung verlieren, die in der Transformationsmatrix aufgezeichnet wurde. Wenn Sie dies beibehalten möchten, müssen Sie 1 für das vierte Element und nicht für 0 verwenden.

Appendix F of the Red Book beschreibt, wie und warum homogene Koordinaten in OpenGL verwendet werden.

Answer 2

mat4 ist eine 4 mal 4-Matrix, Sie benötigen also einen 4-dimensionalen Vektor, um ihn zu multiplizieren.

Die vierte Dimension für 3D Mathe wirklich nützlich ist, zwischen 3D-Raum Punkten (1) und 3D-Vektoren (0)

Hier sind fehle viele Betreiber zu unterscheiden, aber ich hoffe, dass Sie die Idee.

class point3 
{ 
public: 
    vec4 p; 

public: 
    point3(); 
    point3(const point3& rhs); 
    point3(const point3& rhs); 
    point3(float x, float y, float z); 
    point3& operator=(const point3&rhs); 
    vector3 operator-(const point3&rhs); 
    point3 operator+(const vector3&rhs); 
    point3& operator+=(const vector3&rhs); 
}; 

point3::point3():p.x(0), p.y(0), p.z(0), p.w(1) 
{ 

} 
point3::point3(const point3& rhs):p(rhs.p) 
{ 

} 
point3::point3(const point3& rhs):p(rhs.p) 
{ 

} 
point3::point3(float x, float y, float z):p.x(x), p.y(y), p.z(z), p.w(1) 
{ 

} 
point3& point3::operator=(const point3&rhs) 
{ 
    return (p=rhs.p); 
} 
vector3 point3::operator-(const point3&rhs) 
{ 
    vector3 result; 
    result.p=(p-rhs.p); 
    return result; 
} 
point3 point3::operator+(const vector3&rhs) 
{ 
    point3 result; 
    result.p=(p+rhs.p); 
    return result; 
} 
point3& point3::operator+=(const vector3&rhs) 
{ 
    p=(p+rhs.p); 
    return p; 
} 

class vector3 
{ 
public: 
    vec4 p; 

public: 
    vector3(); 
    vector3(const vector3& rhs); 
    vector3(const vector3& rhs); 
    vector3(float x, float y, float z); 
    vector3& operator=(const vector3&rhs); 
    vector3 operator-(const vector3&rhs); 
    point3 operator-(const point3&rhs); 
    point3 operator+(const point3&rhs); 
    vector3 operator+(const vector3&rhs); 
    vector3& operator+=(const vector3&rhs); 
}; 
vector3::vector3():p.x(0), p.y(0), p.z(0), p.w(0) 
{ 
} 
vector3::vector3(const vector3& rhs):p(rhs.p) 
{ 
} 
vector3::vector3(const vector3& rhs):p(rhs.p) 
{ 
} 
vector3::vector3(float x, float y, float z):p.x(x), p.y(y), p.z(z), p.w(0) 
{ 
} 
vector3& vector3::operator=(const vector3&rhs) 
{ 
    p=rhs.p; 
    return p; 
} 
vector3 vector3::operator-(const vector3&rhs) 
{ 
    vector3 result; 
    result.p=(p-rhs.p); 
    return result; 
} 
point3 vector3::operator-(const point3&rhs) 
{ 
    point3 result; 
    result.p=(p-rhs.p); 
    return result; 
} 
point3 vector3::operator+(const point3&rhs) 
{ 
    point3 result; 
    result.p=(p+rhs.p); 
    return result; 
} 
vector3 vector3::operator+(const vector3&rhs) 
{ 
    vector3 result; 
    result.p=(p+rhs.p); 
    return result; 
} 
vector3& vector3::operator+=(const vector3&rhs) 
{ 
    p=(p+rhs.p); 
    return p; 
}