1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2020 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#ifndef NV_CLOTH_EXTENSIONS_CLOTH_FABRIC_COOKER_H
#define NV_CLOTH_EXTENSIONS_CLOTH_FABRIC_COOKER_H
/** \addtogroup extensions
@{
*/
#include "ClothMeshDesc.h"
#include "NvCloth/Fabric.h"
#include "NvCloth/Factory.h"
namespace nv
{
namespace cloth
{
struct CookedData
{
uint32_t mNumParticles;
Range<const uint32_t> mPhaseIndices;
Range<const int32_t> mPhaseTypes;
Range<const uint32_t> mSets;
Range<const float> mRestvalues;
Range<const float> mStiffnessValues;
Range<const uint32_t> mIndices;
Range<const uint32_t> mAnchors;
Range<const float> mTetherLengths;
Range<const uint32_t> mTriangles;
};
/**
\brief Describe type of phase in cloth fabric.
\see Fabric for an explanation of concepts on phase and set.
*/
struct ClothFabricPhaseType
{
enum Enum
{
eINVALID, //!< invalid type
eVERTICAL, //!< resists stretching or compression, usually along the gravity
eHORIZONTAL, //!< resists stretching or compression, perpendicular to the gravity
eBENDING, //!< resists out-of-plane bending in angle-based formulation
eSHEARING, //!< resists in-plane shearing along (typically) diagonal edges,
eCOUNT // internal use only
};
};
/**
\brief References a set of constraints that can be solved in parallel.
\see Fabric for an explanation of the concepts on phase and set.
*/
struct ClothFabricPhase
{
ClothFabricPhase(ClothFabricPhaseType::Enum type =
ClothFabricPhaseType::eINVALID, physx::PxU32 index = 0);
/**
\brief Type of constraints to solve.
*/
ClothFabricPhaseType::Enum phaseType;
/**
\brief Index of the set that contains the particle indices.
*/
physx::PxU32 setIndex;
};
PX_INLINE ClothFabricPhase::ClothFabricPhase(
ClothFabricPhaseType::Enum type, physx::PxU32 index)
: phaseType(type)
, setIndex(index)
{}
/**
\brief References all the data required to create a fabric.
\see ClothFabricCooker.getDescriptor()
*/
class ClothFabricDesc
{
public:
/** \brief The number of particles needed when creating a PxCloth instance from the fabric. */
physx::PxU32 nbParticles;
/** \brief The number of solver phases. */
physx::PxU32 nbPhases;
/** \brief Array defining which constraints to solve each phase. See #Fabric.getPhases(). */
const ClothFabricPhase* phases;
/** \brief The number of sets in the fabric. */
physx::PxU32 nbSets;
/** \brief Array with an index per set which points one entry beyond the last constraint of the set. See #Fabric.getSets(). */
const physx::PxU32* sets;
/** \brief Array of particle indices which specifies the pair of constrained vertices. See #Fabric.getParticleIndices(). */
const physx::PxU32* indices;
/** \brief Array of rest values for each constraint. See #Fabric.getRestvalues(). */
const physx::PxReal* restvalues;
/** \brief Size of tetherAnchors and tetherLengths arrays, needs to be multiple of nbParticles. */
physx::PxU32 nbTethers;
/** \brief Array of particle indices specifying the tether anchors. See #Fabric.getTetherAnchors(). */
const physx::PxU32* tetherAnchors;
/** \brief Array of rest distance between tethered particle pairs. See #Fabric.getTetherLengths(). */
const physx::PxReal* tetherLengths;
physx::PxU32 nbTriangles;
const physx::PxU32* triangles;
/**
\brief constructor sets to default.
*/
PX_INLINE ClothFabricDesc();
/**
\brief (re)sets the structure to the default.
*/
PX_INLINE void setToDefault();
/**
\brief Returns true if the descriptor is valid.
\return True if the current settings are valid
*/
PX_INLINE bool isValid() const;
};
PX_INLINE ClothFabricDesc::ClothFabricDesc()
{
setToDefault();
}
PX_INLINE void ClothFabricDesc::setToDefault()
{
memset(this, 0, sizeof(ClothFabricDesc));
}
PX_INLINE bool ClothFabricDesc::isValid() const
{
return nbParticles && nbPhases && phases && restvalues && nbSets
&& sets && indices && (!nbTethers || (tetherAnchors && tetherLengths))
&& (!nbTriangles || triangles);
}
///Use NvClothCreateFabricCooker() to create an implemented instance
class NV_CLOTH_IMPORT ClothFabricCooker : public UserAllocated
{
public:
virtual ~ClothFabricCooker(){}
/**
\brief Cooks a triangle mesh to a ClothFabricDesc.
\param desc The cloth mesh descriptor on which the generation of the cooked mesh depends.
\param gravity A normalized vector which specifies the direction of gravity.
This information allows the cooker to generate a fabric with higher quality simulation behavior.
The gravity vector should point in the direction gravity will be pulling towards in the most common situation/at rest.
e.g. For flags it might be beneficial to set the gravity horizontal if they are cooked in landscape orientation, as a flag will hang in portrait orientation at rest.
\param useGeodesicTether A flag to indicate whether to compute geodesic distance for tether constraints.
\note The geodesic option for tether only works for manifold input. For non-manifold input, a simple Euclidean distance will be used.
For more detailed cooker status for such cases, try running ClothGeodesicTetherCooker directly.
*/
virtual bool cook(const ClothMeshDesc& desc, physx::PxVec3 gravity, bool useGeodesicTether = true) = 0;
/** \brief Returns fabric cooked data for creating fabrics. */
virtual CookedData getCookedData() const = 0;
/** \brief Returns the fabric descriptor to create the fabric. */
virtual ClothFabricDesc getDescriptor() const = 0;
/** \brief Saves the fabric data to a platform and version dependent stream. */
virtual void save(physx::PxOutputStream& stream, bool platformMismatch) const = 0;
};
/** @} */
} // namespace cloth
} // namespace nv
NV_CLOTH_API(nv::cloth::ClothFabricCooker*) NvClothCreateFabricCooker();
/**
\brief Cooks a triangle mesh to a Fabric.
\param factory The factory for which the cloth is cooked.
\param desc The cloth mesh descriptor on which the generation of the cooked mesh depends.
\param gravity A normalized vector which specifies the direction of gravity.
This information allows the cooker to generate a fabric with higher quality simulation behavior.
\param phaseTypes Optional array where phase type information can be writen to.
\param useGeodesicTether A flag to indicate whether to compute geodesic distance for tether constraints.
\return The created cloth fabric, or NULL if creation failed.
*/
NV_CLOTH_API(nv::cloth::Fabric*) NvClothCookFabricFromMesh(nv::cloth::Factory* factory,
const nv::cloth::ClothMeshDesc& desc, const physx::PxVec3& gravity,
nv::cloth::Vector<int32_t>::Type* phaseTypes = nullptr, bool useGeodesicTether = true);
#endif // NV_CLOTH_EXTENSIONS_CLOTH_FABRIC_COOKER_H
|