("EndSecondaryCamera", cachedArg);
-}
+}
\ No newline at end of file
diff --git a/interface/src/avatar/AvatarManager.h b/interface/src/avatar/AvatarManager.h
index 7f5aa00466..6a3d0355f6 100644
--- a/interface/src/avatar/AvatarManager.h
+++ b/interface/src/avatar/AvatarManager.h
@@ -29,10 +29,25 @@
/**jsdoc
* The AvatarManager API has properties and methods which manage Avatars within the same domain.
+ *
+ * Note: This API is also provided to Interface and client entity scripts as the synonym,
+ * AvatarList. For assignment client scripts, see the separate {@link AvatarList} API.
+ *
* @namespace AvatarManager
*
* @hifi-interface
* @hifi-client-entity
+ *
+ * @borrows AvatarList.getAvatarIdentifiers as getAvatarIdentifiers
+ * @borrows AvatarList.getAvatarsInRange as getAvatarsInRange
+ * @borrows AvatarList.avatarAddedEvent as avatarAddedEvent
+ * @borrows AvatarList.avatarRemovedEvent as avatarRemovedEvent
+ * @borrows AvatarList.avatarSessionChangedEvent as avatarSessionChangedEvent
+ * @borrows AvatarList.isAvatarInRange as isAvatarInRange
+ * @borrows AvatarList.sessionUUIDChanged as sessionUUIDChanged
+ * @borrows AvatarList.processAvatarDataPacket as processAvatarDataPacket
+ * @borrows AvatarList.processAvatarIdentityPacket as processAvatarIdentityPacket
+ * @borrows AvatarList.processKillAvatar as processKillAvatar
*/
class AvatarManager : public AvatarHashMap {
diff --git a/interface/src/avatar/AvatarMotionState.cpp b/interface/src/avatar/AvatarMotionState.cpp
index 900c1c0a11..beb7e34439 100644
--- a/interface/src/avatar/AvatarMotionState.cpp
+++ b/interface/src/avatar/AvatarMotionState.cpp
@@ -21,6 +21,17 @@ AvatarMotionState::AvatarMotionState(AvatarSharedPointer avatar, const btCollisi
_type = MOTIONSTATE_TYPE_AVATAR;
}
+void AvatarMotionState::handleEasyChanges(uint32_t& flags) {
+ ObjectMotionState::handleEasyChanges(flags);
+ if (flags & Simulation::DIRTY_PHYSICS_ACTIVATION && !_body->isActive()) {
+ _body->activate();
+ }
+}
+
+bool AvatarMotionState::handleHardAndEasyChanges(uint32_t& flags, PhysicsEngine* engine) {
+ return ObjectMotionState::handleHardAndEasyChanges(flags, engine);
+}
+
AvatarMotionState::~AvatarMotionState() {
assert(_avatar);
_avatar = nullptr;
@@ -46,6 +57,9 @@ PhysicsMotionType AvatarMotionState::computePhysicsMotionType() const {
const btCollisionShape* AvatarMotionState::computeNewShape() {
ShapeInfo shapeInfo;
std::static_pointer_cast(_avatar)->computeShapeInfo(shapeInfo);
+ glm::vec3 halfExtents = shapeInfo.getHalfExtents();
+ halfExtents.y = 0.0f;
+ _diameter = 2.0f * glm::length(halfExtents);
return getShapeManager()->getShape(shapeInfo);
}
@@ -60,25 +74,31 @@ void AvatarMotionState::getWorldTransform(btTransform& worldTrans) const {
worldTrans.setRotation(glmToBullet(getObjectRotation()));
if (_body) {
_body->setLinearVelocity(glmToBullet(getObjectLinearVelocity()));
- _body->setAngularVelocity(glmToBullet(getObjectLinearVelocity()));
+ _body->setAngularVelocity(glmToBullet(getObjectAngularVelocity()));
}
}
// virtual
void AvatarMotionState::setWorldTransform(const btTransform& worldTrans) {
- // HACK: The PhysicsEngine does not actually move OTHER avatars -- instead it slaves their local RigidBody to the transform
- // as specified by a remote simulation. However, to give the remote simulation time to respond to our own objects we tie
- // the other avatar's body to its true position with a simple spring. This is a HACK that will have to be improved later.
const float SPRING_TIMESCALE = 0.5f;
float tau = PHYSICS_ENGINE_FIXED_SUBSTEP / SPRING_TIMESCALE;
btVector3 currentPosition = worldTrans.getOrigin();
- btVector3 targetPosition = glmToBullet(getObjectPosition());
- btTransform newTransform;
- newTransform.setOrigin((1.0f - tau) * currentPosition + tau * targetPosition);
- newTransform.setRotation(glmToBullet(getObjectRotation()));
- _body->setWorldTransform(newTransform);
- _body->setLinearVelocity(glmToBullet(getObjectLinearVelocity()));
- _body->setAngularVelocity(glmToBullet(getObjectLinearVelocity()));
+ btVector3 offsetToTarget = glmToBullet(getObjectPosition()) - currentPosition;
+ float distance = offsetToTarget.length();
+ if ((1.0f - tau) * distance > _diameter) {
+ // the avatar body is far from its target --> slam position
+ btTransform newTransform;
+ newTransform.setOrigin(currentPosition + offsetToTarget);
+ newTransform.setRotation(glmToBullet(getObjectRotation()));
+ _body->setWorldTransform(newTransform);
+ _body->setLinearVelocity(glmToBullet(getObjectLinearVelocity()));
+ _body->setAngularVelocity(glmToBullet(getObjectAngularVelocity()));
+ } else {
+ // the avatar body is near its target --> slam velocity
+ btVector3 velocity = glmToBullet(getObjectLinearVelocity()) + (1.0f / SPRING_TIMESCALE) * offsetToTarget;
+ _body->setLinearVelocity(velocity);
+ _body->setAngularVelocity(glmToBullet(getObjectAngularVelocity()));
+ }
}
// These pure virtual methods must be implemented for each MotionState type
@@ -145,3 +165,8 @@ void AvatarMotionState::computeCollisionGroupAndMask(int16_t& group, int16_t& ma
mask = Physics::getDefaultCollisionMask(group);
}
+// virtual
+float AvatarMotionState::getMass() const {
+ return std::static_pointer_cast(_avatar)->computeMass();
+}
+
diff --git a/interface/src/avatar/AvatarMotionState.h b/interface/src/avatar/AvatarMotionState.h
index 90bd2a60ac..73fb853312 100644
--- a/interface/src/avatar/AvatarMotionState.h
+++ b/interface/src/avatar/AvatarMotionState.h
@@ -23,6 +23,9 @@ class AvatarMotionState : public ObjectMotionState {
public:
AvatarMotionState(AvatarSharedPointer avatar, const btCollisionShape* shape);
+ virtual void handleEasyChanges(uint32_t& flags) override;
+ virtual bool handleHardAndEasyChanges(uint32_t& flags, PhysicsEngine* engine) override;
+
virtual PhysicsMotionType getMotionType() const override { return _motionType; }
virtual uint32_t getIncomingDirtyFlags() override;
@@ -64,6 +67,8 @@ public:
virtual void computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const override;
+ virtual float getMass() const override;
+
friend class AvatarManager;
friend class Avatar;
@@ -76,6 +81,7 @@ protected:
virtual const btCollisionShape* computeNewShape() override;
AvatarSharedPointer _avatar;
+ float _diameter { 0.0f };
uint32_t _dirtyFlags;
};
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index 154e2e4d09..fa6a675d99 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -137,9 +137,9 @@ class MyAvatar : public Avatar {
* @property {number} scale
* @property {number} density Read-only.
* @property {Vec3} handPosition
- * @property {number} bodyYaw - The rotation left or right about an axis running from the head to the feet of MyAvatar. Yaw
- * is sometimes called "heading".
- * @property {number} bodyPitch - The rotation about an axis running from shoulder to shoulder of MyAvatar. Pitch is
+ * @property {number} bodyYaw - The rotation left or right about an axis running from the head to the feet of the avatar.
+ * Yaw is sometimes called "heading".
+ * @property {number} bodyPitch - The rotation about an axis running from shoulder to shoulder of the avatar. Pitch is
* sometimes called "elevation".
* @property {number} bodyRoll - The rotation about an axis running from the chest to the back of the avatar. Roll is
* sometimes called "bank".
diff --git a/interface/src/avatar/MySkeletonModel.cpp b/interface/src/avatar/MySkeletonModel.cpp
index fd57657d33..f317f6b2c1 100644
--- a/interface/src/avatar/MySkeletonModel.cpp
+++ b/interface/src/avatar/MySkeletonModel.cpp
@@ -60,7 +60,7 @@ static AnimPose computeHipsInSensorFrame(MyAvatar* myAvatar, bool isFlying) {
// rotate the hips back to match the flying animation.
const float TILT_ANGLE = 0.523f;
- const glm::quat tiltRot = glm::angleAxis(TILT_ANGLE, transformVectorFast(avatarToSensorMat, -Vectors::UNIT_X));
+ const glm::quat tiltRot = glm::angleAxis(TILT_ANGLE, glm::normalize(transformVectorFast(avatarToSensorMat, -Vectors::UNIT_X)));
glm::vec3 headPos;
int headIndex = myAvatar->getJointIndex("Head");
diff --git a/interface/src/raypick/LaserPointerScriptingInterface.h b/interface/src/raypick/LaserPointerScriptingInterface.h
index c2e6c8f113..5aaacd7960 100644
--- a/interface/src/raypick/LaserPointerScriptingInterface.h
+++ b/interface/src/raypick/LaserPointerScriptingInterface.h
@@ -20,24 +20,122 @@ class LaserPointerScriptingInterface : public QObject, public Dependency {
Q_OBJECT
SINGLETON_DEPENDENCY
+/**jsdoc
+ * Synonym for {@link Pointers} as used for laser pointers.
+ *
+ * @namespace LaserPointers
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ */
public:
+
+ /**jsdoc
+ * @function LaserPointers.createLaserPointer
+ * @param {Pointers.LaserPointerProperties} properties
+ * @returns {number}
+ */
Q_INVOKABLE unsigned int createLaserPointer(const QVariant& properties) const;
+
+ /**jsdoc
+ * @function LaserPointers.enableLaserPointer
+ * @param {number} id
+ */
Q_INVOKABLE void enableLaserPointer(unsigned int uid) const { DependencyManager::get()->enablePointer(uid); }
+
+ /**jsdoc
+ * @function LaserPointers.disableLaserPointer
+ * @param {number} id
+ */
Q_INVOKABLE void disableLaserPointer(unsigned int uid) const { DependencyManager::get()->disablePointer(uid); }
+
+ /**jsdoc
+ * @function LaserPointers.removeLaserPointer
+ * @param {number} id
+ */
Q_INVOKABLE void removeLaserPointer(unsigned int uid) const { DependencyManager::get()->removePointer(uid); }
+
+ /**jsdoc
+ * @function LaserPointers.editRenderState
+ * @param {number} id
+ * @param {string} renderState
+ * @param {Pointers.RayPointerRenderState} properties
+ */
Q_INVOKABLE void editRenderState(unsigned int uid, const QString& renderState, const QVariant& properties) const;
+
+ /**jsdoc
+ * @function LaserPointers.setRenderState
+ * @param {string} renderState
+ * @param {number} id
+ */
Q_INVOKABLE void setRenderState(unsigned int uid, const QString& renderState) const { DependencyManager::get()->setRenderState(uid, renderState.toStdString()); }
+
+ /**jsdoc
+ * @function LaserPointers.getPrevRayPickResult
+ * @param {number} id
+ * @returns {RayPickResult}
+ */
Q_INVOKABLE QVariantMap getPrevRayPickResult(unsigned int uid) const;
+
+ /**jsdoc
+ * @function LaserPointers.setPrecisionPicking
+ * @param {number} id
+ * @param {boolean} precisionPicking
+ */
Q_INVOKABLE void setPrecisionPicking(unsigned int uid, bool precisionPicking) const { DependencyManager::get()->setPrecisionPicking(uid, precisionPicking); }
+
+ /**jsdoc
+ * @function LaserPointers.setLaserLength
+ * @param {number} id
+ * @param {number} laserLength
+ */
Q_INVOKABLE void setLaserLength(unsigned int uid, float laserLength) const { DependencyManager::get()->setLength(uid, laserLength); }
+
+ /**jsdoc
+ * @function LaserPointers.setIgnoreItems
+ * @param {number} id
+ * @param {Uuid[]} ignoreItems
+ */
Q_INVOKABLE void setIgnoreItems(unsigned int uid, const QScriptValue& ignoreEntities) const;
+
+ /**jsdoc
+ * @function LaserPointers.setIncludeItems
+ * @param {number} id
+ * @param {Uuid[]} includeItems
+ */
Q_INVOKABLE void setIncludeItems(unsigned int uid, const QScriptValue& includeEntities) const;
+
+ /**jsdoc
+ * @function LaserPointers.setLockEndUUID
+ * @param {number} id
+ * @param {Uuid} itemID
+ * @param {boolean} isOverlay
+ * @param {Mat4} [offsetMat]
+ */
Q_INVOKABLE void setLockEndUUID(unsigned int uid, const QUuid& objectID, bool isOverlay, const glm::mat4& offsetMat = glm::mat4()) const { DependencyManager::get()->setLockEndUUID(uid, objectID, isOverlay, offsetMat); }
+
+ /**jsdoc
+ * @function LaserPointers.isLeftHand
+ * @param {number} id
+ * @returns {boolean}
+ */
Q_INVOKABLE bool isLeftHand(unsigned int uid) { return DependencyManager::get()->isLeftHand(uid); }
+
+ /**jsdoc
+ * @function LaserPointers.isRightHand
+ * @param {number} id
+ * @returns {boolean}
+ */
Q_INVOKABLE bool isRightHand(unsigned int uid) { return DependencyManager::get()->isRightHand(uid); }
+
+ /**jsdoc
+ * @function LaserPointers.isMouse
+ * @param {number} id
+ * @returns {boolean}
+ */
Q_INVOKABLE bool isMouse(unsigned int uid) { return DependencyManager::get()->isMouse(uid); }
};
diff --git a/interface/src/raypick/PickScriptingInterface.cpp b/interface/src/raypick/PickScriptingInterface.cpp
index 1bf6dd2f8e..8da6e7c615 100644
--- a/interface/src/raypick/PickScriptingInterface.cpp
+++ b/interface/src/raypick/PickScriptingInterface.cpp
@@ -31,6 +31,20 @@ unsigned int PickScriptingInterface::createPick(const PickQuery::PickType type,
}
}
+/**jsdoc
+ * A set of properties that can be passed to {@link Picks.createPick} to create a new Ray Pick.
+ * @typedef {object} Picks.RayPickProperties
+ * @property {boolean} [enabled=false] If this Pick should start enabled or not. Disabled Picks do not updated their pick results.
+ * @property {number} [filter=Picks.PICK_NOTHING] The filter for this Pick to use, constructed using filter flags combined using bitwise OR.
+ * @property {float} [maxDistance=0.0] The max distance at which this Pick will intersect. 0.0 = no max. < 0.0 is invalid.
+ * @property {string} [joint] Only for Joint or Mouse Ray Picks. If "Mouse", it will create a Ray Pick that follows the system mouse, in desktop or HMD.
+ * If "Avatar", it will create a Joint Ray Pick that follows your avatar's head. Otherwise, it will create a Joint Ray Pick that follows the given joint, if it
+ * exists on your current avatar.
+ * @property {Vec3} [posOffset=Vec3.ZERO] Only for Joint Ray Picks. A local joint position offset, in meters. x = upward, y = forward, z = lateral
+ * @property {Vec3} [dirOffset=Vec3.UP] Only for Joint Ray Picks. A local joint direction offset. x = upward, y = forward, z = lateral
+ * @property {Vec3} [position] Only for Static Ray Picks. The world-space origin of the ray.
+ * @property {Vec3} [direction=-Vec3.UP] Only for Static Ray Picks. The world-space direction of the ray.
+ */
unsigned int PickScriptingInterface::createRayPick(const QVariant& properties) {
QVariantMap propMap = properties.toMap();
@@ -83,6 +97,14 @@ unsigned int PickScriptingInterface::createRayPick(const QVariant& properties) {
return PickManager::INVALID_PICK_ID;
}
+/**jsdoc
+ * A set of properties that can be passed to {@link Picks.createPick} to create a new Stylus Pick.
+ * @typedef {object} Picks.StylusPickProperties
+ * @property {number} [hand=-1] An integer. 0 == left, 1 == right. Invalid otherwise.
+ * @property {boolean} [enabled=false] If this Pick should start enabled or not. Disabled Picks do not updated their pick results.
+ * @property {number} [filter=Picks.PICK_NOTHING] The filter for this Pick to use, constructed using filter flags combined using bitwise OR.
+ * @property {float} [maxDistance=0.0] The max distance at which this Pick will intersect. 0.0 = no max. < 0.0 is invalid.
+ */
unsigned int PickScriptingInterface::createStylusPick(const QVariant& properties) {
QVariantMap propMap = properties.toMap();
diff --git a/interface/src/raypick/PickScriptingInterface.h b/interface/src/raypick/PickScriptingInterface.h
index 2568dd8457..a39aa3a4a1 100644
--- a/interface/src/raypick/PickScriptingInterface.h
+++ b/interface/src/raypick/PickScriptingInterface.h
@@ -22,19 +22,22 @@
* @hifi-interface
* @hifi-client-entity
*
- * @property PICK_NOTHING {number} A filter flag. Don't intersect with anything.
- * @property PICK_ENTITIES {number} A filter flag. Include entities when intersecting.
- * @property PICK_OVERLAYS {number} A filter flag. Include overlays when intersecting.
- * @property PICK_AVATARS {number} A filter flag. Include avatars when intersecting.
- * @property PICK_HUD {number} A filter flag. Include the HUD sphere when intersecting in HMD mode.
- * @property PICK_COARSE {number} A filter flag. Pick against coarse meshes, instead of exact meshes.
- * @property PICK_INCLUDE_INVISIBLE {number} A filter flag. Include invisible objects when intersecting.
- * @property PICK_INCLUDE_NONCOLLIDABLE {number} A filter flag. Include non-collidable objects when intersecting.
- * @property INTERSECTED_NONE {number} An intersection type. Intersected nothing with the given filter flags.
- * @property INTERSECTED_ENTITY {number} An intersection type. Intersected an entity.
- * @property INTERSECTED_OVERLAY {number} An intersection type. Intersected an overlay.
- * @property INTERSECTED_AVATAR {number} An intersection type. Intersected an avatar.
- * @property INTERSECTED_HUD {number} An intersection type. Intersected the HUD sphere.
+ * @property PICK_NOTHING {number} A filter flag. Don't intersect with anything. Read-only.
+ * @property PICK_ENTITIES {number} A filter flag. Include entities when intersecting. Read-only.
+ * @property PICK_OVERLAYS {number} A filter flag. Include overlays when intersecting. Read-only.
+ * @property PICK_AVATARS {number} A filter flag. Include avatars when intersecting. Read-only.
+ * @property PICK_HUD {number} A filter flag. Include the HUD sphere when intersecting in HMD mode. Read-only.
+ * @property PICK_COARSE {number} A filter flag. Pick against coarse meshes, instead of exact meshes. Read-only.
+ * @property PICK_INCLUDE_INVISIBLE {number} A filter flag. Include invisible objects when intersecting. Read-only.
+ * @property PICK_INCLUDE_NONCOLLIDABLE {number} A filter flag. Include non-collidable objects when intersecting.
+ * Read-only.
+ * @property PICK_ALL_INTERSECTIONS {number} Read-only.
+ * @property INTERSECTED_NONE {number} An intersection type. Intersected nothing with the given filter flags. Read-only.
+ * @property INTERSECTED_ENTITY {number} An intersection type. Intersected an entity. Read-only.
+ * @property INTERSECTED_OVERLAY {number} An intersection type. Intersected an overlay. Read-only.
+ * @property INTERSECTED_AVATAR {number} An intersection type. Intersected an avatar. Read-only.
+ * @property INTERSECTED_HUD {number} An intersection type. Intersected the HUD sphere. Read-only.
+ * @property {number} perFrameTimeBudget - The max number of usec to spend per frame updating Pick results. Read-only.
*/
class PickScriptingInterface : public QObject, public Dependency {
@@ -61,46 +64,31 @@ public:
void registerMetaTypes(QScriptEngine* engine);
- /**jsdoc
- * A set of properties that can be passed to {@link Picks.createPick} to create a new Pick.
- *
- * Different {@link Picks.PickType}s use different properties, and within one PickType, the properties you choose can lead to a wide range of behaviors. For example,
- * with PickType.Ray, depending on which optional parameters you pass, you could create a Static Ray Pick, a Mouse Ray Pick, or a Joint Ray Pick.
- *
- * @typedef {Object} Picks.PickProperties
- * @property {boolean} [enabled=false] If this Pick should start enabled or not. Disabled Picks do not updated their pick results.
- * @property {number} [filter=Picks.PICK_NOTHING] The filter for this Pick to use, constructed using filter flags combined using bitwise OR.
- * @property {float} [maxDistance=0.0] The max distance at which this Pick will intersect. 0.0 = no max. < 0.0 is invalid.
- * @property {string} [joint] Only for Joint or Mouse Ray Picks. If "Mouse", it will create a Ray Pick that follows the system mouse, in desktop or HMD.
- * If "Avatar", it will create a Joint Ray Pick that follows your avatar's head. Otherwise, it will create a Joint Ray Pick that follows the given joint, if it
- * exists on your current avatar.
- * @property {Vec3} [posOffset=Vec3.ZERO] Only for Joint Ray Picks. A local joint position offset, in meters. x = upward, y = forward, z = lateral
- * @property {Vec3} [dirOffset=Vec3.UP] Only for Joint Ray Picks. A local joint direction offset. x = upward, y = forward, z = lateral
- * @property {Vec3} [position] Only for Static Ray Picks. The world-space origin of the ray.
- * @property {Vec3} [direction=-Vec3.UP] Only for Static Ray Picks. The world-space direction of the ray.
- * @property {number} [hand=-1] Only for Stylus Picks. An integer. 0 == left, 1 == right. Invalid otherwise.
- */
-
/**jsdoc
* Adds a new Pick.
+ * Different {@link PickType}s use different properties, and within one PickType, the properties you choose can lead to a wide range of behaviors. For example,
+ * with PickType.Ray, depending on which optional parameters you pass, you could create a Static Ray Pick, a Mouse Ray Pick, or a Joint Ray Pick.
* @function Picks.createPick
- * @param {Picks.PickType} type A PickType that specifies the method of picking to use
- * @param {Picks.PickProperties} properties A PickProperties object, containing all the properties for initializing this Pick
+ * @param {PickType} type A PickType that specifies the method of picking to use
+ * @param {Picks.RayPickProperties|Picks.StylusPickProperties} properties A PickProperties object, containing all the properties for initializing this Pick
* @returns {number} The ID of the created Pick. Used for managing the Pick. 0 if invalid.
*/
Q_INVOKABLE unsigned int createPick(const PickQuery::PickType type, const QVariant& properties);
+
/**jsdoc
* Enables a Pick.
* @function Picks.enablePick
* @param {number} uid The ID of the Pick, as returned by {@link Picks.createPick}.
*/
Q_INVOKABLE void enablePick(unsigned int uid);
+
/**jsdoc
* Disables a Pick.
* @function Picks.disablePick
* @param {number} uid The ID of the Pick, as returned by {@link Picks.createPick}.
*/
Q_INVOKABLE void disablePick(unsigned int uid);
+
/**jsdoc
* Removes a Pick.
* @function Picks.removePick
@@ -111,7 +99,7 @@ public:
/**jsdoc
* An intersection result for a Ray Pick.
*
- * @typedef {Object} Picks.RayPickResult
+ * @typedef {Object} RayPickResult
* @property {number} type The intersection type.
* @property {boolean} intersects If there was a valid intersection (type != INTERSECTED_NONE)
* @property {Uuid} objectID The ID of the intersected object. Uuid.NULL for the HUD or invalid intersections.
@@ -125,7 +113,7 @@ public:
/**jsdoc
* An intersection result for a Stylus Pick.
*
- * @typedef {Object} Picks.StylusPickResult
+ * @typedef {Object} StylusPickResult
* @property {number} type The intersection type.
* @property {boolean} intersects If there was a valid intersection (type != INTERSECTED_NONE)
* @property {Uuid} objectID The ID of the intersected object. Uuid.NULL for the HUD or invalid intersections.
@@ -140,7 +128,7 @@ public:
* Get the most recent pick result from this Pick. This will be updated as long as the Pick is enabled.
* @function Picks.getPrevPickResult
* @param {number} uid The ID of the Pick, as returned by {@link Picks.createPick}.
- * @returns {PickResult} The most recent intersection result. This will be slightly different for different PickTypes. See {@link Picks.RayPickResult} and {@link Picks.StylusPickResult}.
+ * @returns {RayPickResult|StylusPickResult} The most recent intersection result. This will be different for different PickTypes.
*/
Q_INVOKABLE QVariantMap getPrevPickResult(unsigned int uid);
@@ -151,6 +139,7 @@ public:
* @param {boolean} precisionPicking Whether or not to use precision picking
*/
Q_INVOKABLE void setPrecisionPicking(unsigned int uid, bool precisionPicking);
+
/**jsdoc
* Sets a list of Entity IDs, Overlay IDs, and/or Avatar IDs to ignore during intersection. Not used by Stylus Picks.
* @function Picks.setIgnoreItems
@@ -158,6 +147,7 @@ public:
* @param {Uuid[]} ignoreItems A list of IDs to ignore.
*/
Q_INVOKABLE void setIgnoreItems(unsigned int uid, const QScriptValue& ignoreItems);
+
/**jsdoc
* Sets a list of Entity IDs, Overlay IDs, and/or Avatar IDs to include during intersection, instead of intersecting with everything. Stylus
* Picks only intersect with objects in their include list.
@@ -174,6 +164,7 @@ public:
* @returns {boolean} True if the Pick is a Joint Ray Pick with joint == "_CONTROLLER_LEFTHAND" or "_CAMERA_RELATIVE_CONTROLLER_LEFTHAND", or a Stylus Pick with hand == 0.
*/
Q_INVOKABLE bool isLeftHand(unsigned int uid);
+
/**jsdoc
* Check if a Pick is associated with the right hand.
* @function Picks.isRightHand
@@ -181,6 +172,7 @@ public:
* @returns {boolean} True if the Pick is a Joint Ray Pick with joint == "_CONTROLLER_RIGHTHAND" or "_CAMERA_RELATIVE_CONTROLLER_RIGHTHAND", or a Stylus Pick with hand == 1.
*/
Q_INVOKABLE bool isRightHand(unsigned int uid);
+
/**jsdoc
* Check if a Pick is associated with the system mouse.
* @function Picks.isMouse
@@ -189,28 +181,96 @@ public:
*/
Q_INVOKABLE bool isMouse(unsigned int uid);
+ // FIXME: Move to other property definitions.
Q_PROPERTY(unsigned int perFrameTimeBudget READ getPerFrameTimeBudget WRITE setPerFrameTimeBudget)
- /**jsdoc
- * The max number of usec to spend per frame updating Pick results.
- * @typedef {number} Picks.perFrameTimeBudget
- */
+
unsigned int getPerFrameTimeBudget() const;
void setPerFrameTimeBudget(unsigned int numUsecs);
public slots:
+
+ /**jsdoc
+ * @function Picks.PICK_NOTHING
+ * @returns {number}
+ */
static constexpr unsigned int PICK_NOTHING() { return 0; }
+
+ /**jsdoc
+ * @function Picks.PICK_ENTITIES
+ * @returns {number}
+ */
static constexpr unsigned int PICK_ENTITIES() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_ENTITIES); }
+
+ /**jsdoc
+ * @function Picks.PICK_OVERLAYS
+ * @returns {number}
+ */
static constexpr unsigned int PICK_OVERLAYS() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_OVERLAYS); }
+
+ /**jsdoc
+ * @function Picks.PICK_AVATARS
+ * @returns {number}
+ */
static constexpr unsigned int PICK_AVATARS() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_AVATARS); }
+
+ /**jsdoc
+ * @function Picks.PICK_HUD
+ * @returns {number}
+ */
static constexpr unsigned int PICK_HUD() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_HUD); }
+
+ /**jsdoc
+ * @function Picks.PICK_COARSE
+ * @returns {number}
+ */
static constexpr unsigned int PICK_COARSE() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_COARSE); }
+
+ /**jsdoc
+ * @function Picks.PICK_INCLUDE_INVISIBLE
+ * @returns {number}
+ */
static constexpr unsigned int PICK_INCLUDE_INVISIBLE() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_INCLUDE_INVISIBLE); }
+
+ /**jsdoc
+ * @function Picks.PICK_INCLUDE_NONCOLLIDABLE
+ * @returns {number}
+ */
static constexpr unsigned int PICK_INCLUDE_NONCOLLIDABLE() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_INCLUDE_NONCOLLIDABLE); }
+
+ /**jsdoc
+ * @function Picks.PICK_ALL_INTERSECTIONS
+ * @returns {number}
+ */
static constexpr unsigned int PICK_ALL_INTERSECTIONS() { return PickFilter::getBitMask(PickFilter::FlagBit::PICK_ALL_INTERSECTIONS); }
+
+ /**jsdoc
+ * @function Picks.INTERSECTED_NONE
+ * @returns {number}
+ */
static constexpr unsigned int INTERSECTED_NONE() { return IntersectionType::NONE; }
+
+ /**jsdoc
+ * @function Picks.INTERSECTED_ENTITY
+ * @returns {number}
+ */
static constexpr unsigned int INTERSECTED_ENTITY() { return IntersectionType::ENTITY; }
+
+ /**jsdoc
+ * @function Picks.INTERSECTED_OVERLAY
+ * @returns {number}
+ */
static constexpr unsigned int INTERSECTED_OVERLAY() { return IntersectionType::OVERLAY; }
+
+ /**jsdoc
+ * @function Picks.INTERSECTED_AVATAR
+ * @returns {number}
+ */
static constexpr unsigned int INTERSECTED_AVATAR() { return IntersectionType::AVATAR; }
+
+ /**jsdoc
+ * @function Picks.INTERSECTED_HUD
+ * @returns {number}
+ */
static constexpr unsigned int INTERSECTED_HUD() { return IntersectionType::HUD; }
};
diff --git a/interface/src/raypick/PointerScriptingInterface.cpp b/interface/src/raypick/PointerScriptingInterface.cpp
index ac5a467e76..b7ac899c8d 100644
--- a/interface/src/raypick/PointerScriptingInterface.cpp
+++ b/interface/src/raypick/PointerScriptingInterface.cpp
@@ -42,6 +42,12 @@ unsigned int PointerScriptingInterface::createPointer(const PickQuery::PickType&
}
}
+/**jsdoc
+ * A set of properties that can be passed to {@link Pointers.createPointer} to create a new Pointer. Contains the relevant {@link Picks.PickProperties} to define the underlying Pick.
+ * @typedef {object} Pointers.StylusPointerProperties
+ * @property {boolean} [hover=false] If this pointer should generate hover events.
+ * @property {boolean} [enabled=false]
+ */
unsigned int PointerScriptingInterface::createStylus(const QVariant& properties) const {
QVariantMap propertyMap = properties.toMap();
@@ -58,6 +64,48 @@ unsigned int PointerScriptingInterface::createStylus(const QVariant& properties)
return DependencyManager::get()->addPointer(std::make_shared(properties, StylusPointer::buildStylusOverlay(propertyMap), hover, enabled));
}
+/**jsdoc
+ * A set of properties used to define the visual aspect of a Ray Pointer in the case that the Pointer is not intersecting something. Same as a {@link Pointers.RayPointerRenderState},
+ * but with an additional distance field.
+ *
+ * @typedef {Object} Pointers.DefaultRayPointerRenderState
+ * @augments Pointers.RayPointerRenderState
+ * @property {number} distance The distance at which to render the end of this Ray Pointer, if one is defined.
+ */
+/**jsdoc
+ * A set of properties used to define the visual aspect of a Ray Pointer in the case that the Pointer is intersecting something.
+ *
+ * @typedef {Object} Pointers.RayPointerRenderState
+ * @property {string} name The name of this render state, used by {@link Pointers.setRenderState} and {@link Pointers.editRenderState}
+ * @property {Overlays.OverlayProperties} [start] All of the properties you would normally pass to {@link Overlays.addOverlay}, plus the type (as a type field).
+ * An overlay to represent the beginning of the Ray Pointer, if desired.
+ * @property {Overlays.OverlayProperties} [path] All of the properties you would normally pass to {@link Overlays.addOverlay}, plus the type (as a type field), which must be "line3d".
+ * An overlay to represent the path of the Ray Pointer, if desired.
+ * @property {Overlays.OverlayProperties} [end] All of the properties you would normally pass to {@link Overlays.addOverlay}, plus the type (as a type field).
+ * An overlay to represent the end of the Ray Pointer, if desired.
+ */
+/**jsdoc
+ * A trigger mechanism for Ray Pointers.
+ *
+ * @typedef {Object} Pointers.Trigger
+ * @property {Controller.Standard|Controller.Actions|function} action This can be a built-in Controller action, like Controller.Standard.LTClick, or a function that evaluates to >= 1.0 when you want to trigger button.
+ * @property {string} button Which button to trigger. "Primary", "Secondary", "Tertiary", and "Focus" are currently supported. Only "Primary" will trigger clicks on web surfaces. If "Focus" is triggered,
+ * it will try to set the entity or overlay focus to the object at which the Pointer is aimed. Buttons besides the first three will still trigger events, but event.button will be "None".
+ */
+/**jsdoc
+ * A set of properties that can be passed to {@link Pointers.createPointer} to create a new Pointer. Contains the relevant {@link Picks.PickProperties} to define the underlying Pick.
+ * @typedef {object} Pointers.LaserPointerProperties
+ * @property {boolean} [faceAvatar=false] Ray Pointers only. If true, the end of the Pointer will always rotate to face the avatar.
+ * @property {boolean} [centerEndY=true] Ray Pointers only. If false, the end of the Pointer will be moved up by half of its height.
+ * @property {boolean} [lockEnd=false] Ray Pointers only. If true, the end of the Pointer will lock on to the center of the object at which the laser is pointing.
+ * @property {boolean} [distanceScaleEnd=false] Ray Pointers only. If true, the dimensions of the end of the Pointer will scale linearly with distance.
+ * @property {boolean} [scaleWithAvatar=false] Ray Pointers only. If true, the width of the Pointer's path will scale linearly with your avatar's scale.
+ * @property {boolean} [enabled=false]
+ * @property {Pointers.RayPointerRenderState[]} [renderStates] Ray Pointers only. A list of different visual states to switch between.
+ * @property {Pointers.DefaultRayPointerRenderState[]} [defaultRenderStates] Ray Pointers only. A list of different visual states to use if there is no intersection.
+ * @property {boolean} [hover=false] If this Pointer should generate hover events.
+ * @property {Pointers.Trigger[]} [triggers] Ray Pointers only. A list of different triggers mechanisms that control this Pointer's click event generation.
+ */
unsigned int PointerScriptingInterface::createLaserPointer(const QVariant& properties) const {
QVariantMap propertyMap = properties.toMap();
diff --git a/interface/src/raypick/PointerScriptingInterface.h b/interface/src/raypick/PointerScriptingInterface.h
index e7acfd4037..49eb40504d 100644
--- a/interface/src/raypick/PointerScriptingInterface.h
+++ b/interface/src/raypick/PointerScriptingInterface.h
@@ -16,7 +16,7 @@
/**jsdoc
* The Pointers API lets you create and manage objects for repeatedly calculating intersections in different ways, as well as the visual representation of those objects.
- * Pointers can also be configured to automatically generate PointerEvents.
+ * Pointers can also be configured to automatically generate {@link PointerEvent}s on {@link Entities} and {@link Overlays}.
*
* @namespace Pointers
*
@@ -33,59 +33,12 @@ public:
unsigned int createStylus(const QVariant& properties) const;
/**jsdoc
- * A set of properties that can be passed to {@link Pointers.createPointer} to create a new Pointer. Also contains the relevant {@link Picks.PickProperties} to define the underlying Pick.
- *
+ * Adds a new Pointer
* Different {@link PickType}s use different properties, and within one PickType, the properties you choose can lead to a wide range of behaviors. For example,
* with PickType.Ray, depending on which optional parameters you pass, you could create a Static Ray Pointer, a Mouse Ray Pointer, or a Joint Ray Pointer.
- *
- * @typedef {Object} Pointers.PointerProperties
- * @property {boolean} [hover=false] If this Pointer should generate hover events.
- * @property {boolean} [faceAvatar=false] Ray Pointers only. If true, the end of the Pointer will always rotate to face the avatar.
- * @property {boolean} [centerEndY=true] Ray Pointers only. If false, the end of the Pointer will be moved up by half of its height.
- * @property {boolean} [lockEnd=false] Ray Pointers only. If true, the end of the Pointer will lock on to the center of the object at which the laser is pointing.
- * @property {boolean} [distanceScaleEnd=false] Ray Pointers only. If true, the dimensions of the end of the Pointer will scale linearly with distance.
- * @property {boolean} [scaleWithAvatar=false] Ray Pointers only. If true, the width of the Pointer's path will scale linearly with your avatar's scale.
- * @property {Pointers.RayPointerRenderState[]} [renderStates] Ray Pointers only. A list of different visual states to switch between.
- * @property {Pointers.DefaultRayPointerRenderState[]} [defaultRenderStates] Ray Pointers only. A list of different visual states to use if there is no intersection.
- * @property {Pointers.Trigger[]} [triggers] Ray Pointers only. A list of different triggers mechanisms that control this Pointer's click event generation.
- */
-
- /**jsdoc
- * A set of properties used to define the visual aspect of a Ray Pointer in the case that the Pointer is intersecting something.
- *
- * @typedef {Object} Pointers.RayPointerRenderState
- * @property {string} name The name of this render state, used by {@link Pointers.setRenderState} and {@link Pointers.editRenderState}
- * @property {OverlayProperties} [start] All of the properties you would normally pass to {@Overlays.addOverlay}, plus the type (as a type field).
- * An overlay to represent the beginning of the Ray Pointer, if desired.
- * @property {OverlayProperties} [path] All of the properties you would normally pass to {@Overlays.addOverlay}, plus the type (as a type field), which must be "line3d".
- * An overlay to represent the path of the Ray Pointer, if desired.
- * @property {OverlayProperties} [end] All of the properties you would normally pass to {@Overlays.addOverlay}, plus the type (as a type field).
- * An overlay to represent the end of the Ray Pointer, if desired.
- */
-
- /**jsdoc
- * A set of properties used to define the visual aspect of a Ray Pointer in the case that the Pointer is not intersecting something. Same as a {@link Pointers.RayPointerRenderState},
- * but with an additional distance field.
- *
- * @typedef {Object} Pointers.DefaultRayPointerRenderState
- * @augments Pointers.RayPointerRenderState
- * @property {number} distance The distance at which to render the end of this Ray Pointer, if one is defined.
- */
-
- /**jsdoc
- * A trigger mechanism for Ray Pointers.
- *
- * @typedef {Object} Pointers.Trigger
- * @property {Controller.Action} action This can be a built-in Controller action, like Controller.Standard.LTClick, or a function that evaluates to >= 1.0 when you want to trigger button.
- * @property {string} button Which button to trigger. "Primary", "Secondary", "Tertiary", and "Focus" are currently supported. Only "Primary" will trigger clicks on web surfaces. If "Focus" is triggered,
- * it will try to set the entity or overlay focus to the object at which the Pointer is aimed. Buttons besides the first three will still trigger events, but event.button will be "None".
- */
-
- /**jsdoc
- * Adds a new Pointer
* @function Pointers.createPointer
- * @param {Picks.PickType} type A PickType that specifies the method of picking to use
- * @param {Pointers.PointerProperties} properties A PointerProperties object, containing all the properties for initializing this Pointer and the {@link Picks.PickProperties} for the Pick that
+ * @param {PickType} type A PickType that specifies the method of picking to use
+ * @param {Pointers.LaserPointerProperties|Pointers.StylusPointerProperties} properties A PointerProperties object, containing all the properties for initializing this Pointer and the {@link Picks.PickProperties} for the Pick that
* this Pointer will use to do its picking.
* @returns {number} The ID of the created Pointer. Used for managing the Pointer. 0 if invalid.
*
@@ -121,32 +74,37 @@ public:
* Pointers.setRenderState(pointer, "test");
*/
Q_INVOKABLE unsigned int createPointer(const PickQuery::PickType& type, const QVariant& properties);
+
/**jsdoc
* Enables a Pointer.
* @function Pointers.enablePointer
* @param {number} uid The ID of the Pointer, as returned by {@link Pointers.createPointer}.
*/
Q_INVOKABLE void enablePointer(unsigned int uid) const { DependencyManager::get()->enablePointer(uid); }
+
/**jsdoc
* Disables a Pointer.
* @function Pointers.disablePointer
* @param {number} uid The ID of the Pointer, as returned by {@link Pointers.createPointer}.
*/
Q_INVOKABLE void disablePointer(unsigned int uid) const { DependencyManager::get()->disablePointer(uid); }
+
/**jsdoc
* Removes a Pointer.
* @function Pointers.removePointer
* @param {number} uid The ID of the Pointer, as returned by {@link Pointers.createPointer}.
*/
Q_INVOKABLE void removePointer(unsigned int uid) const { DependencyManager::get()->removePointer(uid); }
+
/**jsdoc
* Edit some visual aspect of a Pointer. Currently only supported for Ray Pointers.
* @function Pointers.editRenderState
* @param {number} uid The ID of the Pointer, as returned by {@link Pointers.createPointer}.
* @param {string} renderState The name of the render state you want to edit.
- * @param {RenderState} properties The new properties for renderState. For Ray Pointers, a {@link Pointers.RayPointerRenderState}.
+ * @param {Pointers.RayPointerRenderState} properties The new properties for renderStates item.
*/
Q_INVOKABLE void editRenderState(unsigned int uid, const QString& renderState, const QVariant& properties) const;
+
/**jsdoc
* Set the render state of a Pointer. For Ray Pointers, this means switching between their {@link Pointers.RayPointerRenderState}s, or "" to turn off rendering and hover/trigger events.
* For Stylus Pointers, there are three built-in options: "events on" (render and send events, the default), "events off" (render but don't send events), and "disabled" (don't render, don't send events).
@@ -156,14 +114,16 @@ public:
*/
Q_INVOKABLE void setRenderState(unsigned int uid, const QString& renderState) const { DependencyManager::get()->setRenderState(uid, renderState.toStdString()); }
+
/**jsdoc
* Get the most recent pick result from this Pointer. This will be updated as long as the Pointer is enabled, regardless of the render state.
* @function Pointers.getPrevPickResult
* @param {number} uid The ID of the Pointer, as returned by {@link Pointers.createPointer}.
- * @returns {PickResult} The most recent intersection result. This will be slightly different for different PickTypes. See {@link Picks.RayPickResult} and {@link Picks.StylusPickResult}.
+ * @returns {RayPickResult|StylusPickResult} The most recent intersection result. This will be slightly different for different PickTypes.
*/
Q_INVOKABLE QVariantMap getPrevPickResult(unsigned int uid) const;
+
/**jsdoc
* Sets whether or not to use precision picking.
* @function Pointers.setPrecisionPicking
@@ -171,6 +131,7 @@ public:
* @param {boolean} precisionPicking Whether or not to use precision picking
*/
Q_INVOKABLE void setPrecisionPicking(unsigned int uid, bool precisionPicking) const { DependencyManager::get()->setPrecisionPicking(uid, precisionPicking); }
+
/**jsdoc
* Sets the length of this Pointer. No effect on Stylus Pointers.
* @function Pointers.setLength
@@ -178,6 +139,7 @@ public:
* @param {float} length The desired length of the Pointer.
*/
Q_INVOKABLE void setLength(unsigned int uid, float length) const { DependencyManager::get()->setLength(uid, length); }
+
/**jsdoc
* Sets a list of Entity IDs, Overlay IDs, and/or Avatar IDs to ignore during intersection. Not used by Stylus Pointers.
* @function Pointers.setIgnoreItems
@@ -185,6 +147,7 @@ public:
* @param {Uuid[]} ignoreItems A list of IDs to ignore.
*/
Q_INVOKABLE void setIgnoreItems(unsigned int uid, const QScriptValue& ignoreEntities) const;
+
/**jsdoc
* Sets a list of Entity IDs, Overlay IDs, and/or Avatar IDs to include during intersection, instead of intersecting with everything. Stylus
* Pointers only intersect with objects in their include list.
@@ -194,17 +157,19 @@ public:
*/
Q_INVOKABLE void setIncludeItems(unsigned int uid, const QScriptValue& includeEntities) const;
+
/**jsdoc
* Lock a Pointer onto a specific object (overlay, entity, or avatar). Optionally, provide an offset in object-space, otherwise the Pointer will lock on to the center of the object.
* Not used by Stylus Pointers.
* @function Pointers.setLockEndUUID
* @param {number} uid The ID of the Pointer, as returned by {@link Pointers.createPointer}.
- * @param {QUuid} objectID The ID of the object to which to lock on.
+ * @param {Uuid} objectID The ID of the object to which to lock on.
* @param {boolean} isOverlay False for entities or avatars, true for overlays
* @param {Mat4} [offsetMat] The offset matrix to use if you do not want to lock on to the center of the object.
*/
Q_INVOKABLE void setLockEndUUID(unsigned int uid, const QUuid& objectID, bool isOverlay, const glm::mat4& offsetMat = glm::mat4()) const { DependencyManager::get()->setLockEndUUID(uid, objectID, isOverlay, offsetMat); }
+
/**jsdoc
* Check if a Pointer is associated with the left hand.
* @function Pointers.isLeftHand
@@ -212,6 +177,7 @@ public:
* @returns {boolean} True if the Pointer is a Joint Ray Pointer with joint == "_CONTROLLER_LEFTHAND" or "_CAMERA_RELATIVE_CONTROLLER_LEFTHAND", or a Stylus Pointer with hand == 0
*/
Q_INVOKABLE bool isLeftHand(unsigned int uid) { return DependencyManager::get()->isLeftHand(uid); }
+
/**jsdoc
* Check if a Pointer is associated with the right hand.
* @function Pointers.isRightHand
@@ -219,6 +185,7 @@ public:
* @returns {boolean} True if the Pointer is a Joint Ray Pointer with joint == "_CONTROLLER_RIGHTHAND" or "_CAMERA_RELATIVE_CONTROLLER_RIGHTHAND", or a Stylus Pointer with hand == 1
*/
Q_INVOKABLE bool isRightHand(unsigned int uid) { return DependencyManager::get()->isRightHand(uid); }
+
/**jsdoc
* Check if a Pointer is associated with the system mouse.
* @function Pointers.isMouse
diff --git a/interface/src/raypick/RayPickScriptingInterface.h b/interface/src/raypick/RayPickScriptingInterface.h
index 3795f191b3..d5e224018e 100644
--- a/interface/src/raypick/RayPickScriptingInterface.h
+++ b/interface/src/raypick/RayPickScriptingInterface.h
@@ -18,6 +18,30 @@
#include "PickScriptingInterface.h"
+/**jsdoc
+ * Synonym for {@link Picks} as used for ray picks.
+ *
+ * @namespace RayPick
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ *
+ * @property {number} PICK_NOTHING Read-only.
+ * @property {number} PICK_ENTITIES Read-only.
+ * @property {number} PICK_OVERLAYS Read-only.
+ * @property {number} PICK_AVATARS Read-only.
+ * @property {number} PICK_HUD Read-only.
+ * @property {number} PICK_COARSE Read-only.
+ * @property {number} PICK_INCLUDE_INVISIBLE Read-only.
+ * @property {number} PICK_INCLUDE_NONCOLLIDABLE Read-only.
+ * @property {number} PICK_ALL_INTERSECTIONS Read-only.
+ * @property {number} INTERSECTED_NONE Read-only.
+ * @property {number} INTERSECTED_ENTITY Read-only.
+ * @property {number} INTERSECTED_OVERLAY Read-only.
+ * @property {number} INTERSECTED_AVATAR Read-only.
+ * @property {number} INTERSECTED_HUD Read-only.
+ */
+
class RayPickScriptingInterface : public QObject, public Dependency {
Q_OBJECT
Q_PROPERTY(unsigned int PICK_NOTHING READ PICK_NOTHING CONSTANT)
@@ -37,34 +61,167 @@ class RayPickScriptingInterface : public QObject, public Dependency {
SINGLETON_DEPENDENCY
public:
+
+ /**jsdoc
+ * @function RayPick.createRayPick
+ * @param {Picks.RayPickProperties}
+ * @returns {number}
+ */
Q_INVOKABLE unsigned int createRayPick(const QVariant& properties);
+
+ /**jsdoc
+ * @function RayPick.enableRayPick
+ * @param {number} id
+ */
Q_INVOKABLE void enableRayPick(unsigned int uid);
+
+ /**jsdoc
+ * @function RayPick.disableRayPick
+ * @param {number} id
+ */
Q_INVOKABLE void disableRayPick(unsigned int uid);
+
+ /**jsdoc
+ * @function RayPick.removeRayPick
+ * @param {number} id
+ */
Q_INVOKABLE void removeRayPick(unsigned int uid);
+
+ /**jsdoc
+ * @function RayPick.getPrevRayPickResult
+ * @param {number} id
+ * @returns {RayPickResult}
+ */
Q_INVOKABLE QVariantMap getPrevRayPickResult(unsigned int uid);
+
+ /**jsdoc
+ * @function RayPick.setPrecisionPicking
+ * @param {number} id
+ * @param {boolean} precisionPicking
+ */
Q_INVOKABLE void setPrecisionPicking(unsigned int uid, bool precisionPicking);
+
+ /**jsdoc
+ * @function RayPick.setIgnoreItems
+ * @param {number} id
+ * @param {Uuid[]) ignoreEntities
+ */
Q_INVOKABLE void setIgnoreItems(unsigned int uid, const QScriptValue& ignoreEntities);
+
+ /**jsdoc
+ * @function RayPick.setIncludeItems
+ * @param {number} id
+ * @param {Uuid[]) includeEntities
+ */
Q_INVOKABLE void setIncludeItems(unsigned int uid, const QScriptValue& includeEntities);
+
+ /**jsdoc
+ * @function RayPick.isLeftHand
+ * @param {number} id
+ * @returns {boolean}
+ */
Q_INVOKABLE bool isLeftHand(unsigned int uid);
+
+ /**jsdoc
+ * @function RayPick.isRightHand
+ * @param {number} id
+ * @returns {boolean}
+ */
Q_INVOKABLE bool isRightHand(unsigned int uid);
+
+ /**jsdoc
+ * @function RayPick.isMouse
+ * @param {number} id
+ * @returns {boolean}
+ */
Q_INVOKABLE bool isMouse(unsigned int uid);
public slots:
+
+ /**jsdoc
+ * @function RayPick.PICK_NOTHING
+ * @returns {number}
+ */
static unsigned int PICK_NOTHING() { return PickScriptingInterface::PICK_NOTHING(); }
+
+ /**jsdoc
+ * @function RayPick.PICK_ENTITIES
+ * @returns {number}
+ */
static unsigned int PICK_ENTITIES() { return PickScriptingInterface::PICK_ENTITIES(); }
+
+ /**jsdoc
+ * @function RayPick.PICK_OVERLAYS
+ * @returns {number}
+ */
static unsigned int PICK_OVERLAYS() { return PickScriptingInterface::PICK_OVERLAYS(); }
+
+ /**jsdoc
+ * @function RayPick.PICK_AVATARS
+ * @returns {number}
+ */
static unsigned int PICK_AVATARS() { return PickScriptingInterface::PICK_AVATARS(); }
+
+ /**jsdoc
+ * @function RayPick.PICK_HUD
+ * @returns {number}
+ */
static unsigned int PICK_HUD() { return PickScriptingInterface::PICK_HUD(); }
+
+ /**jsdoc
+ * @function RayPick.PICK_COARSE
+ * @returns {number}
+ */
static unsigned int PICK_COARSE() { return PickScriptingInterface::PICK_COARSE(); }
+
+ /**jsdoc
+ * @function RayPick.PICK_INCLUDE_INVISIBLE
+ * @returns {number}
+ */
static unsigned int PICK_INCLUDE_INVISIBLE() { return PickScriptingInterface::PICK_INCLUDE_INVISIBLE(); }
+
+ /**jsdoc
+ * @function RayPick.PICK_INCLUDE_NONCOLLIDABLE
+ * @returns {number}
+ */
static unsigned int PICK_INCLUDE_NONCOLLIDABLE() { return PickScriptingInterface::PICK_INCLUDE_NONCOLLIDABLE(); }
+
+ /**jsdoc
+ * @function RayPick.PICK_ALL_INTERSECTIONS
+ * @returns {number}
+ */
static unsigned int PICK_ALL_INTERSECTIONS() { return PickScriptingInterface::PICK_ALL_INTERSECTIONS(); }
+
+ /**jsdoc
+ * @function RayPick.INTERSECTED_NONE
+ * @returns {number}
+ */
static unsigned int INTERSECTED_NONE() { return PickScriptingInterface::INTERSECTED_NONE(); }
+
+ /**jsdoc
+ * @function RayPick.INTERSECTED_ENTITY
+ * @returns {number}
+ */
static unsigned int INTERSECTED_ENTITY() { return PickScriptingInterface::INTERSECTED_ENTITY(); }
+
+ /**jsdoc
+ * @function RayPick.INTERSECTED_OVERLAY
+ * @returns {number}
+ */
static unsigned int INTERSECTED_OVERLAY() { return PickScriptingInterface::INTERSECTED_OVERLAY(); }
+
+ /**jsdoc
+ * @function RayPick.INTERSECTED_AVATAR
+ * @returns {number}
+ */
static unsigned int INTERSECTED_AVATAR() { return PickScriptingInterface::INTERSECTED_AVATAR(); }
+
+ /**jsdoc
+ * @function RayPick.INTERSECTED_HUD
+ * @returns {number}
+ */
static unsigned int INTERSECTED_HUD() { return PickScriptingInterface::INTERSECTED_HUD(); }
};
diff --git a/interface/src/scripting/Audio.h b/interface/src/scripting/Audio.h
index f0a4328c2f..8d16b06995 100644
--- a/interface/src/scripting/Audio.h
+++ b/interface/src/scripting/Audio.h
@@ -89,7 +89,7 @@ public:
/**jsdoc
* @function Audio.setReverbOptions
- * @param {} options
+ * @param {AudioEffectOptions} options
*/
Q_INVOKABLE void setReverbOptions(const AudioEffectOptions* options);
diff --git a/interface/src/scripting/TestScriptingInterface.cpp b/interface/src/scripting/TestScriptingInterface.cpp
index 9e7c0e142e..700994c517 100644
--- a/interface/src/scripting/TestScriptingInterface.cpp
+++ b/interface/src/scripting/TestScriptingInterface.cpp
@@ -160,3 +160,29 @@ void TestScriptingInterface::clearCaches() {
qApp->reloadResourceCaches();
}
+// Writes a JSON object from javascript to a file
+void TestScriptingInterface::saveObject(QVariant variant, const QString& filename) {
+ if (_testResultsLocation.isNull()) {
+ return;
+ }
+
+ QJsonDocument jsonDocument;
+ jsonDocument = QJsonDocument::fromVariant(variant);
+ if (jsonDocument.isNull()) {
+ return;
+ }
+
+ QByteArray jsonData = jsonDocument.toJson();
+
+ // Append trailing slash if needed
+ if (_testResultsLocation.right(1) != "/") {
+ _testResultsLocation += "/";
+ }
+
+ QString filepath = QDir::cleanPath(_testResultsLocation + filename);
+ QFile file(filepath);
+
+ file.open(QFile::WriteOnly);
+ file.write(jsonData);
+ file.close();
+}
diff --git a/interface/src/scripting/TestScriptingInterface.h b/interface/src/scripting/TestScriptingInterface.h
index 687cb41689..5666417727 100644
--- a/interface/src/scripting/TestScriptingInterface.h
+++ b/interface/src/scripting/TestScriptingInterface.h
@@ -18,6 +18,10 @@ class QScriptValue;
class TestScriptingInterface : public QObject {
Q_OBJECT
+public:
+ void setTestResultsLocation(const QString path) { _testResultsLocation = path; }
+ const QString& getTestResultsLocation() { return _testResultsLocation; };
+
public slots:
static TestScriptingInterface* getInstance();
@@ -46,7 +50,6 @@ public slots:
*/
void waitIdle();
-
bool waitForConnection(qint64 maxWaitMs = 10000);
void wait(int milliseconds);
@@ -83,8 +86,14 @@ public slots:
*/
void clearCaches();
+ /**jsdoc
+ * Save a JSON object to a file in the test results location
+ */
+ void saveObject(QVariant v, const QString& filename);
+
private:
bool waitForCondition(qint64 maxWaitMs, std::function condition);
+ QString _testResultsLocation;
};
-#endif // hifi_TestScriptingInterface_h
+#endif // hifi_TestScriptingInterface_h
diff --git a/interface/src/scripting/WalletScriptingInterface.h b/interface/src/scripting/WalletScriptingInterface.h
index 9e40aad087..25955ca7a3 100644
--- a/interface/src/scripting/WalletScriptingInterface.h
+++ b/interface/src/scripting/WalletScriptingInterface.h
@@ -30,6 +30,14 @@ public:
};
+/**jsdoc
+ * @namespace Wallet
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ *
+ * @property {number} walletStatus
+ */
class WalletScriptingInterface : public QObject, public Dependency {
Q_OBJECT
@@ -38,17 +46,53 @@ class WalletScriptingInterface : public QObject, public Dependency {
public:
WalletScriptingInterface();
+ /**jsdoc
+ * @function Wallet.refreshWalletStatus
+ */
Q_INVOKABLE void refreshWalletStatus();
+
+ /**jsdoc
+ * @function Wallet.getWalletStatus
+ * @returns {number}
+ */
Q_INVOKABLE uint getWalletStatus() { return _walletStatus; }
+
+ /**jsdoc
+ * @function Wallet.proveAvatarEntityOwnershipVerification
+ * @param {Uuid} entityID
+ */
Q_INVOKABLE void proveAvatarEntityOwnershipVerification(const QUuid& entityID);
+
// setWalletStatus() should never be made Q_INVOKABLE. If it were,
// scripts could cause the Wallet to incorrectly report its status.
void setWalletStatus(const uint& status);
signals:
+
+ /**jsdoc
+ * @function Wallet.walletStatusChanged
+ * @returns {Signal}
+ */
void walletStatusChanged();
+
+ /**jsdoc
+ * @function Wallet.walletNotSetup
+ * @returns {Signal}
+ */
void walletNotSetup();
+
+ /**jsdoc
+ * @function Wallet.ownershipVerificationSuccess
+ * @param {Uuid} entityID
+ * @returns {Signal}
+ */
void ownershipVerificationSuccess(const QUuid& entityID);
+
+ /**jsdoc
+ * @function Wallet.ownershipVerificationFailed
+ * @param {Uuid} entityID
+ * @returns {Signal}
+ */
void ownershipVerificationFailed(const QUuid& entityID);
private:
diff --git a/interface/src/scripting/WindowScriptingInterface.cpp b/interface/src/scripting/WindowScriptingInterface.cpp
index 9c46f9e98a..6f6e83842c 100644
--- a/interface/src/scripting/WindowScriptingInterface.cpp
+++ b/interface/src/scripting/WindowScriptingInterface.cpp
@@ -15,12 +15,13 @@
#include
#include
#include
-
+#include
#include
#include
#include
-
+#include
+#include "AndroidHelper.h"
#include "Application.h"
#include "DomainHandler.h"
#include "MainWindow.h"
@@ -131,6 +132,24 @@ void WindowScriptingInterface::disconnectedFromDomain() {
emit domainChanged(QUrl());
}
+void WindowScriptingInterface::openUrl(const QUrl& url) {
+ if (!url.isEmpty()) {
+ if (url.scheme() == URL_SCHEME_HIFI) {
+ DependencyManager::get()->handleLookupString(url.toString());
+ } else {
+ // address manager did not handle - ask QDesktopServices to handle
+ QDesktopServices::openUrl(url);
+ }
+ }
+}
+
+void WindowScriptingInterface::openAndroidActivity(const QString& activityName, const bool backToScene) {
+#if defined(Q_OS_ANDROID)
+ AndroidHelper::instance().requestActivity(activityName, backToScene);
+#endif
+}
+
+
QString fixupPathForMac(const QString& directory) {
// On OS X `directory` does not work as expected unless a file is included in the path, so we append a bogus
// filename if the directory is valid.
@@ -431,6 +450,10 @@ void WindowScriptingInterface::takeSecondaryCameraSnapshot(const QString& filena
qApp->takeSecondaryCameraSnapshot(filename);
}
+void WindowScriptingInterface::takeSecondaryCamera360Snapshot(const glm::vec3& cameraPosition, const bool& cubemapOutputFormat, const QString& filename) {
+ qApp->takeSecondaryCamera360Snapshot(cameraPosition, cubemapOutputFormat, filename);
+}
+
void WindowScriptingInterface::shareSnapshot(const QString& path, const QUrl& href) {
qApp->shareSnapshot(path, href);
}
diff --git a/interface/src/scripting/WindowScriptingInterface.h b/interface/src/scripting/WindowScriptingInterface.h
index 348882e0f8..1d06f33ec0 100644
--- a/interface/src/scripting/WindowScriptingInterface.h
+++ b/interface/src/scripting/WindowScriptingInterface.h
@@ -370,6 +370,20 @@ public slots:
*/
void takeSecondaryCameraSnapshot(const QString& filename = QString());
+ /**jsdoc
+ * Takes a 360 snapshot given a position of the secondary camera (which does not need to have been previously set up).
+ * @function Window.takeSecondaryCameraSnapshot
+ * @param {vec3} [cameraPosition] - The (x, y, z) position of the camera for the 360 snapshot
+ * @param {boolean} [cubemapOutputFormat=false] - If true then the snapshot is saved as a cube map image,
+ * otherwise is saved as an equirectangular image.
+ * @param {string} [filename=""] - If this parameter is not given, the image will be saved as 'hifi-snap-by--YYYY-MM-DD_HH-MM-SS'.
+ * If this parameter is "" then the image will be saved as ".jpg".
+ * Otherwise, the image will be saved to this filename, with an appended ".jpg".
+ *
+ * var filename = QString();
+ */
+ void takeSecondaryCamera360Snapshot(const glm::vec3& cameraPosition, const bool& cubemapOutputFormat = false, const QString& filename = QString());
+
/**jsdoc
* Emit a {@link Window.connectionAdded|connectionAdded} or a {@link Window.connectionError|connectionError} signal that
* indicates whether or not a user connection was successfully made using the Web API.
@@ -508,6 +522,20 @@ public slots:
*/
int openMessageBox(QString title, QString text, int buttons, int defaultButton);
+ /**jsdoc
+ * Open the given resource in the Interface window or in a web browser depending on the url scheme
+ * @function Window.openUrl
+ * @param {string} url - The resource to open
+ */
+ void openUrl(const QUrl& url);
+
+ /**jsdoc
+ * (Android only) Open the requested Activity and optionally back to the scene when the activity is done
+ * @function Window.openAndroidActivity
+ * @param {string} activityName - The name of the activity to open. One of "Home", "Login" or "Privacy Policy"
+ */
+ void openAndroidActivity(const QString& activityName, const bool backToScene);
+
/**jsdoc
* Update the content of a message box that was opened with {@link Window.openMessageBox|openMessageBox}.
* @function Window.updateMessageBox
@@ -578,6 +606,16 @@ signals:
*/
void stillSnapshotTaken(const QString& pathStillSnapshot, bool notify);
+ /**jsdoc
+ * Triggered when a still equirectangular snapshot has been taken by calling {@link Window.takeSecondaryCamera360Snapshot|takeSecondaryCamera360Snapshot}
+ * @function Window.snapshot360Taken
+ * @param {string} pathStillSnapshot - The path and name of the snapshot image file.
+ * @param {boolean} notify - The value of the notify parameter that {@link Window.takeSecondaryCamera360Snapshot|takeSecondaryCamera360Snapshot}
+ * was called with.
+ * @returns {Signal}
+ */
+ void snapshot360Taken(const QString& path360Snapshot, bool notify);
+
/**jsdoc
* Triggered when a snapshot submitted via {@link Window.shareSnapshot|shareSnapshot} is ready for sharing. The snapshot
* may then be shared via the {@link Account.metaverseServerURL} Web API.
diff --git a/interface/src/ui/ApplicationOverlay.cpp b/interface/src/ui/ApplicationOverlay.cpp
index 9a7ebdf784..ea660fb0e2 100644
--- a/interface/src/ui/ApplicationOverlay.cpp
+++ b/interface/src/ui/ApplicationOverlay.cpp
@@ -179,7 +179,7 @@ static const auto DEPTH_FORMAT = gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::DEPT
void ApplicationOverlay::buildFramebufferObject() {
PROFILE_RANGE(app, __FUNCTION__);
- auto uiSize = qApp->getUiSize();
+ auto uiSize = glm::uvec2(glm::vec2(qApp->getUiSize()) * qApp->getRenderResolutionScale());
if (!_overlayFramebuffer || uiSize != _overlayFramebuffer->getSize()) {
_overlayFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("ApplicationOverlay"));
}
diff --git a/interface/src/ui/LoginDialog.cpp b/interface/src/ui/LoginDialog.cpp
index 2e40d3c087..39a5849d85 100644
--- a/interface/src/ui/LoginDialog.cpp
+++ b/interface/src/ui/LoginDialog.cpp
@@ -31,10 +31,13 @@ HIFI_QML_DEF(LoginDialog)
LoginDialog::LoginDialog(QQuickItem *parent) : OffscreenQmlDialog(parent) {
auto accountManager = DependencyManager::get();
+#if !defined(Q_OS_ANDROID)
connect(accountManager.data(), &AccountManager::loginComplete,
this, &LoginDialog::handleLoginCompleted);
connect(accountManager.data(), &AccountManager::loginFailed,
this, &LoginDialog::handleLoginFailed);
+#endif
+
}
void LoginDialog::showWithSelection()
diff --git a/interface/src/ui/PreferencesDialog.cpp b/interface/src/ui/PreferencesDialog.cpp
index 4c233b986c..6bb35fde41 100644
--- a/interface/src/ui/PreferencesDialog.cpp
+++ b/interface/src/ui/PreferencesDialog.cpp
@@ -132,8 +132,8 @@ void setupPreferences() {
// Snapshots
static const QString SNAPSHOTS { "Snapshots" };
{
- auto getter = []()->QString { return Snapshot::snapshotsLocation.get(); };
- auto setter = [](const QString& value) { Snapshot::snapshotsLocation.set(value); emit DependencyManager::get()->snapshotLocationSet(value); };
+ auto getter = []()->QString { return DependencyManager::get()->_snapshotsLocation.get(); };
+ auto setter = [](const QString& value) { DependencyManager::get()->_snapshotsLocation.set(value); emit DependencyManager::get()->snapshotLocationSet(value); };
auto preference = new BrowsePreference(SNAPSHOTS, "Put my snapshots here", getter, setter);
preferences->addPreference(preference);
}
diff --git a/interface/src/ui/Snapshot.cpp b/interface/src/ui/Snapshot.cpp
index 39fef1d742..b2c0ee7ce7 100644
--- a/interface/src/ui/Snapshot.cpp
+++ b/interface/src/ui/Snapshot.cpp
@@ -21,7 +21,8 @@
#include
#include
#include
-#include
+#include
+#include
#include
#include
@@ -31,20 +32,39 @@
#include
#include
#include
+#include
+#include
#include "Application.h"
+#include "display-plugins/CompositorHelper.h"
+#include "scripting/WindowScriptingInterface.h"
+#include "MainWindow.h"
+#include "Snapshot.h"
#include "SnapshotUploader.h"
+#include "ToneMappingEffect.h"
// filename format: hifi-snap-by-%username%-on-%date%_%time%_@-%location%.jpg
// %1 <= username, %2 <= date and time, %3 <= current location
const QString FILENAME_PATH_FORMAT = "hifi-snap-by-%1-on-%2.jpg";
-
const QString DATETIME_FORMAT = "yyyy-MM-dd_hh-mm-ss";
const QString SNAPSHOTS_DIRECTORY = "Snapshots";
-
const QString URL = "highfidelity_url";
+static const int SNAPSHOT_360_TIMER_INTERVAL = 350;
-Setting::Handle Snapshot::snapshotsLocation("snapshotsLocation");
+Snapshot::Snapshot() {
+ _snapshotTimer.setSingleShot(false);
+ _snapshotTimer.setTimerType(Qt::PreciseTimer);
+ _snapshotTimer.setInterval(SNAPSHOT_360_TIMER_INTERVAL);
+ connect(&_snapshotTimer, &QTimer::timeout, this, &Snapshot::takeNextSnapshot);
+
+ _snapshotIndex = 0;
+ _oldEnabled = false;
+ _oldAttachedEntityId = 0;
+ _oldOrientation = 0;
+ _oldvFoV = 0;
+ _oldNearClipPlaneDistance = 0;
+ _oldFarClipPlaneDistance = 0;
+}
SnapshotMetaData* Snapshot::parseSnapshotData(QString snapshotPath) {
@@ -78,14 +98,236 @@ QString Snapshot::saveSnapshot(QImage image, const QString& filename, const QStr
QFile* snapshotFile = savedFileForSnapshot(image, false, filename, pathname);
- // we don't need the snapshot file, so close it, grab its filename and delete it
- snapshotFile->close();
+ if (snapshotFile) {
+ // we don't need the snapshot file, so close it, grab its filename and delete it
+ snapshotFile->close();
- QString snapshotPath = QFileInfo(*snapshotFile).absoluteFilePath();
+ QString snapshotPath = QFileInfo(*snapshotFile).absoluteFilePath();
- delete snapshotFile;
+ delete snapshotFile;
- return snapshotPath;
+ return snapshotPath;
+ }
+
+ return "";
+}
+
+static const float CUBEMAP_SIDE_PIXEL_DIMENSION = 2048.0f;
+static const float SNAPSHOT_360_FOV = 90.0f;
+static const float SNAPSHOT_360_NEARCLIP = 0.3f;
+static const float SNAPSHOT_360_FARCLIP = 16384.0f;
+static const glm::quat CAMERA_ORIENTATION_DOWN(glm::quat(glm::radians(glm::vec3(-90.0f, 0.0f, 0.0f))));
+static const glm::quat CAMERA_ORIENTATION_FRONT(glm::quat(glm::radians(glm::vec3(0.0f, 0.0f, 0.0f))));
+static const glm::quat CAMERA_ORIENTATION_LEFT(glm::quat(glm::radians(glm::vec3(0.0f, 90.0f, 0.0f))));
+static const glm::quat CAMERA_ORIENTATION_BACK(glm::quat(glm::radians(glm::vec3(0.0f, 180.0f, 0.0f))));
+static const glm::quat CAMERA_ORIENTATION_RIGHT(glm::quat(glm::radians(glm::vec3(0.0f, 270.0f, 0.0f))));
+static const glm::quat CAMERA_ORIENTATION_UP(glm::quat(glm::radians(glm::vec3(90.0f, 0.0f, 0.0f))));
+void Snapshot::save360Snapshot(const glm::vec3& cameraPosition, const bool& cubemapOutputFormat, const QString& filename) {
+ _snapshotFilename = filename;
+ _cubemapOutputFormat = cubemapOutputFormat;
+ SecondaryCameraJobConfig* secondaryCameraRenderConfig = static_cast(qApp->getRenderEngine()->getConfiguration()->getConfig("SecondaryCamera"));
+
+ // Save initial values of secondary camera render config
+ _oldEnabled = secondaryCameraRenderConfig->isEnabled();
+ _oldAttachedEntityId = secondaryCameraRenderConfig->property("attachedEntityId");
+ _oldOrientation = secondaryCameraRenderConfig->property("orientation");
+ _oldvFoV = secondaryCameraRenderConfig->property("vFoV");
+ _oldNearClipPlaneDistance = secondaryCameraRenderConfig->property("nearClipPlaneDistance");
+ _oldFarClipPlaneDistance = secondaryCameraRenderConfig->property("farClipPlaneDistance");
+
+ if (!_oldEnabled) {
+ secondaryCameraRenderConfig->enableSecondaryCameraRenderConfigs(true);
+ }
+
+ // Initialize some secondary camera render config options for 360 snapshot capture
+ static_cast(qApp->getRenderEngine()->getConfiguration()->getConfig("SecondaryCameraJob.ToneMapping"))->setCurve(0);
+
+ secondaryCameraRenderConfig->resetSizeSpectatorCamera(static_cast(CUBEMAP_SIDE_PIXEL_DIMENSION), static_cast(CUBEMAP_SIDE_PIXEL_DIMENSION));
+ secondaryCameraRenderConfig->setProperty("attachedEntityId", "");
+ secondaryCameraRenderConfig->setPosition(cameraPosition);
+ secondaryCameraRenderConfig->setProperty("vFoV", SNAPSHOT_360_FOV);
+ secondaryCameraRenderConfig->setProperty("nearClipPlaneDistance", SNAPSHOT_360_NEARCLIP);
+ secondaryCameraRenderConfig->setProperty("farClipPlaneDistance", SNAPSHOT_360_FARCLIP);
+
+ // Setup for Down Image capture
+ secondaryCameraRenderConfig->setOrientation(CAMERA_ORIENTATION_DOWN);
+
+ _snapshotIndex = 0;
+
+ _snapshotTimer.start(SNAPSHOT_360_TIMER_INTERVAL);
+}
+
+void Snapshot::takeNextSnapshot() {
+ SecondaryCameraJobConfig* config = static_cast(qApp->getRenderEngine()->getConfiguration()->getConfig("SecondaryCamera"));
+
+ // Order is:
+ // 0. Down
+ // 1. Front
+ // 2. Left
+ // 3. Back
+ // 4. Right
+ // 5. Up
+ if (_snapshotIndex < 6) {
+ _imageArray[_snapshotIndex] = qApp->getActiveDisplayPlugin()->getSecondaryCameraScreenshot();
+ }
+
+ if (_snapshotIndex == 0) {
+ // Setup for Front Image capture
+ config->setOrientation(CAMERA_ORIENTATION_FRONT);
+ } else if (_snapshotIndex == 1) {
+ // Setup for Left Image capture
+ config->setOrientation(CAMERA_ORIENTATION_LEFT);
+ } else if (_snapshotIndex == 2) {
+ // Setup for Back Image capture
+ config->setOrientation(CAMERA_ORIENTATION_BACK);
+ } else if (_snapshotIndex == 3) {
+ // Setup for Right Image capture
+ config->setOrientation(CAMERA_ORIENTATION_RIGHT);
+ } else if (_snapshotIndex == 4) {
+ // Setup for Up Image capture
+ config->setOrientation(CAMERA_ORIENTATION_UP);
+ } else if (_snapshotIndex > 5) {
+ _snapshotTimer.stop();
+
+ // Reset secondary camera render config
+ static_cast(qApp->getRenderEngine()->getConfiguration()->getConfig("SecondaryCameraJob.ToneMapping"))->setCurve(1);
+ config->resetSizeSpectatorCamera(qApp->getWindow()->geometry().width(), qApp->getWindow()->geometry().height());
+ config->setProperty("attachedEntityId", _oldAttachedEntityId);
+ config->setProperty("vFoV", _oldvFoV);
+ config->setProperty("nearClipPlaneDistance", _oldNearClipPlaneDistance);
+ config->setProperty("farClipPlaneDistance", _oldFarClipPlaneDistance);
+
+ if (!_oldEnabled) {
+ config->enableSecondaryCameraRenderConfigs(false);
+ }
+
+ // Process six QImages
+ if (_cubemapOutputFormat) {
+ QtConcurrent::run([this]() { convertToCubemap(); });
+ } else {
+ QtConcurrent::run([this]() { convertToEquirectangular(); });
+ }
+ }
+
+ _snapshotIndex++;
+}
+
+void Snapshot::convertToCubemap() {
+ float outputImageHeight = CUBEMAP_SIDE_PIXEL_DIMENSION * 3.0f;
+ float outputImageWidth = CUBEMAP_SIDE_PIXEL_DIMENSION * 4.0f;
+
+ QImage outputImage(outputImageWidth, outputImageHeight, QImage::Format_RGB32);
+
+ QPainter painter(&outputImage);
+ QPoint destPos;
+
+ // Paint DownImage
+ destPos = QPoint(CUBEMAP_SIDE_PIXEL_DIMENSION, CUBEMAP_SIDE_PIXEL_DIMENSION * 2.0f);
+ painter.drawImage(destPos, _imageArray[0]);
+
+ // Paint FrontImage
+ destPos = QPoint(CUBEMAP_SIDE_PIXEL_DIMENSION, CUBEMAP_SIDE_PIXEL_DIMENSION);
+ painter.drawImage(destPos, _imageArray[1]);
+
+ // Paint LeftImage
+ destPos = QPoint(0, CUBEMAP_SIDE_PIXEL_DIMENSION);
+ painter.drawImage(destPos, _imageArray[2]);
+
+ // Paint BackImage
+ destPos = QPoint(CUBEMAP_SIDE_PIXEL_DIMENSION * 3.0f, CUBEMAP_SIDE_PIXEL_DIMENSION);
+ painter.drawImage(destPos, _imageArray[3]);
+
+ // Paint RightImage
+ destPos = QPoint(CUBEMAP_SIDE_PIXEL_DIMENSION * 2.0f, CUBEMAP_SIDE_PIXEL_DIMENSION);
+ painter.drawImage(destPos, _imageArray[4]);
+
+ // Paint UpImage
+ destPos = QPoint(CUBEMAP_SIDE_PIXEL_DIMENSION, 0);
+ painter.drawImage(destPos, _imageArray[5]);
+
+ painter.end();
+
+ emit DependencyManager::get()->snapshot360Taken(saveSnapshot(outputImage, _snapshotFilename), true);
+}
+
+void Snapshot::convertToEquirectangular() {
+ // I got help from StackOverflow while writing this code:
+ // https://stackoverflow.com/questions/34250742/converting-a-cubemap-into-equirectangular-panorama
+
+ int cubeFaceWidth = static_cast(CUBEMAP_SIDE_PIXEL_DIMENSION);
+ int cubeFaceHeight = static_cast(CUBEMAP_SIDE_PIXEL_DIMENSION);
+ float outputImageHeight = CUBEMAP_SIDE_PIXEL_DIMENSION * 2.0f;
+ float outputImageWidth = outputImageHeight * 2.0f;
+ QImage outputImage(outputImageWidth, outputImageHeight, QImage::Format_RGB32);
+ outputImage.fill(0);
+ QRgb sourceColorValue;
+ float phi, theta;
+
+ for (int j = 0; j < outputImageHeight; j++) {
+ theta = (1.0f - ((float)j / outputImageHeight)) * PI;
+
+ for (int i = 0; i < outputImageWidth; i++) {
+ phi = ((float)i / outputImageWidth) * 2.0f * PI;
+
+ float x = glm::sin(phi) * glm::sin(theta) * -1.0f;
+ float y = glm::cos(theta);
+ float z = glm::cos(phi) * glm::sin(theta) * -1.0f;
+
+ float a = std::max(std::max(std::abs(x), std::abs(y)), std::abs(z));
+
+ float xa = x / a;
+ float ya = y / a;
+ float za = z / a;
+
+ // Pixel in the source images
+ int xPixel, yPixel;
+ QImage sourceImage;
+
+ if (xa == 1) {
+ // Right image
+ xPixel = (int)((((za + 1.0f) / 2.0f) - 1.0f) * cubeFaceWidth);
+ yPixel = (int)((((ya + 1.0f) / 2.0f)) * cubeFaceHeight);
+ sourceImage = _imageArray[4];
+ } else if (xa == -1) {
+ // Left image
+ xPixel = (int)((((za + 1.0f) / 2.0f)) * cubeFaceWidth);
+ yPixel = (int)((((ya + 1.0f) / 2.0f)) * cubeFaceHeight);
+ sourceImage = _imageArray[2];
+ } else if (ya == 1) {
+ // Down image
+ xPixel = (int)((((xa + 1.0f) / 2.0f)) * cubeFaceWidth);
+ yPixel = (int)((((za + 1.0f) / 2.0f) - 1.0f) * cubeFaceHeight);
+ sourceImage = _imageArray[0];
+ } else if (ya == -1) {
+ // Up image
+ xPixel = (int)((((xa + 1.0f) / 2.0f)) * cubeFaceWidth);
+ yPixel = (int)((((za + 1.0f) / 2.0f)) * cubeFaceHeight);
+ sourceImage = _imageArray[5];
+ } else if (za == 1) {
+ // Front image
+ xPixel = (int)((((xa + 1.0f) / 2.0f)) * cubeFaceWidth);
+ yPixel = (int)((((ya + 1.0f) / 2.0f)) * cubeFaceHeight);
+ sourceImage = _imageArray[1];
+ } else if (za == -1) {
+ // Back image
+ xPixel = (int)((((xa + 1.0f) / 2.0f) - 1.0f) * cubeFaceWidth);
+ yPixel = (int)((((ya + 1.0f) / 2.0f)) * cubeFaceHeight);
+ sourceImage = _imageArray[3];
+ } else {
+ qDebug() << "Unknown face encountered when processing 360 Snapshot";
+ xPixel = 0;
+ yPixel = 0;
+ }
+
+ xPixel = std::min(std::abs(xPixel), 2047);
+ yPixel = std::min(std::abs(yPixel), 2047);
+
+ sourceColorValue = sourceImage.pixel(xPixel, yPixel);
+ outputImage.setPixel(i, j, sourceColorValue);
+ }
+ }
+
+ emit DependencyManager::get()->snapshot360Taken(saveSnapshot(outputImage, _snapshotFilename), true);
}
QTemporaryFile* Snapshot::saveTempSnapshot(QImage image) {
@@ -123,12 +365,12 @@ QFile* Snapshot::savedFileForSnapshot(QImage & shot, bool isTemporary, const QSt
if (!userSelectedPathname.isNull()) {
snapshotFullPath = userSelectedPathname;
} else {
- snapshotFullPath = snapshotsLocation.get();
+ snapshotFullPath = _snapshotsLocation.get();
}
if (snapshotFullPath.isEmpty()) {
snapshotFullPath = OffscreenUi::getExistingDirectory(nullptr, "Choose Snapshots Directory", QStandardPaths::writableLocation(QStandardPaths::DesktopLocation));
- snapshotsLocation.set(snapshotFullPath);
+ _snapshotsLocation.set(snapshotFullPath);
}
if (!snapshotFullPath.isEmpty()) { // not cancelled
@@ -140,7 +382,27 @@ QFile* Snapshot::savedFileForSnapshot(QImage & shot, bool isTemporary, const QSt
snapshotFullPath.append(filename);
QFile* imageFile = new QFile(snapshotFullPath);
- imageFile->open(QIODevice::WriteOnly);
+ while (!imageFile->open(QIODevice::WriteOnly)) {
+ // It'd be better for the directory chooser to restore the cursor to its previous state
+ // after choosing a directory, but if the user has entered this codepath,
+ // something terrible has happened. Let's just show the user their cursor so they can get
+ // out of this awful state.
+ qApp->getApplicationCompositor().getReticleInterface()->setVisible(true);
+ qApp->getApplicationCompositor().getReticleInterface()->setAllowMouseCapture(true);
+
+ snapshotFullPath = OffscreenUi::getExistingDirectory(nullptr, "Write Error - Choose New Snapshots Directory", QStandardPaths::writableLocation(QStandardPaths::DesktopLocation));
+ if (snapshotFullPath.isEmpty()) {
+ return NULL;
+ }
+ _snapshotsLocation.set(snapshotFullPath);
+
+ if (!snapshotFullPath.endsWith(QDir::separator())) {
+ snapshotFullPath.append(QDir::separator());
+ }
+ snapshotFullPath.append(filename);
+
+ imageFile = new QFile(snapshotFullPath);
+ }
shot.save(imageFile, 0, IMAGE_QUALITY);
imageFile->close();
@@ -210,9 +472,9 @@ void Snapshot::uploadSnapshot(const QString& filename, const QUrl& href) {
}
QString Snapshot::getSnapshotsLocation() {
- return snapshotsLocation.get("");
+ return _snapshotsLocation.get("");
}
void Snapshot::setSnapshotsLocation(const QString& location) {
- snapshotsLocation.set(location);
+ _snapshotsLocation.set(location);
}
diff --git a/interface/src/ui/Snapshot.h b/interface/src/ui/Snapshot.h
index 606313f3c3..2bac857a97 100644
--- a/interface/src/ui/Snapshot.h
+++ b/interface/src/ui/Snapshot.h
@@ -17,6 +17,8 @@
#include
#include
#include
+#include
+#include
#include
#include
@@ -34,28 +36,71 @@ private:
QUrl _URL;
};
+
+/**jsdoc
+ * @namespace Snapshot
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ */
+
class Snapshot : public QObject, public Dependency {
Q_OBJECT
SINGLETON_DEPENDENCY
public:
- static QString saveSnapshot(QImage image, const QString& filename, const QString& pathname = QString());
- static QTemporaryFile* saveTempSnapshot(QImage image);
- static SnapshotMetaData* parseSnapshotData(QString snapshotPath);
+ Snapshot();
+ QString saveSnapshot(QImage image, const QString& filename, const QString& pathname = QString());
+ void save360Snapshot(const glm::vec3& cameraPosition, const bool& cubemapOutputFormat, const QString& filename);
+ QTemporaryFile* saveTempSnapshot(QImage image);
+ SnapshotMetaData* parseSnapshotData(QString snapshotPath);
- static Setting::Handle snapshotsLocation;
- static void uploadSnapshot(const QString& filename, const QUrl& href = QUrl(""));
+ Setting::Handle _snapshotsLocation{ "snapshotsLocation" };
+ void uploadSnapshot(const QString& filename, const QUrl& href = QUrl(""));
signals:
+
+ /**jsdoc
+ * @function Snapshot.snapshotLocationSet
+ * @param {string} location
+ * @returns {Signal}
+ */
void snapshotLocationSet(const QString& value);
public slots:
+
+ /**jsdoc
+ * @function Snapshot.getSnapshotsLocation
+ * @returns {string}
+ */
Q_INVOKABLE QString getSnapshotsLocation();
+
+ /**jsdoc
+ * @function Snapshot.setSnapshotsLocation
+ * @param {String} location
+ */
Q_INVOKABLE void setSnapshotsLocation(const QString& location);
+
+private slots:
+ void takeNextSnapshot();
+
private:
- static QFile* savedFileForSnapshot(QImage& image,
+ QFile* savedFileForSnapshot(QImage& image,
bool isTemporary,
const QString& userSelectedFilename = QString(),
const QString& userSelectedPathname = QString());
+ QString _snapshotFilename;
+ bool _cubemapOutputFormat;
+ QTimer _snapshotTimer;
+ qint16 _snapshotIndex;
+ bool _oldEnabled;
+ QVariant _oldAttachedEntityId;
+ QVariant _oldOrientation;
+ QVariant _oldvFoV;
+ QVariant _oldNearClipPlaneDistance;
+ QVariant _oldFarClipPlaneDistance;
+ QImage _imageArray[6];
+ void convertToCubemap();
+ void convertToEquirectangular();
};
#endif // hifi_Snapshot_h
diff --git a/interface/src/ui/SnapshotAnimated.cpp b/interface/src/ui/SnapshotAnimated.cpp
index 7866e742d9..9d58d89385 100644
--- a/interface/src/ui/SnapshotAnimated.cpp
+++ b/interface/src/ui/SnapshotAnimated.cpp
@@ -103,18 +103,40 @@ void SnapshotAnimated::captureFrames() {
}
}
+void SnapshotAnimated::clearTempVariables() {
+ // Clear out the frame and frame delay vectors.
+ // Also release the memory not required to store the items.
+ SnapshotAnimated::snapshotAnimatedFrameVector.clear();
+ SnapshotAnimated::snapshotAnimatedFrameVector.squeeze();
+ SnapshotAnimated::snapshotAnimatedFrameDelayVector.clear();
+ SnapshotAnimated::snapshotAnimatedFrameDelayVector.squeeze();
+ // Reset the current frame timestamp
+ SnapshotAnimated::snapshotAnimatedTimestamp = 0;
+ SnapshotAnimated::snapshotAnimatedFirstFrameTimestamp = 0;
+}
+
void SnapshotAnimated::processFrames() {
uint32_t width = SnapshotAnimated::snapshotAnimatedFrameVector[0].width();
uint32_t height = SnapshotAnimated::snapshotAnimatedFrameVector[0].height();
// Create the GIF from the temporary files
// Write out the header and beginning of the GIF file
- GifBegin(
+ if (!GifBegin(
&(SnapshotAnimated::snapshotAnimatedGifWriter),
qPrintable(SnapshotAnimated::snapshotAnimatedPath),
width,
height,
- 1); // "1" means "yes there is a delay" with this GifCreator library.
+ 1)) { // "1" means "yes there is a delay" with this GifCreator library.
+
+ // We should never, ever get here. If we do, that means that writing a still JPG to the filesystem
+ // has succeeded, but that writing the tiny header to a GIF file in the same directory failed.
+ // If that happens, we _could_ throw up the "Folder Chooser" dialog like we do for still JPG images,
+ // but I have no way of testing whether or not that'll work or get properly exercised,
+ // so I'm not going to bother for now.
+ SnapshotAnimated::clearTempVariables();
+ qDebug() << "Animated snapshot header failed to write - aborting GIF processing.";
+ return;
+ }
for (int itr = 0; itr < SnapshotAnimated::snapshotAnimatedFrameVector.size(); itr++) {
// Write each frame to the GIF
GifWriteFrame(&(SnapshotAnimated::snapshotAnimatedGifWriter),
@@ -126,15 +148,7 @@ void SnapshotAnimated::processFrames() {
// Write out the end of the GIF
GifEnd(&(SnapshotAnimated::snapshotAnimatedGifWriter));
- // Clear out the frame and frame delay vectors.
- // Also release the memory not required to store the items.
- SnapshotAnimated::snapshotAnimatedFrameVector.clear();
- SnapshotAnimated::snapshotAnimatedFrameVector.squeeze();
- SnapshotAnimated::snapshotAnimatedFrameDelayVector.clear();
- SnapshotAnimated::snapshotAnimatedFrameDelayVector.squeeze();
- // Reset the current frame timestamp
- SnapshotAnimated::snapshotAnimatedTimestamp = 0;
- SnapshotAnimated::snapshotAnimatedFirstFrameTimestamp = 0;
+ SnapshotAnimated::clearTempVariables();
// Update the "Share" dialog with the processed GIF.
emit SnapshotAnimated::snapshotAnimatedDM->processingGifCompleted(SnapshotAnimated::snapshotAnimatedPath);
diff --git a/interface/src/ui/SnapshotAnimated.h b/interface/src/ui/SnapshotAnimated.h
index dd32e4893d..87ce533fc3 100644
--- a/interface/src/ui/SnapshotAnimated.h
+++ b/interface/src/ui/SnapshotAnimated.h
@@ -49,6 +49,7 @@ private:
static void captureFrames();
static void processFrames();
+ static void clearTempVariables();
public:
static void saveSnapshotAnimated(QString pathStill, float aspectRatio, Application* app, QSharedPointer dm);
static bool isAlreadyTakingSnapshotAnimated() { return snapshotAnimatedFirstFrameTimestamp != 0; };
diff --git a/interface/src/ui/Stats.cpp b/interface/src/ui/Stats.cpp
index d54faf8b28..9d86745341 100644
--- a/interface/src/ui/Stats.cpp
+++ b/interface/src/ui/Stats.cpp
@@ -354,6 +354,7 @@ void Stats::updateStats(bool force) {
STAT_UPDATE(gpuTextureResidentMemory, (int)BYTES_TO_MB(gpu::Context::getTextureResidentGPUMemSize()));
STAT_UPDATE(gpuTextureFramebufferMemory, (int)BYTES_TO_MB(gpu::Context::getTextureFramebufferGPUMemSize()));
STAT_UPDATE(gpuTextureResourceMemory, (int)BYTES_TO_MB(gpu::Context::getTextureResourceGPUMemSize()));
+ STAT_UPDATE(gpuTextureResourceIdealMemory, (int)BYTES_TO_MB(gpu::Context::getTextureResourceIdealGPUMemSize()));
STAT_UPDATE(gpuTextureResourcePopulatedMemory, (int)BYTES_TO_MB(gpu::Context::getTextureResourcePopulatedGPUMemSize()));
STAT_UPDATE(gpuTextureExternalMemory, (int)BYTES_TO_MB(gpu::Context::getTextureExternalGPUMemSize()));
#if !defined(Q_OS_ANDROID)
diff --git a/interface/src/ui/Stats.h b/interface/src/ui/Stats.h
index af3189f20b..36e923261d 100644
--- a/interface/src/ui/Stats.h
+++ b/interface/src/ui/Stats.h
@@ -23,6 +23,153 @@ private: \
type _##name{ initialValue };
+/**jsdoc
+ * @namespace Stats
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ * @hifi-server-entity
+ * @hifi-assignment-client
+ *
+ * @property {boolean} expanded
+ * @property {boolean} timingExpanded - Read-only.
+ * @property {string} monospaceFont - Read-only.
+ *
+ * @property {number} serverCount - Read-only.
+ * @property {number} renderrate - How often the app is creating new gpu::Frames. Read-only.
+ * @property {number} presentrate - How often the display plugin is presenting to the device. Read-only.
+ * @property {number} stutterrate - How often the display device is reprojecting old frames. Read-only.
+ *
+ * @property {number} appdropped - Read-only.
+ * @property {number} longsubmits - Read-only.
+ * @property {number} longrenders - Read-only.
+ * @property {number} longframes - Read-only.
+ *
+ * @property {number} presentnewrate - Read-only.
+ * @property {number} presentdroprate - Read-only.
+ * @property {number} gameLoopRate - Read-only.
+ * @property {number} avatarCount - Read-only.
+ * @property {number} updatedAvatarCount - Read-only.
+ * @property {number} notUpdatedAvatarCount - Read-only.
+ * @property {number} packetInCount - Read-only.
+ * @property {number} packetOutCount - Read-only.
+ * @property {number} mbpsIn - Read-only.
+ * @property {number} mbpsOut - Read-only.
+ * @property {number} assetMbpsIn - Read-only.
+ * @property {number} assetMbpsOut - Read-only.
+ * @property {number} audioPing - Read-only.
+ * @property {number} avatarPing - Read-only.
+ * @property {number} entitiesPing - Read-only.
+ * @property {number} assetPing - Read-only.
+ * @property {number} messagePing - Read-only.
+ * @property {Vec3} position - Read-only.
+ * @property {number} speed - Read-only.
+ * @property {number} yaw - Read-only.
+ * @property {number} avatarMixerInKbps - Read-only.
+ * @property {number} avatarMixerInPps - Read-only.
+ * @property {number} avatarMixerOutKbps - Read-only.
+ * @property {number} avatarMixerOutPps - Read-only.
+ * @property {number} myAvatarSendRate - Read-only.
+ *
+ * @property {number} audioMixerInKbps - Read-only.
+ * @property {number} audioMixerInPps - Read-only.
+ * @property {number} audioMixerOutKbps - Read-only.
+ * @property {number} audioMixerOutPps - Read-only.
+ * @property {number} audioMixerKbps - Read-only.
+ * @property {number} audioMixerPps - Read-only.
+ * @property {number} audioOutboundPPS - Read-only.
+ * @property {number} audioSilentOutboundPPS - Read-only.
+ * @property {number} audioAudioInboundPPS - Read-only.
+ * @property {number} audioSilentInboundPPS - Read-only.
+ * @property {number} audioPacketLoss - Read-only.
+ * @property {string} audioCodec - Read-only.
+ * @property {string} audioNoiseGate - Read-only.
+ * @property {number} entityPacketsInKbps - Read-only.
+ *
+ * @property {number} downloads - Read-only.
+ * @property {number} downloadLimit - Read-only.
+ * @property {number} downloadsPending - Read-only.
+ * @property {string[]} downloadUrls - Read-only.
+ * @property {number} processing - Read-only.
+ * @property {number} processingPending - Read-only.
+ * @property {number} triangles - Read-only.
+ * @property {number} quads - Read-only.
+ * @property {number} materialSwitches - Read-only.
+ * @property {number} itemConsidered - Read-only.
+ * @property {number} itemOutOfView - Read-only.
+ * @property {number} itemTooSmall - Read-only.
+ * @property {number} itemRendered - Read-only.
+ * @property {number} shadowConsidered - Read-only.
+ * @property {number} shadowOutOfView - Read-only.
+ * @property {number} shadowTooSmall - Read-only.
+ * @property {number} shadowRendered - Read-only.
+ * @property {string} sendingMode - Read-only.
+ * @property {string} packetStats - Read-only.
+ * @property {string} lodStatus - Read-only.
+ * @property {string} timingStats - Read-only.
+ * @property {string} gameUpdateStats - Read-only.
+ * @property {number} serverElements - Read-only.
+ * @property {number} serverInternal - Read-only.
+ * @property {number} serverLeaves - Read-only.
+ * @property {number} localElements - Read-only.
+ * @property {number} localInternal - Read-only.
+ * @property {number} localLeaves - Read-only.
+ * @property {number} rectifiedTextureCount - Read-only.
+ * @property {number} decimatedTextureCount - Read-only.
+ * @property {number} gpuBuffers - Read-only.
+ * @property {number} gpuBufferMemory - Read-only.
+ * @property {number} gpuTextures - Read-only.
+ * @property {number} glContextSwapchainMemory - Read-only.
+ * @property {number} qmlTextureMemory - Read-only.
+ * @property {number} texturePendingTransfers - Read-only.
+ * @property {number} gpuTextureMemory - Read-only.
+ * @property {number} gpuTextureResidentMemory - Read-only.
+ * @property {number} gpuTextureFramebufferMemory - Read-only.
+ * @property {number} gpuTextureResourceMemory - Read-only.
+ * @property {number} gpuTextureResourceIdealMemory - Read-only.
+ * @property {number} gpuTextureResourcePopulatedMemory - Read-only.
+ * @property {number} gpuTextureExternalMemory - Read-only.
+ * @property {string} gpuTextureMemoryPressureState - Read-only.
+ * @property {number} gpuFreeMemory - Read-only.
+ * @property {number} gpuFrameTime - Read-only.
+ * @property {number} batchFrameTime - Read-only.
+ * @property {number} engineFrameTime - Read-only.
+ * @property {number} avatarSimulationTime - Read-only.
+ *
+ *
+ * @property {number} x
+ * @property {number} y
+ * @property {number} z
+ * @property {number} width
+ * @property {number} height
+ *
+ * @property {number} opacity
+ * @property {boolean} enabled
+ * @property {boolean} visible
+ *
+ * @property {string} state
+ * @property {object} anchors - Read-only.
+ * @property {number} baselineOffset
+ *
+ * @property {boolean} clip
+ *
+ * @property {boolean} focus
+ * @property {boolean} activeFocus - Read-only.
+ * @property {boolean} activeFocusOnTab
+ *
+ * @property {number} rotation
+ * @property {number} scale
+ * @property {number} transformOrigin
+ *
+ * @property {boolean} smooth
+ * @property {boolean} antialiasing
+ * @property {number} implicitWidth
+ * @property {number} implicitHeight
+ *
+ * @property {object} layer - Read-only.
+ */
+// Properties from x onwards are QQuickItem properties.
+
class Stats : public QQuickItem {
Q_OBJECT
HIFI_QML_DECL
@@ -124,6 +271,7 @@ class Stats : public QQuickItem {
STATS_PROPERTY(int, gpuTextureResidentMemory, 0)
STATS_PROPERTY(int, gpuTextureFramebufferMemory, 0)
STATS_PROPERTY(int, gpuTextureResourceMemory, 0)
+ STATS_PROPERTY(int, gpuTextureResourceIdealMemory, 0)
STATS_PROPERTY(int, gpuTextureResourcePopulatedMemory, 0)
STATS_PROPERTY(int, gpuTextureExternalMemory, 0)
STATS_PROPERTY(QString, gpuTextureMemoryPressureState, QString())
@@ -161,105 +309,916 @@ public slots:
void forceUpdateStats() { updateStats(true); }
signals:
+
+ /**jsdoc
+ * Triggered when the value of the longsubmits property changes.
+ * @function Stats.longsubmitsChanged
+ * @returns {Signal}
+ */
void longsubmitsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the longrenders property changes.
+ * @function Stats.longrendersChanged
+ * @returns {Signal}
+ */
void longrendersChanged();
+
+ /**jsdoc
+ * Triggered when the value of the longframes property changes.
+ * @function Stats.longframesChanged
+ * @returns {Signal}
+ */
void longframesChanged();
+
+ /**jsdoc
+ * Triggered when the value of the appdropped property changes.
+ * @function Stats.appdroppedChanged
+ * @returns {Signal}
+ */
void appdroppedChanged();
+
+ /**jsdoc
+ * Triggered when the value of the expanded property changes.
+ * @function Stats.expandedChanged
+ * @returns {Signal}
+ */
void expandedChanged();
+
+ /**jsdoc
+ * Triggered when the value of the timingExpanded property changes.
+ * @function Stats.timingExpandedChanged
+ * @returns {Signal}
+ */
void timingExpandedChanged();
+
+ /**jsdoc
+ * Triggered when the value of the serverCount property changes.
+ * @function Stats.serverCountChanged
+ * @returns {Signal}
+ */
void serverCountChanged();
+
+ /**jsdoc
+ * Triggered when the value of the renderrate property changes.
+ * @function Stats.renderrateChanged
+ * @returns {Signal}
+ */
void renderrateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the presentrate property changes.
+ * @function Stats.presentrateChanged
+ * @returns {Signal}
+ */
void presentrateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the presentnewrate property changes.
+ * @function Stats.presentnewrateChanged
+ * @returns {Signal}
+ */
void presentnewrateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the presentdroprate property changes.
+ * @function Stats.presentdroprateChanged
+ * @returns {Signal}
+ */
void presentdroprateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the stutterrate property changes.
+ * @function Stats.stutterrateChanged
+ * @returns {Signal}
+ */
void stutterrateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gameLoopRate property changes.
+ * @function Stats.gameLoopRateChanged
+ * @returns {Signal}
+ */
void gameLoopRateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the avatarCount property changes.
+ * @function Stats.avatarCountChanged
+ * @returns {Signal}
+ */
void avatarCountChanged();
+
+ /**jsdoc
+ * Triggered when the value of the updatedAvatarCount property changes.
+ * @function Stats.updatedAvatarCountChanged
+ * @returns {Signal}
+ */
void updatedAvatarCountChanged();
+
+ /**jsdoc
+ * Triggered when the value of the notUpdatedAvatarCount property changes.
+ * @function Stats.notUpdatedAvatarCountChanged
+ * @returns {Signal}
+ */
void notUpdatedAvatarCountChanged();
+
+ /**jsdoc
+ * Triggered when the value of the packetInCount property changes.
+ * @function Stats.packetInCountChanged
+ * @returns {Signal}
+ */
void packetInCountChanged();
+
+ /**jsdoc
+ * Triggered when the value of the packetOutCount property changes.
+ * @function Stats.packetOutCountChanged
+ * @returns {Signal}
+ */
void packetOutCountChanged();
+
+ /**jsdoc
+ * Triggered when the value of the mbpsIn property changes.
+ * @function Stats.mbpsInChanged
+ * @returns {Signal}
+ */
void mbpsInChanged();
+
+ /**jsdoc
+ * Triggered when the value of the mbpsOut property changes.
+ * @function Stats.mbpsOutChanged
+ * @returns {Signal}
+ */
void mbpsOutChanged();
+
+ /**jsdoc
+ * Triggered when the value of the assetMbpsIn property changes.
+ * @function Stats.assetMbpsInChanged
+ * @returns {Signal}
+ */
void assetMbpsInChanged();
+
+ /**jsdoc
+ * Triggered when the value of the assetMbpsOut property changes.
+ * @function Stats.assetMbpsOutChanged
+ * @returns {Signal}
+ */
void assetMbpsOutChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioPing property changes.
+ * @function Stats.audioPingChanged
+ * @returns {Signal}
+ */
void audioPingChanged();
+
+ /**jsdoc
+ * Triggered when the value of the avatarPing property changes.
+ * @function Stats.avatarPingChanged
+ * @returns {Signal}
+ */
void avatarPingChanged();
+
+ /**jsdoc
+ * Triggered when the value of the entitiesPing property changes.
+ * @function Stats.entitiesPingChanged
+ * @returns {Signal}
+ */
void entitiesPingChanged();
+
+ /**jsdoc
+ * Triggered when the value of the assetPing property changes.
+ * @function Stats.assetPingChanged
+ * @returns {Signal}
+ */
void assetPingChanged();
+
+ /**jsdoc
+ * Triggered when the value of the messagePing property changes.
+ * @function Stats.messagePingChanged
+ * @returns {Signal}
+ */
void messagePingChanged();
+
+ /**jsdoc
+ * Triggered when the value of the position property changes.
+ * @function Stats.positionChanged
+ * @returns {Signal}
+ */
void positionChanged();
+
+ /**jsdoc
+ * Triggered when the value of the speed property changes.
+ * @function Stats.speedChanged
+ * @returns {Signal}
+ */
void speedChanged();
+
+ /**jsdoc
+ * Triggered when the value of the yaw property changes.
+ * @function Stats.yawChanged
+ * @returns {Signal}
+ */
void yawChanged();
+
+ /**jsdoc
+ * Triggered when the value of the avatarMixerInKbps property changes.
+ * @function Stats.avatarMixerInKbpsChanged
+ * @returns {Signal}
+ */
void avatarMixerInKbpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the avatarMixerInPps property changes.
+ * @function Stats.avatarMixerInPpsChanged
+ * @returns {Signal}
+ */
void avatarMixerInPpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the avatarMixerOutKbps property changes.
+ * @function Stats.avatarMixerOutKbpsChanged
+ * @returns {Signal}
+ */
void avatarMixerOutKbpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the avatarMixerOutPps property changes.
+ * @function Stats.avatarMixerOutPpsChanged
+ * @returns {Signal}
+ */
void avatarMixerOutPpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the myAvatarSendRate property changes.
+ * @function Stats.myAvatarSendRateChanged
+ * @returns {Signal}
+ */
void myAvatarSendRateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioMixerInKbps property changes.
+ * @function Stats.audioMixerInKbpsChanged
+ * @returns {Signal}
+ */
void audioMixerInKbpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioMixerInPps property changes.
+ * @function Stats.audioMixerInPpsChanged
+ * @returns {Signal}
+ */
void audioMixerInPpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioMixerOutKbps property changes.
+ * @function Stats.audioMixerOutKbpsChanged
+ * @returns {Signal}
+ */
void audioMixerOutKbpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioMixerOutPps property changes.
+ * @function Stats.audioMixerOutPpsChanged
+ * @returns {Signal}
+ */
void audioMixerOutPpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioMixerKbps property changes.
+ * @function Stats.audioMixerKbpsChanged
+ * @returns {Signal}
+ */
void audioMixerKbpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioMixerPps property changes.
+ * @function Stats.audioMixerPpsChanged
+ * @returns {Signal}
+ */
void audioMixerPpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioOutboundPPS property changes.
+ * @function Stats.audioOutboundPPSChanged
+ * @returns {Signal}
+ */
void audioOutboundPPSChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioSilentOutboundPPS property changes.
+ * @function Stats.audioSilentOutboundPPSChanged
+ * @returns {Signal}
+ */
void audioSilentOutboundPPSChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioAudioInboundPPS property changes.
+ * @function Stats.audioAudioInboundPPSChanged
+ * @returns {Signal}
+ */
void audioAudioInboundPPSChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioSilentInboundPPS property changes.
+ * @function Stats.audioSilentInboundPPSChanged
+ * @returns {Signal}
+ */
void audioSilentInboundPPSChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioPacketLoss property changes.
+ * @function Stats.audioPacketLossChanged
+ * @returns {Signal}
+ */
void audioPacketLossChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioCodec property changes.
+ * @function Stats.audioCodecChanged
+ * @returns {Signal}
+ */
void audioCodecChanged();
+
+ /**jsdoc
+ * Triggered when the value of the audioNoiseGate property changes.
+ * @function Stats.audioNoiseGateChanged
+ * @returns {Signal}
+ */
void audioNoiseGateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the entityPacketsInKbps property changes.
+ * @function Stats.entityPacketsInKbpsChanged
+ * @returns {Signal}
+ */
void entityPacketsInKbpsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the downloads property changes.
+ * @function Stats.downloadsChanged
+ * @returns {Signal}
+ */
void downloadsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the downloadLimit property changes.
+ * @function Stats.downloadLimitChanged
+ * @returns {Signal}
+ */
void downloadLimitChanged();
+
+ /**jsdoc
+ * Triggered when the value of the downloadsPending property changes.
+ * @function Stats.downloadsPendingChanged
+ * @returns {Signal}
+ */
void downloadsPendingChanged();
+
+ /**jsdoc
+ * Triggered when the value of the downloadUrls property changes.
+ * @function Stats.downloadUrlsChanged
+ * @returns {Signal}
+ */
void downloadUrlsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the processing property changes.
+ * @function Stats.processingChanged
+ * @returns {Signal}
+ */
void processingChanged();
+
+ /**jsdoc
+ * Triggered when the value of the processingPending property changes.
+ * @function Stats.processingPendingChanged
+ * @returns {Signal}
+ */
void processingPendingChanged();
+
+ /**jsdoc
+ * Triggered when the value of the triangles property changes.
+ * @function Stats.trianglesChanged
+ * @returns {Signal}
+ */
void trianglesChanged();
+
+ /**jsdoc
+ * Triggered when the value of the quads property changes.
+ * @function Stats.quadsChanged
+ * @returns {Signal}
+ */
void quadsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the materialSwitches property changes.
+ * @function Stats.materialSwitchesChanged
+ * @returns {Signal}
+ */
void materialSwitchesChanged();
+
+ /**jsdoc
+ * Triggered when the value of the itemConsidered property changes.
+ * @function Stats.itemConsideredChanged
+ * @returns {Signal}
+ */
void itemConsideredChanged();
+
+ /**jsdoc
+ * Triggered when the value of the itemOutOfView property changes.
+ * @function Stats.itemOutOfViewChanged
+ * @returns {Signal}
+ */
void itemOutOfViewChanged();
+
+ /**jsdoc
+ * Triggered when the value of the itemTooSmall property changes.
+ * @function Stats.itemTooSmallChanged
+ * @returns {Signal}
+ */
void itemTooSmallChanged();
+
+ /**jsdoc
+ * Triggered when the value of the itemRendered property changes.
+ * @function Stats.itemRenderedChanged
+ * @returns {Signal}
+ */
void itemRenderedChanged();
+
+ /**jsdoc
+ * Triggered when the value of the shadowConsidered property changes.
+ * @function Stats.shadowConsideredChanged
+ * @returns {Signal}
+ */
void shadowConsideredChanged();
+
+ /**jsdoc
+ * Triggered when the value of the shadowOutOfView property changes.
+ * @function Stats.shadowOutOfViewChanged
+ * @returns {Signal}
+ */
void shadowOutOfViewChanged();
+
+ /**jsdoc
+ * Triggered when the value of the shadowTooSmall property changes.
+ * @function Stats.shadowTooSmallChanged
+ * @returns {Signal}
+ */
void shadowTooSmallChanged();
+
+ /**jsdoc
+ * Triggered when the value of the shadowRendered property changes.
+ * @function Stats.shadowRenderedChanged
+ * @returns {Signal}
+ */
void shadowRenderedChanged();
+
+ /**jsdoc
+ * Triggered when the value of the sendingMode property changes.
+ * @function Stats.sendingModeChanged
+ * @returns {Signal}
+ */
void sendingModeChanged();
+
+ /**jsdoc
+ * Triggered when the value of the packetStats property changes.
+ * @function Stats.packetStatsChanged
+ * @returns {Signal}
+ */
void packetStatsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the lodStatus property changes.
+ * @function Stats.lodStatusChanged
+ * @returns {Signal}
+ */
void lodStatusChanged();
+
+ /**jsdoc
+ * Triggered when the value of the serverElements property changes.
+ * @function Stats.serverElementsChanged
+ * @returns {Signal}
+ */
void serverElementsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the serverInternal property changes.
+ * @function Stats.serverInternalChanged
+ * @returns {Signal}
+ */
void serverInternalChanged();
+
+ /**jsdoc
+ * Triggered when the value of the serverLeaves property changes.
+ * @function Stats.serverLeavesChanged
+ * @returns {Signal}
+ */
void serverLeavesChanged();
+
+ /**jsdoc
+ * Triggered when the value of the localElements property changes.
+ * @function Stats.localElementsChanged
+ * @returns {Signal}
+ */
void localElementsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the localInternal property changes.
+ * @function Stats.localInternalChanged
+ * @returns {Signal}
+ */
void localInternalChanged();
+
+ /**jsdoc
+ * Triggered when the value of the localLeaves property changes.
+ * @function Stats.localLeavesChanged
+ * @returns {Signal}
+ */
void localLeavesChanged();
+
+ /**jsdoc
+ * Triggered when the value of the timingStats property changes.
+ * @function Stats.timingStatsChanged
+ * @returns {Signal}
+ */
void timingStatsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gameUpdateStats property changes.
+ * @function Stats.gameUpdateStatsChanged
+ * @returns {Signal}
+ */
void gameUpdateStatsChanged();
+
+ /**jsdoc
+ * Triggered when the value of the glContextSwapchainMemory property changes.
+ * @function Stats.glContextSwapchainMemoryChanged
+ * @returns {Signal}
+ */
void glContextSwapchainMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the qmlTextureMemory property changes.
+ * @function Stats.qmlTextureMemoryChanged
+ * @returns {Signal}
+ */
void qmlTextureMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the texturePendingTransfers property changes.
+ * @function Stats.texturePendingTransfersChanged
+ * @returns {Signal}
+ */
void texturePendingTransfersChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuBuffers property changes.
+ * @function Stats.gpuBuffersChanged
+ * @returns {Signal}
+ */
void gpuBuffersChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuBufferMemory property changes.
+ * @function Stats.gpuBufferMemoryChanged
+ * @returns {Signal}
+ */
void gpuBufferMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextures property changes.
+ * @function Stats.gpuTexturesChanged
+ * @returns {Signal}
+ */
void gpuTexturesChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextureMemory property changes.
+ * @function Stats.gpuTextureMemoryChanged
+ * @returns {Signal}
+ */
void gpuTextureMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextureResidentMemory property changes.
+ * @function Stats.gpuTextureResidentMemoryChanged
+ * @returns {Signal}
+ */
void gpuTextureResidentMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextureFramebufferMemory property changes.
+ * @function Stats.gpuTextureFramebufferMemoryChanged
+ * @returns {Signal}
+ */
void gpuTextureFramebufferMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextureResourceMemory property changes.
+ * @function Stats.gpuTextureResourceMemoryChanged
+ * @returns {Signal}
+ */
void gpuTextureResourceMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextureResourceIdealMemory property changes.
+ * @function Stats.gpuTextureResourceIdealMemoryChanged
+ * @returns {Signal}
+ */
+ void gpuTextureResourceIdealMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextureResourcePopulatedMemory property changes.
+ * @function Stats.gpuTextureResourcePopulatedMemoryChanged
+ * @returns {Signal}
+ */
void gpuTextureResourcePopulatedMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextureExternalMemory property changes.
+ * @function Stats.gpuTextureExternalMemoryChanged
+ * @returns {Signal}
+ */
void gpuTextureExternalMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuTextureMemoryPressureState property changes.
+ * @function Stats.gpuTextureMemoryPressureStateChanged
+ * @returns {Signal}
+ */
void gpuTextureMemoryPressureStateChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuFreeMemory property changes.
+ * @function Stats.gpuFreeMemoryChanged
+ * @returns {Signal}
+ */
void gpuFreeMemoryChanged();
+
+ /**jsdoc
+ * Triggered when the value of the gpuFrameTime property changes.
+ * @function Stats.gpuFrameTimeChanged
+ * @returns {Signal}
+ */
void gpuFrameTimeChanged();
+
+ /**jsdoc
+ * Triggered when the value of the batchFrameTime property changes.
+ * @function Stats.batchFrameTimeChanged
+ * @returns {Signal}
+ */
void batchFrameTimeChanged();
+
+ /**jsdoc
+ * Triggered when the value of the engineFrameTime property changes.
+ * @function Stats.engineFrameTimeChanged
+ * @returns {Signal}
+ */
void engineFrameTimeChanged();
+
+ /**jsdoc
+ * Triggered when the value of the avatarSimulationTime property changes.
+ * @function Stats.avatarSimulationTimeChanged
+ * @returns {Signal}
+ */
void avatarSimulationTimeChanged();
+
+ /**jsdoc
+ * Triggered when the value of the rectifiedTextureCount property changes.
+ * @function Stats.rectifiedTextureCountChanged
+ * @returns {Signal}
+ */
void rectifiedTextureCountChanged();
+
+ /**jsdoc
+ * Triggered when the value of the decimatedTextureCount property changes.
+ * @function Stats.decimatedTextureCountChanged
+ * @returns {Signal}
+ */
void decimatedTextureCountChanged();
+
+ // QQuickItem signals.
+
+ /**jsdoc
+ * Triggered when the parent item changes.
+ * @function Stats.parentChanged
+ * @param {object} parent
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the x property changes.
+ * @function Stats.xChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the y property changes.
+ * @function Stats.yChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the z property changes.
+ * @function Stats.zChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the width property changes.
+ * @function Stats.widthChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the height property changes.
+ * @function Stats.heightChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the opacity property changes.
+ * @function Stats.opacityChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the enabled property changes.
+ * @function Stats.enabledChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the visibleChanged property changes.
+ * @function Stats.visibleChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the list of visible children changes.
+ * @function Stats.visibleChildrenChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the state property changes.
+ * @function Stats.stateChanged
+ * @paramm {string} state
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the position and size of the rectangle containing the children changes.
+ * @function Stats.childrenRectChanged
+ * @param {Rect} childrenRect
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the baselineOffset property changes.
+ * @function Stats.baselineOffsetChanged
+ * @param {number} baselineOffset
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the clip property changes.
+ * @function Stats.clipChanged
+ * @param {boolean} clip
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the focus property changes.
+ * @function Stats.focusChanged
+ * @param {boolean} focus
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the activeFocus property changes.
+ * @function Stats.activeFocusChanged
+ * @param {boolean} activeFocus
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the activeFocusOnTab property changes.
+ * @function Stats.activeFocusOnTabChanged
+ * @param {boolean} activeFocusOnTab
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the rotation property changes.
+ * @function Stats.rotationChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the scaleChanged property changes.
+ * @function Stats.scaleChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the transformOrigin property changes.
+ * @function Stats.transformOriginChanged
+ * @param {number} transformOrigin
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the smooth property changes.
+ * @function Stats.smoothChanged
+ * @param {boolean} smooth
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the antialiasing property changes.
+ * @function Stats.antialiasingChanged
+ * @param {boolean} antialiasing
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the implicitWidth property changes.
+ * @function Stats.implicitWidthChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * Triggered when the value of the implicitHeight property changes.
+ * @function Stats.implicitHeightChanged
+ * @returns {Signal}
+ */
+
+ /**jsdoc
+ * @function Stats.windowChanged
+ * @param {object} window
+ * @returns {Signal}
+ */
+
+
+ // QQuickItem functions.
+
+ /**jsdoc
+ * @function Stats.grabToImage
+ * @param {object} callback
+ * @param {Size} [targetSize=0,0]
+ * @returns {boolean}
+ */
+
+ /**jsdoc
+ * @function Stats.contains
+ * @param {Vec2} point
+ * @returns {boolean}
+ */
+
+ /**jsdoc
+ * @function Stats.mapFromItem
+ * @param {object} item
+ */
+
+ /**jsdoc
+ * @function Stats.mapToItem
+ * @param {object} item
+ */
+
+ /**jsdoc
+ * @function Stats.mapFromGlobal
+ * @param {object} global
+ */
+
+ /**jsdoc
+ * @function Stats.mapToGlobal
+ * @param {object} global
+ */
+
+ /**jsdoc
+ * @function Stats.forceActiveFocus
+ * @param {number} [reason=7]
+ */
+
+ /**jsdoc
+ * @function Stats.nextItemInFocusChain
+ * @param {boolean} [forward=true]
+ * @returns {object}
+ */
+
+ /**jsdoc
+ * @function Stats.childAt
+ * @param {number} x
+ * @param {number} y
+ * @returns {object}
+ */
+
+ /**jsdoc
+ * @function Stats.update
+ */
+
private:
int _recentMaxPackets{ 0 } ; // recent max incoming voxel packets to process
bool _resetRecentMaxPacketsSoon{ true };
diff --git a/interface/src/ui/overlays/Overlays.cpp b/interface/src/ui/overlays/Overlays.cpp
index 6556cedb21..85041aad4e 100644
--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/interface/src/ui/overlays/Overlays.cpp
@@ -118,7 +118,7 @@ void Overlays::renderHUD(RenderArgs* renderArgs) {
auto geometryCache = DependencyManager::get();
auto textureCache = DependencyManager::get();
- auto size = qApp->getUiSize();
+ auto size = glm::uvec2(glm::vec2(qApp->getUiSize()) * qApp->getRenderResolutionScale());
int width = size.x;
int height = size.y;
mat4 legacyProjection = glm::ortho(0, width, height, 0, -1000, 1000);
diff --git a/interface/src/ui/overlays/Overlays.h b/interface/src/ui/overlays/Overlays.h
index cf1151b46a..3ff782da99 100644
--- a/interface/src/ui/overlays/Overlays.h
+++ b/interface/src/ui/overlays/Overlays.h
@@ -60,7 +60,7 @@ public:
bool intersects { false };
OverlayID overlayID { UNKNOWN_OVERLAY_ID };
float distance { 0 };
- BoxFace face;
+ BoxFace face { UNKNOWN_FACE };
glm::vec3 surfaceNormal;
glm::vec3 intersection;
QVariantMap extraInfo;
diff --git a/libraries/audio/src/AudioEffectOptions.cpp b/libraries/audio/src/AudioEffectOptions.cpp
index 9d3ce9299b..edb0ff52ae 100644
--- a/libraries/audio/src/AudioEffectOptions.cpp
+++ b/libraries/audio/src/AudioEffectOptions.cpp
@@ -58,6 +58,30 @@ static void setOption(QScriptValue arguments, const QString name, float defaultV
variable = arguments.property(name).isNumber() ? (float)arguments.property(name).toNumber() : defaultValue;
}
+/**jsdoc
+ * @typedef {object} AudioEffectOptions.ReverbOptions
+ * @property {number} bandwidth
+ * @property {number} preDelay
+ * @property {number} lateDelay
+ * @property {number} reverbTime
+ * @property {number} earlyDiffusion
+ * @property {number} lateDiffusion
+ * @property {number} roomSize
+ * @property {number} density
+ * @property {number} bassMult
+ * @property {number} bassFreq
+ * @property {number} highGain
+ * @property {number} highFreq
+ * @property {number} modRate
+ * @property {number} modDepth
+ * @property {number} earlyGain
+ * @property {number} lateGain
+ * @property {number} earlyMixLeft
+ * @property {number} earlyMixRight
+ * @property {number} lateMixLeft
+ * @property {number} lateMixRight
+ * @property {number} wetDryMix
+ */
AudioEffectOptions::AudioEffectOptions(QScriptValue arguments) {
setOption(arguments, BANDWIDTH_HANDLE, BANDWIDTH_DEFAULT, _bandwidth);
setOption(arguments, PRE_DELAY_HANDLE, PRE_DELAY_DEFAULT, _preDelay);
diff --git a/libraries/audio/src/AudioEffectOptions.h b/libraries/audio/src/AudioEffectOptions.h
index 9a65301473..1afd4e21be 100644
--- a/libraries/audio/src/AudioEffectOptions.h
+++ b/libraries/audio/src/AudioEffectOptions.h
@@ -15,6 +15,38 @@
#include
#include
+/**jsdoc
+ * @class AudioEffectOptions
+ * @param {AudioEffectOptions.ReverbOptions} [reverbOptions=null]
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ * @hifi-server-entity
+ * @hifi-assignment-client
+ *
+ * @property {number} bandwidth=10000
+ * @property {number} preDelay=20
+ * @property {number} lateDelay=0
+ * @property {number} reverbTime=2
+ * @property {number} earlyDiffusion=100
+ * @property {number} lateDiffusion=100
+ * @property {number} roomSize=50
+ * @property {number} density=100
+ * @property {number} bassMult=1.5
+ * @property {number} bassFreq=250
+ * @property {number} highGain=-6
+ * @property {number} highFreq=3000
+ * @property {number} modRate=2.3
+ * @property {number} modDepth=50
+ * @property {number} earlyGain=0
+ * @property {number} lateGain=0
+ * @property {number} earlyMixLeft=20
+ * @property {number} earlyMixRight=20
+ * @property {number} lateMixLeft=90
+ * @property {number} lateMixRight=90
+ * @property {number} wetDryMix=50
+ */
+
class AudioEffectOptions : public QObject {
Q_OBJECT
diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
index 048b8b1633..da829b23e4 100644
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
+++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
@@ -799,7 +799,6 @@ bool Avatar::shouldRenderHead(const RenderArgs* renderArgs) const {
return true;
}
-// virtual
void Avatar::simulateAttachments(float deltaTime) {
assert(_attachmentModels.size() == _attachmentModelsTexturesLoaded.size());
PerformanceTimer perfTimer("attachments");
@@ -1482,12 +1481,14 @@ void Avatar::updateDisplayNameAlpha(bool showDisplayName) {
}
}
-// virtual
void Avatar::computeShapeInfo(ShapeInfo& shapeInfo) {
float uniformScale = getModelScale();
- shapeInfo.setCapsuleY(uniformScale * _skeletonModel->getBoundingCapsuleRadius(),
- 0.5f * uniformScale * _skeletonModel->getBoundingCapsuleHeight());
- shapeInfo.setOffset(uniformScale * _skeletonModel->getBoundingCapsuleOffset());
+ float radius = uniformScale * _skeletonModel->getBoundingCapsuleRadius();
+ float height = uniformScale * _skeletonModel->getBoundingCapsuleHeight();
+ shapeInfo.setCapsuleY(radius, 0.5f * height);
+
+ glm::vec3 offset = uniformScale * _skeletonModel->getBoundingCapsuleOffset();
+ shapeInfo.setOffset(offset);
}
void Avatar::getCapsule(glm::vec3& start, glm::vec3& end, float& radius) {
@@ -1510,9 +1511,8 @@ float Avatar::computeMass() {
return _density * TWO_PI * radius * radius * (glm::length(end - start) + 2.0f * radius / 3.0f);
}
-// virtual
void Avatar::rebuildCollisionShape() {
- addPhysicsFlags(Simulation::DIRTY_SHAPE);
+ addPhysicsFlags(Simulation::DIRTY_SHAPE | Simulation::DIRTY_MASS);
}
void Avatar::setPhysicsCallback(AvatarPhysicsCallback cb) {
diff --git a/libraries/avatars/src/AvatarData.cpp b/libraries/avatars/src/AvatarData.cpp
index db38999481..7a28686f8c 100644
--- a/libraries/avatars/src/AvatarData.cpp
+++ b/libraries/avatars/src/AvatarData.cpp
@@ -2363,7 +2363,7 @@ glm::vec3 AvatarData::getAbsoluteJointTranslationInObjectFrame(int index) const
}
/**jsdoc
- * @typedef MyAvatar.AttachmentData
+ * @typedef AttachmentData
* @property {string} modelUrl
* @property {string} jointName
* @property {Vec3} translation
diff --git a/libraries/avatars/src/AvatarData.h b/libraries/avatars/src/AvatarData.h
index bbcdd3693d..62a14ec51e 100644
--- a/libraries/avatars/src/AvatarData.h
+++ b/libraries/avatars/src/AvatarData.h
@@ -351,7 +351,7 @@ public:
class AvatarData : public QObject, public SpatiallyNestable {
Q_OBJECT
- // The following properties have JSDoc in MyAvatar.h.
+ // The following properties have JSDoc in MyAvatar.h and ScriptableAvatar.h
Q_PROPERTY(glm::vec3 position READ getWorldPosition WRITE setPositionViaScript)
Q_PROPERTY(float scale READ getTargetScale WRITE setTargetScale)
Q_PROPERTY(float density READ getDensity)
@@ -502,7 +502,7 @@ public:
float getDomainLimitedScale() const;
/**jsdoc
- * returns the minimum scale allowed for this avatar in the current domain.
+ * Returns the minimum scale allowed for this avatar in the current domain.
* This value can change as the user changes avatars or when changing domains.
* @function MyAvatar.getDomainMinScale
* @returns {number} minimum scale allowed for this avatar in the current domain.
@@ -510,14 +510,14 @@ public:
Q_INVOKABLE float getDomainMinScale() const;
/**jsdoc
- * returns the maximum scale allowed for this avatar in the current domain.
+ * Returns the maximum scale allowed for this avatar in the current domain.
* This value can change as the user changes avatars or when changing domains.
* @function MyAvatar.getDomainMaxScale
* @returns {number} maximum scale allowed for this avatar in the current domain.
*/
Q_INVOKABLE float getDomainMaxScale() const;
- // returns eye height of avatar in meters, ignoreing avatar scale.
+ // Returns eye height of avatar in meters, ignoring avatar scale.
// if _targetScale is 1 then this will be identical to getEyeHeight;
virtual float getUnscaledEyeHeight() const { return DEFAULT_AVATAR_EYE_HEIGHT; }
@@ -775,7 +775,7 @@ public:
* Get the rotations of all joints in the current avatar. Each joint's rotation is relative to its parent joint.
* @function MyAvatar.getJointRotations
* @returns {Quat[]} The rotations of all joints relative to each's parent. The values are in the same order as the array
- * returned by {@link MyAvatar.getJointNames}.
+ * returned by {@link MyAvatar.getJointNames} or {@link Avatar.getJointNames}.
* @example Report the rotations of all your avatar's joints.
* print(JSON.stringify(MyAvatar.getJointRotations()));
*/
@@ -796,7 +796,7 @@ public:
* the rotation of the elbow, the hand inverse kinematics position won't end up in the right place.
* @function MyAvatar.setJointRotations
* @param {Quat[]} jointRotations - The rotations for all joints in the avatar. The values are in the same order as the
- * array returned by {@link MyAvatar.getJointNames}.
+ * array returned by {@link MyAvatar.getJointNames} or {@link Avatar.getJointNames}.
* @example Set your avatar to its default T-pose then rotate its right arm.
* 
*
@@ -852,7 +852,7 @@ public:
/**jsdoc
* Get the joint index for a named joint. The joint index value is the position of the joint in the array returned by
- * {@link MyAvatar.getJointNames}.
+ * {@link MyAvatar.getJointNames} or {@link Avatar.getJointNames}.
* @function MyAvatar.getJointIndex
* @param {string} name - The name of the joint.
* @returns {number} The index of the joint.
@@ -952,7 +952,7 @@ public:
/**jsdoc
* Get information about all models currently attached to your avatar.
* @function MyAvatar.getAttachmentData
- * @returns {MyAvatar.AttachmentData[]} Information about all models attached to your avatar.
+ * @returns {AttachmentData[]} Information about all models attached to your avatar.
* @example Report the URLs of all current attachments.
* var attachments = MyAvatar.getaAttachmentData();
* for (var i = 0; i < attachments.length; i++) {
@@ -963,10 +963,10 @@ public:
/**jsdoc
* Set all models currently attached to your avatar. For example, if you retrieve attachment data using
- * {@link MyAvatar.getAttachmentData}, make changes to it, and then want to update your avatar's attachments per the
+ * {@link MyAvatar.getAttachmentData} or {@link Avatar.getAttachmentData}, make changes to it, and then want to update your avatar's attachments per the
* changed data. You can also remove all attachments by using setting attachmentData to null.
* @function MyAvatar.setAttachmentData
- * @param {MyAvatar.AttachmentData[]} attachmentData - The attachment data defining the models to have attached to your avatar. Use
+ * @param {AttachmentData[]} attachmentData - The attachment data defining the models to have attached to your avatar. Use
* null to remove all attachments.
* @example Remove a hat attachment if your avatar is wearing it.
* var hatURL = "https://s3.amazonaws.com/hifi-public/tony/cowboy-hat.fbx";
@@ -989,7 +989,7 @@ public:
* Nor can you use this function to attach an entity (such as a sphere or a box) to your avatar.
* @function MyAvatar.attach
* @param {string} modelURL - The URL of the model to attach. Models can be .FBX or .OBJ format.
- * @param {string} [jointName=""] - The name of the avatar joint (see {@link MyAvatar.getJointNames}) to attach the model
+ * @param {string} [jointName=""] - The name of the avatar joint (see {@link MyAvatar.getJointNames} or {@link Avatar.getJointNames}) to attach the model
* to.
* @param {Vec3} [translation=Vec3.ZERO] - The offset to apply to the model relative to the joint position.
* @param {Quat} [rotation=Quat.IDENTITY] - The rotation to apply to the model relative to the joint orientation.
diff --git a/libraries/avatars/src/AvatarHashMap.h b/libraries/avatars/src/AvatarHashMap.h
index dc3f40c5d3..6747025de0 100644
--- a/libraries/avatars/src/AvatarHashMap.h
+++ b/libraries/avatars/src/AvatarHashMap.h
@@ -30,6 +30,15 @@
#include "AvatarData.h"
+/**jsdoc
+ * Note: An AvatarList API is also provided for Interface and client entity scripts: it is a
+ * synonym for the {@link AvatarManager} API.
+ *
+ * @namespace AvatarList
+ *
+ * @hifi-assignment-client
+ */
+
class AvatarHashMap : public QObject, public Dependency {
Q_OBJECT
SINGLETON_DEPENDENCY
@@ -42,20 +51,24 @@ public:
// Currently, your own avatar will be included as the null avatar id.
/**jsdoc
- * @function AvatarManager.getAvatarIdentifiers
+ * @function AvatarList.getAvatarIdentifiers
* @returns {Uuid[]}
*/
Q_INVOKABLE QVector getAvatarIdentifiers();
/**jsdoc
- * @function AvatarManager.getAvatarsInRange
+ * @function AvatarList.getAvatarsInRange
* @param {Vec3} position
* @param {number} range
* @returns {Uuid[]}
*/
Q_INVOKABLE QVector getAvatarsInRange(const glm::vec3& position, float rangeMeters) const;
- // No JSDod because it's documwented in AvatarManager.
+ /**jsdoc
+ * @function AvatarList.getAvatar
+ * @param {Uuid} avatarID
+ * @returns {AvatarData}
+ */
// Null/Default-constructed QUuids will return MyAvatar
Q_INVOKABLE virtual ScriptAvatarData* getAvatar(QUuid avatarID) { return new ScriptAvatarData(getAvatarBySessionID(avatarID)); }
@@ -65,21 +78,21 @@ public:
signals:
/**jsdoc
- * @function AvatarManager.avatarAddedEvent
+ * @function AvatarList.avatarAddedEvent
* @param {Uuid} sessionUUID
* @returns {Signal}
*/
void avatarAddedEvent(const QUuid& sessionUUID);
/**jsdoc
- * @function AvatarManager.avatarRemovedEvent
+ * @function AvatarList.avatarRemovedEvent
* @param {Uuid} sessionUUID
* @returns {Signal}
*/
void avatarRemovedEvent(const QUuid& sessionUUID);
/**jsdoc
- * @function AvatarManager.avatarSessionChangedEvent
+ * @function AvatarList.avatarSessionChangedEvent
* @param {Uuid} sessionUUID
* @param {Uuid} oldSessionUUID
* @returns {Signal}
@@ -89,7 +102,7 @@ signals:
public slots:
/**jsdoc
- * @function AvatarManager.isAvatarInRange
+ * @function AvatarList.isAvatarInRange
* @param {string} position
* @param {string} range
* @returns {boolean}
@@ -99,28 +112,28 @@ public slots:
protected slots:
/**jsdoc
- * @function AvatarManager.sessionUUIDChanged
+ * @function AvatarList.sessionUUIDChanged
* @param {Uuid} sessionUUID
* @param {Uuid} oldSessionUUID
*/
void sessionUUIDChanged(const QUuid& sessionUUID, const QUuid& oldUUID);
/**jsdoc
- * @function AvatarManager.processAvatarDataPacket
+ * @function AvatarList.processAvatarDataPacket
* @param {} message
* @param {} sendingNode
*/
void processAvatarDataPacket(QSharedPointer message, SharedNodePointer sendingNode);
/**jsdoc
- * @function AvatarManager.processAvatarIdentityPacket
+ * @function AvatarList.processAvatarIdentityPacket
* @param {} message
* @param {} sendingNode
*/
void processAvatarIdentityPacket(QSharedPointer message, SharedNodePointer sendingNode);
/**jsdoc
- * @function AvatarManager.processKillAvatar
+ * @function AvatarList.processKillAvatar
* @param {} message
* @param {} sendingNode
*/
diff --git a/libraries/display-plugins/src/display-plugins/Basic2DWindowOpenGLDisplayPlugin.cpp b/libraries/display-plugins/src/display-plugins/Basic2DWindowOpenGLDisplayPlugin.cpp
index 59cd637ca0..09b9b7f8f9 100644
--- a/libraries/display-plugins/src/display-plugins/Basic2DWindowOpenGLDisplayPlugin.cpp
+++ b/libraries/display-plugins/src/display-plugins/Basic2DWindowOpenGLDisplayPlugin.cpp
@@ -28,69 +28,76 @@ void Basic2DWindowOpenGLDisplayPlugin::customizeContext() {
qreal dpi = getFullscreenTarget()->physicalDotsPerInch();
_virtualPadPixelSize = dpi * VirtualPad::Manager::BASE_DIAMETER_PIXELS / VirtualPad::Manager::DPI;
- auto iconPath = PathUtils::resourcesPath() + "images/analog_stick.png";
- auto image = QImage(iconPath);
- if (image.format() != QImage::Format_ARGB32) {
- image = image.convertToFormat(QImage::Format_ARGB32);
- }
- if ((image.width() > 0) && (image.height() > 0)) {
- image = image.scaled(_virtualPadPixelSize, _virtualPadPixelSize, Qt::KeepAspectRatio);
+ if (!_virtualPadStickTexture) {
+ auto iconPath = PathUtils::resourcesPath() + "images/analog_stick.png";
+ auto image = QImage(iconPath);
+ if (image.format() != QImage::Format_ARGB32) {
+ image = image.convertToFormat(QImage::Format_ARGB32);
+ }
+ if ((image.width() > 0) && (image.height() > 0)) {
+ image = image.scaled(_virtualPadPixelSize, _virtualPadPixelSize, Qt::KeepAspectRatio);
- _virtualPadStickTexture = gpu::Texture::createStrict(
- gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA),
- image.width(), image.height(),
- gpu::Texture::MAX_NUM_MIPS,
- gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR));
- _virtualPadStickTexture->setSource("virtualPad stick");
- auto usage = gpu::Texture::Usage::Builder().withColor().withAlpha();
- _virtualPadStickTexture->setUsage(usage.build());
- _virtualPadStickTexture->setStoredMipFormat(gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA));
- _virtualPadStickTexture->assignStoredMip(0, image.byteCount(), image.constBits());
- _virtualPadStickTexture->setAutoGenerateMips(true);
+ _virtualPadStickTexture = gpu::Texture::createStrict(
+ gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA),
+ image.width(), image.height(),
+ gpu::Texture::MAX_NUM_MIPS,
+ gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR));
+ _virtualPadStickTexture->setSource("virtualPad stick");
+ auto usage = gpu::Texture::Usage::Builder().withColor().withAlpha();
+ _virtualPadStickTexture->setUsage(usage.build());
+ _virtualPadStickTexture->setStoredMipFormat(gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA));
+ _virtualPadStickTexture->assignStoredMip(0, image.byteCount(), image.constBits());
+ _virtualPadStickTexture->setAutoGenerateMips(true);
+ }
}
- iconPath = PathUtils::resourcesPath() + "images/analog_stick_base.png";
- image = QImage(iconPath);
- if (image.format() != QImage::Format_ARGB32) {
- image = image.convertToFormat(QImage::Format_ARGB32);
- }
- if ((image.width() > 0) && (image.height() > 0)) {
- image = image.scaled(_virtualPadPixelSize, _virtualPadPixelSize, Qt::KeepAspectRatio);
+ if (!_virtualPadStickBaseTexture) {
+ auto iconPath = PathUtils::resourcesPath() + "images/analog_stick_base.png";
+ auto image = QImage(iconPath);
+ if (image.format() != QImage::Format_ARGB32) {
+ image = image.convertToFormat(QImage::Format_ARGB32);
+ }
+ if ((image.width() > 0) && (image.height() > 0)) {
+ image = image.scaled(_virtualPadPixelSize, _virtualPadPixelSize, Qt::KeepAspectRatio);
- _virtualPadStickBaseTexture = gpu::Texture::createStrict(
- gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA),
- image.width(), image.height(),
- gpu::Texture::MAX_NUM_MIPS,
- gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR));
- _virtualPadStickBaseTexture->setSource("virtualPad base");
- auto usage = gpu::Texture::Usage::Builder().withColor().withAlpha();
- _virtualPadStickBaseTexture->setUsage(usage.build());
- _virtualPadStickBaseTexture->setStoredMipFormat(gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA));
- _virtualPadStickBaseTexture->assignStoredMip(0, image.byteCount(), image.constBits());
- _virtualPadStickBaseTexture->setAutoGenerateMips(true);
+ _virtualPadStickBaseTexture = gpu::Texture::createStrict(
+ gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA),
+ image.width(), image.height(),
+ gpu::Texture::MAX_NUM_MIPS,
+ gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR));
+ _virtualPadStickBaseTexture->setSource("virtualPad base");
+ auto usage = gpu::Texture::Usage::Builder().withColor().withAlpha();
+ _virtualPadStickBaseTexture->setUsage(usage.build());
+ _virtualPadStickBaseTexture->setStoredMipFormat(gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA));
+ _virtualPadStickBaseTexture->assignStoredMip(0, image.byteCount(), image.constBits());
+ _virtualPadStickBaseTexture->setAutoGenerateMips(true);
+ }
}
+
_virtualPadJumpBtnPixelSize = dpi * VirtualPad::Manager::JUMP_BTN_FULL_PIXELS / VirtualPad::Manager::DPI;
- iconPath = PathUtils::resourcesPath() + "images/fly.png";
- image = QImage(iconPath);
- if (image.format() != QImage::Format_ARGB32) {
- image = image.convertToFormat(QImage::Format_ARGB32);
- }
- if ((image.width() > 0) && (image.height() > 0)) {
- image = image.scaled(_virtualPadJumpBtnPixelSize, _virtualPadJumpBtnPixelSize, Qt::KeepAspectRatio);
- image = image.mirrored();
+ if (!_virtualPadJumpBtnTexture) {
+ auto iconPath = PathUtils::resourcesPath() + "images/fly.png";
+ auto image = QImage(iconPath);
+ if (image.format() != QImage::Format_ARGB32) {
+ image = image.convertToFormat(QImage::Format_ARGB32);
+ }
+ if ((image.width() > 0) && (image.height() > 0)) {
+ image = image.scaled(_virtualPadJumpBtnPixelSize, _virtualPadJumpBtnPixelSize, Qt::KeepAspectRatio);
+ image = image.mirrored();
- _virtualPadJumpBtnTexture = gpu::Texture::createStrict(
- gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA),
- image.width(), image.height(),
- gpu::Texture::MAX_NUM_MIPS,
- gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR));
- _virtualPadJumpBtnTexture->setSource("virtualPad jump");
- auto usage = gpu::Texture::Usage::Builder().withColor().withAlpha();
- _virtualPadJumpBtnTexture->setUsage(usage.build());
- _virtualPadJumpBtnTexture->setStoredMipFormat(gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA));
- _virtualPadJumpBtnTexture->assignStoredMip(0, image.byteCount(), image.constBits());
- _virtualPadJumpBtnTexture->setAutoGenerateMips(true);
+ _virtualPadJumpBtnTexture = gpu::Texture::createStrict(
+ gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA),
+ image.width(), image.height(),
+ gpu::Texture::MAX_NUM_MIPS,
+ gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR));
+ _virtualPadJumpBtnTexture->setSource("virtualPad jump");
+ auto usage = gpu::Texture::Usage::Builder().withColor().withAlpha();
+ _virtualPadJumpBtnTexture->setUsage(usage.build());
+ _virtualPadJumpBtnTexture->setStoredMipFormat(gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA));
+ _virtualPadJumpBtnTexture->assignStoredMip(0, image.byteCount(), image.constBits());
+ _virtualPadJumpBtnTexture->setAutoGenerateMips(true);
+ }
}
#endif
Parent::customizeContext();
@@ -124,44 +131,32 @@ void Basic2DWindowOpenGLDisplayPlugin::compositeExtra() {
// render stick base
auto stickBaseTransform = DependencyManager::get()->getPoint2DTransform(virtualPadManager.getLeftVirtualPad()->getFirstTouch(),
_virtualPadPixelSize, _virtualPadPixelSize);
- render([&](gpu::Batch& batch) {
- batch.enableStereo(false);
- batch.setProjectionTransform(mat4());
- batch.setPipeline(_cursorPipeline);
- batch.setResourceTexture(0, _virtualPadStickBaseTexture);
- batch.resetViewTransform();
- batch.setModelTransform(stickBaseTransform);
- batch.setViewportTransform(ivec4(uvec2(0), getRecommendedRenderSize()));
- batch.draw(gpu::TRIANGLE_STRIP, 4);
- });
- // render stick head
auto stickTransform = DependencyManager::get()->getPoint2DTransform(virtualPadManager.getLeftVirtualPad()->getCurrentTouch(),
- _virtualPadPixelSize, _virtualPadPixelSize);
+ _virtualPadPixelSize, _virtualPadPixelSize);
+ auto jumpTransform = DependencyManager::get()->getPoint2DTransform(virtualPadManager.getJumpButtonPosition(),
+ _virtualPadJumpBtnPixelSize, _virtualPadJumpBtnPixelSize);
+
render([&](gpu::Batch& batch) {
batch.enableStereo(false);
+ batch.setFramebuffer(_compositeFramebuffer);
+ batch.resetViewTransform();
batch.setProjectionTransform(mat4());
batch.setPipeline(_cursorPipeline);
- batch.setResourceTexture(0, _virtualPadStickTexture);
- batch.resetViewTransform();
- batch.setModelTransform(stickTransform);
- batch.setViewportTransform(ivec4(uvec2(0), getRecommendedRenderSize()));
+
+ batch.setResourceTexture(0, _virtualPadStickBaseTexture);
+ batch.setModelTransform(stickBaseTransform);
batch.draw(gpu::TRIANGLE_STRIP, 4);
- });
- if (!virtualPadManager.getLeftVirtualPad()->isBeingTouched()) {
- // render stick head
- auto jumpTransform = DependencyManager::get()->getPoint2DTransform(virtualPadManager.getJumpButtonPosition(),
- _virtualPadJumpBtnPixelSize, _virtualPadJumpBtnPixelSize);
- render([&](gpu::Batch& batch) {
- batch.enableStereo(false);
- batch.setProjectionTransform(mat4());
- batch.setPipeline(_cursorPipeline);
+
+ batch.setResourceTexture(0, _virtualPadStickTexture);
+ batch.setModelTransform(stickTransform);
+ batch.draw(gpu::TRIANGLE_STRIP, 4);
+
+ if (!virtualPadManager.getLeftVirtualPad()->isBeingTouched()) {
batch.setResourceTexture(0, _virtualPadJumpBtnTexture);
- batch.resetViewTransform();
batch.setModelTransform(jumpTransform);
- batch.setViewportTransform(ivec4(uvec2(0), getRecommendedRenderSize()));
batch.draw(gpu::TRIANGLE_STRIP, 4);
- });
- }
+ }
+ });
}
#endif
Parent::compositeExtra();
diff --git a/libraries/display-plugins/src/display-plugins/CompositorHelper.cpp b/libraries/display-plugins/src/display-plugins/CompositorHelper.cpp
index fb53ca253f..b78f00fa0e 100644
--- a/libraries/display-plugins/src/display-plugins/CompositorHelper.cpp
+++ b/libraries/display-plugins/src/display-plugins/CompositorHelper.cpp
@@ -275,7 +275,7 @@ bool CompositorHelper::getReticleOverDesktop() const {
// as being over the desktop.
if (isHMD()) {
QMutexLocker locker(&_reticleLock);
- glm::vec2 maxOverlayPosition = _currentDisplayPlugin->getRecommendedUiSize();
+ glm::vec2 maxOverlayPosition = glm::vec2(_currentDisplayPlugin->getRecommendedUiSize()) * _currentDisplayPlugin->getRenderResolutionScale();
static const glm::vec2 minOverlayPosition;
if (glm::any(glm::lessThan(_reticlePositionInHMD, minOverlayPosition)) ||
glm::any(glm::greaterThan(_reticlePositionInHMD, maxOverlayPosition))) {
@@ -317,7 +317,7 @@ void CompositorHelper::sendFakeMouseEvent() {
void CompositorHelper::setReticlePosition(const glm::vec2& position, bool sendFakeEvent) {
if (isHMD()) {
- glm::vec2 maxOverlayPosition = _currentDisplayPlugin->getRecommendedUiSize();
+ glm::vec2 maxOverlayPosition = glm::vec2(_currentDisplayPlugin->getRecommendedUiSize()) * _currentDisplayPlugin->getRenderResolutionScale();
// FIXME don't allow negative mouseExtra
glm::vec2 mouseExtra = (MOUSE_EXTENTS_PIXELS - maxOverlayPosition) / 2.0f;
glm::vec2 minMouse = vec2(0) - mouseExtra;
diff --git a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
index 3cfc0651d8..bd207da5df 100644
--- a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
+++ b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
@@ -885,7 +885,7 @@ OpenGLDisplayPlugin::~OpenGLDisplayPlugin() {
}
void OpenGLDisplayPlugin::updateCompositeFramebuffer() {
- auto renderSize = getRecommendedRenderSize();
+ auto renderSize = glm::uvec2(glm::vec2(getRecommendedRenderSize()) * getRenderResolutionScale());
if (!_compositeFramebuffer || _compositeFramebuffer->getSize() != renderSize) {
_compositeFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("OpenGLDisplayPlugin::composite", gpu::Element::COLOR_RGBA_32, renderSize.x, renderSize.y));
}
diff --git a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp b/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
index 5a3caa55fe..5062162b6e 100644
--- a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
@@ -251,7 +251,7 @@ void ZoneEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scen
updateAmbientLightFromEntity(entity);
}
- if (skyboxChanged) {
+ if (skyboxChanged || _proceduralUserData != entity->getUserData()) {
updateKeyBackgroundFromEntity(entity);
}
@@ -295,6 +295,10 @@ bool ZoneEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPoint
return true;
}
+ if (entity->getUserData() != _proceduralUserData) {
+ return true;
+ }
+
#if 0
if (_typedEntity->getCompoundShapeURL() != _lastShapeURL) {
return true;
diff --git a/libraries/entities/src/EntityScriptingInterface.h b/libraries/entities/src/EntityScriptingInterface.h
index 8adb5138f2..7e47d9e2d4 100644
--- a/libraries/entities/src/EntityScriptingInterface.h
+++ b/libraries/entities/src/EntityScriptingInterface.h
@@ -481,8 +481,8 @@ public slots:
/**jsdoc
* Gets the status of server entity script attached to an entity
* @function Entities.getServerScriptStatus
- * @property {Uuid} entityID - The ID of the entity to get the server entity script status for.
- * @property {Entities~getServerScriptStatusCallback} callback - The function to call upon completion.
+ * @param {Uuid} entityID - The ID of the entity to get the server entity script status for.
+ * @param {Entities~getServerScriptStatusCallback} callback - The function to call upon completion.
* @returns {boolean} true always.
*/
/**jsdoc
diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp
index 501e59f38e..f484de57f1 100644
--- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp
@@ -44,9 +44,9 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
(&::gpu::gl::GLBackend::do_setModelTransform),
(&::gpu::gl::GLBackend::do_setViewTransform),
- (&::gpu::gl::GLBackend::do_setProjectionTransform),
- (&::gpu::gl::GLBackend::do_setProjectionJitter),
- (&::gpu::gl::GLBackend::do_setViewportTransform),
+ (&::gpu::gl::GLBackend::do_setProjectionTransform),
+ (&::gpu::gl::GLBackend::do_setProjectionJitter),
+ (&::gpu::gl::GLBackend::do_setViewportTransform),
(&::gpu::gl::GLBackend::do_setDepthRangeTransform),
(&::gpu::gl::GLBackend::do_setPipeline),
@@ -118,12 +118,6 @@ void GLBackend::init() {
#if !defined(USE_GLES)
qCDebug(gpugllogging, "V-Sync is %s\n", (::gl::getSwapInterval() > 0 ? "ON" : "OFF"));
#endif
-#if THREADED_TEXTURE_BUFFERING
- // This has to happen on the main thread in order to give the thread
- // pool a reasonable parent object
- GLVariableAllocationSupport::TransferJob::startBufferingThread();
-#endif
-
});
}
@@ -136,6 +130,7 @@ GLBackend::GLBackend() {
GLBackend::~GLBackend() {
killInput();
killTransform();
+ killTextureManagementStage();
}
void GLBackend::renderPassTransfer(const Batch& batch) {
@@ -167,18 +162,18 @@ void GLBackend::renderPassTransfer(const Batch& batch) {
case Batch::COMMAND_drawIndexedInstanced:
case Batch::COMMAND_multiDrawIndirect:
case Batch::COMMAND_multiDrawIndexedIndirect:
- {
- Vec2u outputSize{ 1,1 };
+ {
+ Vec2u outputSize{ 1,1 };
- if (_output._framebuffer) {
- outputSize.x = _output._framebuffer->getWidth();
- outputSize.y = _output._framebuffer->getHeight();
- } else if (glm::dot(_transform._projectionJitter, _transform._projectionJitter)>0.0f) {
- qCWarning(gpugllogging) << "Jittering needs to have a frame buffer to be set";
- }
+ if (_output._framebuffer) {
+ outputSize.x = _output._framebuffer->getWidth();
+ outputSize.y = _output._framebuffer->getHeight();
+ } else if (glm::dot(_transform._projectionJitter, _transform._projectionJitter)>0.0f) {
+ qCWarning(gpugllogging) << "Jittering needs to have a frame buffer to be set";
+ }
- _transform.preUpdate(_commandIndex, _stereo, outputSize);
- }
+ _transform.preUpdate(_commandIndex, _stereo, outputSize);
+ }
break;
case Batch::COMMAND_disableContextStereo:
@@ -191,10 +186,10 @@ void GLBackend::renderPassTransfer(const Batch& batch) {
case Batch::COMMAND_setViewportTransform:
case Batch::COMMAND_setViewTransform:
- case Batch::COMMAND_setProjectionTransform:
- case Batch::COMMAND_setProjectionJitter:
- {
- CommandCall call = _commandCalls[(*command)];
+ case Batch::COMMAND_setProjectionTransform:
+ case Batch::COMMAND_setProjectionJitter:
+ {
+ CommandCall call = _commandCalls[(*command)];
(this->*(call))(batch, *offset);
break;
}
@@ -268,8 +263,8 @@ void GLBackend::render(const Batch& batch) {
if (!batch.isStereoEnabled()) {
_stereo._enable = false;
}
- // Reset jitter
- _transform._projectionJitter = Vec2(0.0f, 0.0f);
+ // Reset jitter
+ _transform._projectionJitter = Vec2(0.0f, 0.0f);
{
PROFILE_RANGE(render_gpu_gl_detail, "Transfer");
@@ -729,9 +724,8 @@ void GLBackend::recycle() const {
glDeleteQueries((GLsizei)ids.size(), ids.data());
}
}
-
- GLVariableAllocationSupport::manageMemory();
- GLVariableAllocationSupport::_frameTexturesCreated = 0;
+
+ _textureManagement._transferEngine->manageMemory();
Texture::KtxStorage::releaseOpenKtxFiles();
}
diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h
index 314bbee387..32c75d0363 100644
--- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h
@@ -491,8 +491,10 @@ protected:
struct TextureManagementStageState {
bool _sparseCapable { false };
+ GLTextureTransferEnginePointer _transferEngine;
} _textureManagement;
- virtual void initTextureManagementStage() {}
+ virtual void initTextureManagementStage();
+ virtual void killTextureManagementStage();
typedef void (GLBackend::*CommandCall)(const Batch&, size_t);
static CommandCall _commandCalls[Batch::NUM_COMMANDS];
diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLShared.h b/libraries/gpu-gl-common/src/gpu/gl/GLShared.h
index ccdf0a5c41..f67439f96a 100644
--- a/libraries/gpu-gl-common/src/gpu/gl/GLShared.h
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLShared.h
@@ -137,6 +137,8 @@ class GLQuery;
class GLState;
class GLShader;
class GLTexture;
+class GLTextureTransferEngine;
+using GLTextureTransferEnginePointer = std::shared_ptr;
struct ShaderObject;
} } // namespace gpu::gl
diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLTexture.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLTexture.cpp
index 943b8148ef..394b44166f 100644
--- a/libraries/gpu-gl-common/src/gpu/gl/GLTexture.cpp
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLTexture.cpp
@@ -48,6 +48,14 @@ const GLFilterMode GLTexture::FILTER_MODES[Sampler::NUM_FILTERS] = {
{ GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR } //FILTER_ANISOTROPIC,
};
+static constexpr size_t MAX_PIXEL_BYTE_SIZE{ 4 };
+static constexpr size_t MAX_TRANSFER_DIMENSION{ 1024 };
+
+const uvec3 GLVariableAllocationSupport::MAX_TRANSFER_DIMENSIONS{ MAX_TRANSFER_DIMENSION, MAX_TRANSFER_DIMENSION, 1 };
+const uvec3 GLVariableAllocationSupport::INITIAL_MIP_TRANSFER_DIMENSIONS{ 64, 64, 1 };
+const size_t GLVariableAllocationSupport::MAX_TRANSFER_SIZE = MAX_TRANSFER_DIMENSION * MAX_TRANSFER_DIMENSION * MAX_PIXEL_BYTE_SIZE;
+const size_t GLVariableAllocationSupport::MAX_BUFFER_SIZE = MAX_TRANSFER_SIZE;
+
GLenum GLTexture::getGLTextureType(const Texture& texture) {
switch (texture.getType()) {
case Texture::TEX_2D:
@@ -131,7 +139,6 @@ Size GLTexture::copyMipFaceFromTexture(uint16_t sourceMip, uint16_t targetMip, u
return 0;
}
-
GLExternalTexture::GLExternalTexture(const std::weak_ptr& backend, const Texture& texture, GLuint id)
: Parent(backend, texture, id) {
Backend::textureExternalCount.increment();
@@ -151,65 +158,58 @@ GLExternalTexture::~GLExternalTexture() {
Backend::textureExternalCount.decrement();
}
-
-// Variable sized textures
-using MemoryPressureState = GLVariableAllocationSupport::MemoryPressureState;
-using WorkQueue = GLVariableAllocationSupport::WorkQueue;
-using TransferJobPointer = GLVariableAllocationSupport::TransferJobPointer;
-
-std::list GLVariableAllocationSupport::_memoryManagedTextures;
-MemoryPressureState GLVariableAllocationSupport::_memoryPressureState { MemoryPressureState::Idle };
-std::atomic GLVariableAllocationSupport::_memoryPressureStateStale { false };
-const uvec3 GLVariableAllocationSupport::INITIAL_MIP_TRANSFER_DIMENSIONS { 64, 64, 1 };
-WorkQueue GLVariableAllocationSupport::_transferQueue;
-WorkQueue GLVariableAllocationSupport::_promoteQueue;
-WorkQueue GLVariableAllocationSupport::_demoteQueue;
-size_t GLVariableAllocationSupport::_frameTexturesCreated { 0 };
-
-#define OVERSUBSCRIBED_PRESSURE_VALUE 0.95f
-#define UNDERSUBSCRIBED_PRESSURE_VALUE 0.85f
-#define DEFAULT_ALLOWED_TEXTURE_MEMORY_MB ((size_t)1024)
-
-static const size_t DEFAULT_ALLOWED_TEXTURE_MEMORY = MB_TO_BYTES(DEFAULT_ALLOWED_TEXTURE_MEMORY_MB);
-
-using TransferJob = GLVariableAllocationSupport::TransferJob;
-
-const uvec3 GLVariableAllocationSupport::MAX_TRANSFER_DIMENSIONS { 1024, 1024, 1 };
-const size_t GLVariableAllocationSupport::MAX_TRANSFER_SIZE = GLVariableAllocationSupport::MAX_TRANSFER_DIMENSIONS.x * GLVariableAllocationSupport::MAX_TRANSFER_DIMENSIONS.y * 4;
-
-#if THREADED_TEXTURE_BUFFERING
-
-TexturePointer GLVariableAllocationSupport::_currentTransferTexture;
-TransferJobPointer GLVariableAllocationSupport::_currentTransferJob;
-QThreadPool* TransferJob::_bufferThreadPool { nullptr };
-
-void TransferJob::startBufferingThread() {
- static std::once_flag once;
- std::call_once(once, [&] {
- _bufferThreadPool = new QThreadPool(qApp);
- _bufferThreadPool->setMaxThreadCount(1);
- });
+GLVariableAllocationSupport::GLVariableAllocationSupport() {
}
-#endif
+GLVariableAllocationSupport::~GLVariableAllocationSupport() {
+}
-TransferJob::TransferJob(const GLTexture& parent, uint16_t sourceMip, uint16_t targetMip, uint8_t face, uint32_t lines, uint32_t lineOffset)
- : _parent(parent) {
+void GLVariableAllocationSupport::incrementPopulatedSize(Size delta) const {
+ _populatedSize += delta;
+ // Keep the 2 code paths to be able to debug
+ if (_size < _populatedSize) {
+ Backend::textureResourcePopulatedGPUMemSize.update(0, delta);
+ } else {
+ Backend::textureResourcePopulatedGPUMemSize.update(0, delta);
+ }
+}
- auto transferDimensions = _parent._gpuObject.evalMipDimensions(sourceMip);
+void GLVariableAllocationSupport::decrementPopulatedSize(Size delta) const {
+ _populatedSize -= delta;
+ // Keep the 2 code paths to be able to debug
+ if (_size < _populatedSize) {
+ Backend::textureResourcePopulatedGPUMemSize.update(delta, 0);
+ } else {
+ Backend::textureResourcePopulatedGPUMemSize.update(delta, 0);
+ }
+}
+
+void GLVariableAllocationSupport::sanityCheck() const {
+ if (_populatedMip < _allocatedMip) {
+ qCWarning(gpugllogging) << "Invalid mip levels";
+ }
+}
+
+TransferJob::TransferJob(const Texture& texture,
+ uint16_t sourceMip,
+ uint16_t targetMip,
+ uint8_t face,
+ uint32_t lines,
+ uint32_t lineOffset) {
+ auto transferDimensions = texture.evalMipDimensions(sourceMip);
GLenum format;
GLenum internalFormat;
GLenum type;
- GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(_parent._gpuObject.getTexelFormat(), _parent._gpuObject.getStoredMipFormat());
+ GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(texture.getTexelFormat(), texture.getStoredMipFormat());
format = texelFormat.format;
internalFormat = texelFormat.internalFormat;
type = texelFormat.type;
- _transferSize = _parent._gpuObject.getStoredMipFaceSize(sourceMip, face);
+ _transferSize = texture.getStoredMipFaceSize(sourceMip, face);
// If we're copying a subsection of the mip, do additional calculations to find the size and offset of the segment
if (0 != lines) {
transferDimensions.y = lines;
- auto dimensions = _parent._gpuObject.evalMipDimensions(sourceMip);
+ auto dimensions = texture.evalMipDimensions(sourceMip);
auto bytesPerLine = (uint32_t)_transferSize / dimensions.y;
_transferOffset = bytesPerLine * lineOffset;
_transferSize = bytesPerLine * lines;
@@ -222,481 +222,34 @@ TransferJob::TransferJob(const GLTexture& parent, uint16_t sourceMip, uint16_t t
}
// Buffering can invoke disk IO, so it should be off of the main and render threads
- _bufferingLambda = [=] {
- auto mipStorage = _parent._gpuObject.accessStoredMipFace(sourceMip, face);
+ _bufferingLambda = [=](const TexturePointer& texture) {
+ auto mipStorage = texture->accessStoredMipFace(sourceMip, face);
if (mipStorage) {
_mipData = mipStorage->createView(_transferSize, _transferOffset);
} else {
- qCWarning(gpugllogging) << "Buffering failed because mip could not be retrieved from texture " << _parent._source.c_str() ;
+ qCWarning(gpugllogging) << "Buffering failed because mip could not be retrieved from texture "
+ << texture->source().c_str();
}
};
- _transferLambda = [=] {
+ _transferLambda = [=](const TexturePointer& texture) {
if (_mipData) {
- _parent.copyMipFaceLinesFromTexture(targetMip, face, transferDimensions, lineOffset, internalFormat, format, type, _mipData->size(), _mipData->readData());
+ auto gltexture = Backend::getGPUObject(*texture);
+ ;
+ gltexture->copyMipFaceLinesFromTexture(targetMip, face, transferDimensions, lineOffset, internalFormat, format,
+ type, _mipData->size(), _mipData->readData());
_mipData.reset();
} else {
- qCWarning(gpugllogging) << "Transfer failed because mip could not be retrieved from texture " << _parent._source.c_str();
+ qCWarning(gpugllogging) << "Transfer failed because mip could not be retrieved from texture "
+ << texture->source().c_str();
}
};
}
-TransferJob::TransferJob(const GLTexture& parent, std::function transferLambda)
- : _parent(parent), _bufferingRequired(false), _transferLambda(transferLambda) {
-}
+TransferJob::TransferJob(const std::function& transferLambda) :
+ _bufferingRequired(false), _transferLambda([=](const TexturePointer&) { transferLambda(); }) {}
TransferJob::~TransferJob() {
Backend::texturePendingGPUTransferMemSize.update(_transferSize, 0);
}
-bool TransferJob::tryTransfer() {
-#if THREADED_TEXTURE_BUFFERING
- // Are we ready to transfer
- if (!bufferingCompleted()) {
- startBuffering();
- return false;
- }
-#else
- if (_bufferingRequired) {
- _bufferingLambda();
- }
-#endif
- _transferLambda();
- return true;
-}
-
-#if THREADED_TEXTURE_BUFFERING
-bool TransferJob::bufferingRequired() const {
- if (!_bufferingRequired) {
- return false;
- }
-
- // The default state of a QFuture is with status Canceled | Started | Finished,
- // so we have to check isCancelled before we check the actual state
- if (_bufferingStatus.isCanceled()) {
- return true;
- }
-
- return !_bufferingStatus.isStarted();
-}
-
-bool TransferJob::bufferingCompleted() const {
- if (!_bufferingRequired) {
- return true;
- }
-
- // The default state of a QFuture is with status Canceled | Started | Finished,
- // so we have to check isCancelled before we check the actual state
- if (_bufferingStatus.isCanceled()) {
- return false;
- }
-
- return _bufferingStatus.isFinished();
-}
-
-void TransferJob::startBuffering() {
- if (bufferingRequired()) {
- assert(_bufferingStatus.isCanceled());
- _bufferingStatus = QtConcurrent::run(_bufferThreadPool, [=] {
- _bufferingLambda();
- });
- assert(!_bufferingStatus.isCanceled());
- assert(_bufferingStatus.isStarted());
- }
-}
-#endif
-
-GLVariableAllocationSupport::GLVariableAllocationSupport() {
- _memoryPressureStateStale = true;
-}
-
-GLVariableAllocationSupport::~GLVariableAllocationSupport() {
- _memoryPressureStateStale = true;
-}
-
-void GLVariableAllocationSupport::addMemoryManagedTexture(const TexturePointer& texturePointer) {
- _memoryManagedTextures.push_back(texturePointer);
- if (MemoryPressureState::Idle != _memoryPressureState) {
- addToWorkQueue(texturePointer);
- }
-}
-
-void GLVariableAllocationSupport::addToWorkQueue(const TexturePointer& texturePointer) {
- GLTexture* gltexture = Backend::getGPUObject(*texturePointer);
- GLVariableAllocationSupport* vargltexture = dynamic_cast(gltexture);
- switch (_memoryPressureState) {
- case MemoryPressureState::Oversubscribed:
- if (vargltexture->canDemote()) {
- // Demote largest first
- _demoteQueue.push({ texturePointer, (float)gltexture->size() });
- }
- break;
-
- case MemoryPressureState::Undersubscribed:
- if (vargltexture->canPromote()) {
- // Promote smallest first
- _promoteQueue.push({ texturePointer, 1.0f / (float)gltexture->size() });
- }
- break;
-
- case MemoryPressureState::Transfer:
- if (vargltexture->hasPendingTransfers()) {
- // Transfer priority given to smaller mips first
- _transferQueue.push({ texturePointer, 1.0f / (float)gltexture->_gpuObject.evalMipSize(vargltexture->_populatedMip) });
- }
- break;
-
- case MemoryPressureState::Idle:
- Q_UNREACHABLE();
- break;
- }
-}
-
-WorkQueue& GLVariableAllocationSupport::getActiveWorkQueue() {
- static WorkQueue empty;
- switch (_memoryPressureState) {
- case MemoryPressureState::Oversubscribed:
- return _demoteQueue;
-
- case MemoryPressureState::Undersubscribed:
- return _promoteQueue;
-
- case MemoryPressureState::Transfer:
- return _transferQueue;
-
- case MemoryPressureState::Idle:
- Q_UNREACHABLE();
- break;
- }
- return empty;
-}
-
-// FIXME hack for stats display
-QString getTextureMemoryPressureModeString() {
- switch (GLVariableAllocationSupport::_memoryPressureState) {
- case MemoryPressureState::Oversubscribed:
- return "Oversubscribed";
-
- case MemoryPressureState::Undersubscribed:
- return "Undersubscribed";
-
- case MemoryPressureState::Transfer:
- return "Transfer";
-
- case MemoryPressureState::Idle:
- return "Idle";
- }
- Q_UNREACHABLE();
- return "Unknown";
-}
-
-void GLVariableAllocationSupport::updateMemoryPressure() {
- static size_t lastAllowedMemoryAllocation = gpu::Texture::getAllowedGPUMemoryUsage();
-
- size_t allowedMemoryAllocation = gpu::Texture::getAllowedGPUMemoryUsage();
- if (0 == allowedMemoryAllocation) {
- allowedMemoryAllocation = DEFAULT_ALLOWED_TEXTURE_MEMORY;
- }
-
- // If the user explicitly changed the allowed memory usage, we need to mark ourselves stale
- // so that we react
- if (allowedMemoryAllocation != lastAllowedMemoryAllocation) {
- _memoryPressureStateStale = true;
- lastAllowedMemoryAllocation = allowedMemoryAllocation;
- }
-
- if (!_memoryPressureStateStale.exchange(false)) {
- return;
- }
-
- PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
-
- // Clear any defunct textures (weak pointers that no longer have a valid texture)
- _memoryManagedTextures.remove_if([&](const TextureWeakPointer& weakPointer) {
- return weakPointer.expired();
- });
-
- // Convert weak pointers to strong. This new list may still contain nulls if a texture was
- // deleted on another thread between the previous line and this one
- std::vector strongTextures; {
- strongTextures.reserve(_memoryManagedTextures.size());
- std::transform(
- _memoryManagedTextures.begin(), _memoryManagedTextures.end(),
- std::back_inserter(strongTextures),
- [](const TextureWeakPointer& p) { return p.lock(); });
- }
-
- size_t totalVariableMemoryAllocation = 0;
- size_t idealMemoryAllocation = 0;
- bool canDemote = false;
- bool canPromote = false;
- bool hasTransfers = false;
- for (const auto& texture : strongTextures) {
- // Race conditions can still leave nulls in the list, so we need to check
- if (!texture) {
- continue;
- }
- GLTexture* gltexture = Backend::getGPUObject(*texture);
- GLVariableAllocationSupport* vartexture = dynamic_cast(gltexture);
- // Track how much the texture thinks it should be using
- idealMemoryAllocation += texture->evalTotalSize();
- // Track how much we're actually using
- totalVariableMemoryAllocation += gltexture->size();
- canDemote |= vartexture->canDemote();
- canPromote |= vartexture->canPromote();
- hasTransfers |= vartexture->hasPendingTransfers();
- }
-
- size_t unallocated = idealMemoryAllocation - totalVariableMemoryAllocation;
- float pressure = (float)totalVariableMemoryAllocation / (float)allowedMemoryAllocation;
-
- auto newState = MemoryPressureState::Idle;
- if (pressure < UNDERSUBSCRIBED_PRESSURE_VALUE && (unallocated != 0 && canPromote)) {
- newState = MemoryPressureState::Undersubscribed;
- } else if (pressure > OVERSUBSCRIBED_PRESSURE_VALUE && canDemote) {
- newState = MemoryPressureState::Oversubscribed;
- } else if (hasTransfers) {
- newState = MemoryPressureState::Transfer;
- }
-
- if (newState != _memoryPressureState) {
- _memoryPressureState = newState;
- // Clear the existing queue
- _transferQueue = WorkQueue();
- _promoteQueue = WorkQueue();
- _demoteQueue = WorkQueue();
-
- // Populate the existing textures into the queue
- if (_memoryPressureState != MemoryPressureState::Idle) {
- for (const auto& texture : strongTextures) {
- // Race conditions can still leave nulls in the list, so we need to check
- if (!texture) {
- continue;
- }
- addToWorkQueue(texture);
- }
- }
- }
-}
-
-TexturePointer GLVariableAllocationSupport::getNextWorkQueueItem(WorkQueue& workQueue) {
- while (!workQueue.empty()) {
- auto workTarget = workQueue.top();
-
- auto texture = workTarget.first.lock();
- if (!texture) {
- workQueue.pop();
- continue;
- }
-
- // Check whether the resulting texture can actually have work performed
- GLTexture* gltexture = Backend::getGPUObject(*texture);
- GLVariableAllocationSupport* vartexture = dynamic_cast(gltexture);
- switch (_memoryPressureState) {
- case MemoryPressureState::Oversubscribed:
- if (vartexture->canDemote()) {
- return texture;
- }
- break;
-
- case MemoryPressureState::Undersubscribed:
- if (vartexture->canPromote()) {
- return texture;
- }
- break;
-
- case MemoryPressureState::Transfer:
- if (vartexture->hasPendingTransfers()) {
- return texture;
- }
- break;
-
- case MemoryPressureState::Idle:
- Q_UNREACHABLE();
- break;
- }
-
- // If we got here, then the texture has no work to do in the current state,
- // so pop it off the queue and continue
- workQueue.pop();
- }
-
- return TexturePointer();
-}
-
-void GLVariableAllocationSupport::processWorkQueue(WorkQueue& workQueue) {
- if (workQueue.empty()) {
- return;
- }
-
- // Get the front of the work queue to perform work
- auto texture = getNextWorkQueueItem(workQueue);
- if (!texture) {
- return;
- }
-
- // Grab the first item off the demote queue
- PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
-
- GLTexture* gltexture = Backend::getGPUObject(*texture);
- GLVariableAllocationSupport* vartexture = dynamic_cast(gltexture);
- switch (_memoryPressureState) {
- case MemoryPressureState::Oversubscribed:
- vartexture->demote();
- workQueue.pop();
- addToWorkQueue(texture);
- _memoryPressureStateStale = true;
- break;
-
- case MemoryPressureState::Undersubscribed:
- vartexture->promote();
- workQueue.pop();
- addToWorkQueue(texture);
- _memoryPressureStateStale = true;
- break;
-
- case MemoryPressureState::Transfer:
- if (vartexture->executeNextTransfer(texture)) {
- workQueue.pop();
- addToWorkQueue(texture);
-
-#if THREADED_TEXTURE_BUFFERING
- // Eagerly start the next buffering job if possible
- texture = getNextWorkQueueItem(workQueue);
- if (texture) {
- gltexture = Backend::getGPUObject(*texture);
- vartexture = dynamic_cast(gltexture);
- vartexture->executeNextBuffer(texture);
- }
-#endif
- }
- break;
-
- case MemoryPressureState::Idle:
- Q_UNREACHABLE();
- break;
- }
-}
-
-void GLVariableAllocationSupport::processWorkQueues() {
- if (MemoryPressureState::Idle == _memoryPressureState) {
- return;
- }
-
- auto& workQueue = getActiveWorkQueue();
- // Do work on the front of the queue
- processWorkQueue(workQueue);
-
- if (workQueue.empty()) {
- _memoryPressureState = MemoryPressureState::Idle;
- _memoryPressureStateStale = true;
- }
-}
-
-void GLVariableAllocationSupport::manageMemory() {
- PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
- updateMemoryPressure();
- processWorkQueues();
-}
-
-bool GLVariableAllocationSupport::executeNextTransfer(const TexturePointer& currentTexture) {
-#if THREADED_TEXTURE_BUFFERING
- // If a transfer job is active on the buffering thread, but has not completed it's buffering lambda,
- // then we need to exit early, since we don't want to have the transfer job leave scope while it's
- // being used in another thread -- See https://highfidelity.fogbugz.com/f/cases/4626
- if (_currentTransferJob && !_currentTransferJob->bufferingCompleted()) {
- return false;
- }
-#endif
-
- if (_populatedMip <= _allocatedMip) {
-#if THREADED_TEXTURE_BUFFERING
- _currentTransferJob.reset();
- _currentTransferTexture.reset();
-#endif
- return true;
- }
-
- // If the transfer queue is empty, rebuild it
- if (_pendingTransfers.empty()) {
- populateTransferQueue();
- }
-
- bool result = false;
- if (!_pendingTransfers.empty()) {
-#if THREADED_TEXTURE_BUFFERING
- // If there is a current transfer, but it's not the top of the pending transfer queue, then it's an orphan, so we want to abandon it.
- if (_currentTransferJob && _currentTransferJob != _pendingTransfers.front()) {
- _currentTransferJob.reset();
- }
-
- if (!_currentTransferJob) {
- // Keeping hold of a strong pointer to the transfer job ensures that if the pending transfer queue is rebuilt, the transfer job
- // doesn't leave scope, causing a crash in the buffering thread
- _currentTransferJob = _pendingTransfers.front();
-
- // Keeping hold of a strong pointer during the transfer ensures that the transfer thread cannot try to access a destroyed texture
- _currentTransferTexture = currentTexture;
- }
-
- // transfer jobs use asynchronous buffering of the texture data because it may involve disk IO, so we execute a try here to determine if the buffering
- // is complete
- if (_currentTransferJob->tryTransfer()) {
- _pendingTransfers.pop();
- // Once a given job is finished, release the shared pointers keeping them alive
- _currentTransferTexture.reset();
- _currentTransferJob.reset();
- result = true;
- }
-#else
- if (_pendingTransfers.front()->tryTransfer()) {
- _pendingTransfers.pop();
- result = true;
- }
-#endif
- }
- return result;
-}
-
-#if THREADED_TEXTURE_BUFFERING
-void GLVariableAllocationSupport::executeNextBuffer(const TexturePointer& currentTexture) {
- if (_currentTransferJob && !_currentTransferJob->bufferingCompleted()) {
- return;
- }
-
- // If the transfer queue is empty, rebuild it
- if (_pendingTransfers.empty()) {
- populateTransferQueue();
- }
-
- if (!_pendingTransfers.empty()) {
- if (!_currentTransferJob) {
- _currentTransferJob = _pendingTransfers.front();
- _currentTransferTexture = currentTexture;
- }
-
- _currentTransferJob->startBuffering();
- }
-}
-#endif
-
-void GLVariableAllocationSupport::incrementPopulatedSize(Size delta) const {
- _populatedSize += delta;
- // Keep the 2 code paths to be able to debug
- if (_size < _populatedSize) {
- Backend::textureResourcePopulatedGPUMemSize.update(0, delta);
- } else {
- Backend::textureResourcePopulatedGPUMemSize.update(0, delta);
- }
-}
-void GLVariableAllocationSupport::decrementPopulatedSize(Size delta) const {
- _populatedSize -= delta;
- // Keep the 2 code paths to be able to debug
- if (_size < _populatedSize) {
- Backend::textureResourcePopulatedGPUMemSize.update(delta, 0);
- } else {
- Backend::textureResourcePopulatedGPUMemSize.update(delta, 0);
- }
-}
-
-
diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLTexture.h b/libraries/gpu-gl-common/src/gpu/gl/GLTexture.h
index c2483eb2a1..5ace804683 100644
--- a/libraries/gpu-gl-common/src/gpu/gl/GLTexture.h
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLTexture.h
@@ -16,8 +16,6 @@
#include "GLTexelFormat.h"
#include
-#define THREADED_TEXTURE_BUFFERING 1
-
namespace gpu { namespace gl {
struct GLFilterMode {
@@ -25,107 +23,92 @@ struct GLFilterMode {
GLint magFilter;
};
+class GLTextureTransferEngine {
+public:
+ using Pointer = std::shared_ptr;
+ /// Called once per frame to perform any require memory management or transfer work
+ virtual void manageMemory() = 0;
+ virtual void shutdown() = 0;
+
+ /// Called whenever a client wants to create a new texture. This allows the transfer engine to
+ /// potentially limit the number of GL textures created per frame
+ bool allowCreate() const { return _frameTexturesCreated < MAX_RESOURCE_TEXTURES_PER_FRAME; }
+ /// Called whenever a client creates a new resource texture that should use managed memory
+ /// and incremental transfer
+ void addMemoryManagedTexture(const TexturePointer& texturePointer);
+
+protected:
+ // Fetch all the currently active textures as strong pointers, while clearing the
+ // empty weak pointers out of _registeredTextures
+ std::vector getAllTextures();
+ void resetFrameTextureCreated() { _frameTexturesCreated = 0; }
+
+private:
+ static const size_t MAX_RESOURCE_TEXTURES_PER_FRAME{ 2 };
+ size_t _frameTexturesCreated{ 0 };
+ std::list _registeredTextures;
+};
+
+/**
+ A transfer job encapsulates an individual piece of work required to upload texture data to the GPU.
+ The work can be broken down into two parts, expressed as lambdas. The buffering lambda is repsonsible
+ for putting the data to be uploaded into a CPU memory buffer. The transfer lambda is repsonsible for
+ uploading the data from the CPU memory buffer to the GPU using OpenGL calls. Ideally the buffering lambda
+ will be executed on a seprate thread from the OpenGL work to ensure that disk IO operations do not block
+ OpenGL calls
+
+ Additionally, a TransferJob can encapsulate some kind of post-upload work that changes the state of the
+ GLTexture derived object wrapping the actual texture ID, such as changing the _populateMip value once
+ a given mip level has been compeltely uploaded
+ */
+class TransferJob {
+public:
+ using Pointer = std::shared_ptr;
+ using Queue = std::queue;
+ using Lambda = std::function;
+private:
+ Texture::PixelsPointer _mipData;
+ size_t _transferOffset{ 0 };
+ size_t _transferSize{ 0 };
+ bool _bufferingRequired{ true };
+ Lambda _transferLambda{ [](const TexturePointer&) {} };
+ Lambda _bufferingLambda{ [](const TexturePointer&) {} };
+public:
+ TransferJob(const TransferJob& other) = delete;
+ TransferJob(const std::function& transferLambda);
+ TransferJob(const Texture& texture, uint16_t sourceMip, uint16_t targetMip, uint8_t face, uint32_t lines = 0, uint32_t lineOffset = 0);
+ ~TransferJob();
+ const size_t& size() const { return _transferSize; }
+ bool bufferingRequired() const { return _bufferingRequired; }
+ void buffer(const TexturePointer& texture) { _bufferingLambda(texture); }
+ void transfer(const TexturePointer& texture) { _transferLambda(texture); }
+};
+
+using TransferJobPointer = std::shared_ptr;
+using TransferQueue = std::queue;
+
class GLVariableAllocationSupport {
friend class GLBackend;
public:
GLVariableAllocationSupport();
virtual ~GLVariableAllocationSupport();
+ virtual void populateTransferQueue(TransferQueue& pendingTransfers) = 0;
- enum class MemoryPressureState {
- Idle,
- Transfer,
- Oversubscribed,
- Undersubscribed,
- };
-
- using QueuePair = std::pair;
- struct QueuePairLess {
- bool operator()(const QueuePair& a, const QueuePair& b) {
- return a.second < b.second;
- }
- };
- using WorkQueue = std::priority_queue, QueuePairLess>;
-
- class TransferJob {
- using VoidLambda = std::function;
- using VoidLambdaQueue = std::queue;
- const GLTexture& _parent;
- Texture::PixelsPointer _mipData;
- size_t _transferOffset { 0 };
- size_t _transferSize { 0 };
-
- bool _bufferingRequired { true };
- VoidLambda _transferLambda;
- VoidLambda _bufferingLambda;
-
-#if THREADED_TEXTURE_BUFFERING
- // Indicates if a transfer from backing storage to interal storage has started
- QFuture _bufferingStatus;
- static QThreadPool* _bufferThreadPool;
-#endif
-
- public:
- TransferJob(const TransferJob& other) = delete;
- TransferJob(const GLTexture& parent, std::function transferLambda);
- TransferJob(const GLTexture& parent, uint16_t sourceMip, uint16_t targetMip, uint8_t face, uint32_t lines = 0, uint32_t lineOffset = 0);
- ~TransferJob();
- bool tryTransfer();
-
-#if THREADED_TEXTURE_BUFFERING
- void startBuffering();
- bool bufferingRequired() const;
- bool bufferingCompleted() const;
- static void startBufferingThread();
-#endif
-
- private:
- void transfer();
- };
-
- using TransferJobPointer = std::shared_ptr;
- using TransferQueue = std::queue;
- static MemoryPressureState _memoryPressureState;
-
-public:
- static void addMemoryManagedTexture(const TexturePointer& texturePointer);
-
-protected:
- static size_t _frameTexturesCreated;
- static std::atomic _memoryPressureStateStale;
- static std::list _memoryManagedTextures;
- static WorkQueue _transferQueue;
- static WorkQueue _promoteQueue;
- static WorkQueue _demoteQueue;
-#if THREADED_TEXTURE_BUFFERING
- static TexturePointer _currentTransferTexture;
- static TransferJobPointer _currentTransferJob;
-#endif
- static const uvec3 INITIAL_MIP_TRANSFER_DIMENSIONS;
- static const uvec3 MAX_TRANSFER_DIMENSIONS;
- static const size_t MAX_TRANSFER_SIZE;
-
-
- static void updateMemoryPressure();
- static void processWorkQueues();
- static void processWorkQueue(WorkQueue& workQueue);
- static TexturePointer getNextWorkQueueItem(WorkQueue& workQueue);
- static void addToWorkQueue(const TexturePointer& texture);
- static WorkQueue& getActiveWorkQueue();
-
- static void manageMemory();
-
- //bool canPromoteNoAllocate() const { return _allocatedMip < _populatedMip; }
+ void sanityCheck() const;
bool canPromote() const { return _allocatedMip > _minAllocatedMip; }
bool canDemote() const { return _allocatedMip < _maxAllocatedMip; }
bool hasPendingTransfers() const { return _populatedMip > _allocatedMip; }
-#if THREADED_TEXTURE_BUFFERING
- void executeNextBuffer(const TexturePointer& currentTexture);
-#endif
- bool executeNextTransfer(const TexturePointer& currentTexture);
- virtual void populateTransferQueue() = 0;
- virtual void promote() = 0;
- virtual void demote() = 0;
+
+ virtual size_t promote() = 0;
+ virtual size_t demote() = 0;
+
+ static const uvec3 MAX_TRANSFER_DIMENSIONS;
+ static const uvec3 INITIAL_MIP_TRANSFER_DIMENSIONS;
+ static const size_t MAX_TRANSFER_SIZE;
+ static const size_t MAX_BUFFER_SIZE;
+
+protected:
// THe amount of memory currently allocated
Size _size { 0 };
@@ -148,10 +131,6 @@ protected:
// The lowest (highest resolution) mip that we will support, relative to the number
// of mips in the gpu::Texture object
uint16 _minAllocatedMip { 0 };
- // Contains a series of lambdas that when executed will transfer data to the GPU, modify
- // the _populatedMip and update the sampler in order to fully populate the allocated texture
- // until _populatedMip == _allocatedMip
- TransferQueue _pendingTransfers;
};
class GLTexture : public GLObject {
@@ -172,6 +151,9 @@ public:
static const std::vector& getFaceTargets(GLenum textureType);
static uint8_t getFaceCount(GLenum textureType);
static GLenum getGLTextureType(const Texture& texture);
+ virtual Size size() const = 0;
+ virtual Size copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const uvec3& size, uint32_t yOffset, GLenum internalFormat, GLenum format, GLenum type, Size sourceSize, const void* sourcePointer) const = 0;
+ virtual Size copyMipFaceFromTexture(uint16_t sourceMip, uint16_t targetMip, uint8_t face) const final;
static const uint8_t TEXTURE_2D_NUM_FACES = 1;
static const uint8_t TEXTURE_CUBE_NUM_FACES = 6;
@@ -180,12 +162,9 @@ public:
static const GLenum WRAP_MODES[Sampler::NUM_WRAP_MODES];
protected:
- virtual Size size() const = 0;
virtual void generateMips() const = 0;
virtual void syncSampler() const = 0;
- virtual Size copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const uvec3& size, uint32_t yOffset, GLenum internalFormat, GLenum format, GLenum type, Size sourceSize, const void* sourcePointer) const = 0;
- virtual Size copyMipFaceFromTexture(uint16_t sourceMip, uint16_t targetMip, uint8_t face) const final;
virtual void copyTextureMipsInGPUMem(GLuint srcId, GLuint destId, uint16_t srcMipOffset, uint16_t destMipOffset, uint16_t populatedMips) {} // Only relevant for Variable Allocation textures
GLTexture(const std::weak_ptr& backend, const Texture& texture, GLuint id);
@@ -205,7 +184,6 @@ protected:
Size size() const override { return 0; }
};
-
} }
#endif
diff --git a/libraries/gpu-gl-common/src/gpu/gl/GLTextureTransfer.cpp b/libraries/gpu-gl-common/src/gpu/gl/GLTextureTransfer.cpp
new file mode 100644
index 0000000000..56da8927a4
--- /dev/null
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLTextureTransfer.cpp
@@ -0,0 +1,502 @@
+//
+// Created by Bradley Austin Davis on 2016/05/15
+// Copyright 2013-2016 High Fidelity, Inc.
+//
+// Distributed under the Apache License, Version 2.0.
+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "GLTexture.h"
+
+#include
+#include
+
+#include "GLBackend.h"
+
+#define OVERSUBSCRIBED_PRESSURE_VALUE 0.95f
+#define UNDERSUBSCRIBED_PRESSURE_VALUE 0.85f
+#define DEFAULT_ALLOWED_TEXTURE_MEMORY_MB ((size_t)1024)
+#define MAX_RESOURCE_TEXTURES_PER_FRAME 2
+#define NO_BUFFER_WORK_SLEEP_TIME_MS 2
+#define THREADED_TEXTURE_BUFFERING 1
+
+static const size_t DEFAULT_ALLOWED_TEXTURE_MEMORY = MB_TO_BYTES(DEFAULT_ALLOWED_TEXTURE_MEMORY_MB);
+
+namespace gpu { namespace gl {
+
+enum class MemoryPressureState
+{
+ Idle,
+ Transfer,
+ Undersubscribed,
+};
+
+static MemoryPressureState _memoryPressureState{ MemoryPressureState::Idle };
+
+template
+struct LessPairSecond {
+ bool operator()(const T& a, const T& b) { return a.second < b.second; }
+};
+
+using QueuePair = std::pair;
+// Contains a priority sorted list of textures on which work is to be done over many frames
+// Uses a weak pointer to the texture to avoid keeping it in scope if the client stops using it
+using WorkQueue = std::priority_queue, LessPairSecond>;
+
+
+using ImmediateQueuePair = std::pair;
+// Contains a priority sorted list of textures on which work is to be done in the current frame
+using ImmediateWorkQueue = std::priority_queue, LessPairSecond>;
+
+// A map of weak texture pointers to queues of work to be done to transfer their data from the backing store to the GPU
+using TransferMap = std::map>;
+
+class GLTextureTransferEngineDefault : public GLTextureTransferEngine {
+ using Parent = GLTextureTransferEngine;
+public:
+ // Called once per frame by the GLBackend to manage texture memory
+ // Will deallocate textures if oversubscribed,
+ void manageMemory() override;
+ void shutdown() override;
+
+protected:
+ class TextureBufferThread : public QThread {
+ public:
+ TextureBufferThread(GLTextureTransferEngineDefault& parent) : _parent(parent) { start(); }
+
+ protected:
+ void run() override {
+ while (!_parent._shutdown) {
+ if (!_parent.processActiveBufferQueue()) {
+ QThread::msleep(NO_BUFFER_WORK_SLEEP_TIME_MS);
+ }
+ }
+ }
+
+ GLTextureTransferEngineDefault& _parent;
+ };
+
+ using ActiveTransferJob = std::pair;
+ using ActiveTransferQueue = std::list;
+
+ void populateActiveBufferQueue();
+ bool processActiveBufferQueue();
+ void processTransferQueues();
+ void populateTransferQueue(const TexturePointer& texturePointer);
+ //void addToWorkQueue(const TexturePointer& texturePointer);
+ void updateMemoryPressure();
+
+ void processDemotes(size_t relief, const std::vector& strongTextures);
+ void processPromotes();
+
+private:
+ std::atomic _shutdown{ false };
+ // Contains a priority sorted list of weak texture pointers that have been determined to be eligible for additional allocation
+ // While the memory state is 'undersubscribed', items will be removed from this list and processed, allocating additional memory
+ // per frame
+ WorkQueue _promoteQueue;
+ // This queue contains jobs that will buffer data from the texture backing store (ideally a memory mapped KTX file)
+ // to a CPU memory buffer. This queue is populated on the main GPU thread, and drained on a dedicated thread.
+ // When an item on the _activeBufferQueue is completed it is put into the _activeTransferQueue
+ ActiveTransferQueue _activeBufferQueue;
+ // This queue contains jobs that will upload data from a CPU buffer into a GPU. This queue is populated on the background
+ // thread that process the _activeBufferQueue and drained on the main GPU thread
+ ActiveTransferQueue _activeTransferQueue;
+ // Mutex protecting the _activeTransferQueue & _activeBufferQueue since they are each accessed both from the main GPU thread
+ // and the buffering thread
+ Mutex _bufferMutex;
+ // The buffering thread which drains the _activeBufferQueue and populates the _activeTransferQueue
+ TextureBufferThread* _transferThread{ nullptr };
+ // The amount of buffering work currently represented by the _activeBufferQueue
+ std::atomic _queuedBufferSize{ 0 };
+ // This contains a map of all textures to queues of pending transfer jobs. While in the transfer state, this map is used to
+ // populate the _activeBufferQueue up to the limit specified in GLVariableAllocationTexture::MAX_BUFFER_SIZE
+ TransferMap _pendingTransfersMap;
+};
+
+}} // namespace gpu::gl
+
+using namespace gpu;
+using namespace gpu::gl;
+
+void GLBackend::initTextureManagementStage() {
+ _textureManagement._transferEngine = std::make_shared();
+}
+
+void GLBackend::killTextureManagementStage() {
+ _textureManagement._transferEngine->shutdown();
+ _textureManagement._transferEngine.reset();
+}
+
+std::vector GLTextureTransferEngine::getAllTextures() {
+ std::vector result;
+ result.reserve(_registeredTextures.size());
+ std::remove_if(_registeredTextures.begin(), _registeredTextures.end(), [&](const std::weak_ptr& weak)->bool {
+ auto strong = weak.lock();
+ bool strongResult = strong.operator bool();
+ if (strongResult) {
+ result.push_back(strong);
+ }
+ return strongResult;
+ });
+ return result;
+}
+
+void GLTextureTransferEngine::addMemoryManagedTexture(const TexturePointer& texturePointer) {
+ ++_frameTexturesCreated;
+ _registeredTextures.push_back(texturePointer);
+}
+
+void GLTextureTransferEngineDefault::shutdown() {
+ _shutdown = true;
+#if THREADED_TEXTURE_BUFFERING
+ if (_transferThread) {
+ _transferThread->wait();
+ delete _transferThread;
+ _transferThread = nullptr;
+ }
+#endif
+}
+
+
+void GLTextureTransferEngineDefault::manageMemory() {
+ PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
+ // reset the count used to limit the number of textures created per frame
+ resetFrameTextureCreated();
+ // Determine the current memory management state. It will be either idle (no work to do),
+ // undersubscribed (need to do more allocation) or transfer (need to upload content from the
+ // backing store to the GPU
+ updateMemoryPressure();
+ if (MemoryPressureState::Undersubscribed == _memoryPressureState) {
+ // If we're undersubscribed, we need to process some of the textures that can have additional allocation
+ processPromotes();
+ } else if (MemoryPressureState::Transfer == _memoryPressureState) {
+ // If we're in transfer mode we need to manage the buffering and upload queues
+ processTransferQueues();
+ }
+}
+
+// Each frame we will check if our memory pressure state has changed.
+void GLTextureTransferEngineDefault::updateMemoryPressure() {
+ PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
+
+ size_t allowedMemoryAllocation = gpu::Texture::getAllowedGPUMemoryUsage();
+ if (0 == allowedMemoryAllocation) {
+ allowedMemoryAllocation = DEFAULT_ALLOWED_TEXTURE_MEMORY;
+ }
+
+ // Clear any defunct textures (weak pointers that no longer have a valid texture)
+ auto strongTextures = getAllTextures();
+
+ size_t totalVariableMemoryAllocation = 0;
+ size_t idealMemoryAllocation = 0;
+ bool canDemote = false;
+ bool canPromote = false;
+ bool hasTransfers = false;
+ for (const auto& texture : strongTextures) {
+ GLTexture* gltexture = Backend::getGPUObject(*texture);
+ GLVariableAllocationSupport* vartexture = dynamic_cast(gltexture);
+ vartexture->sanityCheck();
+
+ // Track how much the texture thinks it should be using
+ idealMemoryAllocation += texture->evalTotalSize();
+ // Track how much we're actually using
+ totalVariableMemoryAllocation += gltexture->size();
+ if (vartexture->canDemote()) {
+ canDemote |= true;
+ }
+ if (vartexture->canPromote()) {
+ canPromote |= true;
+ }
+ if (vartexture->hasPendingTransfers()) {
+ hasTransfers |= true;
+ }
+ }
+
+ Backend::textureResourceIdealGPUMemSize.set(idealMemoryAllocation);
+ size_t unallocated = idealMemoryAllocation - totalVariableMemoryAllocation;
+ float pressure = (float)totalVariableMemoryAllocation / (float)allowedMemoryAllocation;
+
+ // If we're oversubscribed we need to demote textures IMMEDIATELY
+ if (pressure > OVERSUBSCRIBED_PRESSURE_VALUE && canDemote) {
+ auto overPressure = pressure - OVERSUBSCRIBED_PRESSURE_VALUE;
+ size_t relief = (size_t)(overPressure * totalVariableMemoryAllocation);
+ processDemotes(relief, strongTextures);
+ return;
+ }
+
+
+ auto newState = MemoryPressureState::Idle;
+ if (pressure < UNDERSUBSCRIBED_PRESSURE_VALUE && (unallocated != 0 && canPromote)) {
+ newState = MemoryPressureState::Undersubscribed;
+ } else if (hasTransfers) {
+ newState = MemoryPressureState::Transfer;
+ } else {
+ Lock lock(_bufferMutex);
+ if (!_activeBufferQueue.empty() || !_activeTransferQueue.empty() || !_pendingTransfersMap.empty()) {
+ newState = MemoryPressureState::Transfer;
+ }
+ }
+
+ // If we've changed state then we have to populate the appropriate structure with the work to be done
+ if (newState != _memoryPressureState) {
+ _memoryPressureState = newState;
+ _promoteQueue = WorkQueue();
+ _pendingTransfersMap.clear();
+
+ if (MemoryPressureState::Idle == _memoryPressureState) {
+ return;
+ }
+
+ // For each texture, if it's eligible for work in the current state, put it into the appropriate structure
+ for (const auto& texture : strongTextures) {
+ GLTexture* gltexture = Backend::getGPUObject(*texture);
+ GLVariableAllocationSupport* vargltexture = dynamic_cast(gltexture);
+ if (MemoryPressureState::Undersubscribed == _memoryPressureState && vargltexture->canPromote()) {
+ // Promote smallest first
+ _promoteQueue.push({ texture, 1.0f / (float)gltexture->size() });
+ } else if (MemoryPressureState::Transfer == _memoryPressureState && vargltexture->hasPendingTransfers()) {
+ populateTransferQueue(texture);
+ }
+ }
+ }
+}
+
+// Manage the _activeBufferQueue and _activeTransferQueue queues
+void GLTextureTransferEngineDefault::processTransferQueues() {
+#if THREADED_TEXTURE_BUFFERING
+ if (!_transferThread) {
+ _transferThread = new TextureBufferThread(*this);
+ }
+#endif
+
+
+ // From the pendingTransferMap, queue jobs into the _activeBufferQueue
+ // Doing so will lock the weak texture pointer so that it can't be destroyed
+ // while the background thread is working.
+ //
+ // This will queue jobs until _queuedBufferSize can't be increased without exceeding
+ // GLVariableAllocationTexture::MAX_BUFFER_SIZE or there is no more work to be done
+ populateActiveBufferQueue();
+#if !THREADED_TEXTURE_BUFFERING
+ processActiveBufferQueue();
+#endif
+
+ // Take any tasks which have completed buffering and process them, uploading the buffered
+ // data to the GPU. Drains the _activeTransferQueue
+ {
+ ActiveTransferQueue activeTransferQueue;
+ {
+ Lock lock(_bufferMutex);
+ activeTransferQueue.swap(_activeTransferQueue);
+ }
+
+ while (!activeTransferQueue.empty()) {
+ const auto& activeTransferJob = activeTransferQueue.front();
+ const auto& texturePointer = activeTransferJob.first;
+ const auto& tranferJob = activeTransferJob.second;
+ tranferJob->transfer(texturePointer);
+ // The pop_front MUST be the last call since all of these varaibles in scope are
+ // references that will be invalid after the pop
+ activeTransferQueue.pop_front();
+ }
+ }
+
+ // If we have no more work in any of the structures, reset the memory state to idle to
+ // force reconstruction of the _pendingTransfersMap if necessary
+ {
+ Lock lock(_bufferMutex);
+ if (_activeTransferQueue.empty() && _activeBufferQueue.empty() && _pendingTransfersMap.empty()) {
+ _memoryPressureState = MemoryPressureState::Idle;
+ }
+ }
+}
+
+void GLTextureTransferEngineDefault::populateActiveBufferQueue() {
+ size_t queuedBufferSize = _queuedBufferSize;
+ static const auto& MAX_BUFFER_SIZE = GLVariableAllocationSupport::MAX_BUFFER_SIZE;
+ Q_ASSERT(queuedBufferSize <= MAX_BUFFER_SIZE);
+ size_t availableBufferSize = MAX_BUFFER_SIZE - queuedBufferSize;
+
+ // Queue up buffering jobs
+ ActiveTransferQueue newBufferJobs;
+ size_t newTransferSize{ 0 };
+
+ for (auto itr = _pendingTransfersMap.begin(); itr != _pendingTransfersMap.end(); ) {
+ const auto& weakTexture = itr->first;
+ const auto texture = weakTexture.lock();
+
+ // Texture no longer exists, remove from the transfer map and move on
+ if (!texture) {
+ itr = _pendingTransfersMap.erase(itr);
+ continue;
+ }
+
+ GLTexture* gltexture = Backend::getGPUObject(*texture);
+ GLVariableAllocationSupport* vargltexture = dynamic_cast(gltexture);
+
+ auto& textureTransferQueue = itr->second;
+ // Can't find any pending transfers, so move on
+ if (textureTransferQueue.empty()) {
+ if (vargltexture->hasPendingTransfers()) {
+ qWarning(gpugllogging) << "Texture has no transfer jobs, but has pending transfers";
+ }
+ itr = _pendingTransfersMap.erase(itr);
+ continue;
+ }
+
+ const auto& transferJob = textureTransferQueue.front();
+ const auto& transferSize = transferJob->size();
+ // If there's not enough space for the buffering, then break out of the loop
+ if (transferSize > availableBufferSize) {
+ break;
+ }
+ availableBufferSize -= transferSize;
+ Q_ASSERT(availableBufferSize <= MAX_BUFFER_SIZE);
+ Q_ASSERT(newTransferSize <= MAX_BUFFER_SIZE);
+ newTransferSize += transferSize;
+ Q_ASSERT(newTransferSize <= MAX_BUFFER_SIZE);
+ newBufferJobs.emplace_back(texture, transferJob);
+ textureTransferQueue.pop();
+ ++itr;
+ }
+
+ {
+ Lock lock(_bufferMutex);
+ _activeBufferQueue.splice(_activeBufferQueue.end(), newBufferJobs);
+ Q_ASSERT(_queuedBufferSize <= MAX_BUFFER_SIZE);
+ _queuedBufferSize += newTransferSize;
+ Q_ASSERT(_queuedBufferSize <= MAX_BUFFER_SIZE);
+ }
+}
+
+bool GLTextureTransferEngineDefault::processActiveBufferQueue() {
+ ActiveTransferQueue activeBufferQueue;
+ {
+ Lock lock(_bufferMutex);
+ _activeBufferQueue.swap(activeBufferQueue);
+ }
+
+ if (activeBufferQueue.empty()) {
+ return false;
+ }
+
+ for (const auto& activeJob : activeBufferQueue) {
+ const auto& texture = activeJob.first;
+ const auto& transferJob = activeJob.second;
+ // Some jobs don't require buffering, but they pass through this queue to ensure that we don't re-order
+ // the buffering & transfer operations. All jobs in the queue must be processed in order.
+ if (!transferJob->bufferingRequired()) {
+ continue;
+ }
+ const auto& transferSize = transferJob->size();
+ transferJob->buffer(texture);
+ Q_ASSERT(_queuedBufferSize >= transferSize);
+ _queuedBufferSize -= transferSize;
+ }
+
+ {
+ Lock lock(_bufferMutex);
+ _activeTransferQueue.splice(_activeTransferQueue.end(), activeBufferQueue);
+ }
+
+ return true;
+}
+
+void GLTextureTransferEngineDefault::populateTransferQueue(const TexturePointer& texturePointer) {
+ TextureWeakPointer weakTexture = texturePointer;
+ GLTexture* gltexture = Backend::getGPUObject(*texturePointer);
+ GLVariableAllocationSupport* vargltexture = dynamic_cast(gltexture);
+ TransferJob::Queue pendingTransfers;
+ PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
+ vargltexture->populateTransferQueue(pendingTransfers);
+ if (!pendingTransfers.empty()) {
+ _pendingTransfersMap[weakTexture] = pendingTransfers;
+ }
+}
+
+// From the queue of textures to be promited
+void GLTextureTransferEngineDefault::processPromotes() {
+ // FIXME use max allocated memory per frame instead of promotion count
+ static const size_t MAX_ALLOCATED_BYTES_PER_FRAME = GLVariableAllocationSupport::MAX_BUFFER_SIZE;
+ static const size_t MAX_ALLOCATIONS_PER_FRAME = 8;
+ size_t allocatedBytes{ 0 };
+ size_t allocations{ 0 };
+
+ while (!_promoteQueue.empty()) {
+ // Grab the first item off the demote queue
+ PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
+ auto entry = _promoteQueue.top();
+ _promoteQueue.pop();
+ auto texture = entry.first.lock();
+ if (!texture) {
+ continue;
+ }
+
+ GLTexture* gltexture = Backend::getGPUObject(*texture);
+ GLVariableAllocationSupport* vartexture = dynamic_cast(gltexture);
+ auto originalSize = gltexture->size();
+ vartexture->promote();
+ auto allocationDelta = gltexture->size() - originalSize;
+ if (vartexture->canPromote()) {
+ // Promote smallest first
+ _promoteQueue.push({ texture, 1.0f / (float)gltexture->size() });
+ }
+ allocatedBytes += allocationDelta;
+ if (++allocations >= MAX_ALLOCATIONS_PER_FRAME) {
+ break;
+ }
+ if (allocatedBytes >= MAX_ALLOCATED_BYTES_PER_FRAME) {
+ break;
+ }
+ }
+
+ // Get the front of the work queue to perform work
+ if (_promoteQueue.empty()) {
+ // Force rebuild of work queue
+ _memoryPressureState = MemoryPressureState::Idle;
+ }
+}
+
+void GLTextureTransferEngineDefault::processDemotes(size_t reliefRequired, const std::vector& strongTextures) {
+ // Demote largest first
+ ImmediateWorkQueue demoteQueue;
+ for (const auto& texture : strongTextures) {
+ GLTexture* gltexture = Backend::getGPUObject(*texture);
+ GLVariableAllocationSupport* vargltexture = dynamic_cast(gltexture);
+ if (vargltexture->canDemote()) {
+ demoteQueue.push({ texture, (float)gltexture->size() });
+ }
+ }
+
+ size_t relieved = 0;
+ while (!demoteQueue.empty() && relieved < reliefRequired) {
+ {
+ const auto& target = demoteQueue.top();
+ const auto& texture = target.first;
+ GLTexture* gltexture = Backend::getGPUObject(*texture);
+ auto oldSize = gltexture->size();
+ GLVariableAllocationSupport* vargltexture = dynamic_cast(gltexture);
+ vargltexture->demote();
+ auto newSize = gltexture->size();
+ relieved += (oldSize - newSize);
+ }
+ demoteQueue.pop();
+ }
+}
+
+// FIXME hack for stats display
+QString getTextureMemoryPressureModeString() {
+ switch (_memoryPressureState) {
+ case MemoryPressureState::Undersubscribed:
+ return "Undersubscribed";
+
+ case MemoryPressureState::Transfer:
+ return "Transfer";
+
+ case MemoryPressureState::Idle:
+ return "Idle";
+ }
+ Q_UNREACHABLE();
+ return "Unknown";
+}
diff --git a/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h b/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h
index f3b452b1f9..23dcac0d8d 100644
--- a/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h
+++ b/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h
@@ -114,9 +114,9 @@ public:
void allocateStorage(uint16 allocatedMip);
void syncSampler() const override;
- void promote() override;
- void demote() override;
- void populateTransferQueue() override;
+ size_t promote() override;
+ size_t demote() override;
+ void populateTransferQueue(TransferQueue& pendingTransfers) override;
Size copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const uvec3& size, uint32_t yOffset, GLenum internalFormat, GLenum format, GLenum type, Size sourceSize, const void* sourcePointer) const override;
Size copyMipsFromTexture();
diff --git a/libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp b/libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp
index 0298b8b892..00f7ae284f 100644
--- a/libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp
@@ -72,7 +72,7 @@ GLTexture* GL41Backend::syncGPUObject(const TexturePointer& texturePointer) {
case TextureUsageType::RESOURCE:
qCDebug(gpugllogging) << "variable / Strict texture " << texture.source().c_str();
object = new GL41ResourceTexture(shared_from_this(), texture);
- GLVariableAllocationSupport::addMemoryManagedTexture(texturePointer);
+ _textureManagement._transferEngine->addMemoryManagedTexture(texturePointer);
break;
default:
@@ -86,7 +86,6 @@ GLTexture* GL41Backend::syncGPUObject(const TexturePointer& texturePointer) {
auto minAvailableMip = texture.minAvailableMipLevel();
if (minAvailableMip < varTex->_minAllocatedMip) {
varTex->_minAllocatedMip = minAvailableMip;
- GL41VariableAllocationTexture::_memoryPressureStateStale = true;
}
}
}
@@ -299,9 +298,7 @@ GL41VariableAllocationTexture::GL41VariableAllocationTexture(const std::weak_ptr
uint16_t allocatedMip = std::max(_minAllocatedMip, targetMip);
allocateStorage(allocatedMip);
- _memoryPressureStateStale = true;
copyMipsFromTexture();
-
syncSampler();
}
@@ -341,8 +338,7 @@ Size GL41VariableAllocationTexture::copyMipsFromTexture() {
amount += copyMipFaceFromTexture(sourceMip, targetMip, face);
}
}
-
-
+ incrementPopulatedSize(amount);
return amount;
}
@@ -351,7 +347,6 @@ Size GL41VariableAllocationTexture::copyMipFaceLinesFromTexture(uint16_t mip, ui
withPreservedTexture([&] {
amountCopied = Parent::copyMipFaceLinesFromTexture(mip, face, size, yOffset, internalFormat, format, type, sourceSize, sourcePointer);
});
- incrementPopulatedSize(amountCopied);
return amountCopied;
}
@@ -496,7 +491,7 @@ void GL41VariableAllocationTexture::copyTextureMipsInGPUMem(GLuint srcId, GLuint
});
}
-void GL41VariableAllocationTexture::promote() {
+size_t GL41VariableAllocationTexture::promote() {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
Q_ASSERT(_allocatedMip > 0);
@@ -524,12 +519,11 @@ void GL41VariableAllocationTexture::promote() {
// update the memory usage
Backend::textureResourceGPUMemSize.update(oldSize, 0);
+ return (_size - oldSize);
// no change to Backend::textureResourcePopulatedGPUMemSize
-
- populateTransferQueue();
}
-void GL41VariableAllocationTexture::demote() {
+size_t GL41VariableAllocationTexture::demote() {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
Q_ASSERT(_allocatedMip < _maxAllocatedMip);
auto oldId = _id;
@@ -563,16 +557,16 @@ void GL41VariableAllocationTexture::demote() {
}
decrementPopulatedSize(amountUnpopulated);
}
- populateTransferQueue();
+
+ return oldSize - _size;
}
-void GL41VariableAllocationTexture::populateTransferQueue() {
+void GL41VariableAllocationTexture::populateTransferQueue(TransferQueue& pendingTransfers) {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
if (_populatedMip <= _allocatedMip) {
return;
}
- _pendingTransfers = TransferQueue();
const uint8_t maxFace = GLTexture::getFaceCount(_target);
uint16_t sourceMip = _populatedMip;
@@ -588,7 +582,7 @@ void GL41VariableAllocationTexture::populateTransferQueue() {
// If the mip is less than the max transfer size, then just do it in one transfer
if (glm::all(glm::lessThanEqual(mipDimensions, MAX_TRANSFER_DIMENSIONS))) {
// Can the mip be transferred in one go
- _pendingTransfers.emplace(new TransferJob(*this, sourceMip, targetMip, face));
+ pendingTransfers.emplace(new TransferJob(_gpuObject, sourceMip, targetMip, face));
continue;
}
@@ -605,14 +599,16 @@ void GL41VariableAllocationTexture::populateTransferQueue() {
uint32_t lineOffset = 0;
while (lineOffset < lines) {
uint32_t linesToCopy = std::min(lines - lineOffset, linesPerTransfer);
- _pendingTransfers.emplace(new TransferJob(*this, sourceMip, targetMip, face, linesToCopy, lineOffset));
+ pendingTransfers.emplace(new TransferJob(_gpuObject, sourceMip, targetMip, face, linesToCopy, lineOffset));
lineOffset += linesToCopy;
}
}
// queue up the sampler and populated mip change for after the transfer has completed
- _pendingTransfers.emplace(new TransferJob(*this, [=] {
+ pendingTransfers.emplace(new TransferJob([=] {
_populatedMip = sourceMip;
+ incrementPopulatedSize(_gpuObject.evalMipSize(sourceMip));
+ sanityCheck();
syncSampler();
}));
} while (sourceMip != _allocatedMip);
diff --git a/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h b/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h
index 616b6d1075..0db9271f57 100644
--- a/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h
@@ -187,9 +187,9 @@ public:
GL45ResourceTexture(const std::weak_ptr& backend, const Texture& texture);
void syncSampler() const override;
- void promote() override;
- void demote() override;
- void populateTransferQueue() override;
+ size_t promote() override;
+ size_t demote() override;
+ void populateTransferQueue(TransferQueue& pendingTransfers) override;
void allocateStorage(uint16 mip);
diff --git a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
index 6b3c99ccc3..558f221705 100644
--- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
@@ -28,7 +28,6 @@ using namespace gpu;
using namespace gpu::gl;
using namespace gpu::gl45;
-#define MAX_RESOURCE_TEXTURES_PER_FRAME 2
#define FORCE_STRICT_TEXTURE 0
#define ENABLE_SPARSE_TEXTURE 0
@@ -82,7 +81,8 @@ GLTexture* GL45Backend::syncGPUObject(const TexturePointer& texturePointer) {
#if !FORCE_STRICT_TEXTURE
case TextureUsageType::RESOURCE: {
- if (GL45VariableAllocationTexture::_frameTexturesCreated < MAX_RESOURCE_TEXTURES_PER_FRAME) {
+ auto& transferEngine = _textureManagement._transferEngine;
+ if (transferEngine->allowCreate()) {
#if ENABLE_SPARSE_TEXTURE
if (isTextureManagementSparseEnabled() && GL45Texture::isSparseEligible(texture)) {
object = new GL45SparseResourceTexture(shared_from_this(), texture);
@@ -92,7 +92,7 @@ GLTexture* GL45Backend::syncGPUObject(const TexturePointer& texturePointer) {
#else
object = new GL45ResourceTexture(shared_from_this(), texture);
#endif
- GLVariableAllocationSupport::addMemoryManagedTexture(texturePointer);
+ transferEngine->addMemoryManagedTexture(texturePointer);
} else {
auto fallback = texturePointer->getFallbackTexture();
if (fallback) {
@@ -114,7 +114,6 @@ GLTexture* GL45Backend::syncGPUObject(const TexturePointer& texturePointer) {
auto minAvailableMip = texture.minAvailableMipLevel();
if (minAvailableMip < varTex->_minAllocatedMip) {
varTex->_minAllocatedMip = minAvailableMip;
- GL45VariableAllocationTexture::_memoryPressureStateStale = true;
}
}
}
@@ -124,6 +123,7 @@ GLTexture* GL45Backend::syncGPUObject(const TexturePointer& texturePointer) {
}
void GL45Backend::initTextureManagementStage() {
+ GLBackend::initTextureManagementStage();
// enable the Sparse Texture on gl45
_textureManagement._sparseCapable = true;
diff --git a/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp b/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp
index 08d077605d..713b99fc77 100644
--- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp
@@ -31,7 +31,6 @@ using GL45Texture = GL45Backend::GL45Texture;
using GL45VariableAllocationTexture = GL45Backend::GL45VariableAllocationTexture;
GL45VariableAllocationTexture::GL45VariableAllocationTexture(const std::weak_ptr& backend, const Texture& texture) : GL45Texture(backend, texture) {
- ++_frameTexturesCreated;
Backend::textureResourceCount.increment();
}
@@ -55,7 +54,6 @@ const GL45Texture::Bindless& GL45VariableAllocationTexture::getBindless() const
Size GL45VariableAllocationTexture::copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const uvec3& size, uint32_t yOffset, GLenum internalFormat, GLenum format, GLenum type, Size sourceSize, const void* sourcePointer) const {
Size amountCopied = 0;
amountCopied = Parent::copyMipFaceLinesFromTexture(mip, face, size, yOffset, internalFormat, format, type, sourceSize, sourcePointer);
- incrementPopulatedSize(amountCopied);
return amountCopied;
}
@@ -82,7 +80,6 @@ void GL45VariableAllocationTexture::copyTextureMipsInGPUMem(GLuint srcId, GLuint
copyTexGPUMem(_gpuObject, _target, srcId, destId, numMips, srcMipOffset, destMipOffset, populatedMips);
}
-
// Managed size resource textures
using GL45ResourceTexture = GL45Backend::GL45ResourceTexture;
@@ -104,7 +101,6 @@ GL45ResourceTexture::GL45ResourceTexture(const std::weak_ptr& backend
uint16_t allocatedMip = std::max(_minAllocatedMip, targetMip);
allocateStorage(allocatedMip);
- _memoryPressureStateStale = true;
copyMipsFromTexture();
syncSampler();
}
@@ -134,6 +130,7 @@ Size GL45ResourceTexture::copyMipsFromTexture() {
amount += copyMipFaceFromTexture(sourceMip, targetMip, face);
}
}
+ incrementPopulatedSize(amount);
return amount;
}
@@ -141,14 +138,14 @@ void GL45ResourceTexture::syncSampler() const {
Parent::syncSampler();
#if GPU_BINDLESS_TEXTURES
if (!isBindless()) {
- glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, _populatedMip - _allocatedMip);
+ glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, _populatedMip - _allocatedMip);
}
#else
glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, _populatedMip - _allocatedMip);
#endif
}
-void GL45ResourceTexture::promote() {
+size_t GL45ResourceTexture::promote() {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
Q_ASSERT(_allocatedMip > 0);
@@ -171,7 +168,7 @@ void GL45ResourceTexture::promote() {
// allocate storage for new level
allocateStorage(targetAllocatedMip);
-
+
// copy pre-existing mips
copyTextureMipsInGPUMem(oldId, _id, oldAllocatedMip, _allocatedMip, _populatedMip);
@@ -191,11 +188,10 @@ void GL45ResourceTexture::promote() {
// update the memory usage
Backend::textureResourceGPUMemSize.update(oldSize, 0);
// no change to Backend::textureResourcePopulatedGPUMemSize
-
- populateTransferQueue();
+ return (_size - oldSize);
}
-void GL45ResourceTexture::demote() {
+size_t GL45ResourceTexture::demote() {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
Q_ASSERT(_allocatedMip < _maxAllocatedMip);
auto oldId = _id;
@@ -233,25 +229,25 @@ void GL45ResourceTexture::demote() {
// update the memory usage
Backend::textureResourceGPUMemSize.update(oldSize, 0);
- // Demoting unpopulate the memory delta
+ // Demoting unpopulate the memory delta
if (oldPopulatedMip != _populatedMip) {
auto numPopulatedDemoted = _populatedMip - oldPopulatedMip;
Size amountUnpopulated = 0;
for (int i = 0; i < numPopulatedDemoted; i++) {
- amountUnpopulated += _gpuObject.evalMipSize(oldPopulatedMip + i);
+ amountUnpopulated += _gpuObject.evalMipSize(oldPopulatedMip + i);
}
- decrementPopulatedSize(amountUnpopulated);
+ decrementPopulatedSize(amountUnpopulated);
}
-
- populateTransferQueue();
+ return (oldSize - _size);
}
-void GL45ResourceTexture::populateTransferQueue() {
+void GL45ResourceTexture::populateTransferQueue(TransferQueue& pendingTransfers) {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
+ sanityCheck();
+
if (_populatedMip <= _allocatedMip) {
return;
}
- _pendingTransfers = TransferQueue();
const uint8_t maxFace = GLTexture::getFaceCount(_target);
uint16_t sourceMip = _populatedMip;
@@ -267,16 +263,16 @@ void GL45ResourceTexture::populateTransferQueue() {
// If the mip is less than the max transfer size, then just do it in one transfer
if (glm::all(glm::lessThanEqual(mipDimensions, MAX_TRANSFER_DIMENSIONS))) {
// Can the mip be transferred in one go
- _pendingTransfers.emplace(new TransferJob(*this, sourceMip, targetMip, face));
+ pendingTransfers.emplace(new TransferJob(_gpuObject, sourceMip, targetMip, face));
continue;
}
- // break down the transfers into chunks so that no single transfer is
+ // break down the transfers into chunks so that no single transfer is
// consuming more than X bandwidth
// For compressed format, regions must be a multiple of the 4x4 tiles, so enforce 4 lines as the minimum block
auto mipSize = _gpuObject.getStoredMipFaceSize(sourceMip, face);
const auto lines = mipDimensions.y;
- const uint32_t BLOCK_NUM_LINES { 4 };
+ const uint32_t BLOCK_NUM_LINES{ 4 };
const auto numBlocks = (lines + (BLOCK_NUM_LINES - 1)) / BLOCK_NUM_LINES;
auto bytesPerBlock = mipSize / numBlocks;
Q_ASSERT(0 == (mipSize % lines));
@@ -284,14 +280,16 @@ void GL45ResourceTexture::populateTransferQueue() {
uint32_t lineOffset = 0;
while (lineOffset < lines) {
uint32_t linesToCopy = std::min(lines - lineOffset, linesPerTransfer);
- _pendingTransfers.emplace(new TransferJob(*this, sourceMip, targetMip, face, linesToCopy, lineOffset));
+ pendingTransfers.emplace(new TransferJob(_gpuObject, sourceMip, targetMip, face, linesToCopy, lineOffset));
lineOffset += linesToCopy;
}
}
// queue up the sampler and populated mip change for after the transfer has completed
- _pendingTransfers.emplace(new TransferJob(*this, [=] {
+ pendingTransfers.emplace(new TransferJob([=] {
_populatedMip = sourceMip;
+ incrementPopulatedSize(_gpuObject.evalMipSize(sourceMip));
+ sanityCheck();
syncSampler();
}));
} while (sourceMip != _allocatedMip);
diff --git a/libraries/gpu-gles/src/gpu/gles/GLESBackend.h b/libraries/gpu-gles/src/gpu/gles/GLESBackend.h
index 47a123718a..cb8e4abb29 100644
--- a/libraries/gpu-gles/src/gpu/gles/GLESBackend.h
+++ b/libraries/gpu-gles/src/gpu/gles/GLESBackend.h
@@ -105,9 +105,9 @@ public:
void allocateStorage(uint16 allocatedMip);
void syncSampler() const override;
- void promote() override;
- void demote() override;
- void populateTransferQueue() override;
+ size_t promote() override;
+ size_t demote() override;
+ void populateTransferQueue(TransferJob::Queue& queue) override;
Size copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const uvec3& size, uint32_t yOffset, GLenum internalFormat, GLenum format, GLenum type, Size sourceSize, const void* sourcePointer) const override;
Size copyMipsFromTexture();
diff --git a/libraries/gpu-gles/src/gpu/gles/GLESBackendTexture.cpp b/libraries/gpu-gles/src/gpu/gles/GLESBackendTexture.cpp
index 2009dc5dc9..7419221889 100644
--- a/libraries/gpu-gles/src/gpu/gles/GLESBackendTexture.cpp
+++ b/libraries/gpu-gles/src/gpu/gles/GLESBackendTexture.cpp
@@ -90,7 +90,6 @@ GLTexture* GLESBackend::syncGPUObject(const TexturePointer& texturePointer) {
auto minAvailableMip = texture.minAvailableMipLevel();
if (minAvailableMip < varTex->_minAllocatedMip) {
varTex->_minAllocatedMip = minAvailableMip;
- GLESVariableAllocationTexture::_memoryPressureStateStale = true;
}
}
}
@@ -361,7 +360,6 @@ GLESVariableAllocationTexture::GLESVariableAllocationTexture(const std::weak_ptr
uint16_t allocatedMip = std::max(_minAllocatedMip, targetMip);
allocateStorage(allocatedMip);
- _memoryPressureStateStale = true;
copyMipsFromTexture();
syncSampler();
@@ -403,8 +401,7 @@ Size GLESVariableAllocationTexture::copyMipsFromTexture() {
amount += copyMipFaceFromTexture(sourceMip, targetMip, face);
}
}
-
-
+ incrementPopulatedSize(amount);
return amount;
}
@@ -413,7 +410,6 @@ Size GLESVariableAllocationTexture::copyMipFaceLinesFromTexture(uint16_t mip, ui
withPreservedTexture([&] {
amountCopied = Parent::copyMipFaceLinesFromTexture(mip, face, size, yOffset, internalFormat, format, type, sourceSize, sourcePointer);
});
- incrementPopulatedSize(amountCopied);
return amountCopied;
}
@@ -559,7 +555,7 @@ void GLESVariableAllocationTexture::copyTextureMipsInGPUMem(GLuint srcId, GLuint
});
}
-void GLESVariableAllocationTexture::promote() {
+size_t GLESVariableAllocationTexture::promote() {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
Q_ASSERT(_allocatedMip > 0);
@@ -587,12 +583,11 @@ void GLESVariableAllocationTexture::promote() {
// update the memory usage
Backend::textureResourceGPUMemSize.update(oldSize, 0);
- // no change to Backend::textureResourcePopulatedGPUMemSize
- populateTransferQueue();
+ return _size - oldSize;
}
-void GLESVariableAllocationTexture::demote() {
+size_t GLESVariableAllocationTexture::demote() {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
Q_ASSERT(_allocatedMip < _maxAllocatedMip);
auto oldId = _id;
@@ -626,16 +621,16 @@ void GLESVariableAllocationTexture::demote() {
}
decrementPopulatedSize(amountUnpopulated);
}
- populateTransferQueue();
+
+ return oldSize - _size;
}
-void GLESVariableAllocationTexture::populateTransferQueue() {
+void GLESVariableAllocationTexture::populateTransferQueue(TransferJob::Queue& queue) {
PROFILE_RANGE(render_gpu_gl, __FUNCTION__);
if (_populatedMip <= _allocatedMip) {
return;
}
- _pendingTransfers = TransferQueue();
const uint8_t maxFace = GLTexture::getFaceCount(_target);
uint16_t sourceMip = _populatedMip;
@@ -651,7 +646,7 @@ void GLESVariableAllocationTexture::populateTransferQueue() {
// If the mip is less than the max transfer size, then just do it in one transfer
if (glm::all(glm::lessThanEqual(mipDimensions, MAX_TRANSFER_DIMENSIONS))) {
// Can the mip be transferred in one go
- _pendingTransfers.emplace(new TransferJob(*this, sourceMip, targetMip, face));
+ queue.emplace(new TransferJob(_gpuObject, sourceMip, targetMip, face));
continue;
}
@@ -668,14 +663,16 @@ void GLESVariableAllocationTexture::populateTransferQueue() {
uint32_t lineOffset = 0;
while (lineOffset < lines) {
uint32_t linesToCopy = std::min(lines - lineOffset, linesPerTransfer);
- _pendingTransfers.emplace(new TransferJob(*this, sourceMip, targetMip, face, linesToCopy, lineOffset));
+ queue.emplace(new TransferJob(_gpuObject, sourceMip, targetMip, face, linesToCopy, lineOffset));
lineOffset += linesToCopy;
}
}
// queue up the sampler and populated mip change for after the transfer has completed
- _pendingTransfers.emplace(new TransferJob(*this, [=] {
+ queue.emplace(new TransferJob([=] {
_populatedMip = sourceMip;
+ incrementPopulatedSize(_gpuObject.evalMipSize(sourceMip));
+ sanityCheck();
syncSampler();
}));
} while (sourceMip != _allocatedMip);
diff --git a/libraries/gpu/src/gpu/Context.cpp b/libraries/gpu/src/gpu/Context.cpp
index 75c80a0164..ad2be7af5e 100644
--- a/libraries/gpu/src/gpu/Context.cpp
+++ b/libraries/gpu/src/gpu/Context.cpp
@@ -270,6 +270,7 @@ ContextMetricCount Backend::texturePendingGPUTransferCount;
ContextMetricSize Backend::texturePendingGPUTransferMemSize;
ContextMetricSize Backend::textureResourcePopulatedGPUMemSize;
+ContextMetricSize Backend::textureResourceIdealGPUMemSize;
Size Context::getFreeGPUMemSize() {
return Backend::freeGPUMemSize.getValue();
@@ -329,3 +330,7 @@ Size Context::getTexturePendingGPUTransferMemSize() {
Size Context::getTextureResourcePopulatedGPUMemSize() {
return Backend::textureResourcePopulatedGPUMemSize.getValue();
}
+
+Size Context::getTextureResourceIdealGPUMemSize() {
+ return Backend::textureResourceIdealGPUMemSize.getValue();
+}
diff --git a/libraries/gpu/src/gpu/Context.h b/libraries/gpu/src/gpu/Context.h
index 8c5a4d493e..23c7edaff4 100644
--- a/libraries/gpu/src/gpu/Context.h
+++ b/libraries/gpu/src/gpu/Context.h
@@ -113,6 +113,7 @@ public:
static ContextMetricCount texturePendingGPUTransferCount;
static ContextMetricSize texturePendingGPUTransferMemSize;
static ContextMetricSize textureResourcePopulatedGPUMemSize;
+ static ContextMetricSize textureResourceIdealGPUMemSize;
protected:
@@ -243,6 +244,7 @@ public:
static Size getTexturePendingGPUTransferMemSize();
static Size getTextureResourcePopulatedGPUMemSize();
+ static Size getTextureResourceIdealGPUMemSize();
protected:
Context(const Context& context);
diff --git a/libraries/graphics-scripting/src/graphics-scripting/Forward.h b/libraries/graphics-scripting/src/graphics-scripting/Forward.h
index ed8e96a12f..104674eddc 100644
--- a/libraries/graphics-scripting/src/graphics-scripting/Forward.h
+++ b/libraries/graphics-scripting/src/graphics-scripting/Forward.h
@@ -36,6 +36,30 @@ namespace scriptable {
using ModelProviderPointer = std::shared_ptr;
using WeakModelProviderPointer = std::weak_ptr;
+ /**jsdoc
+ * @typedef {object} Graphics.Material
+ * @property {string} name
+ * @property {string} model
+ * @property {number} opacity
+ * @property {number} roughness
+ * @property {number} metallic
+ * @property {number} scattering
+ * @property {boolean} unlit
+ * @propety {Vec3} emissive
+ * @propety {Vec3} albedo
+ * @property {string} emissiveMap
+ * @property {string} albedoMap
+ * @property {string} opacityMap
+ * @property {string} metallicMap
+ * @property {string} specularMap
+ * @property {string} roughnessMap
+ * @property {string} glossMap
+ * @property {string} normalMap
+ * @property {string} bumpMap
+ * @property {string} occlusionMap
+ * @property {string} lightmapMap
+ * @property {string} scatteringMap
+ */
class ScriptableMaterial {
public:
ScriptableMaterial() {}
@@ -68,7 +92,7 @@ namespace scriptable {
/**jsdoc
* @typedef {object} Graphics.MaterialLayer
- * @property {Material} material - This layer's material.
+ * @property {Graphics.Material} material - This layer's material.
* @property {number} priority - The priority of this layer. If multiple materials are applied to a mesh part, only the highest priority layer is used.
*/
class ScriptableMaterialLayer {
diff --git a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
index 20b54b02c9..6fd0017ae2 100644
--- a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
+++ b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
@@ -166,6 +166,17 @@ bool GraphicsScriptingInterface::updateMeshPart(scriptable::ScriptableMeshPointe
scriptable::ScriptableMeshPointer GraphicsScriptingInterface::newMesh(const QVariantMap& ifsMeshData) {
// TODO: this is bare-bones way for now to improvise a new mesh from the scripting side
// in the future we want to support a formal C++ structure data type here instead
+
+ /**jsdoc
+ * @typedef {object} Graphics.IFSData
+ * @property {string} [name=""] - mesh name (useful for debugging / debug prints).
+ * @property {string} [topology=""]
+ * @property {number[]} indices - vertex indices to use for the mesh faces.
+ * @property {Vec3[]} vertices - vertex positions (model space)
+ * @property {Vec3[]} [normals=[]] - vertex normals (normalized)
+ * @property {Vec3[]} [colors=[]] - vertex colors (normalized)
+ * @property {Vec2[]} [texCoords0=[]] - vertex texture coordinates (normalized)
+ */
QString meshName = ifsMeshData.value("name").toString();
QString topologyName = ifsMeshData.value("topology").toString();
QVector indices = buffer_helpers::variantToVector(ifsMeshData.value("indices"));
diff --git a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.h b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.h
index b88c6345cf..1ec60c4244 100644
--- a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.h
+++ b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.h
@@ -46,10 +46,28 @@ public slots:
*/
scriptable::ScriptableModelPointer getModel(QUuid uuid);
+ /**jsdoc
+ * @function Graphics.updateModel
+ * @param {Uuid} id
+ * @param {Graphics.Model} model
+ * @returns {boolean}
+ */
bool updateModel(QUuid uuid, const scriptable::ScriptableModelPointer& model);
+ /**jsdoc
+ * @function Graphics.canUpdateModel
+ * @param {Uuid} id
+ * @param {number} [meshIndex=-1]
+ * @param {number} [partNumber=-1]
+ * @returns {boolean}
+ */
bool canUpdateModel(QUuid uuid, int meshIndex = -1, int partNumber = -1);
+ /**jsdoc
+ * @function Graphics.newModel
+ * @param {Graphics.Mesh[]} meshes
+ * @returns {Graphics.Model}
+ */
scriptable::ScriptableModelPointer newModel(const scriptable::ScriptableMeshes& meshes);
/**jsdoc
@@ -59,15 +77,6 @@ public slots:
* @param {Graphics.IFSData} ifsMeshData Index-Faced Set (IFS) arrays used to create the new mesh.
* @returns {Graphics.Mesh} the resulting Mesh / Mesh Part object
*/
- /**jsdoc
- * @typedef {object} Graphics.IFSData
- * @property {string} [name] - mesh name (useful for debugging / debug prints).
- * @property {number[]} indices - vertex indices to use for the mesh faces.
- * @property {Vec3[]} vertices - vertex positions (model space)
- * @property {Vec3[]} [normals] - vertex normals (normalized)
- * @property {Vec3[]} [colors] - vertex colors (normalized)
- * @property {Vec2[]} [texCoords0] - vertex texture coordinates (normalized)
- */
scriptable::ScriptableMeshPointer newMesh(const QVariantMap& ifsMeshData);
#ifdef SCRIPTABLE_MESH_TODO
@@ -77,6 +86,11 @@ public slots:
bool updateMeshPart(scriptable::ScriptableMeshPointer mesh, scriptable::ScriptableMeshPartPointer part);
#endif
+ /**jsdoc
+ * @function Graphics.exportModelToOBJ
+ * @param {Graphics.Model} model
+ * @returns {string}
+ */
QString exportModelToOBJ(const scriptable::ScriptableModel& in);
private:
diff --git a/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.h b/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.h
index 62a67aa5e6..dcb1c53759 100644
--- a/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.h
+++ b/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.h
@@ -36,6 +36,10 @@ namespace scriptable {
* @property {number} numIndices - Total number of vertex indices in the mesh.
* @property {number} numVertices - Total number of vertices in the Mesh.
* @property {number} numAttributes - Number of currently defined vertex attributes.
+ * @property {boolean} valid
+ * @property {boolean} strong
+ * @property {object} extents
+ * @property {object} bufferFormats
*/
class ScriptableMesh : public ScriptableMeshBase, QScriptable {
Q_OBJECT
diff --git a/libraries/graphics-scripting/src/graphics-scripting/ScriptableMeshPart.h b/libraries/graphics-scripting/src/graphics-scripting/ScriptableMeshPart.h
index dd71d9b998..7352fcd0f6 100644
--- a/libraries/graphics-scripting/src/graphics-scripting/ScriptableMeshPart.h
+++ b/libraries/graphics-scripting/src/graphics-scripting/ScriptableMeshPart.h
@@ -12,7 +12,11 @@
namespace scriptable {
/**jsdoc
* @typedef {object} Graphics.MeshPart
+ * @property {boolean} valid
* @property {number} partIndex - The part index (within the containing Mesh).
+ * @property {number} firstVertexIndex
+ * @property {number} baseVertexIndex
+ * @property {number} lastVertexIndex
* @property {Graphics.Topology} topology - element interpretation (currently only 'triangles' is supported).
* @property {string[]} attributeNames - Vertex attribute names (color, normal, etc.)
* @property {number} numIndices - Number of vertex indices that this mesh part refers to.
@@ -20,6 +24,8 @@ namespace scriptable {
* @property {number} numFaces - Number of faces represented by the mesh part (numIndices / numVerticesPerFace).
* @property {number} numVertices - Total number of vertices in the containing Mesh.
* @property {number} numAttributes - Number of currently defined vertex attributes.
+ * @property {object} extents
+ * @property {object} bufferFormats
*/
class ScriptableMeshPart : public QObject, QScriptable {
diff --git a/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h b/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h
index ac0b7b9623..7d1ca5f560 100644
--- a/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h
+++ b/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h
@@ -21,7 +21,7 @@ namespace scriptable {
* @property {Uuid} objectID - UUID of corresponding inworld object (if model is associated)
* @property {number} numMeshes - The number of submeshes contained in the model.
* @property {Graphics.Mesh[]} meshes - Array of submesh references.
- * @property {Object.} materialLayers - Map of materials layer lists. You can look up a material layer list by mesh part number or by material name.
+ * @property {Object.} materialLayers - Map of materials layer lists. You can look up a material layer list by mesh part number or by material name.
* @property {string[]} materialNames - Array of all the material names used by the mesh parts of this model, in order (e.g. materialNames[0] is the name of the first mesh part's material).
*/
diff --git a/libraries/graphics/src/graphics/Geometry.h b/libraries/graphics/src/graphics/Geometry.h
index 485542d26b..eddfdbd1b6 100755
--- a/libraries/graphics/src/graphics/Geometry.h
+++ b/libraries/graphics/src/graphics/Geometry.h
@@ -76,6 +76,23 @@ public:
// Access vertex position value
const Vec3& getPos(Index index) const { return _vertexBuffer.get(index); }
+ /**jsdoc
+ *
+ *
+ * | Value | Description |
|---|
+ *
+ *
+ * 0 | Points. |
+ * 1 | Lines. |
+ * 2 | Line strip. |
+ * 3 | Triangles. |
+ * 4 | Triangle strip. |
+ * 5 | Quads. |
+ * 6 | Quad strip. |
+ *
+ *
+ * @typedef {number} Graphics.Topology
+ */
enum Topology {
POINTS = 0,
LINES,
diff --git a/libraries/graphics/src/graphics/skybox.slf b/libraries/graphics/src/graphics/skybox.slf
index 7b25e36af7..153e73b9ef 100755
--- a/libraries/graphics/src/graphics/skybox.slf
+++ b/libraries/graphics/src/graphics/skybox.slf
@@ -35,8 +35,11 @@ void main(void) {
#ifdef PROCEDURAL
vec3 color = getSkyboxColor();
- // Procedural Shaders are expected to be Gamma corrected so let's bring back the RGB in linear space for the rest of the pipeline
- color = pow(color, vec3(2.2));
+ // Protect from NaNs and negative values
+ color = mix(color, vec3(0), isnan(color));
+ color = max(color, vec3(0));
+ // Procedural Shaders are expected to be Gamma corrected so let's bring back the RGB in linear space for the rest of the pipeline
+ color = pow(color, vec3(2.2));
_fragColor = vec4(color, 0.0);
// FIXME: scribe does not yet scrub out else statements
diff --git a/libraries/input-plugins/src/input-plugins/TouchscreenVirtualPadDevice.cpp b/libraries/input-plugins/src/input-plugins/TouchscreenVirtualPadDevice.cpp
index 7ee2135325..8d63b82911 100644
--- a/libraries/input-plugins/src/input-plugins/TouchscreenVirtualPadDevice.cpp
+++ b/libraries/input-plugins/src/input-plugins/TouchscreenVirtualPadDevice.cpp
@@ -57,7 +57,7 @@ void TouchscreenVirtualPadDevice::init() {
void TouchscreenVirtualPadDevice::resize() {
QScreen* eventScreen = qApp->primaryScreen();
if (_screenDPIProvided != eventScreen->physicalDotsPerInch()) {
- _screenWidthCenter = eventScreen->size().width() / 2;
+ _screenWidthCenter = eventScreen->availableSize().width() / 2;
_screenDPIScale.x = (float)eventScreen->physicalDotsPerInchX();
_screenDPIScale.y = (float)eventScreen->physicalDotsPerInchY();
_screenDPIProvided = eventScreen->physicalDotsPerInch();
@@ -81,7 +81,7 @@ void TouchscreenVirtualPadDevice::setupControlsPositions(VirtualPad::Manager& vi
// Movement stick
float margin = _screenDPI * VirtualPad::Manager::BASE_MARGIN_PIXELS / VirtualPad::Manager::DPI;
- _fixedCenterPosition = glm::vec2( _fixedRadius + margin, eventScreen->size().height() - margin - _fixedRadius - _extraBottomMargin);
+ _fixedCenterPosition = glm::vec2( _fixedRadius + margin, eventScreen->availableSize().height() - margin - _fixedRadius - _extraBottomMargin);
_moveRefTouchPoint = _fixedCenterPosition;
virtualPadManager.getLeftVirtualPad()->setFirstTouch(_moveRefTouchPoint);
@@ -89,7 +89,7 @@ void TouchscreenVirtualPadDevice::setupControlsPositions(VirtualPad::Manager& vi
float jumpBtnPixelSize = _screenDPI * VirtualPad::Manager::JUMP_BTN_FULL_PIXELS / VirtualPad::Manager::DPI;
float rightMargin = _screenDPI * VirtualPad::Manager::JUMP_BTN_RIGHT_MARGIN_PIXELS / VirtualPad::Manager::DPI;
float bottomMargin = _screenDPI * VirtualPad::Manager::JUMP_BTN_BOTTOM_MARGIN_PIXELS/ VirtualPad::Manager::DPI;
- _jumpButtonPosition = glm::vec2( eventScreen->size().width() - rightMargin - jumpBtnPixelSize, eventScreen->size().height() - bottomMargin - _jumpButtonRadius - _extraBottomMargin);
+ _jumpButtonPosition = glm::vec2( eventScreen->availableSize().width() - rightMargin - jumpBtnPixelSize, eventScreen->availableSize().height() - bottomMargin - _jumpButtonRadius - _extraBottomMargin);
virtualPadManager.setJumpButtonPosition(_jumpButtonPosition);
}
@@ -187,6 +187,13 @@ void TouchscreenVirtualPadDevice::InputDevice::update(float deltaTime, const con
_axisStateMap.clear();
}
+bool TouchscreenVirtualPadDevice::InputDevice::triggerHapticPulse(float strength, float duration, controller::Hand hand) {
+ auto& virtualPadManager = VirtualPad::Manager::instance();
+ virtualPadManager.requestHapticFeedback((int) duration);
+ return true;
+}
+
+
void TouchscreenVirtualPadDevice::InputDevice::focusOutEvent() {
}
@@ -200,7 +207,7 @@ void TouchscreenVirtualPadDevice::debugPoints(const QTouchEvent* event, QString
points << thisPoint;
}
QScreen* eventScreen = event->window()->screen();
- int midScreenX = eventScreen->size().width()/2;
+ int midScreenX = eventScreen->availableSize().width()/2;
int lefties = 0;
int righties = 0;
vec2 currentPoint;
diff --git a/libraries/input-plugins/src/input-plugins/TouchscreenVirtualPadDevice.h b/libraries/input-plugins/src/input-plugins/TouchscreenVirtualPadDevice.h
index e7e540b503..ef1e7a4d89 100644
--- a/libraries/input-plugins/src/input-plugins/TouchscreenVirtualPadDevice.h
+++ b/libraries/input-plugins/src/input-plugins/TouchscreenVirtualPadDevice.h
@@ -63,6 +63,8 @@ protected:
// Device functions
virtual controller::Input::NamedVector getAvailableInputs() const override;
virtual QString getDefaultMappingConfig() const override;
+
+ virtual bool triggerHapticPulse(float strength, float duration, controller::Hand hand) override;
virtual void update(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) override;
virtual void focusOutEvent() override;
diff --git a/libraries/midi/src/Midi.h b/libraries/midi/src/Midi.h
index f7940bbe5d..e5c44c6b7e 100644
--- a/libraries/midi/src/Midi.h
+++ b/libraries/midi/src/Midi.h
@@ -20,6 +20,13 @@
#include
#include
+/**jsdoc
+ * @namespace Midi
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ */
+
class Midi : public QObject, public Dependency {
Q_OBJECT
SINGLETON_DEPENDENCY
@@ -46,57 +53,135 @@ signals:
void midiReset();
public slots:
- // Send Raw Midi Packet to all connected devices
+
+ /**jsdoc
+ * Send Raw MIDI packet to a particular device.
+ * @function Midi.sendRawDword
+ * @param {number} device - Integer device number.
+ * @param {number} raw - Integer (DWORD) raw MIDI message.
+ */
Q_INVOKABLE void sendRawDword(int device, int raw);
- /// Send Raw Midi message to selected device
- /// @param {int} device: device number
- /// @param {int} raw: raw midi message (DWORD)
- // Send Midi Message to all connected devices
+ /**jsdoc
+ * Send MIDI message to a particular device.
+ * @function Midi.sendMidiMessage
+ * @param {number} device - Integer device number.
+ * @param {number} channel - Integer channel number.
+ * @param {number} type - 0x8 is note off, 0x9 is note on (if velocity=0, note off), etc.
+ * @param {number} note - MIDI note number.
+ * @param {number} velocity - Note velocity (0 means note off).
+ */
Q_INVOKABLE void sendMidiMessage(int device, int channel, int type, int note, int velocity);
- /// Send midi message to selected device/devices
- /// @param {int} device: device number
- /// @param {int} channel: channel number
- /// @param {int} type: 0x8 is noteoff, 0x9 is noteon (if velocity=0, noteoff), etc
- /// @param {int} note: midi note number
- /// @param {int} velocity: note velocity (0 means noteoff)
- // Send Midi Message to all connected devices
+ /**jsdoc
+ * Play a note on all connected devices.
+ * @function Midi.playMidiNote
+ * @param {number} status - 0x80 is note off, 0x90 is note on (if velocity=0, note off), etc.
+ * @param {number} note - MIDI note number.
+ * @param {number} velocity - Note velocity (0 means note off).
+ */
Q_INVOKABLE void playMidiNote(int status, int note, int velocity);
- /// play a note on all connected devices
- /// @param {int} status: 0x80 is noteoff, 0x90 is noteon (if velocity=0, noteoff), etc
- /// @param {int} note: midi note number
- /// @param {int} velocity: note velocity (0 means noteoff)
- /// turn off all notes on all connected devices
+ /**jsdoc
+ * Turn off all notes on all connected devices.
+ * @function Midi.allNotesOff
+ */
Q_INVOKABLE void allNotesOff();
- /// clean up and re-discover attached devices
+ /**jsdoc
+ * Clean up and re-discover attached devices.
+ * @function Midi.resetDevices
+ */
Q_INVOKABLE void resetDevices();
- /// ask for a list of inputs/outputs
+ /**jsdoc
+ * Get a list of inputs/outputs.
+ * @function Midi.listMidiDevices
+ * @param {boolean} output
+ * @returns {string[]}
+ */
Q_INVOKABLE QStringList listMidiDevices(bool output);
- /// block an input/output by name
+ /**jsdoc
+ * Block an input/output by name.
+ * @function Midi.blockMidiDevice
+ * @param {string} name
+ * @param {boolean} output
+ */
Q_INVOKABLE void blockMidiDevice(QString name, bool output);
- /// unblock an input/output by name
+ /**jsdoc
+ * Unblock an input/output by name.
+ * @function Midi.unblockMidiDevice
+ * @param {string} name
+ * @param {boolean} output
+ */
Q_INVOKABLE void unblockMidiDevice(QString name, bool output);
- /// repeat all incoming notes to all outputs (default disabled)
+ /**jsdoc
+ * Repeat all incoming notes to all outputs (default disabled).
+ * @function Midi.thruModeEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void thruModeEnable(bool enable);
- /// broadcast on all unblocked devices
+
+ /**jsdoc
+ * Broadcast on all unblocked devices.
+ * @function Midi.broadcastEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void broadcastEnable(bool enable);
+
/// filter by event types
+
+ /**jsdoc
+ * @function Midi.typeNoteOffEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void typeNoteOffEnable(bool enable);
+
+ /**jsdoc
+ * @function Midi.typeNoteOnEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void typeNoteOnEnable(bool enable);
+
+ /**jsdoc
+ * @function Midi.typePolyKeyPressureEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void typePolyKeyPressureEnable(bool enable);
+
+ /**jsdoc
+ * @function Midi.typeControlChangeEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void typeControlChangeEnable(bool enable);
+
+ /**jsdoc
+ * @function Midi.typeProgramChangeEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void typeProgramChangeEnable(bool enable);
+
+ /**jsdoc
+ * @function Midi.typeChanPressureEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void typeChanPressureEnable(bool enable);
+
+ /**jsdoc
+ * @function Midi.typePitchBendEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void typePitchBendEnable(bool enable);
+
+ /**jsdoc
+ * @function Midi.typeSystemMessageEnable
+ * @param {boolean} enable
+ */
Q_INVOKABLE void typeSystemMessageEnable(bool enable);
diff --git a/libraries/networking/src/AccountManager.cpp b/libraries/networking/src/AccountManager.cpp
index 049129b2ba..e70e3e26d0 100644
--- a/libraries/networking/src/AccountManager.cpp
+++ b/libraries/networking/src/AccountManager.cpp
@@ -453,6 +453,20 @@ void AccountManager::removeAccountFromFile() {
<< "from settings file.";
}
+void AccountManager::setAccountInfo(const DataServerAccountInfo &newAccountInfo) {
+ _accountInfo = newAccountInfo;
+ _pendingPrivateKey.clear();
+ if (_isAgent && !_accountInfo.getAccessToken().token.isEmpty() && !_accountInfo.hasProfile()) {
+ // we are missing profile information, request it now
+ requestProfile();
+ }
+
+ // prepare to refresh our token if it is about to expire
+ if (needsToRefreshToken()) {
+ refreshAccessToken();
+ }
+}
+
bool AccountManager::hasValidAccessToken() {
if (_accountInfo.getAccessToken().token.isEmpty() || _accountInfo.getAccessToken().isExpired()) {
diff --git a/libraries/networking/src/AccountManager.h b/libraries/networking/src/AccountManager.h
index 87b17d00d5..88ebaf5656 100644
--- a/libraries/networking/src/AccountManager.h
+++ b/libraries/networking/src/AccountManager.h
@@ -88,6 +88,7 @@ public:
void requestProfile();
DataServerAccountInfo& getAccountInfo() { return _accountInfo; }
+ void setAccountInfo(const DataServerAccountInfo &newAccountInfo);
static QJsonObject dataObjectFromResponse(QNetworkReply& requestReply);
diff --git a/libraries/networking/src/AddressManager.h b/libraries/networking/src/AddressManager.h
index 8e2553779b..7832b26c96 100644
--- a/libraries/networking/src/AddressManager.h
+++ b/libraries/networking/src/AddressManager.h
@@ -32,6 +32,11 @@ const QString GET_PLACE = "/api/v1/places/%1";
/**jsdoc
* The location API provides facilities related to your current location in the metaverse.
*
+ * Getter/Setter
+ * You can get and set your current metaverse address by directly reading a string value from and writing a string value to
+ * the location object. This is an alternative to using the location.href property or this object's
+ * functions.
+ *
* @namespace location
*
* @hifi-interface
diff --git a/libraries/networking/src/DomainHandler.h b/libraries/networking/src/DomainHandler.h
index 2d4712209d..08908dbaf6 100644
--- a/libraries/networking/src/DomainHandler.h
+++ b/libraries/networking/src/DomainHandler.h
@@ -97,7 +97,7 @@ public:
int getCheckInPacketsSinceLastReply() const { return _checkInPacketsSinceLastReply; }
void sentCheckInPacket();
- void domainListReceived() { _checkInPacketsSinceLastReply = 0; }
+ void clearPendingCheckins() { _checkInPacketsSinceLastReply = 0; }
/**jsdoc
* The reasons that you may be refused connection to a domain are defined by numeric values:
diff --git a/libraries/networking/src/NodeList.cpp b/libraries/networking/src/NodeList.cpp
index 04e32f50cb..4920ea97c7 100644
--- a/libraries/networking/src/NodeList.cpp
+++ b/libraries/networking/src/NodeList.cpp
@@ -594,6 +594,8 @@ void NodeList::processDomainServerConnectionTokenPacket(QSharedPointerreadWithoutCopy(NUM_BYTES_RFC4122_UUID)));
+
+ _domainHandler.clearPendingCheckins();
sendDomainServerCheckIn();
}
@@ -605,7 +607,7 @@ void NodeList::processDomainServerList(QSharedPointer message)
}
// this is a packet from the domain server, reset the count of un-replied check-ins
- _domainHandler.domainListReceived();
+ _domainHandler.clearPendingCheckins();
// emit our signal so listeners know we just heard from the DS
emit receivedDomainServerList();
diff --git a/libraries/networking/src/ResourceCache.h b/libraries/networking/src/ResourceCache.h
index e2df582aa3..18840cd11e 100644
--- a/libraries/networking/src/ResourceCache.h
+++ b/libraries/networking/src/ResourceCache.h
@@ -86,7 +86,6 @@ private:
/// Wrapper to expose resources to JS/QML
class ScriptableResource : public QObject {
-
/**jsdoc
* @constructor Resource
*
@@ -98,12 +97,15 @@ class ScriptableResource : public QObject {
* @property {string} url - URL of this resource.
* @property {Resource.State} state - Current loading state.
*/
-
+ /**jsdoc
+ * @namespace Resource
+ * @variation 0
+ * @property {Resource.State} State
+ */
Q_OBJECT
Q_PROPERTY(QUrl url READ getURL)
Q_PROPERTY(int state READ getState NOTIFY stateChanged)
-
public:
/**jsdoc
@@ -115,7 +117,6 @@ public:
* @property {number} FINISHED - The resource has completely finished loading and is ready.
* @property {number} FAILED - Downloading the resource has failed.
*/
-
enum State {
QUEUED,
LOADING,
diff --git a/libraries/networking/src/ResourceScriptingInterface.h b/libraries/networking/src/ResourceScriptingInterface.h
index d9777e7514..cc3f12f990 100644
--- a/libraries/networking/src/ResourceScriptingInterface.h
+++ b/libraries/networking/src/ResourceScriptingInterface.h
@@ -17,11 +17,30 @@
#include
+/**jsdoc
+ * @namespace Resources
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ * @hifi-server-entity
+ * @hifi-assignment-client
+ */
+
class ResourceScriptingInterface : public QObject, public Dependency {
Q_OBJECT
public:
+
+ /**jsdoc
+ * @function Resources.overrideUrlPrefix
+ * @param {string} prefix
+ * @param {string} replacement
+ */
Q_INVOKABLE void overrideUrlPrefix(const QString& prefix, const QString& replacement);
+ /**jsdoc
+ * @function Resources.restoreUrlPrefix
+ * @param {string} prefix
+ */
Q_INVOKABLE void restoreUrlPrefix(const QString& prefix) {
overrideUrlPrefix(prefix, "");
}
diff --git a/libraries/networking/src/ThreadedAssignment.h b/libraries/networking/src/ThreadedAssignment.h
index 007e41a543..9372cfa667 100644
--- a/libraries/networking/src/ThreadedAssignment.h
+++ b/libraries/networking/src/ThreadedAssignment.h
@@ -29,13 +29,34 @@ public:
void addPacketStatsAndSendStatsPacket(QJsonObject statsObject);
public slots:
+ // JSDoc: Overridden in Agent.h.
/// threaded run of assignment
virtual void run() = 0;
+
+ /**jsdoc
+ * @function Agent.stop
+ * @deprecated This function is being removed from the API.
+ */
Q_INVOKABLE virtual void stop() { setFinished(true); }
+
+ /**jsdoc
+ * @function Agent.sendStatsPacket
+ * @deprecated This function is being removed from the API.
+ */
virtual void sendStatsPacket();
+
+ /**jsdoc
+ * @function Agent.clearQueuedCheckIns
+ * @deprecated This function is being removed from the API.
+ */
void clearQueuedCheckIns() { _numQueuedCheckIns = 0; }
signals:
+ /**jsdoc
+ * @function Agent.finished
+ * @returns {Signal}
+ * @deprecated This function is being removed from the API.
+ */
void finished();
protected:
@@ -47,6 +68,10 @@ protected:
int _numQueuedCheckIns { 0 };
protected slots:
+ /**jsdoc
+ * @function Agent.domainSettingsRequestFailed
+ * @deprecated This function is being removed from the API.
+ */
void domainSettingsRequestFailed();
private slots:
diff --git a/libraries/physics/src/EntityMotionState.cpp b/libraries/physics/src/EntityMotionState.cpp
index 9f067e51c6..7a0ead3e0d 100644
--- a/libraries/physics/src/EntityMotionState.cpp
+++ b/libraries/physics/src/EntityMotionState.cpp
@@ -731,7 +731,9 @@ void EntityMotionState::measureBodyAcceleration() {
// hence the equation for acceleration is: a = (v1 / (1 - D)^dt - v0) / dt
glm::vec3 velocity = getBodyLinearVelocityGTSigma();
- _measuredAcceleration = (velocity / powf(1.0f - _body->getLinearDamping(), dt) - _lastVelocity) * invDt;
+ const float MIN_DAMPING_FACTOR = 0.01f;
+ float invDampingAttenuationFactor = 1.0f / glm::max(powf(1.0f - _body->getLinearDamping(), dt), MIN_DAMPING_FACTOR);
+ _measuredAcceleration = (velocity * invDampingAttenuationFactor - _lastVelocity) * invDt;
_lastVelocity = velocity;
if (numSubsteps > PHYSICS_ENGINE_MAX_NUM_SUBSTEPS) {
// we fall in here when _lastMeasureStep is old: the body has just become active
diff --git a/libraries/physics/src/ObjectActionTractor.cpp b/libraries/physics/src/ObjectActionTractor.cpp
index a48989be33..4235bbd616 100644
--- a/libraries/physics/src/ObjectActionTractor.cpp
+++ b/libraries/physics/src/ObjectActionTractor.cpp
@@ -397,7 +397,7 @@ void ObjectActionTractor::deserialize(QByteArray serializedArguments) {
EntityDynamicType type;
dataStream >> type;
- assert(type == getType());
+ assert(type == getType() || type == DYNAMIC_TYPE_SPRING);
QUuid id;
dataStream >> id;
diff --git a/libraries/physics/src/ObjectMotionState.h b/libraries/physics/src/ObjectMotionState.h
index fbda9366fc..e1cf5a4285 100644
--- a/libraries/physics/src/ObjectMotionState.h
+++ b/libraries/physics/src/ObjectMotionState.h
@@ -111,7 +111,7 @@ public:
virtual PhysicsMotionType getMotionType() const { return _motionType; }
void setMass(float mass);
- float getMass() const;
+ virtual float getMass() const;
void setBodyLinearVelocity(const glm::vec3& velocity) const;
void setBodyAngularVelocity(const glm::vec3& velocity) const;
diff --git a/libraries/plugins/src/plugins/DisplayPlugin.h b/libraries/plugins/src/plugins/DisplayPlugin.h
index ff6801109e..e330f6d7ec 100644
--- a/libraries/plugins/src/plugins/DisplayPlugin.h
+++ b/libraries/plugins/src/plugins/DisplayPlugin.h
@@ -140,6 +140,14 @@ public:
virtual void setContext(const gpu::ContextPointer& context) final { _gpuContext = context; }
virtual void submitFrame(const gpu::FramePointer& newFrame) = 0;
+ virtual float getRenderResolutionScale() const {
+ return _renderResolutionScale;
+ }
+
+ void setRenderResolutionScale(float renderResolutionScale) {
+ _renderResolutionScale = renderResolutionScale;
+ }
+
// The size of the rendering target (may be larger than the device size due to distortion)
virtual glm::uvec2 getRecommendedRenderSize() const = 0;
@@ -220,6 +228,8 @@ protected:
MovingAverage _movingAveragePresent;
+ float _renderResolutionScale { 1.0f };
+
private:
QMutex _presentMutex;
QWaitCondition _presentCondition;
diff --git a/libraries/plugins/src/plugins/SteamClientPlugin.h b/libraries/plugins/src/plugins/SteamClientPlugin.h
index 343ed40402..fc1b85c572 100644
--- a/libraries/plugins/src/plugins/SteamClientPlugin.h
+++ b/libraries/plugins/src/plugins/SteamClientPlugin.h
@@ -40,6 +40,15 @@ public:
virtual int getSteamVRBuildID() = 0;
};
+/**jsdoc
+ * @namespace Steam
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ *
+ * @property {boolean} running - Read-only.
+ */
+
class SteamScriptingInterface : public QObject {
Q_OBJECT
@@ -49,7 +58,16 @@ public:
SteamScriptingInterface(QObject* parent, SteamClientPlugin* plugin) : QObject(parent), _plugin(plugin) {}
public slots:
+
+ /**jsdoc
+ * @function Steam.isRunning
+ * @returns {boolean}
+ */
bool isRunning() const { return _plugin && _plugin->isRunning(); }
+
+ /**jsdoc
+ * @function Steam.openInviteOverlay
+ */
void openInviteOverlay() const { if (_plugin) { _plugin->openInviteOverlay(); } }
private:
diff --git a/libraries/pointers/src/Pick.h b/libraries/pointers/src/Pick.h
index 68c89a59cb..53606b154f 100644
--- a/libraries/pointers/src/Pick.h
+++ b/libraries/pointers/src/Pick.h
@@ -135,15 +135,29 @@ public:
PickQuery(const PickFilter& filter, const float maxDistance, const bool enabled);
/**jsdoc
- * @namespace
- * @augments Picks
- *
* Enum for different types of Picks and Pointers.
*
- * @typedef {enum} Picks.PickType
+ * @namespace PickType
+ * @variation 0
+ *
+ * @hifi-interface
+ * @hifi-client-entity
+ *
* @property {number} Ray Ray Picks intersect a ray with the nearest object in front of them, along a given direction.
* @property {number} Stylus Stylus Picks provide "tapping" functionality on/into flat surfaces.
*/
+ /**jsdoc
+ *
+ *
+ * | Value | Description |
|---|
+ *
+ *
+ * {@link PickType(0)|PickType.Ray} | |
+ * {@link PickType(0)|PickType.Stylus} | |
+ *
+ *
+ * @typedef {number} PickType
+ */
enum PickType {
Ray = 0,
Stylus,
diff --git a/libraries/procedural/src/procedural/Procedural.cpp b/libraries/procedural/src/procedural/Procedural.cpp
index 19c4a62443..7bf020094a 100644
--- a/libraries/procedural/src/procedural/Procedural.cpp
+++ b/libraries/procedural/src/procedural/Procedural.cpp
@@ -272,18 +272,29 @@ void Procedural::prepare(gpu::Batch& batch, const glm::vec3& position, const glm
// Leave this here for debugging
// qCDebug(procedural) << "FragmentShader:\n" << fragmentShaderSource.c_str();
- _opaqueFragmentShader = gpu::Shader::createPixel(opaqueShaderSource);
- _opaqueShader = gpu::Shader::createProgram(_vertexShader, _opaqueFragmentShader);
- _transparentFragmentShader = gpu::Shader::createPixel(transparentShaderSource);
- _transparentShader = gpu::Shader::createProgram(_vertexShader, _transparentFragmentShader);
-
gpu::Shader::BindingSet slotBindings;
+
slotBindings.insert(gpu::Shader::Binding(std::string("iChannel0"), 0));
slotBindings.insert(gpu::Shader::Binding(std::string("iChannel1"), 1));
slotBindings.insert(gpu::Shader::Binding(std::string("iChannel2"), 2));
slotBindings.insert(gpu::Shader::Binding(std::string("iChannel3"), 3));
+
+ // TODO: THis is a simple fix, we need a cleaner way to provide the "hosting" program for procedural custom shaders to be defined together with the required bindings.
+ const int PROCEDURAL_PROGRAM_LIGHTING_MODEL_SLOT = 3;
+ slotBindings.insert(gpu::Shader::Binding(std::string("lightingModelBuffer"), PROCEDURAL_PROGRAM_LIGHTING_MODEL_SLOT));
+
+ _opaqueFragmentShader = gpu::Shader::createPixel(opaqueShaderSource);
+ _opaqueShader = gpu::Shader::createProgram(_vertexShader, _opaqueFragmentShader);
gpu::Shader::makeProgram(*_opaqueShader, slotBindings);
- gpu::Shader::makeProgram(*_transparentShader, slotBindings);
+
+ if (!transparentShaderSource.empty() && transparentShaderSource != opaqueShaderSource) {
+ _transparentFragmentShader = gpu::Shader::createPixel(transparentShaderSource);
+ _transparentShader = gpu::Shader::createProgram(_vertexShader, _transparentFragmentShader);
+ gpu::Shader::makeProgram(*_transparentShader, slotBindings);
+ } else {
+ _transparentFragmentShader = _opaqueFragmentShader;
+ _transparentShader = _opaqueShader;
+ }
_opaquePipeline = gpu::Pipeline::create(_opaqueShader, _opaqueState);
_transparentPipeline = gpu::Pipeline::create(_transparentShader, _transparentState);
diff --git a/libraries/render-utils/src/AntialiasingEffect.cpp b/libraries/render-utils/src/AntialiasingEffect.cpp
index 2173aef76a..8317568fc6 100644
--- a/libraries/render-utils/src/AntialiasingEffect.cpp
+++ b/libraries/render-utils/src/AntialiasingEffect.cpp
@@ -486,16 +486,14 @@ JitterSample::SampleSequence::SampleSequence(){
}
void JitterSample::configure(const Config& config) {
- _freeze = config.freeze;
- if (config.stop || _freeze) {
+ _freeze = config.stop || config.freeze;
+ if (config.freeze) {
auto pausedIndex = config.getIndex();
if (_sampleSequence.currentIndex != pausedIndex) {
_sampleSequence.currentIndex = pausedIndex;
}
- } else {
- if (_sampleSequence.currentIndex < 0) {
- _sampleSequence.currentIndex = config.getIndex();
- }
+ } else if (config.stop) {
+ _sampleSequence.currentIndex = -1;
}
_scale = config.scale;
}
@@ -509,7 +507,12 @@ void JitterSample::run(const render::RenderContextPointer& renderContext, Output
current = -1;
}
}
- jitter = _sampleSequence.offsets[(current < 0 ? SEQUENCE_LENGTH : current)];
+
+ jitter.x = 0.0f;
+ jitter.y = 0.0f;
+ if (current >= 0) {
+ jitter = _sampleSequence.offsets[current];
+ }
}
diff --git a/libraries/render-utils/src/AntialiasingEffect.h b/libraries/render-utils/src/AntialiasingEffect.h
index 9f62fd76c1..ffce84495e 100644
--- a/libraries/render-utils/src/AntialiasingEffect.h
+++ b/libraries/render-utils/src/AntialiasingEffect.h
@@ -62,7 +62,7 @@ public:
};
using Config = JitterSampleConfig;
- using Output = glm::vec2;
+ using Output = glm::vec2;
using JobModel = render::Job::ModelO;
void configure(const Config& config);
@@ -95,7 +95,7 @@ class AntialiasingConfig : public render::Job::Config {
Q_PROPERTY(bool debug MEMBER debug NOTIFY dirty)
Q_PROPERTY(float debugX MEMBER debugX NOTIFY dirty)
- Q_PROPERTY(float debugFXAAX MEMBER debugFXAAX NOTIFY dirty)
+ Q_PROPERTY(bool fxaaOnOff READ debugFXAA WRITE setDebugFXAA NOTIFY dirty)
Q_PROPERTY(float debugShowVelocityThreshold MEMBER debugShowVelocityThreshold NOTIFY dirty)
Q_PROPERTY(bool showCursorPixel MEMBER showCursorPixel NOTIFY dirty)
Q_PROPERTY(glm::vec2 debugCursorTexcoord MEMBER debugCursorTexcoord NOTIFY dirty)
@@ -106,6 +106,10 @@ class AntialiasingConfig : public render::Job::Config {
public:
AntialiasingConfig() : render::Job::Config(true) {}
+ void setDebugFXAA(bool debug) { debugFXAAX = (debug ? 0.0f : 1.0f); emit dirty();}
+ bool debugFXAA() const { return (debugFXAAX == 0.0f ? true : false); }
+
+
float blend{ 0.25f };
float sharpen{ 0.05f };
diff --git a/libraries/render-utils/src/DeferredBufferWrite.slh b/libraries/render-utils/src/DeferredBufferWrite.slh
index 49db49af2a..ae8d6fa277 100644
--- a/libraries/render-utils/src/DeferredBufferWrite.slh
+++ b/libraries/render-utils/src/DeferredBufferWrite.slh
@@ -27,6 +27,7 @@ float evalOpaqueFinalAlpha(float alpha, float mapAlpha) {
}
<@include DefaultMaterials.slh@>
+<@include LightingModel.slh@>
void packDeferredFragment(vec3 normal, float alpha, vec3 albedo, float roughness, float metallic, vec3 emissive, float occlusion, float scattering) {
if (alpha != 1.0) {
@@ -36,7 +37,7 @@ void packDeferredFragment(vec3 normal, float alpha, vec3 albedo, float roughness
_fragColor1 = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0));
_fragColor2 = vec4(((scattering > 0.0) ? vec3(scattering) : emissive), occlusion);
- _fragColor3 = vec4(emissive, 1.0);
+ _fragColor3 = vec4(isEmissiveEnabled() * emissive, 1.0);
}
void packDeferredFragmentLightmap(vec3 normal, float alpha, vec3 albedo, float roughness, float metallic, vec3 fresnel, vec3 lightmap) {
@@ -46,9 +47,9 @@ void packDeferredFragmentLightmap(vec3 normal, float alpha, vec3 albedo, float r
_fragColor0 = vec4(albedo, packLightmappedMetallic(metallic));
_fragColor1 = vec4(packNormal(normal), clamp(roughness, 0.0, 1.0));
- _fragColor2 = vec4(lightmap, 1.0);
+ _fragColor2 = vec4(isLightmapEnabled() * lightmap, 1.0);
- _fragColor3 = vec4(lightmap * albedo, 1.0);
+ _fragColor3 = vec4(isLightmapEnabled() * lightmap * albedo, 1.0);
}
void packDeferredFragmentUnlit(vec3 normal, float alpha, vec3 color) {
diff --git a/libraries/render-utils/src/DeferredGlobalLight.slh b/libraries/render-utils/src/DeferredGlobalLight.slh
index f6c1d290a7..c4894200a3 100644
--- a/libraries/render-utils/src/DeferredGlobalLight.slh
+++ b/libraries/render-utils/src/DeferredGlobalLight.slh
@@ -140,7 +140,7 @@ vec3 evalSkyboxGlobalColor(mat4 invViewMat, float shadowAttenuation, float obscu
color += directionalSpecular;
// Attenuate the light if haze effect selected
- if ((hazeParams.hazeMode & HAZE_MODE_IS_KEYLIGHT_ATTENUATED) == HAZE_MODE_IS_KEYLIGHT_ATTENUATED) {
+ if ((isHazeEnabled() > 0.0) && (hazeParams.hazeMode & HAZE_MODE_IS_KEYLIGHT_ATTENUATED) == HAZE_MODE_IS_KEYLIGHT_ATTENUATED) {
color = computeHazeColorKeyLightAttenuation(color, lightDirection, fragPositionWS);
}
@@ -234,7 +234,7 @@ vec3 evalGlobalLightingAlphaBlendedWithHaze(
color += (ambientSpecular + directionalSpecular) / opacity;
// Haze
- if ((hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) == HAZE_MODE_IS_ACTIVE) {
+ if ((isHazeEnabled() > 0.0) && (hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) == HAZE_MODE_IS_ACTIVE) {
vec4 colorV4 = computeHazeColor(
vec4(color, 1.0), // fragment original color
positionES, // fragment position in eye coordinates
@@ -272,7 +272,7 @@ vec3 evalGlobalLightingAlphaBlendedWithHaze(
color += (ambientSpecular + directionalSpecular) / opacity;
// Haze
- if ((hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) == HAZE_MODE_IS_ACTIVE) {
+ if ((isHazeEnabled() > 0.0) && (hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) == HAZE_MODE_IS_ACTIVE) {
vec4 colorV4 = computeHazeColor(
vec4(color, 1.0), // fragment original color
positionES, // fragment position in eye coordinates
diff --git a/libraries/render-utils/src/DeferredLightingEffect.cpp b/libraries/render-utils/src/DeferredLightingEffect.cpp
index 956b6c4a58..3074bb2e7f 100644
--- a/libraries/render-utils/src/DeferredLightingEffect.cpp
+++ b/libraries/render-utils/src/DeferredLightingEffect.cpp
@@ -61,20 +61,22 @@ enum DeferredShader_MapSlot {
DEFERRED_BUFFER_EMISSIVE_UNIT = 2,
DEFERRED_BUFFER_DEPTH_UNIT = 3,
DEFERRED_BUFFER_OBSCURANCE_UNIT = 4,
- SHADOW_MAP_UNIT = 5,
- SKYBOX_MAP_UNIT = SHADOW_MAP_UNIT + SHADOW_CASCADE_MAX_COUNT,
- DEFERRED_BUFFER_LINEAR_DEPTH_UNIT,
- DEFERRED_BUFFER_CURVATURE_UNIT,
- DEFERRED_BUFFER_DIFFUSED_CURVATURE_UNIT,
- SCATTERING_LUT_UNIT,
- SCATTERING_SPECULAR_UNIT,
+ DEFERRED_BUFFER_LINEAR_DEPTH_UNIT = 5,
+ DEFERRED_BUFFER_CURVATURE_UNIT = 6,
+ DEFERRED_BUFFER_DIFFUSED_CURVATURE_UNIT = 7,
+ SCATTERING_LUT_UNIT = 8,
+ SCATTERING_SPECULAR_UNIT = 9,
+ SKYBOX_MAP_UNIT = render::ShapePipeline::Slot::LIGHT_AMBIENT_MAP, // unit = 10
+ SHADOW_MAP_UNIT = 11,
+ nextAvailableUnit = SHADOW_MAP_UNIT + SHADOW_CASCADE_MAX_COUNT
};
enum DeferredShader_BufferSlot {
DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT = 0,
CAMERA_CORRECTION_BUFFER_SLOT,
SCATTERING_PARAMETERS_BUFFER_SLOT,
LIGHTING_MODEL_BUFFER_SLOT = render::ShapePipeline::Slot::LIGHTING_MODEL,
- LIGHT_GPU_SLOT = render::ShapePipeline::Slot::LIGHT,
+ KEY_LIGHT_SLOT = render::ShapePipeline::Slot::KEY_LIGHT,
+ LIGHT_ARRAY_SLOT = render::ShapePipeline::Slot::LIGHT_ARRAY_BUFFER,
LIGHT_AMBIENT_SLOT = render::ShapePipeline::Slot::LIGHT_AMBIENT_BUFFER,
HAZE_MODEL_BUFFER_SLOT = render::ShapePipeline::Slot::HAZE_MODEL,
LIGHT_INDEX_GPU_SLOT,
@@ -149,17 +151,20 @@ void DeferredLightingEffect::unsetKeyLightBatch(gpu::Batch& batch, int lightBuff
}
void DeferredLightingEffect::setupLocalLightsBatch(gpu::Batch& batch,
- int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit,
+ int lightArrayBufferUnit, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit,
const LightClustersPointer& lightClusters) {
// Bind the global list of lights and the visible lights this frame
- batch.setUniformBuffer(_localLightLocations->lightBufferUnit, lightClusters->_lightStage->getLightArrayBuffer());
+ batch.setUniformBuffer(lightArrayBufferUnit, lightClusters->_lightStage->getLightArrayBuffer());
batch.setUniformBuffer(frustumGridBufferUnit, lightClusters->_frustumGridBuffer);
batch.setUniformBuffer(clusterGridBufferUnit, lightClusters->_clusterGridBuffer);
batch.setUniformBuffer(clusterContentBufferUnit, lightClusters->_clusterContentBuffer);
}
-void DeferredLightingEffect::unsetLocalLightsBatch(gpu::Batch& batch, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit) {
+void DeferredLightingEffect::unsetLocalLightsBatch(gpu::Batch& batch, int lightArrayBufferUnit, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit) {
+ if (lightArrayBufferUnit >= 0) {
+ batch.setUniformBuffer(lightArrayBufferUnit, nullptr);
+ }
if (clusterGridBufferUnit >= 0) {
batch.setUniformBuffer(clusterGridBufferUnit, nullptr);
}
@@ -194,7 +199,8 @@ static gpu::ShaderPointer makeLightProgram(const gpu::ShaderPointer& vertShader,
slotBindings.insert(gpu::Shader::Binding(std::string("lightingModelBuffer"), LIGHTING_MODEL_BUFFER_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("hazeBuffer"), HAZE_MODEL_BUFFER_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("subsurfaceScatteringParametersBuffer"), SCATTERING_PARAMETERS_BUFFER_SLOT));
- slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), LIGHT_GPU_SLOT));
+ slotBindings.insert(gpu::Shader::Binding(std::string("keyLightBuffer"), KEY_LIGHT_SLOT));
+ slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), LIGHT_ARRAY_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("lightAmbientBuffer"), LIGHT_AMBIENT_SLOT));
slotBindings.insert(gpu::Shader::Binding(std::string("lightIndexBuffer"), LIGHT_INDEX_GPU_SLOT));
@@ -592,7 +598,7 @@ void RenderDeferredSetup::run(const render::RenderContextPointer& renderContext,
batch._glUniform4fv(locations->texcoordFrameTransform, 1, reinterpret_cast< const float* >(&textureFrameTransform));
// Setup the global lighting
- deferredLightingEffect->setupKeyLightBatch(args, batch, locations->keyLightBufferUnit, locations->ambientBufferUnit, SKYBOX_MAP_UNIT);
+ deferredLightingEffect->setupKeyLightBatch(args, batch, KEY_LIGHT_SLOT, LIGHT_AMBIENT_SLOT, SKYBOX_MAP_UNIT);
// Haze
if (haze) {
@@ -601,7 +607,7 @@ void RenderDeferredSetup::run(const render::RenderContextPointer& renderContext,
batch.draw(gpu::TRIANGLE_STRIP, 4);
- deferredLightingEffect->unsetKeyLightBatch(batch, locations->keyLightBufferUnit, locations->ambientBufferUnit, SKYBOX_MAP_UNIT);
+ deferredLightingEffect->unsetKeyLightBatch(batch, KEY_LIGHT_SLOT, LIGHT_AMBIENT_SLOT, SKYBOX_MAP_UNIT);
for (auto i = 0; i < SHADOW_CASCADE_MAX_COUNT; i++) {
batch.setResourceTexture(SHADOW_MAP_UNIT+i, nullptr);
@@ -656,8 +662,9 @@ void RenderDeferredLocals::run(const render::RenderContextPointer& renderContext
auto& lightIndices = lightClusters->_visibleLightIndices;
if (!lightIndices.empty() && lightIndices[0] > 0) {
- deferredLightingEffect->setupLocalLightsBatch(batch, LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT, LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT, LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT,
- lightClusters);
+ deferredLightingEffect->setupLocalLightsBatch(batch,
+ LIGHT_ARRAY_SLOT, LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT, LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT, LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT,
+ lightClusters);
// Local light pipeline
batch.setPipeline(deferredLightingEffect->_localLight);
diff --git a/libraries/render-utils/src/DeferredLightingEffect.h b/libraries/render-utils/src/DeferredLightingEffect.h
index ce7ecacbbe..3b77b8137e 100644
--- a/libraries/render-utils/src/DeferredLightingEffect.h
+++ b/libraries/render-utils/src/DeferredLightingEffect.h
@@ -51,8 +51,8 @@ public:
void setupKeyLightBatch(const RenderArgs* args, gpu::Batch& batch, int lightBufferUnit, int ambientBufferUnit, int skyboxCubemapUnit);
void unsetKeyLightBatch(gpu::Batch& batch, int lightBufferUnit, int ambientBufferUnit, int skyboxCubemapUnit);
- void setupLocalLightsBatch(gpu::Batch& batch, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit, const LightClustersPointer& lightClusters);
- void unsetLocalLightsBatch(gpu::Batch& batch, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit);
+ void setupLocalLightsBatch(gpu::Batch& batch, int lightArrayBufferUnit, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit, const LightClustersPointer& lightClusters);
+ void unsetLocalLightsBatch(gpu::Batch& batch, int lightArrayBufferUnit, int clusterGridBufferUnit, int clusterContentBufferUnit, int frustumGridBufferUnit);
void setShadowMapEnabled(bool enable) { _shadowMapEnabled = enable; };
void setAmbientOcclusionEnabled(bool enable) { _ambientOcclusionEnabled = enable; }
diff --git a/libraries/render-utils/src/GeometryCache.cpp b/libraries/render-utils/src/GeometryCache.cpp
index 8be142d939..0d8561ad21 100644
--- a/libraries/render-utils/src/GeometryCache.cpp
+++ b/libraries/render-utils/src/GeometryCache.cpp
@@ -2264,7 +2264,7 @@ gpu::PipelinePointer GeometryCache::getSimplePipeline(bool textured, bool transp
slotBindings.insert(gpu::Shader::Binding(std::string("lightingModelBuffer"), render::ShapePipeline::Slot::LIGHTING_MODEL));
slotBindings.insert(gpu::Shader::Binding(std::string("keyLightBuffer"), render::ShapePipeline::Slot::KEY_LIGHT));
slotBindings.insert(gpu::Shader::Binding(std::string("lightAmbientBuffer"), render::ShapePipeline::Slot::LIGHT_AMBIENT_BUFFER));
- slotBindings.insert(gpu::Shader::Binding(std::string("skyboxMap"), render::ShapePipeline::Slot::MAP::LIGHT_AMBIENT));
+ slotBindings.insert(gpu::Shader::Binding(std::string("skyboxMap"), render::ShapePipeline::Slot::MAP::LIGHT_AMBIENT_MAP));
gpu::Shader::makeProgram(*_simpleShader, slotBindings);
gpu::Shader::makeProgram(*_transparentShader, slotBindings);
gpu::Shader::makeProgram(*_unlitShader, slotBindings);
@@ -2284,7 +2284,7 @@ gpu::PipelinePointer GeometryCache::getSimplePipeline(bool textured, bool transp
slotBindings.insert(gpu::Shader::Binding(std::string("lightingModelBuffer"), render::ShapePipeline::Slot::LIGHTING_MODEL));
slotBindings.insert(gpu::Shader::Binding(std::string("keyLightBuffer"), render::ShapePipeline::Slot::KEY_LIGHT));
slotBindings.insert(gpu::Shader::Binding(std::string("lightAmbientBuffer"), render::ShapePipeline::Slot::LIGHT_AMBIENT_BUFFER));
- slotBindings.insert(gpu::Shader::Binding(std::string("skyboxMap"), render::ShapePipeline::Slot::MAP::LIGHT_AMBIENT));
+ slotBindings.insert(gpu::Shader::Binding(std::string("skyboxMap"), render::ShapePipeline::Slot::MAP::LIGHT_AMBIENT_MAP));
slotBindings.insert(gpu::Shader::Binding(std::string("fadeMaskMap"), render::ShapePipeline::Slot::MAP::FADE_MASK));
gpu::Shader::makeProgram(*_simpleFadeShader, slotBindings);
gpu::Shader::makeProgram(*_unlitFadeShader, slotBindings);
diff --git a/libraries/render-utils/src/Haze.slf b/libraries/render-utils/src/Haze.slf
index b9f23fd932..6b45a72768 100644
--- a/libraries/render-utils/src/Haze.slf
+++ b/libraries/render-utils/src/Haze.slf
@@ -42,7 +42,7 @@ in vec2 varTexCoord0;
out vec4 outFragColor;
void main(void) {
- if ((hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) != HAZE_MODE_IS_ACTIVE) {
+ if ((isHazeEnabled() == 0.0) || (hazeParams.hazeMode & HAZE_MODE_IS_ACTIVE) != HAZE_MODE_IS_ACTIVE) {
discard;
}
diff --git a/libraries/render-utils/src/HighlightEffect.cpp b/libraries/render-utils/src/HighlightEffect.cpp
index d151da766b..3905d3a54c 100644
--- a/libraries/render-utils/src/HighlightEffect.cpp
+++ b/libraries/render-utils/src/HighlightEffect.cpp
@@ -169,6 +169,7 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
glm::mat4 projMat;
Transform viewMat;
+ const auto jitter = inputs.get2();
args->getViewFrustum().evalProjectionMatrix(projMat);
args->getViewFrustum().evalViewTransform(viewMat);
@@ -183,6 +184,7 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
// Setup camera, projection and viewport for all items
batch.setViewportTransform(args->_viewport);
batch.setProjectionTransform(projMat);
+ batch.setProjectionJitter(jitter.x, jitter.y);
batch.setViewTransform(viewMat);
std::vector skinnedShapeKeys{};
@@ -356,6 +358,7 @@ void DebugHighlight::run(const render::RenderContextPointer& renderContext, cons
assert(renderContext->args);
assert(renderContext->args->hasViewFrustum());
RenderArgs* args = renderContext->args;
+ const auto jitter = input.get2();
gpu::doInBatch("DebugHighlight::run", args->_context, [&](gpu::Batch& batch) {
batch.setViewportTransform(args->_viewport);
@@ -368,6 +371,7 @@ void DebugHighlight::run(const render::RenderContextPointer& renderContext, cons
args->getViewFrustum().evalProjectionMatrix(projMat);
args->getViewFrustum().evalViewTransform(viewMat);
batch.setProjectionTransform(projMat);
+ batch.setProjectionJitter(jitter.x, jitter.y);
batch.setViewTransform(viewMat, true);
batch.setModelTransform(Transform());
@@ -480,6 +484,7 @@ void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, ren
const auto sceneFrameBuffer = inputs.getN(1);
const auto primaryFramebuffer = inputs.getN(2);
const auto deferredFrameTransform = inputs.getN(3);
+ const auto jitter = inputs.getN(4);
// Prepare the ShapePipeline
auto shapePlumber = std::make_shared();
@@ -515,7 +520,7 @@ void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, ren
stream << "HighlightMask" << i;
name = stream.str();
}
- const auto drawMaskInputs = DrawHighlightMask::Inputs(sortedBounds, highlightRessources).asVarying();
+ const auto drawMaskInputs = DrawHighlightMask::Inputs(sortedBounds, highlightRessources, jitter).asVarying();
const auto highlightedRect = task.addJob(name, drawMaskInputs, i, shapePlumber, sharedParameters);
if (i == 0) {
highlight0Rect = highlightedRect;
@@ -532,7 +537,7 @@ void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, ren
}
// Debug highlight
- const auto debugInputs = DebugHighlight::Inputs(highlightRessources, const_cast(highlight0Rect)).asVarying();
+ const auto debugInputs = DebugHighlight::Inputs(highlightRessources, const_cast(highlight0Rect), jitter).asVarying();
task.addJob("HighlightDebug", debugInputs);
}
diff --git a/libraries/render-utils/src/HighlightEffect.h b/libraries/render-utils/src/HighlightEffect.h
index 90a8e730ce..7c1db795fb 100644
--- a/libraries/render-utils/src/HighlightEffect.h
+++ b/libraries/render-utils/src/HighlightEffect.h
@@ -113,7 +113,7 @@ private:
class DrawHighlightMask {
public:
- using Inputs = render::VaryingSet2;
+ using Inputs = render::VaryingSet3;
using Outputs = glm::ivec4;
using JobModel = render::Job::ModelIO;
@@ -182,7 +182,7 @@ signals:
class DebugHighlight {
public:
- using Inputs = render::VaryingSet2;
+ using Inputs = render::VaryingSet3;
using Config = DebugHighlightConfig;
using JobModel = render::Job::ModelI;
@@ -205,7 +205,7 @@ private:
class DrawHighlightTask {
public:
- using Inputs = render::VaryingSet4;
+ using Inputs = render::VaryingSet5;
using Config = render::Task::Config;
using JobModel = render::Task::ModelI;
diff --git a/libraries/render-utils/src/LightClusters.cpp b/libraries/render-utils/src/LightClusters.cpp
index ea02edb601..36d3fe9e49 100644
--- a/libraries/render-utils/src/LightClusters.cpp
+++ b/libraries/render-utils/src/LightClusters.cpp
@@ -39,7 +39,7 @@ enum LightClusterGridShader_MapSlot {
enum LightClusterGridShader_BufferSlot {
DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT = 0,
CAMERA_CORRECTION_BUFFER_SLOT = 1,
- LIGHT_GPU_SLOT = render::ShapePipeline::Slot::LIGHT,
+ LIGHT_GPU_SLOT = render::ShapePipeline::Slot::LIGHT_ARRAY_BUFFER,
LIGHT_INDEX_GPU_SLOT = 7,
LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT = 8,
LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT = 9,
diff --git a/libraries/render-utils/src/LightingModel.cpp b/libraries/render-utils/src/LightingModel.cpp
index 30801ac69e..23d4c66fd5 100644
--- a/libraries/render-utils/src/LightingModel.cpp
+++ b/libraries/render-utils/src/LightingModel.cpp
@@ -49,6 +49,14 @@ void LightingModel::setBackground(bool enable) {
bool LightingModel::isBackgroundEnabled() const {
return (bool)_parametersBuffer.get().enableBackground;
}
+void LightingModel::setHaze(bool enable) {
+ if (enable != isHazeEnabled()) {
+ _parametersBuffer.edit().enableHaze = (float)enable;
+ }
+}
+bool LightingModel::isHazeEnabled() const {
+ return (bool)_parametersBuffer.get().enableHaze;
+}
void LightingModel::setObscurance(bool enable) {
if (enable != isObscuranceEnabled()) {
_parametersBuffer.edit().enableObscurance = (float)enable;
@@ -160,6 +168,7 @@ void MakeLightingModel::configure(const Config& config) {
_lightingModel->setEmissive(config.enableEmissive);
_lightingModel->setLightmap(config.enableLightmap);
_lightingModel->setBackground(config.enableBackground);
+ _lightingModel->setHaze(config.enableHaze);
_lightingModel->setObscurance(config.enableObscurance);
diff --git a/libraries/render-utils/src/LightingModel.h b/libraries/render-utils/src/LightingModel.h
index e058b10921..c71917603c 100644
--- a/libraries/render-utils/src/LightingModel.h
+++ b/libraries/render-utils/src/LightingModel.h
@@ -36,6 +36,9 @@ public:
void setBackground(bool enable);
bool isBackgroundEnabled() const;
+ void setHaze(bool enable);
+ bool isHazeEnabled() const;
+
void setObscurance(bool enable);
bool isObscuranceEnabled() const;
@@ -86,7 +89,6 @@ protected:
float enableSpecular{ 1.0f };
float enableAlbedo{ 1.0f };
-
float enableAmbientLight{ 1.0f };
float enableDirectionalLight{ 1.0f };
float enablePointLight{ 1.0f };
@@ -99,6 +101,11 @@ protected:
float enableMaterialTexturing { 1.0f };
float enableWireframe { 0.0f }; // false by default
+ float enableHaze{ 1.0f };
+ float spare1; // Needed for having the LightingModel class aligned on a 4 scalar boundary for gpu
+ float spare2;
+ float spare3;
+
Parameters() {}
};
UniformBufferView _parametersBuffer;
@@ -116,6 +123,7 @@ class MakeLightingModelConfig : public render::Job::Config {
Q_PROPERTY(bool enableEmissive MEMBER enableEmissive NOTIFY dirty)
Q_PROPERTY(bool enableLightmap MEMBER enableLightmap NOTIFY dirty)
Q_PROPERTY(bool enableBackground MEMBER enableBackground NOTIFY dirty)
+ Q_PROPERTY(bool enableHaze MEMBER enableHaze NOTIFY dirty)
Q_PROPERTY(bool enableObscurance MEMBER enableObscurance NOTIFY dirty)
@@ -158,6 +166,7 @@ public:
bool showLightContour { false }; // false by default
bool enableWireframe { false }; // false by default
+ bool enableHaze{ true };
signals:
void dirty();
diff --git a/libraries/render-utils/src/LightingModel.slh b/libraries/render-utils/src/LightingModel.slh
index 8abdb5cbf9..3b1c94f949 100644
--- a/libraries/render-utils/src/LightingModel.slh
+++ b/libraries/render-utils/src/LightingModel.slh
@@ -18,6 +18,7 @@ struct LightingModel {
vec4 _ScatteringDiffuseSpecularAlbedo;
vec4 _AmbientDirectionalPointSpot;
vec4 _ShowContourObscuranceWireframe;
+ vec4 _Haze_spareyzw;
};
uniform lightingModelBuffer{
@@ -74,6 +75,10 @@ float isWireframeEnabled() {
return lightingModel._ShowContourObscuranceWireframe.z;
}
+float isHazeEnabled() {
+ return lightingModel._Haze_spareyzw.x;
+}
+
<@endfunc@>
<$declareLightingModel()$>
diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp
index bea298122e..3ea56f8542 100644
--- a/libraries/render-utils/src/RenderDeferredTask.cpp
+++ b/libraries/render-utils/src/RenderDeferredTask.cpp
@@ -178,7 +178,7 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
task.addJob("DrawHazeDeferred", drawHazeInputs);
// Render transparent objects forward in LightingBuffer
- const auto transparentsInputs = DrawDeferred::Inputs(transparents, lightingModel, lightClusters).asVarying();
+ const auto transparentsInputs = DrawDeferred::Inputs(transparents, lightingModel, lightClusters, jitter).asVarying();
task.addJob("DrawTransparentDeferred", transparentsInputs, shapePlumber);
// Light Cluster Grid Debuging job
@@ -192,7 +192,7 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
const auto selectionBaseName = "contextOverlayHighlightList";
const auto selectedItems = addSelectItemJobs(task, selectionBaseName, metas, opaques, transparents);
- const auto outlineInputs = DrawHighlightTask::Inputs(items.get0(), deferredFramebuffer, lightingFramebuffer, deferredFrameTransform).asVarying();
+ const auto outlineInputs = DrawHighlightTask::Inputs(items.get0(), deferredFramebuffer, lightingFramebuffer, deferredFrameTransform, jitter).asVarying();
task.addJob("DrawHighlight", outlineInputs);
task.addJob("HighlightRangeTimer", outlineRangeTimer);
@@ -277,7 +277,8 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
// Grab a texture map representing the different status icons and assign that to the drawStatsuJob
auto iconMapPath = PathUtils::resourcesPath() + "icons/statusIconAtlas.svg";
auto statusIconMap = DependencyManager::get()->getImageTexture(iconMapPath, image::TextureUsage::STRICT_TEXTURE);
- task.addJob("DrawStatus", opaques, DrawStatus(statusIconMap));
+ const auto drawStatusInputs = DrawStatus::Input(opaques, jitter).asVarying();
+ task.addJob("DrawStatus", drawStatusInputs, DrawStatus(statusIconMap));
}
task.addJob("DrawZoneStack", deferredFrameTransform);
@@ -315,6 +316,7 @@ void DrawDeferred::run(const RenderContextPointer& renderContext, const Inputs&
const auto& inItems = inputs.get0();
const auto& lightingModel = inputs.get1();
const auto& lightClusters = inputs.get2();
+ const auto jitter = inputs.get3();
auto deferredLightingEffect = DependencyManager::get();
RenderArgs* args = renderContext->args;
@@ -332,16 +334,24 @@ void DrawDeferred::run(const RenderContextPointer& renderContext, const Inputs&
args->getViewFrustum().evalViewTransform(viewMat);
batch.setProjectionTransform(projMat);
+ batch.setProjectionJitter(jitter.x, jitter.y);
batch.setViewTransform(viewMat);
// Setup lighting model for all items;
batch.setUniformBuffer(render::ShapePipeline::Slot::LIGHTING_MODEL, lightingModel->getParametersBuffer());
- deferredLightingEffect->setupLocalLightsBatch(batch,
- render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT,
- render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT,
- render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT,
- lightClusters);
+ // Set the light
+ deferredLightingEffect->setupKeyLightBatch(args, batch,
+ render::ShapePipeline::Slot::KEY_LIGHT,
+ render::ShapePipeline::Slot::LIGHT_AMBIENT_BUFFER,
+ render::ShapePipeline::Slot::LIGHT_AMBIENT_MAP);
+
+ deferredLightingEffect->setupLocalLightsBatch(batch,
+ render::ShapePipeline::Slot::LIGHT_ARRAY_BUFFER,
+ render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT,
+ render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT,
+ render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT,
+ lightClusters);
// Setup haze if current zone has haze
auto hazeStage = args->_scene->getStage();
@@ -367,9 +377,15 @@ void DrawDeferred::run(const RenderContextPointer& renderContext, const Inputs&
args->_globalShapeKey = 0;
deferredLightingEffect->unsetLocalLightsBatch(batch,
- render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT,
- render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT,
- render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT);
+ render::ShapePipeline::Slot::LIGHT_ARRAY_BUFFER,
+ render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT,
+ render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT,
+ render::ShapePipeline::Slot::LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT);
+
+ deferredLightingEffect->unsetKeyLightBatch(batch,
+ render::ShapePipeline::Slot::KEY_LIGHT,
+ render::ShapePipeline::Slot::LIGHT_AMBIENT_BUFFER,
+ render::ShapePipeline::Slot::LIGHT_AMBIENT_MAP);
});
config->setNumDrawn((int)inItems.size());
diff --git a/libraries/render-utils/src/RenderDeferredTask.h b/libraries/render-utils/src/RenderDeferredTask.h
index b923ec0878..9917058790 100644
--- a/libraries/render-utils/src/RenderDeferredTask.h
+++ b/libraries/render-utils/src/RenderDeferredTask.h
@@ -41,7 +41,7 @@ protected:
class DrawDeferred {
public:
- using Inputs = render::VaryingSet3 ;
+ using Inputs = render::VaryingSet4;
using Config = DrawDeferredConfig;
using JobModel = render::Job::ModelI;
diff --git a/libraries/render-utils/src/RenderForwardTask.cpp b/libraries/render-utils/src/RenderForwardTask.cpp
index 63370109e0..4388a39cf3 100755
--- a/libraries/render-utils/src/RenderForwardTask.cpp
+++ b/libraries/render-utils/src/RenderForwardTask.cpp
@@ -21,6 +21,8 @@
#include
+#include
+
#include "StencilMaskPass.h"
#include "ZoneRenderer.h"
#include "FadeEffect.h"
@@ -53,8 +55,9 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
const auto& transparents = items.get0()[RenderFetchCullSortTask::TRANSPARENT_SHAPE];
// const auto& lights = items.get0()[RenderFetchCullSortTask::LIGHT];
const auto& metas = items.get0()[RenderFetchCullSortTask::META];
- // const auto& overlayOpaques = items.get0()[RenderFetchCullSortTask::OVERLAY_OPAQUE_SHAPE];
- // const auto& overlayTransparents = items.get0()[RenderFetchCullSortTask::OVERLAY_TRANSPARENT_SHAPE];
+ const auto& overlayOpaques = items.get0()[RenderFetchCullSortTask::OVERLAY_OPAQUE_SHAPE];
+ const auto& overlayTransparents = items.get0()[RenderFetchCullSortTask::OVERLAY_TRANSPARENT_SHAPE];
+
//const auto& background = items.get0()[RenderFetchCullSortTask::BACKGROUND];
// const auto& spatialSelection = items[1];
@@ -75,6 +78,17 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
// draw a stencil mask in hidden regions of the framebuffer.
task.addJob("PrepareStencil", framebuffer);
+ // Layered Overlays
+ const auto filteredOverlaysOpaque = task.addJob("FilterOverlaysLayeredOpaque", overlayOpaques, Item::LAYER_3D_FRONT);
+ const auto filteredOverlaysTransparent = task.addJob("FilterOverlaysLayeredTransparent", overlayTransparents, Item::LAYER_3D_FRONT);
+ const auto overlaysInFrontOpaque = filteredOverlaysOpaque.getN(0);
+ const auto overlaysInFrontTransparent = filteredOverlaysTransparent.getN