GPU-compatible convex hull could not be built because of oblong shape.

[oneanime]

hello，I want to load this convex hull mesh into the GPU for acceleration, but I encountered an error and I'm not sure how to resolve it.

[vreutskyy]

Hi @oneanime
The convex hull on your screenshot doesn't look like the shape that should cause this error.
Can you make a snippet reproducing this issue?

[oneanime]

Here is my code snippet, thanks for the review.

PxConvexMesh * PolyhedraMesh::createPolyhedraConvexMesh(const PxConvexMeshDesc& desc, const PxConvexMeshCookingType::Enum convexMeshCookingType, const bool directInsertion, const PxU32 gaussMapLimit) {
PxTolerancesScale tolerances;
PxCookingParams params(tolerances);
params.buildGPUData=true;
params.convexMeshCookingType = convexMeshCookingType;
params.gaussMapLimit = gaussMapLimit;

PxU32 meshSize = 0;

PxConvexMesh * convexMesh=nullptr;
if (directInsertion) {
    if (PxValidateConvexMesh(params,desc)) {
        convexMesh = PxCreateConvexMesh(params, desc, physics->getPhysicsInsertionCallback());
    }else {
        //todo 
    }

    PX_ASSERT(convex);
} else {
    PxDefaultMemoryOutputStream outStream;
    bool res = PxCookConvexMesh(params, desc, outStream);
    PX_UNUSED(res);
    PX_ASSERT(res);
    meshSize = outStream.getSize();

    PxDefaultMemoryInputData inStream(outStream.getData(), outStream.getSize());
    convexMesh = physics->createConvexMesh(inStream);
    PX_ASSERT(convex);
}

if (!directInsertion) {
    //todo 
    printf("\t Mesh size: %d \n", meshSize);
}
return convexMesh;

}

PxConvexMesh * PolyhedraMesh::createRandomPolyhedraConvexMeshUsingCGAL() {

Polyhedron polyhedron = PolyhedraUtils::createPolyhedra();

std::vector<PxVec3> vertices;
std::vector<PxHullPolygon> hullPolygons;
std::vector<PxU32> indices;

for (auto v = polyhedron.vertices_begin(); v != polyhedron.vertices_end(); ++v) {
    const Point_3& p = v->point();
    vertices.emplace_back(static_cast<float>(p.x()),
                              static_cast<float>(p.y()),
                              static_cast<float>(p.z()));
}

for (auto f = polyhedron.facets_begin(); f != polyhedron.facets_end(); ++f) {
    PxHullPolygon polygon{};
    polygon.mIndexBase = static_cast<PxU32>(indices.size());  // Starting index of this polygon
    polygon.mNbVerts = 0;  // Number of vertices in this polygon

    // Traverse the halfedges of the facet to collect indices
    auto h = f->facet_begin();
    do {
        indices.push_back(static_cast<PxU32>(std::distance(polyhedron.vertices_begin(), h->vertex())));
        ++polygon.mNbVerts;
        ++h;
    } while (h != f->facet_begin());
    polygon.mPlane[0] = 0.0f;
    polygon.mPlane[1] = 0.0f;
    polygon.mPlane[2] = 0.0f;
    polygon.mPlane[3] = 0.0f;

    hullPolygons.push_back(polygon);
}

PxConvexMeshDesc convexDesc = MeshUtils::createConvexMeshDesc(vertices.data(),vertices.size(),indices.data(),indices.size(),hullPolygons.data(),hullPolygons.size());

PxConvexMesh * convexMesh = this->createPolyhedraConvexMesh(convexDesc,PxConvexMeshCookingType::eQUICKHULL, true, 256);
if (convexMesh) {
    this->convexMeshCollection.push_back(convexMesh);
}else {
    // todo 
}
return convexMesh;

}

Polyhedron PolyhedraUtils::createPolyhedra() {
Polyhedron polyhedra = createRandomPolyhedra(4,64,1.0);

return polyhedra;

}

Polyhedron PolyhedraUtils::createRandomPolyhedra(const int minVertices, const int maxVertices, const double scale) {
std::vector<Point_3> points;

unsigned seed = static_cast<unsigned>(std::chrono::system_clock::now().time_since_epoch().count());
CGAL::Random rng(seed);


int numPoints = rng.get_int(minVertices, maxVertices);


for (int i = 0; i < numPoints; ++i) {
    points.emplace_back(
    rng.get_double(-1.0, 1.0)*scale,
    rng.get_double(-1.0, 1.0)*scale,
    rng.get_double(-1.0, 1.0)*scale
    );
}



Polyhedron polyhedron;
CGAL::convex_hull_3(points.begin(), points.end(), polyhedron);


if (!polyhedron.is_valid()) {
    std::cerr << "Error: Generated convex hull is invalid!" << std::endl;
 
}


if (polyhedron.size_of_vertices() > 256) {
    std::cerr << "Warning: Convex hull has too many vertices for PhysX!" << std::endl;
  
}

return polyhedron;

}

PxRigidDynamic * BaseObject::createRigidDynamic() {
PxConvexMeshGeometry convexMeshGeometry = convexMesh;
convexMeshGeometry.scale.scale = scale;

shape = PxGetPhysics().createShape(convexMeshGeometry, *material);

PxTransform transform(originalPosition);
rigidDynamic = PxGetPhysics().createRigidDynamic(transform);
rigidDynamic->setMass(mass);
rigidDynamic->setRigidBodyFlag(PxRigidBodyFlag::eKINEMATIC, false);
rigidDynamic->attachShape(*shape);
return rigidDynamic;

}