mirror of
https://github.com/overte-org/overte.git
synced 2025-07-15 15:16:39 +02:00
90 lines
No EOL
3.9 KiB
C
90 lines
No EOL
3.9 KiB
C
//
|
|
// GLMHelpers.h
|
|
// libraries/shared/src
|
|
//
|
|
// Created by Stephen Birarda on 2014-08-07.
|
|
// Copyright 2014 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#ifndef hifi_GLMHelpers_h
|
|
#define hifi_GLMHelpers_h
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <glm/glm.hpp>
|
|
#include <glm/gtc/quaternion.hpp>
|
|
|
|
#include <QtCore/QByteArray>
|
|
|
|
#include "SharedUtil.h"
|
|
|
|
glm::quat safeMix(const glm::quat& q1, const glm::quat& q2, float alpha);
|
|
|
|
// These pack/unpack functions are designed to start specific known types in as efficient a manner
|
|
// as possible. Taking advantage of the known characteristics of the semantic types.
|
|
|
|
// Angles are known to be between 0 and 360 degrees, this allows us to encode in 16bits with great accuracy
|
|
int packFloatAngleToTwoByte(unsigned char* buffer, float degrees);
|
|
int unpackFloatAngleFromTwoByte(const uint16_t* byteAnglePointer, float* destinationPointer);
|
|
|
|
// Orientation Quats are known to have 4 normalized components be between -1.0 and 1.0
|
|
// this allows us to encode each component in 16bits with great accuracy
|
|
int packOrientationQuatToBytes(unsigned char* buffer, const glm::quat& quatInput);
|
|
int unpackOrientationQuatFromBytes(const unsigned char* buffer, glm::quat& quatOutput);
|
|
|
|
// Ratios need the be highly accurate when less than 10, but not very accurate above 10, and they
|
|
// are never greater than 1000 to 1, this allows us to encode each component in 16bits
|
|
int packFloatRatioToTwoByte(unsigned char* buffer, float ratio);
|
|
int unpackFloatRatioFromTwoByte(const unsigned char* buffer, float& ratio);
|
|
|
|
// Near/Far Clip values need the be highly accurate when less than 10, but only integer accuracy above 10 and
|
|
// they are never greater than 16,000, this allows us to encode each component in 16bits
|
|
int packClipValueToTwoByte(unsigned char* buffer, float clipValue);
|
|
int unpackClipValueFromTwoByte(const unsigned char* buffer, float& clipValue);
|
|
|
|
// Positive floats that don't need to be very precise
|
|
int packFloatToByte(unsigned char* buffer, float value, float scaleBy);
|
|
int unpackFloatFromByte(const unsigned char* buffer, float& value, float scaleBy);
|
|
|
|
// Allows sending of fixed-point numbers: radix 1 makes 15.1 number, radix 8 makes 8.8 number, etc
|
|
int packFloatScalarToSignedTwoByteFixed(unsigned char* buffer, float scalar, int radix);
|
|
int unpackFloatScalarFromSignedTwoByteFixed(const int16_t* byteFixedPointer, float* destinationPointer, int radix);
|
|
|
|
// A convenience for sending vec3's as fixed-point floats
|
|
int packFloatVec3ToSignedTwoByteFixed(unsigned char* destBuffer, const glm::vec3& srcVector, int radix);
|
|
int unpackFloatVec3FromSignedTwoByteFixed(const unsigned char* sourceBuffer, glm::vec3& destination, int radix);
|
|
|
|
/// \return vec3 with euler angles in radians
|
|
glm::vec3 safeEulerAngles(const glm::quat& q);
|
|
|
|
float angleBetween(const glm::vec3& v1, const glm::vec3& v2);
|
|
|
|
glm::quat rotationBetween(const glm::vec3& v1, const glm::vec3& v2);
|
|
|
|
glm::vec3 extractTranslation(const glm::mat4& matrix);
|
|
|
|
void setTranslation(glm::mat4& matrix, const glm::vec3& translation);
|
|
|
|
glm::quat extractRotation(const glm::mat4& matrix, bool assumeOrthogonal = false);
|
|
|
|
glm::vec3 extractScale(const glm::mat4& matrix);
|
|
|
|
float extractUniformScale(const glm::mat4& matrix);
|
|
|
|
float extractUniformScale(const glm::vec3& scale);
|
|
|
|
QByteArray createByteArray(const glm::vec3& vector);
|
|
QByteArray createByteArray(const glm::quat& quat);
|
|
|
|
/// \return bool are two orientations similar to each other
|
|
const float ORIENTATION_SIMILAR_ENOUGH = 5.0f; // 10 degrees in any direction
|
|
bool isSimilarOrientation(const glm::quat& orientionA, const glm::quat& orientionB,
|
|
float similarEnough = ORIENTATION_SIMILAR_ENOUGH);
|
|
const float POSITION_SIMILAR_ENOUGH = 0.1f; // 0.1 meter
|
|
bool isSimilarPosition(const glm::vec3& positionA, const glm::vec3& positionB, float similarEnough = POSITION_SIMILAR_ENOUGH);
|
|
|
|
|
|
#endif // hifi_GLMHelpers_h
|