Class ManifoldBooleans

Manifold सॉलिड्स को संयोजित करना: दो या कई को एक साथ फ़्यूज़, कट और इंटरसेक्ट करना, और सॉलिड को दूसरे सॉलिड या प्लेन से विभाजित करना। चूँकि कर्नेल बंद त्रिभुज मेश पर काम करता है, ये तेज़ हैं और हमेशा जलरोधी परिणाम देते हैं; दो-शेप और बहु-शेप रूप समान परिणाम देते हैं और सुविधा के लिए मौजूद हैं। हर मेथड नए सॉलिड्स लौटाता है और इनपुट को जैसे हैं वैसा छोड़ देता है।

Index

Constructors

constructor

new ManifoldBooleans(): ManifoldBooleans
Returns ManifoldBooleans

2 manifolds

differenceTwo

differenceTwo(
inputs: TwoManifoldsDto<ManifoldPointer>,
): Promise<ManifoldPointer>
दूसरे सॉलिड को पहले में से काटता है, subtract जैसा ही।
Parameters
- inputs: TwoManifoldsDto<ManifoldPointer>
  वह सॉलिड जिसमें से काटना है और वह सॉलिड जिससे काटना है
Returns Promise<ManifoldPointer>
पहले सॉलिड में से दूसरा घटाकर
Example
```
const holed = await bitbybit.manifold.manifold.booleans.differenceTwo({ manifold1: cube, manifold2: sphere });
```
- Defined in bitbybit-docs.d.ts:38189

unionTwo

