Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-08 15:43:24 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

s i m p l i f y

Browse source
This commit is contained in:
SamGondelman 2018-08-23 00:46:53 -07:00 committed by SamGondelman
parent f0986a7f5a
commit 283c0c0311
102 changed files with 723 additions and 926 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
interface/src/Application.cpp
View file

@ -4812,7 +4812,7 @@ bool Application::exportEntities(const QString& filename,
properties.setParentID(AVATAR_SELF_ID);
} else {
if (parentID.isInvalidID()) {
properties.setPosition(properties.getPosition().toGlm() - root);
properties.setPosition(properties.getPosition() - root);
} else if (!entities.contains(parentID)) {
entityDatum->globalizeProperties(properties, "Parent %3 of %2 %1 is not selected for export.", -root);
} // else valid parent -- don't offset
@ -5462,9 +5462,9 @@ void Application::updateSecondaryCameraViewFrustum() {
if (camera->mirrorProjection && !camera->attachedEntityId.isNull()) {
auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();
auto entityProperties = entityScriptingInterface->getEntityProperties(camera->attachedEntityId);
glm::vec3 mirrorPropertiesPosition = entityProperties.getPosition().toGlm();
glm::vec3 mirrorPropertiesPosition = entityProperties.getPosition();
glm::quat mirrorPropertiesRotation = entityProperties.getRotation();
glm::vec3 mirrorPropertiesDimensions = entityProperties.getDimensions().toGlm();
glm::vec3 mirrorPropertiesDimensions = entityProperties.getDimensions();
glm::vec3 halfMirrorPropertiesDimensions = 0.5f * mirrorPropertiesDimensions;
// setup mirror from world as inverse of world from mirror transformation using inverted x and z for mirrored image
@ -5496,7 +5496,7 @@ void Application::updateSecondaryCameraViewFrustum() {
if (!camera->attachedEntityId.isNull()) {
auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();
auto entityProperties = entityScriptingInterface->getEntityProperties(camera->attachedEntityId);
secondaryViewFrustum.setPosition(entityProperties.getPosition().toGlm());
secondaryViewFrustum.setPosition(entityProperties.getPosition());
secondaryViewFrustum.setOrientation(entityProperties.getRotation());
} else {
secondaryViewFrustum.setPosition(camera->position);
@ -7349,7 +7349,7 @@ void Application::addAssetToWorldCheckModelSize() {
auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();
auto properties = entityScriptingInterface->getEntityProperties(entityID, propertyFlags);
auto name = properties.getName();
auto dimensions = properties.getDimensions().toGlm();
auto dimensions = properties.getDimensions();
bool doResize = false;

4
interface/src/raypick/CollisionPick.cpp
View file

@ -28,8 +28,8 @@ void buildObjectIntersectionsMap(IntersectionType intersectionType, const std::v
}
QVariantMap collisionPointPair;
collisionPointPair["pointOnPick"] = vec3ToVariant(objectIntersection.testCollisionPoint);
collisionPointPair["pointOnObject"] = vec3ToVariant(objectIntersection.foundCollisionPoint);
collisionPointPair["pointOnPick"] = vec3toVariant(objectIntersection.testCollisionPoint);
collisionPointPair["pointOnObject"] = vec3toVariant(objectIntersection.foundCollisionPoint);
collisionPointPairs[objectIntersection.foundID].append(collisionPointPair);
}

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

@ -74,7 +74,7 @@ void LaserPointer::setVisualPickResultInternal(PickResultPointer pickResult, Int
rayPickResult->intersection = intersection;
rayPickResult->distance = distance;
rayPickResult->surfaceNormal = surfaceNormal;
rayPickResult->pickVariant["direction"] = vec3ToVariant(-surfaceNormal);
rayPickResult->pickVariant["direction"] = vec3toVariant(-surfaceNormal);
}
}
@ -107,10 +107,10 @@ void LaserPointer::RenderState::disable() {
void LaserPointer::RenderState::update(const glm::vec3& origin, const glm::vec3& end, const glm::vec3& surfaceNormal, bool scaleWithAvatar, bool distanceScaleEnd, bool centerEndY,
bool faceAvatar, bool followNormal, float followNormalStrength, float distance, const PickResultPointer& pickResult) {
StartEndRenderState::update(origin, end, surfaceNormal, scaleWithAvatar, distanceScaleEnd, centerEndY, faceAvatar, followNormal, followNormalStrength, distance, pickResult);
QVariant endVariant = vec3ToVariant(end);
QVariant endVariant = vec3toVariant(end);
if (!getPathID().isNull()) {
QVariantMap pathProps;
pathProps.insert("start", vec3ToVariant(origin));
pathProps.insert("start", vec3toVariant(origin));
pathProps.insert("end", endVariant);
pathProps.insert("visible", true);
pathProps.insert("ignoreRayIntersection", doesPathIgnoreRays());

4
interface/src/raypick/ParabolaPick.h
View file

@ -50,8 +50,8 @@ public:
toReturn["objectID"] = objectID;
toReturn["distance"] = distance;
toReturn["parabolicDistance"] = parabolicDistance;
toReturn["intersection"] = vec3ToVariant(intersection);
toReturn["surfaceNormal"] = vec3ToVariant(surfaceNormal);
toReturn["intersection"] = vec3toVariant(intersection);
toReturn["surfaceNormal"] = vec3toVariant(surfaceNormal);
toReturn["parabola"] = PickResult::toVariantMap();
toReturn["extraInfo"] = extraInfo;
return toReturn;

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

@ -100,7 +100,7 @@ void ParabolaPointer::setVisualPickResultInternal(PickResultPointer pickResult,
parabolaPickResult->distance = distance;
parabolaPickResult->surfaceNormal = surfaceNormal;
PickParabola parabola = PickParabola(parabolaPickResult->pickVariant);
parabolaPickResult->pickVariant["velocity"] = vec3ToVariant((intersection - parabola.origin -
parabolaPickResult->pickVariant["velocity"] = vec3toVariant((intersection - parabola.origin -
0.5f * parabola.acceleration * parabolaPickResult->parabolicDistance * parabolaPickResult->parabolicDistance) / parabolaPickResult->parabolicDistance);
}
}

16
interface/src/raypick/PathPointer.cpp
View file

@ -102,12 +102,12 @@ PickResultPointer PathPointer::getVisualPickResult(const PickResultPointer& pick
registrationPoint = glm::vec3(0.5f);
} else {
EntityItemProperties props = DependencyManager::get<EntityScriptingInterface>()->getEntityProperties(_lockEndObject.id);
glm::mat4 entityMat = createMatFromQuatAndPos(props.getRotation(), props.getPosition().toGlm());
glm::mat4 entityMat = createMatFromQuatAndPos(props.getRotation(), props.getPosition());
glm::mat4 finalPosAndRotMat = entityMat * _lockEndObject.offsetMat;
pos = extractTranslation(finalPosAndRotMat);
rot = glmExtractRotation(finalPosAndRotMat);
dim = props.getDimensions().toGlm();
registrationPoint = props.getRegistrationPoint().toGlm();
dim = props.getDimensions();
registrationPoint = props.getRegistrationPoint();
}
const glm::vec3 DEFAULT_REGISTRATION_POINT = glm::vec3(0.5f);
endVec = pos + rot * (dim * (DEFAULT_REGISTRATION_POINT - registrationPoint));
@ -277,10 +277,10 @@ void StartEndRenderState::update(const glm::vec3& origin, const glm::vec3& end,
bool faceAvatar, bool followNormal, float followNormalStrength, float distance, const PickResultPointer& pickResult) {
if (!getStartID().isNull()) {
QVariantMap startProps;
startProps.insert("position", vec3ToVariant(origin));
startProps.insert("position", vec3toVariant(origin));
startProps.insert("visible", true);
if (scaleWithAvatar) {
startProps.insert("dimensions", vec3ToVariant(getStartDim() * DependencyManager::get<AvatarManager>()->getMyAvatar()->getSensorToWorldScale()));
startProps.insert("dimensions", vec3toVariant(getStartDim() * DependencyManager::get<AvatarManager>()->getMyAvatar()->getSensorToWorldScale()));
}
startProps.insert("ignoreRayIntersection", doesStartIgnoreRays());
qApp->getOverlays().editOverlay(getStartID(), startProps);
@ -291,10 +291,10 @@ void StartEndRenderState::update(const glm::vec3& origin, const glm::vec3& end,
glm::vec3 dim = vec3FromVariant(qApp->getOverlays().getProperty(getEndID(), "dimensions").value);
if (distanceScaleEnd) {
dim = getEndDim() * glm::distance(origin, end);
endProps.insert("dimensions", vec3ToVariant(dim));
endProps.insert("dimensions", vec3toVariant(dim));
} else if (scaleWithAvatar) {
dim = getEndDim() * DependencyManager::get<AvatarManager>()->getMyAvatar()->getSensorToWorldScale();
endProps.insert("dimensions", vec3ToVariant(dim));
endProps.insert("dimensions", vec3toVariant(dim));
}
glm::quat normalQuat = Quat().lookAtSimple(Vectors::ZERO, surfaceNormal);
@ -331,7 +331,7 @@ void StartEndRenderState::update(const glm::vec3& origin, const glm::vec3& end,
_avgEndRot = rotation;
}
}
endProps.insert("position", vec3ToVariant(position));
endProps.insert("position", vec3toVariant(position));
endProps.insert("rotation", quatToVariant(rotation));
endProps.insert("visible", true);
endProps.insert("ignoreRayIntersection", doesEndIgnoreRays());

4
interface/src/raypick/RayPick.cpp
View file

@ -65,7 +65,7 @@ glm::vec3 RayPick::intersectRayWithOverlayXYPlane(const QUuid& overlayID, const
glm::vec3 RayPick::intersectRayWithEntityXYPlane(const QUuid& entityID, const glm::vec3& origin, const glm::vec3& direction) {
auto props = DependencyManager::get<EntityScriptingInterface>()->getEntityProperties(entityID);
return intersectRayWithXYPlane(origin, direction, props.getPosition().toGlm(), props.getRotation(), props.getRegistrationPoint().toGlm());
return intersectRayWithXYPlane(origin, direction, props.getPosition(), props.getRotation(), props.getRegistrationPoint());
}
glm::vec2 RayPick::projectOntoXYPlane(const glm::vec3& worldPos, const glm::vec3& position, const glm::quat& rotation, const glm::vec3& dimensions, const glm::vec3& registrationPoint, bool unNormalized) {
@ -91,5 +91,5 @@ glm::vec2 RayPick::projectOntoOverlayXYPlane(const QUuid& overlayID, const glm::
glm::vec2 RayPick::projectOntoEntityXYPlane(const QUuid& entityID, const glm::vec3& worldPos, bool unNormalized) {
auto props = DependencyManager::get<EntityScriptingInterface>()->getEntityProperties(entityID);
return projectOntoXYPlane(worldPos, props.getPosition().toGlm(), props.getRotation(), props.getDimensions().toGlm(), props.getRegistrationPoint().toGlm(), unNormalized);
return projectOntoXYPlane(worldPos, props.getPosition(), props.getRotation(), props.getDimensions(), props.getRegistrationPoint(), unNormalized);
}

4
interface/src/raypick/RayPick.h
View file

@ -46,8 +46,8 @@ public:
toReturn["intersects"] = intersects;
toReturn["objectID"] = objectID;
toReturn["distance"] = distance;
toReturn["intersection"] = vec3ToVariant(intersection);
toReturn["surfaceNormal"] = vec3ToVariant(surfaceNormal);
toReturn["intersection"] = vec3toVariant(intersection);
toReturn["surfaceNormal"] = vec3toVariant(surfaceNormal);
toReturn["searchRay"] = PickResult::toVariantMap();
toReturn["extraInfo"] = extraInfo;
return toReturn;

4
interface/src/raypick/StylusPick.h
View file

@ -44,8 +44,8 @@ public:
toReturn["intersects"] = intersects;
toReturn["objectID"] = objectID;
toReturn["distance"] = distance;
toReturn["intersection"] = vec3ToVariant(intersection);
toReturn["surfaceNormal"] = vec3ToVariant(surfaceNormal);
toReturn["intersection"] = vec3toVariant(intersection);
toReturn["surfaceNormal"] = vec3toVariant(surfaceNormal);
toReturn["stylusTip"] = PickResult::toVariantMap();
return toReturn;
}

4
interface/src/raypick/StylusPointer.cpp
View file

@ -74,9 +74,9 @@ void StylusPointer::show(const StylusTip& tip) {
auto modelOrientation = tip.orientation * X_ROT_NEG_90;
auto sensorToWorldScale = DependencyManager::get<AvatarManager>()->getMyAvatar()->getSensorToWorldScale();
auto modelPositionOffset = modelOrientation * (vec3(0.0f, 0.0f, -WEB_STYLUS_LENGTH / 2.0f) * sensorToWorldScale);
props["position"] = vec3ToVariant(tip.position + modelPositionOffset);
props["position"] = vec3toVariant(tip.position + modelPositionOffset);
props["rotation"] = quatToVariant(modelOrientation);
props["dimensions"] = vec3ToVariant(sensorToWorldScale * vec3(0.01f, 0.01f, WEB_STYLUS_LENGTH));
props["dimensions"] = vec3toVariant(sensorToWorldScale * vec3(0.01f, 0.01f, WEB_STYLUS_LENGTH));
props["visible"] = true;
qApp->getOverlays().editOverlay(_stylusOverlay, props);
}

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

@ -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"] = 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["outlineUnoccludedAlpha"] = _style._outlineUnoccluded.alpha;
properties["outlineOccludedAlpha"] = _style._outlineOccluded.alpha;

8
interface/src/ui/overlays/Base3DOverlay.cpp
View file

@ -59,7 +59,7 @@ QVariantMap convertOverlayLocationFromScriptSemantics(const QVariantMap& propert
glm::vec3 localPosition = SpatiallyNestable::worldToLocal(vec3FromVariant(result["position"]),
parentID, parentJointIndex, scalesWithParent, success);
if (success) {
result["position"] = vec3ToVariant(localPosition);
result["position"] = vec3toVariant(localPosition);
}
}
@ -112,7 +112,7 @@ void Base3DOverlay::setProperties(const QVariantMap& originalProperties) {
properties["parentJointIndex"] = getParentJointIndex();
}
if (!properties["position"].isValid() && !properties["localPosition"].isValid()) {
properties["position"] = vec3ToVariant(getWorldPosition());
properties["position"] = vec3toVariant(getWorldPosition());
}
if (!properties["orientation"].isValid() && !properties["localOrientation"].isValid()) {
properties["orientation"] = quatToVariant(getWorldOrientation());
@ -241,10 +241,10 @@ QVariant Base3DOverlay::getProperty(const QString& property) {
return _name;
}
if (property == "position" || property == "start" || property == "p1" || property == "point") {
return vec3ToVariant(getWorldPosition());
return vec3toVariant(getWorldPosition());
}
if (property == "localPosition") {
return vec3ToVariant(getLocalPosition());
return vec3toVariant(getLocalPosition());
}
if (property == "rotation" || property == "orientation") {
return quatToVariant(getWorldOrientation());

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

@ -265,7 +265,7 @@ template<typename T> T fromVariant(const QVariant& v, bool& valid) {
return qvariant_cast<T>(v);
}
template<> ScriptVec3UChar fromVariant(const QVariant& v, bool& valid) {
template<> glm::u8vec3 fromVariant(const QVariant& v, bool& valid) {
return vec3FromVariant(v, valid);
}
@ -329,11 +329,11 @@ void Circle3DOverlay::setProperties(const QVariantMap& properties) {
_dirty |= updateIfValid(properties, "outerStartAlpha", _outerStartAlpha);
_dirty |= updateIfValid(properties, "outerEndAlpha", _outerEndAlpha);
_dirty |= updateIfValid<ScriptVec3UChar>(properties, "color", { _innerStartColor, _innerEndColor, _outerStartColor, _outerEndColor });
_dirty |= updateIfValid<ScriptVec3UChar>(properties, "startColor", { _innerStartColor, _outerStartColor } );
_dirty |= updateIfValid<ScriptVec3UChar>(properties, "endColor", { _innerEndColor, _outerEndColor } );
_dirty |= updateIfValid<ScriptVec3UChar>(properties, "innerColor", { _innerStartColor, _innerEndColor } );
_dirty |= updateIfValid<ScriptVec3UChar>(properties, "outerColor", { _outerStartColor, _outerEndColor } );
_dirty |= updateIfValid<glm::u8vec3>(properties, "color", { _innerStartColor, _innerEndColor, _outerStartColor, _outerEndColor });
_dirty |= updateIfValid<glm::u8vec3>(properties, "startColor", { _innerStartColor, _outerStartColor } );
_dirty |= updateIfValid<glm::u8vec3>(properties, "endColor", { _innerEndColor, _outerEndColor } );
_dirty |= updateIfValid<glm::u8vec3>(properties, "innerColor", { _innerStartColor, _innerEndColor } );
_dirty |= updateIfValid<glm::u8vec3>(properties, "outerColor", { _outerStartColor, _outerEndColor } );
_dirty |= updateIfValid(properties, "innerStartColor", _innerStartColor);
_dirty |= updateIfValid(properties, "innerEndColor", _innerEndColor);
_dirty |= updateIfValid(properties, "outerStartColor", _outerStartColor);
@ -463,16 +463,16 @@ QVariant Circle3DOverlay::getProperty(const QString& property) {
return _innerRadius;
}
if (property == "innerStartColor") {
return vec3ToVariant(_innerStartColor.toGlm());
return vec3toVariant(_innerStartColor);
}
if (property == "innerEndColor") {
return vec3ToVariant(_innerEndColor.toGlm());
return vec3toVariant(_innerEndColor);
}
if (property == "outerStartColor") {
return vec3ToVariant(_outerStartColor.toGlm());
return vec3toVariant(_outerStartColor);
}
if (property == "outerEndColor") {
return vec3ToVariant(_outerEndColor.toGlm());
return vec3toVariant(_outerEndColor);
}
if (property == "innerStartAlpha") {
return _innerStartAlpha;
@ -502,10 +502,10 @@ QVariant Circle3DOverlay::getProperty(const QString& property) {
return _minorTickMarksLength;
}
if (property == "majorTickMarksColor") {
return vec3ToVariant(_majorTickMarksColor.toGlm());
return vec3toVariant(_majorTickMarksColor);
}
if (property == "minorTickMarksColor") {
return vec3ToVariant(_minorTickMarksColor.toGlm());
return vec3toVariant(_minorTickMarksColor);
}
return Planar3DOverlay::getProperty(property);

20
interface/src/ui/overlays/Circle3DOverlay.h
View file

@ -39,8 +39,8 @@ public:
float getMinorTickMarksAngle() const { return _minorTickMarksAngle; }
float getMajorTickMarksLength() const { return _majorTickMarksLength; }
float getMinorTickMarksLength() const { return _minorTickMarksLength; }
ScriptVec3UChar getMajorTickMarksColor() const { return _majorTickMarksColor; }
ScriptVec3UChar getMinorTickMarksColor() const { return _minorTickMarksColor; }
glm::u8vec3 getMajorTickMarksColor() const { return _majorTickMarksColor; }
glm::u8vec3 getMinorTickMarksColor() const { return _minorTickMarksColor; }
void setStartAt(float value) { _startAt = value; }
void setEndAt(float value) { _endAt = value; }
@ -51,8 +51,8 @@ public:
void setMinorTickMarksAngle(float value) { _minorTickMarksAngle = value; }
void setMajorTickMarksLength(float value) { _majorTickMarksLength = value; }
void setMinorTickMarksLength(float value) { _minorTickMarksLength = value; }
void setMajorTickMarksColor(const ScriptVec3UChar& value) { _majorTickMarksColor = value; }
void setMinorTickMarksColor(const ScriptVec3UChar& value) { _minorTickMarksColor = value; }
void setMajorTickMarksColor(const glm::u8vec3& value) { _majorTickMarksColor = value; }
void setMinorTickMarksColor(const glm::u8vec3& value) { _minorTickMarksColor = value; }
virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance,
BoxFace& face, glm::vec3& surfaceNormal, bool precisionPicking = false) override;
@ -67,10 +67,10 @@ protected:
float _outerRadius { 1 };
float _innerRadius { 0 };
ScriptVec3UChar _innerStartColor { DEFAULT_OVERLAY_COLOR };
ScriptVec3UChar _innerEndColor { DEFAULT_OVERLAY_COLOR };
ScriptVec3UChar _outerStartColor { DEFAULT_OVERLAY_COLOR };
ScriptVec3UChar _outerEndColor { DEFAULT_OVERLAY_COLOR };
glm::u8vec3 _innerStartColor { DEFAULT_OVERLAY_COLOR };
glm::u8vec3 _innerEndColor { DEFAULT_OVERLAY_COLOR };
glm::u8vec3 _outerStartColor { DEFAULT_OVERLAY_COLOR };
glm::u8vec3 _outerEndColor { DEFAULT_OVERLAY_COLOR };
float _innerStartAlpha { DEFAULT_ALPHA };
float _innerEndAlpha { DEFAULT_ALPHA };
float _outerStartAlpha { DEFAULT_ALPHA };
@ -81,8 +81,8 @@ protected:
float _minorTickMarksAngle { 0 };
float _majorTickMarksLength { 0 };
float _minorTickMarksLength { 0 };
ScriptVec3UChar _majorTickMarksColor { DEFAULT_OVERLAY_COLOR };
ScriptVec3UChar _minorTickMarksColor { DEFAULT_OVERLAY_COLOR };
glm::u8vec3 _majorTickMarksColor { DEFAULT_OVERLAY_COLOR };
glm::u8vec3 _minorTickMarksColor { DEFAULT_OVERLAY_COLOR };
gpu::Primitive _solidPrimitive { gpu::TRIANGLE_FAN };
int _quadVerticesID { 0 };
int _lineVerticesID { 0 };

12
interface/src/ui/overlays/ContextOverlayInterface.cpp
View file

@ -62,7 +62,7 @@ ContextOverlayInterface::ContextOverlayInterface() {
glm::quat cameraOrientation = qApp->getCamera().getOrientation();
QVariantMap props;
float sensorToWorldScale = myAvatar->getSensorToWorldScale();
props.insert("position", vec3ToVariant(myAvatar->getEyePosition() + glm::quat(glm::radians(glm::vec3(0.0f, CONTEXT_OVERLAY_TABLET_OFFSET, 0.0f))) * ((CONTEXT_OVERLAY_TABLET_DISTANCE * sensorToWorldScale) * (cameraOrientation * Vectors::FRONT))));
props.insert("position", vec3toVariant(myAvatar->getEyePosition() + glm::quat(glm::radians(glm::vec3(0.0f, CONTEXT_OVERLAY_TABLET_OFFSET, 0.0f))) * ((CONTEXT_OVERLAY_TABLET_DISTANCE * sensorToWorldScale) * (cameraOrientation * Vectors::FRONT))));
props.insert("orientation", quatToVariant(cameraOrientation * glm::quat(glm::radians(glm::vec3(0.0f, CONTEXT_OVERLAY_TABLET_ORIENTATION, 0.0f)))));
qApp->getOverlays().editOverlay(tabletFrameID, props);
_contextOverlayJustClicked = false;
@ -83,7 +83,7 @@ ContextOverlayInterface::ContextOverlayInterface() {
_challengeOwnershipTimeoutTimer.setSingleShot(true);
}
static const ScriptVec3UChar CONTEXT_OVERLAY_COLOR = { 255, 255, 255 };
static const glm::u8vec3 CONTEXT_OVERLAY_COLOR = { 255, 255, 255 };
static const float CONTEXT_OVERLAY_INSIDE_DISTANCE = 1.0f; // in meters
static const float CONTEXT_OVERLAY_SIZE = 0.09f; // in meters, same x and y dims
static const float CONTEXT_OVERLAY_OFFSET_DISTANCE = 0.1f;
@ -140,10 +140,10 @@ bool ContextOverlayInterface::createOrDestroyContextOverlay(const EntityItemID&
// Add all necessary variables to the stack
EntityItemProperties entityProperties = _entityScriptingInterface->getEntityProperties(entityItemID, _entityPropertyFlags);
glm::vec3 cameraPosition = qApp->getCamera().getPosition();
glm::vec3 entityDimensions = entityProperties.getDimensions().toGlm();
glm::vec3 entityPosition = entityProperties.getPosition().toGlm();
glm::vec3 registrationPoint = entityProperties.getRegistrationPoint().toGlm();
glm::vec3 contextOverlayPosition = entityProperties.getPosition().toGlm();
glm::vec3 entityDimensions = entityProperties.getDimensions();
glm::vec3 entityPosition = entityProperties.getPosition();
glm::vec3 registrationPoint = entityProperties.getRegistrationPoint();
glm::vec3 contextOverlayPosition = entityProperties.getPosition();
glm::vec2 contextOverlayDimensions;
// Update the position of the overlay if the registration point of the entity

2
interface/src/ui/overlays/Cube3DOverlay.cpp
View file

@ -49,7 +49,7 @@ void Cube3DOverlay::render(RenderArgs* args) {
}
float alpha = getAlpha();
ScriptVec3UChar color = getColor();
glm::u8vec3 color = getColor();
glm::vec4 cubeColor(toGlm(color), alpha);
auto batch = args->_batch;

2
interface/src/ui/overlays/Grid3DOverlay.cpp
View file

@ -58,7 +58,7 @@ void Grid3DOverlay::render(RenderArgs* args) {
}
float alpha = getAlpha();
ScriptVec3UChar color = getColor();
glm::u8vec3 color = getColor();
glm::vec4 gridColor(toGlm(color), alpha);
auto batch = args->_batch;

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

@ -108,7 +108,7 @@ void Image3DOverlay::render(RenderArgs* args) {
(fromImage.y() + fromImage.height() - 0.5f) / imageHeight);
float alpha = getAlpha();
ScriptVec3UChar color = getColor();
glm::u8vec3 color = getColor();
glm::vec4 imageColor(toGlm(color), alpha);
batch->setModelTransform(getRenderTransform());
@ -241,7 +241,7 @@ QVariant Image3DOverlay::getProperty(const QString& property) {
return _fromImage;
}
if (property == "offsetPosition") {
return vec3ToVariant(getOffsetPosition());
return vec3toVariant(getOffsetPosition());
}
if (property == "emissive") {
return _emissive;

10
interface/src/ui/overlays/Line3DOverlay.cpp
View file

@ -128,7 +128,7 @@ void Line3DOverlay::render(RenderArgs* args) {
}
float alpha = getAlpha();
ScriptVec3UChar color = getColor();
glm::u8vec3 color = getColor();
glm::vec4 colorv4(toGlm(color), alpha);
auto batch = args->_batch;
if (batch) {
@ -312,10 +312,10 @@ void Line3DOverlay::setProperties(const QVariantMap& originalProperties) {
*/
QVariant Line3DOverlay::getProperty(const QString& property) {
if (property == "start" || property == "startPoint" || property == "p1") {
return vec3ToVariant(getStart());
return vec3toVariant(getStart());
}
if (property == "end" || property == "endPoint" || property == "p2") {
return vec3ToVariant(getEnd());
return vec3toVariant(getEnd());
}
if (property == "length") {
return QVariant(getLength());
@ -327,10 +327,10 @@ QVariant Line3DOverlay::getProperty(const QString& property) {
return _endParentJointIndex;
}
if (property == "localStart") {
return vec3ToVariant(getLocalStart());
return vec3toVariant(getLocalStart());
}
if (property == "localEnd") {
return vec3ToVariant(getLocalEnd());
return vec3toVariant(getLocalEnd());
}
if (property == "glow") {
return getGlow();

8
interface/src/ui/overlays/ModelOverlay.cpp
View file

@ -423,10 +423,10 @@ QVariant ModelOverlay::getProperty(const QString& property) {
return _url.toString();
}
if (property == "dimensions" || property == "size") {
return vec3ToVariant(getDimensions());
return vec3toVariant(getDimensions());
}
if (property == "scale") {
return vec3ToVariant(getSNScale());
return vec3toVariant(getSNScale());
}
if (property == "textures") {
if (_modelTextures.size() > 0) {
@ -470,7 +470,7 @@ QVariant ModelOverlay::getProperty(const QString& property) {
[this](int jointIndex) -> QVariant {
glm::vec3 translation;
_model->getJointTranslation(jointIndex, translation);
return vec3ToVariant(translation);
return vec3toVariant(translation);
});
}
@ -490,7 +490,7 @@ QVariant ModelOverlay::getProperty(const QString& property) {
[this](int jointIndex) -> QVariant {
glm::vec3 position;
_model->getJointPositionInWorldFrame(jointIndex, position);
return vec3ToVariant(position);
return vec3toVariant(position);
});
}

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

@ -15,7 +15,7 @@
#include "Application.h"
const ScriptVec3UChar Overlay::DEFAULT_OVERLAY_COLOR = { 255, 255, 255 };
const glm::u8vec3 Overlay::DEFAULT_OVERLAY_COLOR = { 255, 255, 255 };
const float Overlay::DEFAULT_ALPHA = 0.7f;
Overlay::Overlay() :
@ -116,7 +116,7 @@ QVariant Overlay::getProperty(const QString& property) {
return QVariant(getType());
}
if (property == "color") {
return vec3ToVariant(_color.toGlm());
return vec3toVariant(_color);
}
if (property == "alpha") {
return _alpha;
@ -143,13 +143,13 @@ QVariant Overlay::getProperty(const QString& property) {
return QVariant();
}
ScriptVec3UChar Overlay::getColor() {
glm::u8vec3 Overlay::getColor() {
if (_colorPulse == 0.0f) {
return _color;
}
float pulseLevel = updatePulse();
ScriptVec3UChar result = _color;
glm::u8vec3 result = _color;
if (_colorPulse < 0.0f) {
result.x *= (1.0f - pulseLevel);
result.y *= (1.0f - pulseLevel);

8
interface/src/ui/overlays/Overlay.h
View file

@ -57,7 +57,7 @@ public:
virtual bool isTransparent() { return getAlphaPulse() != 0.0f || getAlpha() != 1.0f; };
virtual bool getIsVisibleInSecondaryCamera() const { return false; }
ScriptVec3UChar getColor();
glm::u8vec3 getColor();
float getAlpha();
float getPulseMax() const { return _pulseMax; }
@ -71,7 +71,7 @@ public:
// setters
virtual void setVisible(bool visible) { _visible = visible; }
void setDrawHUDLayer(bool drawHUDLayer);
void setColor(const ScriptVec3UChar& color) { _color = color; }
void setColor(const glm::u8vec3& color) { _color = color; }
void setAlpha(float alpha) { _alpha = alpha; }
void setPulseMax(float value) { _pulseMax = value; }
@ -113,12 +113,12 @@ protected:
float _alphaPulse; // ratio of the pulse to the alpha
float _colorPulse; // ratio of the pulse to the color
ScriptVec3UChar _color;
glm::u8vec3 _color;
bool _visible; // should the overlay be drawn at all
unsigned int _stackOrder { 0 };
static const ScriptVec3UChar DEFAULT_OVERLAY_COLOR;
static const glm::u8vec3 DEFAULT_OVERLAY_COLOR;
static const float DEFAULT_ALPHA;
std::unordered_map<std::string, graphics::MultiMaterial> _materials;

8
interface/src/ui/overlays/Overlays.cpp
View file

@ -629,9 +629,9 @@ QScriptValue RayToOverlayIntersectionResultToScriptValue(QScriptEngine* engine,
obj.setProperty("distance", value.distance);
obj.setProperty("face", boxFaceToString(value.face));
QScriptValue intersection = vec3ToScriptValue(engine, value.intersection);
QScriptValue intersection = vec3FloatToScriptValue(engine, value.intersection);
obj.setProperty("intersection", intersection);
QScriptValue surfaceNormal = vec3ToScriptValue(engine, value.surfaceNormal);
QScriptValue surfaceNormal = vec3FloatToScriptValue(engine, value.surfaceNormal);
obj.setProperty("surfaceNormal", surfaceNormal);
obj.setProperty("extraInfo", engine->toScriptValue(value.extraInfo));
return obj;
@ -646,11 +646,11 @@ void RayToOverlayIntersectionResultFromScriptValue(const QScriptValue& object, R
QScriptValue intersection = object.property("intersection");
if (intersection.isValid()) {
vec3FromScriptValue(intersection, value.intersection);
vec3FloatFromScriptValue(intersection, value.intersection);
}
QScriptValue surfaceNormal = object.property("surfaceNormal");
if (surfaceNormal.isValid()) {
vec3FromScriptValue(surfaceNormal, value.surfaceNormal);
vec3FloatFromScriptValue(surfaceNormal, value.surfaceNormal);
}
value.extraInfo = object.property("extraInfo").toVariant().toMap();
}

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

@ -21,13 +21,13 @@ bool PanelAttachable::getParentVisible() const {
// No JSDoc because these properties are not actually used.
QVariant PanelAttachable::getProperty(const QString& property) {
if (property == "offsetPosition") {
return vec3ToVariant(getOffsetPosition());
return vec3toVariant(getOffsetPosition());
}
if (property == "offsetRotation") {
return quatToVariant(getOffsetRotation());
}
if (property == "offsetScale") {
return vec3ToVariant(getOffsetScale());
return vec3toVariant(getOffsetScale());
}
return QVariant();
}

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

@ -51,7 +51,7 @@ void Rectangle3DOverlay::render(RenderArgs* args) {
}
float alpha = getAlpha();
ScriptVec3UChar color = getColor();
glm::u8vec3 color = getColor();
glm::vec4 rectangleColor(toGlm(color), alpha);
auto batch = args->_batch;
@ -82,12 +82,12 @@ void Rectangle3DOverlay::render(RenderArgs* args) {
geometryCache->renderDashedLine(*batch, point4, point1, rectangleColor, _rectGeometryIds[3]);
} else {
if (halfDimensions != _previousHalfDimensions) {
QVector<ScriptVec3Float> border;
border << ScriptVec3Float(-halfDimensions.x, -halfDimensions.y, 0.0f);
border << ScriptVec3Float(halfDimensions.x, -halfDimensions.y, 0.0f);
border << ScriptVec3Float(halfDimensions.x, halfDimensions.y, 0.0f);
border << ScriptVec3Float(-halfDimensions.x, halfDimensions.y, 0.0f);
border << ScriptVec3Float(-halfDimensions.x, -halfDimensions.y, 0.0f);
QVector<glm::vec3> border;
border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);
border << glm::vec3(halfDimensions.x, -halfDimensions.y, 0.0f);
border << glm::vec3(halfDimensions.x, halfDimensions.y, 0.0f);
border << glm::vec3(-halfDimensions.x, halfDimensions.y, 0.0f);
border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);
geometryCache->updateVertices(_geometryCacheID, border, rectangleColor);
_previousHalfDimensions = halfDimensions;

2
interface/src/ui/overlays/Shape3DOverlay.cpp
View file

@ -30,7 +30,7 @@ void Shape3DOverlay::render(RenderArgs* args) {
}
float alpha = getAlpha();
ScriptVec3UChar color = getColor();
glm::u8vec3 color = getColor();
glm::vec4 shapeColor(toGlm(color), alpha);
auto batch = args->_batch;

2
interface/src/ui/overlays/Sphere3DOverlay.cpp
View file

@ -77,7 +77,7 @@ void Sphere3DOverlay::render(RenderArgs* args) {
}
float alpha = getAlpha();
ScriptVec3UChar color = getColor();
glm::u8vec3 color = getColor();
glm::vec4 sphereColor(toGlm(color), alpha);
auto batch = args->_batch;

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

@ -64,13 +64,13 @@ void Text3DOverlay::setText(const QString& text) {
_text = text;
}
ScriptVec3UChar Text3DOverlay::getBackgroundColor() {
glm::u8vec3 Text3DOverlay::getBackgroundColor() {
if (_colorPulse == 0.0f) {
return _backgroundColor;
}
float pulseLevel = updatePulse();
ScriptVec3UChar result = _backgroundColor;
glm::u8vec3 result = _backgroundColor;
if (_colorPulse < 0.0f) {
result.x *= (1.0f - pulseLevel);
result.y *= (1.0f - pulseLevel);
@ -94,7 +94,7 @@ void Text3DOverlay::render(RenderArgs* args) {
auto transform = getRenderTransform();
batch.setModelTransform(transform);
ScriptVec3UChar backgroundColor = getBackgroundColor();
glm::u8vec3 backgroundColor = getBackgroundColor();
glm::vec4 quadColor(toGlm(backgroundColor), getBackgroundAlpha());
glm::vec2 dimensions = getDimensions();
@ -258,7 +258,7 @@ QVariant Text3DOverlay::getProperty(const QString& property) {
return _textAlpha;
}
if (property == "backgroundColor") {
return vec3ToVariant(_backgroundColor.toGlm());
return vec3toVariant(_backgroundColor);
}
if (property == "backgroundAlpha") {
return Billboard3DOverlay::getProperty("alpha");

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

@ -39,7 +39,7 @@ public:
float getTopMargin() const { return _topMargin; }
float getRightMargin() const { return _rightMargin; }
float getBottomMargin() const { return _bottomMargin; }
ScriptVec3UChar getBackgroundColor();
glm::u8vec3 getBackgroundColor();
float getTextAlpha() { return _textAlpha; }
float getBackgroundAlpha() { return getAlpha(); }
bool isTransparent() override { return Overlay::isTransparent() || _textAlpha < 1.0f; }
@ -65,7 +65,7 @@ private:
QString _text;
mutable QMutex _mutex; // used to make get/setText threadsafe, mutable so can be used in const functions
ScriptVec3UChar _backgroundColor { 0, 0, 0 };
glm::u8vec3 _backgroundColor { 0, 0, 0 };
float _textAlpha { 1.0f };
float _lineHeight { 1.0f };
float _leftMargin { 0.1f };

2
interface/src/ui/overlays/Volume3DOverlay.cpp
View file

@ -69,7 +69,7 @@ void Volume3DOverlay::setProperties(const QVariantMap& properties) {
*/
QVariant Volume3DOverlay::getProperty(const QString& property) {
if (property == "dimensions" || property == "scale" || property == "size") {
return vec3ToVariant(getDimensions());
return vec3toVariant(getDimensions());
}
return Base3DOverlay::getProperty(property);

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

@ -190,7 +190,7 @@ void Web3DOverlay::buildWebSurface() {
_webSurface->load(_url);
_cachedWebSurface = false;
}
_webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3ToVariant(getWorldPosition()));
_webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3toVariant(getWorldPosition()));
onResizeWebSurface();
_webSurface->resume();
});
@ -202,7 +202,7 @@ void Web3DOverlay::buildWebSurface() {
void Web3DOverlay::update(float deltatime) {
if (_webSurface) {
// update globalPosition
_webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3ToVariant(getWorldPosition()));
_webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3toVariant(getWorldPosition()));
}
Parent::update(deltatime);
}

2
libraries/animation/src/AnimVariant.cpp
View file

@ -40,7 +40,7 @@ QScriptValue AnimVariantMap::animVariantMapToScriptValue(QScriptEngine* engine,
target.setProperty(name, value.getString());
break;
case AnimVariant::Type::Vec3:
target.setProperty(name, vec3ToScriptValue(engine, value.getVec3()));
target.setProperty(name, vec3FloatToScriptValue(engine, value.getVec3()));
break;
case AnimVariant::Type::Quat:
target.setProperty(name, quatToScriptValue(engine, value.getQuat()));

4
libraries/audio/src/AudioInjectorOptions.cpp
View file

@ -34,7 +34,7 @@ AudioInjectorOptions::AudioInjectorOptions() :
QScriptValue injectorOptionsToScriptValue(QScriptEngine* engine, const AudioInjectorOptions& injectorOptions) {
QScriptValue obj = engine->newObject();
obj.setProperty("position", vec3ToScriptValue(engine, injectorOptions.position));
obj.setProperty("position", vec3FloatToScriptValue(engine, injectorOptions.position));
obj.setProperty("volume", injectorOptions.volume);
obj.setProperty("loop", injectorOptions.loop);
obj.setProperty("orientation", quatToScriptValue(engine, injectorOptions.orientation));
@ -73,7 +73,7 @@ void injectorOptionsFromScriptValue(const QScriptValue& object, AudioInjectorOpt
it.next();
if (it.name() == "position") {
vec3FromScriptValue(object.property("position"), injectorOptions.position);
vec3FloatFromScriptValue(object.property("position"), injectorOptions.position);
} else if (it.name() == "orientation") {
quatFromScriptValue(object.property("orientation"), injectorOptions.orientation);
} else if (it.name() == "volume") {

2
libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
View file

@ -1504,7 +1504,7 @@ void Avatar::renderJointConnectingCone(gpu::Batch& batch, glm::vec3 position1, g
perpSin = glm::cross(perpCos, axis);
float angleb = 0.0f;
QVector<ScriptVec3Float> points;
QVector<glm::vec3> points;
for (int i = 0; i < NUM_BODY_CONE_SIDES; i ++) {

8
libraries/avatars/src/AvatarData.cpp
View file

@ -2723,10 +2723,10 @@ QScriptValue RayToAvatarIntersectionResultToScriptValue(QScriptEngine* engine, c
obj.setProperty("avatarID", avatarIDValue);
obj.setProperty("distance", value.distance);
obj.setProperty("face", boxFaceToString(value.face));
QScriptValue intersection = vec3ToScriptValue(engine, value.intersection);
QScriptValue intersection = vec3FloatToScriptValue(engine, value.intersection);
obj.setProperty("intersection", intersection);
QScriptValue surfaceNormal = vec3ToScriptValue(engine, value.surfaceNormal);
QScriptValue surfaceNormal = vec3FloatToScriptValue(engine, value.surfaceNormal);
obj.setProperty("surfaceNormal", surfaceNormal);
obj.setProperty("extraInfo", engine->toScriptValue(value.extraInfo));
return obj;
@ -2741,11 +2741,11 @@ void RayToAvatarIntersectionResultFromScriptValue(const QScriptValue& object, Ra
QScriptValue intersection = object.property("intersection");
if (intersection.isValid()) {
vec3FromScriptValue(intersection, value.intersection);
vec3FloatFromScriptValue(intersection, value.intersection);
}
QScriptValue surfaceNormal = object.property("surfaceNormal");
if (surfaceNormal.isValid()) {
vec3FromScriptValue(surfaceNormal, value.surfaceNormal);
vec3FloatFromScriptValue(surfaceNormal, value.surfaceNormal);
}
value.extraInfo = object.property("extraInfo").toVariant().toMap();
}

12
libraries/controllers/src/controllers/Pose.cpp
View file

@ -41,10 +41,10 @@ namespace controller {
*/
QScriptValue Pose::toScriptValue(QScriptEngine* engine, const Pose& pose) {
QScriptValue obj = engine->newObject();
obj.setProperty("translation", vec3ToScriptValue(engine, pose.translation));
obj.setProperty("translation", vec3FloatToScriptValue(engine, pose.translation));
obj.setProperty("rotation", quatToScriptValue(engine, pose.rotation));
obj.setProperty("velocity", vec3ToScriptValue(engine, pose.velocity));
obj.setProperty("angularVelocity", vec3ToScriptValue(engine, pose.angularVelocity));
obj.setProperty("velocity", vec3FloatToScriptValue(engine, pose.velocity));
obj.setProperty("angularVelocity", vec3FloatToScriptValue(engine, pose.angularVelocity));
obj.setProperty("valid", pose.valid);
return obj;
}
@ -58,10 +58,10 @@ namespace controller {
rotation.isValid() &&
velocity.isValid() &&
angularVelocity.isValid()) {
vec3FromScriptValue(translation, pose.translation);
vec3FloatFromScriptValue(translation, pose.translation);
quatFromScriptValue(rotation, pose.rotation);
vec3FromScriptValue(velocity, pose.velocity);
vec3FromScriptValue(angularVelocity, pose.angularVelocity);
vec3FloatFromScriptValue(velocity, pose.velocity);
vec3FloatFromScriptValue(angularVelocity, pose.angularVelocity);
pose.valid = true;
} else {
pose.valid = false;

2
libraries/entities-renderer/src/RenderableLineEntityItem.h
View file

@ -34,7 +34,7 @@ protected:
private:
int _lineVerticesID { GeometryCache::UNKNOWN_ID };
QVector<ScriptVec3Float> _linePoints;
QVector<glm::vec3> _linePoints;
};
} } // namespace

4
libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp
View file

@ -31,8 +31,8 @@ void MaterialEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer&
withWriteLock([&] {
_drawMaterial = entity->getMaterial();
_parentID = entity->getParentID();
_materialMappingPos = entity->getMaterialMappingPos().toGlm();
_materialMappingScale = entity->getMaterialMappingScale().toGlm();
_materialMappingPos = entity->getMaterialMappingPos();
_materialMappingScale = entity->getMaterialMappingScale();
_materialMappingRot = entity->getMaterialMappingRot();
_renderTransform = getModelTransform();
const float MATERIAL_ENTITY_SCALE = 0.5f;

4
libraries/entities-renderer/src/RenderableModelEntityItem.cpp
View file

@ -917,7 +917,7 @@ void RenderableModelEntityItem::setJointRotationsSet(const QVector<bool>& rotati
_needsJointSimulation = true;
}
void RenderableModelEntityItem::setJointTranslations(const QVector<ScriptVec3Float>& translations) {
void RenderableModelEntityItem::setJointTranslations(const QVector<glm::vec3>& translations) {
ModelEntityItem::setJointTranslations(translations);
_needsJointSimulation = true;
}
@ -1033,7 +1033,7 @@ void RenderableModelEntityItem::copyAnimationJointDataToModel() {
changed = true;
}
if (jointData.translationDirty) {
model->setJointTranslation(index, true, jointData.joint.translation.toGlm(), 1.0f);
model->setJointTranslation(index, true, jointData.joint.translation, 1.0f);
jointData.translationDirty = false;
changed = true;
}

2
libraries/entities-renderer/src/RenderableModelEntityItem.h
View file

@ -105,7 +105,7 @@ public:
virtual void setJointRotations(const QVector<glm::quat>& rotations) override;
virtual void setJointRotationsSet(const QVector<bool>& rotationsSet) override;
virtual void setJointTranslations(const QVector<ScriptVec3Float>& translations) override;
virtual void setJointTranslations(const QVector<glm::vec3>& translations) override;
virtual void setJointTranslationsSet(const QVector<bool>& translationsSet) override;
virtual void locationChanged(bool tellPhysics = true) override;

22
libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp
View file

@ -142,7 +142,7 @@ void PolyLineEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPo
}
if (strokeColorsChanged) {
_lastStrokeColors = entity->getStrokeColors();
_lastStrokeColors = _lastNormals.size() == _lastStrokeColors.size() ? _lastStrokeColors : QVector<ScriptVec3Float>({ toGlm(entity->getColor()) });
_lastStrokeColors = _lastNormals.size() == _lastStrokeColors.size() ? _lastStrokeColors : QVector<glm::vec3>({ toGlm(entity->getColor()) });
}
if (pointsChanged || strokeWidthsChanged || normalsChanged || strokeColorsChanged) {
_empty = std::min(_lastPoints.size(), std::min(_lastNormals.size(), _lastStrokeWidths.size())) < 2;
@ -161,10 +161,10 @@ void PolyLineEntityRenderer::updateGeometry(const std::vector<Vertex>& vertices)
_verticesBuffer->setSubData(0, vertices);
}
std::vector<PolyLineEntityRenderer::Vertex> PolyLineEntityRenderer::updateVertices(const QVector<ScriptVec3Float>& points,
const QVector<ScriptVec3Float>& normals,
std::vector<PolyLineEntityRenderer::Vertex> PolyLineEntityRenderer::updateVertices(const QVector<glm::vec3>& points,
const QVector<glm::vec3>& normals,
const QVector<float>& strokeWidths,
const QVector<ScriptVec3Float>& strokeColors,
const QVector<glm::vec3>& strokeColors,
const bool isUVModeStretch,
const float textureAspectRatio) {
// Calculate the minimum vector size out of normals, points, and stroke widths
@ -197,14 +197,14 @@ std::vector<PolyLineEntityRenderer::Vertex> PolyLineEntityRenderer::updateVertic
for (int i = 0; i <= finalIndex; i++) {
const float& width = strokeWidths.at(i);
const auto& point = points.at(i).toGlm();
const auto& normal = normals.at(i).toGlm();
const auto& color = strokeColors.size() == normals.size() ? strokeColors.at(i).toGlm() : strokeColors.at(0).toGlm();
const auto& point = points.at(i);
const auto& normal = normals.at(i);
const auto& color = strokeColors.size() == normals.size() ? strokeColors.at(i) : strokeColors.at(0);
int vertexIndex = i * 2;
if (!isUVModeStretch && i >= 1) {
distanceToLastPoint = glm::distance(points.at(i).toGlm(), points.at(i - 1).toGlm());
distanceToLastPoint = glm::distance(points.at(i), points.at(i - 1));
accumulatedDistance += distanceToLastPoint;
strokeWidth = 2 * strokeWidths[i];
@ -230,7 +230,7 @@ std::vector<PolyLineEntityRenderer::Vertex> PolyLineEntityRenderer::updateVertic
// For last point we can assume binormals are the same since it represents the last two vertices of quad
if (i < finalIndex) {
const auto tangent = points.at(i + 1).toGlm() - point;
const auto tangent = points.at(i + 1) - point;
binormal = glm::normalize(glm::cross(tangent, normal)) * width;
// Check to make sure binormal is not a NAN. If it is, don't add to vertices vector
@ -239,8 +239,8 @@ std::vector<PolyLineEntityRenderer::Vertex> PolyLineEntityRenderer::updateVertic
}
}
const auto v1 = points.at(i).toGlm() + binormal;
const auto v2 = points.at(i).toGlm() - binormal;
const auto v1 = points.at(i) + binormal;
const auto v2 = points.at(i) - binormal;
vertices.emplace_back(v1, normal, vec2(uCoord, 0.0f), color);
vertices.emplace_back(v2, normal, vec2(uCoord, 1.0f), color);
}

12
libraries/entities-renderer/src/RenderablePolyLineEntityItem.h
View file

@ -52,17 +52,17 @@ protected:
};
void updateGeometry(const std::vector<Vertex>& vertices);
static std::vector<Vertex> updateVertices(const QVector<ScriptVec3Float>& points,
const QVector<ScriptVec3Float>& normals,
static std::vector<Vertex> updateVertices(const QVector<glm::vec3>& points,
const QVector<glm::vec3>& normals,
const QVector<float>& strokeWidths,
const QVector<ScriptVec3Float>& strokeColors,
const QVector<glm::vec3>& strokeColors,
const bool isUVModeStretch,
const float textureAspectRatio);
Transform _polylineTransform;
QVector<ScriptVec3Float> _lastPoints;
QVector<ScriptVec3Float> _lastNormals;
QVector<ScriptVec3Float> _lastStrokeColors;
QVector<glm::vec3> _lastPoints;
QVector<glm::vec3> _lastNormals;
QVector<glm::vec3> _lastStrokeColors;
QVector<float> _lastStrokeWidths;
gpu::BufferPointer _verticesBuffer;

26
libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp
View file

@ -211,7 +211,7 @@ void RenderablePolyVoxEntityItem::setVoxelSurfaceStyle(PolyVoxSurfaceStyle voxel
glm::vec3 RenderablePolyVoxEntityItem::getSurfacePositionAdjustment() const {
glm::vec3 result;
withReadLock([&] {
glm::vec3 scale = getScaledDimensions() / _voxelVolumeSize.toGlm(); // meters / voxel-units
glm::vec3 scale = getScaledDimensions() / _voxelVolumeSize; // meters / voxel-units
if (isEdged(_voxelSurfaceStyle)) {
result = scale / -2.0f;
}
@ -223,7 +223,7 @@ glm::vec3 RenderablePolyVoxEntityItem::getSurfacePositionAdjustment() const {
glm::mat4 RenderablePolyVoxEntityItem::voxelToLocalMatrix() const {
glm::vec3 voxelVolumeSize;
withReadLock([&] {
voxelVolumeSize = _voxelVolumeSize.toGlm();
voxelVolumeSize = _voxelVolumeSize;
});
glm::vec3 dimensions = getScaledDimensions();
@ -309,7 +309,7 @@ bool RenderablePolyVoxEntityItem::setAll(uint8_t toValue) {
}
withWriteLock([&] {
loop3(ivec3(0), ivec3(_voxelVolumeSize.toGlm()), [&](const ivec3& v) {
loop3(ivec3(0), ivec3(_voxelVolumeSize), [&](const ivec3& v) {
result |= setVoxelInternal(v, toValue);
});
});
@ -328,7 +328,7 @@ bool RenderablePolyVoxEntityItem::setCuboid(const glm::vec3& lowPosition, const
ivec3 iLowPosition = ivec3{ glm::round(lowPosition) };
ivec3 iCuboidSize = ivec3{ glm::round(cuboidSize) };
ivec3 iVoxelVolumeSize = ivec3{ glm::round(_voxelVolumeSize.toGlm()) };
ivec3 iVoxelVolumeSize = ivec3{ glm::round(_voxelVolumeSize) };
ivec3 low = glm::max(glm::min(iLowPosition, iVoxelVolumeSize - 1), ivec3(0));
ivec3 high = glm::max(glm::min(low + iCuboidSize, iVoxelVolumeSize), low);
@ -364,7 +364,7 @@ bool RenderablePolyVoxEntityItem::setSphereInVolume(const vec3& center, float ra
float radiusSquared = radius * radius;
// This three-level for loop iterates over every voxel in the volume
withWriteLock([&] {
loop3(ivec3(0), ivec3(_voxelVolumeSize.toGlm()), [&](const ivec3& v) {
loop3(ivec3(0), ivec3(_voxelVolumeSize), [&](const ivec3& v) {
// Store our current position as a vector...
glm::vec3 pos = vec3(v) + 0.5f; // consider voxels cenetered on their coordinates
// And compute how far the current position is from the center of the volume
@ -392,7 +392,7 @@ bool RenderablePolyVoxEntityItem::setSphere(const vec3& centerWorldCoords, float
glm::mat4 wtvMatrix = glm::inverse(vtwMatrix);
glm::vec3 dimensions = getScaledDimensions();
glm::vec3 voxelSize = dimensions / _voxelVolumeSize.toGlm();
glm::vec3 voxelSize = dimensions / _voxelVolumeSize;
float smallestDimensionSize = voxelSize.x;
smallestDimensionSize = glm::min(smallestDimensionSize, voxelSize.y);
smallestDimensionSize = glm::min(smallestDimensionSize, voxelSize.z);
@ -406,8 +406,8 @@ bool RenderablePolyVoxEntityItem::setSphere(const vec3& centerWorldCoords, float
glm::vec3 low = glm::floor(centerInVoxelCoords - maxRadiusInVoxelCoords);
glm::vec3 high = glm::ceil(centerInVoxelCoords + maxRadiusInVoxelCoords);
glm::ivec3 lowI = glm::clamp(low, glm::vec3(0.0f), _voxelVolumeSize.toGlm());
glm::ivec3 highI = glm::clamp(high, glm::vec3(0.0f), _voxelVolumeSize.toGlm());
glm::ivec3 lowI = glm::clamp(low, glm::vec3(0.0f), _voxelVolumeSize);
glm::ivec3 highI = glm::clamp(high, glm::vec3(0.0f), _voxelVolumeSize);
glm::vec3 radials(radiusWorldCoords / voxelSize.x,
radiusWorldCoords / voxelSize.y,
@ -453,7 +453,7 @@ bool RenderablePolyVoxEntityItem::setCapsule(const vec3& startWorldCoords, const
glm::mat4 wtvMatrix = glm::inverse(vtwMatrix);
glm::vec3 dimensions = getScaledDimensions();
glm::vec3 voxelSize = dimensions / _voxelVolumeSize.toGlm();
glm::vec3 voxelSize = dimensions / _voxelVolumeSize;
float smallestDimensionSize = voxelSize.x;
smallestDimensionSize = glm::min(smallestDimensionSize, voxelSize.y);
smallestDimensionSize = glm::min(smallestDimensionSize, voxelSize.z);
@ -468,8 +468,8 @@ bool RenderablePolyVoxEntityItem::setCapsule(const vec3& startWorldCoords, const
glm::vec3 high = glm::max(glm::ceil(startInVoxelCoords + maxRadiusInVoxelCoords),
glm::ceil(endInVoxelCoords + maxRadiusInVoxelCoords));
glm::ivec3 lowI = glm::clamp(low, glm::vec3(0.0f), _voxelVolumeSize.toGlm());
glm::ivec3 highI = glm::clamp(high, glm::vec3(0.0f), _voxelVolumeSize.toGlm());
glm::ivec3 lowI = glm::clamp(low, glm::vec3(0.0f), _voxelVolumeSize);
glm::ivec3 highI = glm::clamp(high, glm::vec3(0.0f), _voxelVolumeSize);
// This three-level for loop iterates over every voxel in the volume that might be in the capsule
withWriteLock([&] {
@ -778,7 +778,7 @@ bool RenderablePolyVoxEntityItem::updateDependents() {
return !volDataDirty;
}
void RenderablePolyVoxEntityItem::setVoxelVolumeSize(const ScriptVec3Float& voxelVolumeSize) {
void RenderablePolyVoxEntityItem::setVoxelVolumeSize(const glm::vec3& voxelVolumeSize) {
// This controls how many individual voxels are in the entity. This is unrelated to
// the dimentions of the entity -- it defines the sizes of the arrays that hold voxel values.
// In addition to setting the number of voxels, this is used in a few places for its
@ -1245,7 +1245,7 @@ void RenderablePolyVoxEntityItem::computeShapeInfoWorker() {
withReadLock([&] {
voxelSurfaceStyle = _voxelSurfaceStyle;
voxelVolumeSize = _voxelVolumeSize.toGlm();
voxelVolumeSize = _voxelVolumeSize;
mesh = _mesh;
});

2
libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h
View file

@ -62,7 +62,7 @@ public:
QVariantMap& extraInfo, bool precisionPicking) const override;
virtual void setVoxelData(const QByteArray& voxelData) override;
virtual void setVoxelVolumeSize(const ScriptVec3Float& voxelVolumeSize) override;
virtual void setVoxelVolumeSize(const glm::vec3& voxelVolumeSize) override;
virtual void setVoxelSurfaceStyle(PolyVoxSurfaceStyle voxelSurfaceStyle) override;
glm::vec3 getSurfacePositionAdjustment() const;

2
libraries/entities-renderer/src/RenderableWebEntityItem.cpp
View file

@ -199,7 +199,7 @@ void WebEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scene
if (_contextPosition != entity->getWorldPosition()) {
// update globalPosition
_contextPosition = entity->getWorldPosition();
_webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3ToVariant(_contextPosition));
_webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3toVariant(_contextPosition));
}
_lastDPI = entity->getDPI();

6
libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
View file

@ -333,7 +333,7 @@ void ZoneEntityRenderer::updateKeySunFromEntity(const TypedEntityPointer& entity
// Set the keylight
sunLight->setColor(ColorUtils::toVec3(_keyLightProperties.getColor()));
sunLight->setIntensity(_keyLightProperties.getIntensity());
sunLight->setDirection(entity->getTransform().getRotation() * _keyLightProperties.getDirection().toGlm());
sunLight->setDirection(entity->getTransform().getRotation() * _keyLightProperties.getDirection());
sunLight->setCastShadows(_keyLightProperties.getCastShadows());
}
@ -368,9 +368,9 @@ void ZoneEntityRenderer::updateHazeFromEntity(const TypedEntityPointer& entity)
haze->setAltitudeBased(_hazeProperties.getHazeAltitudeEffect());
haze->setHazeRangeFactor(graphics::Haze::convertHazeRangeToHazeRangeFactor(_hazeProperties.getHazeRange()));
ScriptVec3UChar hazeColor = _hazeProperties.getHazeColor();
glm::u8vec3 hazeColor = _hazeProperties.getHazeColor();
haze->setHazeColor(toGlm(hazeColor));
ScriptVec3UChar hazeGlareColor = _hazeProperties.getHazeGlareColor();
glm::u8vec3 hazeGlareColor = _hazeProperties.getHazeGlareColor();
haze->setHazeGlareColor(toGlm(hazeGlareColor));
haze->setHazeEnableGlare(_hazeProperties.getHazeEnableGlare());
haze->setHazeGlareBlend(graphics::Haze::convertGlareAngleToPower(_hazeProperties.getHazeGlareAngle()));

8
libraries/entities/src/EntityEditFilters.cpp
View file

@ -104,10 +104,10 @@ bool EntityEditFilters::filter(glm::vec3& position, EntityItemProperties& proper
AABox aaBox = zoneEntity->getAABox(success);
if (success) {
QScriptValue boundingBox = filterData.engine->newObject();
QScriptValue bottomRightNear = vec3ToScriptValue(filterData.engine, aaBox.getCorner());
QScriptValue topFarLeft = vec3ToScriptValue(filterData.engine, aaBox.calcTopFarLeft());
QScriptValue center = vec3ToScriptValue(filterData.engine, aaBox.calcCenter());
QScriptValue boundingBoxDimensions = vec3ToScriptValue(filterData.engine, aaBox.getDimensions());
QScriptValue bottomRightNear = vec3FloatToScriptValue(filterData.engine, aaBox.getCorner());
QScriptValue topFarLeft = vec3FloatToScriptValue(filterData.engine, aaBox.calcTopFarLeft());
QScriptValue center = vec3FloatToScriptValue(filterData.engine, aaBox.calcCenter());
QScriptValue boundingBoxDimensions = vec3FloatToScriptValue(filterData.engine, aaBox.getDimensions());
boundingBox.setProperty("brn", bottomRightNear);
boundingBox.setProperty("tfl", topFarLeft);
boundingBox.setProperty("center", center);

44
libraries/entities/src/EntityItem.cpp
View file

@ -238,15 +238,15 @@ OctreeElement::AppendState EntityItem::appendEntityData(OctreePacketData* packet
// PROP_CUSTOM_PROPERTIES_INCLUDED,
APPEND_ENTITY_PROPERTY(PROP_SIMULATION_OWNER, _simulationOwner.toByteArray());
APPEND_ENTITY_PROPERTY(PROP_POSITION, getScriptLocalPosition());
APPEND_ENTITY_PROPERTY(PROP_POSITION, getLocalPosition());
APPEND_ENTITY_PROPERTY(PROP_ROTATION, getLocalOrientation());
APPEND_ENTITY_PROPERTY(PROP_VELOCITY, getScriptLocalVelocity());
APPEND_ENTITY_PROPERTY(PROP_ANGULAR_VELOCITY, getScriptLocalAngularVelocity());
APPEND_ENTITY_PROPERTY(PROP_ACCELERATION, getScriptAcceleration());
APPEND_ENTITY_PROPERTY(PROP_VELOCITY, getLocalVelocity());
APPEND_ENTITY_PROPERTY(PROP_ANGULAR_VELOCITY, getLocalAngularVelocity());
APPEND_ENTITY_PROPERTY(PROP_ACCELERATION, getAcceleration());
APPEND_ENTITY_PROPERTY(PROP_DIMENSIONS, getScriptUnscaledDimensions());
APPEND_ENTITY_PROPERTY(PROP_DIMENSIONS, getUnscaledDimensions());
APPEND_ENTITY_PROPERTY(PROP_DENSITY, getDensity());
APPEND_ENTITY_PROPERTY(PROP_GRAVITY, getScriptGravity());
APPEND_ENTITY_PROPERTY(PROP_GRAVITY, getGravity());
APPEND_ENTITY_PROPERTY(PROP_DAMPING, getDamping());
APPEND_ENTITY_PROPERTY(PROP_RESTITUTION, getRestitution());
APPEND_ENTITY_PROPERTY(PROP_FRICTION, getFriction());
@ -254,7 +254,7 @@ OctreeElement::AppendState EntityItem::appendEntityData(OctreePacketData* packet
APPEND_ENTITY_PROPERTY(PROP_SCRIPT, getScript());
APPEND_ENTITY_PROPERTY(PROP_SCRIPT_TIMESTAMP, getScriptTimestamp());
APPEND_ENTITY_PROPERTY(PROP_SERVER_SCRIPTS, getServerScripts());
APPEND_ENTITY_PROPERTY(PROP_REGISTRATION_POINT, getScriptRegistrationPoint());
APPEND_ENTITY_PROPERTY(PROP_REGISTRATION_POINT, getRegistrationPoint());
APPEND_ENTITY_PROPERTY(PROP_ANGULAR_DAMPING, getAngularDamping());
APPEND_ENTITY_PROPERTY(PROP_VISIBLE, getVisible());
APPEND_ENTITY_PROPERTY(PROP_CAN_CAST_SHADOW, getCanCastShadow());
@ -766,11 +766,11 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
// Note: duplicate packets are expected and not wrong. They may be sent for any number of
// reasons and the contract is that the client handles them in an idempotent manner.
auto customUpdatePositionFromNetwork = [this, shouldUpdate, lastEdited](ScriptVec3Float value){
auto customUpdatePositionFromNetwork = [this, shouldUpdate, lastEdited](glm::vec3 value){
if (shouldUpdate(_lastUpdatedPositionTimestamp, value != _lastUpdatedPositionValue)) {
setPosition(value);
_lastUpdatedPositionTimestamp = lastEdited;
_lastUpdatedPositionValue = value.toGlm();
_lastUpdatedPositionValue = value;
}
};
@ -782,40 +782,40 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
}
};
auto customUpdateVelocityFromNetwork = [this, shouldUpdate, lastEdited](ScriptVec3Float value){
auto customUpdateVelocityFromNetwork = [this, shouldUpdate, lastEdited](glm::vec3 value){
if (shouldUpdate(_lastUpdatedVelocityTimestamp, value != _lastUpdatedVelocityValue)) {
setVelocity(value);
_lastUpdatedVelocityTimestamp = lastEdited;
_lastUpdatedVelocityValue = value.toGlm();
_lastUpdatedVelocityValue = value;
}
};
auto customUpdateAngularVelocityFromNetwork = [this, shouldUpdate, lastEdited](ScriptVec3Float value){
auto customUpdateAngularVelocityFromNetwork = [this, shouldUpdate, lastEdited](glm::vec3 value){
if (shouldUpdate(_lastUpdatedAngularVelocityTimestamp, value != _lastUpdatedAngularVelocityValue)) {
setAngularVelocity(value);
_lastUpdatedAngularVelocityTimestamp = lastEdited;
_lastUpdatedAngularVelocityValue = value.toGlm();
_lastUpdatedAngularVelocityValue = value;
}
};
auto customSetAcceleration = [this, shouldUpdate, lastEdited](ScriptVec3Float value){
auto customSetAcceleration = [this, shouldUpdate, lastEdited](glm::vec3 value){
if (shouldUpdate(_lastUpdatedAccelerationTimestamp, value != _lastUpdatedAccelerationValue)) {
setAcceleration(value);
_lastUpdatedAccelerationTimestamp = lastEdited;
_lastUpdatedAccelerationValue = value.toGlm();
_lastUpdatedAccelerationValue = value;
}
};
READ_ENTITY_PROPERTY(PROP_POSITION, ScriptVec3Float, customUpdatePositionFromNetwork);
READ_ENTITY_PROPERTY(PROP_POSITION, glm::vec3, customUpdatePositionFromNetwork);
READ_ENTITY_PROPERTY(PROP_ROTATION, glm::quat, customUpdateRotationFromNetwork);
READ_ENTITY_PROPERTY(PROP_VELOCITY, ScriptVec3Float, customUpdateVelocityFromNetwork);
READ_ENTITY_PROPERTY(PROP_ANGULAR_VELOCITY, ScriptVec3Float, customUpdateAngularVelocityFromNetwork);
READ_ENTITY_PROPERTY(PROP_ACCELERATION, ScriptVec3Float, customSetAcceleration);
READ_ENTITY_PROPERTY(PROP_VELOCITY, glm::vec3, customUpdateVelocityFromNetwork);
READ_ENTITY_PROPERTY(PROP_ANGULAR_VELOCITY, glm::vec3, customUpdateAngularVelocityFromNetwork);
READ_ENTITY_PROPERTY(PROP_ACCELERATION, glm::vec3, customSetAcceleration);
}
READ_ENTITY_PROPERTY(PROP_DIMENSIONS, ScriptVec3Float, setUnscaledDimensions);
READ_ENTITY_PROPERTY(PROP_DIMENSIONS, glm::vec3, setUnscaledDimensions);
READ_ENTITY_PROPERTY(PROP_DENSITY, float, setDensity);
READ_ENTITY_PROPERTY(PROP_GRAVITY, ScriptVec3Float, setGravity);
READ_ENTITY_PROPERTY(PROP_GRAVITY, glm::vec3, setGravity);
READ_ENTITY_PROPERTY(PROP_DAMPING, float, setDamping);
READ_ENTITY_PROPERTY(PROP_RESTITUTION, float, setRestitution);
@ -836,7 +836,7 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
READ_ENTITY_PROPERTY(PROP_SERVER_SCRIPTS, QString, setServerScripts);
}
READ_ENTITY_PROPERTY(PROP_REGISTRATION_POINT, ScriptVec3Float, setRegistrationPoint);
READ_ENTITY_PROPERTY(PROP_REGISTRATION_POINT, glm::vec3, setRegistrationPoint);
READ_ENTITY_PROPERTY(PROP_ANGULAR_DAMPING, float, setAngularDamping);
READ_ENTITY_PROPERTY(PROP_VISIBLE, bool, setVisible);

11
libraries/entities/src/EntityItem.h
View file

@ -192,9 +192,7 @@ public:
virtual glm::vec3 getRaycastDimensions() const { return getScaledDimensions(); }
glm::vec3 getUnscaledDimensions() const;
ScriptVec3Float getScriptUnscaledDimensions() const { return getUnscaledDimensions(); }
virtual void setUnscaledDimensions(const glm::vec3& value);
void setUnscaledDimensions(const ScriptVec3Float& value) { setUnscaledDimensions(value.toGlm()); }
float getLocalRenderAlpha() const;
void setLocalRenderAlpha(float localRenderAlpha);
@ -209,15 +207,11 @@ public:
bool hasLocalVelocity() const { return getLocalVelocity() != ENTITY_ITEM_ZERO_VEC3; }
glm::vec3 getGravity() const; /// get gravity in meters
ScriptVec3Float getScriptGravity() const { return getGravity(); }
void setGravity(const glm::vec3& value); /// gravity in meters
void setGravity(const ScriptVec3Float& value) { setGravity(value.toGlm()); }
bool hasGravity() const { return getGravity() != ENTITY_ITEM_ZERO_VEC3; }
glm::vec3 getAcceleration() const; /// get acceleration in meters/second/second
ScriptVec3Float getScriptAcceleration() const { return getAcceleration(); }
void setAcceleration(const glm::vec3& value); /// acceleration in meters/second/second
void setAcceleration(const ScriptVec3Float& value) { setAcceleration(value.toGlm()); }
bool hasAcceleration() const { return getAcceleration() != ENTITY_ITEM_ZERO_VEC3; }
float getDamping() const;
@ -269,16 +263,13 @@ public:
void setCollisionSoundURL(const QString& value);
glm::vec3 getRegistrationPoint() const; /// registration point as ratio of entity
ScriptVec3Float getScriptRegistrationPoint() const { return getRegistrationPoint(); }
/// registration point as ratio of entity
virtual void setRegistrationPoint(const glm::vec3& value); // FIXME: this is suspicious!
void setRegistrationPoint(const ScriptVec3Float& value) { setRegistrationPoint(value.toGlm()); }
bool hasAngularVelocity() const { return getWorldAngularVelocity() != ENTITY_ITEM_ZERO_VEC3; }
bool hasLocalAngularVelocity() const { return getLocalAngularVelocity() != ENTITY_ITEM_ZERO_VEC3; }
virtual void setAngularVelocity(const glm::vec3& angularVelocity);
void setAngularVelocity(const ScriptVec3Float& angularVelocity) { setAngularVelocity(angularVelocity.toGlm()); }
float getAngularDamping() const;
void setAngularDamping(float value);
@ -391,13 +382,11 @@ public:
virtual ShapeType getShapeType() const { return SHAPE_TYPE_NONE; }
void setPosition(const glm::vec3& value);
void setPosition(const ScriptVec3Float& value) { setPosition(value.toGlm()); }
virtual void setParentID(const QUuid& parentID) override;
virtual void setShapeType(ShapeType type) { /* do nothing */ }
void setRotation(glm::quat orientation);
void setVelocity(const glm::vec3& velocity);
void setVelocity(const ScriptVec3Float& velocity) { setVelocity(velocity.toGlm()); }
uint32_t getDirtyFlags() const;
void markDirtyFlags(uint32_t mask);

216
libraries/entities/src/EntityItemProperties.cpp
View file

@ -60,8 +60,8 @@ EntityItemProperties::EntityItemProperties(EntityPropertyFlags desiredProperties
}
void EntityItemProperties::calculateNaturalPosition(const glm::vec3& min, const glm::vec3& max) {
glm::vec3 halfDimension = (max - min) / 2.0f;
void EntityItemProperties::calculateNaturalPosition(const vec3& min, const vec3& max) {
vec3 halfDimension = (max - min) / 2.0f;
_naturalPosition = max - halfDimension;
}
@ -1447,10 +1447,10 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
if (!skipDefaults && !strictSemantics) {
AABox aaBox = getAABox();
QScriptValue boundingBox = engine->newObject();
QScriptValue bottomRightNear = vec3ToScriptValue(engine, aaBox.getCorner());
QScriptValue topFarLeft = vec3ToScriptValue(engine, aaBox.calcTopFarLeft());
QScriptValue center = vec3ToScriptValue(engine, aaBox.calcCenter());
QScriptValue boundingBoxDimensions = vec3ToScriptValue(engine, aaBox.getDimensions());
QScriptValue bottomRightNear = vec3FloatToScriptValue(engine, aaBox.getCorner());
QScriptValue topFarLeft = vec3FloatToScriptValue(engine, aaBox.calcTopFarLeft());
QScriptValue center = vec3FloatToScriptValue(engine, aaBox.calcCenter());
QScriptValue boundingBoxDimensions = vec3FloatToScriptValue(engine, aaBox.getDimensions());
boundingBox.setProperty("brn", bottomRightNear);
boundingBox.setProperty("tfl", topFarLeft);
boundingBox.setProperty("center", center);
@ -1527,13 +1527,13 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
}
COPY_PROPERTY_FROM_QSCRIPTVALUE(lastEditedBy, QUuid, setLastEditedBy);
COPY_PROPERTY_FROM_QSCRIPTVALUE(position, ScriptVec3Float, setPosition);
COPY_PROPERTY_FROM_QSCRIPTVALUE(dimensions, ScriptVec3Float, setDimensions);
COPY_PROPERTY_FROM_QSCRIPTVALUE(position, vec3, setPosition);
COPY_PROPERTY_FROM_QSCRIPTVALUE(dimensions, vec3, setDimensions);
COPY_PROPERTY_FROM_QSCRIPTVALUE(rotation, quat, setRotation);
COPY_PROPERTY_FROM_QSCRIPTVALUE(density, float, setDensity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(velocity, ScriptVec3Float, setVelocity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(gravity, ScriptVec3Float, setGravity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(acceleration, ScriptVec3Float, setAcceleration);
COPY_PROPERTY_FROM_QSCRIPTVALUE(velocity, vec3, setVelocity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(gravity, vec3, setGravity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(acceleration, vec3, setAcceleration);
COPY_PROPERTY_FROM_QSCRIPTVALUE(damping, float, setDamping);
COPY_PROPERTY_FROM_QSCRIPTVALUE(restitution, float, setRestitution);
COPY_PROPERTY_FROM_QSCRIPTVALUE(friction, float, setFriction);
@ -1541,15 +1541,15 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
COPY_PROPERTY_FROM_QSCRIPTVALUE(script, QString, setScript);
COPY_PROPERTY_FROM_QSCRIPTVALUE(scriptTimestamp, quint64, setScriptTimestamp);
COPY_PROPERTY_FROM_QSCRIPTVALUE(serverScripts, QString, setServerScripts);
COPY_PROPERTY_FROM_QSCRIPTVALUE(registrationPoint, ScriptVec3Float, setRegistrationPoint);
COPY_PROPERTY_FROM_QSCRIPTVALUE(angularVelocity, ScriptVec3Float, setAngularVelocity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(registrationPoint, vec3, setRegistrationPoint);
COPY_PROPERTY_FROM_QSCRIPTVALUE(angularVelocity, vec3, setAngularVelocity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(angularDamping, float, setAngularDamping);
COPY_PROPERTY_FROM_QSCRIPTVALUE(visible, bool, setVisible);
COPY_PROPERTY_FROM_QSCRIPTVALUE(canCastShadow, bool, setCanCastShadow);
COPY_PROPERTY_FROM_QSCRIPTVALUE(color, ScriptVec3UChar, setColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE(colorSpread, ScriptVec3UChar, setColorSpread);
COPY_PROPERTY_FROM_QSCRIPTVALUE(colorStart, ScriptVec3Float, setColorStart);
COPY_PROPERTY_FROM_QSCRIPTVALUE(colorFinish, ScriptVec3Float, setColorFinish);
COPY_PROPERTY_FROM_QSCRIPTVALUE(color, u8vec3, setColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE(colorSpread, u8vec3, setColorSpread);
COPY_PROPERTY_FROM_QSCRIPTVALUE(colorStart, vec3, setColorStart);
COPY_PROPERTY_FROM_QSCRIPTVALUE(colorFinish, vec3, setColorFinish);
COPY_PROPERTY_FROM_QSCRIPTVALUE(alpha, float, setAlpha);
COPY_PROPERTY_FROM_QSCRIPTVALUE(alphaSpread, float, setAlphaSpread);
COPY_PROPERTY_FROM_QSCRIPTVALUE(alphaStart, float, setAlphaStart);
@ -1574,8 +1574,8 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
COPY_PROPERTY_FROM_QSCRIPTVALUE(userData, QString, setUserData);
COPY_PROPERTY_FROM_QSCRIPTVALUE(text, QString, setText);
COPY_PROPERTY_FROM_QSCRIPTVALUE(lineHeight, float, setLineHeight);
COPY_PROPERTY_FROM_QSCRIPTVALUE(textColor, ScriptVec3UChar, setTextColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE(backgroundColor, ScriptVec3UChar, setBackgroundColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE(textColor, u8vec3, setTextColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE(backgroundColor, u8vec3, setBackgroundColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(shapeType, ShapeType);
COPY_PROPERTY_FROM_QSCRIPTVALUE(maxParticles, quint32, setMaxParticles);
COPY_PROPERTY_FROM_QSCRIPTVALUE(lifespan, float, setLifespan);
@ -1584,14 +1584,14 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
COPY_PROPERTY_FROM_QSCRIPTVALUE(emitSpeed, float, setEmitSpeed);
COPY_PROPERTY_FROM_QSCRIPTVALUE(speedSpread, float, setSpeedSpread);
COPY_PROPERTY_FROM_QSCRIPTVALUE(emitOrientation, quat, setEmitOrientation);
COPY_PROPERTY_FROM_QSCRIPTVALUE(emitDimensions, ScriptVec3Float, setEmitDimensions);
COPY_PROPERTY_FROM_QSCRIPTVALUE(emitDimensions, vec3, setEmitDimensions);
COPY_PROPERTY_FROM_QSCRIPTVALUE(emitRadiusStart, float, setEmitRadiusStart);
COPY_PROPERTY_FROM_QSCRIPTVALUE(polarStart, float, setPolarStart);
COPY_PROPERTY_FROM_QSCRIPTVALUE(polarFinish, float, setPolarFinish);
COPY_PROPERTY_FROM_QSCRIPTVALUE(azimuthStart, float, setAzimuthStart);
COPY_PROPERTY_FROM_QSCRIPTVALUE(azimuthFinish, float, setAzimuthFinish);
COPY_PROPERTY_FROM_QSCRIPTVALUE(emitAcceleration, ScriptVec3Float, setEmitAcceleration);
COPY_PROPERTY_FROM_QSCRIPTVALUE(accelerationSpread, ScriptVec3Float, setAccelerationSpread);
COPY_PROPERTY_FROM_QSCRIPTVALUE(emitAcceleration, vec3, setEmitAcceleration);
COPY_PROPERTY_FROM_QSCRIPTVALUE(accelerationSpread, vec3, setAccelerationSpread);
COPY_PROPERTY_FROM_QSCRIPTVALUE(particleRadius, float, setParticleRadius);
COPY_PROPERTY_FROM_QSCRIPTVALUE(radiusSpread, float, setRadiusSpread);
COPY_PROPERTY_FROM_QSCRIPTVALUE(radiusStart, float, setRadiusStart);
@ -1601,8 +1601,8 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(materialMappingMode, MaterialMappingMode);
COPY_PROPERTY_FROM_QSCRIPTVALUE(priority, quint16, setPriority);
COPY_PROPERTY_FROM_QSCRIPTVALUE(parentMaterialName, QString, setParentMaterialName);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingPos, ScriptVec2Float, setMaterialMappingPos);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingScale, ScriptVec2Float, setMaterialMappingScale);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingPos, vec2, setMaterialMappingPos);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingScale, vec2, setMaterialMappingScale);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingRot, float, setMaterialMappingRot);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialData, QString, setMaterialData);
COPY_PROPERTY_FROM_QSCRIPTVALUE(isVisibleInSecondaryCamera, bool, setIsVisibleInSecondaryCamera);
@ -1634,7 +1634,7 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(skyboxMode, SkyboxMode);
COPY_PROPERTY_FROM_QSCRIPTVALUE(sourceUrl, QString, setSourceUrl);
COPY_PROPERTY_FROM_QSCRIPTVALUE(voxelVolumeSize, ScriptVec3Float, setVoxelVolumeSize);
COPY_PROPERTY_FROM_QSCRIPTVALUE(voxelVolumeSize, vec3, setVoxelVolumeSize);
COPY_PROPERTY_FROM_QSCRIPTVALUE(voxelData, QByteArray, setVoxelData);
COPY_PROPERTY_FROM_QSCRIPTVALUE(voxelSurfaceStyle, uint16_t, setVoxelSurfaceStyle);
COPY_PROPERTY_FROM_QSCRIPTVALUE(lineWidth, float, setLineWidth);
@ -1681,11 +1681,11 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
COPY_PROPERTY_FROM_QSCRIPTVALUE(parentJointIndex, quint16, setParentJointIndex);
COPY_PROPERTY_FROM_QSCRIPTVALUE(queryAACube, AACube, setQueryAACube);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localPosition, ScriptVec3Float, setLocalPosition);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localPosition, vec3, setLocalPosition);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localRotation, quat, setLocalRotation);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localVelocity, ScriptVec3Float, setLocalVelocity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localAngularVelocity, ScriptVec3Float, setLocalAngularVelocity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localDimensions, ScriptVec3Float, setLocalDimensions);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localVelocity, vec3, setLocalVelocity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localAngularVelocity, vec3, setLocalAngularVelocity);
COPY_PROPERTY_FROM_QSCRIPTVALUE(localDimensions, vec3, setLocalDimensions);
COPY_PROPERTY_FROM_QSCRIPTVALUE(jointRotationsSet, qVectorBool, setJointRotationsSet);
COPY_PROPERTY_FROM_QSCRIPTVALUE(jointRotations, qVectorQuat, setJointRotations);
@ -1917,13 +1917,13 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
std::call_once(initMap, [](){
ADD_PROPERTY_TO_MAP(PROP_VISIBLE, Visible, visible, bool);
ADD_PROPERTY_TO_MAP(PROP_CAN_CAST_SHADOW, CanCastShadow, canCastShadow, bool);
ADD_PROPERTY_TO_MAP(PROP_POSITION, Position, position, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_DIMENSIONS, Dimensions, dimensions, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_ROTATION, Rotation, rotation, glm::quat);
ADD_PROPERTY_TO_MAP(PROP_POSITION, Position, position, vec3);
ADD_PROPERTY_TO_MAP(PROP_DIMENSIONS, Dimensions, dimensions, vec3);
ADD_PROPERTY_TO_MAP(PROP_ROTATION, Rotation, rotation, quat);
ADD_PROPERTY_TO_MAP(PROP_DENSITY, Density, density, float);
ADD_PROPERTY_TO_MAP(PROP_VELOCITY, Velocity, velocity, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_GRAVITY, Gravity, gravity, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_ACCELERATION, Acceleration, acceleration, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_VELOCITY, Velocity, velocity, vec3);
ADD_PROPERTY_TO_MAP(PROP_GRAVITY, Gravity, gravity, vec3);
ADD_PROPERTY_TO_MAP(PROP_ACCELERATION, Acceleration, acceleration, vec3);
ADD_PROPERTY_TO_MAP(PROP_DAMPING, Damping, damping, float);
ADD_PROPERTY_TO_MAP(PROP_RESTITUTION, Restitution, restitution, float);
ADD_PROPERTY_TO_MAP(PROP_FRICTION, Friction, friction, float);
@ -1932,10 +1932,10 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
ADD_PROPERTY_TO_MAP(PROP_SCRIPT_TIMESTAMP, ScriptTimestamp, scriptTimestamp, quint64);
ADD_PROPERTY_TO_MAP(PROP_SERVER_SCRIPTS, ServerScripts, serverScripts, QString);
ADD_PROPERTY_TO_MAP(PROP_COLLISION_SOUND_URL, CollisionSoundURL, collisionSoundURL, QString);
ADD_PROPERTY_TO_MAP(PROP_COLOR, Color, color, ScriptVec3UChar);
ADD_PROPERTY_TO_MAP(PROP_COLOR_SPREAD, ColorSpread, colorSpread, ScriptVec3UChar);
ADD_PROPERTY_TO_MAP(PROP_COLOR_START, ColorStart, colorStart, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_COLOR_FINISH, ColorFinish, colorFinish, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_COLOR, Color, color, u8vec3);
ADD_PROPERTY_TO_MAP(PROP_COLOR_SPREAD, ColorSpread, colorSpread, u8vec3);
ADD_PROPERTY_TO_MAP(PROP_COLOR_START, ColorStart, colorStart, vec3);
ADD_PROPERTY_TO_MAP(PROP_COLOR_FINISH, ColorFinish, colorFinish, vec3);
ADD_PROPERTY_TO_MAP(PROP_ALPHA, Alpha, alpha, float);
ADD_PROPERTY_TO_MAP(PROP_ALPHA_SPREAD, AlphaSpread, alphaSpread, float);
ADD_PROPERTY_TO_MAP(PROP_ALPHA_START, AlphaStart, alphaStart, float);
@ -1943,8 +1943,8 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
ADD_PROPERTY_TO_MAP(PROP_EMITTER_SHOULD_TRAIL, EmitterShouldTrail, emitterShouldTrail, bool);
ADD_PROPERTY_TO_MAP(PROP_MODEL_URL, ModelURL, modelURL, QString);
ADD_PROPERTY_TO_MAP(PROP_COMPOUND_SHAPE_URL, CompoundShapeURL, compoundShapeURL, QString);
ADD_PROPERTY_TO_MAP(PROP_REGISTRATION_POINT, RegistrationPoint, registrationPoint, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_ANGULAR_VELOCITY, AngularVelocity, angularVelocity, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_REGISTRATION_POINT, RegistrationPoint, registrationPoint, vec3);
ADD_PROPERTY_TO_MAP(PROP_ANGULAR_VELOCITY, AngularVelocity, angularVelocity, vec3);
ADD_PROPERTY_TO_MAP(PROP_ANGULAR_DAMPING, AngularDamping, angularDamping, float);
ADD_PROPERTY_TO_MAP(PROP_COLLISIONLESS, Collisionless, collisionless, bool);
ADD_PROPERTY_TO_MAP(PROP_COLLISIONLESS, unused, ignoreForCollisions, unused); // legacy support
@ -1963,24 +1963,24 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
ADD_PROPERTY_TO_MAP(PROP_SIMULATION_OWNER, SimulationOwner, simulationOwner, SimulationOwner);
ADD_PROPERTY_TO_MAP(PROP_TEXT, Text, text, QString);
ADD_PROPERTY_TO_MAP(PROP_LINE_HEIGHT, LineHeight, lineHeight, float);
ADD_PROPERTY_TO_MAP(PROP_TEXT_COLOR, TextColor, textColor, ScriptVec3UChar);
ADD_PROPERTY_TO_MAP(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, ScriptVec3UChar);
ADD_PROPERTY_TO_MAP(PROP_TEXT_COLOR, TextColor, textColor, u8vec3);
ADD_PROPERTY_TO_MAP(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, u8vec3);
ADD_PROPERTY_TO_MAP(PROP_SHAPE_TYPE, ShapeType, shapeType, ShapeType);
ADD_PROPERTY_TO_MAP(PROP_MAX_PARTICLES, MaxParticles, maxParticles, quint32);
ADD_PROPERTY_TO_MAP(PROP_LIFESPAN, Lifespan, lifespan, float);
ADD_PROPERTY_TO_MAP(PROP_EMITTING_PARTICLES, IsEmitting, isEmitting, bool);
ADD_PROPERTY_TO_MAP(PROP_EMIT_RATE, EmitRate, emitRate, float);
ADD_PROPERTY_TO_MAP(PROP_EMIT_SPEED, EmitSpeed, emitSpeed, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_SPEED_SPREAD, SpeedSpread, speedSpread, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_EMIT_ORIENTATION, EmitOrientation, emitOrientation, glm::quat);
ADD_PROPERTY_TO_MAP(PROP_EMIT_DIMENSIONS, EmitDimensions, emitDimensions, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_EMIT_SPEED, EmitSpeed, emitSpeed, vec3);
ADD_PROPERTY_TO_MAP(PROP_SPEED_SPREAD, SpeedSpread, speedSpread, vec3);
ADD_PROPERTY_TO_MAP(PROP_EMIT_ORIENTATION, EmitOrientation, emitOrientation, quat);
ADD_PROPERTY_TO_MAP(PROP_EMIT_DIMENSIONS, EmitDimensions, emitDimensions, vec3);
ADD_PROPERTY_TO_MAP(PROP_EMIT_RADIUS_START, EmitRadiusStart, emitRadiusStart, float);
ADD_PROPERTY_TO_MAP(PROP_POLAR_START, EmitPolarStart, polarStart, float);
ADD_PROPERTY_TO_MAP(PROP_POLAR_FINISH, EmitPolarFinish, polarFinish, float);
ADD_PROPERTY_TO_MAP(PROP_AZIMUTH_START, EmitAzimuthStart, azimuthStart, float);
ADD_PROPERTY_TO_MAP(PROP_AZIMUTH_FINISH, EmitAzimuthFinish, azimuthFinish, float);
ADD_PROPERTY_TO_MAP(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, vec3);
ADD_PROPERTY_TO_MAP(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, vec3);
ADD_PROPERTY_TO_MAP(PROP_PARTICLE_RADIUS, ParticleRadius, particleRadius, float);
ADD_PROPERTY_TO_MAP(PROP_RADIUS_SPREAD, RadiusSpread, radiusSpread, float);
ADD_PROPERTY_TO_MAP(PROP_RADIUS_START, RadiusStart, radiusStart, float);
@ -1990,8 +1990,8 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, materialMappingMode, MaterialMappingMode);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_PRIORITY, Priority, priority, quint16);
ADD_PROPERTY_TO_MAP(PROP_PARENT_MATERIAL_NAME, ParentMaterialName, parentMaterialName, QString);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, ScriptVec2UChar);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, ScriptVec2UChar);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, vec2);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, vec2);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_ROT, MaterialMappingRot, materialMappingRot, float);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_DATA, MaterialData, materialData, QString);
@ -2016,24 +2016,24 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
ADD_PROPERTY_TO_MAP(PROP_CERTIFICATE_ID, CertificateID, certificateID, QString);
ADD_PROPERTY_TO_MAP(PROP_STATIC_CERTIFICATE_VERSION, StaticCertificateVersion, staticCertificateVersion, quint32);
ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_COLOR, KeyLightColor, keyLightColor, ScriptVec3UChar);
ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_COLOR, KeyLightColor, keyLightColor, u8vec3);
ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_INTENSITY, KeyLightIntensity, keyLightIntensity, float);
ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_DIRECTION, KeyLightDirection, keyLightDirection, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_DIRECTION, KeyLightDirection, keyLightDirection, vec3);
ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_CAST_SHADOW, KeyLightCastShadows, keyLightCastShadows, bool);
ADD_PROPERTY_TO_MAP(PROP_VOXEL_VOLUME_SIZE, VoxelVolumeSize, voxelVolumeSize, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_VOXEL_VOLUME_SIZE, VoxelVolumeSize, voxelVolumeSize, vec3);
ADD_PROPERTY_TO_MAP(PROP_VOXEL_DATA, VoxelData, voxelData, QByteArray);
ADD_PROPERTY_TO_MAP(PROP_VOXEL_SURFACE_STYLE, VoxelSurfaceStyle, voxelSurfaceStyle, uint16_t);
ADD_PROPERTY_TO_MAP(PROP_NAME, Name, name, QString);
ADD_PROPERTY_TO_MAP(PROP_SOURCE_URL, SourceUrl, sourceUrl, QString);
ADD_PROPERTY_TO_MAP(PROP_LINE_WIDTH, LineWidth, lineWidth, float);
ADD_PROPERTY_TO_MAP(PROP_LINE_POINTS, LinePoints, linePoints, QVector<ScriptVec3Float>);
ADD_PROPERTY_TO_MAP(PROP_LINE_POINTS, LinePoints, linePoints, QVector<vec3>);
ADD_PROPERTY_TO_MAP(PROP_HREF, Href, href, QString);
ADD_PROPERTY_TO_MAP(PROP_DESCRIPTION, Description, description, QString);
ADD_PROPERTY_TO_MAP(PROP_FACE_CAMERA, FaceCamera, faceCamera, bool);
ADD_PROPERTY_TO_MAP(PROP_ACTION_DATA, ActionData, actionData, QByteArray);
ADD_PROPERTY_TO_MAP(PROP_NORMALS, Normals, normals, QVector<ScriptVec3Float>);
ADD_PROPERTY_TO_MAP(PROP_STROKE_COLORS, StrokeColors, strokeColors, QVector<ScriptVec3Float>);
ADD_PROPERTY_TO_MAP(PROP_NORMALS, Normals, normals, QVector<vec3>);
ADD_PROPERTY_TO_MAP(PROP_STROKE_COLORS, StrokeColors, strokeColors, QVector<vec3>);
ADD_PROPERTY_TO_MAP(PROP_STROKE_WIDTHS, StrokeWidths, strokeWidths, QVector<float>);
ADD_PROPERTY_TO_MAP(PROP_IS_UV_MODE_STRETCH, IsUVModeStretch, isUVModeStretch, QVector<float>);
ADD_PROPERTY_TO_MAP(PROP_X_TEXTURE_URL, XTextureURL, xTextureURL, QString);
@ -2049,16 +2049,16 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
ADD_PROPERTY_TO_MAP(PROP_PARENT_ID, ParentID, parentID, QUuid);
ADD_PROPERTY_TO_MAP(PROP_PARENT_JOINT_INDEX, ParentJointIndex, parentJointIndex, uint16_t);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_POSITION, LocalPosition, localPosition, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_ROTATION, LocalRotation, localRotation, glm::quat);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_VELOCITY, LocalVelocity, localVelocity, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_ANGULAR_VELOCITY, LocalAngularVelocity, localAngularVelocity, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_DIMENSIONS, LocalDimensions, localDimensions, ScriptVec3Float);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_POSITION, LocalPosition, localPosition, vec3);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_ROTATION, LocalRotation, localRotation, quat);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_VELOCITY, LocalVelocity, localVelocity, vec3);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_ANGULAR_VELOCITY, LocalAngularVelocity, localAngularVelocity, vec3);
ADD_PROPERTY_TO_MAP(PROP_LOCAL_DIMENSIONS, LocalDimensions, localDimensions, vec3);
ADD_PROPERTY_TO_MAP(PROP_JOINT_ROTATIONS_SET, JointRotationsSet, jointRotationsSet, QVector<bool>);
ADD_PROPERTY_TO_MAP(PROP_JOINT_ROTATIONS, JointRotations, jointRotations, QVector<glm::quat>);
ADD_PROPERTY_TO_MAP(PROP_JOINT_ROTATIONS, JointRotations, jointRotations, QVector<quat>);
ADD_PROPERTY_TO_MAP(PROP_JOINT_TRANSLATIONS_SET, JointTranslationsSet, jointTranslationsSet, QVector<bool>);
ADD_PROPERTY_TO_MAP(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<ScriptVec3Float>);
ADD_PROPERTY_TO_MAP(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<vec3>);
ADD_PROPERTY_TO_MAP(PROP_RELAY_PARENT_JOINTS, RelayParentJoints, relayParentJoints, bool);
ADD_PROPERTY_TO_MAP(PROP_SHAPE, Shape, shape, QString);
@ -2163,7 +2163,7 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
// Always include the root octcode. This is only because the OctreeEditPacketSender will check these octcodes
// to determine which server to send the changes to in the case of multiple jurisdictions. The root will be sent
// to all servers.
glm::vec3 rootPosition(0);
vec3 rootPosition(0);
float rootScale = 0.5f;
unsigned char* octcode = pointToOctalCode(rootPosition.x, rootPosition.y, rootPosition.z, rootScale);
@ -2501,7 +2501,7 @@ QByteArray EntityItemProperties::getPackedNormals() const {
return packNormals(getNormals());
}
QByteArray EntityItemProperties::packNormals(const QVector<ScriptVec3Float>& normals) const {
QByteArray EntityItemProperties::packNormals(const QVector<vec3>& normals) const {
int normalsSize = normals.size();
QByteArray packedNormals = QByteArray(normalsSize * 6 + 1, '0');
// add size of the array
@ -2509,7 +2509,7 @@ QByteArray EntityItemProperties::packNormals(const QVector<ScriptVec3Float>& nor
int index = 1;
for (int i = 0; i < normalsSize; i++) {
int numBytes = packFloatVec3ToSignedTwoByteFixed((unsigned char*)packedNormals.data() + index, normals[i].toGlm(), 15);
int numBytes = packFloatVec3ToSignedTwoByteFixed((unsigned char*)packedNormals.data() + index, normals[i], 15);
index += numBytes;
}
return packedNormals;
@ -2518,7 +2518,7 @@ QByteArray EntityItemProperties::packNormals(const QVector<ScriptVec3Float>& nor
QByteArray EntityItemProperties::getPackedStrokeColors() const {
return packStrokeColors(getStrokeColors());
}
QByteArray EntityItemProperties::packStrokeColors(const QVector<ScriptVec3Float>& strokeColors) const {
QByteArray EntityItemProperties::packStrokeColors(const QVector<vec3>& strokeColors) const {
int strokeColorsSize = strokeColors.size();
QByteArray packedStrokeColors = QByteArray(strokeColorsSize * 3 + 1, '0');
@ -2619,13 +2619,13 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
processedBytes += propertyFlags.getEncodedLength();
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SIMULATION_OWNER, QByteArray, setSimulationOwner);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POSITION, ScriptVec3Float, setPosition);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_DIMENSIONS, ScriptVec3Float, setDimensions);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ROTATION, glm::quat, setRotation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POSITION, vec3, setPosition);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_DIMENSIONS, vec3, setDimensions);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ROTATION, quat, setRotation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_DENSITY, float, setDensity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VELOCITY, ScriptVec3Float, setVelocity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_GRAVITY, ScriptVec3Float, setGravity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION, ScriptVec3Float, setAcceleration);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VELOCITY, vec3, setVelocity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_GRAVITY, vec3, setGravity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION, vec3, setAcceleration);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_DAMPING, float, setDamping);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RESTITUTION, float, setRestitution);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_FRICTION, float, setFriction);
@ -2633,8 +2633,8 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SCRIPT, QString, setScript);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SCRIPT_TIMESTAMP, quint64, setScriptTimestamp);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SERVER_SCRIPTS, QString, setServerScripts);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_REGISTRATION_POINT, ScriptVec3Float, setRegistrationPoint);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANGULAR_VELOCITY, ScriptVec3Float, setAngularVelocity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_REGISTRATION_POINT, vec3, setRegistrationPoint);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANGULAR_VELOCITY, vec3, setAngularVelocity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANGULAR_DAMPING, float, setAngularDamping);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VISIBLE, bool, setVisible);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_CAN_CAST_SHADOW, bool, setCanCastShadow);
@ -2657,8 +2657,8 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
if (properties.getType() == EntityTypes::Text) {
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXT, QString, setText);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_HEIGHT, float, setLineHeight);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXT_COLOR, ScriptVec3UChar, setTextColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_BACKGROUND_COLOR, ScriptVec3UChar, setBackgroundColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXT_COLOR, u8vec3, setTextColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_BACKGROUND_COLOR, u8vec3, setBackgroundColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_FACE_CAMERA, bool, setFaceCamera);
}
@ -2667,20 +2667,20 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COMPOUND_SHAPE_URL, QString, setCompoundShapeURL);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXTURES, QString, setTextures);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SHAPE_TYPE, ShapeType, setShapeType);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3, setColor);
properties.getAnimation().decodeFromEditPacket(propertyFlags, dataAt, processedBytes);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_ROTATIONS_SET, QVector<bool>, setJointRotationsSet);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_ROTATIONS, QVector<glm::quat>, setJointRotations);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_ROTATIONS, QVector<quat>, setJointRotations);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_TRANSLATIONS_SET, QVector<bool>, setJointTranslationsSet);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_TRANSLATIONS, QVector<ScriptVec3Float>, setJointTranslations);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_TRANSLATIONS, QVector<vec3>, setJointTranslations);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RELAY_PARENT_JOINTS, bool, setRelayParentJoints);
}
if (properties.getType() == EntityTypes::Light) {
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_IS_SPOTLIGHT, bool, setIsSpotlight);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_INTENSITY, float, setIntensity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_FALLOFF_RADIUS, float, setFalloffRadius);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EXPONENT, float, setExponent);
@ -2695,23 +2695,23 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RATE, float, setEmitRate);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_SPEED, float, setEmitSpeed);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SPEED_SPREAD, float, setSpeedSpread);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_DIMENSIONS, ScriptVec3Float, setEmitDimensions);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ORIENTATION, quat, setEmitOrientation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_DIMENSIONS, vec3, setEmitDimensions);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RADIUS_START, float, setEmitRadiusStart);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POLAR_START, float, setPolarStart);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POLAR_FINISH, float, setPolarFinish);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_AZIMUTH_START, float, setAzimuthStart);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_AZIMUTH_FINISH, float, setAzimuthFinish);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ACCELERATION, ScriptVec3Float, setEmitAcceleration);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION_SPREAD, ScriptVec3Float, setAccelerationSpread);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ACCELERATION, vec3, setEmitAcceleration);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION_SPREAD, vec3, setAccelerationSpread);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_PARTICLE_RADIUS, float, setParticleRadius);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RADIUS_SPREAD, float, setRadiusSpread);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RADIUS_START, float, setRadiusStart);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RADIUS_FINISH, float, setRadiusFinish);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_SPREAD, ScriptVec3UChar, setColorSpread);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_START, ScriptVec3Float, setColorStart);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_FINISH, ScriptVec3Float, setColorFinish);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_SPREAD, u8vec3, setColorSpread);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_START, vec3, setColorStart);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_FINISH, vec3, setColorFinish);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ALPHA_SPREAD, float, setAlphaSpread);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ALPHA_START, float, setAlphaStart);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ALPHA_FINISH, float, setAlphaFinish);
@ -2744,7 +2744,7 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
}
if (properties.getType() == EntityTypes::PolyVox) {
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VOXEL_VOLUME_SIZE, ScriptVec3Float, setVoxelVolumeSize);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VOXEL_VOLUME_SIZE, vec3, setVoxelVolumeSize);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VOXEL_DATA, QByteArray, setVoxelData);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VOXEL_SURFACE_STYLE, uint16_t, setVoxelSurfaceStyle);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_X_TEXTURE_URL, QString, setXTextureURL);
@ -2759,16 +2759,16 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
}
if (properties.getType() == EntityTypes::Line) {
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_WIDTH, float, setLineWidth);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_POINTS, QVector<ScriptVec3Float>, setLinePoints);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_POINTS, QVector<vec3>, setLinePoints);
}
if (properties.getType() == EntityTypes::PolyLine) {
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_WIDTH, float, setLineWidth);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_POINTS, QVector<ScriptVec3Float>, setLinePoints);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_POINTS, QVector<vec3>, setLinePoints);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_NORMALS, QByteArray, setPackedNormals);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_STROKE_COLORS, QByteArray, setPackedStrokeColors);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_STROKE_WIDTHS, QVector<float>, setStrokeWidths);
@ -2782,7 +2782,7 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
properties.getType() == EntityTypes::Box ||
properties.getType() == EntityTypes::Sphere) {
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SHAPE, QString, setShape);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3, setColor);
}
// Materials
@ -2791,8 +2791,8 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, setMaterialMappingMode);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_PRIORITY, quint16, setPriority);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_PARENT_MATERIAL_NAME, QString, setParentMaterialName);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_POS, ScriptVec2Float, setMaterialMappingPos);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_SCALE, ScriptVec2Float, setMaterialMappingScale);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_POS, vec2, setMaterialMappingPos);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_SCALE, vec2, setMaterialMappingScale);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_ROT, float, setMaterialMappingRot);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_DATA, QString, setMaterialData);
}
@ -2828,14 +2828,14 @@ void EntityItemProperties::setPackedNormals(const QByteArray& value) {
setNormals(unpackNormals(value));
}
QVector<ScriptVec3Float> EntityItemProperties::unpackNormals(const QByteArray& normals) {
QVector<vec3> EntityItemProperties::unpackNormals(const QByteArray& normals) {
// the size of the vector is packed first
QVector<ScriptVec3Float> unpackedNormals = QVector<ScriptVec3Float>((int)normals[0]);
QVector<vec3> unpackedNormals = QVector<vec3>((int)normals[0]);
if ((int)normals[0] == normals.size() / 6) {
int j = 0;
for (int i = 1; i < normals.size();) {
glm::vec3 aux = glm::vec3();
vec3 aux = vec3();
i += unpackFloatVec3FromSignedTwoByteFixed((unsigned char*)normals.data() + i, aux, 15);
unpackedNormals[j] = aux;
j++;
@ -2851,9 +2851,9 @@ void EntityItemProperties::setPackedStrokeColors(const QByteArray& value) {
setStrokeColors(unpackStrokeColors(value));
}
QVector<ScriptVec3Float> EntityItemProperties::unpackStrokeColors(const QByteArray& strokeColors) {
QVector<vec3> EntityItemProperties::unpackStrokeColors(const QByteArray& strokeColors) {
// the size of the vector is packed first
QVector<ScriptVec3Float> unpackedStrokeColors = QVector<ScriptVec3Float>((int)strokeColors[0]);
QVector<vec3> unpackedStrokeColors = QVector<vec3>((int)strokeColors[0]);
if ((int)strokeColors[0] == strokeColors.size() / 3) {
int j = 0;
@ -2862,7 +2862,7 @@ QVector<ScriptVec3Float> EntityItemProperties::unpackStrokeColors(const QByteArr
float r = (uint8_t)strokeColors[i++] / 255.0f;
float g = (uint8_t)strokeColors[i++] / 255.0f;
float b = (uint8_t)strokeColors[i++] / 255.0f;
unpackedStrokeColors[j++] = ScriptVec3Float(r, g, b);
unpackedStrokeColors[j++] = vec3(r, g, b);
}
} else {
qCDebug(entities) << "WARNING - Expected received size for stroke colors does not match. Expected: "
@ -3123,15 +3123,15 @@ void EntityItemProperties::markAllChanged() {
AABox EntityItemProperties::getAABox() const {
// _position represents the position of the registration point.
glm::vec3 registrationRemainder = glm::vec3(1.0f) - _registrationPoint.toGlm();
vec3 registrationRemainder = vec3(1.0f) - _registrationPoint;
glm::vec3 unrotatedMinRelativeToEntity = - (_dimensions.toGlm() * _registrationPoint.toGlm());
glm::vec3 unrotatedMaxRelativeToEntity = _dimensions.toGlm() * registrationRemainder;
vec3 unrotatedMinRelativeToEntity = - (_dimensions * _registrationPoint);
vec3 unrotatedMaxRelativeToEntity = _dimensions * registrationRemainder;
Extents unrotatedExtentsRelativeToRegistrationPoint = { unrotatedMinRelativeToEntity, unrotatedMaxRelativeToEntity };
Extents rotatedExtentsRelativeToRegistrationPoint = unrotatedExtentsRelativeToRegistrationPoint.getRotated(_rotation);
// shift the extents to be relative to the position/registration point
rotatedExtentsRelativeToRegistrationPoint.shiftBy(_position.toGlm());
rotatedExtentsRelativeToRegistrationPoint.shiftBy(_position);
return AABox(rotatedExtentsRelativeToRegistrationPoint);
}

76
libraries/entities/src/EntityItemProperties.h
View file

@ -119,13 +119,13 @@ public:
DEFINE_PROPERTY(PROP_VISIBLE, Visible, visible, bool, ENTITY_ITEM_DEFAULT_VISIBLE);
DEFINE_PROPERTY(PROP_CAN_CAST_SHADOW, CanCastShadow, canCastShadow, bool, ENTITY_ITEM_DEFAULT_CAN_CAST_SHADOW);
DEFINE_PROPERTY_REF_WITH_SETTER(PROP_POSITION, Position, position, ScriptVec3Float, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_DIMENSIONS, Dimensions, dimensions, ScriptVec3Float, ENTITY_ITEM_DEFAULT_DIMENSIONS);
DEFINE_PROPERTY_REF_WITH_SETTER(PROP_POSITION, Position, position, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_DIMENSIONS, Dimensions, dimensions, glm::vec3, ENTITY_ITEM_DEFAULT_DIMENSIONS);
DEFINE_PROPERTY_REF(PROP_ROTATION, Rotation, rotation, glm::quat, ENTITY_ITEM_DEFAULT_ROTATION);
DEFINE_PROPERTY(PROP_DENSITY, Density, density, float, ENTITY_ITEM_DEFAULT_DENSITY);
DEFINE_PROPERTY_REF(PROP_VELOCITY, Velocity, velocity, ScriptVec3Float, ENTITY_ITEM_DEFAULT_VELOCITY);
DEFINE_PROPERTY_REF(PROP_GRAVITY, Gravity, gravity, ScriptVec3Float, ENTITY_ITEM_DEFAULT_GRAVITY);
DEFINE_PROPERTY_REF(PROP_ACCELERATION, Acceleration, acceleration, ScriptVec3Float, ENTITY_ITEM_DEFAULT_ACCELERATION);
DEFINE_PROPERTY_REF(PROP_VELOCITY, Velocity, velocity, glm::vec3, ENTITY_ITEM_DEFAULT_VELOCITY);
DEFINE_PROPERTY_REF(PROP_GRAVITY, Gravity, gravity, glm::vec3, ENTITY_ITEM_DEFAULT_GRAVITY);
DEFINE_PROPERTY_REF(PROP_ACCELERATION, Acceleration, acceleration, glm::vec3, ENTITY_ITEM_DEFAULT_ACCELERATION);
DEFINE_PROPERTY(PROP_DAMPING, Damping, damping, float, ENTITY_ITEM_DEFAULT_DAMPING);
DEFINE_PROPERTY(PROP_RESTITUTION, Restitution, restitution, float, ENTITY_ITEM_DEFAULT_RESTITUTION);
DEFINE_PROPERTY(PROP_FRICTION, Friction, friction, float, ENTITY_ITEM_DEFAULT_FRICTION);
@ -134,18 +134,18 @@ public:
DEFINE_PROPERTY_REF(PROP_SCRIPT, Script, script, QString, ENTITY_ITEM_DEFAULT_SCRIPT);
DEFINE_PROPERTY(PROP_SCRIPT_TIMESTAMP, ScriptTimestamp, scriptTimestamp, quint64, ENTITY_ITEM_DEFAULT_SCRIPT_TIMESTAMP);
DEFINE_PROPERTY_REF(PROP_COLLISION_SOUND_URL, CollisionSoundURL, collisionSoundURL, QString, ENTITY_ITEM_DEFAULT_COLLISION_SOUND_URL);
DEFINE_PROPERTY_REF(PROP_COLOR, Color, color, ScriptVec3UChar, particle::DEFAULT_COLOR);
DEFINE_PROPERTY_REF(PROP_COLOR_SPREAD, ColorSpread, colorSpread, ScriptVec3UChar, particle::DEFAULT_COLOR_SPREAD);
DEFINE_PROPERTY_REF(PROP_COLOR_START, ColorStart, colorStart, ScriptVec3Float, particle::DEFAULT_COLOR_UNINITIALIZED);
DEFINE_PROPERTY_REF(PROP_COLOR_FINISH, ColorFinish, colorFinish, ScriptVec3Float, particle::DEFAULT_COLOR_UNINITIALIZED);
DEFINE_PROPERTY_REF(PROP_COLOR, Color, color, glm::u8vec3, particle::DEFAULT_COLOR);
DEFINE_PROPERTY_REF(PROP_COLOR_SPREAD, ColorSpread, colorSpread, glm::u8vec3, particle::DEFAULT_COLOR_SPREAD);
DEFINE_PROPERTY_REF(PROP_COLOR_START, ColorStart, colorStart, glm::vec3, particle::DEFAULT_COLOR_UNINITIALIZED);
DEFINE_PROPERTY_REF(PROP_COLOR_FINISH, ColorFinish, colorFinish, glm::vec3, particle::DEFAULT_COLOR_UNINITIALIZED);
DEFINE_PROPERTY(PROP_ALPHA, Alpha, alpha, float, particle::DEFAULT_ALPHA);
DEFINE_PROPERTY(PROP_ALPHA_SPREAD, AlphaSpread, alphaSpread, float, particle::DEFAULT_ALPHA_SPREAD);
DEFINE_PROPERTY(PROP_ALPHA_START, AlphaStart, alphaStart, float, particle::DEFAULT_ALPHA_START);
DEFINE_PROPERTY(PROP_ALPHA_FINISH, AlphaFinish, alphaFinish, float, particle::DEFAULT_ALPHA_FINISH);
DEFINE_PROPERTY_REF(PROP_MODEL_URL, ModelURL, modelURL, QString, "");
DEFINE_PROPERTY_REF(PROP_COMPOUND_SHAPE_URL, CompoundShapeURL, compoundShapeURL, QString, "");
DEFINE_PROPERTY_REF(PROP_REGISTRATION_POINT, RegistrationPoint, registrationPoint, ScriptVec3Float, ENTITY_ITEM_DEFAULT_REGISTRATION_POINT);
DEFINE_PROPERTY_REF(PROP_ANGULAR_VELOCITY, AngularVelocity, angularVelocity, ScriptVec3Float, ENTITY_ITEM_DEFAULT_ANGULAR_VELOCITY);
DEFINE_PROPERTY_REF(PROP_REGISTRATION_POINT, RegistrationPoint, registrationPoint, glm::vec3, ENTITY_ITEM_DEFAULT_REGISTRATION_POINT);
DEFINE_PROPERTY_REF(PROP_ANGULAR_VELOCITY, AngularVelocity, angularVelocity, glm::vec3, ENTITY_ITEM_DEFAULT_ANGULAR_VELOCITY);
DEFINE_PROPERTY(PROP_ANGULAR_DAMPING, AngularDamping, angularDamping, float, ENTITY_ITEM_DEFAULT_ANGULAR_DAMPING);
DEFINE_PROPERTY(PROP_COLLISIONLESS, Collisionless, collisionless, bool, ENTITY_ITEM_DEFAULT_COLLISIONLESS);
DEFINE_PROPERTY(PROP_COLLISION_MASK, CollisionMask, collisionMask, uint16_t, ENTITY_COLLISION_MASK_DEFAULT);
@ -161,8 +161,8 @@ public:
DEFINE_PROPERTY_REF(PROP_SIMULATION_OWNER, SimulationOwner, simulationOwner, SimulationOwner, SimulationOwner());
DEFINE_PROPERTY_REF(PROP_TEXT, Text, text, QString, TextEntityItem::DEFAULT_TEXT);
DEFINE_PROPERTY(PROP_LINE_HEIGHT, LineHeight, lineHeight, float, TextEntityItem::DEFAULT_LINE_HEIGHT);
DEFINE_PROPERTY_REF(PROP_TEXT_COLOR, TextColor, textColor, ScriptVec3UChar, TextEntityItem::DEFAULT_TEXT_COLOR);
DEFINE_PROPERTY_REF(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, ScriptVec3UChar, TextEntityItem::DEFAULT_BACKGROUND_COLOR);
DEFINE_PROPERTY_REF(PROP_TEXT_COLOR, TextColor, textColor, glm::u8vec3, TextEntityItem::DEFAULT_TEXT_COLOR);
DEFINE_PROPERTY_REF(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, glm::u8vec3, TextEntityItem::DEFAULT_BACKGROUND_COLOR);
DEFINE_PROPERTY_REF_ENUM(PROP_SHAPE_TYPE, ShapeType, shapeType, ShapeType, SHAPE_TYPE_NONE);
DEFINE_PROPERTY(PROP_MAX_PARTICLES, MaxParticles, maxParticles, quint32, particle::DEFAULT_MAX_PARTICLES);
DEFINE_PROPERTY(PROP_LIFESPAN, Lifespan, lifespan, float, particle::DEFAULT_LIFESPAN);
@ -171,14 +171,14 @@ public:
DEFINE_PROPERTY(PROP_EMIT_SPEED, EmitSpeed, emitSpeed, float, particle::DEFAULT_EMIT_SPEED);
DEFINE_PROPERTY(PROP_SPEED_SPREAD, SpeedSpread, speedSpread, float, particle::DEFAULT_SPEED_SPREAD);
DEFINE_PROPERTY_REF(PROP_EMIT_ORIENTATION, EmitOrientation, emitOrientation, glm::quat, particle::DEFAULT_EMIT_ORIENTATION);
DEFINE_PROPERTY_REF(PROP_EMIT_DIMENSIONS, EmitDimensions, emitDimensions, ScriptVec3Float, particle::DEFAULT_EMIT_DIMENSIONS);
DEFINE_PROPERTY_REF(PROP_EMIT_DIMENSIONS, EmitDimensions, emitDimensions, glm::vec3, particle::DEFAULT_EMIT_DIMENSIONS);
DEFINE_PROPERTY(PROP_EMIT_RADIUS_START, EmitRadiusStart, emitRadiusStart, float, particle::DEFAULT_EMIT_RADIUS_START);
DEFINE_PROPERTY(PROP_POLAR_START, PolarStart, polarStart, float, particle::DEFAULT_POLAR_START);
DEFINE_PROPERTY(PROP_POLAR_FINISH, PolarFinish, polarFinish, float, particle::DEFAULT_POLAR_FINISH);
DEFINE_PROPERTY(PROP_AZIMUTH_START, AzimuthStart, azimuthStart, float, particle::DEFAULT_AZIMUTH_START);
DEFINE_PROPERTY(PROP_AZIMUTH_FINISH, AzimuthFinish, azimuthFinish, float, particle::DEFAULT_AZIMUTH_FINISH);
DEFINE_PROPERTY_REF(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, ScriptVec3Float, particle::DEFAULT_EMIT_ACCELERATION);
DEFINE_PROPERTY_REF(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, ScriptVec3Float, particle::DEFAULT_ACCELERATION_SPREAD);
DEFINE_PROPERTY_REF(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, glm::vec3, particle::DEFAULT_EMIT_ACCELERATION);
DEFINE_PROPERTY_REF(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, glm::vec3, particle::DEFAULT_ACCELERATION_SPREAD);
DEFINE_PROPERTY(PROP_PARTICLE_RADIUS, ParticleRadius, particleRadius, float, particle::DEFAULT_PARTICLE_RADIUS);
DEFINE_PROPERTY(PROP_RADIUS_SPREAD, RadiusSpread, radiusSpread, float, particle::DEFAULT_RADIUS_SPREAD);
DEFINE_PROPERTY(PROP_RADIUS_START, RadiusStart, radiusStart, float, particle::DEFAULT_RADIUS_START);
@ -186,7 +186,7 @@ public:
DEFINE_PROPERTY(PROP_EMITTER_SHOULD_TRAIL, EmitterShouldTrail, emitterShouldTrail, bool, particle::DEFAULT_EMITTER_SHOULD_TRAIL);
DEFINE_PROPERTY_GROUP(KeyLight, keyLight, KeyLightPropertyGroup);
DEFINE_PROPERTY_GROUP(AmbientLight, ambientLight, AmbientLightPropertyGroup);
DEFINE_PROPERTY_REF(PROP_VOXEL_VOLUME_SIZE, VoxelVolumeSize, voxelVolumeSize, ScriptVec3Float, PolyVoxEntityItem::DEFAULT_VOXEL_VOLUME_SIZE);
DEFINE_PROPERTY_REF(PROP_VOXEL_VOLUME_SIZE, VoxelVolumeSize, voxelVolumeSize, glm::vec3, PolyVoxEntityItem::DEFAULT_VOXEL_VOLUME_SIZE);
DEFINE_PROPERTY_REF(PROP_VOXEL_DATA, VoxelData, voxelData, QByteArray, PolyVoxEntityItem::DEFAULT_VOXEL_DATA);
DEFINE_PROPERTY_REF(PROP_VOXEL_SURFACE_STYLE, VoxelSurfaceStyle, voxelSurfaceStyle, uint16_t, PolyVoxEntityItem::DEFAULT_VOXEL_SURFACE_STYLE);
DEFINE_PROPERTY_REF(PROP_NAME, Name, name, QString, ENTITY_ITEM_DEFAULT_NAME);
@ -201,13 +201,13 @@ public:
DEFINE_PROPERTY_GROUP(Animation, animation, AnimationPropertyGroup);
DEFINE_PROPERTY_REF(PROP_SOURCE_URL, SourceUrl, sourceUrl, QString, "");
DEFINE_PROPERTY(PROP_LINE_WIDTH, LineWidth, lineWidth, float, LineEntityItem::DEFAULT_LINE_WIDTH);
DEFINE_PROPERTY_REF(LINE_POINTS, LinePoints, linePoints, QVector<ScriptVec3Float>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
DEFINE_PROPERTY_REF(LINE_POINTS, LinePoints, linePoints, QVector<glm::vec3>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
DEFINE_PROPERTY_REF(PROP_HREF, Href, href, QString, "");
DEFINE_PROPERTY_REF(PROP_DESCRIPTION, Description, description, QString, "");
DEFINE_PROPERTY(PROP_FACE_CAMERA, FaceCamera, faceCamera, bool, TextEntityItem::DEFAULT_FACE_CAMERA);
DEFINE_PROPERTY_REF(PROP_ACTION_DATA, ActionData, actionData, QByteArray, QByteArray());
DEFINE_PROPERTY(PROP_NORMALS, Normals, normals, QVector<ScriptVec3Float>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
DEFINE_PROPERTY(PROP_STROKE_COLORS, StrokeColors, strokeColors, QVector<ScriptVec3Float>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
DEFINE_PROPERTY(PROP_NORMALS, Normals, normals, QVector<glm::vec3>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
DEFINE_PROPERTY(PROP_STROKE_COLORS, StrokeColors, strokeColors, QVector<glm::vec3>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
DEFINE_PROPERTY(PROP_STROKE_WIDTHS, StrokeWidths, strokeWidths, QVector<float>, QVector<float>());
DEFINE_PROPERTY(PROP_IS_UV_MODE_STRETCH, IsUVModeStretch, isUVModeStretch, bool, true);
DEFINE_PROPERTY_REF(PROP_X_TEXTURE_URL, XTextureURL, xTextureURL, QString, "");
@ -228,8 +228,8 @@ public:
DEFINE_PROPERTY_REF_ENUM(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, materialMappingMode, MaterialMappingMode, UV);
DEFINE_PROPERTY_REF(PROP_MATERIAL_PRIORITY, Priority, priority, quint16, 0);
DEFINE_PROPERTY_REF(PROP_PARENT_MATERIAL_NAME, ParentMaterialName, parentMaterialName, QString, "0");
DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, ScriptVec2Float, ScriptVec2Float(0.0f));
DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, ScriptVec2Float, ScriptVec2Float(1.0f));
DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, glm::vec2, glm::vec2(0.0f));
DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, glm::vec2, glm::vec2(1.0f));
DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_ROT, MaterialMappingRot, materialMappingRot, float, 0);
DEFINE_PROPERTY_REF(PROP_MATERIAL_DATA, MaterialData, materialData, QString, "");
@ -255,16 +255,16 @@ public:
DEFINE_PROPERTY_REF(PROP_STATIC_CERTIFICATE_VERSION, StaticCertificateVersion, staticCertificateVersion, quint32, ENTITY_ITEM_DEFAULT_STATIC_CERTIFICATE_VERSION);
// these are used when bouncing location data into and out of scripts
DEFINE_PROPERTY_REF(PROP_LOCAL_POSITION, LocalPosition, localPosition, ScriptVec3Float, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_LOCAL_POSITION, LocalPosition, localPosition, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_LOCAL_ROTATION, LocalRotation, localRotation, quat, ENTITY_ITEM_DEFAULT_ROTATION);
DEFINE_PROPERTY_REF(PROP_LOCAL_VELOCITY, LocalVelocity, localVelocity, ScriptVec3Float, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_LOCAL_ANGULAR_VELOCITY, LocalAngularVelocity, localAngularVelocity, ScriptVec3Float, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_LOCAL_DIMENSIONS, LocalDimensions, localDimensions, ScriptVec3Float, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_LOCAL_VELOCITY, LocalVelocity, localVelocity, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_LOCAL_ANGULAR_VELOCITY, LocalAngularVelocity, localAngularVelocity, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_LOCAL_DIMENSIONS, LocalDimensions, localDimensions, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
DEFINE_PROPERTY_REF(PROP_JOINT_ROTATIONS_SET, JointRotationsSet, jointRotationsSet, QVector<bool>, QVector<bool>());
DEFINE_PROPERTY_REF(PROP_JOINT_ROTATIONS, JointRotations, jointRotations, QVector<glm::quat>, QVector<glm::quat>());
DEFINE_PROPERTY_REF(PROP_JOINT_TRANSLATIONS_SET, JointTranslationsSet, jointTranslationsSet, QVector<bool>, QVector<bool>());
DEFINE_PROPERTY_REF(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<ScriptVec3Float>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
DEFINE_PROPERTY_REF(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<glm::vec3>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
DEFINE_PROPERTY(PROP_FLYING_ALLOWED, FlyingAllowed, flyingAllowed, bool, ZoneEntityItem::DEFAULT_FLYING_ALLOWED);
DEFINE_PROPERTY(PROP_GHOSTING_ALLOWED, GhostingAllowed, ghostingAllowed, bool, ZoneEntityItem::DEFAULT_GHOSTING_ALLOWED);
@ -293,7 +293,7 @@ public:
std::array<ComponentPair, COMPONENT_MODE_ITEM_COUNT>::const_iterator findComponent(const QString& mode);
public:
float getMaxDimension() const { return glm::compMax(_dimensions.toGlm()); }
float getMaxDimension() const { return glm::compMax(_dimensions); }
float getAge() const { return (float)(usecTimestampNow() - _created) / (float)USECS_PER_SECOND; }
bool hasCreatedTime() const { return (_created != UNKNOWN_CREATED_TIME); }
@ -320,10 +320,10 @@ public:
void clearID() { _id = UNKNOWN_ENTITY_ID; _idSet = false; }
void markAllChanged();
glm::vec3 getNaturalDimensions() const { return _naturalDimensions.toGlm(); }
const glm::vec3& getNaturalDimensions() const { return _naturalDimensions; }
void setNaturalDimensions(const glm::vec3& value) { _naturalDimensions = value; }
glm::vec3 getNaturalPosition() const { return _naturalPosition.toGlm(); }
const glm::vec3& getNaturalPosition() const { return _naturalPosition; }
void calculateNaturalPosition(const glm::vec3& min, const glm::vec3& max);
const QVariantMap& getTextureNames() const { return _textureNames; }
@ -370,16 +370,16 @@ public:
void setRenderInfoHasTransparent(bool value) { _renderInfoHasTransparent = value; }
void setPackedNormals(const QByteArray& value);
QVector<ScriptVec3Float> unpackNormals(const QByteArray& normals);
QVector<glm::vec3> unpackNormals(const QByteArray& normals);
void setPackedStrokeColors(const QByteArray& value);
QVector<ScriptVec3Float> unpackStrokeColors(const QByteArray& strokeColors);
QVector<glm::vec3> unpackStrokeColors(const QByteArray& strokeColors);
QByteArray getPackedNormals() const;
QByteArray packNormals(const QVector<ScriptVec3Float>& normals) const;
QByteArray packNormals(const QVector<glm::vec3>& normals) const;
QByteArray getPackedStrokeColors() const;
QByteArray packStrokeColors(const QVector<ScriptVec3Float>& strokeColors) const;
QByteArray packStrokeColors(const QVector<glm::vec3>& strokeColors) const;
QByteArray getStaticCertificateJSON() const;
QByteArray getStaticCertificateHash() const;
@ -407,8 +407,8 @@ private:
// NOTE: The following are pseudo client only properties. They are only used in clients which can access
// properties of model geometry. But these properties are not serialized like other properties.
QVariantMap _textureNames;
ScriptVec3Float _naturalDimensions;
ScriptVec3Float _naturalPosition;
glm::vec3 _naturalDimensions;
glm::vec3 _naturalPosition;
size_t _renderInfoVertexCount { 0 };
int _renderInfoTextureCount { 0 };
@ -431,8 +431,8 @@ void EntityPropertyFlagsFromScriptValue(const QScriptValue& object, EntityProper
// define these inline here so the macros work
inline void EntityItemProperties::setPosition(const ScriptVec3Float& value)
{ _position = glm::clamp(value.toGlm(), (float)-HALF_TREE_SCALE, (float)HALF_TREE_SCALE); _positionChanged = true; }
inline void EntityItemProperties::setPosition(const glm::vec3& value)
{ _position = glm::clamp(value, (float)-HALF_TREE_SCALE, (float)HALF_TREE_SCALE); _positionChanged = true; }
inline QDebug operator<<(QDebug debug, const EntityItemProperties& properties) {
debug << "EntityItemProperties[" << "\n";

2
libraries/entities/src/EntityItemPropertiesDefaults.h
View file

@ -24,7 +24,7 @@ const glm::vec3 ENTITY_ITEM_ZERO_VEC3 = glm::vec3(0.0f);
const glm::vec3 ENTITY_ITEM_ONE_VEC3 = glm::vec3(1.0f);
const glm::vec3 ENTITY_ITEM_HALF_VEC3 = glm::vec3(0.5f);
const QVector<ScriptVec3Float> ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC = QVector<ScriptVec3Float>();
const QVector<glm::vec3> ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC = QVector<glm::vec3>();
const bool ENTITY_ITEM_DEFAULT_LOCKED = false;
const QString ENTITY_ITEM_DEFAULT_USER_DATA = QString("");

24
libraries/entities/src/EntityItemPropertiesMacros.h
View file

@ -101,9 +101,9 @@
changedProperties += P; \
}
inline QScriptValue convertScriptValue(QScriptEngine* e, const ScriptVec2Float& v) { return vec2FloatToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const ScriptVec3Float& v) { return vec3FloatToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const ScriptVec3UChar& v) { return vec3UCharToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::vec2& v) { return vec2FloatToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::vec3& v) { return vec3FloatToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::u8vec3& v) { return vec3UCharToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, float v) { return QScriptValue(v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, int v) { return QScriptValue(v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, bool v) { return QScriptValue(v); }
@ -114,7 +114,7 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const QString& v) { ret
inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::quat& v) { return quatToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const QScriptValue& v) { return v; }
inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<ScriptVec3Float>& v) {return qVectorVec3ToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<glm::vec3>& v) {return qVectorVec3FloatToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<glm::quat>& v) {return qVectorQuatToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<bool>& v) {return qVectorBoolToScriptValue(e, v); }
inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<float>& v) { return qVectorFloatToScriptValue(e, v); }
@ -185,7 +185,7 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const AACube& v) { retu
properties.setProperty(#P, V); \
}
typedef QVector<ScriptVec3Float> qVectorVec3;
typedef QVector<glm::vec3> qVectorVec3;
typedef QVector<glm::quat> qVectorQuat;
typedef QVector<bool> qVectorBool;
typedef QVector<float> qVectorFloat;
@ -221,23 +221,23 @@ inline QByteArray QByteArray_convertFromScriptValue(const QScriptValue& v, bool&
return QByteArray::fromBase64(b64.toUtf8());
}
inline ScriptVec2Float ScriptVec2Float_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
inline glm::vec2 vec2_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
isValid = true;
ScriptVec2Float vec2;
glm::vec2 vec2;
vec2FloatFromScriptValue(v, vec2);
return vec2;
}
inline ScriptVec3Float ScriptVec3Float_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
inline glm::vec3 vec3_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
isValid = true;
ScriptVec3Float vec3;
glm::vec3 vec3;
vec3FloatFromScriptValue(v, vec3);
return vec3;
}
inline ScriptVec3UChar ScriptVec3UChar_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
inline glm::u8vec3 u8vec3_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
isValid = true;
ScriptVec3UChar vec3;
glm::u8vec3 vec3;
vec3UCharFromScriptValue(v, vec3);
return vec3;
}
@ -256,7 +256,7 @@ inline qVectorFloat qVectorFloat_convertFromScriptValue(const QScriptValue& v, b
inline qVectorVec3 qVectorVec3_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
isValid = true;
return qVectorVec3FromScriptValue(v);
return qVectorVec3FloatFromScriptValue(v);
}
inline qVectorQuat qVectorQuat_convertFromScriptValue(const QScriptValue& v, bool& isValid) {

26
libraries/entities/src/EntityScriptingInterface.cpp
View file

@ -137,7 +137,7 @@ EntityItemProperties convertPropertiesToScriptSemantics(const EntityItemProperti
scriptSideProperties.setLocalDimensions(entitySideProperties.getDimensions());
bool success;
glm::vec3 worldPosition = SpatiallyNestable::localToWorld(entitySideProperties.getPosition().toGlm(),
glm::vec3 worldPosition = SpatiallyNestable::localToWorld(entitySideProperties.getPosition(),
entitySideProperties.getParentID(),
entitySideProperties.getParentJointIndex(),
scalesWithParent,
@ -147,17 +147,17 @@ EntityItemProperties convertPropertiesToScriptSemantics(const EntityItemProperti
entitySideProperties.getParentJointIndex(),
scalesWithParent,
success);
glm::vec3 worldVelocity = SpatiallyNestable::localToWorldVelocity(entitySideProperties.getVelocity().toGlm(),
glm::vec3 worldVelocity = SpatiallyNestable::localToWorldVelocity(entitySideProperties.getVelocity(),
entitySideProperties.getParentID(),
entitySideProperties.getParentJointIndex(),
scalesWithParent,
success);
glm::vec3 worldAngularVelocity = SpatiallyNestable::localToWorldAngularVelocity(entitySideProperties.getAngularVelocity().toGlm(),
glm::vec3 worldAngularVelocity = SpatiallyNestable::localToWorldAngularVelocity(entitySideProperties.getAngularVelocity(),
entitySideProperties.getParentID(),
entitySideProperties.getParentJointIndex(),
scalesWithParent,
success);
glm::vec3 worldDimensions = SpatiallyNestable::localToWorldDimensions(entitySideProperties.getDimensions().toGlm(),
glm::vec3 worldDimensions = SpatiallyNestable::localToWorldDimensions(entitySideProperties.getDimensions(),
entitySideProperties.getParentID(),
entitySideProperties.getParentJointIndex(),
scalesWithParent,
@ -186,7 +186,7 @@ EntityItemProperties convertPropertiesFromScriptSemantics(const EntityItemProper
if (scriptSideProperties.localPositionChanged()) {
entitySideProperties.setPosition(scriptSideProperties.getLocalPosition());
} else if (scriptSideProperties.positionChanged()) {
glm::vec3 localPosition = SpatiallyNestable::worldToLocal(entitySideProperties.getPosition().toGlm(),
glm::vec3 localPosition = SpatiallyNestable::worldToLocal(entitySideProperties.getPosition(),
entitySideProperties.getParentID(),
entitySideProperties.getParentJointIndex(),
scalesWithParent, success);
@ -206,7 +206,7 @@ EntityItemProperties convertPropertiesFromScriptSemantics(const EntityItemProper
if (scriptSideProperties.localVelocityChanged()) {
entitySideProperties.setVelocity(scriptSideProperties.getLocalVelocity());
} else if (scriptSideProperties.velocityChanged()) {
glm::vec3 localVelocity = SpatiallyNestable::worldToLocalVelocity(entitySideProperties.getVelocity().toGlm(),
glm::vec3 localVelocity = SpatiallyNestable::worldToLocalVelocity(entitySideProperties.getVelocity(),
entitySideProperties.getParentID(),
entitySideProperties.getParentJointIndex(),
scalesWithParent, success);
@ -217,7 +217,7 @@ EntityItemProperties convertPropertiesFromScriptSemantics(const EntityItemProper
entitySideProperties.setAngularVelocity(scriptSideProperties.getLocalAngularVelocity());
} else if (scriptSideProperties.angularVelocityChanged()) {
glm::vec3 localAngularVelocity =
SpatiallyNestable::worldToLocalAngularVelocity(entitySideProperties.getAngularVelocity().toGlm(),
SpatiallyNestable::worldToLocalAngularVelocity(entitySideProperties.getAngularVelocity(),
entitySideProperties.getParentID(),
entitySideProperties.getParentJointIndex(),
scalesWithParent, success);
@ -227,7 +227,7 @@ EntityItemProperties convertPropertiesFromScriptSemantics(const EntityItemProper
if (scriptSideProperties.localDimensionsChanged()) {
entitySideProperties.setDimensions(scriptSideProperties.getLocalDimensions());
} else if (scriptSideProperties.dimensionsChanged()) {
glm::vec3 localDimensions = SpatiallyNestable::worldToLocalDimensions(entitySideProperties.getDimensions().toGlm(),
glm::vec3 localDimensions = SpatiallyNestable::worldToLocalDimensions(entitySideProperties.getDimensions(),
entitySideProperties.getParentID(),
entitySideProperties.getParentJointIndex(),
scalesWithParent, success);
@ -1061,9 +1061,9 @@ QScriptValue RayToEntityIntersectionResultToScriptValue(QScriptEngine* engine, c
obj.setProperty("distance", value.distance);
obj.setProperty("face", boxFaceToString(value.face));
QScriptValue intersection = vec3ToScriptValue(engine, value.intersection);
QScriptValue intersection = vec3FloatToScriptValue(engine, value.intersection);
obj.setProperty("intersection", intersection);
QScriptValue surfaceNormal = vec3ToScriptValue(engine, value.surfaceNormal);
QScriptValue surfaceNormal = vec3FloatToScriptValue(engine, value.surfaceNormal);
obj.setProperty("surfaceNormal", surfaceNormal);
obj.setProperty("extraInfo", engine->toScriptValue(value.extraInfo));
return obj;
@ -1079,11 +1079,11 @@ void RayToEntityIntersectionResultFromScriptValue(const QScriptValue& object, Ra
QScriptValue intersection = object.property("intersection");
if (intersection.isValid()) {
vec3FromScriptValue(intersection, value.intersection);
vec3FloatFromScriptValue(intersection, value.intersection);
}
QScriptValue surfaceNormal = object.property("surfaceNormal");
if (surfaceNormal.isValid()) {
vec3FromScriptValue(surfaceNormal, value.surfaceNormal);
vec3FloatFromScriptValue(surfaceNormal, value.surfaceNormal);
}
value.extraInfo = object.property("extraInfo").toVariant().toMap();
}
@ -1196,7 +1196,7 @@ bool EntityScriptingInterface::setVoxelsInCuboid(QUuid entityID, const glm::vec3
});
}
bool EntityScriptingInterface::setAllPoints(QUuid entityID, const QVector<ScriptVec3Float>& points) {
bool EntityScriptingInterface::setAllPoints(QUuid entityID, const QVector<glm::vec3>& points) {
PROFILE_RANGE(script_entities, __FUNCTION__);
EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID));

2
libraries/entities/src/EntityScriptingInterface.h
View file

@ -850,7 +850,7 @@ public slots:
* ]);
* }, 2000);
*/
Q_INVOKABLE bool setAllPoints(QUuid entityID, const QVector<ScriptVec3Float>& points);
Q_INVOKABLE bool setAllPoints(QUuid entityID, const QVector<glm::vec3>& points);
/**jsdoc
* Append a point to a {@link Entities.EntityType|Line} entity.

10
libraries/entities/src/EntityTree.cpp
View file

@ -1071,7 +1071,7 @@ void EntityTree::fixupTerseEditLogging(EntityItemProperties& properties, QList<Q
if (properties.velocityChanged()) {
int index = changedProperties.indexOf("velocity");
if (index >= 0) {
glm::vec3 value = properties.getVelocity().toGlm();
glm::vec3 value = properties.getVelocity();
changedProperties[index] = QString("velocity:") +
QString::number((int)value.x) + "," +
QString::number((int)value.y) + "," +
@ -1082,7 +1082,7 @@ void EntityTree::fixupTerseEditLogging(EntityItemProperties& properties, QList<Q
if (properties.gravityChanged()) {
int index = changedProperties.indexOf("gravity");
if (index >= 0) {
glm::vec3 value = properties.getGravity().toGlm();
glm::vec3 value = properties.getGravity();
QString changeHint = "0";
if (value.x + value.y + value.z > 0) {
changeHint = "+";
@ -1200,7 +1200,7 @@ void EntityTree::fixupTerseEditLogging(EntityItemProperties& properties, QList<Q
}
if (properties.positionChanged()) {
int index = changedProperties.indexOf("position");
glm::vec3 pos = properties.getPosition().toGlm();
glm::vec3 pos = properties.getPosition();
changedProperties[index] = QString("position:") +
QString::number((int)pos.x) + "," +
QString::number((int)pos.y) + "," +
@ -1220,7 +1220,7 @@ bool EntityTree::filterProperties(EntityItemPointer& existingEntity, EntityItemP
bool accepted = true;
auto entityEditFilters = DependencyManager::get<EntityEditFilters>();
if (entityEditFilters) {
auto position = existingEntity ? existingEntity->getWorldPosition() : propertiesIn.getPosition().toGlm();
auto position = existingEntity ? existingEntity->getWorldPosition() : propertiesIn.getPosition();
auto entityID = existingEntity ? existingEntity->getEntityItemID() : EntityItemID();
accepted = entityEditFilters->filter(position, propertiesIn, propertiesOut, wasChanged, filterType, entityID, existingEntity);
}
@ -2379,7 +2379,7 @@ bool EntityTree::sendEntitiesOperation(const OctreeElementPointer& element, void
EntityItemID oldParentID = properties.getParentID();
if (oldParentID.isInvalidID()) { // no parent
properties.setPosition(properties.getPosition().toGlm() + args->root);
properties.setPosition(properties.getPosition() + args->root);
} else {
EntityItemPointer parentEntity = args->ourTree->findEntityByEntityItemID(oldParentID);
if (parentEntity || oldParentID == AVATAR_SELF_ID) { // map the parent

12
libraries/entities/src/HazePropertyGroup.cpp
View file

@ -36,8 +36,8 @@ void HazePropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProp
void HazePropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeRange, float, setHazeRange);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeColor, ScriptVec3UChar, setHazeColor);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeGlareColor, ScriptVec3UChar, setHazeGlareColor);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeColor, u8vec3, setHazeColor);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeGlareColor, u8vec3, setHazeGlareColor);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeEnableGlare, bool, setHazeEnableGlare);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeGlareAngle, float, setHazeGlareAngle);
@ -167,8 +167,8 @@ bool HazePropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFlags,
bool somethingChanged = false;
READ_ENTITY_PROPERTY(PROP_HAZE_RANGE, float, setHazeRange);
READ_ENTITY_PROPERTY(PROP_HAZE_COLOR, ScriptVec3UChar, setHazeColor);
READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_COLOR, ScriptVec3UChar, setHazeGlareColor);
READ_ENTITY_PROPERTY(PROP_HAZE_COLOR, glm::u8vec3, setHazeColor);
READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_COLOR, glm::u8vec3, setHazeGlareColor);
READ_ENTITY_PROPERTY(PROP_HAZE_ENABLE_GLARE, bool, setHazeEnableGlare);
READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_ANGLE, float, setHazeGlareAngle);
@ -343,8 +343,8 @@ int HazePropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char* dat
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_HAZE_RANGE, float, setHazeRange);
READ_ENTITY_PROPERTY(PROP_HAZE_COLOR, ScriptVec3UChar, setHazeColor);
READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_COLOR, ScriptVec3UChar, setHazeGlareColor);
READ_ENTITY_PROPERTY(PROP_HAZE_COLOR, glm::u8vec3, setHazeColor);
READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_COLOR, glm::u8vec3, setHazeGlareColor);
READ_ENTITY_PROPERTY(PROP_HAZE_ENABLE_GLARE, bool, setHazeEnableGlare);
READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_ANGLE, float, setHazeGlareAngle);

8
libraries/entities/src/HazePropertyGroup.h
View file

@ -28,8 +28,8 @@ class EntityTreeElementExtraEncodeData;
class ReadBitstreamToTreeParams;
static const float INITIAL_HAZE_RANGE{ 1000.0f };
static const ScriptVec3UChar initialHazeGlareColor { 255, 229, 179 };
static const ScriptVec3UChar initialHazeColor { 128, 154, 179 };
static const glm::u8vec3 initialHazeGlareColor { 255, 229, 179 };
static const glm::u8vec3 initialHazeColor { 128, 154, 179 };
static const float INITIAL_HAZE_GLARE_ANGLE{ 20.0f };
static const float INITIAL_HAZE_BASE_REFERENCE{ 0.0f };
@ -118,8 +118,8 @@ public:
// Range only parameters
DEFINE_PROPERTY(PROP_HAZE_RANGE, HazeRange, hazeRange, float, INITIAL_HAZE_RANGE);
DEFINE_PROPERTY_REF(PROP_HAZE_COLOR, HazeColor, hazeColor, ScriptVec3UChar, initialHazeColor);
DEFINE_PROPERTY_REF(PROP_HAZE_GLARE_COLOR, HazeGlareColor, hazeGlareColor, ScriptVec3UChar, initialHazeGlareColor);
DEFINE_PROPERTY_REF(PROP_HAZE_COLOR, HazeColor, hazeColor, glm::u8vec3, initialHazeColor);
DEFINE_PROPERTY_REF(PROP_HAZE_GLARE_COLOR, HazeGlareColor, hazeGlareColor, glm::u8vec3, initialHazeGlareColor);
DEFINE_PROPERTY(PROP_HAZE_ENABLE_GLARE, HazeEnableGlare, hazeEnableGlare, bool, false);
DEFINE_PROPERTY_REF(PROP_HAZE_GLARE_ANGLE, HazeGlareAngle, hazeGlareAngle, float, INITIAL_HAZE_GLARE_ANGLE);

18
libraries/entities/src/KeyLightPropertyGroup.cpp
View file

@ -17,7 +17,7 @@
#include "EntityItemProperties.h"
#include "EntityItemPropertiesMacros.h"
const ScriptVec3UChar KeyLightPropertyGroup::DEFAULT_KEYLIGHT_COLOR = { 255, 255, 255 };
const glm::u8vec3 KeyLightPropertyGroup::DEFAULT_KEYLIGHT_COLOR = { 255, 255, 255 };
const float KeyLightPropertyGroup::DEFAULT_KEYLIGHT_INTENSITY = 1.0f;
const float KeyLightPropertyGroup::DEFAULT_KEYLIGHT_AMBIENT_INTENSITY = 0.5f;
const glm::vec3 KeyLightPropertyGroup::DEFAULT_KEYLIGHT_DIRECTION = { 0.0f, -1.0f, 0.0f };
@ -33,15 +33,15 @@ void KeyLightPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desired
}
void KeyLightPropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, color, ScriptVec3UChar, setColor);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, color, u8vec3, setColor);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, intensity, float, setIntensity);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, direction, ScriptVec3Float, setDirection);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, direction, vec3, setDirection);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, castShadows, bool, setCastShadows);
// legacy property support
COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightColor, ScriptVec3UChar, setColor, getColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightColor, u8vec3, setColor, getColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightIntensity, float, setIntensity, getIntensity);
COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightDirection, ScriptVec3Float, setDirection, getDirection);
COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightDirection, vec3, setDirection, getDirection);
COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightCastShadows, bool, setCastShadows, getCastShadows);
}
@ -99,9 +99,9 @@ bool KeyLightPropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFl
bool overwriteLocalData = true;
bool somethingChanged = false;
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_INTENSITY, float, setIntensity);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, ScriptVec3Float, setDirection);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, glm::vec3, setDirection);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, bool, setCastShadows);
DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_KEYLIGHT_COLOR, Color);
@ -187,9 +187,9 @@ int KeyLightPropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char*
int bytesRead = 0;
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_INTENSITY, float, setIntensity);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, ScriptVec3Float, setDirection);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, glm::vec3, setDirection);
READ_ENTITY_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, bool, setCastShadows);
return bytesRead;

6
libraries/entities/src/KeyLightPropertyGroup.h
View file

@ -84,15 +84,15 @@ public:
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
bool& somethingChanged) override;
static const ScriptVec3UChar DEFAULT_KEYLIGHT_COLOR;
static const glm::u8vec3 DEFAULT_KEYLIGHT_COLOR;
static const float DEFAULT_KEYLIGHT_INTENSITY;
static const float DEFAULT_KEYLIGHT_AMBIENT_INTENSITY;
static const glm::vec3 DEFAULT_KEYLIGHT_DIRECTION;
static const bool DEFAULT_KEYLIGHT_CAST_SHADOWS;
DEFINE_PROPERTY_REF(PROP_KEYLIGHT_COLOR, Color, color, ScriptVec3UChar, DEFAULT_KEYLIGHT_COLOR);
DEFINE_PROPERTY_REF(PROP_KEYLIGHT_COLOR, Color, color, glm::u8vec3, DEFAULT_KEYLIGHT_COLOR);
DEFINE_PROPERTY(PROP_KEYLIGHT_INTENSITY, Intensity, intensity, float, DEFAULT_KEYLIGHT_INTENSITY);
DEFINE_PROPERTY_REF(PROP_KEYLIGHT_DIRECTION, Direction, direction, ScriptVec3Float, DEFAULT_KEYLIGHT_DIRECTION);
DEFINE_PROPERTY_REF(PROP_KEYLIGHT_DIRECTION, Direction, direction, glm::vec3, DEFAULT_KEYLIGHT_DIRECTION);
DEFINE_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, CastShadows, castShadows, bool, DEFAULT_KEYLIGHT_CAST_SHADOWS);
};

8
libraries/entities/src/LightEntityItem.cpp
View file

@ -175,7 +175,7 @@ int LightEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_IS_SPOTLIGHT, bool, setIsSpotlight);
READ_ENTITY_PROPERTY(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_INTENSITY, float, setIntensity);
READ_ENTITY_PROPERTY(PROP_EXPONENT, float, setExponent);
READ_ENTITY_PROPERTY(PROP_CUTOFF, float, setCutoff);
@ -213,13 +213,13 @@ void LightEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBit
APPEND_ENTITY_PROPERTY(PROP_FALLOFF_RADIUS, getFalloffRadius());
}
ScriptVec3UChar LightEntityItem::getColor() const {
return resultWithReadLock<ScriptVec3UChar>([&] {
glm::u8vec3 LightEntityItem::getColor() const {
return resultWithReadLock<glm::u8vec3>([&] {
return _color;
});
}
void LightEntityItem::setColor(const ScriptVec3UChar& value) {
void LightEntityItem::setColor(const glm::u8vec3& value) {
withWriteLock([&] {
_color = value;
_lightPropertiesChanged = true;

6
libraries/entities/src/LightEntityItem.h
View file

@ -52,8 +52,8 @@ public:
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
bool& somethingChanged) override;
ScriptVec3UChar getColor() const;
void setColor(const ScriptVec3UChar& value);
glm::u8vec3 getColor() const;
void setColor(const glm::u8vec3& value);
bool getIsSpotlight() const;
void setIsSpotlight(bool value);
@ -90,7 +90,7 @@ public:
private:
// properties of a light
ScriptVec3UChar _color;
glm::u8vec3 _color;
bool _isSpotlight { DEFAULT_IS_SPOTLIGHT };
float _intensity { DEFAULT_INTENSITY };
float _falloffRadius { DEFAULT_FALLOFF_RADIUS };

20
libraries/entities/src/LineEntityItem.cpp
View file

@ -69,7 +69,7 @@ bool LineEntityItem::setProperties(const EntityItemProperties& properties) {
return somethingChanged;
}
bool LineEntityItem::appendPoint(const ScriptVec3Float& point) {
bool LineEntityItem::appendPoint(const glm::vec3& point) {
if (_points.size() > MAX_POINTS_PER_LINE - 1) {
qCDebug(entities) << "MAX POINTS REACHED!";
return false;
@ -86,13 +86,13 @@ bool LineEntityItem::appendPoint(const ScriptVec3Float& point) {
return true;
}
bool LineEntityItem::setLinePoints(const QVector<ScriptVec3Float>& points) {
bool LineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
if (points.size() > MAX_POINTS_PER_LINE) {
return false;
}
glm::vec3 halfBox = getScaledDimensions() * 0.5f;
for (int i = 0; i < points.size(); i++) {
ScriptVec3Float point = points.at(i);
glm::vec3 point = points.at(i);
if ( (point.x < - halfBox.x || point.x > halfBox.x) || (point.y < -halfBox.y || point.y > halfBox.y) || (point.z < - halfBox.z || point.z > halfBox.z) ) {
qCDebug(entities) << "Point is outside entity's bounding box";
return false;
@ -114,9 +114,9 @@ int LineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
int bytesRead = 0;
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_LINE_WIDTH, float, setLineWidth);
READ_ENTITY_PROPERTY(PROP_LINE_POINTS, QVector<ScriptVec3Float>, setLinePoints);
READ_ENTITY_PROPERTY(PROP_LINE_POINTS, QVector<glm::vec3>, setLinePoints);
return bytesRead;
}
@ -154,13 +154,13 @@ void LineEntityItem::debugDump() const {
qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now);
}
ScriptVec3UChar LineEntityItem::getColor() const {
return resultWithReadLock<ScriptVec3UChar>([&] {
glm::u8vec3 LineEntityItem::getColor() const {
return resultWithReadLock<glm::u8vec3>([&] {
return _color;
});
}
void LineEntityItem::setColor(const ScriptVec3UChar& value) {
void LineEntityItem::setColor(const glm::u8vec3& value) {
withWriteLock([&] {
_color = value;
});
@ -180,8 +180,8 @@ float LineEntityItem::getLineWidth() const {
return result;
}
QVector<ScriptVec3Float> LineEntityItem::getLinePoints() const {
QVector<ScriptVec3Float> result;
QVector<glm::vec3> LineEntityItem::getLinePoints() const {
QVector<glm::vec3> result;
withReadLock([&] {
result = _points;
});

14
libraries/entities/src/LineEntityItem.h
View file

@ -41,16 +41,16 @@ class LineEntityItem : public EntityItem {
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
bool& somethingChanged) override;
ScriptVec3UChar getColor() const;
void setColor(const ScriptVec3UChar& value);
glm::u8vec3 getColor() const;
void setColor(const glm::u8vec3& value);
void setLineWidth(float lineWidth);
float getLineWidth() const;
bool setLinePoints(const QVector<ScriptVec3Float>& points);
bool appendPoint(const ScriptVec3Float& point);
bool setLinePoints(const QVector<glm::vec3>& points);
bool appendPoint(const glm::vec3& point);
QVector<ScriptVec3Float> getLinePoints() const;
QVector<glm::vec3> getLinePoints() const;
virtual ShapeType getShapeType() const override { return SHAPE_TYPE_NONE; }
@ -73,9 +73,9 @@ class LineEntityItem : public EntityItem {
static const int MAX_POINTS_PER_LINE;
private:
ScriptVec3UChar _color;
glm::u8vec3 _color;
float _lineWidth { DEFAULT_LINE_WIDTH };
QVector<ScriptVec3Float> _points;
QVector<glm::vec3> _points;
bool _pointsChanged { true };
};

12
libraries/entities/src/MaterialEntityItem.cpp
View file

@ -81,8 +81,8 @@ int MaterialEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, setMaterialMappingMode);
READ_ENTITY_PROPERTY(PROP_MATERIAL_PRIORITY, quint16, setPriority);
READ_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_NAME, QString, setParentMaterialName);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, ScriptVec2Float, setMaterialMappingPos);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, ScriptVec2Float, setMaterialMappingScale);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, glm::vec2, setMaterialMappingPos);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, glm::vec2, setMaterialMappingScale);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_ROT, float, setMaterialMappingRot);
READ_ENTITY_PROPERTY(PROP_MATERIAL_DATA, QString, setMaterialData);
@ -208,18 +208,18 @@ void MaterialEntityItem::setMaterialData(const QString& materialData) {
}
}
void MaterialEntityItem::setMaterialMappingPos(const ScriptVec2Float& materialMappingPos) {
void MaterialEntityItem::setMaterialMappingPos(const glm::vec2& materialMappingPos) {
if (_materialMappingPos != materialMappingPos) {
removeMaterial();
_materialMappingPos = materialMappingPos.toGlm();
_materialMappingPos = materialMappingPos;
applyMaterial();
}
}
void MaterialEntityItem::setMaterialMappingScale(const ScriptVec2Float& materialMappingScale) {
void MaterialEntityItem::setMaterialMappingScale(const glm::vec2& materialMappingScale) {
if (_materialMappingScale != materialMappingScale) {
removeMaterial();
_materialMappingScale = materialMappingScale.toGlm();
_materialMappingScale = materialMappingScale;
applyMaterial();
}
}

8
libraries/entities/src/MaterialEntityItem.h
View file

@ -66,10 +66,10 @@ public:
QString getParentMaterialName() const { return _parentMaterialName; }
void setParentMaterialName(const QString& parentMaterialName);
ScriptVec2Float getMaterialMappingPos() const { return _materialMappingPos; }
void setMaterialMappingPos(const ScriptVec2Float& materialMappingPos);
ScriptVec2Float getMaterialMappingScale() const { return _materialMappingScale; }
void setMaterialMappingScale(const ScriptVec2Float& materialMappingScale);
glm::vec2 getMaterialMappingPos() const { return _materialMappingPos; }
void setMaterialMappingPos(const glm::vec2& materialMappingPos);
glm::vec2 getMaterialMappingScale() const { return _materialMappingScale; }
void setMaterialMappingScale(const glm::vec2& materialMappingScale);
float getMaterialMappingRot() const { return _materialMappingRot; }
void setMaterialMappingRot(const float& materialMappingRot);

16
libraries/entities/src/ModelEntityItem.cpp
View file

@ -113,7 +113,7 @@ int ModelEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
const unsigned char* dataAt = data;
bool animationPropertiesChanged = false;
READ_ENTITY_PROPERTY(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_MODEL_URL, QString, setModelURL);
READ_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, QString, setCompoundShapeURL);
READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures);
@ -139,7 +139,7 @@ int ModelEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
READ_ENTITY_PROPERTY(PROP_JOINT_ROTATIONS_SET, QVector<bool>, setJointRotationsSet);
READ_ENTITY_PROPERTY(PROP_JOINT_ROTATIONS, QVector<glm::quat>, setJointRotations);
READ_ENTITY_PROPERTY(PROP_JOINT_TRANSLATIONS_SET, QVector<bool>, setJointTranslationsSet);
READ_ENTITY_PROPERTY(PROP_JOINT_TRANSLATIONS, QVector<ScriptVec3Float>, setJointTranslations);
READ_ENTITY_PROPERTY(PROP_JOINT_TRANSLATIONS, QVector<glm::vec3>, setJointTranslations);
return bytesRead;
}
@ -428,7 +428,7 @@ void ModelEntityItem::setJointRotationsSet(const QVector<bool>& rotationsSet) {
});
}
void ModelEntityItem::setJointTranslations(const QVector<ScriptVec3Float>& translations) {
void ModelEntityItem::setJointTranslations(const QVector<glm::vec3>& translations) {
resizeJointArrays(translations.size());
_jointDataLock.withWriteLock([&] {
_jointTranslationsExplicitlySet = translations.size() > 0;
@ -479,8 +479,8 @@ QVector<bool> ModelEntityItem::getJointRotationsSet() const {
return result;
}
QVector<ScriptVec3Float> ModelEntityItem::getJointTranslations() const {
QVector<ScriptVec3Float> result;
QVector<glm::vec3> ModelEntityItem::getJointTranslations() const {
QVector<glm::vec3> result;
_jointDataLock.withReadLock([&] {
if (_jointTranslationsExplicitlySet) {
result.resize(_localJointData.size());
@ -537,14 +537,14 @@ QString ModelEntityItem::getCompoundShapeURL() const {
return _compoundShapeURL.get();
}
void ModelEntityItem::setColor(const ScriptVec3UChar& value) {
void ModelEntityItem::setColor(const glm::u8vec3& value) {
withWriteLock([&] {
_color = value;
});
}
ScriptVec3UChar ModelEntityItem::getColor() const {
return resultWithReadLock<ScriptVec3UChar>([&] {
glm::u8vec3 ModelEntityItem::getColor() const {
return resultWithReadLock<glm::u8vec3>([&] {
return _color;
});
}

10
libraries/entities/src/ModelEntityItem.h
View file

@ -57,8 +57,8 @@ public:
// TODO: Move these to subclasses, or other appropriate abstraction
// getters/setters applicable to models and particles
ScriptVec3UChar getColor() const;
void setColor(const ScriptVec3UChar& value);
glm::u8vec3 getColor() const;
void setColor(const glm::u8vec3& value);
bool hasModel() const;
virtual bool hasCompoundShapeURL() const;
@ -115,14 +115,14 @@ public:
virtual void setJointRotations(const QVector<glm::quat>& rotations);
virtual void setJointRotationsSet(const QVector<bool>& rotationsSet);
virtual void setJointTranslations(const QVector<ScriptVec3Float>& translations);
virtual void setJointTranslations(const QVector<glm::vec3>& translations);
virtual void setJointTranslationsSet(const QVector<bool>& translationsSet);
virtual void setAnimationJointsData(const QVector<EntityJointData>& jointsData);
QVector<glm::quat> getJointRotations() const;
QVector<bool> getJointRotationsSet() const;
QVector<ScriptVec3Float> getJointTranslations() const;
QVector<glm::vec3> getJointTranslations() const;
QVector<bool> getJointTranslationsSet() const;
private:
@ -153,7 +153,7 @@ protected:
QVector<ModelJointData> _localJointData;
int _lastKnownCurrentFrame{-1};
ScriptVec3UChar _color;
glm::u8vec3 _color;
QString _modelURL;
bool _relayParentJoints;

36
libraries/entities/src/ParticleEffectEntityItem.cpp
View file

@ -498,9 +498,9 @@ bool ParticleEffectEntityItem::setProperties(const EntityItemProperties& propert
return somethingChanged;
}
void ParticleEffectEntityItem::setColor(const ScriptVec3UChar& value) {
void ParticleEffectEntityItem::setColor(const glm::u8vec3& value) {
withWriteLock([&] {
_particleProperties.color.gradient.target = value.toGlm();
_particleProperties.color.gradient.target = value;
});
}
@ -512,15 +512,15 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch
int bytesRead = 0;
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_EMITTING_PARTICLES, bool, setIsEmitting);
READ_ENTITY_PROPERTY(PROP_SHAPE_TYPE, ShapeType, setShapeType);
READ_ENTITY_PROPERTY(PROP_MAX_PARTICLES, quint32, setMaxParticles);
READ_ENTITY_PROPERTY(PROP_LIFESPAN, float, setLifespan);
READ_ENTITY_PROPERTY(PROP_EMIT_RATE, float, setEmitRate);
READ_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, ScriptVec3Float, setEmitAcceleration);
READ_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, ScriptVec3Float, setAccelerationSpread);
READ_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, glm::vec3, setEmitAcceleration);
READ_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, glm::vec3, setAccelerationSpread);
READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius);
READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures);
@ -528,9 +528,9 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch
READ_ENTITY_PROPERTY(PROP_RADIUS_START, float, setRadiusStart);
READ_ENTITY_PROPERTY(PROP_RADIUS_FINISH, float, setRadiusFinish);
READ_ENTITY_PROPERTY(PROP_COLOR_SPREAD, ScriptVec3UChar, setColorSpread);
READ_ENTITY_PROPERTY(PROP_COLOR_START, ScriptVec3Float, setColorStart);
READ_ENTITY_PROPERTY(PROP_COLOR_FINISH, ScriptVec3Float, setColorFinish);
READ_ENTITY_PROPERTY(PROP_COLOR_SPREAD, glm::u8vec3, setColorSpread);
READ_ENTITY_PROPERTY(PROP_COLOR_START, glm::vec3, setColorStart);
READ_ENTITY_PROPERTY(PROP_COLOR_FINISH, glm::vec3, setColorFinish);
READ_ENTITY_PROPERTY(PROP_ALPHA, float, setAlpha);
READ_ENTITY_PROPERTY(PROP_ALPHA_SPREAD, float, setAlphaSpread);
READ_ENTITY_PROPERTY(PROP_ALPHA_START, float, setAlphaStart);
@ -539,7 +539,7 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch
READ_ENTITY_PROPERTY(PROP_EMIT_SPEED, float, setEmitSpeed);
READ_ENTITY_PROPERTY(PROP_SPEED_SPREAD, float, setSpeedSpread);
READ_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, quat, setEmitOrientation);
READ_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, ScriptVec3Float, setEmitDimensions);
READ_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, glm::vec3, setEmitDimensions);
READ_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, float, setEmitRadiusStart);
READ_ENTITY_PROPERTY(PROP_POLAR_START, float, setPolarStart);
READ_ENTITY_PROPERTY(PROP_POLAR_FINISH, float, setPolarFinish);
@ -614,16 +614,16 @@ void ParticleEffectEntityItem::appendSubclassData(OctreePacketData* packetData,
APPEND_ENTITY_PROPERTY(PROP_MAX_PARTICLES, getMaxParticles());
APPEND_ENTITY_PROPERTY(PROP_LIFESPAN, getLifespan());
APPEND_ENTITY_PROPERTY(PROP_EMIT_RATE, getEmitRate());
APPEND_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, getScriptEmitAcceleration());
APPEND_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, getScriptAccelerationSpread());
APPEND_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, getEmitAcceleration());
APPEND_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, getAccelerationSpread());
APPEND_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, getParticleRadius());
APPEND_ENTITY_PROPERTY(PROP_TEXTURES, getTextures());
APPEND_ENTITY_PROPERTY(PROP_RADIUS_SPREAD, getRadiusSpread());
APPEND_ENTITY_PROPERTY(PROP_RADIUS_START, getRadiusStart());
APPEND_ENTITY_PROPERTY(PROP_RADIUS_FINISH, getRadiusFinish());
APPEND_ENTITY_PROPERTY(PROP_COLOR_SPREAD, getColorSpread());
APPEND_ENTITY_PROPERTY(PROP_COLOR_START, getScriptColorStart());
APPEND_ENTITY_PROPERTY(PROP_COLOR_FINISH, getScriptColorFinish());
APPEND_ENTITY_PROPERTY(PROP_COLOR_START, getColorStart());
APPEND_ENTITY_PROPERTY(PROP_COLOR_FINISH, getColorFinish());
APPEND_ENTITY_PROPERTY(PROP_ALPHA, getAlpha());
APPEND_ENTITY_PROPERTY(PROP_ALPHA_SPREAD, getAlphaSpread());
APPEND_ENTITY_PROPERTY(PROP_ALPHA_START, getAlphaStart());
@ -631,7 +631,7 @@ void ParticleEffectEntityItem::appendSubclassData(OctreePacketData* packetData,
APPEND_ENTITY_PROPERTY(PROP_EMIT_SPEED, getEmitSpeed());
APPEND_ENTITY_PROPERTY(PROP_SPEED_SPREAD, getSpeedSpread());
APPEND_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, getEmitOrientation());
APPEND_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, getScriptEmitDimensions());
APPEND_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, getEmitDimensions());
APPEND_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, getEmitRadiusStart());
APPEND_ENTITY_PROPERTY(PROP_POLAR_START, getPolarStart());
APPEND_ENTITY_PROPERTY(PROP_POLAR_FINISH, getPolarFinish());
@ -692,9 +692,9 @@ void ParticleEffectEntityItem::setColorFinish(const vec3& colorFinish) {
});
}
void ParticleEffectEntityItem::setColorSpread(const ScriptVec3UChar& value) {
void ParticleEffectEntityItem::setColorSpread(const glm::u8vec3& value) {
withWriteLock([&] {
_particleProperties.color.gradient.spread = value.toGlm();
_particleProperties.color.gradient.spread = value;
});
}
@ -717,10 +717,10 @@ particle::Properties ParticleEffectEntityItem::getParticleProperties() const {
// Special case the properties that get treated differently if they're unintialized
if (glm::any(glm::isnan(result.color.range.start))) {
result.color.range.start = getColor().toGlm();
result.color.range.start = getColor();
}
if (glm::any(glm::isnan(result.color.range.finish))) {
result.color.range.finish = getColor().toGlm();
result.color.range.finish = getColor();
}
if (glm::isnan(result.alpha.range.start)) {
result.alpha.range.start = getAlpha();

32
libraries/entities/src/ParticleEffectEntityItem.h
View file

@ -20,9 +20,9 @@
namespace particle {
static const float SCRIPT_MAXIMUM_PI = 3.1416f; // Round up so that reasonable property values work
static const float UNINITIALIZED = NAN;
static const ScriptVec3UChar DEFAULT_COLOR = { 255, 255, 255 };
static const u8vec3 DEFAULT_COLOR = { 255, 255, 255 };
static const vec3 DEFAULT_COLOR_UNINITIALIZED = { UNINITIALIZED, UNINITIALIZED, UNINITIALIZED };
static const ScriptVec3UChar DEFAULT_COLOR_SPREAD = { 0, 0, 0 };
static const u8vec3 DEFAULT_COLOR_SPREAD = { 0, 0, 0 };
static const float DEFAULT_ALPHA = 1.0f;
static const float DEFAULT_ALPHA_SPREAD = 0.0f;
static const float DEFAULT_ALPHA_START = UNINITIALIZED;
@ -42,8 +42,8 @@ namespace particle {
static const float MINIMUM_EMIT_SPEED = -1000.0f;
static const float MAXIMUM_EMIT_SPEED = 1000.0f; // Approx mach 3
static const float DEFAULT_SPEED_SPREAD = 1.0f;
static const glm::quat DEFAULT_EMIT_ORIENTATION = glm::angleAxis(-PI_OVER_TWO, Vectors::UNIT_X); // Vertical
static const glm::vec3 DEFAULT_EMIT_DIMENSIONS = Vectors::ZERO; // Emit from point
static const quat DEFAULT_EMIT_ORIENTATION = glm::angleAxis(-PI_OVER_TWO, Vectors::UNIT_X); // Vertical
static const vec3 DEFAULT_EMIT_DIMENSIONS = Vectors::ZERO; // Emit from point
static const float MINIMUM_EMIT_DIMENSION = 0.0f;
static const float MAXIMUM_EMIT_DIMENSION = (float)TREE_SCALE;
static const float DEFAULT_EMIT_RADIUS_START = 1.0f; // Emit from surface (when emitDimensions > 0)
@ -57,10 +57,10 @@ namespace particle {
static const float MAXIMUM_AZIMUTH = SCRIPT_MAXIMUM_PI;
static const float DEFAULT_AZIMUTH_START = -PI; // Emit full circumference (when polarFinish > 0)
static const float DEFAULT_AZIMUTH_FINISH = PI; // ""
static const glm::vec3 DEFAULT_EMIT_ACCELERATION(0.0f, -9.8f, 0.0f);
static const vec3 DEFAULT_EMIT_ACCELERATION(0.0f, -9.8f, 0.0f);
static const float MINIMUM_EMIT_ACCELERATION = -100.0f; // ~ 10g
static const float MAXIMUM_EMIT_ACCELERATION = 100.0f;
static const glm::vec3 DEFAULT_ACCELERATION_SPREAD(0.0f, 0.0f, 0.0f);
static const vec3 DEFAULT_ACCELERATION_SPREAD(0.0f, 0.0f, 0.0f);
static const float MINIMUM_ACCELERATION_SPREAD = 0.0f;
static const float MAXIMUM_ACCELERATION_SPREAD = 100.0f;
static const float DEFAULT_PARTICLE_RADIUS = 0.025f;
@ -154,7 +154,7 @@ namespace particle {
};
struct Properties {
RangeGradient<vec3> color { DEFAULT_COLOR.toGlm(), DEFAULT_COLOR_UNINITIALIZED, DEFAULT_COLOR_UNINITIALIZED, DEFAULT_COLOR_SPREAD.toGlm() };
RangeGradient<vec3> color { DEFAULT_COLOR, DEFAULT_COLOR_UNINITIALIZED, DEFAULT_COLOR_UNINITIALIZED, DEFAULT_COLOR_SPREAD };
RangeGradient<float> alpha { DEFAULT_ALPHA, DEFAULT_ALPHA_START, DEFAULT_ALPHA_FINISH, DEFAULT_ALPHA_SPREAD };
float radiusStart { DEFAULT_EMIT_RADIUS_START };
RangeGradient<float> radius { DEFAULT_PARTICLE_RADIUS, DEFAULT_RADIUS_START, DEFAULT_RADIUS_FINISH, DEFAULT_RADIUS_SPREAD };
@ -228,21 +228,17 @@ public:
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
bool& somethingChanged) override;
void setColor(const ScriptVec3UChar& value);
ScriptVec3UChar getColor() const { return _particleProperties.color.gradient.target; }
void setColor(const glm::u8vec3& value);
glm::u8vec3 getColor() const { return _particleProperties.color.gradient.target; }
void setColorStart(const vec3& colorStart);
void setColorStart(const ScriptVec3Float& colorStart) { setColorStart(colorStart.toGlm()); }
vec3 getColorStart() const { return _particleProperties.color.range.start; }
ScriptVec3Float getScriptColorStart() const { return getColorStart(); }
void setColorFinish(const vec3& colorFinish);
void setColorFinish(const ScriptVec3Float& colorFinish) { setColorFinish(colorFinish.toGlm()); }
vec3 getColorFinish() const { return _particleProperties.color.range.finish; }
ScriptVec3Float getScriptColorFinish() const { return getColorFinish(); }
void setColorSpread(const ScriptVec3UChar& colorSpread);
ScriptVec3UChar getColorSpread() const { return _particleProperties.color.gradient.spread; }
void setColorSpread(const glm::u8vec3& colorSpread);
glm::u8vec3 getColorSpread() const { return _particleProperties.color.gradient.spread; }
void setAlpha(float alpha);
float getAlpha() const { return _particleProperties.alpha.gradient.target; }
@ -283,9 +279,7 @@ public:
const glm::quat& getEmitOrientation() const { return _particleProperties.emission.orientation; }
void setEmitDimensions(const glm::vec3& emitDimensions);
void setEmitDimensions(const ScriptVec3Float& emitDimensions) { setEmitDimensions(emitDimensions.toGlm()); }
const glm::vec3& getEmitDimensions() const { return _particleProperties.emission.dimensions; }
ScriptVec3Float getScriptEmitDimensions() const { return getEmitDimensions(); }
void setEmitRadiusStart(float emitRadiusStart);
float getEmitRadiusStart() const { return _particleProperties.radiusStart; }
@ -303,14 +297,10 @@ public:
float getAzimuthFinish() const { return _particleProperties.azimuth.finish; }
void setEmitAcceleration(const glm::vec3& emitAcceleration);
void setEmitAcceleration(const ScriptVec3Float& emitAcceleration) { setEmitAcceleration(emitAcceleration.toGlm()); }
const glm::vec3& getEmitAcceleration() const { return _particleProperties.emission.acceleration.target; }
ScriptVec3Float getScriptEmitAcceleration() const { return getEmitAcceleration(); }
void setAccelerationSpread(const glm::vec3& accelerationSpread);
void setAccelerationSpread(const ScriptVec3Float& accelerationSpread) { setAccelerationSpread(accelerationSpread.toGlm()); }
const glm::vec3& getAccelerationSpread() const { return _particleProperties.emission.acceleration.spread; }
ScriptVec3Float getScriptAccelerationSpread() const { return getAccelerationSpread(); }
void setParticleRadius(float particleRadius);
float getParticleRadius() const { return _particleProperties.radius.gradient.target; }

39
libraries/entities/src/PolyLineEntityItem.cpp
View file

@ -79,7 +79,7 @@ bool PolyLineEntityItem::setProperties(const EntityItemProperties& properties) {
}
bool PolyLineEntityItem::appendPoint(const ScriptVec3Float& point) {
bool PolyLineEntityItem::appendPoint(const glm::vec3& point) {
if (_points.size() > MAX_POINTS_PER_LINE - 1) {
qCDebug(entities) << "MAX POINTS REACHED!";
return false;
@ -102,7 +102,7 @@ bool PolyLineEntityItem::setStrokeWidths(const QVector<float>& strokeWidths) {
return true;
}
bool PolyLineEntityItem::setNormals(const QVector<ScriptVec3Float>& normals) {
bool PolyLineEntityItem::setNormals(const QVector<glm::vec3>& normals) {
withWriteLock([&] {
_normals = normals;
_normalsChanged = true;
@ -110,7 +110,7 @@ bool PolyLineEntityItem::setNormals(const QVector<ScriptVec3Float>& normals) {
return true;
}
bool PolyLineEntityItem::setStrokeColors(const QVector<ScriptVec3Float>& strokeColors) {
bool PolyLineEntityItem::setStrokeColors(const QVector<glm::vec3>& strokeColors) {
withWriteLock([&] {
_strokeColors = strokeColors;
_strokeColorsChanged = true;
@ -119,7 +119,7 @@ bool PolyLineEntityItem::setStrokeColors(const QVector<ScriptVec3Float>& strokeC
}
bool PolyLineEntityItem::setLinePoints(const QVector<ScriptVec3Float>& points) {
bool PolyLineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
if (points.size() > MAX_POINTS_PER_LINE) {
return false;
}
@ -161,10 +161,10 @@ void PolyLineEntityItem::calculateScaleAndRegistrationPoint() {
withReadLock([&] {
pointCount = _points.size();
if (pointCount > 0) {
firstPoint = _points.at(0).toGlm();
firstPoint = _points.at(0);
}
for (int i = 0; i < pointCount; i++) {
const glm::vec3& point = _points.at(i).toGlm();
const glm::vec3& point = _points.at(i);
high = glm::max(point, high);
low = glm::min(point, low);
}
@ -200,11 +200,11 @@ int PolyLineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
int bytesRead = 0;
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_LINE_WIDTH, float, setLineWidth);
READ_ENTITY_PROPERTY(PROP_LINE_POINTS, QVector<ScriptVec3Float>, setLinePoints);
READ_ENTITY_PROPERTY(PROP_NORMALS, QVector<ScriptVec3Float>, setNormals);
READ_ENTITY_PROPERTY(PROP_STROKE_COLORS, QVector<ScriptVec3Float>, setStrokeColors);
READ_ENTITY_PROPERTY(PROP_LINE_POINTS, QVector<glm::vec3>, setLinePoints);
READ_ENTITY_PROPERTY(PROP_NORMALS, QVector<glm::vec3>, setNormals);
READ_ENTITY_PROPERTY(PROP_STROKE_COLORS, QVector<glm::vec3>, setStrokeColors);
READ_ENTITY_PROPERTY(PROP_STROKE_WIDTHS, QVector<float>, setStrokeWidths);
READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures);
READ_ENTITY_PROPERTY(PROP_IS_UV_MODE_STRETCH, bool, setIsUVModeStretch);
@ -257,24 +257,24 @@ void PolyLineEntityItem::debugDump() const {
QVector<ScriptVec3Float> PolyLineEntityItem::getLinePoints() const {
QVector<ScriptVec3Float> result;
QVector<glm::vec3> PolyLineEntityItem::getLinePoints() const {
QVector<glm::vec3> result;
withReadLock([&] {
result = _points;
});
return result;
}
QVector<ScriptVec3Float> PolyLineEntityItem::getNormals() const {
QVector<ScriptVec3Float> result;
QVector<glm::vec3> PolyLineEntityItem::getNormals() const {
QVector<glm::vec3> result;
withReadLock([&] {
result = _normals;
});
return result;
}
QVector<ScriptVec3Float> PolyLineEntityItem::getStrokeColors() const {
QVector<ScriptVec3Float> result;
QVector<glm::vec3> PolyLineEntityItem::getStrokeColors() const {
QVector<glm::vec3> result;
withReadLock([&] {
result = _strokeColors;
});
@ -306,14 +306,15 @@ void PolyLineEntityItem::setTextures(const QString& textures) {
});
}
void PolyLineEntityItem::setColor(const ScriptVec3UChar& value) {
void PolyLineEntityItem::setColor(const glm::u8vec3& value) {
withWriteLock([&] {
_strokeColorsChanged = true;
_color = value;
});
}
ScriptVec3UChar PolyLineEntityItem::getColor() const {
return resultWithReadLock<ScriptVec3UChar>([&] {
glm::u8vec3 PolyLineEntityItem::getColor() const {
return resultWithReadLock<glm::u8vec3>([&] {
return _color;
});
}

26
libraries/entities/src/PolyLineEntityItem.h
View file

@ -41,21 +41,21 @@ class PolyLineEntityItem : public EntityItem {
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
bool& somethingChanged) override;
ScriptVec3UChar getColor() const;
void setColor(const ScriptVec3UChar& value);
glm::u8vec3 getColor() const;
void setColor(const glm::u8vec3& value);
void setLineWidth(float lineWidth){ _lineWidth = lineWidth; }
float getLineWidth() const{ return _lineWidth; }
bool setLinePoints(const QVector<ScriptVec3Float>& points);
bool appendPoint(const ScriptVec3Float& point);
QVector<ScriptVec3Float> getLinePoints() const;
bool setLinePoints(const QVector<glm::vec3>& points);
bool appendPoint(const glm::vec3& point);
QVector<glm::vec3> getLinePoints() const;
bool setNormals(const QVector<ScriptVec3Float>& normals);
QVector<ScriptVec3Float> getNormals() const;
bool setNormals(const QVector<glm::vec3>& normals);
QVector<glm::vec3> getNormals() const;
bool setStrokeColors(const QVector<ScriptVec3Float>& strokeColors);
QVector<ScriptVec3Float> getStrokeColors() const;
bool setStrokeColors(const QVector<glm::vec3>& strokeColors);
QVector<glm::vec3> getStrokeColors() const;
bool setStrokeWidths(const QVector<float>& strokeWidths);
QVector<float> getStrokeWidths() const;
@ -98,15 +98,15 @@ private:
void calculateScaleAndRegistrationPoint();
protected:
ScriptVec3UChar _color;
glm::u8vec3 _color;
float _lineWidth { DEFAULT_LINE_WIDTH };
bool _pointsChanged { true };
bool _normalsChanged { true };
bool _strokeColorsChanged { true };
bool _strokeWidthsChanged { true };
QVector<ScriptVec3Float> _points;
QVector<ScriptVec3Float> _normals;
QVector<ScriptVec3Float> _strokeColors;
QVector<glm::vec3> _points;
QVector<glm::vec3> _normals;
QVector<glm::vec3> _strokeColors;
QVector<float> _strokeWidths;
QString _textures;
bool _isUVModeStretch;

14
libraries/entities/src/PolyVoxEntityItem.cpp
View file

@ -70,9 +70,9 @@ PolyVoxEntityItem::PolyVoxEntityItem(const EntityItemID& entityItemID) : EntityI
_type = EntityTypes::PolyVox;
}
void PolyVoxEntityItem::setVoxelVolumeSize(const ScriptVec3Float& voxelVolumeSize) {
void PolyVoxEntityItem::setVoxelVolumeSize(const glm::vec3& voxelVolumeSize) {
withWriteLock([&] {
assert(!glm::any(glm::isnan(voxelVolumeSize.toGlm())));
assert(!glm::any(glm::isnan(voxelVolumeSize)));
_voxelVolumeSize = glm::vec3(roundf(voxelVolumeSize.x), roundf(voxelVolumeSize.y), roundf(voxelVolumeSize.z));
if (_voxelVolumeSize.x < 1) {
@ -104,8 +104,8 @@ void PolyVoxEntityItem::setVoxelVolumeSize(const ScriptVec3Float& voxelVolumeSiz
});
}
ScriptVec3Float PolyVoxEntityItem::getVoxelVolumeSize() const {
ScriptVec3Float voxelVolumeSize;
glm::vec3 PolyVoxEntityItem::getVoxelVolumeSize() const {
glm::vec3 voxelVolumeSize;
withReadLock([&] {
voxelVolumeSize = _voxelVolumeSize;
});
@ -167,7 +167,7 @@ int PolyVoxEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* dat
int bytesRead = 0;
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_VOXEL_VOLUME_SIZE, ScriptVec3Float, setVoxelVolumeSize);
READ_ENTITY_PROPERTY(PROP_VOXEL_VOLUME_SIZE, glm::vec3, setVoxelVolumeSize);
READ_ENTITY_PROPERTY(PROP_VOXEL_DATA, QByteArray, setVoxelData);
READ_ENTITY_PROPERTY(PROP_VOXEL_SURFACE_STYLE, uint16_t, setVoxelSurfaceStyle);
READ_ENTITY_PROPERTY(PROP_X_TEXTURE_URL, QString, setXTextureURL);
@ -375,7 +375,7 @@ EntityItemID PolyVoxEntityItem::getZPNeighborID() const {
glm::vec3 PolyVoxEntityItem::getSurfacePositionAdjustment() const {
glm::vec3 result;
withReadLock([&] {
glm::vec3 scale = getScaledDimensions() / _voxelVolumeSize.toGlm(); // meters / voxel-units
glm::vec3 scale = getScaledDimensions() / _voxelVolumeSize; // meters / voxel-units
if (isEdged()) {
result = scale / -2.0f;
}
@ -387,7 +387,7 @@ glm::vec3 PolyVoxEntityItem::getSurfacePositionAdjustment() const {
glm::mat4 PolyVoxEntityItem::voxelToLocalMatrix() const {
glm::vec3 voxelVolumeSize;
withReadLock([&] {
voxelVolumeSize = _voxelVolumeSize.toGlm();
voxelVolumeSize = _voxelVolumeSize;
});
glm::vec3 dimensions = getScaledDimensions();

6
libraries/entities/src/PolyVoxEntityItem.h
View file

@ -54,8 +54,8 @@ class PolyVoxEntityItem : public EntityItem {
virtual void debugDump() const override;
virtual void setVoxelVolumeSize(const ScriptVec3Float& voxelVolumeSize);
virtual ScriptVec3Float getVoxelVolumeSize() const;
virtual void setVoxelVolumeSize(const glm::vec3& voxelVolumeSize);
virtual glm::vec3 getVoxelVolumeSize() const;
virtual void setVoxelData(const QByteArray& voxelData);
virtual QByteArray getVoxelData() const;
@ -176,7 +176,7 @@ class PolyVoxEntityItem : public EntityItem {
protected:
void setVoxelDataDirty(bool value) { withWriteLock([&] { _voxelDataDirty = value; }); }
ScriptVec3Float _voxelVolumeSize { DEFAULT_VOXEL_VOLUME_SIZE }; // this is always 3 bytes
glm::vec3 _voxelVolumeSize { DEFAULT_VOXEL_VOLUME_SIZE }; // this is always 3 bytes
QByteArray _voxelData { DEFAULT_VOXEL_DATA };
bool _voxelDataDirty { true }; // _voxelData has changed, things that depend on it should be updated

8
libraries/entities/src/ShapeEntityItem.cpp
View file

@ -184,7 +184,7 @@ int ShapeEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_SHAPE, QString, setShape);
READ_ENTITY_PROPERTY(PROP_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_ALPHA, float, setAlpha);
return bytesRead;
@ -212,15 +212,15 @@ void ShapeEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBit
APPEND_ENTITY_PROPERTY(PROP_ALPHA, getAlpha());
}
void ShapeEntityItem::setColor(const ScriptVec3UChar& value) {
void ShapeEntityItem::setColor(const glm::u8vec3& value) {
withWriteLock([&] {
_color = value;
_material->setAlbedo(toGlm(_color));
});
}
ScriptVec3UChar ShapeEntityItem::getColor() const {
return resultWithReadLock<ScriptVec3UChar>([&] {
glm::u8vec3 ShapeEntityItem::getColor() const {
return resultWithReadLock<glm::u8vec3>([&] {
return _color;
});
}

6
libraries/entities/src/ShapeEntityItem.h
View file

@ -77,8 +77,8 @@ public:
float getAlpha() const { return _alpha; };
void setAlpha(float alpha);
ScriptVec3UChar getColor() const;
void setColor(const ScriptVec3UChar& value);
glm::u8vec3 getColor() const;
void setColor(const glm::u8vec3& value);
void setUnscaledDimensions(const glm::vec3& value) override;
@ -104,7 +104,7 @@ public:
protected:
float _alpha { 1.0f };
ScriptVec3UChar _color;
glm::u8vec3 _color;
entity::Shape _shape { entity::Shape::Sphere };
//! This is SHAPE_TYPE_ELLIPSOID rather than SHAPE_TYPE_NONE to maintain

8
libraries/entities/src/SkyboxPropertyGroup.cpp
View file

@ -16,7 +16,7 @@
#include "EntityItemProperties.h"
#include "EntityItemPropertiesMacros.h"
const ScriptVec3UChar SkyboxPropertyGroup::DEFAULT_COLOR = { 0, 0, 0 };
const glm::u8vec3 SkyboxPropertyGroup::DEFAULT_COLOR = { 0, 0, 0 };
void SkyboxPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties, QScriptEngine* engine, bool skipDefaults, EntityItemProperties& defaultEntityProperties) const {
COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_SKYBOX_COLOR, Skybox, skybox, Color, color);
@ -24,7 +24,7 @@ void SkyboxPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredPr
}
void SkyboxPropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(skybox, color, ScriptVec3UChar, setColor);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(skybox, color, u8vec3, setColor);
COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(skybox, url, QString, setURL);
}
@ -71,7 +71,7 @@ bool SkyboxPropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFlag
bool overwriteLocalData = true;
bool somethingChanged = false;
READ_ENTITY_PROPERTY(PROP_SKYBOX_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_SKYBOX_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_SKYBOX_URL, QString, setURL);
DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_SKYBOX_COLOR, Color);
@ -143,7 +143,7 @@ int SkyboxPropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char* d
int bytesRead = 0;
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_SKYBOX_COLOR, ScriptVec3UChar, setColor);
READ_ENTITY_PROPERTY(PROP_SKYBOX_COLOR, glm::u8vec3, setColor);
READ_ENTITY_PROPERTY(PROP_SKYBOX_URL, QString, setURL);
return bytesRead;

4
libraries/entities/src/SkyboxPropertyGroup.h
View file

@ -83,8 +83,8 @@ public:
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
bool& somethingChanged) override;
static const ScriptVec3UChar DEFAULT_COLOR;
DEFINE_PROPERTY_REF(PROP_SKYBOX_COLOR, Color, color, ScriptVec3UChar, DEFAULT_COLOR);
static const glm::u8vec3 DEFAULT_COLOR;
DEFINE_PROPERTY_REF(PROP_SKYBOX_COLOR, Color, color, glm::u8vec3, DEFAULT_COLOR);
DEFINE_PROPERTY_REF(PROP_SKYBOX_URL, URL, url, QString, "");
};

20
libraries/entities/src/TextEntityItem.cpp
View file

@ -25,8 +25,8 @@
const QString TextEntityItem::DEFAULT_TEXT("");
const float TextEntityItem::DEFAULT_LINE_HEIGHT = 0.1f;
const ScriptVec3UChar TextEntityItem::DEFAULT_TEXT_COLOR = { 255, 255, 255 };
const ScriptVec3UChar TextEntityItem::DEFAULT_BACKGROUND_COLOR = { 0, 0, 0};
const glm::u8vec3 TextEntityItem::DEFAULT_TEXT_COLOR = { 255, 255, 255 };
const glm::u8vec3 TextEntityItem::DEFAULT_BACKGROUND_COLOR = { 0, 0, 0};
const bool TextEntityItem::DEFAULT_FACE_CAMERA = false;
EntityItemPointer TextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
@ -91,8 +91,8 @@ int TextEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
READ_ENTITY_PROPERTY(PROP_TEXT, QString, setText);
READ_ENTITY_PROPERTY(PROP_LINE_HEIGHT, float, setLineHeight);
READ_ENTITY_PROPERTY(PROP_TEXT_COLOR, ScriptVec3UChar, setTextColor);
READ_ENTITY_PROPERTY(PROP_BACKGROUND_COLOR, ScriptVec3UChar, setBackgroundColor);
READ_ENTITY_PROPERTY(PROP_TEXT_COLOR, glm::u8vec3, setTextColor);
READ_ENTITY_PROPERTY(PROP_BACKGROUND_COLOR, glm::u8vec3, setBackgroundColor);
READ_ENTITY_PROPERTY(PROP_FACE_CAMERA, bool, setFaceCamera);
return bytesRead;
@ -206,26 +206,26 @@ float TextEntityItem::getLineHeight() const {
return result;
}
void TextEntityItem::setTextColor(const ScriptVec3UChar& value) {
void TextEntityItem::setTextColor(const glm::u8vec3& value) {
withWriteLock([&] {
_textColor = value;
});
}
ScriptVec3UChar TextEntityItem::getTextColor() const {
return resultWithReadLock<ScriptVec3UChar>([&] {
glm::u8vec3 TextEntityItem::getTextColor() const {
return resultWithReadLock<glm::u8vec3>([&] {
return _textColor;
});
}
void TextEntityItem::setBackgroundColor(const ScriptVec3UChar& value) {
void TextEntityItem::setBackgroundColor(const glm::u8vec3& value) {
withWriteLock([&] {
_backgroundColor = value;
});
}
ScriptVec3UChar TextEntityItem::getBackgroundColor() const {
return resultWithReadLock<ScriptVec3UChar>([&] {
glm::u8vec3 TextEntityItem::getBackgroundColor() const {
return resultWithReadLock<glm::u8vec3>([&] {
return _backgroundColor;
});
}

16
libraries/entities/src/TextEntityItem.h
View file

@ -63,13 +63,13 @@ public:
void setLineHeight(float value);
float getLineHeight() const;
static const ScriptVec3UChar DEFAULT_TEXT_COLOR;
ScriptVec3UChar getTextColor() const;
void setTextColor(const ScriptVec3UChar& value);
static const glm::u8vec3 DEFAULT_TEXT_COLOR;
glm::u8vec3 getTextColor() const;
void setTextColor(const glm::u8vec3& value);
static const ScriptVec3UChar DEFAULT_BACKGROUND_COLOR;
ScriptVec3UChar getBackgroundColor() const;
void setBackgroundColor(const ScriptVec3UChar& value);
static const glm::u8vec3 DEFAULT_BACKGROUND_COLOR;
glm::u8vec3 getBackgroundColor() const;
void setBackgroundColor(const glm::u8vec3& value);
static const bool DEFAULT_FACE_CAMERA;
bool getFaceCamera() const;
@ -78,8 +78,8 @@ public:
private:
QString _text;
float _lineHeight;
ScriptVec3UChar _textColor;
ScriptVec3UChar _backgroundColor;
glm::u8vec3 _textColor;
glm::u8vec3 _backgroundColor;
bool _faceCamera;
};

4
libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
View file

@ -367,8 +367,8 @@ namespace scriptable {
obj.setProperty("metallic", material.metallic);
obj.setProperty("scattering", material.scattering);
obj.setProperty("unlit", material.unlit);
obj.setProperty("emissive", vec3ToScriptValue(engine, material.emissive));
obj.setProperty("albedo", vec3ToScriptValue(engine, material.albedo));
obj.setProperty("emissive", vec3FloatToScriptValue(engine, material.emissive));
obj.setProperty("albedo", vec3FloatToScriptValue(engine, material.albedo));
obj.setProperty("emissiveMap", material.emissiveMap);
obj.setProperty("albedoMap", material.albedoMap);
obj.setProperty("opacityMap", material.opacityMap);

32
libraries/octree/src/OctreePacketData.cpp
View file

@ -373,9 +373,9 @@ bool OctreePacketData::appendValue(float value) {
return success;
}
bool OctreePacketData::appendValue(const ScriptVec2Float& value) {
bool OctreePacketData::appendValue(const glm::vec2& value) {
const unsigned char* data = (const unsigned char*)&value;
int length = sizeof(ScriptVec2Float);
int length = sizeof(glm::vec2);
bool success = append(data, length);
if (success) {
_bytesOfValues += length;
@ -384,9 +384,9 @@ bool OctreePacketData::appendValue(const ScriptVec2Float& value) {
return success;
}
bool OctreePacketData::appendValue(const ScriptVec3Float& value) {
bool OctreePacketData::appendValue(const glm::vec3& value) {
const unsigned char* data = (const unsigned char*)&value;
int length = sizeof(ScriptVec3Float);
int length = sizeof(glm::vec3);
bool success = append(data, length);
if (success) {
_bytesOfValues += length;
@ -395,18 +395,18 @@ bool OctreePacketData::appendValue(const ScriptVec3Float& value) {
return success;
}
bool OctreePacketData::appendValue(const ScriptVec3UChar& color) {
bool OctreePacketData::appendValue(const glm::u8vec3& color) {
return appendColor(color.x, color.y, color.z);
}
bool OctreePacketData::appendValue(const QVector<ScriptVec3Float>& value) {
bool OctreePacketData::appendValue(const QVector<glm::vec3>& value) {
uint16_t qVecSize = value.size();
bool success = appendValue(qVecSize);
if (success) {
success = append((const unsigned char*)value.constData(), qVecSize * sizeof(ScriptVec3Float));
success = append((const unsigned char*)value.constData(), qVecSize * sizeof(glm::vec3));
if (success) {
_bytesOfValues += qVecSize * sizeof(ScriptVec3Float);
_totalBytesOfValues += qVecSize * sizeof(ScriptVec3Float);
_bytesOfValues += qVecSize * sizeof(glm::vec3);
_totalBytesOfValues += qVecSize * sizeof(glm::vec3);
}
}
return success;
@ -668,17 +668,17 @@ void OctreePacketData::debugBytes() {
qCDebug(octree) << " _bytesReserved=" << _bytesReserved;
}
int OctreePacketData::unpackDataFromBytes(const unsigned char* dataBytes, ScriptVec2Float& result) {
int OctreePacketData::unpackDataFromBytes(const unsigned char* dataBytes, glm::vec2& result) {
memcpy(&result, dataBytes, sizeof(result));
return sizeof(result);
}
int OctreePacketData::unpackDataFromBytes(const unsigned char* dataBytes, ScriptVec3Float& result) {
int OctreePacketData::unpackDataFromBytes(const unsigned char* dataBytes, glm::vec3& result) {
memcpy(&result, dataBytes, sizeof(result));
return sizeof(result);
}
int OctreePacketData::unpackDataFromBytes(const unsigned char* dataBytes, ScriptVec3UChar& result) {
int OctreePacketData::unpackDataFromBytes(const unsigned char* dataBytes, glm::u8vec3& result) {
memcpy(&result, dataBytes, sizeof(result));
return sizeof(result);
}
@ -705,19 +705,19 @@ int OctreePacketData::unpackDataFromBytes(const unsigned char* dataBytes, QUuid&
return sizeof(length) + length;
}
int OctreePacketData::unpackDataFromBytes(const unsigned char *dataBytes, QVector<ScriptVec3Float>& result) {
int OctreePacketData::unpackDataFromBytes(const unsigned char *dataBytes, QVector<glm::vec3>& result) {
uint16_t length;
memcpy(&length, dataBytes, sizeof(uint16_t));
dataBytes += sizeof(length);
// FIXME - this size check is wrong if we allow larger packets
if (length * sizeof(ScriptVec3Float) > MAX_OCTREE_UNCOMRESSED_PACKET_SIZE) {
if (length * sizeof(glm::vec3) > MAX_OCTREE_UNCOMRESSED_PACKET_SIZE) {
result.resize(0);
return sizeof(uint16_t);
}
result.resize(length);
memcpy(result.data(), dataBytes, length * sizeof(ScriptVec3Float));
return sizeof(uint16_t) + length * sizeof(ScriptVec3Float);
memcpy(result.data(), dataBytes, length * sizeof(glm::vec3));
return sizeof(uint16_t) + length * sizeof(glm::vec3);
}
int OctreePacketData::unpackDataFromBytes(const unsigned char *dataBytes, QVector<glm::quat>& result) {

16
libraries/octree/src/OctreePacketData.h
View file

@ -159,16 +159,16 @@ public:
bool appendValue(float value);
/// appends a vec2 to the end of the stream, may fail if new data stream is too long to fit in packet
bool appendValue(const ScriptVec2Float& value);
bool appendValue(const glm::vec2& value);
/// appends a non-position vector to the end of the stream, may fail if new data stream is too long to fit in packet
bool appendValue(const ScriptVec3Float& value);
bool appendValue(const glm::vec3& value);
/// appends a color to the end of the stream, may fail if new data stream is too long to fit in packet
bool appendValue(const ScriptVec3UChar& value);
bool appendValue(const glm::u8vec3& value);
/// appends a QVector of vec3s to the end of the stream, may fail if new data stream is too long to fit in packet
bool appendValue(const QVector<ScriptVec3Float>& value);
bool appendValue(const QVector<glm::vec3>& value);
/// appends a QVector of quats to the end of the stream, may fail if new data stream is too long to fit in packet
bool appendValue(const QVector<glm::quat>& value);
@ -258,12 +258,12 @@ public:
static int unpackDataFromBytes(const unsigned char* dataBytes, glm::quat& result) { int bytes = unpackOrientationQuatFromBytes(dataBytes, result); return bytes; }
static int unpackDataFromBytes(const unsigned char* dataBytes, ShapeType& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
static int unpackDataFromBytes(const unsigned char* dataBytes, MaterialMappingMode& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
static int unpackDataFromBytes(const unsigned char* dataBytes, ScriptVec2Float& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, ScriptVec3Float& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, ScriptVec3UChar& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, glm::vec2& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, glm::vec3& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, glm::u8vec3& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QString& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QUuid& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QVector<ScriptVec3Float>& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QVector<glm::vec3>& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QVector<glm::quat>& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QVector<float>& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QVector<bool>& result);

10
libraries/render-utils/src/GeometryCache.cpp
View file

@ -1061,7 +1061,7 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, con
updateVertices(id, points, QVector<glm::vec4>({ color }));
}
void GeometryCache::updateVertices(int id, const QVector<ScriptVec3Float>& points, const QVector<glm::vec4>& colors) {
void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec4>& colors) {
BatchItemDetails& details = _registeredVertices[id];
if (details.isCreated) {
details.clear();
@ -1109,7 +1109,7 @@ void GeometryCache::updateVertices(int id, const QVector<ScriptVec3Float>& point
auto pointCount = points.size();
auto colorCount = colors.size();
for (auto i = 0; i < pointCount; i++) {
const glm::vec3& point = points[i].toGlm();
const glm::vec3& point = points[i];
if (i < colorCount) {
const glm::vec4& color = colors[i];
compactColor = ((int(color.x * 255.0f) & 0xFF)) |
@ -1136,11 +1136,11 @@ void GeometryCache::updateVertices(int id, const QVector<ScriptVec3Float>& point
#endif
}
void GeometryCache::updateVertices(int id, const QVector<ScriptVec3Float>& points, const glm::vec4& color) {
void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, const glm::vec4& color) {
updateVertices(id, points, QVector<glm::vec4>({ color }));
}
void GeometryCache::updateVertices(int id, const QVector<ScriptVec3Float>& points, const QVector<glm::vec2>& texCoords, const glm::vec4& color) {
void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec2>& texCoords, const glm::vec4& color) {
BatchItemDetails& details = _registeredVertices[id];
if (details.isCreated) {
@ -1195,7 +1195,7 @@ void GeometryCache::updateVertices(int id, const QVector<ScriptVec3Float>& point
const glm::vec3 NORMAL(0.0f, 0.0f, 1.0f);
for (int i = 0; i < points.size(); i++) {
glm::vec3 point = points[i].toGlm();
glm::vec3 point = points[i];
glm::vec2 texCoord = texCoords[i];
*(vertex++) = point.x;
*(vertex++) = point.y;

6
libraries/render-utils/src/GeometryCache.h
View file

@ -346,9 +346,9 @@ public:
void updateVertices(int id, const QVector<glm::vec2>& points, const glm::vec4& color);
void updateVertices(int id, const QVector<glm::vec2>& points, const QVector<glm::vec4>& colors);
void updateVertices(int id, const QVector<ScriptVec3Float>& points, const glm::vec4& color);
void updateVertices(int id, const QVector<ScriptVec3Float>& points, const QVector<glm::vec4>& colors);
void updateVertices(int id, const QVector<ScriptVec3Float>& points, const QVector<glm::vec2>& texCoords, const glm::vec4& color);
void updateVertices(int id, const QVector<glm::vec3>& points, const glm::vec4& color);
void updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec4>& colors);
void updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec2>& texCoords, const glm::vec4& color);
void renderVertices(gpu::Batch& batch, gpu::Primitive primitiveType, int id);
/// Set a batch to the simple pipeline, returning the previous pipeline

38
libraries/render-utils/src/Model.cpp
View file

@ -415,8 +415,8 @@ bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const g
face = triangleSetFace;
bestModelTriangle = triangleSetTriangle;
bestWorldTriangle = triangleSetTriangle * meshToWorldMatrix;
extraInfo["worldIntersectionPoint"] = vec3ToVariant(worldIntersectionPoint);
extraInfo["meshIntersectionPoint"] = vec3ToVariant(meshIntersectionPoint);
extraInfo["worldIntersectionPoint"] = vec3toVariant(worldIntersectionPoint);
extraInfo["meshIntersectionPoint"] = vec3toVariant(meshIntersectionPoint);
extraInfo["partIndex"] = partIndex;
extraInfo["shapeID"] = shapeID;
bestSubMeshIndex = subMeshIndex;
@ -435,15 +435,15 @@ bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const g
extraInfo["subMeshIndex"] = bestSubMeshIndex;
extraInfo["subMeshName"] = geometry.getModelNameOfMesh(bestSubMeshIndex);
extraInfo["subMeshTriangleWorld"] = QVariantMap{
{ "v0", vec3ToVariant(bestWorldTriangle.v0) },
{ "v1", vec3ToVariant(bestWorldTriangle.v1) },
{ "v2", vec3ToVariant(bestWorldTriangle.v2) },
{ "v0", vec3toVariant(bestWorldTriangle.v0) },
{ "v1", vec3toVariant(bestWorldTriangle.v1) },
{ "v2", vec3toVariant(bestWorldTriangle.v2) },
};
extraInfo["subMeshNormal"] = vec3ToVariant(bestModelTriangle.getNormal());
extraInfo["subMeshNormal"] = vec3toVariant(bestModelTriangle.getNormal());
extraInfo["subMeshTriangle"] = QVariantMap{
{ "v0", vec3ToVariant(bestModelTriangle.v0) },
{ "v1", vec3ToVariant(bestModelTriangle.v1) },
{ "v2", vec3ToVariant(bestModelTriangle.v2) },
{ "v0", vec3toVariant(bestModelTriangle.v0) },
{ "v1", vec3toVariant(bestModelTriangle.v1) },
{ "v2", vec3toVariant(bestModelTriangle.v2) },
};
}
}
@ -520,8 +520,8 @@ bool Model::findParabolaIntersectionAgainstSubMeshes(const glm::vec3& origin, co
0.5f * meshFrameAcceleration * triangleSetDistance * triangleSetDistance;
glm::vec3 worldIntersectionPoint = origin + velocity * triangleSetDistance +
0.5f * acceleration * triangleSetDistance * triangleSetDistance;
extraInfo["worldIntersectionPoint"] = vec3ToVariant(worldIntersectionPoint);
extraInfo["meshIntersectionPoint"] = vec3ToVariant(meshIntersectionPoint);
extraInfo["worldIntersectionPoint"] = vec3toVariant(worldIntersectionPoint);
extraInfo["meshIntersectionPoint"] = vec3toVariant(meshIntersectionPoint);
extraInfo["partIndex"] = partIndex;
extraInfo["shapeID"] = shapeID;
bestSubMeshIndex = subMeshIndex;
@ -540,15 +540,15 @@ bool Model::findParabolaIntersectionAgainstSubMeshes(const glm::vec3& origin, co
extraInfo["subMeshIndex"] = bestSubMeshIndex;
extraInfo["subMeshName"] = geometry.getModelNameOfMesh(bestSubMeshIndex);
extraInfo["subMeshTriangleWorld"] = QVariantMap{
{ "v0", vec3ToVariant(bestWorldTriangle.v0) },
{ "v1", vec3ToVariant(bestWorldTriangle.v1) },
{ "v2", vec3ToVariant(bestWorldTriangle.v2) },
{ "v0", vec3toVariant(bestWorldTriangle.v0) },
{ "v1", vec3toVariant(bestWorldTriangle.v1) },
{ "v2", vec3toVariant(bestWorldTriangle.v2) },
};
extraInfo["subMeshNormal"] = vec3ToVariant(bestModelTriangle.getNormal());
extraInfo["subMeshNormal"] = vec3toVariant(bestModelTriangle.getNormal());
extraInfo["subMeshTriangle"] = QVariantMap{
{ "v0", vec3ToVariant(bestModelTriangle.v0) },
{ "v1", vec3ToVariant(bestModelTriangle.v1) },
{ "v2", vec3ToVariant(bestModelTriangle.v2) },
{ "v0", vec3toVariant(bestModelTriangle.v0) },
{ "v1", vec3toVariant(bestModelTriangle.v1) },
{ "v2", vec3toVariant(bestModelTriangle.v2) },
};
}
}
@ -999,7 +999,7 @@ void Model::renderDebugMeshBoxes(gpu::Batch& batch) {
if (_debugMeshBoxesID == GeometryCache::UNKNOWN_ID) {
_debugMeshBoxesID = DependencyManager::get<GeometryCache>()->allocateID();
}
QVector<ScriptVec3Float> points;
QVector<glm::vec3> points;
glm::vec3 brn = box.getCorner();
glm::vec3 bln = brn + glm::vec3(box.getDimensions().x, 0, 0);

2
libraries/script-engine/src/ModelScriptingInterface.cpp
View file

@ -192,7 +192,7 @@ QScriptValue ModelScriptingInterface::getVertex(MeshProxy* meshProxy, int vertex
}
glm::vec3 pos = vertexBufferView.get<glm::vec3>(vertexIndex);
return vec3ToScriptValue(_modelScriptEngine, pos);
return vec3FloatToScriptValue(_modelScriptEngine, pos);
}

2
libraries/script-engine/src/ScriptEngine.cpp
View file

@ -681,7 +681,7 @@ void ScriptEngine::init() {
qScriptRegisterSequenceMetaType<QVector<QUuid>>(this);
qScriptRegisterSequenceMetaType<QVector<EntityItemID>>(this);
qScriptRegisterSequenceMetaType<QVector<ScriptVec2Float>>(this);
qScriptRegisterSequenceMetaType<QVector<glm::vec2>>(this);
qScriptRegisterSequenceMetaType<QVector<glm::quat>>(this);
qScriptRegisterSequenceMetaType<QVector<QString>>(this);

4
libraries/script-engine/src/SpatialEvent.cpp
View file

@ -33,9 +33,9 @@ SpatialEvent::SpatialEvent(const SpatialEvent& event) {
QScriptValue SpatialEvent::toScriptValue(QScriptEngine* engine, const SpatialEvent& event) {
QScriptValue obj = engine->newObject();
obj.setProperty("locTranslation", vec3ToScriptValue(engine, event.locTranslation) );
obj.setProperty("locTranslation", vec3FloatToScriptValue(engine, event.locTranslation) );
obj.setProperty("locRotation", quatToScriptValue(engine, event.locRotation) );
obj.setProperty("absTranslation", vec3ToScriptValue(engine, event.absTranslation) );
obj.setProperty("absTranslation", vec3FloatToScriptValue(engine, event.absTranslation) );
obj.setProperty("absRotation", quatToScriptValue(engine, event.absRotation) );
return obj;

6
libraries/script-engine/src/TouchEvent.cpp
View file

@ -16,6 +16,8 @@
#include <NumericalConstants.h>
#include "RegisteredMetaTypes.h"
TouchEvent::TouchEvent() :
x(0.0f),
y(0.0f),
@ -79,7 +81,7 @@ void TouchEvent::initWithQTouchEvent(const QTouchEvent& event) {
touchAvgY += (float)tPoints[i].pos().y();
// add it to our points vector
ScriptVec2Float thisPoint(tPoints[i].pos().x(), tPoints[i].pos().y());
glm::vec2 thisPoint(tPoints[i].pos().x(), tPoints[i].pos().y());
points << thisPoint;
}
touchAvgX /= (float)(touchPoints);
@ -218,7 +220,7 @@ QScriptValue TouchEvent::toScriptValue(QScriptEngine* engine, const TouchEvent&
QScriptValue pointsObj = engine->newArray();
int index = 0;
foreach (ScriptVec2Float point, event.points) {
foreach (glm::vec2 point, event.points) {
QScriptValue thisPoint = vec2FloatToScriptValue(engine, point);
pointsObj.setProperty(index, thisPoint);
index++;

4
libraries/script-engine/src/TouchEvent.h
View file

@ -17,8 +17,6 @@
#include <QVector>
#include <QTouchEvent>
#include <RegisteredMetaTypes.h>
class QScriptValue;
class QScriptEngine;
@ -42,7 +40,7 @@ public:
bool isMeta;
bool isAlt;
int touchPoints;
QVector<ScriptVec2Float> points;
QVector<glm::vec2> points;
float radius;
bool isPinching;
bool isPinchOpening;

6
libraries/shared/src/ColorUtils.h
View file

@ -18,13 +18,11 @@
#include "DependencyManager.h"
#include "RegisteredMetaTypes.h"
extern const float srgbToLinearLookupTable[256];
class ColorUtils {
public:
inline static glm::vec3 toVec3(const ScriptVec3UChar& color);
inline static glm::vec3 toVec3(const glm::u8vec3& color);
// Convert to gamma 2.2 space from linear
inline static glm::vec3 toGamma22Vec3(const glm::vec3& linear);
@ -42,7 +40,7 @@ public:
inline static float tosRGBFloat(const float& linear);
};
inline glm::vec3 ColorUtils::toVec3(const ScriptVec3UChar& color) {
inline glm::vec3 ColorUtils::toVec3(const glm::u8vec3& color) {
const float ONE_OVER_255 = 1.0f / 255.0f;
return glm::vec3(color.x * ONE_OVER_255, color.y * ONE_OVER_255, color.z * ONE_OVER_255);
}

13
libraries/shared/src/GLMHelpers.cpp
View file

@ -13,8 +13,6 @@
#include <glm/gtc/matrix_transform.hpp>
#include "NumericalConstants.h"
#include "RegisteredMetaTypes.h"
const vec3 Vectors::UNIT_X{ 1.0f, 0.0f, 0.0f };
const vec3 Vectors::UNIT_Y{ 0.0f, 1.0f, 0.0f };
const vec3 Vectors::UNIT_Z{ 0.0f, 0.0f, 1.0f };
@ -450,22 +448,21 @@ glm::vec2 toGlm(const QPointF& pt) {
return glm::vec2(pt.x(), pt.y());
}
glm::vec3 toGlm(const ScriptVec3UChar& color) {
glm::vec3 toGlm(const glm::u8vec3& color) {
static const float MAX_COLOR = 255.0f;
return color.toGlm() / MAX_COLOR;
return glm::vec3(color) / MAX_COLOR;
}
vec4 toGlm(const ScriptVec3UChar& color, float alpha) {
vec4 toGlm(const glm::u8vec3& color, float alpha) {
static const float MAX_COLOR = 255.0f;
return vec4(color.toGlm() / MAX_COLOR, alpha);
return vec4(glm::vec3(color) / MAX_COLOR, alpha);
}
ScriptVec3UChar scriptVec3UCharFromGlm(const glm::vec3 & color) {
glm::u8vec3 vec3UCharFromGlm(const glm::vec3 & color) {
static const float MAX_COLOR = 255.0f;
return { (uint8_t)(color.x * MAX_COLOR), (uint8_t)(color.y * MAX_COLOR), (uint8_t)(color.z * MAX_COLOR) };
}
glm::vec4 toGlm(const QColor& color) {
return glm::vec4(color.redF(), color.greenF(), color.blueF(), color.alphaF());
}

9
libraries/shared/src/GLMHelpers.h
View file

@ -24,6 +24,7 @@ using glm::ivec2;
using glm::ivec3;
using glm::ivec4;
using glm::uvec2;
using glm::u8vec3;
using glm::uvec3;
using glm::uvec4;
using glm::mat3;
@ -33,8 +34,6 @@ using glm::vec3;
using glm::vec4;
using glm::quat;
class ScriptVec3UChar;
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdouble-promotion"
@ -176,12 +175,12 @@ bool isSimilarPosition(const glm::vec3& positionA, const glm::vec3& positionB, f
uvec2 toGlm(const QSize& size);
ivec2 toGlm(const QPoint& pt);
vec2 toGlm(const QPointF& pt);
vec3 toGlm(const ScriptVec3UChar& color);
vec3 toGlm(const glm::u8vec3& color);
vec4 toGlm(const QColor& color);
ivec4 toGlm(const QRect& rect);
vec4 toGlm(const ScriptVec3UChar& color, float alpha);
vec4 toGlm(const glm::u8vec3& color, float alpha);
ScriptVec3UChar scriptVec3UCharFromGlm(const glm::vec3 & c);
glm::u8vec3 vec3UCharFromGlm(const glm::vec3 & c);
QSize fromGlm(const glm::ivec2 & v);
QMatrix4x4 fromGlm(const glm::mat4 & m);

4
libraries/shared/src/JointData.h
View file

@ -5,12 +5,10 @@
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include "RegisteredMetaTypes.h"
class EntityJointData {
public:
glm::quat rotation;
ScriptVec3Float translation;
glm::vec3 translation;
bool rotationSet = false;
bool translationSet = false;
};

8
libraries/shared/src/PointerEvent.cpp
View file

@ -230,16 +230,16 @@ void PointerEvent::fromScriptValue(const QScriptValue& object, PointerEvent& eve
event._id = id.isNumber() ? (uint32_t)id.toNumber() : 0;
glm::vec2 pos2D;
vec2FromScriptValue(object.property("pos2D"), event._pos2D);
vec2FloatFromScriptValue(object.property("pos2D"), event._pos2D);
glm::vec3 pos3D;
vec3FromScriptValue(object.property("pos3D"), event._pos3D);
vec3FloatFromScriptValue(object.property("pos3D"), event._pos3D);
glm::vec3 normal;
vec3FromScriptValue(object.property("normal"), event._normal);
vec3FloatFromScriptValue(object.property("normal"), event._normal);
glm::vec3 direction;
vec3FromScriptValue(object.property("direction"), event._direction);
vec3FloatFromScriptValue(object.property("direction"), event._direction);
QScriptValue button = object.property("button");
QString buttonStr = type.isString() ? button.toString() : "NoButtons";

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

@ -25,13 +25,11 @@
#include <QtScript/QScriptValue>
#include <QtScript/QScriptValueIterator>
int glmVec2MetaTypeId = qRegisterMetaType<glm::vec2>();
int vec2FloatMetaTypeId = qRegisterMetaType<ScriptVec2Float>();
int glmVec3MetaTypeId = qRegisterMetaType<glm::vec3>();
int vec3FloatMetaTypeId = qRegisterMetaType<ScriptVec3Float>();
int vec3UintMetaTypeId = qRegisterMetaType<ScriptVec3UChar>();
int vec2FloatMetaTypeId = qRegisterMetaType<glm::vec2>();
int vec3FloatMetaTypeId = qRegisterMetaType<glm::vec3>();
int vec3UintMetaTypeId = qRegisterMetaType<glm::u8vec3>();
int vec4MetaTypeId = qRegisterMetaType<glm::vec4>();
int qVectorVec3MetaTypeId = qRegisterMetaType<QVector<ScriptVec3Float>>();
int qVectorVec3MetaTypeId = qRegisterMetaType<QVector<glm::vec3>>();
int qVectorQuatMetaTypeId = qRegisterMetaType<QVector<glm::quat>>();
int qVectorBoolMetaTypeId = qRegisterMetaType<QVector<bool>>();
int quatMetaTypeId = qRegisterMetaType<glm::quat>();
@ -43,16 +41,14 @@ int voidLambdaType = qRegisterMetaType<std::function<void()>>();
int variantLambdaType = qRegisterMetaType<std::function<QVariant()>>();
void registerMetaTypes(QScriptEngine* engine) {
qScriptRegisterMetaType(engine, vec2ToScriptValue, vec2FromScriptValue);
qScriptRegisterMetaType(engine, vec2FloatToScriptValue, vec2FloatFromScriptValue);
qScriptRegisterMetaType(engine, vec3ToScriptValue, vec3FromScriptValue);
qScriptRegisterMetaType(engine, vec3FloatToScriptValue, vec3FloatFromScriptValue);
qScriptRegisterMetaType(engine, vec3UCharToScriptValue, vec3UCharFromScriptValue);
qScriptRegisterMetaType(engine, vec4toScriptValue, vec4FromScriptValue);
qScriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue);
qScriptRegisterMetaType(engine, mat4toScriptValue, mat4FromScriptValue);
qScriptRegisterMetaType(engine, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue);
qScriptRegisterMetaType(engine, qVectorVec3FloatToScriptValue, qVectorVec3FloatFromScriptValue);
qScriptRegisterMetaType(engine, qVectorQuatToScriptValue, qVectorQuatFromScriptValue);
qScriptRegisterMetaType(engine, qVectorBoolToScriptValue, qVectorBoolFromScriptValue);
qScriptRegisterMetaType(engine, qVectorFloatToScriptValue, qVectorFloatFromScriptValue);
@ -69,7 +65,7 @@ void registerMetaTypes(QScriptEngine* engine) {
qScriptRegisterMetaType(engine, aaCubeToScriptValue, aaCubeFromScriptValue);
}
QScriptValue vec2FloatToScriptValue(QScriptEngine* engine, const ScriptVec2Float& vec2) {
QScriptValue vec2FloatToScriptValue(QScriptEngine* engine, const glm::vec2& vec2) {
auto prototype = engine->globalObject().property("__hifi_vec2_float__");
if (!prototype.property("defined").toBool()) {
prototype = engine->evaluate(
@ -91,7 +87,7 @@ QScriptValue vec2FloatToScriptValue(QScriptEngine* engine, const ScriptVec2Float
return value;
}
void vec2FloatFromScriptValue(const QScriptValue& object, ScriptVec2Float& vec2) {
void vec2FloatFromScriptValue(const QScriptValue& object, glm::vec2& vec2) {
QScriptValue x = object.property("x");
if (!x.isValid()) {
x = object.property("u");
@ -112,37 +108,6 @@ void vec2FloatFromScriptValue(const QScriptValue& object, ScriptVec2Float& vec2)
vec2.y = y.toVariant().toFloat();
}
QScriptValue vec2ToScriptValue(QScriptEngine* engine, const glm::vec2& vec2) {
QScriptValue obj = engine->newObject();
obj.setProperty("x", vec2.x);
obj.setProperty("y", vec2.y);
return obj;
}
void vec2FromScriptValue(const QScriptValue& object, glm::vec2& vec2) {
auto x = object.property("x");
if (!x.isValid()) {
x = object.property("u");
}
if (!x.isValid()) {
x = object.property("width");
}
auto y = object.property("y");
if (!y.isValid()) {
y = object.property("v");
}
if (!y.isValid()) {
y = object.property("height");
}
if (x.isValid() && y.isValid()) {
vec2.x = x.toVariant().toFloat();
vec2.y = y.toVariant().toFloat();
return;
}
vec2 = glm::vec2();
}
QVariant vec2ToVariant(const glm::vec2 &vec2) {
if (vec2.x != vec2.x || vec2.y != vec2.y) {
// if vec2 contains a NaN don't try to convert it
@ -196,7 +161,7 @@ glm::vec2 vec2FromVariant(const QVariant &object) {
return vec2FromVariant(object, valid);
}
QScriptValue vec3FloatToScriptValue(QScriptEngine* engine, const ScriptVec3Float& vec3) {
QScriptValue vec3FloatToScriptValue(QScriptEngine* engine, const glm::vec3& vec3) {
auto prototype = engine->globalObject().property("__hifi_vec3_float__");
if (!prototype.property("defined").toBool()) {
prototype = engine->evaluate(
@ -225,46 +190,57 @@ QScriptValue vec3FloatToScriptValue(QScriptEngine* engine, const ScriptVec3Float
return value;
}
void vec3FloatFromScriptValue(const QScriptValue& object, ScriptVec3Float& vec3) {
QScriptValue x = object.property("x");
if (!x.isValid()) {
x = object.property("r");
}
if (!x.isValid()) {
x = object.property("red");
}
if (!x.isValid()) {
x = object.property("width");
}
void vec3FloatFromScriptValue(const QScriptValue& object, glm::vec3& vec3) {
if (object.isString()) {
QColor qColor(object.toString());
if (qColor.isValid()) {
vec3.x = qColor.red();
vec3.y = qColor.green();
vec3.z = qColor.blue();
return;
}
} else {
QScriptValue x = object.property("x");
if (!x.isValid()) {
x = object.property("r");
}
if (!x.isValid()) {
x = object.property("red");
}
if (!x.isValid()) {
x = object.property("width");
}
QScriptValue y = object.property("y");
if (!y.isValid()) {
y = object.property("g");
}
if (!y.isValid()) {
y = object.property("green");
}
if (!y.isValid()) {
y = object.property("height");
}
QScriptValue y = object.property("y");
if (!y.isValid()) {
y = object.property("g");
}
if (!y.isValid()) {
y = object.property("green");
}
if (!y.isValid()) {
y = object.property("height");
}
QScriptValue z = object.property("z");
if (!z.isValid()) {
z = object.property("b");
}
if (!z.isValid()) {
z = object.property("blue");
}
if (!z.isValid()) {
z = object.property("depth");
}
QScriptValue z = object.property("z");
if (!z.isValid()) {
z = object.property("b");
}
if (!z.isValid()) {
z = object.property("blue");
}
if (!z.isValid()) {
z = object.property("depth");
}
vec3.x = x.toVariant().toFloat();
vec3.y = y.toVariant().toFloat();
vec3.z = z.toVariant().toFloat();
vec3.x = x.toVariant().toFloat();
vec3.y = y.toVariant().toFloat();
vec3.z = z.toVariant().toFloat();
return;
}
}
QScriptValue vec3UCharToScriptValue(QScriptEngine* engine, const ScriptVec3UChar& vec3) {
QScriptValue vec3UCharToScriptValue(QScriptEngine* engine, const glm::u8vec3& vec3) {
auto prototype = engine->globalObject().property("__hifi_vec3_uchar__");
if (!prototype.property("defined").toBool()) {
prototype = engine->evaluate(
@ -293,13 +269,13 @@ QScriptValue vec3UCharToScriptValue(QScriptEngine* engine, const ScriptVec3UChar
return value;
}
void vec3UCharFromScriptValue(const QScriptValue& object, ScriptVec3UChar& vec3) {
void vec3UCharFromScriptValue(const QScriptValue& object, glm::u8vec3& vec3) {
if (object.isString()) {
QColor qColor(object.toString());
if (qColor.isValid()) {
vec3.x = (uint8_t)qColor.red();
vec3.y = (uint8_t)qColor.blue();
vec3.z = (uint8_t)qColor.green();
vec3.y = (uint8_t)qColor.green();
vec3.z = (uint8_t)qColor.blue();
return;
}
} else {
@ -341,64 +317,9 @@ void vec3UCharFromScriptValue(const QScriptValue& object, ScriptVec3UChar& vec3)
vec3.z = z.toVariant().toUInt();
return;
}
vec3 = ScriptVec3UChar();
}
QScriptValue vec3ToScriptValue(QScriptEngine* engine, const glm::vec3 &vec3) {
QScriptValue obj = engine->newObject();
if (vec3.x != vec3.x || vec3.y != vec3.y || vec3.z != vec3.z) {
// if vec3 contains a NaN don't try to convert it
return obj;
}
obj.setProperty("x", vec3.x);
obj.setProperty("y", vec3.y);
obj.setProperty("z", vec3.z);
return obj;
}
void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3) {
auto x = object.property("x");
if (!x.isValid()) {
x = object.property("r");
}
if (!x.isValid()) {
x = object.property("red");
}
if (!x.isValid()) {
x = object.property("width");
}
auto y = object.property("y");
if (!y.isValid()) {
y = object.property("g");
}
if (!y.isValid()) {
y = object.property("green");
}
if (!y.isValid()) {
y = object.property("height");
}
auto z = object.property("z");
if (!z.isValid()) {
z = object.property("b");
}
if (!z.isValid()) {
z = object.property("blue");
}
if (!z.isValid()) {
z = object.property("depth");
}
if (x.isValid() && y.isValid() && z.isValid()) {
vec3.x = x.toVariant().toFloat();
vec3.y = y.toVariant().toFloat();
vec3.z = z.toVariant().toFloat();
return;
}
vec3 = glm::vec3();
return;
}
QVariant vec3ToVariant(const glm::vec3& vec3) {
QVariant vec3toVariant(const glm::vec3& vec3) {
if (vec3.x != vec3.x || vec3.y != vec3.y || vec3.z != vec3.z) {
// if vec3 contains a NaN don't try to convert it
return QVariant();
@ -428,16 +349,16 @@ glm::vec3 vec3FromVariant(const QVariant& object, bool& valid) {
QColor qColor(object.toString());
if (qColor.isValid()) {
v.x = (uint8_t)qColor.red();
v.y = (uint8_t)qColor.blue();
v.z = (uint8_t)qColor.green();
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.blue();
v.z = (uint8_t)qColor.green();
v.y = (uint8_t)qColor.green();
v.z = (uint8_t)qColor.blue();
valid = true;
}
} else {
@ -594,7 +515,7 @@ void mat4FromScriptValue(const QScriptValue& object, glm::mat4& mat4) {
mat4[3][3] = object.property("r3c3").toVariant().toFloat();
}
QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<ScriptVec3Float>& vector) {
QScriptValue qVectorVec3FloatToScriptValue(QScriptEngine* engine, const QVector<glm::vec3>& vector) {
QScriptValue array = engine->newArray();
for (int i = 0; i < vector.size(); i++) {
array.setProperty(i, vec3FloatToScriptValue(engine, vector.at(i)));
@ -602,23 +523,23 @@ QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<Scrip
return array;
}
QVector<ScriptVec3Float> qVectorVec3FromScriptValue(const QScriptValue& array) {
QVector<ScriptVec3Float> newVector;
QVector<glm::vec3> qVectorVec3FloatFromScriptValue(const QScriptValue& array) {
QVector<glm::vec3> newVector;
int length = array.property("length").toInteger();
for (int i = 0; i < length; i++) {
ScriptVec3Float newVec3 = ScriptVec3Float();
glm::vec3 newVec3 = glm::vec3();
vec3FloatFromScriptValue(array.property(i), newVec3);
newVector << newVec3;
}
return newVector;
}
void qVectorVec3FromScriptValue(const QScriptValue& array, QVector<ScriptVec3Float>& vector) {
void qVectorVec3FloatFromScriptValue(const QScriptValue& array, QVector<glm::vec3>& vector) {
int length = array.property("length").toInteger();
for (int i = 0; i < length; i++) {
ScriptVec3Float newVec3 = ScriptVec3Float();
glm::vec3 newVec3 = glm::vec3();
vec3FloatFromScriptValue(array.property(i), newVec3);
vector << newVec3;
}
@ -947,9 +868,9 @@ void qURLFromScriptValue(const QScriptValue& object, QUrl& url) {
QScriptValue pickRayToScriptValue(QScriptEngine* engine, const PickRay& pickRay) {
QScriptValue obj = engine->newObject();
QScriptValue origin = vec3ToScriptValue(engine, pickRay.origin);
QScriptValue origin = vec3FloatToScriptValue(engine, pickRay.origin);
obj.setProperty("origin", origin);
QScriptValue direction = vec3ToScriptValue(engine, pickRay.direction);
QScriptValue direction = vec3FloatToScriptValue(engine, pickRay.direction);
obj.setProperty("direction", direction);
return obj;
}
@ -993,9 +914,9 @@ QScriptValue collisionToScriptValue(QScriptEngine* engine, const Collision& coll
obj.setProperty("type", collision.type);
obj.setProperty("idA", quuidToScriptValue(engine, collision.idA));
obj.setProperty("idB", quuidToScriptValue(engine, collision.idB));
obj.setProperty("penetration", vec3ToScriptValue(engine, collision.penetration));
obj.setProperty("contactPoint", vec3ToScriptValue(engine, collision.contactPoint));
obj.setProperty("velocityChange", vec3ToScriptValue(engine, collision.velocityChange));
obj.setProperty("penetration", vec3FloatToScriptValue(engine, collision.penetration));
obj.setProperty("contactPoint", vec3FloatToScriptValue(engine, collision.contactPoint));
obj.setProperty("velocityChange", vec3FloatToScriptValue(engine, collision.velocityChange));
return obj;
}

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

@ -25,13 +25,12 @@
#include "shared/Bilateral.h"
#include "Transform.h"
#include <QJsonDocument>
#include <QJsonObject>
#include "shared/JSONHelpers.h"
class QColor;
class QUrl;
Q_DECLARE_METATYPE(glm::vec2)
Q_DECLARE_METATYPE(glm::u8vec3)
Q_DECLARE_METATYPE(glm::vec3)
Q_DECLARE_METATYPE(glm::vec4)
Q_DECLARE_METATYPE(glm::quat)
Q_DECLARE_METATYPE(glm::mat4)
@ -53,41 +52,8 @@ void mat4FromScriptValue(const QScriptValue& object, glm::mat4& mat4);
* @property {number} x - X-coordinate of the vector. Synonyms: <code>u</code> and <code>width</code>.
* @property {number} y - Y-coordinate of the vector. Synonyms: <code>v</code> and <code>height</code>.
*/
class ScriptVec2Float {
public:
ScriptVec2Float() {}
ScriptVec2Float(float xy) : x(xy), y(xy) {}
ScriptVec2Float(float x, float y) : x(x), y(y) {}
ScriptVec2Float(const ScriptVec2Float& other) : x(other.x), y(other.y) {}
ScriptVec2Float(const glm::vec2& other) : x(other.x), y(other.y) {}
void operator=(const ScriptVec2Float& other) { x = other.x; y = other.y; }
inline bool operator==(const ScriptVec2Float& other) const { return (x == other.x && y == other.y); }
inline bool operator!=(const ScriptVec2Float& other) const { return !(*this == other); }
inline bool operator==(const glm::vec2& other) const { return (x == other.x && y == other.y); }
inline bool operator!=(const glm::vec2& other) const { return !(*this == other); }
glm::vec2 toGlm() const { return glm::vec2(x, y); }
float x { 0.0f };
float y { 0.0f };
private:
friend QDebug operator<<(QDebug debug, const ScriptVec2Float& vec2);
friend bool operator==(glm::vec2 glmVec2, const ScriptVec2Float& vec2);
friend bool operator!=(glm::vec2 glmVec2, const ScriptVec2Float& vec2);
};
inline QDebug operator<<(QDebug debug, const ScriptVec2Float& vec2) {
debug << "{" << vec2.x << "," << vec2.y << "}";
return debug;
}
inline bool operator==(glm::vec2 glmVec2, const ScriptVec2Float& vec2) { return (glmVec2.x == vec2.x && glmVec2.y == vec2.y); }
inline bool operator!=(glm::vec2 glmVec2, const ScriptVec2Float& vec2) { return !(glmVec2 == vec2); }
Q_DECLARE_METATYPE(ScriptVec2Float)
QScriptValue vec2FloatToScriptValue(QScriptEngine* engine, const ScriptVec2Float& vec2);
void vec2FloatFromScriptValue(const QScriptValue& object, ScriptVec2Float& vec2);
Q_DECLARE_METATYPE(glm::vec2)
QScriptValue vec2ToScriptValue(QScriptEngine* engine, const glm::vec2& vec2);
void vec2FromScriptValue(const QScriptValue& object, glm::vec2& vec2);
QScriptValue vec2FloatToScriptValue(QScriptEngine* engine, const glm::vec2& vec2);
void vec2FloatFromScriptValue(const QScriptValue& object, glm::vec2& vec2);
QVariant vec2ToVariant(const glm::vec2& vec2);
glm::vec2 vec2FromVariant(const QVariant& object, bool& valid);
@ -101,38 +67,8 @@ glm::vec2 vec2FromVariant(const QVariant& object);
* @property {number} y - Y-coordinate of the vector. Synonyms: <code>g</code>, <code>green</code>, and <code>height</code>.
* @property {number} z - Z-coordinate of the vector. Synonyms: <code>b</code>, <code>blue</code>, and <code>depth</code>.
*/
class ScriptVec3Float {
public:
ScriptVec3Float() {}
ScriptVec3Float(float xyz) : x(xyz), y(xyz), z(xyz) {}
ScriptVec3Float(float x, float y, float z) : x(x), y(y), z(z) {}
ScriptVec3Float(const ScriptVec3Float& other) : x(other.x), y(other.y), z(other.z) {}
ScriptVec3Float(const glm::vec3& other) : x(other.x), y(other.y), z(other.z) {}
void operator=(const ScriptVec3Float& other) { x = other.x; y = other.y; z = other.z; }
inline bool operator==(const ScriptVec3Float& other) const { return (x == other.x && y == other.y && z == other.z); }
inline bool operator!=(const ScriptVec3Float& other) const { return !(*this == other); }
inline bool operator==(const glm::vec3& other) const { return (x == other.x && y == other.y && z == other.z); }
inline bool operator!=(const glm::vec3& other) const { return !(*this == other); }
glm::vec3 toGlm() const { return glm::vec3(x, y, z); }
float x { 0.0f };
float y { 0.0f };
float z { 0.0f };
private:
friend QDebug operator<<(QDebug debug, const ScriptVec3Float& vec3);
friend bool operator==(glm::vec3 glmVec3, const ScriptVec3Float& vec3);
friend bool operator!=(glm::vec3 glmVec3, const ScriptVec3Float& vec3);
};
inline QDebug operator<<(QDebug debug, const ScriptVec3Float& vec3) {
debug << "{" << vec3.x << "," << vec3.y << "," << vec3.z << "}";
return debug;
}
inline bool operator==(glm::vec3 glmVec3, const ScriptVec3Float& vec3) { return (glmVec3.x == vec3.x && glmVec3.y == vec3.y && glmVec3.z == vec3.z); }
inline bool operator!=(glm::vec3 glmVec3, const ScriptVec3Float& vec3) { return !(glmVec3 == vec3); }
Q_DECLARE_METATYPE(ScriptVec3Float)
QScriptValue vec3FloatToScriptValue(QScriptEngine* engine, const ScriptVec3Float& vec3);
void vec3FloatFromScriptValue(const QScriptValue& object, ScriptVec3Float& vec3);
QScriptValue vec3FloatToScriptValue(QScriptEngine* engine, const glm::vec3& vec3);
void vec3FloatFromScriptValue(const QScriptValue& object, glm::vec3& vec3);
/**jsdoc
* A color vector. See also the {@link Vec3(0)|Vec3} object.
@ -142,42 +78,10 @@ void vec3FloatFromScriptValue(const QScriptValue& object, ScriptVec3Float& vec3)
* @property {number} y - Green component value. Integer in the range <code>0</code> - <code>255</code>. Synonyms: <code>g</code>, <code>green</code>, and <code>height</code>.
* @property {number} z - Blue component value. Integer in the range <code>0</code> - <code>255</code>. Synonyms: <code>b</code>, <code>blue</code>, and <code>depth</code>.
*/
class ScriptVec3UChar {
public:
ScriptVec3UChar() {}
ScriptVec3UChar(unsigned int xyz) : x(xyz), y(xyz), z(xyz) {}
ScriptVec3UChar(unsigned int x, unsigned int y, unsigned int z) : x(x), y(y), z(z) {}
ScriptVec3UChar(const ScriptVec3UChar& other) : x(other.x), y(other.y), z(other.z) {}
ScriptVec3UChar(const glm::vec3& other) : x(other.x), y(other.y), z(other.z) {}
void operator=(const ScriptVec3UChar& other) { x = other.x; y = other.y; z = other.z; }
inline bool operator==(const ScriptVec3UChar& other) const { return (x == other.x && y == other.y && z == other.z); }
inline bool operator!=(const ScriptVec3UChar& other) const { return !(*this == other); }
QScriptValue vec3UCharToScriptValue(QScriptEngine* engine, const glm::u8vec3& vec3);
void vec3UCharFromScriptValue(const QScriptValue& object, glm::u8vec3& vec3);
glm::vec3 toGlm() const { return glm::vec3(x, y, z); }
unsigned char x { 0 };
unsigned char y { 0 };
unsigned char z { 0 };
private:
friend QDebug operator<<(QDebug debug, const ScriptVec3UChar& vec3);
friend bool operator==(glm::vec3 glmVec3, const ScriptVec3UChar& vec3);
friend bool operator!=(glm::vec3 glmVec3, const ScriptVec3UChar& vec3);
};
inline QDebug operator<<(QDebug debug, const ScriptVec3UChar& vec3) {
debug << "{" << vec3.x << "," << vec3.y << "," << vec3.z << "}";
return debug;
}
inline bool operator==(glm::vec3 glmVec3, const ScriptVec3UChar& vec3) { return (glmVec3.x == vec3.x && glmVec3.y == vec3.y && glmVec3.z == vec3.z); }
inline bool operator!=(glm::vec3 glmVec3, const ScriptVec3UChar& vec3) { return !(glmVec3 == vec3); }
Q_DECLARE_METATYPE(ScriptVec3UChar)
QScriptValue vec3UCharToScriptValue(QScriptEngine* engine, const ScriptVec3UChar& vec3);
void vec3UCharFromScriptValue(const QScriptValue& object, ScriptVec3UChar& vec3);
Q_DECLARE_METATYPE(glm::vec3)
QScriptValue vec3ToScriptValue(QScriptEngine* engine, const glm::vec3 &vec3);
void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3);
QVariant vec3ToVariant(const glm::vec3& vec3);
QVariant vec3toVariant(const glm::vec3& vec3);
glm::vec3 vec3FromVariant(const QVariant &object, bool& valid);
glm::vec3 vec3FromVariant(const QVariant &object);
@ -219,12 +123,13 @@ QScriptValue qURLToScriptValue(QScriptEngine* engine, const QUrl& url);
void qURLFromScriptValue(const QScriptValue& object, QUrl& url);
// vector<vec3>
Q_DECLARE_METATYPE(QVector<ScriptVec3Float>)
QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<ScriptVec3Float>& vector);
void qVectorVec3FromScriptValue(const QScriptValue& array, QVector<ScriptVec3Float>& vector);
QVector<ScriptVec3Float> qVectorVec3FromScriptValue(const QScriptValue& array);
Q_DECLARE_METATYPE(QVector<glm::vec3>)
QScriptValue qVectorVec3FloatToScriptValue(QScriptEngine* engine, const QVector<glm::vec3>& vector);
void qVectorVec3FloatFromScriptValue(const QScriptValue& array, QVector<glm::vec3>& vector);
QVector<glm::vec3> qVectorVec3FloatFromScriptValue(const QScriptValue& array);
// vector<quat>
Q_DECLARE_METATYPE(QVector<glm::quat>)
QScriptValue qVectorQuatToScriptValue(QScriptEngine* engine, const QVector<glm::quat>& vector);
void qVectorQuatFromScriptValue(const QScriptValue& array, QVector<glm::quat>& vector);
QVector<glm::quat> qVectorQuatFromScriptValue(const QScriptValue& array);
@ -280,8 +185,8 @@ public:
}
QVariantMap toVariantMap() const override {
QVariantMap pickRay;
pickRay["origin"] = vec3ToVariant(origin);
pickRay["direction"] = vec3ToVariant(direction);
pickRay["origin"] = vec3toVariant(origin);
pickRay["direction"] = vec3toVariant(direction);
return pickRay;
}
};
@ -318,9 +223,9 @@ public:
QVariantMap toVariantMap() const override {
QVariantMap stylusTip;
stylusTip["side"] = (int)side;
stylusTip["position"] = vec3ToVariant(position);
stylusTip["position"] = vec3toVariant(position);
stylusTip["orientation"] = quatToVariant(orientation);
stylusTip["velocity"] = vec3ToVariant(velocity);
stylusTip["velocity"] = vec3toVariant(velocity);
return stylusTip;
}
};
@ -350,9 +255,9 @@ public:
}
QVariantMap toVariantMap() const override {
QVariantMap pickParabola;
pickParabola["origin"] = vec3ToVariant(origin);
pickParabola["velocity"] = vec3ToVariant(velocity);
pickParabola["acceleration"] = vec3ToVariant(acceleration);
pickParabola["origin"] = vec3toVariant(origin);
pickParabola["velocity"] = vec3toVariant(velocity);
pickParabola["acceleration"] = vec3toVariant(acceleration);
return pickParabola;
}
};
@ -405,11 +310,11 @@ public:
QVariantMap shape;
shape["shapeType"] = ShapeInfo::getNameForShapeType(shapeInfo->getType());
shape["modelURL"] = modelURL.toString();
shape["dimensions"] = vec3ToVariant(transform.getScale());
shape["dimensions"] = vec3toVariant(transform.getScale());
collisionRegion["shape"] = shape;
collisionRegion["position"] = vec3ToVariant(transform.getTranslation());
collisionRegion["position"] = vec3toVariant(transform.getTranslation());
collisionRegion["orientation"] = quatToVariant(transform.getRotation());
return collisionRegion;

4
libraries/shared/src/SharedUtil.cpp
View file

@ -24,8 +24,6 @@
#include <glm/glm.hpp>
#include "RegisteredMetaTypes.h"
#ifdef Q_OS_WIN
#include <windows.h>
#include "CPUIdent.h"
@ -421,7 +419,7 @@ unsigned char* pointToVoxel(float x, float y, float z, float s, unsigned char r,
}
auto voxelSizeInBytes = bytesRequiredForCodeLength(voxelSizeInOctets); // (voxelSizeInBits/8)+1;
auto voxelBufferSize = voxelSizeInBytes + sizeof(ScriptVec3UChar); // 3 for color
auto voxelBufferSize = voxelSizeInBytes + sizeof(glm::u8vec3); // 3 for color
// allocate our resulting buffer
unsigned char* voxelOut = new unsigned char[voxelBufferSize];

5
libraries/shared/src/SpatiallyNestable.h
View file

@ -19,8 +19,6 @@
#include "SpatialParentFinder.h"
#include "shared/ReadWriteLockable.h"
#include "RegisteredMetaTypes.h"
class SpatiallyNestable;
using SpatiallyNestableWeakPointer = std::weak_ptr<SpatiallyNestable>;
using SpatiallyNestableWeakConstPointer = std::weak_ptr<const SpatiallyNestable>;
@ -137,18 +135,15 @@ public:
virtual void setLocalTransform(const Transform& transform);
virtual glm::vec3 getLocalPosition() const;
virtual ScriptVec3Float getScriptLocalPosition() const { return getLocalPosition(); }
virtual void setLocalPosition(const glm::vec3& position, bool tellPhysics = true);
virtual glm::quat getLocalOrientation() const;
virtual void setLocalOrientation(const glm::quat& orientation);
virtual glm::vec3 getLocalVelocity() const;
virtual ScriptVec3Float getScriptLocalVelocity() const { return getLocalVelocity(); }
virtual void setLocalVelocity(const glm::vec3& velocity);
virtual glm::vec3 getLocalAngularVelocity() const;
virtual ScriptVec3Float getScriptLocalAngularVelocity() const { return getLocalAngularVelocity(); }
virtual void setLocalAngularVelocity(const glm::vec3& angularVelocity);
virtual glm::vec3 getLocalSNScale() const;

Some files were not shown because too many files have changed in this diff Show more