StdMeshMath.h

Go to the documentation of this file.

/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2011-2016, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
 
#ifndef INC_StdMeshMath
#define INC_StdMeshMath
 
// OGRE mesh
 
struct StdMeshVector
{
    float x, y, z;
 
    static StdMeshVector Zero();
    static StdMeshVector UnitScale();
    static StdMeshVector Translate(float dx, float dy, float dz);
    static StdMeshVector Cross(const StdMeshVector& lhs, const StdMeshVector& rhs);
 
    void Normalize();
};
 
 
struct StdMeshVertex
{
    static const size_t MaxBoneWeightCount = 8;
 
    // Match GL_T2F_N3F_V3F
    float u{0}, v{0};
    float nx{0}, ny{0}, nz{0};
    float x{0}, y{0}, z{0};
 
    float bone_weight[MaxBoneWeightCount];
    uint16_t bone_index[MaxBoneWeightCount];
 
    char _padding[16];
 
    StdMeshVertex()
    {
        std::uninitialized_fill(std::begin(bone_weight), std::end(bone_weight), 0);
        std::uninitialized_fill(std::begin(bone_index), std::end(bone_index), 0);
        std::uninitialized_fill(std::begin(_padding), std::end(_padding), 0);
    }
};
static_assert((sizeof(StdMeshVertex) & 31) == 0, "StdMeshVertex should be a multiple of 32 bytes");
 
struct StdMeshQuaternion
{
    float w;
    float x, y, z;
 
    static StdMeshQuaternion Zero();
    static StdMeshQuaternion AngleAxis(float theta, const StdMeshVector& axis);
 
    float LenSqr() const { return w*w+x*x+y*y+z*z; }
    void Normalize();
 
    static StdMeshQuaternion Nlerp(const StdMeshQuaternion& lhs, const StdMeshQuaternion& rhs, float w);
};
 
struct StdMeshTransformation
{
    StdMeshVector scale;
    StdMeshQuaternion rotate;
    StdMeshVector translate;
 
    static StdMeshTransformation Zero();
    static StdMeshTransformation Identity();
    static StdMeshTransformation Inverse(const StdMeshTransformation& transform);
    static StdMeshTransformation Translate(float dx, float dy, float dz);
    static StdMeshTransformation Scale(float sx, float sy, float sz);
    static StdMeshTransformation Rotate(float angle, float rx, float ry, float rz);
 
    // TODO: Might add path parameter if necessary
    static StdMeshTransformation Nlerp(const StdMeshTransformation& lhs, const StdMeshTransformation& rhs, float w);
};
 
class StdMeshMatrix
{
public:
    static const int NColumns = 4;
    static const int NRows = 3;
 
    static StdMeshMatrix Zero();
    static StdMeshMatrix Identity();
    static StdMeshMatrix Inverse(const StdMeshMatrix& mat);
    static StdMeshMatrix Translate(float dx, float dy, float dz);
    static StdMeshMatrix Scale(float sx, float sy, float sz);
    static StdMeshMatrix Rotate(float angle, float rx, float ry, float rz);
    static StdMeshMatrix Transform(const StdMeshTransformation& transform);
    static StdMeshMatrix TransformInverse(const StdMeshTransformation& transform);
    static StdMeshMatrix LookAt(const StdMeshVector& eye, const StdMeshVector& center, const StdMeshVector& up);
 
    float& operator()(int i, int j) { return a[i][j]; }
    float operator()(int i, int j) const { return a[i][j]; }
 
    float Determinant() const;
    StdMeshTransformation Decompose() const;
 
    const float* data() const { return &a[0][0]; }
 
private:
    // 3x3 orthogonal + translation in last column
    float a[3][4];
};
 
// Full 4x4 matrix with projection components
class StdProjectionMatrix
{
public:
    static const int NColumns = 4;
    static const int NRows = 4;
 
    static StdProjectionMatrix Identity();
    static StdProjectionMatrix Translate(float dx, float dy, float dz);
    static StdProjectionMatrix Scale(float sx, float sy, float sz);
    static StdProjectionMatrix Rotate(float angle, float rx, float ry, float rz);
 
    static StdProjectionMatrix Orthographic(float left, float right, float bottom, float top);
 
    static StdMeshMatrix Upper3x4(const StdProjectionMatrix& matrix);
 
    float& operator()(int i, int j) { return a[i][j]; }
    float operator()(int i, int j) const { return a[i][j]; }
 
    const float* data() const { return &a[0][0]; }
private:
    float a[4][4];
};
 
StdMeshMatrix operator*(const StdMeshMatrix& lhs, const StdMeshMatrix& rhs);
StdMeshMatrix operator*(float lhs, const StdMeshMatrix& rhs);
StdMeshMatrix operator*(const StdMeshMatrix& lhs, float rhs);
StdMeshMatrix& operator*=(StdMeshMatrix& lhs, const StdMeshMatrix& rhs);
StdMeshMatrix operator+(const StdMeshMatrix& lhs, const StdMeshMatrix& rhs);
 
