////  ShapeInfoTests.cpp//  tests/physics/src////  Created by Andrew Meadows on 2014.11.02//  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 "ShapeInfoTests.h" #include <iostream> #include <btBulletDynamicsCommon.h>#include <LinearMath/btHashMap.h> #include <HashKey.h>#include <ShapeInfo.h>#include <ShapeFactory.h>#include <StreamUtils.h> QTEST_MAIN(ShapeInfoTests) // Enable this to manually run testHashCollisions// (NOT a regular unit test; takes ~40 secs to run on an i7)//#define MANUAL_TEST true void ShapeInfoTests::testHashFunctions() {#if MANUAL_TEST    int maxTests = 10000000;    ShapeInfo info;    btHashMap<HashKey, int32_t> hashes;     const int32_t NUM_HASH_BITS = 32;    uint32_t bits[NUM_HASH_BITS];    uint32_t masks[NUM_HASH_BITS];    for (int i = 0; i < NUM_HASH_BITS; ++i) {        bits[i] = 0;        masks[i] = 1UL << i;    }     float deltaLength = 1.0f / (HashKey::getNumQuantizedValuesPerMeter() - 3.0f);    float endLength = 2000.0f * deltaLength;    int numSteps = (int)(endLength / deltaLength);     int testCount = 0;    int numCollisions = 0;     btClock timer;    for (int i = 1; i < numSteps && testCount < maxTests; ++i) {        float radiusX = (float)i * deltaLength;        int32_t* hashPtr;        // test sphere        info.setSphere(radiusX);        ++testCount;        HashKey hashKey(info.getHash());        hashPtr = hashes.find(hashKey);        if (hashPtr) {            std::cout << testCount << "  hash collision sphere radius = " << radiusX                << "  h = 0x" << std::hex << hashKey.getHash() << " : 0x" << *hashPtr                << std::dec << std::endl;            ++numCollisions;            assert(false);        } else {            hashes.insert(hashKey, hashKey.getHash());        }        // track bit distribution counts to evaluate hash function randomness        for (int j = 0; j < NUM_HASH_BITS; ++j) {            if (masks[j] & hashKey.getHash()) {                ++bits[j];            }        }         for (int y = 1; y < numSteps && testCount < maxTests; ++y) {            float radiusY = (float)y * deltaLength;            for (int z = 1; z < numSteps && testCount < maxTests; ++z) {                float radiusZ = (float)z * deltaLength;                // test box                info.setBox(glm::vec3(radiusX, radiusY, radiusZ));                ++testCount;                HashKey hashKey(info.getHash());                hashPtr = hashes.find(hashKey);                if (hashPtr) {                    std::cout << testCount << "  hash collision box dimensions = < " << radiusX                        << ", " << radiusY << ", " << radiusZ << " >"                        << "  h = 0x" << std::hex << hashKey.getHash() << " : 0x" << *hashPtr << " : 0x" << hashKey.getHash64()                        << std::dec << std::endl;                    ++numCollisions;                    assert(false);                } else {                    hashes.insert(hashKey, hashKey.getHash());                }                // track bit distribution counts to evaluate hash function randomness                for (int k = 0; k < NUM_HASH_BITS; ++k) {                    if (masks[k] & hashKey.getHash()) {                        ++bits[k];                    }                }            }        }    }    uint64_t msec = timer.getTimeMilliseconds();    std::cout << msec << " msec with " << numCollisions << " collisions out of " << testCount << " hashes" << std::endl;     // print out distribution of bits    // ideally the numbers in each bin will be about the same    for (int i = 0; i < NUM_HASH_BITS; ++i) {        std::cout << "bit 0x" << std::hex << masks[i] << std::dec << " = " << bits[i] << std::endl;    }    QCOMPARE(numCollisions, 0);#endif // MANUAL_TEST} void ShapeInfoTests::testBoxShape() {    ShapeInfo info;    glm::vec3 halfExtents(1.23f, 4.56f, 7.89f);    info.setBox(halfExtents);    HashKey hashKey(info.getHash());     const btCollisionShape* shape = ShapeFactory::createShapeFromInfo(info);    QCOMPARE(shape != nullptr, true);     ShapeInfo otherInfo = info;    HashKey otherKey = otherInfo.getHash();    QCOMPARE(hashKey.getHash(), otherKey.getHash());     delete shape;} void ShapeInfoTests::testSphereShape() {    ShapeInfo info;    float radius = 1.23f;    info.setSphere(radius);    HashKey hashKey = info.getHash();     const btCollisionShape* shape = ShapeFactory::createShapeFromInfo(info);    QCOMPARE(shape != nullptr, true);     ShapeInfo otherInfo = info;    HashKey otherKey = otherInfo.getHash();    QCOMPARE(hashKey.getHash(), otherKey.getHash());     delete shape;} void ShapeInfoTests::testCylinderShape() {    /* TODO: reimplement Cylinder shape    ShapeInfo info;    float radius = 1.23f;    float height = 4.56f;    info.setCylinder(radius, height);    HashKey hashKey(info.getHash());     btCollisionShape* shape = ShapeFactory::createShapeFromInfo(info);    QCOMPARE(shape != nullptr, true);     ShapeInfo otherInfo = info;    HashKey otherKey = otherInfo.getHash();    QCOMPARE(hashKey.getHash(), otherKey.getHash());     delete shape;    */} void ShapeInfoTests::testCapsuleShape() {    /* TODO: reimplement Capsule shape    ShapeInfo info;    float radius = 1.23f;    float height = 4.56f;    info.setCapsule(radius, height);    HashKey hashKey(info.getHash());     btCollisionShape* shape = ShapeFactory::createShapeFromInfo(info);    QCOMPARE(shape != nullptr, true);     ShapeInfo otherInfo = info;    HashKey otherKey = otherInfo.getHash();    QCOMPARE(hashKey.getHash(), otherKey.getHash());     delete shape;    */}