Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-20 03:44:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

variant conversions

Browse source
This commit is contained in:
SamGondelman 2018-10-16 11:55:28 -07:00
parent 9788aa307e
commit ded8d4b547
7 changed files with 116 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
interface/src/raypick/ParabolaPointer.cpp
View file

@ -52,8 +52,7 @@ void ParabolaPointer::editRenderStatePath(const std::string& state, const QVaria
if (!pathMap.isEmpty()) {
enabled = true;
if (pathMap["color"].isValid()) {
bool valid;
color = toGlm(vec3FromVariant(pathMap["color"], valid));
color = toGlm(u8vec3FromVariant(pathMap["color"]));
}
if (pathMap["alpha"].isValid()) {
alpha = pathMap["alpha"].toFloat();
@ -250,8 +249,7 @@ std::shared_ptr<StartEndRenderState> ParabolaPointer::buildRenderState(const QVa
enabled = true;
QVariantMap pathMap = propMap["path"].toMap();
if (pathMap["color"].isValid()) {
bool valid;
color = toGlm(vec3FromVariant(pathMap["color"], valid));
color = toGlm(u8vec3FromVariant(pathMap["color"]));
}
if (pathMap["alpha"].isValid()) {

16
interface/src/scripting/SelectionScriptingInterface.cpp
View file

@ -421,7 +421,7 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
auto colorVariant = properties["outlineUnoccludedColor"];
if (colorVariant.isValid()) {
bool isValid;
auto color = vec3FromVariant(colorVariant, isValid);
auto color = u8vec3FromVariant(colorVariant, isValid);
if (isValid) {
_style._outlineUnoccluded.color = toGlm(color);
}
@ -429,7 +429,7 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
colorVariant = properties["outlineOccludedColor"];
if (colorVariant.isValid()) {
bool isValid;
auto color = vec3FromVariant(colorVariant, isValid);
auto color = u8vec3FromVariant(colorVariant, isValid);
if (isValid) {
_style._outlineOccluded.color = toGlm(color);
}
@ -437,7 +437,7 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
colorVariant = properties["fillUnoccludedColor"];
if (colorVariant.isValid()) {
bool isValid;
auto color = vec3FromVariant(colorVariant, isValid);
auto color = u8vec3FromVariant(colorVariant, isValid);
if (isValid) {
_style._fillUnoccluded.color = toGlm(color);
}
@ -445,7 +445,7 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
colorVariant = properties["fillOccludedColor"];
if (colorVariant.isValid()) {
bool isValid;
auto color = vec3FromVariant(colorVariant, isValid);
auto color = u8vec3FromVariant(colorVariant, isValid);
if (isValid) {
_style._fillOccluded.color = toGlm(color);
}
@ -498,10 +498,10 @@ QVariantMap SelectionHighlightStyle::toVariantMap() const {
QVariantMap properties;
const float MAX_COLOR = 255.0f;
properties["outlineUnoccludedColor"] = vec3toVariant(_style._outlineUnoccluded.color * MAX_COLOR);
properties["outlineOccludedColor"] = vec3toVariant(_style._outlineOccluded.color * MAX_COLOR);
properties["fillUnoccludedColor"] = vec3toVariant(_style._fillUnoccluded.color * MAX_COLOR);
properties["fillOccludedColor"] = vec3toVariant(_style._fillOccluded.color * MAX_COLOR);
properties["outlineUnoccludedColor"] = u8vec3ColortoVariant(_style._outlineUnoccluded.color * MAX_COLOR);
properties["outlineOccludedColor"] = u8vec3ColortoVariant(_style._outlineOccluded.color * MAX_COLOR);
properties["fillUnoccludedColor"] = u8vec3ColortoVariant(_style._fillUnoccluded.color * MAX_COLOR);
properties["fillOccludedColor"] = u8vec3ColortoVariant(_style._fillOccluded.color * MAX_COLOR);
properties["outlineUnoccludedAlpha"] = _style._outlineUnoccluded.alpha;
properties["outlineOccludedAlpha"] = _style._outlineOccluded.alpha;

14
interface/src/ui/overlays/Circle3DOverlay.cpp
View file

@ -275,7 +275,7 @@ template<typename T> T fromVariant(const QVariant& v, bool& valid) {
}
template<> glm::u8vec3 fromVariant(const QVariant& v, bool& valid) {
return vec3FromVariant(v, valid);
return u8vec3FromVariant(v, valid);
}
template<typename T>
@ -472,16 +472,16 @@ QVariant Circle3DOverlay::getProperty(const QString& property) {
return _innerRadius;
}
if (property == "innerStartColor") {
return vec3toVariant(_innerStartColor);
return u8vec3ColortoVariant(_innerStartColor);
}
if (property == "innerEndColor") {
return vec3toVariant(_innerEndColor);
return u8vec3ColortoVariant(_innerEndColor);
}
if (property == "outerStartColor") {
return vec3toVariant(_outerStartColor);
return u8vec3ColortoVariant(_outerStartColor);
}
if (property == "outerEndColor") {
return vec3toVariant(_outerEndColor);
return u8vec3ColortoVariant(_outerEndColor);
}
if (property == "innerStartAlpha") {
return _innerStartAlpha;
@ -511,10 +511,10 @@ QVariant Circle3DOverlay::getProperty(const QString& property) {
return _minorTickMarksLength;
}
if (property == "majorTickMarksColor") {
return vec3toVariant(_majorTickMarksColor);
return u8vec3ColortoVariant(_majorTickMarksColor);
}
if (property == "minorTickMarksColor") {
return vec3toVariant(_minorTickMarksColor);
return u8vec3ColortoVariant(_minorTickMarksColor);
}
return Planar3DOverlay::getProperty(property);

4
interface/src/ui/overlays/Overlay.cpp
View file

@ -57,7 +57,7 @@ Overlay::~Overlay() {
void Overlay::setProperties(const QVariantMap& properties) {
bool valid;
auto color = vec3FromVariant(properties["color"], valid);
auto color = u8vec3FromVariant(properties["color"], valid);
if (valid) {
_color = color;
}
@ -116,7 +116,7 @@ QVariant Overlay::getProperty(const QString& property) {
return QVariant(getType());
}
if (property == "color") {
return vec3toVariant(_color);
return u8vec3ColortoVariant(_color);
}
if (property == "alpha") {
return _alpha;

4
interface/src/ui/overlays/Text3DOverlay.cpp
View file

@ -161,7 +161,7 @@ void Text3DOverlay::setProperties(const QVariantMap& properties) {
bool valid;
auto backgroundColor = properties["backgroundColor"];
if (backgroundColor.isValid()) {
auto color = vec3FromVariant(backgroundColor, valid);
auto color = u8vec3FromVariant(backgroundColor, valid);
if (valid) {
_backgroundColor = color;
}
@ -257,7 +257,7 @@ QVariant Text3DOverlay::getProperty(const QString& property) {
return _textAlpha;
}
if (property == "backgroundColor") {
return vec3toVariant(_backgroundColor);
return u8vec3ColortoVariant(_backgroundColor);
}
if (property == "backgroundAlpha") {
return Billboard3DOverlay::getProperty("alpha");

87
libraries/shared/src/RegisteredMetaTypes.cpp
View file

@ -442,6 +442,93 @@ glm::vec3 vec3FromVariant(const QVariant& object) {
return vec3FromVariant(object, valid);
}
QVariant u8vec3toVariant(const glm::u8vec3& vec3) {
QVariantMap result;
result["x"] = vec3.x;
result["y"] = vec3.y;
result["z"] = vec3.z;
return result;
}
QVariant u8vec3ColortoVariant(const glm::u8vec3& vec3) {
QVariantMap result;
result["red"] = vec3.x;
result["green"] = vec3.y;
result["blue"] = vec3.z;
return result;
}
glm::u8vec3 u8vec3FromVariant(const QVariant& object, bool& valid) {
glm::u8vec3 v;
valid = false;
if (!object.isValid() || object.isNull()) {
return v;
} else if (object.canConvert<uint>()) {
v = glm::vec3(object.toUInt());
valid = true;
} else if (object.canConvert<QVector3D>()) {
auto qvec3 = qvariant_cast<QVector3D>(object);
v.x = (uint8_t)qvec3.x();
v.y = (uint8_t)qvec3.y();
v.z = (uint8_t)qvec3.z();
valid = true;
} else if (object.canConvert<QString>()) {
QColor qColor(object.toString());
if (qColor.isValid()) {
v.x = (uint8_t)qColor.red();
v.y = (uint8_t)qColor.green();
v.z = (uint8_t)qColor.blue();
valid = true;
}
} else if (object.canConvert<QColor>()) {
QColor qColor = qvariant_cast<QColor>(object);
if (qColor.isValid()) {
v.x = (uint8_t)qColor.red();
v.y = (uint8_t)qColor.green();
v.z = (uint8_t)qColor.blue();
valid = true;
}
} else {
auto map = object.toMap();
auto x = map["x"];
if (!x.isValid()) {
x = map["r"];
}
if (!x.isValid()) {
x = map["red"];
}
auto y = map["y"];
if (!y.isValid()) {
y = map["g"];
}
if (!y.isValid()) {
y = map["green"];
}
auto z = map["z"];
if (!z.isValid()) {
z = map["b"];
}
if (!z.isValid()) {
z = map["blue"];
}
if (x.canConvert<uint>() && y.canConvert<uint>() && z.canConvert<uint>()) {
v.x = x.toUInt();
v.y = y.toUInt();
v.z = z.toUInt();
valid = true;
}
}
return v;
}
glm::u8vec3 u8vec3FromVariant(const QVariant& object) {
bool valid = false;
return u8vec3FromVariant(object, valid);
}
QScriptValue vec4toScriptValue(QScriptEngine* engine, const glm::vec4& vec4) {
QScriptValue obj = engine->newObject();
obj.setProperty("x", vec4.x);

11
libraries/shared/src/RegisteredMetaTypes.h
View file

@ -90,6 +90,10 @@ QScriptValue vec3ToScriptValue(QScriptEngine* engine, const glm::vec3& vec3);
QScriptValue vec3ColorToScriptValue(QScriptEngine* engine, const glm::vec3& vec3);
void vec3FromScriptValue(const QScriptValue& object, glm::vec3& vec3);
QVariant vec3toVariant(const glm::vec3& vec3);
glm::vec3 vec3FromVariant(const QVariant &object, bool& valid);
glm::vec3 vec3FromVariant(const QVariant &object);
/**jsdoc
* A color vector. See also the {@link Vec3(0)|Vec3} object.
*
@ -132,9 +136,10 @@ QScriptValue u8vec3ToScriptValue(QScriptEngine* engine, const glm::u8vec3& vec3)
QScriptValue u8vec3ColorToScriptValue(QScriptEngine* engine, const glm::u8vec3& vec3);
void u8vec3FromScriptValue(const QScriptValue& object, glm::u8vec3& vec3);
QVariant vec3toVariant(const glm::vec3& vec3);
glm::vec3 vec3FromVariant(const QVariant &object, bool& valid);
glm::vec3 vec3FromVariant(const QVariant &object);
QVariant u8vec3toVariant(const glm::u8vec3& vec3);
QVariant u8vec3ColortoVariant(const glm::u8vec3& vec3);
glm::u8vec3 u8vec3FromVariant(const QVariant &object, bool& valid);
glm::u8vec3 u8vec3FromVariant(const QVariant &object);
/**jsdoc
* A 4-dimensional vector.