StdProjectionMatrix operator*(const StdProjectionMatrix& lhs, const StdProjectionMatrix& rhs);
StdProjectionMatrix& operator*=(StdProjectionMatrix& lhs, const StdProjectionMatrix& rhs);
 
StdMeshQuaternion operator-(const StdMeshQuaternion& rhs);
StdMeshQuaternion operator*(const StdMeshQuaternion& lhs, const StdMeshQuaternion& rhs);
StdMeshQuaternion& operator*=(StdMeshQuaternion& lhs, float rhs);
StdMeshQuaternion operator*(const StdMeshQuaternion& lhs, float rhs);
StdMeshQuaternion operator*(float lhs, const StdMeshQuaternion& rhs);
StdMeshQuaternion& operator+=(StdMeshQuaternion& lhs, const StdMeshQuaternion& rhs);
StdMeshQuaternion operator+(const StdMeshQuaternion& lhs, const StdMeshQuaternion& rhs);
StdMeshQuaternion operator-(const StdMeshQuaternion& lhs, const StdMeshQuaternion& rhs);
StdMeshTransformation operator*(const StdMeshTransformation& lhs, const StdMeshTransformation& rhs);
 
StdMeshVector operator-(const StdMeshVector& rhs);
StdMeshVector& operator+=(StdMeshVector& lhs, const StdMeshVector& rhs);
StdMeshVector operator+(const StdMeshVector& lhs, const StdMeshVector& rhs);
StdMeshVector& operator-=(StdMeshVector& lhs, const StdMeshVector& rhs);
StdMeshVector operator-(const StdMeshVector& lhs, const StdMeshVector& rhs);
StdMeshVector operator*(const StdMeshVector& lhs, const StdMeshVector& rhs);
StdMeshVector& operator*=(StdMeshVector& lhs, float rhs);
StdMeshVector operator*(const StdMeshVector& lhs, float rhs);
StdMeshVector operator*(float lhs, const StdMeshVector& rhs);
StdMeshVector operator/(const StdMeshVector& lhs, const StdMeshVector& rhs);
StdMeshVector operator/(float lhs, const StdMeshVector& rhs);
StdMeshVector operator/(const StdMeshVector& lhs, float rhs);
 
StdMeshVector operator*(const StdMeshMatrix& lhs, const StdMeshVector& rhs); // does not apply translation part
StdMeshVector operator*(const StdMeshQuaternion& lhs, const StdMeshVector& rhs);
 
StdMeshVertex& operator+=(StdMeshVertex& lhs, const StdMeshVertex& rhs);
StdMeshVertex operator+(const StdMeshVertex& lhs, const StdMeshVertex& rhs);
StdMeshVertex operator*(float lhs, const StdMeshVertex& rhs);
StdMeshVertex operator*(const StdMeshVertex& lhs, float rhs);
StdMeshVertex operator*(const StdMeshMatrix& lhs, const StdMeshVertex& rhs);
 
// Multiply in-place the given matrix with a translation matrix to the right
template<typename MatrixType>
void Translate(MatrixType& mat, float dx, float dy, float dz)
{
    static_assert(MatrixType::NColumns >= 4, "Matrix must have at least 4 columns");
 
    for (int i = 0; i < MatrixType::NRows; ++i)
        mat(i, 3) += mat(i,0)*dx + mat(i,1)*dy + mat(i,2)*dz;
}
 
// Multiply in-place the given matrix with a scale matrix to the right
template<typename MatrixType>
void Scale(MatrixType& mat, float sx, float sy, float sz)
{
    static_assert(MatrixType::NColumns >= 3, "Matrix must have at least 3 columns");
 
    for (int i = 0; i < MatrixType::NRows; ++i)
    {
        mat(i, 0) *= sx;
        mat(i, 1) *= sy;
        mat(i, 2) *= sz;
    }
}
 
// Multiply in-place the given matrix with a rotation matrix to the right
template<typename MatrixType>
void Rotate(MatrixType& mat, float angle, float x, float y, float z)
{
    mat *= MatrixType::Rotate(angle, x, y, z);
}
 
// Multiply in-place the given matrix with a perspective projection matrix to the right
template<typename MatrixType>
void Perspective(MatrixType& mat, float cot_fovy2, float aspect, float nearVal, float farVal)
{
    static_assert(MatrixType::NColumns >= 4, "Matrix must have at least 4 columns");
 
    const float fa = cot_fovy2 / aspect;
    const float fb = cot_fovy2;
    const float z1 = (nearVal + farVal) / (nearVal - farVal);
    const float z2 = 2 * nearVal * farVal / (nearVal - farVal);
 
    for (int i = 0; i < MatrixType::NRows; ++i)
    {
        const float mat2 = mat(i, 2);
        mat(i, 0) *= fa;
        mat(i, 1) *= fb;
        mat(i, 2) = mat2 * z1 - mat(i, 3);
        mat(i, 3) = mat2 * z2;
    }
}
 
#endif