Skip to content

Commit

Permalink
Death to tabs
Browse files Browse the repository at this point in the history
  • Loading branch information
@oneup03
oneup03 committed Sep 19, 2024
1 parent 26dda47 commit a2b417a
Show file tree
Hide file tree
Showing 8 changed files with 1,112 additions and 1,112 deletions.
160 changes: 80 additions & 80 deletions README.md
View file

Large diffs are not rendered by default.

164 changes: 82 additions & 82 deletions utils/vrmath/vrmath.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,72 +25,72 @@ static const vr::HmdVector3_t HmdVector3_Backward = { 0, 0, 1.f };
template < class T >
vr::HmdQuaternion_t HmdQuaternion_FromMatrix( const T &matrix )
{
vr::HmdQuaternion_t q{};
vr::HmdQuaternion_t q{};

q.w = sqrt( fmax( 0, 1 + matrix.m[ 0 ][ 0 ] + matrix.m[ 1 ][ 1 ] + matrix.m[ 2 ][ 2 ] ) ) / 2;
q.x = sqrt( fmax( 0, 1 + matrix.m[ 0 ][ 0 ] - matrix.m[ 1 ][ 1 ] - matrix.m[ 2 ][ 2 ] ) ) / 2;
q.y = sqrt( fmax( 0, 1 - matrix.m[ 0 ][ 0 ] + matrix.m[ 1 ][ 1 ] - matrix.m[ 2 ][ 2 ] ) ) / 2;
q.z = sqrt( fmax( 0, 1 - matrix.m[ 0 ][ 0 ] - matrix.m[ 1 ][ 1 ] + matrix.m[ 2 ][ 2 ] ) ) / 2;
q.w = sqrt( fmax( 0, 1 + matrix.m[ 0 ][ 0 ] + matrix.m[ 1 ][ 1 ] + matrix.m[ 2 ][ 2 ] ) ) / 2;
q.x = sqrt( fmax( 0, 1 + matrix.m[ 0 ][ 0 ] - matrix.m[ 1 ][ 1 ] - matrix.m[ 2 ][ 2 ] ) ) / 2;
q.y = sqrt( fmax( 0, 1 - matrix.m[ 0 ][ 0 ] + matrix.m[ 1 ][ 1 ] - matrix.m[ 2 ][ 2 ] ) ) / 2;
q.z = sqrt( fmax( 0, 1 - matrix.m[ 0 ][ 0 ] - matrix.m[ 1 ][ 1 ] + matrix.m[ 2 ][ 2 ] ) ) / 2;

q.x = copysign( q.x, matrix.m[ 2 ][ 1 ] - matrix.m[ 1 ][ 2 ] );
q.y = copysign( q.y, matrix.m[ 0 ][ 2 ] - matrix.m[ 2 ][ 0 ] );
q.z = copysign( q.z, matrix.m[ 1 ][ 0 ] - matrix.m[ 0 ][ 1 ] );
q.x = copysign( q.x, matrix.m[ 2 ][ 1 ] - matrix.m[ 1 ][ 2 ] );
q.y = copysign( q.y, matrix.m[ 0 ][ 2 ] - matrix.m[ 2 ][ 0 ] );
q.z = copysign( q.z, matrix.m[ 1 ][ 0 ] - matrix.m[ 0 ][ 1 ] );

return q;
return q;
}

