Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of github.com:highfidelity/hifi into perfTest_1

Browse source
This commit is contained in:
NissimHadar 2018-05-10 17:05:59 -07:00
commit 480fa912ba
99 changed files with 1454 additions and 412 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -180,6 +180,7 @@ add_subdirectory(tools)
if (BUILD_TESTS)
add_subdirectory(tests)
add_subdirectory(tests-manual)
endif()
if (BUILD_INSTALLER)

5
cmake/macros/SetupHifiTestCase.cmake
View file

@ -124,15 +124,14 @@ macro(SETUP_HIFI_TESTCASE)
# This target will also build + run the other test targets using ctest when built.
add_custom_target(${TEST_TARGET}
COMMAND ctest .
SOURCES ${TEST_PROJ_SRC_FILES} # display source files under the testcase target
DEPENDS ${${TEST_PROJ_NAME}_TARGETS})
set_target_properties(${TEST_TARGET} PROPERTIES
FOLDER "Tests"
EXCLUDE_FROM_DEFAULT_BUILD TRUE
EXCLUDE_FROM_ALL TRUE)
set_target_properties(${TEST_TARGET} PROPERTIES FOLDER "Tests")
list (APPEND ALL_TEST_TARGETS ${TEST_TARGET})
set(ALL_TEST_TARGETS "${ALL_TEST_TARGETS}" PARENT_SCOPE)
else ()

15
libraries/gl/src/gl/OffscreenGLCanvas.cpp
View file

