Enum physx_sys::PxConvexFlag

#[repr(i32)]
pub enum PxConvexFlag {
    E16BitIndices = 1,
    ComputeConvex = 2,
    CheckZeroAreaTriangles = 4,
    QuantizeInput = 8,
    DisableMeshValidation = 16,
    PlaneShifting = 32,
    FastInertiaComputation = 64,
    GpuCompatible = 128,
    ShiftVertices = 256,
}

Flags which describe the format and behavior of a convex mesh.

Variants

E16BitIndices = 1

Denotes the use of 16-bit vertex indices in PxConvexMeshDesc::triangles or PxConvexMeshDesc::polygons. (otherwise, 32-bit indices are assumed)

ComputeConvex = 2

Automatically recomputes the hull from the vertices. If this flag is not set, you must provide the entire geometry manually.

There are two different algorithms for hull computation, please see PxConvexMeshCookingType.

CheckZeroAreaTriangles = 4

Checks and removes almost zero-area triangles during convex hull computation. The rejected area size is specified in PxCookingParams::areaTestEpsilon

This flag is only used in combination with eCOMPUTE_CONVEX.

QuantizeInput = 8

Quantizes the input vertices using the k-means clustering

The input vertices are quantized to PxConvexMeshDesc::quantizedCount see http://en.wikipedia.org/wiki/K-means_clustering

DisableMeshValidation = 16

Disables the convex mesh validation to speed-up hull creation. Please use separate validation function in checked/debug builds. Creating a convex mesh with invalid input data without prior validation may result in undefined behavior.

PlaneShifting = 32

Enables plane shifting vertex limit algorithm.

Plane shifting is an alternative algorithm for the case when the computed hull has more vertices than the specified vertex limit.

The default algorithm computes the full hull, and an OBB around the input vertices. This OBB is then sliced with the hull planes until the vertex limit is reached.The default algorithm requires the vertex limit to be set to at least 8, and typically produces results that are much better quality than are produced by plane shifting.

When plane shifting is enabled, the hull computation stops when vertex limit is reached. The hull planes are then shifted to contain all input vertices, and the new plane intersection points are then used to generate the final hull with the given vertex limit.Plane shifting may produce sharp edges to vertices very far away from the input cloud, and does not guarantee that all input vertices are inside the resulting hull.However, it can be used with a vertex limit as low as 4.

FastInertiaComputation = 64

Inertia tensor computation is faster using SIMD code, but the precision is lower, which may result in incorrect inertia for very thin hulls.

GpuCompatible = 128

Convex hulls are created with respect to GPU simulation limitations. Vertex limit and polygon limit is set to 64 and vertex limit per face is internally set to 32.

Can be used only with eCOMPUTE_CONVEX flag.

ShiftVertices = 256

Convex hull input vertices are shifted to be around origin to provide better computation stability. It is recommended to provide input vertices around the origin, otherwise use this flag to improve numerical stability.

Is used only with eCOMPUTE_CONVEX flag.

Trait Implementations

impl Clone for PxConvexFlag

fn clone(&self) -> PxConvexFlag

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PxConvexFlag

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for PxConvexFlag

fn eq(&self, other: &PxConvexFlag) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for PxConvexFlag

impl Eq for PxConvexFlag

impl StructuralEq for PxConvexFlag

impl StructuralPartialEq for PxConvexFlag