static vr::HmdQuaternion_t HmdQuaternion_FromSwingTwist( const vr::HmdVector2_t &swing, const float twist )
{
vr::HmdQuaternion_t result{};
vr::HmdQuaternion_t result{};

const float swing_squared = swing.v[ 0 ] * swing.v[ 0 ] + swing.v[ 1 ] * swing.v[ 1 ];
const float swing_squared = swing.v[ 0 ] * swing.v[ 0 ] + swing.v[ 1 ] * swing.v[ 1 ];

if ( swing_squared > 0.f )
{
const float theta_swing = std::sqrt( swing_squared );
if ( swing_squared > 0.f )
{
const float theta_swing = std::sqrt( swing_squared );

const float cos_half_theta_swing = std::cos( theta_swing * 0.5f );
const float cos_half_theta_twist = std::cos( twist * 0.5f );
const float cos_half_theta_swing = std::cos( theta_swing * 0.5f );
const float cos_half_theta_twist = std::cos( twist * 0.5f );

const float sin_half_theta_twist = std::sin( twist * 0.5f );
const float sin_half_theta_twist = std::sin( twist * 0.5f );

const float sin_half_theta_swing_over_theta = std::sin( theta_swing * 0.5f ) / theta_swing;
const float sin_half_theta_swing_over_theta = std::sin( theta_swing * 0.5f ) / theta_swing;

result.w = cos_half_theta_swing * cos_half_theta_twist;
result.w = cos_half_theta_swing * cos_half_theta_twist;

result.x = cos_half_theta_swing * sin_half_theta_twist;
result.x = cos_half_theta_swing * sin_half_theta_twist;

result.y = ( swing.v[ 1 ] * cos_half_theta_twist * sin_half_theta_swing_over_theta ) - ( swing.v[ 0 ] * sin_half_theta_twist * sin_half_theta_swing_over_theta );
result.y = ( swing.v[ 1 ] * cos_half_theta_twist * sin_half_theta_swing_over_theta ) - ( swing.v[ 0 ] * sin_half_theta_twist * sin_half_theta_swing_over_theta );

result.z = ( swing.v[ 0 ] * cos_half_theta_twist * sin_half_theta_swing_over_theta ) + ( swing.v[ 1 ] * sin_half_theta_twist * sin_half_theta_swing_over_theta );
}
else
{
float half_twist = twist * 0.5f;
float cos_half_twist = cos( half_twist );
float sin_half_twist = sin( half_twist );
float sin_half_theta_over_theta = 0.5f;
result.z = ( swing.v[ 0 ] * cos_half_theta_twist * sin_half_theta_swing_over_theta ) + ( swing.v[ 1 ] * sin_half_theta_twist * sin_half_theta_swing_over_theta );
}
else
{
float half_twist = twist * 0.5f;
float cos_half_twist = cos( half_twist );
float sin_half_twist = sin( half_twist );
float sin_half_theta_over_theta = 0.5f;

result.w = cos_half_twist;
result.x = sin_half_twist;
result.y = ( swing.v[ 1 ] * cos_half_twist * sin_half_theta_over_theta ) - ( swing.v[ 0 ] * sin_half_twist * sin_half_theta_over_theta );
result.z = ( swing.v[ 0 ] * cos_half_twist * sin_half_theta_over_theta ) + ( swing.v[ 1 ] * sin_half_twist * sin_half_theta_over_theta );
}
result.w = cos_half_twist;
result.x = sin_half_twist;
result.y = ( swing.v[ 1 ] * cos_half_twist * sin_half_theta_over_theta ) - ( swing.v[ 0 ] * sin_half_twist * sin_half_theta_over_theta );
result.z = ( swing.v[ 0 ] * cos_half_twist * sin_half_theta_over_theta ) + ( swing.v[ 1 ] * sin_half_twist * sin_half_theta_over_theta );
}

return result;
return result;
}

static vr::HmdQuaternion_t HmdQuaternion_Normalize( const vr::HmdQuaternion_t &q )
{
vr::HmdQuaternion_t result{};
double n = sqrt( q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w );
vr::HmdQuaternion_t result{};
double n = sqrt( q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w );

result.w = q.w / n;
result.x = q.x / n;
result.y = q.y / n;
result.z = q.z / n;
result.w = q.w / n;
result.x = q.x / n;
result.y = q.y / n;
result.z = q.z / n;

return result;
return result;
}

