8cbbdedaf4
This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
126 lines
2.8 KiB
C++
126 lines
2.8 KiB
C++
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#ifndef __BLI_FLOAT4X4_HH__
|
|
#define __BLI_FLOAT4X4_HH__
|
|
|
|
#include "BLI_float3.hh"
|
|
#include "BLI_math_matrix.h"
|
|
|
|
namespace blender {
|
|
|
|
struct float4x4 {
|
|
float values[4][4];
|
|
|
|
float4x4() = default;
|
|
|
|
float4x4(const float *matrix)
|
|
{
|
|
memcpy(values, matrix, sizeof(float) * 16);
|
|
}
|
|
|
|
float4x4(const float matrix[4][4]) : float4x4((float *)matrix)
|
|
{
|
|
}
|
|
|
|
operator float *()
|
|
{
|
|
return (float *)this;
|
|
}
|
|
|
|
operator const float *() const
|
|
{
|
|
return (const float *)this;
|
|
}
|
|
|
|
friend float4x4 operator*(const float4x4 &a, const float4x4 &b)
|
|
{
|
|
float4x4 result;
|
|
mul_m4_m4m4(result.values, a.values, b.values);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* This also applies the translation on the vector. Use `m.ref_3x3() * v` if that is not
|
|
* intended.
|
|
*/
|
|
friend float3 operator*(const float4x4 &m, const float3 &v)
|
|
{
|
|
float3 result;
|
|
mul_v3_m4v3(result, m.values, v);
|
|
return result;
|
|
}
|
|
|
|
friend float3 operator*(const float4x4 &m, const float (*v)[3])
|
|
{
|
|
return m * float3(v);
|
|
}
|
|
|
|
float4x4 inverted() const
|
|
{
|
|
float result[4][4];
|
|
invert_m4_m4(result, values);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Matrix inversion can be implemented more efficiently for affine matrices.
|
|
*/
|
|
float4x4 inverted_affine() const
|
|
{
|
|
BLI_assert(values[0][3] == 0.0f && values[1][3] == 0.0f && values[2][3] == 0.0f &&
|
|
values[3][3] == 1.0f);
|
|
return this->inverted();
|
|
}
|
|
|
|
struct float3x3_ref {
|
|
const float4x4 &data;
|
|
|
|
friend float3 operator*(const float3x3_ref &m, const float3 &v)
|
|
{
|
|
float3 result;
|
|
mul_v3_mat3_m4v3(result, m.data.values, v);
|
|
return result;
|
|
}
|
|
};
|
|
|
|
float3x3_ref ref_3x3() const
|
|
{
|
|
return {*this};
|
|
}
|
|
|
|
static float4x4 interpolate(const float4x4 &a, const float4x4 &b, float t)
|
|
{
|
|
float result[4][4];
|
|
interp_m4_m4m4(result, a.values, b.values, t);
|
|
return result;
|
|
}
|
|
|
|
uint64_t hash() const
|
|
{
|
|
uint64_t h = 435109;
|
|
for (int i = 0; i < 16; i++) {
|
|
float value = ((const float *)this)[i];
|
|
h = h * 33 + (*(uint32_t *)&value);
|
|
}
|
|
return h;
|
|
}
|
|
};
|
|
|
|
} // namespace blender
|
|
|
|
#endif /* __BLI_FLOAT4X4_HH__ */
|