unionTwo(inputs: TwoManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer>
दो सॉलिड को एक में फ़्यूज़ करता है, add जैसा ही।
Parameters
- inputs: TwoManifoldsDto<ManifoldPointer>
  दोनों सॉलिड्स
Returns Promise<ManifoldPointer>
फ़्यूज़ किया गया सॉलिड
Example
```
const fused = await bitbybit.manifold.manifold.booleans.unionTwo({ manifold1: cube, manifold2: sphere });
```
- Defined in bitbybit-docs.d.ts:38202

intersectionTwo

intersectionTwo(
inputs: TwoManifoldsDto<ManifoldPointer>,
): Promise<ManifoldPointer>
केवल वह आयतन रखता है जो दो सॉलिड साझा करते हैं, intersect जैसा ही।
Parameters
- inputs: TwoManifoldsDto<ManifoldPointer>
  दोनों सॉलिड्स
Returns Promise<ManifoldPointer>
साझा आयतन
Example
```
const common = await bitbybit.manifold.manifold.booleans.intersectionTwo({ manifold1: cube, manifold2: sphere });
```
- Defined in bitbybit-docs.d.ts:38215

a to b

subtract

subtract(inputs: TwoManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer>
दूसरे सॉलिड को पहले में से काटता है, पहले का जो बचता है उसे छोड़ते हुए।
Parameters
- inputs: TwoManifoldsDto<ManifoldPointer>
  वह सॉलिड जिसमें से काटना है और वह सॉलिड जिससे काटना है
Returns Promise<ManifoldPointer>
पहले सॉलिड में से दूसरा घटाकर
Example
```
const holed = await bitbybit.manifold.manifold.booleans.subtract({ manifold1: cube, manifold2: sphere });
```
- Defined in bitbybit-docs.d.ts:38150

add

add(inputs: TwoManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer>
दो सॉलिड को एक बंद, जलरोधी सॉलिड में फ़्यूज़ करता है।
Parameters
- inputs: TwoManifoldsDto<ManifoldPointer>
  दोनों सॉलिड्स
Returns Promise<ManifoldPointer>
फ़्यूज़ किया गया सॉलिड
Example
```
const fused = await bitbybit.manifold.manifold.booleans.add({ manifold1: cube, manifold2: sphere });
```
- Defined in bitbybit-docs.d.ts:38163

intersect

intersect(inputs: TwoManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer>
केवल वह आयतन रखता है जो दो सॉलिड साझा करते हैं, बाकी सब हटाते हुए।
Parameters
- inputs: TwoManifoldsDto<ManifoldPointer>
  दोनों सॉलिड्स
Returns Promise<ManifoldPointer>
साझा आयतन
Example
```
const common = await bitbybit.manifold.manifold.booleans.intersect({ manifold1: cube, manifold2: sphere });
```
- Defined in bitbybit-docs.d.ts:38176

minkowski

minkowskiSum

minkowskiSum(inputs: TwoManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer>
दूसरे सॉलिड को पहले की पूरी सतह पर स्वीप करता है और जिस-जिस से वह गुज़रता है उसे फ़्यूज़ कर देता है, जिससे पहला सॉलिड दूसरे के आकार जितना बढ़ जाता है - मिंकोव्स्की योग, जिससे किसी सॉलिड को गोले से गोल या मोटा किया जाता है।
Parameters
- inputs: TwoManifoldsDto<ManifoldPointer>
  बढ़ाया जाने वाला सॉलिड और स्वीप किया जाने वाला सॉलिड
Returns Promise<ManifoldPointer>
बढ़ा हुआ सॉलिड
Example
```
const padded = await bitbybit.manifold.manifold.booleans.minkowskiSum({ manifold1: cube, manifold2: sphere });
```
- Defined in bitbybit-docs.d.ts:38122

minkowskiDifference

minkowskiDifference(
inputs: TwoManifoldsDto<ManifoldPointer>,
): Promise<ManifoldPointer>
दूसरे सॉलिड को पहले की पूरी सतह पर स्वीप करता है और जिस-जिस से वह गुज़रता है उसे काट देता है, जिससे पहला सॉलिड दूसरे के आकार जितना सिकुड़ जाता है - मिंकोव्स्की अंतर, वह अपरदन जो मिंकोव्स्की योग को उलट देता है।
Parameters
- inputs: TwoManifoldsDto<ManifoldPointer>
  सिकोड़ा जाने वाला सॉलिड और स्वीप किया जाने वाला सॉलिड
Returns Promise<ManifoldPointer>
सिकुड़ा हुआ सॉलिड
Example
```
const eroded = await bitbybit.manifold.manifold.booleans.minkowskiDifference({ manifold1: cube, manifold2: sphere });
```
- Defined in bitbybit-docs.d.ts:38137

multiple

difference

difference(inputs: ManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer>
सूची के हर आगे के सॉलिड को पहले में से काटता है।
Parameters
- inputs: ManifoldsDto<ManifoldPointer>
  सॉलिड्स, जिनमें पहला वह है जिसमें से काटा जाता है
Returns Promise<ManifoldPointer>
पहले सॉलिड में से बाकी सभी घटाकर
Example
```
const holed = await bitbybit.manifold.manifold.booleans.difference({ manifolds: [cube, sphere, cylinder] });
```
- Defined in bitbybit-docs.d.ts:38228

union

union(inputs: ManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer>
सूची के सभी सॉलिड को एक में फ़्यूज़ करता है।
Parameters
- inputs: ManifoldsDto<ManifoldPointer>
  सॉलिड्स
Returns Promise<ManifoldPointer>
फ़्यूज़ किया गया सॉलिड
Example
```
const fused = await bitbybit.manifold.manifold.booleans.union({ manifolds: [cube, sphere, cylinder] });
```
- Defined in bitbybit-docs.d.ts:38241

intersection

intersection(inputs: ManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer>
केवल वह आयतन रखता है जो सूची के सभी सॉलिड साझा करते हैं।
Parameters
- inputs: ManifoldsDto<ManifoldPointer>
  सॉलिड्स
Returns Promise<ManifoldPointer>
उन सभी में साझा आयतन
Example
```
const common = await bitbybit.manifold.manifold.booleans.intersection({ manifolds: [cube, sphere] });
```
- Defined in bitbybit-docs.d.ts:38254

split

split(inputs: SplitManifoldsDto<ManifoldPointer>): Promise<ManifoldPointer[]>
सॉलिड को दूसरे सॉलिड से काटता है और दोनों टुकड़े रखता है: काटने वाले के भीतर का हिस्सा और उसके बाहर का हिस्सा।

जब दोनों चाहिए तब इंटरसेक्शन के बाद सबट्रैक्शन से सस्ता।
Parameters
- inputs: SplitManifoldsDto<ManifoldPointer>
  विभाजित किया जाने वाला सॉलिड और वह सॉलिड जिससे काटना है
Returns Promise<ManifoldPointer[]>
दो सॉलिड्स: कटर के भीतर का हिस्सा, फिर उसके बाहर का हिस्सा
Example
```
const [inside, outside] = await bitbybit.manifold.manifold.booleans.split({ manifoldToSplit: cube, manifoldCutter: sphere });
```
- Defined in bitbybit-docs.d.ts:38270

splitByPlane

splitByPlane(
inputs: SplitByPlaneDto<ManifoldPointer>,
): Promise<ManifoldPointer[]>
सॉलिड को प्लेन से काटता है और दोनों टुकड़े रखता है।

प्लेन उसके नॉर्मल और उस नॉर्मल के साथ मूल बिंदु से उसकी दूरी से दिया जाता है; पहला टुकड़ा उस ओर है जिस ओर नॉर्मल इशारा करता है, दूसरा दूसरी ओर।
Parameters
- inputs: SplitByPlaneDto<ManifoldPointer>
  सॉलिड, प्लेन का नॉर्मल और मूल बिंदु से प्लेन की दूरी
Returns Promise<ManifoldPointer[]>
दो सॉलिड्स: नॉर्मल की ओर का हिस्सा, फिर बाकी
Example
```
const [top, bottom] = await bitbybit.manifold.manifold.booleans.splitByPlane({ manifold: cube, normal: [0, 0, 1], originOffset: 0.5 });
```
- Defined in bitbybit-docs.d.ts:38286

splitByPlaneOnOffsets

splitByPlaneOnOffsets(
inputs: SplitByPlaneOnOffsetsDto<ManifoldPointer>,
): Promise<ManifoldPointer[]>
सॉलिड को कई समानांतर प्लेन से, सभी एक ही नॉर्मल के साथ, मूल बिंदु से दी गई दूरियों पर पटियों में काटता है।

हर कटाव नॉर्मल की दूर वाली ओर का हिस्सा तैयार टुकड़े के रूप में रखता है और बाकी को अगली दूरी तक ले जाता है, इसलिए ऑफ़सेट बढ़ते होने चाहिए; n ऑफ़सेट n + 1 टुकड़े देते हैं, खाली वाले हटा दिए जाते हैं।
Parameters
- inputs: SplitByPlaneOnOffsetsDto<ManifoldPointer>
  सॉलिड, प्लेन का नॉर्मल और मूल बिंदु से प्लेनों की दूरियाँ
Returns Promise<ManifoldPointer[]>
स्लैब, दिए गए ऑफसेट से एक अधिक
Example
```
const slabs = await bitbybit.manifold.manifold.booleans.splitByPlaneOnOffsets({ manifold: cube, normal: [0, 0, 1], originOffsets: [0.25, 0.5, 0.75] });
```
- Defined in bitbybit-docs.d.ts:38304

trim

trimByPlane

trimByPlane(inputs: TrimByPlaneDto<ManifoldPointer>): Promise<ManifoldPointer>
सॉलिड को प्लेन से काटता है और केवल उस ओर का हिस्सा रखता है जिस ओर नॉर्मल इशारा करता है।

प्लेन उसके नॉर्मल और उस नॉर्मल के साथ मूल बिंदु से उसकी दूरी से दिया जाता है।
Parameters
- inputs: TrimByPlaneDto<ManifoldPointer>
  सॉलिड, प्लेन का नॉर्मल और मूल बिंदु से प्लेन की दूरी
Returns Promise<ManifoldPointer>
सॉलिड का नॉर्मल की ओर का हिस्सा
Example
```
const half = await bitbybit.manifold.manifold.booleans.trimByPlane({ manifold: sphere, normal: [0, 0, 1], originOffset: 0 });
```
- Defined in bitbybit-docs.d.ts:38319

Class ManifoldBooleans

Index

Constructors

2 manifolds

a to b

minkowski

multiple

split

trim

Constructors

constructor

Returns ManifoldBooleans

2 manifolds

differenceTwo

Parameters

Returns Promise<ManifoldPointer>

Example

unionTwo

Parameters

Returns Promise<ManifoldPointer>

Example

intersectionTwo

Parameters

Returns Promise<ManifoldPointer>

Example

a to b

subtract

Parameters

Returns Promise<ManifoldPointer>

Example

add

Parameters

Returns Promise<ManifoldPointer>

Example

intersect

Parameters

Returns Promise<ManifoldPointer>

Example

minkowski

minkowskiSum

Parameters

Returns Promise<ManifoldPointer>

Example

minkowskiDifference

Parameters

Returns Promise<ManifoldPointer>

Example

multiple

difference

Parameters

Returns Promise<ManifoldPointer>

Example

union

Parameters

Returns Promise<ManifoldPointer>

Example

intersection

Parameters

Returns Promise<ManifoldPointer>

Example

split

split

Parameters

Returns Promise<ManifoldPointer[]>

Example

splitByPlane

Parameters

Returns Promise<ManifoldPointer[]>

Example

splitByPlaneOnOffsets

Parameters

Returns Promise<ManifoldPointer[]>

Example

trim

trimByPlane

Parameters

Returns Promise<ManifoldPointer>

Example

Settings

On This Page