static vr::HmdQuaternion_t HmdQuaternion_FromEulerAngles(double roll, double pitch, double yaw) {
Expand All @@ -112,104 +112,104 @@ static vr::HmdQuaternion_t HmdQuaternion_FromEulerAngles(double roll, double pit

vr::HmdQuaternion_t QuaternionFromAxisAngle(float x, float y, float z, float angle)
{
vr::HmdQuaternion_t quat;
float halfAngle = angle / 2.0f;
float sinHalfAngle = sin(halfAngle);
vr::HmdQuaternion_t quat;
float halfAngle = angle / 2.0f;
float sinHalfAngle = sin(halfAngle);

quat.w = cos(halfAngle);
quat.x = x * sinHalfAngle;
quat.y = y * sinHalfAngle;
quat.z = z * sinHalfAngle;
quat.w = cos(halfAngle);
quat.x = x * sinHalfAngle;
quat.y = y * sinHalfAngle;
quat.z = z * sinHalfAngle;

return quat;
return quat;
}

template < class T, class Q >
void HmdQuaternion_ConvertQuaternion( const T &in_quaternion, Q &out_quaternion )
{
out_quaternion.w = in_quaternion.w;
out_quaternion.x = in_quaternion.x;
out_quaternion.y = in_quaternion.y;
out_quaternion.z = in_quaternion.z;
out_quaternion.w = in_quaternion.w;
out_quaternion.x = in_quaternion.x;
out_quaternion.y = in_quaternion.y;
out_quaternion.z = in_quaternion.z;
}

static vr::HmdQuaternion_t operator-( const vr::HmdQuaternion_t &q )
{
return { q.w, -q.x, -q.y, -q.z };
return { q.w, -q.x, -q.y, -q.z };
}

static vr::HmdQuaternion_t operator*( const vr::HmdQuaternion_t &lhs, const vr::HmdQuaternion_t &rhs )
{
return {
lhs.w * rhs.w - lhs.x * rhs.x - lhs.y * rhs.y - lhs.z * rhs.z,
lhs.w * rhs.x + lhs.x * rhs.w + lhs.y * rhs.z - lhs.z * rhs.y,
lhs.w * rhs.y - lhs.x * rhs.z + lhs.y * rhs.w + lhs.z * rhs.x,
lhs.w * rhs.z + lhs.x * rhs.y - lhs.y * rhs.x + lhs.z * rhs.w,
};
return {
lhs.w * rhs.w - lhs.x * rhs.x - lhs.y * rhs.y - lhs.z * rhs.z,
lhs.w * rhs.x + lhs.x * rhs.w + lhs.y * rhs.z - lhs.z * rhs.y,
lhs.w * rhs.y - lhs.x * rhs.z + lhs.y * rhs.w + lhs.z * rhs.x,
lhs.w * rhs.z + lhs.x * rhs.y - lhs.y * rhs.x + lhs.z * rhs.w,
};
}

static vr::HmdVector3_t HmdVector3_From34Matrix( const vr::HmdMatrix34_t &matrix )
{
return { matrix.m[ 0 ][ 3 ], matrix.m[ 1 ][ 3 ], matrix.m[ 2 ][ 3 ] };
return { matrix.m[ 0 ][ 3 ], matrix.m[ 1 ][ 3 ], matrix.m[ 2 ][ 3 ] };
}


static vr::HmdVector3_t operator+( const vr::HmdMatrix34_t &matrix, const vr::HmdVector3_t &vec )
{
vr::HmdVector3_t vector{};
vr::HmdVector3_t vector{};

vector.v[ 0 ] = matrix.m[ 0 ][ 3 ] + vec.v[ 0 ];
vector.v[ 1 ] = matrix.m[ 1 ][ 3 ] + vec.v[ 1 ];
vector.v[ 2 ] = matrix.m[ 2 ][ 3 ] + vec.v[ 2 ];
vector.v[ 0 ] = matrix.m[ 0 ][ 3 ] + vec.v[ 0 ];
vector.v[ 1 ] = matrix.m[ 1 ][ 3 ] + vec.v[ 1 ];
vector.v[ 2 ] = matrix.m[ 2 ][ 3 ] + vec.v[ 2 ];

return vector;
return vector;
}

static vr::HmdVector3_t operator*( const vr::HmdMatrix33_t &matrix, const vr::HmdVector3_t &vec )
{
vr::HmdVector3_t result{};
vr::HmdVector3_t result{};

result.v[ 0 ] = matrix.m[ 0 ][ 0 ] * vec.v[ 0 ] + matrix.m[ 0 ][ 1 ] * vec.v[ 1 ] + matrix.m[ 0 ][ 2 ] * vec.v[ 2 ];
result.v[ 1 ] = matrix.m[ 1 ][ 0 ] * vec.v[ 0 ] + matrix.m[ 1 ][ 1 ] * vec.v[ 1 ] + matrix.m[ 1 ][ 2 ] * vec.v[ 2 ];
result.v[ 2 ] = matrix.m[ 2 ][ 0 ] * vec.v[ 0 ] + matrix.m[ 2 ][ 1 ] * vec.v[ 1 ] + matrix.m[ 2 ][ 2 ] * vec.v[ 2 ];
result.v[ 0 ] = matrix.m[ 0 ][ 0 ] * vec.v[ 0 ] + matrix.m[ 0 ][ 1 ] * vec.v[ 1 ] + matrix.m[ 0 ][ 2 ] * vec.v[ 2 ];
result.v[ 1 ] = matrix.m[ 1 ][ 0 ] * vec.v[ 0 ] + matrix.m[ 1 ][ 1 ] * vec.v[ 1 ] + matrix.m[ 1 ][ 2 ] * vec.v[ 2 ];
result.v[ 2 ] = matrix.m[ 2 ][ 0 ] * vec.v[ 0 ] + matrix.m[ 2 ][ 1 ] * vec.v[ 1 ] + matrix.m[ 2 ][ 2 ] * vec.v[ 2 ];

return result;
return result;
}

static vr::HmdVector3_t operator-( const vr::HmdVector3_t &vec, const vr::HmdMatrix34_t &matrix )
{
return { vec.v[ 0 ] - matrix.m[ 0 ][ 3 ], vec.v[ 1 ] - matrix.m[ 1 ][ 3 ], vec.v[ 2 ] - matrix.m[ 2 ][ 3 ] };
return { vec.v[ 0 ] - matrix.m[ 0 ][ 3 ], vec.v[ 1 ] - matrix.m[ 1 ][ 3 ], vec.v[ 2 ] - matrix.m[ 2 ][ 3 ] };
}

static vr::HmdVector3d_t operator+( const vr::HmdVector3d_t &vec1, const vr::HmdVector3d_t &vec2 )
{
return { vec1.v[ 0 ] + vec2.v[ 0 ], vec1.v[ 1 ] + vec2.v[ 1 ], vec1.v[ 2 ] + vec2.v[ 2 ] };
return { vec1.v[ 0 ] + vec2.v[ 0 ], vec1.v[ 1 ] + vec2.v[ 1 ], vec1.v[ 2 ] + vec2.v[ 2 ] };
}


static vr::HmdVector3_t operator+( const vr::HmdVector3_t &vec1, const vr::HmdVector3_t &vec2 )
{
return { vec1.v[ 0 ] + vec2.v[ 0 ], vec1.v[ 1 ] + vec2.v[ 1 ], vec1.v[ 2 ] + vec2.v[ 2 ] };
return { vec1.v[ 0 ] + vec2.v[ 0 ], vec1.v[ 1 ] + vec2.v[ 1 ], vec1.v[ 2 ] + vec2.v[ 2 ] };
}

static vr::HmdVector3d_t operator-( const vr::HmdVector3d_t &vec1, const vr::HmdVector3d_t &vec2 )
{
return { vec1.v[ 0 ] - vec2.v[ 0 ], vec1.v[ 1 ] - vec2.v[ 1 ], vec1.v[ 2 ] - vec2.v[ 2 ] };
return { vec1.v[ 0 ] - vec2.v[ 0 ], vec1.v[ 1 ] - vec2.v[ 1 ], vec1.v[ 2 ] - vec2.v[ 2 ] };
}

static vr::HmdVector3_t operator*( const vr::HmdVector3_t &vec, const vr::HmdQuaternion_t &q )
{
const vr::HmdQuaternion_t qvec = { 0.0, vec.v[ 0 ], vec.v[ 1 ], vec.v[ 2 ] };
const vr::HmdQuaternion_t qvec = { 0.0, vec.v[ 0 ], vec.v[ 1 ], vec.v[ 2 ] };

const vr::HmdQuaternion_t qResult = (q * qvec) * (-q);
const vr::HmdQuaternion_t qResult = (q * qvec) * (-q);

return { static_cast< float >( qResult.x ), static_cast< float >( qResult.y ), static_cast< float >( qResult.z ) };
return { static_cast< float >( qResult.x ), static_cast< float >( qResult.y ), static_cast< float >( qResult.z ) };
}

template < class T, class V >
void HmdVector3_CovertVector( const T &in_vector, V &out_vector )
{
out_vector.v[ 0 ] = in_vector.v[ 0 ];
out_vector.v[ 1 ] = in_vector.v[ 1 ];
out_vector.v[ 2 ] = in_vector.v[ 2 ];
out_vector.v[ 0 ] = in_vector.v[ 0 ];
out_vector.v[ 1 ] = in_vector.v[ 1 ];
out_vector.v[ 2 ] = in_vector.v[ 2 ];
}
Loading

0 comments on commit a2b417a

Please sign in to comment.