@ -103,12 +103,15 @@ void OffscreenGLCanvas::onMessageLogged(const QOpenGLDebugMessage& debugMessage)
bool OffscreenGLCanvas::makeCurrent() {
bool result = _context->makeCurrent(_offscreenSurface);
std::call_once(_reportOnce, []{
qCDebug(glLogging) << "GL Version: " << QString((const char*) glGetString(GL_VERSION));
qCDebug(glLogging) << "GL Shader Language Version: " << QString((const char*) glGetString(GL_SHADING_LANGUAGE_VERSION));
qCDebug(glLogging) << "GL Vendor: " << QString((const char*) glGetString(GL_VENDOR));
qCDebug(glLogging) << "GL Renderer: " << QString((const char*) glGetString(GL_RENDERER));
});
if (glGetString) {
std::call_once(_reportOnce, [] {
qCDebug(glLogging) << "GL Version: " << QString((const char*)glGetString(GL_VERSION));
qCDebug(glLogging) << "GL Shader Language Version: "
<< QString((const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
qCDebug(glLogging) << "GL Vendor: " << QString((const char*)glGetString(GL_VENDOR));
qCDebug(glLogging) << "GL Renderer: " << QString((const char*)glGetString(GL_RENDERER));
});
}
return result;
}

117
libraries/networking/src/HMACAuth.cpp Normal file
View file

@ -0,0 +1,117 @@
//
// HMACAuth.cpp
// libraries/networking/src
//
// Created by Simon Walton on 3/19/2018.
// Copyright 2018 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 "HMACAuth.h"
#include <openssl/opensslv.h>
#include <openssl/hmac.h>
#include <QUuid>
#include "NetworkLogging.h"
#include <cassert>
#if OPENSSL_VERSION_NUMBER >= 0x10100000
HMACAuth::HMACAuth(AuthMethod authMethod)
: _hmacContext(HMAC_CTX_new())
, _authMethod(authMethod) { }
HMACAuth::~HMACAuth()
{
HMAC_CTX_free(_hmacContext);
}
#else
HMACAuth::HMACAuth(AuthMethod authMethod)
: _hmacContext(new HMAC_CTX())
, _authMethod(authMethod) {
HMAC_CTX_init(_hmacContext);
}
HMACAuth::~HMACAuth() {
HMAC_CTX_cleanup(_hmacContext);
delete _hmacContext;
}
#endif
bool HMACAuth::setKey(const char* keyValue, int keyLen) {
const EVP_MD* sslStruct = nullptr;
switch (_authMethod) {
case MD5:
sslStruct = EVP_md5();
break;
case SHA1:
sslStruct = EVP_sha1();
break;
case SHA224:
sslStruct = EVP_sha224();
break;
case SHA256:
sslStruct = EVP_sha256();
break;
case RIPEMD160:
sslStruct = EVP_ripemd160();
break;
default:
return false;
}
QMutexLocker lock(&_lock);
return (bool) HMAC_Init_ex(_hmacContext, keyValue, keyLen, sslStruct, nullptr);
}
bool HMACAuth::setKey(const QUuid& uidKey) {
const QByteArray rfcBytes(uidKey.toRfc4122());
return setKey(rfcBytes.constData(), rfcBytes.length());
}
bool HMACAuth::addData(const char* data, int dataLen) {
QMutexLocker lock(&_lock);
return (bool) HMAC_Update(_hmacContext, reinterpret_cast<const unsigned char*>(data), dataLen);
}
HMACAuth::HMACHash HMACAuth::result() {
HMACHash hashValue(EVP_MAX_MD_SIZE);
unsigned int hashLen;
QMutexLocker lock(&_lock);
auto hmacResult = HMAC_Final(_hmacContext, &hashValue[0], &hashLen);
if (hmacResult) {
hashValue.resize((size_t)hashLen);
} else {
// the HMAC_FINAL call failed - should not be possible to get into this state
qCWarning(networking) << "Error occured calling HMAC_Final";
assert(hmacResult);
}
// Clear state for possible reuse.
HMAC_Init_ex(_hmacContext, nullptr, 0, nullptr, nullptr);
return hashValue;
}
bool HMACAuth::calculateHash(HMACHash& hashResult, const char* data, int dataLen) {
QMutexLocker lock(&_lock);
if (!addData(data, dataLen)) {
qCWarning(networking) << "Error occured calling HMACAuth::addData()";
assert(false);
return false;
}
hashResult = result();
return true;
}

47
libraries/networking/src/HMACAuth.h Normal file
View file

@ -0,0 +1,47 @@
//
// HMACAuth.h
// libraries/networking/src
//
// Created by Simon Walton on 3/19/2018.
// Copyright 2018 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_HMACAuth_h
#define hifi_HMACAuth_h
#include <vector>
#include <memory>
#include <QtCore/QMutex>
class QUuid;
class HMACAuth {
public:
enum AuthMethod { MD5, SHA1, SHA224, SHA256, RIPEMD160 };
using HMACHash = std::vector<unsigned char>;
explicit HMACAuth(AuthMethod authMethod = MD5);
~HMACAuth();
bool setKey(const char* keyValue, int keyLen);
bool setKey(const QUuid& uidKey);
// Calculate complete hash in one.
bool calculateHash(HMACHash& hashResult, const char* data, int dataLen);
// Append to data to be hashed.
bool addData(const char* data, int dataLen);
// Get the resulting hash from calls to addData().
// Note that only one hash may be calculated at a time for each
// HMACAuth instance if this interface is used.
HMACHash result();
private:
QMutex _lock { QMutex::Recursive };
struct hmac_ctx_st* _hmacContext;
AuthMethod _authMethod;
};
#endif // hifi_HMACAuth_h

47
libraries/networking/src/LimitedNodeList.cpp
View file

@ -36,6 +36,7 @@
#include "HifiSockAddr.h"
#include "NetworkLogging.h"
#include "udt/Packet.h"
#include "HMACAuth.h"
static Setting::Handle<quint16> LIMITED_NODELIST_LOCAL_PORT("LimitedNodeList.LocalPort", 0);
@ -332,15 +333,20 @@ bool LimitedNodeList::packetSourceAndHashMatchAndTrackBandwidth(const udt::Packe
if (verifiedPacket && !ignoreVerification) {
QByteArray packetHeaderHash = NLPacket::verificationHashInHeader(packet);
QByteArray expectedHash = NLPacket::hashForPacketAndSecret(packet, sourceNode->getConnectionSecret());
QByteArray expectedHash;
auto sourceNodeHMACAuth = sourceNode->getAuthenticateHash();
if (sourceNode->getAuthenticateHash()) {
expectedHash = NLPacket::hashForPacketAndHMAC(packet, *sourceNodeHMACAuth);
}
// check if the md5 hash in the header matches the hash we would expect
if (packetHeaderHash != expectedHash) {
// check if the HMAC-md5 hash in the header matches the hash we would expect
if (!sourceNodeHMACAuth || packetHeaderHash != expectedHash) {
static QMultiMap<QUuid, PacketType> hashDebugSuppressMap;
if (!hashDebugSuppressMap.contains(sourceID, headerType)) {
qCDebug(networking) << packetHeaderHash << expectedHash;
qCDebug(networking) << "Packet hash mismatch on" << headerType << "- Sender" << sourceID;
qCDebug(networking) << "Packet len:" << packet.getDataSize() << "Expected hash:" <<
expectedHash.toHex() << "Actual:" << packetHeaderHash.toHex();
hashDebugSuppressMap.insert(sourceID, headerType);
}
@ -372,15 +378,15 @@ void LimitedNodeList::collectPacketStats(const NLPacket& packet) {
_numCollectedBytes += packet.getDataSize();
}
void LimitedNodeList::fillPacketHeader(const NLPacket& packet, const QUuid& connectionSecret) {
void LimitedNodeList::fillPacketHeader(const NLPacket& packet, HMACAuth* hmacAuth) {
if (!PacketTypeEnum::getNonSourcedPackets().contains(packet.getType())) {
packet.writeSourceID(getSessionLocalID());
}
if (!connectionSecret.isNull()
if (hmacAuth
&& !PacketTypeEnum::getNonSourcedPackets().contains(packet.getType())
&& !PacketTypeEnum::getNonVerifiedPackets().contains(packet.getType())) {
packet.writeVerificationHashGivenSecret(connectionSecret);
packet.writeVerificationHash(*hmacAuth);
}
}
@ -396,17 +402,17 @@ qint64 LimitedNodeList::sendUnreliablePacket(const NLPacket& packet, const Node&
emit dataSent(destinationNode.getType(), packet.getDataSize());
destinationNode.recordBytesSent(packet.getDataSize());
return sendUnreliablePacket(packet, *destinationNode.getActiveSocket(), destinationNode.getConnectionSecret());
return sendUnreliablePacket(packet, *destinationNode.getActiveSocket(), destinationNode.getAuthenticateHash());
}
qint64 LimitedNodeList::sendUnreliablePacket(const NLPacket& packet, const HifiSockAddr& sockAddr,
const QUuid& connectionSecret) {
HMACAuth* hmacAuth) {
Q_ASSERT(!packet.isPartOfMessage());
Q_ASSERT_X(!packet.isReliable(), "LimitedNodeList::sendUnreliablePacket",
"Trying to send a reliable packet unreliably.");
collectPacketStats(packet);
fillPacketHeader(packet, connectionSecret);
fillPacketHeader(packet, hmacAuth);
return _nodeSocket.writePacket(packet, sockAddr);
}
@ -419,7 +425,7 @@ qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const Node&
emit dataSent(destinationNode.getType(), packet->getDataSize());
destinationNode.recordBytesSent(packet->getDataSize());
return sendPacket(std::move(packet), *activeSocket, destinationNode.getConnectionSecret());
return sendPacket(std::move(packet), *activeSocket, destinationNode.getAuthenticateHash());
} else {
qCDebug(networking) << "LimitedNodeList::sendPacket called without active socket for node" << destinationNode << "- not sending";
return ERROR_SENDING_PACKET_BYTES;
@ -427,18 +433,18 @@ qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const Node&
}
qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const HifiSockAddr& sockAddr,
const QUuid& connectionSecret) {
HMACAuth* hmacAuth) {
Q_ASSERT(!packet->isPartOfMessage());
if (packet->isReliable()) {
collectPacketStats(*packet);
fillPacketHeader(*packet, connectionSecret);
fillPacketHeader(*packet, hmacAuth);
auto size = packet->getDataSize();
_nodeSocket.writePacket(std::move(packet), sockAddr);
return size;
} else {
return sendUnreliablePacket(*packet, sockAddr, connectionSecret);
return sendUnreliablePacket(*packet, sockAddr, hmacAuth);
}
}
@ -447,13 +453,14 @@ qint64 LimitedNodeList::sendUnreliableUnorderedPacketList(NLPacketList& packetLi
if (activeSocket) {
qint64 bytesSent = 0;
auto connectionSecret = destinationNode.getConnectionSecret();
auto connectionHash = destinationNode.getAuthenticateHash();
// close the last packet in the list
packetList.closeCurrentPacket();
while (!packetList._packets.empty()) {
bytesSent += sendPacket(packetList.takeFront<NLPacket>(), *activeSocket, connectionSecret);
bytesSent += sendPacket(packetList.takeFront<NLPacket>(), *activeSocket,
connectionHash);
}
emit dataSent(destinationNode.getType(), bytesSent);
@ -466,14 +473,14 @@ qint64 LimitedNodeList::sendUnreliableUnorderedPacketList(NLPacketList& packetLi
}
qint64 LimitedNodeList::sendUnreliableUnorderedPacketList(NLPacketList& packetList, const HifiSockAddr& sockAddr,
const QUuid& connectionSecret) {
HMACAuth* hmacAuth) {
qint64 bytesSent = 0;
// close the last packet in the list
packetList.closeCurrentPacket();
while (!packetList._packets.empty()) {
bytesSent += sendPacket(packetList.takeFront<NLPacket>(), sockAddr, connectionSecret);
bytesSent += sendPacket(packetList.takeFront<NLPacket>(), sockAddr, hmacAuth);
}
return bytesSent;
@ -501,7 +508,7 @@ qint64 LimitedNodeList::sendPacketList(std::unique_ptr<NLPacketList> packetList,
for (std::unique_ptr<udt::Packet>& packet : packetList->_packets) {
NLPacket* nlPacket = static_cast<NLPacket*>(packet.get());
collectPacketStats(*nlPacket);
fillPacketHeader(*nlPacket, destinationNode.getConnectionSecret());
fillPacketHeader(*nlPacket, destinationNode.getAuthenticateHash());
}
return _nodeSocket.writePacketList(std::move(packetList), *activeSocket);
@ -524,7 +531,7 @@ qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const Node&
auto& destinationSockAddr = (overridenSockAddr.isNull()) ? *destinationNode.getActiveSocket()
: overridenSockAddr;
return sendPacket(std::move(packet), destinationSockAddr, destinationNode.getConnectionSecret());
return sendPacket(std::move(packet), destinationSockAddr, destinationNode.getAuthenticateHash());
}
int LimitedNodeList::updateNodeWithDataFromPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {

10
libraries/networking/src/LimitedNodeList.h
View file

@ -138,19 +138,17 @@ public:
// use sendUnreliablePacket to send an unreliable packet (that you do not need to move)
// either to a node (via its active socket) or to a manual sockaddr
qint64 sendUnreliablePacket(const NLPacket& packet, const Node& destinationNode);
qint64 sendUnreliablePacket(const NLPacket& packet, const HifiSockAddr& sockAddr,
const QUuid& connectionSecret = QUuid());
qint64 sendUnreliablePacket(const NLPacket& packet, const HifiSockAddr& sockAddr, HMACAuth* hmacAuth = nullptr);
// use sendPacket to send a moved unreliable or reliable NL packet to a node's active socket or manual sockaddr
qint64 sendPacket(std::unique_ptr<NLPacket> packet, const Node& destinationNode);
qint64 sendPacket(std::unique_ptr<NLPacket> packet, const HifiSockAddr& sockAddr,
const QUuid& connectionSecret = QUuid());
qint64 sendPacket(std::unique_ptr<NLPacket> packet, const HifiSockAddr& sockAddr, HMACAuth* hmacAuth = nullptr);
// use sendUnreliableUnorderedPacketList to unreliably send separate packets from the packet list
// either to a node's active socket or to a manual sockaddr
qint64 sendUnreliableUnorderedPacketList(NLPacketList& packetList, const Node& destinationNode);
qint64 sendUnreliableUnorderedPacketList(NLPacketList& packetList, const HifiSockAddr& sockAddr,
const QUuid& connectionSecret = QUuid());
HMACAuth* hmacAuth = nullptr);
// use sendPacketList to send reliable packet lists (ordered or unordered) to a node's active socket
// or to a manual sock addr
@ -372,7 +370,7 @@ protected:
qint64 writePacket(const NLPacket& packet, const HifiSockAddr& destinationSockAddr,
const QUuid& connectionSecret = QUuid());
void collectPacketStats(const NLPacket& packet);
void fillPacketHeader(const NLPacket& packet, const QUuid& connectionSecret = QUuid());
void fillPacketHeader(const NLPacket& packet, HMACAuth* hmacAuth = nullptr);
void setLocalSocket(const HifiSockAddr& sockAddr);

20
libraries/networking/src/NLPacket.cpp
View file

@ -11,6 +11,8 @@
#include "NLPacket.h"
#include "HMACAuth.h"
int NLPacket::localHeaderSize(PacketType type) {
bool nonSourced = PacketTypeEnum::getNonSourcedPackets().contains(type);
bool nonVerified = PacketTypeEnum::getNonVerifiedPackets().contains(type);
@ -150,18 +152,16 @@ QByteArray NLPacket::verificationHashInHeader(const udt::Packet& packet) {
return QByteArray(packet.getData() + offset, NUM_BYTES_MD5_HASH);
}
QByteArray NLPacket::hashForPacketAndSecret(const udt::Packet& packet, const QUuid& connectionSecret) {
QCryptographicHash hash(QCryptographicHash::Md5);
QByteArray NLPacket::hashForPacketAndHMAC(const udt::Packet& packet, HMACAuth& hash) {
int offset = Packet::totalHeaderSize(packet.isPartOfMessage()) + sizeof(PacketType) + sizeof(PacketVersion)
+ NUM_BYTES_LOCALID + NUM_BYTES_MD5_HASH;
// add the packet payload and the connection UUID
hash.addData(packet.getData() + offset, packet.getDataSize() - offset);
hash.addData(connectionSecret.toRfc4122());
// return the hash
return hash.result();
HMACAuth::HMACHash hashResult;
if (!hash.calculateHash(hashResult, packet.getData() + offset, packet.getDataSize() - offset)) {
return QByteArray();
}
return QByteArray((const char*) hashResult.data(), (int) hashResult.size());
}
void NLPacket::writeTypeAndVersion() {
@ -214,14 +214,14 @@ void NLPacket::writeSourceID(LocalID sourceID) const {
_sourceID = sourceID;
}
void NLPacket::writeVerificationHashGivenSecret(const QUuid& connectionSecret) const {
void NLPacket::writeVerificationHash(HMACAuth& hmacAuth) const {
Q_ASSERT(!PacketTypeEnum::getNonSourcedPackets().contains(_type) &&
!PacketTypeEnum::getNonVerifiedPackets().contains(_type));
auto offset = Packet::totalHeaderSize(isPartOfMessage()) + sizeof(PacketType) + sizeof(PacketVersion)
+ NUM_BYTES_LOCALID;
QByteArray verificationHash = hashForPacketAndSecret(*this, connectionSecret);
QByteArray verificationHash = hashForPacketAndHMAC(*this, hmacAuth);
memcpy(_packet.get() + offset, verificationHash.data(), verificationHash.size());
}

8
libraries/networking/src/NLPacket.h
View file

@ -18,6 +18,8 @@
#include "udt/Packet.h"
class HMACAuth;
class NLPacket : public udt::Packet {
Q_OBJECT
public:
@ -69,7 +71,7 @@ public:
static LocalID sourceIDInHeader(const udt::Packet& packet);
static QByteArray verificationHashInHeader(const udt::Packet& packet);
static QByteArray hashForPacketAndSecret(const udt::Packet& packet, const QUuid& connectionSecret);
static QByteArray hashForPacketAndHMAC(const udt::Packet& packet, HMACAuth& hash);
PacketType getType() const { return _type; }
void setType(PacketType type);
@ -78,9 +80,9 @@ public:
void setVersion(PacketVersion version);
LocalID getSourceID() const { return _sourceID; }
void writeSourceID(LocalID sourceID) const;
void writeVerificationHashGivenSecret(const QUuid& connectionSecret) const;
void writeVerificationHash(HMACAuth& hmacAuth) const;
protected:

16
libraries/networking/src/Node.cpp
View file

@ -86,7 +86,7 @@ NodeType_t NodeType::fromString(QString type) {
Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket,
const HifiSockAddr& localSocket, QObject* parent) :
const HifiSockAddr& localSocket, QObject* parent) :
NetworkPeer(uuid, publicSocket, localSocket, parent),
_type(type),
_pingMs(-1), // "Uninitialized"
@ -108,6 +108,7 @@ void Node::setType(char type) {
_symmetricSocket.setObjectName(typeString);
}
void Node::updateClockSkewUsec(qint64 clockSkewSample) {
_clockSkewMovingPercentile.updatePercentile(clockSkewSample);
_clockSkewUsec = (quint64)_clockSkewMovingPercentile.getValueAtPercentile();
@ -194,3 +195,16 @@ QDebug operator<<(QDebug debug, const Node& node) {
debug.nospace() << node.getPublicSocket() << "/" << node.getLocalSocket();
return debug.nospace();
}
void Node::setConnectionSecret(const QUuid& connectionSecret) {
if (_connectionSecret == connectionSecret) {
return;
}
if (!_authenticateHash) {
_authenticateHash.reset(new HMACAuth());
}
_connectionSecret = connectionSecret;
_authenticateHash->setKey(_connectionSecret);
}

5
libraries/networking/src/Node.h
View file

@ -33,6 +33,7 @@
#include "SimpleMovingAverage.h"
#include "MovingPercentile.h"
#include "NodePermissions.h"
#include "HMACAuth.h"
class Node : public NetworkPeer {
Q_OBJECT
@ -55,7 +56,8 @@ public:
void setIsUpstream(bool isUpstream) { _isUpstream = isUpstream; }
const QUuid& getConnectionSecret() const { return _connectionSecret; }
void setConnectionSecret(const QUuid& connectionSecret) { _connectionSecret = connectionSecret; }
void setConnectionSecret(const QUuid& connectionSecret);
HMACAuth* getAuthenticateHash() const { return _authenticateHash.get(); }
NodeData* getLinkedData() const { return _linkedData.get(); }
void setLinkedData(std::unique_ptr<NodeData> linkedData) { _linkedData = std::move(linkedData); }
@ -97,6 +99,7 @@ private:
NodeType_t _type;
QUuid _connectionSecret;
std::unique_ptr<HMACAuth> _authenticateHash { nullptr };
std::unique_ptr<NodeData> _linkedData;
bool _isReplicated { false };
int _pingMs;

2
libraries/networking/src/udt/PacketHeaders.cpp
View file

@ -92,7 +92,7 @@ PacketVersion versionForPacketType(PacketType packetType) {
case PacketType::AvatarQuery:
return static_cast<PacketVersion>(AvatarQueryVersion::ConicalFrustums);
default:
return 20;
return 21;
}
}

3
libraries/test-utils/CMakeLists.txt Normal file
View file

@ -0,0 +1,3 @@
set(TARGET_NAME test-utils)
setup_hifi_library(Network Gui)

21
libraries/test-utils/src/test-utils/FileDownloader.cpp Normal file
View file

@ -0,0 +1,21 @@
#include "FileDownloader.h"
#include <QtCore/QCoreApplication>
#include <QtNetwork/QNetworkReply>
FileDownloader::FileDownloader(QUrl url, const Handler& handler, QObject* parent) : QObject(parent), _handler(handler) {
connect(&_accessManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(fileDownloaded(QNetworkReply*)));
_accessManager.get(QNetworkRequest(url));
}
void FileDownloader::waitForDownload() {
while (!_complete) {
QCoreApplication::processEvents();
}
}
void FileDownloader::fileDownloaded(QNetworkReply* pReply) {
_handler(pReply->readAll());
pReply->deleteLater();
_complete = true;
}

23
libraries/test-utils/src/test-utils/FileDownloader.h Normal file
View file

@ -0,0 +1,23 @@
#pragma once
#include <QtCore/QObject>
#include <QtNetwork/QNetworkAccessManager>
class FileDownloader : public QObject {
Q_OBJECT
public:
using Handler = std::function<void(const QByteArray& data)>;
FileDownloader(QUrl url, const Handler& handler, QObject* parent = 0);
void waitForDownload();
private slots:
void fileDownloaded(QNetworkReply* pReply);
private:
QNetworkAccessManager _accessManager;
Handler _handler;
bool _complete { false };
};

305
scripts/system/+android/radar.js
View file

@ -21,7 +21,8 @@ function printd(str) {
}
var radar = false;
var radarHeight = 10; // camera position meters above the avatar
var RADAR_HEIGHT_INIT_DELTA = 10;
var radarHeight = MyAvatar.position.y + RADAR_HEIGHT_INIT_DELTA; // camera position (absolute y)
var tablet;
var RADAR_CAMERA_OFFSET = -1; // 1 meter below the avatar
@ -45,12 +46,12 @@ var uniqueColor;
function moveTo(position) {
if (radar) {
MyAvatar.position = position;
Camera.position = Vec3.sum(MyAvatar.position, {
x : 0,
MyAvatar.goToLocation(position, false);
Camera.position = {
x : position.x,
y : radarHeight,
z : 0
});
z : position.z
};
}
}
@ -89,46 +90,6 @@ function keyPressEvent(event) {
}
}
function actionOnObjectFromEvent(event) {
var rayIntersection = findRayIntersection(Camera.computePickRay(event.x,
event.y));
if (rayIntersection && rayIntersection.intersects
&& rayIntersection.overlayID) {
printd("found overlayID touched " + rayIntersection.overlayID);
if (entitiesByOverlayID[rayIntersection.overlayID]) {
var entity = Entities.getEntityProperties(
entitiesByOverlayID[rayIntersection.overlayID],
[ "sourceUrl" ]);
App.openUrl(entity.sourceUrl);
return true;
}
}
if (rayIntersection && rayIntersection.intersects
&& rayIntersection.entityID && rayIntersection.properties) {
printd("found " + rayIntersection.entityID + " of type "
+ rayIntersection.properties.type);
if (rayIntersection.properties.type == "Web") {
printd("found web element to "
+ rayIntersection.properties.sourceUrl);
App.openUrl(rayIntersection.properties.sourceUrl);
return true;
}
}
return false;
}
function mousePress(event) {
mousePressOrTouchEnd(event);
}
function mousePressOrTouchEnd(event) {
if (radar) {
if (actionOnObjectFromEvent(event)) {
return;
}
}
}
function toggleRadarMode() {
if (radar) {
endRadar();
@ -229,9 +190,6 @@ function touchEnd(event) {
if (analyzeDoubleTap(event))
return; // double tap detected, finish
if (radar) {
mousePressOrTouchEnd(event);
}
}
/**
@ -386,12 +344,13 @@ function pinchUpdate(event) {
radarHeight -= pinchIncrement;
}
}
var deltaHeight = avatarY + radarHeight - Camera.position.y;
Camera.position = Vec3.sum(Camera.position, {
x : 0,
y : deltaHeight,
z : 0
});
Camera.position = {
x : Camera.position.x,
y : radarHeight,
z : Camera.position.z
};
if (!draggingCamera) {
startedDraggingCamera = true;
draggingCamera = true;
@ -401,7 +360,8 @@ function pinchUpdate(event) {
}
function isInsideSquare(coords0, coords1, halfside) {
return Math.abs(coords0.x - coords1.x) <= halfside
return coords0 != undefined && coords1 != undefined &&
Math.abs(coords0.x - coords1.x) <= halfside
&& Math.abs(coords0.y - coords1.y) <= halfside;
}
@ -412,7 +372,7 @@ function dragScrollUpdate(event) {
// drag management
var pickRay = Camera.computePickRay(event.x, event.y);
var dragAt = Vec3.sum(pickRay.origin, Vec3.multiply(pickRay.direction,
radarHeight));
radarHeight - MyAvatar.position.y));
if (lastDragAt === undefined || lastDragAt === null) {
lastDragAt = dragAt;
@ -654,6 +614,7 @@ function Teleporter() {
return;
}
Camera.position = Vec3.sum(Camera.position, {
x : xDelta,
y : 0,
@ -722,7 +683,7 @@ function Teleporter() {
return {
dragTeleportBegin : function(event) {
printd("[newTeleport] TELEPORT began");
var overlayDimensions = entityIconModelDimensions();
var overlayDimensions = teleportIconModelDimensions(MyAvatar.position.y);
// var destination = computeDestination(event, MyAvatar.position,
// Camera.position, radarHeight);
// Dimension teleport and cancel overlays (not show them yet)
@ -843,7 +804,7 @@ var avatarIconDimensionsVal = {
};
function avatarIconPlaneDimensions() {
// given the current height, give a size
var xy = -0.003531 * radarHeight + 0.1;
var xy = -0.003531 * (radarHeight - MyAvatar.position.y) + 0.1;
avatarIconDimensionsVal.x = Math.abs(xy);
avatarIconDimensionsVal.y = Math.abs(xy);
// reuse object
@ -1121,172 +1082,20 @@ function renderAllOthersAvatarIcons() {
}
}
function entityAdded(entityID) {
printd("Entity added " + entityID);
var props = Entities.getEntityProperties(entityID, [ "type" ]);
printd("Entity added " + entityID + " PROPS " + JSON.stringify(props));
if (props && props.type == "Web") {
printd("Entity Web added " + entityID);
saveEntityData(entityID, true);
}
}
function entityRemoved(entityID) {
printd("Entity removed " + entityID);
var props = Entities.getEntityProperties(entityID, [ "type" ]);
if (props && props.type == "Web") {
print("Entity Web removed " + entityID);
removeEntityData(entityID);
}
}
/*******************************************************************************
* Entities (to remark) cache structure for showing entities markers
******************************************************************************/
var entitiesData = {}; // by entityID
var entitiesByOverlayID = {}; // by overlayID
var entitiesIcons = []; // a parallel list of icons (overlays) to easily run
// through
var ICON_ENTITY_WEB_MODEL_URL = Script.resolvePath("../assets/images/web.svg");
var ICON_ENTITY_IMG_MODEL_URL = Script
.resolvePath("../assets/models/teleport-cancel.fbx"); // FIXME - use
// correct
// model&texture
var ICON_ENTITY_DEFAULT_DIMENSIONS = {
x : 0.10,
y : 0.00001,
z : 0.10
};
var entityIconModelDimensionsVal = {
x : 0,
y : 0.00001,
z : 0
};
function entityIconModelDimensions() {
// given the current height, give a size
var xz = -0.002831 * radarHeight + 0.1;
entityIconModelDimensionsVal.x = xz;
entityIconModelDimensionsVal.z = xz;
function teleportIconModelDimensions(y) {
var teleportModelDimensions = ICON_ENTITY_DEFAULT_DIMENSIONS;
var xz = -0.002831 * (radarHeight - y) + 0.1;
teleportModelDimensions.x = xz;
teleportModelDimensions.z = xz;
// reuse object
return entityIconModelDimensionsVal;
}
/*
* entityIconPlaneDimensions: similar to entityIconModelDimensions but using xy
* plane
*/
function entityIconPlaneDimensions() {
var dim = entityIconModelDimensions();
var z = dim.z;
dim.z = dim.y;
dim.y = z;
return dim;
}
function currentOverlayForEntity(QUuid) {
if (entitiesData[QUuid] != undefined) {
return entitiesData[QUuid].icon;
} else {
return null;
}
}
function saveEntityData(QUuid, planar) {
if (QUuid == null)
return;
var entity = Entities.getEntityProperties(QUuid, [ "position" ]);
printd("entity added save entity " + QUuid);
if (entitiesData[QUuid] != undefined) {
entitiesData[QUuid].position = entity.position;
} else {
var entityIcon = Overlays.addOverlay("image3d", {
subImage : {
x : 0,
y : 0,
width : 150,
height : 150
},
url : ICON_ENTITY_WEB_MODEL_URL,
dimensions : ICON_ENTITY_DEFAULT_DIMENSIONS,
visible : false,
ignoreRayIntersection : false,
orientation : Quat.fromPitchYawRollDegrees(-90, 0, 0)
});
entitiesIcons.push(entityIcon);
entitiesData[QUuid] = {
position : entity.position,
icon : entityIcon
};
entitiesByOverlayID[entityIcon] = QUuid;
}
}
function removeEntityData(QUuid) {
if (QUuid == null)
return;
var itsOverlay = currentOverlayForEntity(QUuid);
if (itsOverlay != null) {
Overlays.deleteOverlay(itsOverlay);
delete entitiesByOverlayID[itsOverlay];
}
var idx = entitiesIcons.indexOf(itsOverlay);
entitiesIcons.splice(idx, 1);
delete entitiesData[QUuid];
}
/*******************************************************************************
* Entities to remark Icon/Markers rendering
******************************************************************************/
function hideAllEntitiesIcons() {
var len = entitiesIcons.length;
for (var i = 0; i < len; i++) {
Overlays.editOverlay(entitiesIcons[i], {
visible : false
});
}
}
function renderAllEntitiesIcons() {
var entityPos;
var entityProps;
var iconDimensions = entityIconModelDimensions();
var planeDimensions = entityIconPlaneDimensions(); // plane overlays uses
// xy instead of xz
for ( var QUuid in entitiesData) {
if (entitiesData.hasOwnProperty(QUuid)) {
entityProps = Entities.getEntityProperties(QUuid, [ "position",
"visible" ]);
if (entityProps != null) {
entityPos = entityProps.position;
if (entitiesData[QUuid].icon != undefined && entityPos) {
var iconPos = findLineToHeightIntersectionCoords(
entityPos.x,
entityPos.y
+ RADAR_ICONS_APPARENT_DISTANCE_TO_AVATAR_BASE,
entityPos.z, Camera.position.x, Camera.position.y,
Camera.position.z, Camera.position.y
- RADAR_CAMERA_DISTANCE_TO_ICONS);
if (!iconPos) {
printd("entity icon pos bad for " + QUuid);
continue;
}
var dimensions = entitiesData[QUuid].planar ? planeDimensions
: iconDimensions;
Overlays.editOverlay(entitiesData[QUuid].icon, {
visible : entityProps.visible,
dimensions : dimensions,
position : iconPos
});
}
}
}
}
return teleportModelDimensions;
}
/*******************************************************************************
@ -1298,11 +1107,8 @@ function startRadar() {
saveAllOthersAvatarsData();
Camera.mode = "independent";
Camera.position = Vec3.sum(MyAvatar.position, {
x : 0,
y : radarHeight,
z : 0
});
initCameraOverMyAvatar();
Camera.orientation = Quat.fromPitchYawRollDegrees(-90, 0, 0);
radar = true;
@ -1319,7 +1125,6 @@ function endRadar() {
Controller.setVPadEnabled(true);
disconnectRadarModeEvents();
hideAllEntitiesIcons();
hideAllAvatarIcons();
}
@ -1353,12 +1158,10 @@ function updateRadar() {
// Update avatar icons
if (startedDraggingCamera) {
hideAllAvatarIcons();
hideAllEntitiesIcons();
startedDraggingCamera = false;
} else if (!draggingCamera) {
renderMyAvatarIcon();
renderAllOthersAvatarIcons();
renderAllEntitiesIcons();
}
}
@ -1366,48 +1169,41 @@ function valueIfDefined(value) {
return value !== undefined ? value : "";
}
function entitiesAnalysis() {
var ids = Entities.findEntitiesInFrustum(Camera.frustum);
var entities = [];
for (var i = 0; i < ids.length; i++) {
var id = ids[i];
var properties = Entities.getEntityProperties(id);
entities.push({
id : id,
name : properties.name,
type : properties.type,
url : properties.type == "Model" ? properties.modelURL : "",
sourceUrl : properties.sourceUrl,
locked : properties.locked,
visible : properties.visible,
drawCalls : valueIfDefined(properties.renderInfo.drawCalls),
hasScript : properties.script !== ""
});
}
}
function connectRadarModeEvents() {
Script.update.connect(updateRadar); // 60Hz loop
Controller.keyPressEvent.connect(keyPressEvent);
Controller.mousePressEvent.connect(mousePress); // single click/touch
Controller.touchUpdateEvent.connect(touchUpdate);
Window.domainChanged.connect(domainChanged);
MyAvatar.positionGoneTo.connect(positionGoneTo);
}
function positionGoneTo() {
Camera.position = Vec3.sum(MyAvatar.position, {
x : 0,
function initCameraOverMyAvatar() {
radarHeight = MyAvatar.position.y + RADAR_HEIGHT_INIT_DELTA;
Camera.position = {
x : MyAvatar.position.x,
y : radarHeight,
z : 0
});
z : MyAvatar.position.z
};
}
function domainChanged() {
initCameraOverMyAvatar();
}
function positionGoneTo() {
Camera.position = {
x : MyAvatar.position.x,
y : radarHeight,
z : MyAvatar.position.z
};
}
function disconnectRadarModeEvents() {
Script.update.disconnect(updateRadar);
Controller.keyPressEvent.disconnect(keyPressEvent);
Controller.mousePressEvent.disconnect(mousePress);
Controller.touchUpdateEvent.disconnect(touchUpdate);
MyAvatar.positionGoneTo.disconnect(positionGoneTo);
Window.domainChanged.disconnect(domainChanged);
}
function init() {
@ -1418,7 +1214,4 @@ function init() {
AvatarList.avatarAddedEvent.connect(avatarAdded);
AvatarList.avatarRemovedEvent.connect(avatarRemoved);
Entities.addingEntity.connect(entityAdded);
Entities.deletingEntity.connect(entityRemoved);
}

8
tests-manual/CMakeLists.txt Normal file
View file

@ -0,0 +1,8 @@
# add the manual test directories
file(GLOB TEST_SUBDIRS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/*")
foreach(DIR ${TEST_SUBDIRS})
if((IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${DIR}") AND (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${DIR}/CMakeLists.txt"))
set(TEST_PROJ_NAME ${DIR})
add_subdirectory(${DIR})
endif()
endforeach()

0
tests/controllers/CMakeLists.txt → tests-manual/controllers/CMakeLists.txt
View file

0
tests/controllers/qml/main.qml → tests-manual/controllers/qml/main.qml
View file

0
tests/controllers/src/main.cpp → tests-manual/controllers/src/main.cpp
View file

0
tests/entities/CMakeLists.txt → tests-manual/entities/CMakeLists.txt
View file

0
tests/entities/packet.bin → tests-manual/entities/packet.bin
View file

0
tests/entities/src/main.cpp → tests-manual/entities/src/main.cpp
View file

0
tests/gl/CMakeLists.txt → tests-manual/gl/CMakeLists.txt
View file

0
tests/gl/src/main.cpp → tests-manual/gl/src/main.cpp
View file

16
tests-manual/gpu-textures/CMakeLists.txt Normal file
View file

@ -0,0 +1,16 @@
set(TARGET_NAME gpu-textures-tests)
AUTOSCRIBE_SHADER_LIB(gpu graphics render-utils)
# This is not a testcase -- just set it up as a regular hifi project
setup_hifi_project(Quick Gui Script)
setup_memory_debugger()
set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "Tests/manual-tests/")
link_hifi_libraries(
shared task networking gl
ktx gpu octree
${PLATFORM_GL_BACKEND}
)
set(EXTRA_DEPLOY_OPTIONS "--qmldir \"${PROJECT_SOURCE_DIR}/qml\"")
package_libraries_for_deployment()
target_nsight()

52
tests-manual/gpu-textures/qml/textureStats.qml Normal file
View file

@ -0,0 +1,52 @@
import QtQuick 2.5
import QtQuick.Controls 2.3
Item {
width: 400
height: 600
Column {
spacing: 10
anchors.top: parent.top
anchors.left: parent.left
anchors.margins: 10
Text { text: qsTr("Total") }
Text { text: Stats.total + " MB" }
Text { text: qsTr("Allocated") }
Text { text: Stats.allocated }
Text { text: qsTr("Populated") }
Text { text: Stats.populated }
Text { text: qsTr("Pending") }
Text { text: Stats.pending }
Text { text: qsTr("Current Index") }
Text { text: Stats.index }
Text { text: qsTr("Current Source") }
Text { text: Stats.source }
Text { text: qsTr("Current Rez") }
Text { text: Stats.rez.width + " x " + Stats.rez.height }
}
Row {
id: row1
spacing: 10
anchors.bottom: row2.top
anchors.left: parent.left
anchors.margins: 10
Button { text: "1024"; onClicked: Stats.maxTextureMemory(1024); }
Button { text: "256"; onClicked: Stats.maxTextureMemory(256); }
}
Row {
id: row2
spacing: 10
anchors.bottom: parent.bottom
anchors.left: parent.left
anchors.margins: 10
Button { text: "Change Textures"; onClicked: Stats.changeTextures(); }
Button { text: "Next"; onClicked: Stats.nextTexture(); }
Button { text: "Previous"; onClicked: Stats.prevTexture(); }
}
}

26
tests-manual/gpu-textures/src/TestHelpers.cpp Normal file
View file

@ -0,0 +1,26 @@
//
// Created by Bradley Austin Davis on 2016/05/16
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "TestHelpers.h"
#include <QtCore/QFileInfo>
gpu::ShaderPointer makeShader(const std::string & vertexShaderSrc, const std::string & fragmentShaderSrc, const gpu::Shader::BindingSet & bindings) {
auto vs = gpu::Shader::createVertex(vertexShaderSrc);
auto fs = gpu::Shader::createPixel(fragmentShaderSrc);
auto shader = gpu::Shader::createProgram(vs, fs);
if (!gpu::Shader::makeProgram(*shader, bindings)) {
printf("Could not compile shader\n");
exit(-1);
}
return shader;
}
QString projectRootDir() {
static QString projectRootPath = QFileInfo(QFileInfo(__FILE__).absolutePath() + "/..").absoluteFilePath();
return projectRootPath;
}

40
tests-manual/gpu-textures/src/TestHelpers.h Normal file
View file

@ -0,0 +1,40 @@
//
// Created by Bradley Austin Davis on 2016/05/16
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include <vector>
#include <GLMHelpers.h>
#include <Transform.h>
#include <NumericalConstants.h>
#include <gpu/Resource.h>
#include <gpu/Forward.h>
#include <gpu/Shader.h>
#include <gpu/Stream.h>
struct RenderArgs {
gpu::ContextPointer _context;
ivec4 _viewport;
gpu::Batch* _batch;
};
class GpuTestBase : public QObject {
public:
virtual ~GpuTestBase() {}
virtual bool isReady() const { return true; }
virtual size_t getTestCount() const { return 1; }
virtual void renderTest(size_t test, const RenderArgs& args) = 0;
virtual QObject * statsObject() { return nullptr; }
virtual QUrl statUrl() { return QUrl(); }
};
uint32_t toCompactColor(const glm::vec4& color);
gpu::ShaderPointer makeShader(const std::string & vertexShaderSrc, const std::string & fragmentShaderSrc, const gpu::Shader::BindingSet & bindings);
QString projectRootDir();

166
tests-manual/gpu-textures/src/TestTextures.cpp Normal file
View file

@ -0,0 +1,166 @@
//
// Created by Bradley Austin Davis on 2016/05/16
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "TestTextures.h"
#include <random>
#include <algorithm>
#include <QtCore/QDir>
#include <QtQuick/QQuickView>
#include <QtQml/QQmlContext>
#include <gpu/Batch.h>
#include <gpu/Context.h>
#include "TestHelpers.h"
std::string vertexShaderSource = R"SHADER(
#line 14
layout(location = 0) out vec2 outTexCoord0;
const vec4 VERTICES[] = vec4[](
vec4(-1.0, -1.0, 0.0, 1.0),
vec4( 1.0, -1.0, 0.0, 1.0),
vec4(-1.0, 1.0, 0.0, 1.0),
vec4( 1.0, 1.0, 0.0, 1.0)
);
void main() {
outTexCoord0 = VERTICES[gl_VertexID].xy;
outTexCoord0 += 1.0;
outTexCoord0 /= 2.0;
gl_Position = VERTICES[gl_VertexID];
}
)SHADER";
std::string fragmentShaderSource = R"SHADER(
#line 28
uniform sampler2D tex;
layout(location = 0) in vec2 inTexCoord0;
layout(location = 0) out vec4 outFragColor;
void main() {
outFragColor = texture(tex, inTexCoord0);
outFragColor.a = 1.0;
//outFragColor.rb = inTexCoord0;
}
)SHADER";
#define STAT_UPDATE(name, src) \
{ \
auto val = src; \
if (_##name != val) { \
_##name = val; \
emit name##Changed(); \
} \
}
void TextureTestStats::update(int curIndex, const gpu::TexturePointer& texture) {
STAT_UPDATE(total, (int)BYTES_TO_MB(gpu::Context::getTextureGPUMemSize()));
STAT_UPDATE(allocated, (int)gpu::Context::getTextureResourceGPUMemSize());
STAT_UPDATE(pending, (int)gpu::Context::getTexturePendingGPUTransferMemSize());
STAT_UPDATE(populated, (int)gpu::Context::getTextureResourcePopulatedGPUMemSize());
STAT_UPDATE(source, texture->source().c_str());
STAT_UPDATE(index, curIndex);
auto dims = texture->getDimensions();
STAT_UPDATE(rez, QSize(dims.x, dims.y));
}
TexturesTest::TexturesTest() {
connect(&stats, &TextureTestStats::changeTextures, this, &TexturesTest::onChangeTextures);
connect(&stats, &TextureTestStats::nextTexture, this, &TexturesTest::onNextTexture);
connect(&stats, &TextureTestStats::prevTexture, this, &TexturesTest::onPrevTexture);
connect(&stats, &TextureTestStats::maxTextureMemory, this, &TexturesTest::onMaxTextureMemory);
{
auto VS = gpu::Shader::createVertex(vertexShaderSource);
auto PS = gpu::Shader::createPixel(fragmentShaderSource);
auto program = gpu::Shader::createProgram(VS, PS);
gpu::Shader::BindingSet slotBindings;
gpu::Shader::makeProgram(*program, slotBindings);
// If the pipeline did not exist, make it
auto state = std::make_shared<gpu::State>();
state->setCullMode(gpu::State::CULL_NONE);
state->setDepthTest({});
state->setBlendFunction({ false });
pipeline = gpu::Pipeline::create(program, state);
}
onChangeTextures();
}
void TexturesTest::renderTest(size_t testId, const RenderArgs& args) {
stats.update((int)index, textures[index]);
gpu::Batch& batch = *(args._batch);
batch.setPipeline(pipeline);
batch.setInputFormat(vertexFormat);
for (const auto& texture : textures) {
batch.setResourceTexture(0, texture);
batch.draw(gpu::TRIANGLE_STRIP, 4, 0);
}
batch.setResourceTexture(0, textures[index]);
batch.draw(gpu::TRIANGLE_STRIP, 4, 0);
}
#define LOAD_TEXTURE_COUNT 64
void TexturesTest::onChangeTextures() {
static const QDir TEST_DIR("D:/ktx_texture_test");
static std::vector<std::string> ALL_TEXTURE_FILES;
if (ALL_TEXTURE_FILES.empty()) {
auto entryList = TEST_DIR.entryList({ "*.ktx" }, QDir::Filter::Files);
ALL_TEXTURE_FILES.reserve(entryList.size());
for (auto entry : entryList) {
auto textureFile = TEST_DIR.absoluteFilePath(entry).toStdString();
ALL_TEXTURE_FILES.push_back(textureFile);
}
}
oldTextures.clear();
oldTextures.swap(textures);
#if 0
static const std::string bad = "D:/ktx_texture_test/b4beed38675dbc7a827ecd576399c1f4.ktx";
auto texture = gpu::Texture::unserialize(bad);
auto texelFormat = texture->getTexelFormat();
qDebug() << texture->getTexelFormat().getSemantic();
qDebug() << texture->getTexelFormat().getScalarCount();
textures.push_back(texture);
#else
std::shuffle(ALL_TEXTURE_FILES.begin(), ALL_TEXTURE_FILES.end(), std::default_random_engine());
size_t newTextureCount = std::min<size_t>(ALL_TEXTURE_FILES.size(), LOAD_TEXTURE_COUNT);
for (size_t i = 0; i < newTextureCount; ++i) {
const auto& textureFile = ALL_TEXTURE_FILES[i];
auto texture = gpu::Texture::unserialize(textureFile);
qDebug() << textureFile.c_str();
qDebug() << texture->getTexelFormat().getSemantic();
qDebug() << texture->getTexelFormat().getScalarCount();
textures.push_back(texture);
}
#endif
index = 0;
qDebug() << "Done";
}
void TexturesTest::onNextTexture() {
index += textures.size() + 1;
index %= textures.size();
}
void TexturesTest::onPrevTexture() {
index += textures.size() - 1;
index %= textures.size();
}
void TexturesTest::onMaxTextureMemory(int maxTextureMemory) {
gpu::Texture::setAllowedGPUMemoryUsage(MB_TO_BYTES(maxTextureMemory));
}

74
tests-manual/gpu-textures/src/TestTextures.h Normal file
View file

@ -0,0 +1,74 @@
//
// Created by Bradley Austin Davis on 2016/05/16
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include "TestHelpers.h"
#define STATS_PROPERTY(type, name, initialValue) \
Q_PROPERTY(type name READ name NOTIFY name##Changed) \
public: \
type name() { return _##name; }; \
private: \
type _##name{ initialValue };
class TextureTestStats : public QObject {
Q_OBJECT;
STATS_PROPERTY(int, pending, 0)
STATS_PROPERTY(int, total, 0)
STATS_PROPERTY(int, populated, 0)
STATS_PROPERTY(int, allocated, 0)
STATS_PROPERTY(int, index, 0)
STATS_PROPERTY(QString, source, QString())
STATS_PROPERTY(QSize, rez, QSize(0, 0))
public:
void update(int index, const gpu::TexturePointer& texture);
signals:
void pendingChanged();
void totalChanged();
void populatedChanged();
void allocatedChanged();
void changeTextures();
void rezChanged();
void indexChanged();
void sourceChanged();
void maxTextureMemory(int);
void nextTexture();
void prevTexture();
};
class TexturesTest : public GpuTestBase {
Q_OBJECT
gpu::Stream::FormatPointer vertexFormat { std::make_shared<gpu::Stream::Format>() };
std::vector<gpu::TexturePointer> textures;
std::vector<gpu::TexturePointer> oldTextures;
gpu::PipelinePointer pipeline;
TextureTestStats stats;
size_t index{ 0 };
public:
TexturesTest();
QObject* statsObject() override { return &stats; }
QUrl statUrl() override { return QUrl::fromLocalFile(projectRootDir() + "/qml/textureStats.qml"); }
void renderTest(size_t testId, const RenderArgs& args) override;
protected slots:
void onChangeTextures();
void onMaxTextureMemory(int newValue);
void onNextTexture();
void onPrevTexture();
};

117
tests-manual/gpu-textures/src/TestWindow.cpp Normal file
View file

@ -0,0 +1,117 @@
//
// Created by Bradley Austin Davis on 2016/05/16
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "TestWindow.h"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <QtCore/QTimer>
#include <QtGui/QResizeEvent>
#include <gl/GLHelpers.h>
#include <gpu/gl/GLBackend.h>
TestWindow::TestWindow() {
auto timer = new QTimer(this);
timer->setTimerType(Qt::PreciseTimer);
timer->setInterval(5);
connect(timer, &QTimer::timeout, [&] { draw(); });
timer->start();
connect(qApp, &QCoreApplication::aboutToQuit, [this, timer] {
timer->stop();
_aboutToQuit = true;
});
setSurfaceType(QSurface::OpenGLSurface);
QSurfaceFormat format = getDefaultOpenGLSurfaceFormat();
format.setOption(QSurfaceFormat::DebugContext);
setFormat(format);
_glContext.setFormat(format);
_glContext.create();
_glContext.makeCurrent(this);
show();
}
void TestWindow::initGl() {
_glContext.makeCurrent(this);
gl::initModuleGl();
gpu::Context::init<gpu::gl::GLBackend>();
_renderArgs->_context = std::make_shared<gpu::Context>();
_glContext.makeCurrent(this);
resize(QSize(800, 600));
}
void TestWindow::resizeWindow(const QSize& size) {
_size = size;
_renderArgs->_viewport = ivec4(0, 0, _size.width(), _size.height());
}
void TestWindow::beginFrame() {
_renderArgs->_context->recycle();
_renderArgs->_context->beginFrame();
gpu::doInBatch("TestWindow::beginFrame", _renderArgs->_context, [&](gpu::Batch& batch) {
batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, { 0.0f, 0.1f, 0.2f, 1.0f });
batch.clearDepthFramebuffer(1e4);
batch.setViewportTransform({ 0, 0, _size.width() * devicePixelRatio(), _size.height() * devicePixelRatio() });
});
gpu::doInBatch("TestWindow::beginFrame", _renderArgs->_context, [&](gpu::Batch& batch) {
batch.setViewportTransform(_renderArgs->_viewport);
batch.setStateScissorRect(_renderArgs->_viewport);
batch.setProjectionTransform(_projectionMatrix);
});
}
void TestWindow::endFrame() {
gpu::doInBatch("TestWindow::endFrame::finish", _renderArgs->_context, [&](gpu::Batch& batch) {
batch.resetStages();
});
auto framePointer = _renderArgs->_context->endFrame();
_renderArgs->_context->consumeFrameUpdates(framePointer);
_renderArgs->_context->executeFrame(framePointer);
_glContext.swapBuffers(this);
}
void TestWindow::draw() {
if (_aboutToQuit) {
return;
}
// Attempting to draw before we're visible and have a valid size will
// produce GL errors.
if (!isVisible() || _size.width() <= 0 || _size.height() <= 0) {
return;
}
if (!_glContext.makeCurrent(this)) {
return;
}
static std::once_flag once;
std::call_once(once, [&] { initGl(); });
beginFrame();
renderFrame();
endFrame();
}
void TestWindow::resizeEvent(QResizeEvent* ev) {
resizeWindow(ev->size());
float fov_degrees = 60.0f;
float aspect_ratio = (float)_size.width() / _size.height();
float near_clip = 0.1f;
float far_clip = 1000.0f;
_projectionMatrix = glm::perspective(glm::radians(fov_degrees), aspect_ratio, near_clip, far_clip);
}

41
tests-manual/gpu-textures/src/TestWindow.h Normal file
View file

@ -0,0 +1,41 @@
//
// Created by Bradley Austin Davis on 2016/05/16
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#pragma once
#include <QtGui/QWindow>
#include <QtCore/QTime>
#include <GLMHelpers.h>
#include <gl/QOpenGLContextWrapper.h>
#include <gpu/Forward.h>
#include "TestHelpers.h"
#define DEFERRED_LIGHTING
class TestWindow : public QWindow {
protected:
QOpenGLContextWrapper _glContext;
QSize _size;
glm::mat4 _projectionMatrix;
bool _aboutToQuit { false };
std::shared_ptr<RenderArgs> _renderArgs{ std::make_shared<RenderArgs>() };
TestWindow();
virtual void initGl();
virtual void renderFrame() = 0;
private:
void resizeWindow(const QSize& size);
void beginFrame();
void endFrame();
void draw();
void resizeEvent(QResizeEvent* ev) override;
};

170
tests-manual/gpu-textures/src/main.cpp Normal file
View file

@ -0,0 +1,170 @@
//
// main.cpp
// tests/gpu-test/src
//
// Copyright 2015 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 <unordered_map>
#include <memory>
#include <cstdio>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <QtCore/QTime>
#include <QtCore/QTimer>
#include <QtCore/QDir>
#include <QtCore/QElapsedTimer>
#include <QtCore/QFile>
#include <QtCore/QLoggingCategory>
#include <QtGui/QDesktopServices>
#include <QtGui/QResizeEvent>
#include <QtGui/QWindow>
#include <QtGui/QGuiApplication>
#include <QtGui/QImage>
#include <QtGui/QScreen>
#include <QtWidgets/QApplication>
#include <gl/Config.h>
#include <QtQuick/QQuickWindow>
#include <QtQuick/QQuickView>
#include <QtQml/QQmlContext>
#include <gpu/Context.h>
#include <gpu/Batch.h>
#include <gpu/Stream.h>
#include <gpu/gl/GLBackend.h>
#include <gl/QOpenGLContextWrapper.h>
#include <gl/GLHelpers.h>
#include <GLMHelpers.h>
#include <PathUtils.h>
#include <NumericalConstants.h>
#include <PerfStat.h>
#include <PathUtils.h>
#include <SharedUtil.h>
#include <ViewFrustum.h>
#include <gpu/Pipeline.h>
#include <gpu/Context.h>
#include "TestWindow.h"
#include "TestTextures.h"
using TestBuilder = std::function<GpuTestBase*()>;
using TestBuilders = std::list<TestBuilder>;
#define INTERACTIVE
class MyTestWindow : public TestWindow {
using Parent = TestWindow;
TestBuilders _testBuilders;
GpuTestBase* _currentTest{ nullptr };
size_t _currentTestId{ 0 };
size_t _currentMaxTests{ 0 };
glm::mat4 _camera;
QTime _time;
void initGl() override {
Parent::initGl();
_time.start();
updateCamera();
_testBuilders = TestBuilders({
[] { return new TexturesTest(); },
});
}
void updateCamera() {
float t = _time.elapsed() * 1e-3f;
glm::vec3 unitscale{ 1.0f };
glm::vec3 up{ 0.0f, 1.0f, 0.0f };
float distance = 3.0f;
glm::vec3 camera_position{ distance * sinf(t), 0.5f, distance * cosf(t) };
static const vec3 camera_focus(0);
static const vec3 camera_up(0, 1, 0);
_camera = glm::inverse(glm::lookAt(camera_position, camera_focus, up));
ViewFrustum frustum;
frustum.setPosition(camera_position);
frustum.setOrientation(glm::quat_cast(_camera));
frustum.setProjection(_projectionMatrix);
}
void renderFrame() override {
updateCamera();
while ((!_currentTest || (_currentTestId >= _currentMaxTests)) && !_testBuilders.empty()) {
if (_currentTest) {
delete _currentTest;
_currentTest = nullptr;
}
_currentTest = _testBuilders.front()();
_testBuilders.pop_front();
if (_currentTest) {
auto statsObject = _currentTest->statsObject();
QUrl url = _currentTest->statUrl();
if (statsObject) {
auto screens = qApp->screens();
auto primaryScreen = qApp->primaryScreen();
auto targetScreen = primaryScreen;
for (const auto& screen : screens) {
if (screen == primaryScreen) {
continue;
}
targetScreen = screen;
break;
}
auto destPoint = targetScreen->availableGeometry().topLeft();
QQuickView* view = new QQuickView();
view->rootContext()->setContextProperty("Stats", statsObject);
view->setSource(url);
view->show();
view->setPosition({ destPoint.x() + 100, destPoint.y() + 100 });
}
_currentMaxTests = _currentTest->getTestCount();
_currentTestId = 0;
}
}
if (!_currentTest && _testBuilders.empty()) {
qApp->quit();
return;
}
// Tests might need to wait for resources to download
if (!_currentTest->isReady()) {
return;
}
gpu::doInBatch("main::renderFrame", _renderArgs->_context, [&](gpu::Batch& batch) {
batch.setViewTransform(_camera);
_renderArgs->_batch = &batch;
_currentTest->renderTest(_currentTestId, *_renderArgs);
_renderArgs->_batch = nullptr;
});
}
};
int main(int argc, char** argv) {
setupHifiApplication("GPU Test");
qputenv("HIFI_DEBUG_OPENGL", QByteArray("1"));
QApplication app(argc, argv);
MyTestWindow window;
app.exec();
return 0;
}

0
tests/gpu-test/CMakeLists.txt → tests-manual/gpu/CMakeLists.txt
View file

0
tests/gpu-test/src/TestFbx.cpp → tests-manual/gpu/src/TestFbx.cpp
View file

0
tests/gpu-test/src/TestFbx.h → tests-manual/gpu/src/TestFbx.h
View file

0
tests/gpu-test/src/TestFloorGrid.cpp → tests-manual/gpu/src/TestFloorGrid.cpp
View file

0
tests/gpu-test/src/TestFloorGrid.h → tests-manual/gpu/src/TestFloorGrid.h
View file

0
tests/gpu-test/src/TestFloorTexture.cpp → tests-manual/gpu/src/TestFloorTexture.cpp
View file

0
tests/gpu-test/src/TestFloorTexture.h → tests-manual/gpu/src/TestFloorTexture.h
View file

0
tests/gpu-test/src/TestHelpers.cpp → tests-manual/gpu/src/TestHelpers.cpp
View file

0
tests/gpu-test/src/TestHelpers.h → tests-manual/gpu/src/TestHelpers.h
View file

0
tests/gpu-test/src/TestInstancedShapes.cpp → tests-manual/gpu/src/TestInstancedShapes.cpp
View file

0
tests/gpu-test/src/TestInstancedShapes.h → tests-manual/gpu/src/TestInstancedShapes.h
View file

0
tests/gpu-test/src/TestShapes.cpp → tests-manual/gpu/src/TestShapes.cpp
View file

0
tests/gpu-test/src/TestShapes.h → tests-manual/gpu/src/TestShapes.h
View file

0
tests/gpu-test/src/TestWindow.cpp → tests-manual/gpu/src/TestWindow.cpp
View file

0
tests/gpu-test/src/TestWindow.h → tests-manual/gpu/src/TestWindow.h
View file

0
tests/gpu-test/src/main.cpp → tests-manual/gpu/src/main.cpp
View file

0
tests/qml/CMakeLists.txt → tests-manual/qml/CMakeLists.txt
View file

0
tests/qml/qml/controls/WebEntityView.qml → tests-manual/qml/qml/controls/WebEntityView.qml
View file

0
tests/qml/qml/main.qml → tests-manual/qml/qml/main.qml
View file

0
tests/qml/qml/qml/+android/UI.js → tests-manual/qml/qml/qml/+android/UI.js
View file

0
tests/qml/qml/qml/+ios/UI.js → tests-manual/qml/qml/qml/+ios/UI.js
View file

0
tests/qml/qml/qml/+osx/UI.js → tests-manual/qml/qml/qml/+osx/UI.js
View file

0
tests/qml/qml/qml/ButtonPage.qml → tests-manual/qml/qml/qml/ButtonPage.qml
View file

0
tests/qml/qml/qml/InputPage.qml → tests-manual/qml/qml/qml/InputPage.qml
View file

0
tests/qml/qml/qml/ProgressPage.qml → tests-manual/qml/qml/qml/ProgressPage.qml
View file

0
tests/qml/qml/qml/UI.js → tests-manual/qml/qml/qml/UI.js
View file

0
tests/qml/src/main.cpp → tests-manual/qml/src/main.cpp
View file

0
tests/render-perf/CMakeLists.txt → tests-manual/render-perf/CMakeLists.txt
View file

0
tests/render-perf/src/Camera.hpp → tests-manual/render-perf/src/Camera.hpp
View file

0
tests/render-perf/src/main.cpp → tests-manual/render-perf/src/main.cpp
View file

0
tests/render-texture-load/CMakeLists.txt → tests-manual/render-texture-load/CMakeLists.txt
View file

0
tests/render-texture-load/src/GLIHelpers.cpp → tests-manual/render-texture-load/src/GLIHelpers.cpp
View file

0
tests/render-texture-load/src/GLIHelpers.h → tests-manual/render-texture-load/src/GLIHelpers.h
View file

0
tests/render-texture-load/src/main.cpp → tests-manual/render-texture-load/src/main.cpp
View file

0
tests/render-utils/CMakeLists.txt → tests-manual/render-utils/CMakeLists.txt
View file

0
tests/render-utils/src/main.cpp → tests-manual/render-utils/src/main.cpp
View file

0
tests/shaders/CMakeLists.txt → tests-manual/shaders/CMakeLists.txt
View file

0
tests/shaders/src/main.cpp → tests-manual/shaders/src/main.cpp
View file

0
tests/ui/qml/Palettes.qml → tests-manual/ui/qml/Palettes.qml
View file

0
tests/ui/qml/ScrollingGraph.qml → tests-manual/ui/qml/ScrollingGraph.qml
View file

0
tests/ui/qml/StubMenu.qml → tests-manual/ui/qml/StubMenu.qml
View file

0
tests/ui/qml/Stubs.qml → tests-manual/ui/qml/Stubs.qml
View file

0
tests/ui/qml/TestControllers.qml → tests-manual/ui/qml/TestControllers.qml
View file

0
tests/ui/qml/TestDialog.qml → tests-manual/ui/qml/TestDialog.qml
View file

0
tests/ui/qml/TestMenu.qml → tests-manual/ui/qml/TestMenu.qml
View file

0
tests/ui/qml/TestRoot.qml → tests-manual/ui/qml/TestRoot.qml
View file

0
tests/ui/qml/controlDemo/ButtonPage.qml → tests-manual/ui/qml/controlDemo/ButtonPage.qml
View file

0
tests/ui/qml/controlDemo/InputPage.qml → tests-manual/ui/qml/controlDemo/InputPage.qml
View file

0
tests/ui/qml/controlDemo/ProgressPage.qml → tests-manual/ui/qml/controlDemo/ProgressPage.qml
View file

0
tests/ui/qml/controlDemo/main.qml → tests-manual/ui/qml/controlDemo/main.qml
View file

0
tests/ui/qml/main.qml → tests-manual/ui/qml/main.qml
View file

0
tests/ui/qmlscratch.pro → tests-manual/ui/qmlscratch.pro
View file

0
tests/ui/src/main.cpp → tests-manual/ui/src/main.cpp
View file

4
tests/CMakeLists.txt
View file

@ -27,9 +27,9 @@ set_target_properties("test-extensions" PROPERTIES FOLDER "Tests")
# set (ALL_TEST_TARGETS "${ALL_TEST_TARGETS}" PARENT_SCOPE) # copies this back to parent scope
#
add_custom_target("all-tests"
COMMAND ctest .
DEPENDS "${ALL_TEST_TARGETS}")
set_target_properties("all-tests" PROPERTIES FOLDER "hidden/test-targets")
set_target_properties("all-tests" PROPERTIES
FOLDER "hidden/test-targets"
EXCLUDE_FROM_DEFAULT_BUILD TRUE
EXCLUDE_FROM_ALL TRUE)

43
tests/QTestExtensions.h
View file

@ -13,8 +13,9 @@
#define hifi_QTestExtensions_hpp
#include <QtTest/QtTest>
#include <QtCore/QFileInfo>
#include <functional>
#include <NumericalConstants.h>
#include "GLMTestUtils.h"
// Implements several extensions to QtTest.
@ -302,3 +303,43 @@ inline auto errorTest (float actual, float expected, float acceptableRelativeErr
QCOMPARE_WITH_LAMBDA(actual, expected, errorTest(actual, expected, relativeError))
inline QString getTestResource(const QString& relativePath) {
static QDir dir;
static std::once_flag once;
std::call_once(once, []{
QFileInfo fileInfo(__FILE__);
auto parentDir = fileInfo.absoluteDir();
auto rootDir = parentDir.absoluteFilePath("..");
dir = QDir::cleanPath(rootDir);
});
return QDir::cleanPath(dir.absoluteFilePath(relativePath));
}
inline bool afterUsecs(quint64& startUsecs, quint64 maxIntervalUecs) {
auto now = usecTimestampNow();
auto interval = now - startUsecs;
if (interval > maxIntervalUecs) {
startUsecs = now;
return true;
}
return false;
}
inline bool afterSecs(quint64& startUsecs, quint64 maxIntervalSecs) {
return afterUsecs(startUsecs, maxIntervalSecs * USECS_PER_SECOND);
}
template <typename F>
void doEvery(quint64& lastReportUsecs, quint64 secs, F lamdba) {
if (afterSecs(lastReportUsecs, secs)) {
lamdba();
}
}
inline void failAfter(quint64 startUsecs, quint64 secs, const char* message) {
if (afterSecs(startUsecs, secs)) {
QFAIL(message);
}
}

1
tests/animation/src/AnimTests.cpp
View file

@ -39,6 +39,7 @@ void AnimTests::initTestCase() {
void AnimTests::cleanupTestCase() {
//DependencyManager::destroy<AnimationCache>();
DependencyManager::get<ResourceManager>()->cleanup();
}
void AnimTests::testClipInternalState() {

17
tests/gpu/CMakeLists.txt Normal file
View file

@ -0,0 +1,17 @@
# Declare dependencies
macro (setup_testcase_dependencies)
# link in the shared libraries
link_hifi_libraries(shared test-utils ktx gpu gl ${PLATFORM_GL_BACKEND})
package_libraries_for_deployment()
target_opengl()
target_zlib()
find_package(QuaZip REQUIRED)
target_include_directories(${TARGET_NAME} SYSTEM PUBLIC ${QUAZIP_INCLUDE_DIRS})
target_link_libraries(${TARGET_NAME} ${QUAZIP_LIBRARIES})
if (WIN32)
add_paths_to_fixup_libs(${QUAZIP_DLL_PATH})
add_dependency_external_projects(wasapi)
endif ()
endmacro ()
setup_hifi_testcase()

284
tests/gpu/src/TextureTest.cpp Normal file
View file

@ -0,0 +1,284 @@
//
// Created by Bradley Austin Davis on 2018/01/11
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "TextureTest.h"
#include <iostream>
#include <QtCore/QTemporaryFile>
#include <gpu/Forward.h>
#include <gl/Config.h>
#include <gl/GLHelpers.h>
#include <gpu/gl/GLBackend.h>
#include <NumericalConstants.h>
#include <test-utils/FileDownloader.h>
#include <quazip5/quazip.h>
#include <quazip5/JlCompress.h>
#include "../../QTestExtensions.h"
QTEST_MAIN(TextureTest)
#define LOAD_TEXTURE_COUNT 40
static const QString TEST_DATA("https://hifi-public.s3.amazonaws.com/austin/test_data/test_ktx.zip");
static const QString TEST_DIR_NAME("{630b8f02-52af-4cdf-a896-24e472b94b28}");
std::string vertexShaderSource = R"SHADER(
#line 14
layout(location = 0) out vec2 outTexCoord0;
const vec4 VERTICES[] = vec4[](
vec4(-1.0, -1.0, 0.0, 1.0),
vec4( 1.0, -1.0, 0.0, 1.0),
vec4(-1.0, 1.0, 0.0, 1.0),
vec4( 1.0, 1.0, 0.0, 1.0)
);
void main() {
outTexCoord0 = VERTICES[gl_VertexID].xy;
outTexCoord0 += 1.0;
outTexCoord0 /= 2.0;
gl_Position = VERTICES[gl_VertexID];
}
)SHADER";
std::string fragmentShaderSource = R"SHADER(
#line 28
uniform sampler2D tex;
layout(location = 0) in vec2 inTexCoord0;
layout(location = 0) out vec4 outFragColor;
void main() {
outFragColor = texture(tex, inTexCoord0);
outFragColor.a = 1.0;
//outFragColor.rb = inTexCoord0;
}
)SHADER";
QtMessageHandler originalHandler;
void messageHandler(QtMsgType type, const QMessageLogContext& context, const QString& message) {
#if defined(Q_OS_WIN)
OutputDebugStringA(message.toStdString().c_str());
OutputDebugStringA("\n");
#endif
originalHandler(type, context, message);
}
void TextureTest::initTestCase() {
originalHandler = qInstallMessageHandler(messageHandler);
_resourcesPath = getTestResource("interface/resources");
getDefaultOpenGLSurfaceFormat();
_canvas.create();
if (!_canvas.makeCurrent()) {
qFatal("Unable to make test GL context current");
}
gl::initModuleGl();
gpu::Context::init<gpu::gl::GLBackend>();
_gpuContext = std::make_shared<gpu::Context>();
_resourcesPath = QStandardPaths::writableLocation(QStandardPaths::TempLocation) + "/" + TEST_DIR_NAME;
if (!QFileInfo(_resourcesPath).exists()) {
QDir(_resourcesPath).mkpath(".");
FileDownloader(TEST_DATA,
[&](const QByteArray& data) {
QTemporaryFile zipFile;
if (zipFile.open()) {
zipFile.write(data);
zipFile.close();
}
JlCompress::extractDir(zipFile.fileName(), _resourcesPath);
})
.waitForDownload();
}
_canvas.makeCurrent();
{
auto VS = gpu::Shader::createVertex(vertexShaderSource);
auto PS = gpu::Shader::createPixel(fragmentShaderSource);
auto program = gpu::Shader::createProgram(VS, PS);
gpu::Shader::BindingSet slotBindings;
gpu::Shader::makeProgram(*program, slotBindings);
// If the pipeline did not exist, make it
auto state = std::make_shared<gpu::State>();
state->setCullMode(gpu::State::CULL_NONE);
state->setDepthTest({});
state->setBlendFunction({ false });
_pipeline = gpu::Pipeline::create(program, state);
}
_framebuffer.reset(gpu::Framebuffer::create("cached", gpu::Element::COLOR_SRGBA_32, _size.x, _size.y));
// Find the test textures
{
QDir resourcesDir(_resourcesPath);
auto entryList = resourcesDir.entryList({ "*.ktx" }, QDir::Filter::Files);
_textureFiles.reserve(entryList.size());
for (auto entry : entryList) {
auto textureFile = resourcesDir.absoluteFilePath(entry).toStdString();
_textureFiles.push_back(textureFile);
}
}
// Load the test textures
{
size_t newTextureCount = std::min<size_t>(_textureFiles.size(), LOAD_TEXTURE_COUNT);
for (size_t i = 0; i < newTextureCount; ++i) {
const auto& textureFile = _textureFiles[i];
auto texture = gpu::Texture::unserialize(textureFile);
_textures.push_back(texture);
}
}
}
void TextureTest::cleanupTestCase() {
_framebuffer.reset();
_pipeline.reset();
_gpuContext->recycle();
_gpuContext.reset();
}
void TextureTest::beginFrame() {
_gpuContext->recycle();
_gpuContext->beginFrame();
gpu::doInBatch("TestWindow::beginFrame", _gpuContext, [&](gpu::Batch& batch) {
batch.setFramebuffer(_framebuffer);
batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, { 0.0f, 0.1f, 0.2f, 1.0f });
batch.clearDepthFramebuffer(1e4);
batch.setViewportTransform({ 0, 0, _size.x, _size.y });
});
}
void TextureTest::endFrame() {
gpu::doInBatch("TestWindow::endFrame::finish", _gpuContext, [&](gpu::Batch& batch) { batch.resetStages(); });
auto framePointer = _gpuContext->endFrame();
_gpuContext->consumeFrameUpdates(framePointer);
_gpuContext->executeFrame(framePointer);
// Simulate swapbuffers with a finish
glFinish();
QThread::msleep(10);
}
void TextureTest::renderFrame(const std::function<void(gpu::Batch&)>& renderLambda) {
beginFrame();
gpu::doInBatch("Test::body", _gpuContext, renderLambda);
endFrame();
}
void TextureTest::testTextureLoading() {
QVERIFY(_textures.size() > 0);
auto renderTexturesLamdba = [this](gpu::Batch& batch) {
batch.setPipeline(_pipeline);
for (const auto& texture : _textures) {
batch.setResourceTexture(0, texture);
batch.draw(gpu::TRIANGLE_STRIP, 4, 0);
}
};
size_t expectedAllocation = 0;
for (const auto& texture : _textures) {
expectedAllocation += texture->evalTotalSize();
}
QVERIFY(_textures.size() > 0);
auto reportLambda = [=] {
qDebug() << "Allowed " << gpu::Texture::getAllowedGPUMemoryUsage();
qDebug() << "Allocated " << gpu::Context::getTextureResourceGPUMemSize();
qDebug() << "Populated " << gpu::Context::getTextureResourcePopulatedGPUMemSize();
qDebug() << "Pending " << gpu::Context::getTexturePendingGPUTransferMemSize();
};
auto allocatedMemory = gpu::Context::getTextureResourceGPUMemSize();
auto populatedMemory = gpu::Context::getTextureResourcePopulatedGPUMemSize();
// Cycle frames we're fully allocated
// We need to use the texture rendering lambda
auto lastReport = usecTimestampNow();
auto start = usecTimestampNow();
while (expectedAllocation != allocatedMemory) {
doEvery(lastReport, 4, reportLambda);
failAfter(start, 10, "Failed to allocate texture memory after 10 seconds");
renderFrame(renderTexturesLamdba);
allocatedMemory = gpu::Context::getTextureResourceGPUMemSize();
populatedMemory = gpu::Context::getTextureResourcePopulatedGPUMemSize();
}
QCOMPARE(allocatedMemory, expectedAllocation);
// Restart the timer
start = usecTimestampNow();
// Cycle frames we're fully populated
while (allocatedMemory != populatedMemory || 0 != gpu::Context::getTexturePendingGPUTransferMemSize()) {
doEvery(lastReport, 4, reportLambda);
failAfter(start, 10, "Failed to populate texture memory after 10 seconds");
renderFrame();
allocatedMemory = gpu::Context::getTextureResourceGPUMemSize();
populatedMemory = gpu::Context::getTextureResourcePopulatedGPUMemSize();
}
reportLambda();
QCOMPARE(populatedMemory, allocatedMemory);
// FIXME workaround a race condition in the difference between populated size and the actual _populatedMip value in the texture
for (size_t i = 0; i < _textures.size(); ++i) {
renderFrame();
}
// Test on-demand deallocation of memory
auto maxMemory = allocatedMemory / 2;
gpu::Texture::setAllowedGPUMemoryUsage(maxMemory);
// Restart the timer
start = usecTimestampNow();
// Cycle frames until the allocated memory is below the max memory
while (allocatedMemory > maxMemory || allocatedMemory != populatedMemory) {
doEvery(lastReport, 4, reportLambda);
failAfter(start, 10, "Failed to deallocate texture memory after 10 seconds");
renderFrame(renderTexturesLamdba);
allocatedMemory = gpu::Context::getTextureResourceGPUMemSize();
populatedMemory = gpu::Context::getTextureResourcePopulatedGPUMemSize();
}
reportLambda();
// Verify that the allocation is now below the target
QVERIFY(allocatedMemory <= maxMemory);
// Verify that populated memory is the same as allocated memory
QCOMPARE(populatedMemory, allocatedMemory);
// Restart the timer
start = usecTimestampNow();
// Reset the max memory to automatic
gpu::Texture::setAllowedGPUMemoryUsage(0);
// Cycle frames we're fully populated
while (allocatedMemory != expectedAllocation || allocatedMemory != populatedMemory) {
doEvery(lastReport, 4, reportLambda);
failAfter(start, 10, "Failed to populate texture memory after 10 seconds");
renderFrame();
allocatedMemory = gpu::Context::getTextureResourceGPUMemSize();
populatedMemory = gpu::Context::getTextureResourcePopulatedGPUMemSize();
}
reportLambda();
QCOMPARE(allocatedMemory, expectedAllocation);
QCOMPARE(populatedMemory, allocatedMemory);
_textures.clear();
// Cycle frames we're fully populated
while (allocatedMemory != 0) {
failAfter(start, 10, "Failed to clear texture memory after 10 seconds");
renderFrame();
allocatedMemory = gpu::Context::getTextureResourceGPUMemSize();
populatedMemory = gpu::Context::getTextureResourcePopulatedGPUMemSize();
}
QCOMPARE(allocatedMemory, 0);
QCOMPARE(populatedMemory, 0);
qDebug() << "Done";
}

40
tests/gpu/src/TextureTest.h Normal file
View file

@ -0,0 +1,40 @@
//
// Created by Bradley Austin Davis on 2018/05/08
// Copyright 2013-2018 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
//
#pragma once
#include <QtTest/QtTest>
#include <QtCore/QTemporaryDir>
#include <gpu/Forward.h>
#include <gl/OffscreenGLCanvas.h>
class TextureTest : public QObject {
Q_OBJECT
private:
void beginFrame();
void endFrame();
void renderFrame(const std::function<void(gpu::Batch&)>& = [](gpu::Batch&) {});
private slots:
void initTestCase();
void cleanupTestCase();
void testTextureLoading();
private:
QString _resourcesPath;
OffscreenGLCanvas _canvas;
gpu::ContextPointer _gpuContext;
gpu::PipelinePointer _pipeline;
gpu::FramebufferPointer _framebuffer;
gpu::TexturePointer _colorBuffer, _depthBuffer;
const glm::uvec2 _size{ 640, 480 };
std::vector<std::string> _textureFiles;
std::vector<gpu::TexturePointer> _textures;
};

4
tests/ktx/src/KtxTests.cpp
View file

@ -76,7 +76,9 @@ void KtxTests::testKtxEvalFunctions() {
void KtxTests::testKtxSerialization() {
const QString TEST_IMAGE = getRootPath() + "/scripts/developer/tests/cube_texture.png";
QImage image(TEST_IMAGE);
gpu::TexturePointer testTexture = image::TextureUsage::process2DTextureColorFromImage(image, TEST_IMAGE.toStdString(), true);
std::atomic<bool> abortSignal;
gpu::TexturePointer testTexture =
image::TextureUsage::process2DTextureColorFromImage(std::move(image), TEST_IMAGE.toStdString(), true, abortSignal);
auto ktxMemory = gpu::Texture::serialize(*testTexture);
QVERIFY(ktxMemory.get());

21
tests/networking/src/ResourceTests.cpp
View file

@ -11,16 +11,23 @@
#include <QNetworkDiskCache>
#include "ResourceCache.h"
#include "NetworkAccessManager.h"
#include "DependencyManager.h"
#include <ResourceCache.h>
#include <LimitedNodeList.h>
#include <NodeList.h>
#include <NetworkAccessManager.h>
#include <DependencyManager.h>
#include <StatTracker.h>
QTEST_MAIN(ResourceTests)
void ResourceTests::initTestCase() {
auto resourceCacheSharedItems = DependencyManager::set<ResourceCacheSharedItems>();
//DependencyManager::set<AddressManager>();
DependencyManager::set<StatTracker>();
DependencyManager::registerInheritance<LimitedNodeList, NodeList>();
DependencyManager::set<NodeList>(NodeType::Agent, INVALID_PORT);
DependencyManager::set<ResourceCacheSharedItems>();
DependencyManager::set<ResourceManager>();
const qint64 MAXIMUM_CACHE_SIZE = 1024 * 1024 * 1024; // 1GB
// set up the file cache
@ -34,6 +41,10 @@ void ResourceTests::initTestCase() {
networkAccessManager.setCache(cache);
}
void ResourceTests::cleanupTestCase() {
DependencyManager::get<ResourceManager>()->cleanup();
}
static QSharedPointer<Resource> resource;

1
tests/networking/src/ResourceTests.h
View file

@ -18,6 +18,7 @@ private slots:
void initTestCase();
void downloadFirst();
void downloadAgain();
void cleanupTestCase();
};
#endif // hifi_ResourceTests_h

22
tests/qt59/CMakeLists.txt
View file

@ -1,22 +0,0 @@
set(TARGET_NAME qt59)
if (WIN32)
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ignore:4049 /ignore:4217")
endif()
setup_memory_debugger()
# This is not a testcase -- just set it up as a regular hifi project
setup_hifi_project(Gui)
set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "Tests/manual-tests/")
# link in the shared libraries
link_hifi_libraries(shared networking)
if (WIN32)
add_dependency_external_projects(wasapi)
endif()
package_libraries_for_deployment()

73
tests/qt59/src/main.cpp
View file

@ -1,73 +0,0 @@
//
// Created by Bradley Austin Davis on 2017/06/06
// Copyright 2013-2017 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 <mutex>
#include <QtCore/QCoreApplication>
#include <NodeList.h>
#include <AccountManager.h>
#include <AddressManager.h>
#include <MessagesClient.h>
#include <BuildInfo.h>
class Qt59TestApp : public QCoreApplication {
Q_OBJECT
public:
Qt59TestApp(int argc, char* argv[]);
~Qt59TestApp();
private:
void finish(int exitCode);
};
Qt59TestApp::Qt59TestApp(int argc, char* argv[]) :
QCoreApplication(argc, argv)
{
DependencyManager::registerInheritance<LimitedNodeList, NodeList>();
DependencyManager::set<AccountManager>([&] { return QString("Mozilla/5.0 (HighFidelityACClient)"); });
DependencyManager::set<AddressManager>();
DependencyManager::set<NodeList>(NodeType::Agent, 0);
auto nodeList = DependencyManager::get<NodeList>();
nodeList->startThread();
auto messagesClient = DependencyManager::set<MessagesClient>();
messagesClient->startThread();
QTimer::singleShot(1000, [this] { finish(0); });
}
Qt59TestApp::~Qt59TestApp() {
}
void Qt59TestApp::finish(int exitCode) {
auto nodeList = DependencyManager::get<NodeList>();
// send the domain a disconnect packet, force stoppage of domain-server check-ins
nodeList->getDomainHandler().disconnect();
nodeList->setIsShuttingDown(true);
nodeList->getPacketReceiver().setShouldDropPackets(true);
// remove the NodeList from the DependencyManager
DependencyManager::destroy<NodeList>();
QCoreApplication::exit(exitCode);
}
int main(int argc, char * argv[]) {
setupHifiApplication("Qt59Test");
Qt59TestApp app(argc, argv);
return app.exec();
}
#include "main.moc"

1
tests/ui/CMakeLists.txt
View file

@ -1 +0,0 @@
# This folder contains code for testing the QML UI using Qt Creator. It is not intended to be included in the CMake project