// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
|
#ifndef Matrix_hpp
|
#define Matrix_hpp
|
|
namespace sw
|
{
|
struct Vector;
|
struct Point;
|
struct float4;
|
|
struct Matrix
|
{
|
Matrix();
|
Matrix(const int i);
|
Matrix(const float m[16]);
|
Matrix(const float m[4][4]);
|
Matrix(float m11, float m12, float m13,
|
float m21, float m22, float m23,
|
float m31, float m32, float m33);
|
Matrix(float m11, float m12, float m13, float m14,
|
float m21, float m22, float m23, float m24,
|
float m31, float m32, float m33, float m34,
|
float m41, float m42, float m43, float m44);
|
Matrix(const Vector &v1, const Vector &v2, const Vector &v3); // Column vectors
|
|
Matrix &operator=(const Matrix &N);
|
|
// Row major order
|
float m[4][4];
|
|
static Matrix diag(float m11, float m22, float m33, float m44);
|
|
operator float*();
|
|
Matrix operator+() const;
|
Matrix operator-() const;
|
|
Matrix operator!() const; // Inverse
|
Matrix operator~() const; // Transpose
|
|
Matrix &operator+=(const Matrix &N);
|
Matrix &operator-=(const Matrix &N);
|
Matrix &operator*=(float s);
|
Matrix &operator*=(const Matrix &N);
|
Matrix &operator/=(float s);
|
|
float *operator[](int i); // Access element [row][col], starting with [0][0]
|
const float *operator[](int i) const;
|
|
float &operator()(int i, int j); // Access element (row, col), starting with (1, 1)
|
const float &operator()(int i, int j) const;
|
|
friend bool operator==(const Matrix &M, const Matrix &N);
|
friend bool operator!=(const Matrix &M, const Matrix &N);
|
|
friend Matrix operator+(const Matrix &M, const Matrix &N);
|
friend Matrix operator-(const Matrix &M, const Matrix &N);
|
friend Matrix operator*(float s, const Matrix &M);
|
friend Matrix operator*(const Matrix &M, const Matrix &N);
|
friend Matrix operator/(const Matrix &M, float s);
|
|
float4 operator*(const float4 &v) const;
|
|
static float det(const Matrix &M);
|
static float det(float m11);
|
static float det(float m11, float m12,
|
float m21, float m22);
|
static float det(float m11, float m12, float m13,
|
float m21, float m22, float m23,
|
float m31, float m32, float m33);
|
static float det(float m11, float m12, float m13, float m14,
|
float m21, float m22, float m23, float m24,
|
float m31, float m32, float m33, float m34,
|
float m41, float m42, float m43, float m44);
|
static float det(const Vector &v1, const Vector &v2, const Vector &v3);
|
static float det3(const Matrix &M);
|
|
static float tr(const Matrix &M);
|
|
Matrix &orthogonalise(); // Gram-Schmidt orthogonalisation of 3x3 submatrix
|
|
static Matrix eulerRotate(const Vector &v);
|
static Matrix eulerRotate(float x, float y, float z);
|
|
static Matrix translate(const Vector &v);
|
static Matrix translate(float x, float y, float z);
|
|
static Matrix scale(const Vector &v);
|
static Matrix scale(float x, float y, float z);
|
|
static Matrix lookAt(const Vector &v);
|
static Matrix lookAt(float x, float y, float z);
|
};
|
}
|
|
#include "Vector.hpp"
|
|
namespace sw
|
{
|
inline Matrix::Matrix()
|
{
|
}
|
|
inline Matrix::Matrix(const int i)
|
{
|
const float s = (float)i;
|
|
Matrix &M = *this;
|
|
M(1, 1) = s; M(1, 2) = 0; M(1, 3) = 0; M(1, 4) = 0;
|
M(2, 1) = 0; M(2, 2) = s; M(2, 3) = 0; M(2, 4) = 0;
|
M(3, 1) = 0; M(3, 2) = 0; M(3, 3) = s; M(3, 4) = 0;
|
M(4, 1) = 0; M(4, 2) = 0; M(4, 3) = 0; M(4, 4) = s;
|
}
|
|
inline Matrix::Matrix(const float m[16])
|
{
|
Matrix &M = *this;
|
|
M(1, 1) = m[0]; M(1, 2) = m[1]; M(1, 3) = m[2]; M(1, 4) = m[3];
|
M(2, 1) = m[4]; M(2, 2) = m[5]; M(2, 3) = m[6]; M(2, 4) = m[7];
|
M(3, 1) = m[8]; M(3, 2) = m[8]; M(3, 3) = m[10]; M(3, 4) = m[11];
|
M(4, 1) = m[12]; M(4, 2) = m[13]; M(4, 3) = m[14]; M(4, 4) = m[15];
|
}
|
|
inline Matrix::Matrix(const float m[4][4])
|
{
|
Matrix &M = *this;
|
|
M[0][0] = m[0][0]; M[0][1] = m[0][1]; M[0][2] = m[0][2]; M[0][3] = m[0][3];
|
M[1][0] = m[1][0]; M[1][1] = m[1][1]; M[1][2] = m[1][2]; M[1][3] = m[1][3];
|
M[2][0] = m[2][0]; M[2][1] = m[2][1]; M[2][2] = m[2][2]; M[2][3] = m[2][3];
|
M[3][0] = m[3][0]; M[3][1] = m[3][1]; M[3][2] = m[3][2]; M[3][3] = m[3][3];
|
}
|
|
inline Matrix::Matrix(float m11, float m12, float m13,
|
float m21, float m22, float m23,
|
float m31, float m32, float m33)
|
{
|
Matrix &M = *this;
|
|
M(1, 1) = m11; M(1, 2) = m12; M(1, 3) = m13; M(1, 4) = 0;
|
M(2, 1) = m21; M(2, 2) = m22; M(2, 3) = m23; M(2, 4) = 0;
|
M(3, 1) = m31; M(3, 2) = m32; M(3, 3) = m33; M(3, 4) = 0;
|
M(4, 1) = 0; M(4, 2) = 0; M(4, 3) = 0; M(4, 4) = 1;
|
}
|
|
inline Matrix::Matrix(float m11, float m12, float m13, float m14,
|
float m21, float m22, float m23, float m24,
|
float m31, float m32, float m33, float m34,
|
float m41, float m42, float m43, float m44)
|
{
|
Matrix &M = *this;
|
|
M(1, 1) = m11; M(1, 2) = m12; M(1, 3) = m13; M(1, 4) = m14;
|
M(2, 1) = m21; M(2, 2) = m22; M(2, 3) = m23; M(2, 4) = m24;
|
M(3, 1) = m31; M(3, 2) = m32; M(3, 3) = m33; M(3, 4) = m34;
|
M(4, 1) = m41; M(4, 2) = m42; M(4, 3) = m43; M(4, 4) = m44;
|
}
|
|
inline Matrix::Matrix(const Vector &v1, const Vector &v2, const Vector &v3)
|
{
|
Matrix &M = *this;
|
|
M(1, 1) = v1.x; M(1, 2) = v2.x; M(1, 3) = v3.x; M(1, 4) = 0;
|
M(2, 1) = v1.y; M(2, 2) = v2.y; M(2, 3) = v3.y; M(2, 4) = 0;
|
M(3, 1) = v1.z; M(3, 2) = v2.z; M(3, 3) = v3.z; M(3, 4) = 0;
|
M(4, 1) = 0; M(4, 2) = 0; M(4, 3) = 0; M(4, 4) = 1;
|
}
|
|
inline Matrix &Matrix::operator=(const Matrix &N)
|
{
|
Matrix &M = *this;
|
|
M(1, 1) = N(1, 1); M(1, 2) = N(1, 2); M(1, 3) = N(1, 3); M(1, 4) = N(1, 4);
|
M(2, 1) = N(2, 1); M(2, 2) = N(2, 2); M(2, 3) = N(2, 3); M(2, 4) = N(2, 4);
|
M(3, 1) = N(3, 1); M(3, 2) = N(3, 2); M(3, 3) = N(3, 3); M(3, 4) = N(3, 4);
|
M(4, 1) = N(4, 1); M(4, 2) = N(4, 2); M(4, 3) = N(4, 3); M(4, 4) = N(4, 4);
|
|
return M;
|
}
|
|
inline float *Matrix::operator[](int i)
|
{
|
return m[i];
|
}
|
|
inline const float *Matrix::operator[](int i) const
|
{
|
return m[i];
|
}
|
|
inline float &Matrix::operator()(int i, int j)
|
{
|
return m[i - 1][j - 1];
|
}
|
|
inline const float &Matrix::operator()(int i, int j) const
|
{
|
return m[i - 1][j - 1];
|
}
|
}
|
|
#endif // Matrix_hpp
|
