การ **IntersectOperation** คือผลลัพธ์ของชิ้นส่วนแต่ละชิ้นที่ถูกตัดกัน
เป็นโมเดลของแข็งเดียวผ่านเครื่องมือ **Intersect** ในการสร้างโมเดลของแข็งของ Studio
หรือผ่าน `Class.BasePart:IntersectAsync()`.

ดู [Solid Modeling](/parts/solid-modeling) เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับ
เครื่องมือและวิธีการสร้างโมเดลของแข็งของ Studio.


IntersectOperation

ผลลัพธ์ของชิ้นส่วนที่ถูกตัดกันเป็นโมเดลของแข็งเดียว


คลาสเบื้องต้นที่ส่วนทั้งหมดที่อิงจาก
[การจำลองของแข็ง](/parts/solid-modeling) สืบทอดมาจาก

ตัวอย่างต่อไปนี้จะแทนที่รูปทรงเรขาคณิตของ `Class.PartOperation`
ด้วยรูปทรงเรขาคณิตของ `Class.PartOperation` อีกอันหนึ่ง จากนั้นจะลบ
ข้อจำกัด/การเชื่อมต่อที่ไม่ควรถูกเก็บรักษาหลังจากการแทนที่.


แทนที่รูปทรงของ `Class.PartOperation` นี้ด้วยรูปทรง
ของ `Class.PartOperation` อื่น นี่ทำให้การใช้งานรูปทรงของการดำเนินการจำลองของแข็งเช่น
`Class.GeometryService:UnionAsync()|UnionAsync()`,
`Class.GeometryService:SubtractAsync()|SubtractAsync()`, หรือ
`Class.GeometryService:IntersectAsync()|IntersectAsync()` แต่คงไว้ซึ่ง
คุณสมบัติ, แอตทริบิวต์, แท็ก, และลูกของส่วนหลักเช่น
`Class.Attachment|Attachments`, `Class.Constraint|Constraints`,
`Class.ParticleEmitter|ParticleEmitters`, วัตถุไฟ, สติกเกอร์ และอื่นๆ
วิธีนี้ยังหลีกเลี่ยงการเกิด"กระพริบ" ของการแทนที่
`Class.PartOperation` ตามปกติด้วยอีกอย่าง

โปรดทราบว่า หากคุณเรียกใช้วิธีนี้บน `Class.PartOperation` ที่มี
ลูก `Class.Attachment|Attachments` หรือ `Class.Constraint|Constraints`,
คุณควรคำนวณตัวอย่างที่ได้รับผลกระทบด้วย
`Class.GeometryService:CalculateConstraintsToPreserve()|CalculateConstraintsToPreserve()`,
แล้วละทิ้งตัวอย่างที่แนะนำพ่อเป็น `nil`

PartOperation:SubstituteGeometry

source

`Class.PartOperation` ซึ่งรูปทรงจะถูกแทนที่ด้วยรูปทรง
ของ `Class.PartOperation` นี้

แทนที่รูปทรงของ `Class.PartOperation` นี้ด้วยรูปทรง
ของ `Class.PartOperation` อื่น

PartOperation

คุณสมบัตินี้กำหนดระดับของรายละเอียดที่ส่วนที่จำลองของแข็ง
จะแสดงให้เห็น โดยสามารถตั้งค่าเป็นค่าที่เป็นไปได้ของ
`Enum.RenderFidelity` ยกเว้น
`Enum.RenderFidelity.Performance|Performance`。

ค่าที่กำหนดโดยค่าเริ่มต้นคือ `Enum.RenderFidelity.Automatic|Automatic` ซึ่งหมายความว่ารายละเอียดของส่วนจะขึ้นอยู่กับระยะทางจากกล้องดังที่ได้อธิบายไว้ในตารางด้านล่างนี้。

<table>
    <thead>
        <tr>
            <th>ระยะจากกล้อง</th>
            <th>ความละเอียดในการเรนเดอร์</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>น้อยกว่า 250 studs</td>
            <td>สูงที่สุด</td>
        </tr>
        <tr>
            <td>250-500 studs</td>
            <td>กลาง</td>
        </tr>
        <tr>
            <td>500 หรือมากกว่า studs</td>
            <td>ต่ำที่สุด</td>
        </tr>
    </tbody>
</table>

PartOperation.RenderFidelity

ระดับของรายละเอียดที่ใช้ในการเรนเดอร์ส่วนที่จำลองของแข็ง

คุณสมบัตินี้เป็นตัวแทนของมุมในองศาสำหรับค่าเกณฑ์ระหว่าง
_n_ ที่วัดบนส่วน [การจำลองของแข็ง](/parts/solid-modeling) 。
ถ้าความแตกต่างของนอร์มาลน้อยกว่าค่านั้น นอร์มาลจะถูกปรับเพื่อทำให้ความแตกต่างเรียบขึ้น。 ขณะที่ค่าในช่วงระหว่าง 30 ถึง 70 องศามักจะให้ผลลัพธ์ที่ดี แต่ค่าในช่วงระหว่าง 90 ถึง 180 แนะนำว่าไม่ควรใช้เนื่องจากอาจทำให้เกิดเอฟเฟกต์ "ทำให้มืด" บนยูเนียนที่มีขอบคม。

โปรดทราบว่าการทำให้เรียบไม่มีผลต่อปาร์คระหว่างวัสดุต่างๆ หรือสีที่แตกต่างกัน。

<figure>
<img
src="../../../assets/modeling/solid-modeling/CSG-SmoothingAngle-0.jpg" width="400"
alt="ส่วนจำลองของแข็งที่มี SmoothingAngle เป็น 0" />
<figcaption><code>Class.PartOperation.SmoothingAngle|SmoothingAngle</code>
= 0</figcaption>
</figure>
<figure>
<img
src="../../../assets/modeling/solid-modeling/CSG-SmoothingAngle-50.jpg"
width="400" alt="ส่วนจำลองของแข็งที่มี SmoothingAngle เป็น 50" />
<figcaption><code>Class.PartOperation.SmoothingAngle|SmoothingAngle</code>
= 50</figcaption>
</figure>

PartOperation.SmoothingAngle

มุมในองศาที่มีผลต่อการให้แสงที่เรียบของส่วนจำลองของแข็ง

จำนวนโพลิกอนในโมเดลของแข็งนี้

PartOperation.TriangleCount

ตั้งค่าให้ `Class.PartOperation` สามารถเปลี่ยนสีได้โดยใช้
คุณสมบัติ `Class.BasePart.Color` หรือ `Class.BasePart.BrickColor` เมื่อ
true, ยูเนียนทั้งหมดจะถูกเปลี่ยนสีตาม `Class.BasePart.Color|Color`
หรือ `Class.BasePart.BrickColor|BrickColor` เมื่อ false, ส่วนในยูเนียนจะรักษาสีพื้นฐานเดิมจากก่อนที่การทำงานของหัวหอมจะถูกดำเนินการ

PartOperation.UsePartColor

ตั้งค่าให้ `Class.PartOperation` สามารถเปลี่ยนสีได้โดยใช้
คุณสมบัติสีที่สืบทอด

คลาสเบื้องต้นที่ส่วนทั้งหมดที่อิงจากการจำลองของแข็งสืบทอดมาจาก

TriangleMeshPart เป็นคลาสกลางที่เป็นนามธรรมที่ `Class.MeshPart`
และ `Class.PartOperation` สืบทอดมา คลาสนี้ถูกสร้างขึ้นเพื่อรวมการจัดการ
คุณสมบัติทางกายภาพของเรขาคณิตระหว่างสองคลาสย่อยนี้ โดยจะ
ทำการ implement ฟังก์ชันแบบอ่านอย่างเดียว
`Class.TriangleMeshPart.CollisionFidelity|CollisionFidelity`.


TriangleMeshPart

คุณสมบัตินี้กำหนดว่ารูปแบบการชนของ
`Class.TriangleMeshPart` มีความสัมพันธ์กับเรขาคณิตจริงของตาข่ายอย่างไร คุณสมบัตินี้
ไม่สามารถถูกอ่านหรือปรับแก้โดยสคริปต์ในระหว่างการทำงานได้.

ดู [ที่นี่](/workspace/collisions#collision-fidelity) สำหรับ
การแสดงภาพที่แสดงตัวเลือกต่างๆ.


TriangleMeshPart.CollisionFidelity

กำหนดระดับรายละเอียดที่ฟิสิกส์ของชิ้นส่วนจะปฏิบัติตามเรขาคณิตของมัน


กำหนดการแทนที่ทางเรขาคณิตที่ใช้ในการคำนวณแรงอากาศพลศาสตร์
และแรงบิด.


TriangleMeshPart.FluidFidelity

TriangleMeshPart.MeshSize

คลาสกลางที่เป็นนามธรรมที่จัดการคุณสมบัติทางกายภาพของเรขาคณิตสำหรับ
PartOperations และ MeshParts.


สร้างส่วนสีน้ำเงินและส่วนสีแดงเป้าหมาย ส่วนสีน้ำเงินจะพยายามเข้าถึง
ส่วนสีแดงเป้าหมายอย่างราบรื่น เคลื่อนที่และหมุนส่วนเป้าหมายเพื่อดูพฤติกรรม
การเปลี่ยนแปลง smoothTime จะส่งผลให้ความเร็วในการทำให้เรียบที่แตกต่างกัน


`Class.BasePart` เป็นคลาสพื้นฐานแบบป Abstract สำหรับวัตถุในโลกที่แสดงผล
และจำลองทางกายภาพในขณะที่อยู่ใน `Class.Workspace` มีการใช้งานหลายรูปแบบ
ของ `Class.BasePart` โดยทั่วไปแล้วจะมีการใช้งานบ่อยที่สุดคือ `Class.Part` และ
`Class.MeshPart` รูปแบบอื่น ๆ ได้แก่ `Class.WedgePart`, `Class.SpawnLocation`, และ
วัตถุซิงเกิ้ลตัน `Class.Terrain` โดยทั่วไปเมื่อมีเอกสารพูดถึง
"ส่วน" การใช้งานส่วนใหญ่ของ `Class.BasePart` จะทำงานได้ไม่เฉพาะเพียง
`Class.Part` เท่านั้น。

สำหรับข้อมูลเกี่ยวกับวิธีที่ `Class.BasePart|BaseParts` ถูกจัดกลุ่ม
เป็นร่างจำลองของร่างกายที่แข็งแรงนั้นดูได้ที่ [Assemblies](/physics/assemblies).

มีวัตถุหลายประเภทที่มีปฏิสัมพันธ์กับ `Class.BasePart` (นอกเหนือจาก
`Class.Terrain`) เช่น:

- หลาย ๆ `Class.BasePart|BaseParts` อาจถูกจัดกลุ่มภายใน `Class.Model` และ
  ย้ายพร้อมกันโดยใช้ `Class.PVInstance:PivotTo()` ดูที่
  [Models](/parts/models).
- `Class.Decal` ใช้ภาพที่ขยายตัวบนหน้า `Class.BasePart` ขณะที่ `Class.Texture`
  จะใช้เนื้อภาพตามคำขอโต้ตอบบนหน้า ดูที่ [Textures and Decals](/parts/textures-decals).
- `Class.SurfaceGui` จัดแสดง `Class.GuiObject|GuiObjects` บนหน้าของ
  ส่วน ดูที่
  [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` สามารถถูกเพิ่มไปยัง `Class.BasePart` เพื่อระบุ
  `Datatype.CFrame|CFrames` ที่สัมพันธ์กับส่วน ส่วนเหล่านี้มักถูกใช้โดย
  วัตถุ `Class.Constraint` ทางกายภาพตามที่ได้กล่าวถึงใน
  [Mechanical Constraints](/physics/mechanical-constraints) และ
  [Mover Constraints](/physics/mover-constraints).
- วัตถุ `Class.ParticleEmitter` ปล่อยอนุภาคอย่างสม่ำเสมอในปริมาตรของ
  `Class.BasePart` ที่พวกเขาถูกเป็นพ่อแม่ ดูที่
  [Particle Emitters](/effects/particle-emitters).
- วัตถุแสง เช่น `Class.PointLight` ปล่อยแสงจากกลางของ
  `Class.BasePart` ตามที่แสดงใน
  [Light Sources](/effects/light-sources).
- หากถูกเป็นพ่อแม่ใน `Class.Tool` และตั้งชื่อ **Handle**,
  `Class.BasePart` สามารถถูกถือโดยตัวละคร ดูที่
  [In-Experience Tools](/players/tools).


เกิดขึ้นเมื่อพาร์ตอีกตัวหนึ่งติดต่อกับวัตถุอีกตัว นี่คืออีเวนต์
ที่ส่งข้อมูลไปยังไคลเอนต์เพื่อแจ้งให้ทราบว่าพาร์ตสองตัวชนกัน,
ขณะที่ `Class.BasePart.Touched` จะส่งข้อมูลไปยังเซิร์ฟเวอร์.


BasePart.LocalSimulationTouched

part

เกิดขึ้นหากรูปลักษณ์ของพาร์ตได้รับผลกระทบจากคลาส `Class.Shirt`.


BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

ตัวอย่างรหัสนี้สร้าง BillboardGui บนชิ้นส่วนที่แสดงจำนวนของ
ชิ้นส่วนที่ตอนนี้สัมผัสกับมัน.

ตัวอย่างรหัสนี้สาธิตวิธีการเชื่อมต่อเหตุการณ์ `Class.BasePart.Touched`
ของหลาย ๆ ส่วนใน `Class.Model` เข้ากับฟังก์ชันหนึ่งฟังก์ชัน


อีเวนต์ **Touched** เกิดขึ้นเมื่อพาร์ตติดต่อกับพาร์ตอีกตัวหนึ่ง
ตัวอย่างเช่น หาก **PartA** ชนกับ **PartB** อีเวนต์
`Class.BasePart.Touched|PartA.Touched` จะเกิดขึ้นพร้อมกับ **PartB** และ
`Class.BasePart.Touched|PartB.Touched` จะเกิดขึ้นพร้อมกับ **PartA**.

อีเวนต์นี้จะเกิดขึ้นเฉพาะจากการเคลื่อนไหวทางกายภาพ ดังนั้นมันจะไม่
เกิดขึ้นหากคุณสมบัติ `Class.BasePart.CFrame|CFrame` ถูกเปลี่ยนแปลงทำให้
พาร์ตทับซ้อนกับพาร์ตอีกตัวหนึ่ง ซึ่งหมายความว่าตั้งแต่อย่างน้อยหนึ่งใน
พาร์ตที่เกี่ยวข้องจะต้อง **ไม่** เป็น `Class.BasePart.Anchored|Anchored`
ในช่วงเวลาของการชน.

อีเวนต์นี้ทำงานร่วมกับ
`Class.Workspace.TouchesUseCollisionGroups` เพื่อตั้งค่าว่ากลุ่มการชน
[เลิกใช้งานกลุ่มการชน](/workspace/collisions#collision-filtering)
จะถูกพิจารณาสำหรับการตรวจจับ.


BasePart.Touched

พาร์ตอื่นที่เข้ามาติดต่อกับพาร์ตที่กำหนด.


เกิดขึ้นเมื่อพาร์ตสัมผัสกับพาร์ตอีกตัวหนึ่งจากการเคลื่อนไหวทางกายภาพ.


เกิดขึ้นเมื่อพาร์ตหยุดสัมผัสกับพาร์ตอีกตัวหนึ่งภายใต้เงื่อนไขที่คล้ายกันกับ
`Class.BasePart.Touched`.

อีเวนต์นี้ทำงานร่วมกับ
`Class.Workspace.TouchesUseCollisionGroups` เพื่อตั้งค่าว่ากลุ่มการชน
[เลิกใช้งานกลุ่มการชน](/workspace/collisions#collision-filtering)
จะถูกพิจารณาสำหรับการตรวจจับ.


BasePart.TouchEnded

เกิดขึ้นเมื่อพาร์ตหยุดสัมผัสกับพาร์ตอีกตัวหนึ่งจากการเคลื่อนไหวทางกายภาพ.


ส่งกลับเวกเตอร์แรงบิดในโลกที่ต้องนำไปใช้กับการประกอบของชิ้นส่วนเพื่อให้บรรลุการเร่งเชิงมุมที่กำหนด ผลลัพธ์นี้สามารถใช้เพื่อกำหนดแรงบิดที่ควรนำไปใช้ผ่าน `Class.Torque`
หรือ `Class.BasePart:ApplyAngularImpulse()`.

การคำนวณใช้สมการการหมุนของออยเลอร์ โดยที่ _I_ คือเทนเซอร์ของโมเมนตัมโลกของการประกอบ, _α_ คือการเร่งเชิงมุมที่ต้องการ และ
_ω_ คือความเร็วเชิงมุม.

_τ = I · α + ω × (I · ω)_

หากชิ้นส่วนไม่ใช่ลูกหลานของ `Class.Workspace` เมธอดนี้จะส่งกลับเวกเตอร์ของอนันต. หากการประกอบถูกยึด มันจะส่งกลับเวกเตอร์ของอนันต.

#### ผลกระทบทางเชิงกล

เมื่อการประกอบที่หมุนมีเทนเซอร์ของโมเมนตัมที่ไม่สมมาตร แรงบิดที่จำเป็นในการบรรลุการเร่งเชิงมุมที่กำหนดจะเพิ่มขึ้นเนื่องจากการเปลี่ยนแปลงการจัดเรียงของร่างกาย พารามิเตอร์ `angVelocity` มีไว้เพื่อคำนึงถึงผลกระทบทางเชิงกลนี้ หากถูกละเว้น ผลกระทบทางเชิงกลนี้จะถูกละเว้นจากการคำนวณ.

```lua
local part = workspace.Part
local angularVelocity = part.AssemblyAngularVelocity
local desiredAcceleration = Vector3.new(0, 10, 0)

-- คำนวณแรงบิดที่จำเป็นในการให้การเร่งที่ต้องการ
local torque = part:AngularAccelerationToTorque(desiredAcceleration, angularVelocity)
```


BasePart:AngularAccelerationToTorque

angAcceleration

เวกเตอร์การเร่งเชิงมุมที่ต้องการในโลก.


angVelocity

ความเร็วเชิงมุมปัจจุบันของการประกอบในโลก ค่าดีฟอลต์เป็น `(0, 0, 0)`. ให้ความเร็วเชิงมุมของการประกอบเพื่อคำนึงถึงผลกระทบทางเชิงกล.


เป็น `Datatype.Vector3` ที่แสดงถึงแรงบิดในโลกที่จำเป็นในการผลิตการเร่งเชิงมุมที่กำหนด.


ส่งกลับแรงบิดที่จำเป็นในการบรรลุการเร่งเชิงมุมที่กำหนดในการประกอบของชิ้นส่วนนี้ โดยอาจคำนึงถึงผลทางเชิงกล.


นำแรงกระตุ้นเชิงมุมทันทีไปใช้กับการประกอบของชิ้นส่วนนี้ ทำให้การประกอบหมุน.

ความเร็วเชิงมุมที่เกิดจากแรงกระตุ้นจะขึ้นอยู่กับ `Class.BasePart.AssemblyMass|mass`. ดังนั้นต้องการแรงกระตุ้นที่สูงขึ้นเพื่อขยับการประกอบที่มีมวลมากขึ้น แรงกระตุ้นมีประโยชน์สำหรับกรณีที่ต้องการแรงกระตุ้นทันที เช่นการระเบิดหรือการชน.

หากชิ้นส่วนนี้ถูก [เป็นเจ้าของ](/physics/network-ownership) โดยเซิร์ฟเวอร์ ฟังก์ชันนี้จะต้องถูกเรียกจาก `Class.Script` ที่ทำงานบนเซิร์ฟเวอร์ (ไม่ใช่จาก `Class.LocalScript` หรือ `Class.Script` ที่มี
`Class.BaseScript.RunContext|RunContext` ตั้งค่าเป็น `Enum.RunContext.Client`). หากชิ้นส่วนนี้ถูกเป็นเจ้าของโดยลูกค้าผ่าน- **อัตโนมัติ** การเป็นเจ้าของ ฟังก์ชันนี้สามารถถูกเรียกจากสคริปต์ของลูกค้า **หรือ** สคริปต์ของเซิร์ฟเวอร์; การเรียกมันจากสคริปต์ของลูกค้าสำหรับชิ้นส่วนที่เป็นของเซิร์ฟเวอร์จะไม่มีผล.


BasePart:ApplyAngularImpulse

impulse

เวกเตอร์แรงกระตุ้นเชิงมุมที่จะนำไปใช้กับการประกอบ.


นำแรงกระตุ้นเชิงมุมไปใช้กับการประกอบ.


ฟังก์ชันนี้จะนำแรงกระตุ้นแบบทันทีไปใช้กับการประกอบของชิ้นส่วนนี้.

แรงจะนำไปใช้ที่ `Class.BasePart.AssemblyCenterOfMass|center of mass` ของการประกอบ ดังนั้นการเคลื่อนที่ที่เกิดขึ้นจะเป็นการเคลื่อนที่เชิงเส้นเท่านั้น.

ความเร็วที่เกิดขึ้นจากแรงกระตุ้นจะขึ้นอยู่กับ `Class.BasePart.AssemblyMass|mass` ของการประกอบ ดังนั้นต้องการแรงกระตุ้นที่สูงขึ้นเพื่อขยับการประกอบที่มีมวลมากขึ้น แรงกระตุ้นเหมาะสำหรับกรณีที่คุณต้องการแรงกระตุ้นแบบทันที เช่นการระเบิดหรือการชน.

หากชิ้นส่วนนี้ถูก [เป็นเจ้าของ](/physics/network-ownership) โดยเซิร์ฟเวอร์ ฟังก์ชันนี้ต้องถูกเรียกจาก `Class.Script` ที่ทำงานบนเซิร์ฟเวอร์ (ไม่ใช่จาก `Class.LocalScript` หรือ `Class.Script` ที่มี
`Class.BaseScript.RunContext|RunContext` ตั้งค่าเป็น `Enum.RunContext.Client`). หากชิ้นส่วนนี้ถูกเป็นเจ้าของโดยลูกค้าผ่าน- **อัตโนมัติ** การเป็นเจ้าของ ฟังก์ชันนี้สามารถถูกเรียกจากสคริปต์ของลูกค้า **หรือ** สคริปต์ของเซิร์ฟเวอร์; การเรียกมันจากสคริปต์ของลูกค้าสำหรับชิ้นส่วนที่เป็นของเซิร์ฟเวอร์จะไม่มีผล.


BasePart:ApplyImpulse

เวกเตอร์แรงกระตุ้นเชิงเส้นที่จะนำไปใช้กับการประกอบ.


นำแรงกระตุ้นไปใช้กับการประกอบที่ `Class.BasePart.AssemblyCenterOfMass|center of mass`.


ฟังก์ชันนี้จะนำแรงกระตุ้นทันทีไปใช้กับการประกอบของชิ้นส่วนนี้ ที่ตำแหน่งที่กำหนดในโลก.

หากตำแหน่งไม่ใช่ที่ `Class.BasePart.AssemblyCenterOfMass|center of mass` ของการประกอบ แรงกระตุ้นจะทำให้เกิดการเคลื่อนที่เชิงตำแหน่งและเชิงมุม.

ความเร็วที่เกิดขึ้นจากแรงกระตุ้นจะขึ้นอยู่กับ `Class.BasePart.AssemblyMass|mass` ของการประกอบ ดังนั้นต้องการแรงกระตุ้นที่สูงขึ้นเพื่อขยับการประกอบที่มีมวลมากขึ้น แรงกระตุ้นเหมาะสำหรับกรณีที่นักพัฒนาต้องการนำแรงกระตุ้นไปใช้ทันที เช่นการระเบิดหรือการชน.

หากชิ้นส่วนนี้ถูก [เป็นเจ้าของ](/physics/network-ownership) โดยเซิร์ฟเวอร์ ฟังก์ชันนี้จะต้องถูกเรียกจาก `Class.Script` ที่ทำงานบนเซิร์ฟเวอร์ (ไม่ใช่จาก `Class.LocalScript` หรือ `Class.Script` ที่มี
`Class.BaseScript.RunContext|RunContext` ตั้งค่าเป็น `Enum.RunContext.Client`). หากชิ้นส่วนนี้ถูกเป็นเจ้าของโดยลูกค้าผ่าน- **อัตโนมัติ** การเป็นเจ้าของ ฟังก์ชันนี้สามารถถูกเรียกจากสคริปต์ของลูกค้า **หรือ** สคริปต์ของเซิร์ฟเวอร์; การเรียกมันจากสคริปต์ของลูกค้าสำหรับชิ้นส่วนที่เป็นของเซิร์ฟเวอร์จะไม่มีผล.


BasePart:ApplyImpulseAtPosition

เวกเตอร์แรงกระตุ้นที่จะนำไปใช้กับการประกอบ.


position

ตำแหน่งในโลกที่จะนำแรงกระตุ้นไปใช้.


นำแรงกระตุ้นไปใช้กับการประกอบที่ตำแหน่งที่กำหนด.


ยกเลิกการเชื่อมต่อพื้นผิวใดๆ กับชิ้นส่วนที่อยู่ติดกัน รวมถึง
`Class.Weld` และ `Class.JointInstance` อื่นๆ.


BasePart:BreakJoints

BasePart:breakJoints

ส่งกลับว่าชิ้นส่วนสามารถชนกันได้หรือไม่ ฟังก์ชันนี้คำนึงถึงกลุ่มการชนของสองชิ้นส่วนนี้ ฟังก์ชันนี้จะเกิดข้อผิดพลาดหากชิ้นส่วนที่ระบุไม่ใช่ BasePart.


BasePart:CanCollideWith

ชิ้นส่วนที่ระบุซึ่งกำลังตรวจสอบการชนกัน.


ว่าชิ้นส่วนสามารถชนกันได้หรือไม่.


ส่งกลับว่าชิ้นส่วนสามารถชนกันได้หรือไม่.


ตัวอย่างนี้ตรวจสอบว่าการเป็นเจ้าของเครือข่ายของ `BasePart` แรกที่มีชื่อว่า _Part_ ใน `Workspace` สามารถตั้งค่าได้หรือไม่.

ฟังก์ชัน CanSetNetworkOwnership ตรวจสอบว่าคุณสามารถตั้งค่าการเป็นเจ้าของเครือข่ายของชิ้นส่วนได้หรือไม่.

ค่าที่ส่งกลับจากฟังก์ชันยืนยันว่าคุณสามารถเรียก
`Class.BasePart:SetNetworkOwner()` หรือ
`Class.BasePart:SetNetworkOwnershipAuto()` ได้โดยไม่เกิดข้อผิดพลาด.
มันส่งกลับ true หากคุณสามารถแก้ไข/อ่านการเป็นเจ้าของเครือข่ายได้ หรือส่งกลับ false และเหตุผลว่าทำไมคุณไม่สามารถทำได้ในรูปแบบของสตริง.


BasePart:CanSetNetworkOwnership

คุณสามารถแก้ไขหรืออ่านการเป็นเจ้าของเครือข่ายได้หรือไม่ และเหตุผล.


ตรวจสอบว่าคุณสามารถตั้งค่าการเป็นเจ้าของเครือข่ายของชิ้นส่วนได้หรือไม่.


ส่งกลับจุดที่ใกล้ที่สุดบนพื้นผิวของชิ้นส่วนถึงตำแหน่งในเมืองโลกที่กำหนด หากตำแหน่งที่ให้มาอยู่ภายในชิ้นส่วน จะถูกส่งกลับตามแบบนั้นเลย.

สำหรับ `Class.MeshPart` และ `Class.PartOperation` อินสแตนซ์ วิธีการนี้เคารพค่าของ `Enum.CollisionFidelity` ของชิ้นส่วน. ค่าที่ส่งกลับอาจแตกต่างกันตามว่าขนาดของเมชถูกจัดการเป็นกล่อง, ฮัลล์, หรือรูปแบบที่ซับซ้อนมากขึ้น.


BasePart:GetClosestPointOnSurface

จุดในโลกที่เชื่อมโยงกับจุดพื้นผิวที่ใกล้ที่สุด.


จุดที่ใกล้ที่สุดบนพื้นผิวของชิ้นส่วนในโลก.


ส่งกลับจุดที่ใกล้ที่สุดบนพื้นผิวของชิ้นส่วนถึงจุดที่กำหนด.


ส่งกลับตารางของชิ้นส่วนที่เชื่อมต่อกับวัตถุโดยข้อต่อแบบแข็งทุกประเภท.

หาก `recursive` เป็น true ฟังก์ชันนี้จะส่งกลับทุกชิ้นส่วนในการประกอบที่เชื่อมต่อกันอย่างเหนียวแน่นกับ BasePart.

#### ข้อต่อที่มั่นคง

เมื่อข้อต่อเชื่อมต่อสองชิ้นเข้าด้วยกัน `(Part0 → Part1)` ข้อต่อจะถือว่ามี **ความมั่นคง** หากฟิสิกส์ของ `Part1` ถูกล็อคอย่างสมบูรณ์ โดย `Part0`. สิ่งนี้ใช้ได้กับประเภทของข้อต่อด้านล่างนี้เท่านั้น:

- `Class.Weld`
- `Class.Snap`
- `Class.ManualWeld`
- `Class.Motor`
- `Class.Motor6D`
- `Class.WeldConstraint`


BasePart:GetConnectedParts

recursive

ตารางของชิ้นส่วนที่เชื่อมต่อกับวัตถุโดยข้อต่อใด ๆ
`Class.JointInstance|joint`.


ส่งกลับตารางของชิ้นส่วนที่เชื่อมต่อกับวัตถุโดยข้อต่อแบบแข็งทุกประเภท.


ส่งคืนข้อต่อหรือข้อจำกัดทั้งหมดที่เชื่อมต่อกับชิ้นส่วนนี้.


BasePart:GetJoints

อาร์เรย์ของข้อต่อหรือข้อจำกัดทั้งหมดที่เชื่อมต่อกับชิ้นส่วน.


ตัวอย่างนี้สร้างชิ้นส่วนใหม่ ชื่อ myPart ใน Workspace ของเกม โดยมีขนาด 4x6x4 สตัด ชิ้นส่วนนี้ยังถูกยึดด้วย

จากนั้น myMass จะถูกตั้งค่าให้เท่ากับมวลของชิ้นส่วนใหม่ มวลของชิ้นส่วนจะถูกพิมพ์ที่ท้ายคำสั่ง print:

> มวลของชิ้นส่วนของฉันคือ ...

**GetMass** ส่งกลับค่าของคุณสมบัติที่อ่านได้เพียง `Class.BasePart.Mass|Mass`.

ฟังก์ชันนี้เดิมมีมาก่อนคุณสมบัติ Mass. มันยังคงสนับสนุนเพื่อความเข้ากันได้กับเวอร์ชันก่อนหน้า; คุณควรใช้คุณสมบัติ Mass โดยตรง.


BasePart:GetMass

มวลของชิ้นส่วน.


ส่งกลับค่าของคุณสมบัติ `Class.BasePart.Mass|Mass`.


BasePart:getMass

ส่งกลับผู้เล่นปัจจุบันที่เป็นเจ้าของเครือข่ายของชิ้นส่วนนี้หรือ `nil`
ในกรณีของเซิร์ฟเวอร์.


BasePart:GetNetworkOwner

ผู้เล่นปัจจุบันที่เป็นเจ้าของเครือข่ายของชิ้นส่วนนี้หรือ `nil`
ในกรณีของเซิร์ฟเวอร์.


ส่งกลับ true หากเอนจินเกมกำหนดเจ้าของเครือข่ายโดยอัตโนมัติ
สำหรับชิ้นส่วนนี้.


BasePart:GetNetworkOwnershipAuto

ว่าเอนจินเกมกำหนดเจ้าของเครือข่ายโดยอัตโนมัติสำหรับ
ชิ้นส่วนนี้หรือไม่.


BasePart:GetNoCollisionConstraints

ฟังก์ชันนี้เคยมีความเกี่ยวข้องเมื่อการประนอมล่าช้าใน Roblox เกิดขึ้นภายใน การประนอมตอนนี้จะถูกนำไปใช้กับ `Datatype.CFrame` โดยตรง.


BasePart:GetRenderCFrame

ล้าสมัยแล้ว ส่งกลับ CFrame ที่อธิบายว่าชิ้นส่วนนี้ถูกเรนเดอร์ที่ไหน.


ส่งคืนชิ้นส่วนพื้นฐานจากการประกอบ เมื่อเคลื่อนที่ในการประกอบของชิ้นส่วน
โดยใช้ `Datatype.CFrame`. จำเป็นต้องเคลื่อนที่ชิ้นส่วนพื้นฐานนี้ (นี่จะทำให้ชิ้นส่วนอื่น ๆ ที่เชื่อมต่อกับมันเคลื่อนที่ตามด้วย) ข้อมูลเพิ่มเติมสามารถดูได้ในบทความ [Assemblies](/physics/assemblies).

ฟังก์ชันนี้มีมาก่อนคุณสมบัติ
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` มันยังคงสนับสนุนเพื่อความเข้ากันได้กับเวอร์ชันก่อนหน้า แต่คุณควรใช้
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` โดยตรง.


BasePart:GetRootPart

ชิ้นส่วนพื้นฐานของการประกอบ (การรวมกันของชิ้นส่วนที่เชื่อมต่อกัน).


ส่งคืนชิ้นส่วนพื้นฐานจากการประกอบของชิ้นส่วน.


ส่งคืนตารางของชิ้นส่วนทั้งหมดที่มีการมีปฏิสัมพันธ์ทางกายภาพกับชิ้นส่วนนี้ หากชิ้นส่วนเองมีค่า CanCollide ตั้งเป็น false ฟังก์ชันนี้จะส่งกลับตารางว่างเว้นแต่ชิ้นส่วนนั้นจะมี
`Class.TouchTransmitter|TouchInterest` ที่เป็นพ่อแม่ (หมายถึงบางสิ่งบางอย่างเชื่อมต่อกับเหตุการณ์ Touched ของมัน). ชิ้นส่วนที่อยู่ติดกัน แต่ไม่ตัดกันจะไม่ถือว่าทำการสัมผัส ฟังก์ชันนี้มีมาก่อนฟังก์ชัน `Class.WorldRoot:GetPartsInPart()` ซึ่งให้ความยืดหยุ่นมากขึ้นและหลีกเลี่ยงกฎพิเศษของ
`Class.TouchTransmitter|TouchInterest` ที่อธิบายไว้ด้านบน. ใช้ `Class.WorldRoot:GetPartsInPart()` แทน.


BasePart:GetTouchingParts

ตารางของชิ้นส่วนทั้งหมดที่ตัดกันและสามารถชนกันกับชิ้นส่วนนี้.


ส่งคืนตารางของชิ้นส่วนทั้งหมดที่ `Class.BasePart.CanCollide` เป็นจริงและ
ตัดกันกับชิ้นส่วนนี้.


ส่งคืนความเร็วเชิงเส้นของการประกอบของชิ้นส่วนในตำแหน่งที่กำหนดที
สัมพันธ์กับชิ้นส่วนนี้. สามารถใช้เพื่อระบุความเร็วเชิงเส้นของชิ้นส่วนในการประกอบอื่นนอกจากชิ้นส่วนพื้นฐาน หากการประกอบไม่มีความเร็วเชิงมุม ความเร็วเชิงเส้นจะเหมือนกันเสมอสำหรับทุกตำแหน่ง.


BasePart:GetVelocityAtPosition

ส่งคืนความเร็วเชิงเส้นของการประกอบของชิ้นส่วนในตำแหน่งที่กำหนดที
สัมพันธ์กับชิ้นส่วนนี้.


สร้าง `Class.IntersectOperation` ใหม่จากเรขาคณิตที่ซ้อนทับระหว่างชิ้นส่วนและชิ้นส่วนอื่น ๆ ในอาเรย์ที่กำหนด. รองรับเฉพาะ `Class.Part|Parts`, ไม่ใช่ `Class.Terrain` หรือ `Class.MeshPart|MeshParts`. เช่นเดียวกับ `Class.Instance:Clone()|Clone()` วัตถุที่ส่งกลับไม่มี `Class.Instance.Parent|Parent` ที่กำหนด.

คุณสมบัติจากชิ้นส่วนที่เรียกจะถูกใช้กับ
`Class.IntersectOperation` ที่ส่งกลับ:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

ในภาพเปรียบเทียบต่อไปนี้,
`Class.BasePart:IntersectAsync()|IntersectAsync()` ถูกเรียกบนบล็อกสีม่วงโดยใช้ตารางที่ประกอบด้วยบล็อกสีน้ำเงิน. `Class.IntersectOperation` ที่ส่งกลับจะแปรสภาพเป็นรูปทรงเรขาคณิตที่ซ้อนทับระหว่างชิ้นส่วนทั้งสอง.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="สองบล็อกทับกัน" />
<figcaption>แยกชิ้นส่วน</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg"
width="720" alt="ชิ้นส่วนที่ตัดกันเป็นโมเดลที่มั่นคงใหม่" />
<figcaption>ผลลัพธ์ <code>Class.IntersectOperation</code></figcaption>
</figure>

#### หมายเหตุ

- ชิ้นส่วนดั้งเดิมยังคงอยู่แบบนั้นหลังจากที่การดำเนินการซ้อนทับประสบความสำเร็จ. ในกรณีส่วนใหญ่คุณควรทำลายชิ้นส่วนดั้งเดิมทั้งหมดและตั้งค่าวัตถุ `Class.IntersectOperation` ที่ส่งกลับให้อยู่ในที่เดียวกับ `Class.BasePart` ที่เรียก.
- โดยค่าเริ่มต้น สีของพื้นผิวที่ตัดกันจะยืมมาจากคุณสมบัติ `Class.BasePart.Color|Color` ของชิ้นส่วนดั้งเดิม. หากคุณต้องการเปลี่ยนการตัดทั้งหมดให้เป็นสีที่เฉพาะเจาะจง ให้ตั้งค่าคุณสมบัติ `Class.PartOperation.UsePartColor|UsePartColor` เป็น true.
- หากการดำเนินการซ้อนทับจะส่งผลให้ชิ้นส่วนมีมากกว่า 20,000 สามเหลี่ยม มันจะถูกทำให้เรียบขึ้นเป็น 20,000 สามเหลี่ยม.


BasePart:IntersectAsync

parts

วัตถุที่มีส่วนร่วมในการตัด.


collisionfidelity

ค่าของ `Enum.CollisionFidelity` สำหรับ
`Class.IntersectOperation` ที่เกิดขึ้น.


renderFidelity

ค่าของ `Enum.RenderFidelity` สำหรับ
`Class.PartOperation` ที่เกิดขึ้น.


ผลลัพธ์ `Class.IntersectOperation` ที่มีชื่อเริ่มต้นว่า **Intersect**.


หมายเหตุ: แนะนำให้ใช้ `Class.GeometryService:IntersectAsync` รุ่นใหม่
แทนฟังก์ชันนี้. นอกจากจะมีประสิทธิภาพที่ดีกว่าและมีฟีเจอร์มากมายแล้ว ฟังก์ชันใหม่จะมีความแตกต่างดังนี้:

- ผลลัพธ์จะเป็นอาเรย์ของอินสแตนซ์แทนที่จะเป็นอินสแตนซ์เดียว.
- ชิ้นส่วนอินพุตไม่จำเป็นต้องตั้งอยู่ในฉาก, ซึ่งช่วยให้สามารถดำเนินการในพื้นหลังได้.
- เมื่อกำหนดให้ตัวเลือก `SplitApart` เป็น true (ค่าเริ่มต้น), แต่ละร่างกายที่แตกต่างจะถูกส่งกลับใน `Class.PartOperation` ของมันเอง.
- ชิ้นส่วนที่ถูกส่งกลับทั้งหมดอยู่ในพื้นที่พิกัดของชิ้นส่วนหลัก, ดังนั้นตำแหน่ง `Class.PVInstance.Origin` ของมันจะเหมือนกับของชิ้นส่วนหลัก ซึ่งรักษาจุดยอดของเมชในตำแหน่งเดียวกันสัมพันธ์กับวัตถุตามก่อนการดำเนินการ, แต่มันยังหมายความว่า `(0, 0, 0)` ของชิ้นส่วนที่ส่งกลับอาจไม่อยู่ที่ศูนย์กลางของร่างกาย.

  สร้าง `Class.IntersectOperation` ใหม่จากเรขาคณิตที่ซ้อนทับของชิ้นส่วนและชิ้นส่วนอื่น ๆ ในอาเรย์ที่กำหนด.


ส่งกลับ true หากวัตถุเชื่อมต่อกับชิ้นส่วนที่จะยึดมันไว้ในที่ (เช่น ชิ้นส่วนที่ `Class.BasePart.Anchored|Anchored`), หรือส่งกลับ false. ในการประกอบที่มีชิ้นส่วน `Class.BasePart.Anchored|Anchored`, ชิ้นส่วนอื่นๆ ทั้งหมดจะถูกยึด.


BasePart:IsGrounded

ว่าวัตถุเชื่อมต่อกับชิ้นส่วนซึ่งจะยึดมันไว้ในที่.


ส่งกลับ true หากวัตถุเชื่อมต่อกับชิ้นส่วนที่จะยึดมันไว้ในที่ (เช่น ชิ้นส่วนที่ `Class.BasePart.Anchored|Anchored`), หรือส่งกลับ false.


สร้างข้อต่อในด้านใด ๆ ของ `Class.BasePart|Part` ที่มี `Enum.SurfaceType` ที่สามารถสร้างข้อต่อได้, มันจะสร้างข้อต่อกับชิ้นส่วนที่อยู่ติดกัน.

ข้อต่อจะถูกสร้างระหว่างด้านและพื้นผิวที่สัมผัสกัน ขึ้นอยู่กับพื้นผิวของด้าน.

- พื้นผิวเรียบจะไม่สร้างข้อต่อ
- พื้นผิวกาวจะสร้างข้อต่อ `Class.Glue`
- ข้อต่อที่จะสร้าง `Class.Weld` กับทุกพื้นผิวยกเว้น 
  Unjoinable
- Studs, Inlet หรือ Universal จะสร้างข้อต่อ `Class.Snap` กับอีกพื้นผิวหนึ่ง (เช่น Studs กับ Inlet และ
  Universal)
- พื้นผิว Hinge และ Motor จะสร้างอินสแตนซ์ข้อต่อ `Class.Rotate` และ `Class.RotateV`

แตกต่างจาก `Class.Model:MakeJoints()`, ฟังก์ชันนี้ต้องการอาร์เรย์ของ
ชิ้นส่วนเป็นพารามิเตอร์. อาร์เรย์นี้ให้มาเป็นดังนี้:

```
part:MakeJoints({part1, part2, part3})
```
ข้อต่อจะถูกทำลายหากมีแรงมากพอถูกนำไปใช้กับพวกเขาเนื่องจาก `Class.Explosion` เว้นแต่มีวัตถุ `Class.ForceField` แม่อยู่ใน `Class.BasePart` หรือ `Class.Model` บรรพบุรุษ. ด้วยเหตุนี้มันจึงมักถูกใช้ในการสร้างอาคารที่สามารถทำลายได้ง่ายและโมเดลอื่น ๆ.


BasePart:MakeJoints

สร้างข้อต่อในด้านใดก็ได้ของวัตถุที่มี ID พื้นผิวที่สามารถสร้างข้อต่อได้.


BasePart:makeJoints

เปลี่ยนขนาดของวัตถุเหมือนกับการใช้เครื่องมือปรับขนาดในสตูดิโอ.


BasePart:Resize

normalId

ด้านที่จะปรับขนาด.


deltaAmount

ขนาดที่ต้องการขยาย/ย่อในด้านที่กำหนด.


ว่าชิ้นส่วนถูกปรับขนาดแล้วหรือไม่.


BasePart:resize

ตั้งค่าผู้เล่นที่กำหนดเป็นเจ้าของเครือข่ายสำหรับชิ้นส่วนนี้และชิ้นส่วนที่เชื่อมต่อทั้งหมด.
เมื่อ playerInstance เป็น `nil` เซิร์ฟเวอร์จะเป็นเจ้าของแทนผู้เล่น.


BasePart:SetNetworkOwner

playerInstance

ผู้เล่นที่จะให้การเป็นเจ้าของเครือข่ายของชิ้นส่วน.


ตั้งค่าผู้เล่นที่กำหนดเป็นเจ้าของเครือข่ายสำหรับชิ้นส่วนนี้และชิ้นส่วนที่เชื่อมต่อทั้งหมด.


ให้เอนจินเกมตัดสินใจแบบไดนามิกว่าจะจัดการฟิสิกส์ของชิ้นส่วนอย่างไร
(หนึ่งในลูกค้าหรือเซิร์ฟเวอร์).


BasePart:SetNetworkOwnershipAuto

ตัวอย่างนี้แสดงให้เห็นวิธีการลบชิ้นส่วนจากอีกชิ้นส่วนหนึ่ง
`Class.BasePart` เพื่อสร้าง `Class.UnionOperation` ที่ถูกปฏิเสธ

สร้าง `Class.UnionOperation` ใหม่จากชิ้นส่วน, ลบเรขาคณิตที่ถูกครอบครองโดยชิ้นส่วนในอาเรย์ที่กำหนด. รองรับเฉพาะ `Class.Part|Parts`, ไม่ใช่ `Class.Terrain` หรือ `Class.MeshPart|MeshParts`. เช่นเดียวกับ `Class.Instance:Clone()|Clone()` วัตถุที่ส่งกลับไม่มี `Class.Instance.Parent|Parent` ที่กำหนด.

หมายเหตุว่าผลลัพธ์ยูเนียนไม่สามารถว่างเปล่าเนื่องจากการตัดขาด หากการดำเนินการจะส่งผลให้เกิดเรขาคณิตที่ว่างเปล่า มันจะล้มเหลว.

ในภาพเปรียบเทียบต่อไปนี้,
`Class.BasePart:SubtractAsync()|SubtractAsync()` ถูกเรียกบนกระบอกสีฟ้าโดยใช้ตารางที่ประกอบด้วยบล็อกสีม่วง. `Class.UnionOperation` ที่ส่งกลับจะแปรสภาพเป็นรูปทรงที่ละเว้นเรขาคณิตของบล็อก.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg"
width="720" alt="บล็อกยาวทับซ้อนกับกระบอก" />
<figcaption>แยกชิ้นส่วน</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720"
alt="บล็อกถูกตัดออกจากกระบอก" />
<figcaption>ผลลัพธ์ <code>Class.UnionOperation</code></figcaption>
</figure>


BasePart:SubtractAsync

วัตถุที่มีส่วนร่วมในการลบ.


ค่าของ `Enum.CollisionFidelity` สำหรับ
`Class.UnionOperation` ที่เกิดขึ้น.


ผลลัพธ์ `Class.UnionOperation` ที่มีชื่อเริ่มต้นว่า **Union**.


หมายเหตุ: แนะนำให้ใช้ `Class.GeometryService:UnionAsync` รุ่นใหม่
แทนฟังก์ชันนี้. นอกจากจะมีประสิทธิภาพที่ดีกว่าและมีฟีเจอร์มากมายแล้ว ฟังก์ชันใหม่จะมีความแตกต่างดังนี้:

- ผลลัพธ์จะเป็นอาเรย์ของอินสแตนซ์แทนที่จะเป็นอินสแตนซ์เดียว.
- ชิ้นส่วนอินพุตไม่จำเป็นต้องตั้งอยู่ในฉาก ซึ่งช่วยให้สามารถดำเนินการในพื้นหลังได้.
- เมื่อกำหนดให้ตัวเลือก `SplitApart` เป็น true (ค่าเริ่มต้น) แต่ละร่างกายที่แตกต่างจะถูกส่งกลับใน `Class.PartOperation` ของตัวมันเอง.
- ชิ้นส่วนที่ถูกส่งคืนทั้งหมดอยู่ในพื้นที่พิกัดของชิ้นส่วนหลัก ดังนั้นตำแหน่ง `Class.PVInstance.Origin` ของมันจะเหมือนกับของชิ้นส่วนหลัก ซึ่งรักษาจุดยอดของเมชในตำแหน่งเดียวกันสัมพันธ์กับวัตถุตามก่อนการดำเนินการ แต่มันยังหมายความว่า `(0, 0, 0)` ของชิ้นส่วนที่ส่งกลับอาจไม่อยู่ที่ศูนย์กลางของร่างกาย.

  สร้าง `Class.UnionOperation` ใหม่จากชิ้นส่วน, ลบเรขาคณิตที่ถูกครอบครองโดยชิ้นส่วนในอาเรย์ที่กำหนด.


ส่งกลับการเร่งเชิงมุมในพื้นที่โลกที่เกิดจากการใช้แรงบิดที่กำหนดกับการประกอบของชิ้นส่วนนี้ โดยอาจคำนึงถึงผลกระทบทางเชิงกล.

นี่คือค่าที่เป็นอันตรายต่อ `Class.BasePart:AngularAccelerationToTorque()`. มันมีประโยชน์ในการคาดการณ์ว่าการประกอบจะตอบสนองอย่างไรต่อแรงบิดที่ใช้.

การคำนวณใช้:

**α = I⁻¹ · (τ − ω × (I · ω))**

โดยที่ **I** คือเทนเซอร์ของโมเมนตัมโลกของการประกอบ, **τ** คือแรงบิดที่ใช้ และ **ω** คือความเร็วเชิงมุม.

หากชิ้นส่วนไม่ใช่ลูกหลานของ `Class.Workspace` ส่งคืน `(0, 0, 0)`. หากการประกอบถูกยึด ส่งคืน `(0, 0, 0)`.

#### ผลกระทบทางเชิงกล

เมื่อการประกอบที่หมุนมีเทนเซอร์ของโมเมนตัมที่ไม่สมมาตร การเร่งที่เกิดจากแรงบิดที่ใช้จะขึ้นอยู่กับความเร็วเชิงมุมปัจจุบันด้วย พารามิเตอร์ `angVelocity` ใช้เพื่อคำนึงถึงผลกระทบทางเชิงกลนี้ หากถูกละเว้น (ค่าดีฟอลต์เป็นศูนย์) ผลลัพธ์จะไม่คำนึงถึงส่วนนี้.

```lua
local part = workspace.Part
local angularVelocity = part.AssemblyAngularVelocity
local appliedTorque = Vector3.new(0, 100, 0)

-- คาดการณ์การเร่งเชิงมุมจากแรงบิดนี้
local angAccel = part:TorqueToAngularAcceleration(appliedTorque, angularVelocity)
```


BasePart:TorqueToAngularAcceleration

torque

เวกเตอร์แรงบิดที่นำไปใช้กับการประกอบในโลก.


เป็น `Datatype.Vector3` แสดงถึงการเร่งเชิงมุมที่เกิดขึ้นในโลก.


ส่งกลับการเร่งเชิงมุมที่เกิดจากการใช้แรงบิดที่กำหนดกับการประกอบของชิ้นส่วนนี้ โดยอาจคำนึงถึงผลกระทบทางเชิงกล.


ตัวอย่างนี้แสดงให้เห็นถึงวิธีการรวมเรขาคณิตของ `Class.BasePart`
กับเรขาคณิตของส่วนอื่น ๆ เพื่อสร้าง `Class.UnionOperation`.

สร้าง `Class.UnionOperation` ใหม่จากส่วนที่เป็นพาร์ต รวมถึงเรขาคณิต
ที่ถูกใช้โดยพาร์ตในอาร์เรย์ที่ให้มา ใช้ได้เพียง `Class.Part|Parts`
ไม่ใช่ `Class.Terrain` หรือ `Class.MeshPart|MeshParts` คล้ายกับ
`Class.Instance:Clone()|Clone()` วัตถุที่ส่งคืนไม่มีการตั้งค่า
`Class.Instance.Parent|Parent`.

คุณสมบัติต่อไปนี้จากพาร์ตที่เรียกใช้ถูกนำไปใช้กับ
`Class.UnionOperation` ที่ได้:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

ในการเปรียบเทียบรูปภาพต่อไปนี้,
`Class.BasePart:UnionAsync()|UnionAsync()` ถูกเรียกใช้บนบล็อคสีน้ำเงิน
โดยใช้ตารางที่ประกอบด้วยกระบอกสีม่วง ผลลัพธ์
`Class.UnionOperation` จะเป็นรูปร่างที่รวมเรขาคณิตของ
ทั้งสองพาร์ต.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg"
width="720" alt="บล็อคและกระบอกพาร์ตทับซ้อนกัน" />
<figcaption>พาร์ตแยก</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720"
alt="พาร์ตที่ถูกจับรวมกันเป็นยูเนียนเดียวกัน" />
<figcaption>ผลลัพธ์ของ <code>Class.UnionOperation</code></figcaption>
</figure>

#### หมายเหตุ

- พาร์ตเดิมยังคงสมบูรณ์หลังจากการดำเนินการยูเนียนที่ประสบความสำเร็จ.
  ในกรณีส่วนใหญ่ คุณควรใช้ `Class.Instance.Destroy|Destroy()` กับพาร์ต
  เดิมทั้งหมดและรวบรวม `Class.UnionOperation` ที่ส่งคืนไปยัง
  ที่เดิมเดียวกับ `Class.BasePart` ที่เรียกใช้.
- ตามค่าเริ่มต้น ยูเนียนที่ได้รับจะเคารพ
  คุณสมบัติ `Class.BasePart.Color|Color` ของแต่ละพาร์ต หากต้องการเปลี่ยน
  ยูเนียนทั้งหมดเป็นสีเฉพาะ ให้ตั้งค่า
  คุณสมบัติ `Class.PartOperation.UsePartColor|UsePartColor` เป็น `true`.
- หากการดำเนินการยูเนียนจะส่งผลให้เกิดพาร์ตด้วยจำนวนสามเหลี่ยมมากกว่า 20,000
  สามเหลี่ยม จะถูกทำให้เรียบง่ายเป็น 20,000 สามเหลี่ยม.


BasePart:UnionAsync

วัตถุที่เข้าร่วมในยูเนียนกับพาร์ตที่เรียกใช้.


ค่า `Enum.CollisionFidelity` สำหรับผลลัพธ์
`Class.UnionOperation`.


ค่า `Enum.RenderFidelity` ของผลลัพธ์
`Class.PartOperation`.


หมายเหตุ: แนะนำให้ใช้ `Class.GeometryService:UnionAsync` รุ่นใหม่
แทนฟังก์ชันนี้. นอกจากจะมีประสิทธิภาพที่ดีกว่าและมีฟีเจอร์มากมายแล้ว ฟังก์ชันใหม่จะมีความแตกต่างดังนี้:

- ผลลัพธ์จะเป็นอาเรย์ของอินสแตนซ์แทนที่จะเป็นอินสแตนซ์เดียว.
- ชิ้นส่วนอินพุตไม่จำเป็นต้องตั้งอยู่ในฉาก, ซึ่งช่วยให้สามารถดำเนินการในพื้นหลังได้.
- เมื่อกำหนดให้ตัวเลือก `SplitApart` เป็น true (ค่าเริ่มต้น), แต่ละร่างกายที่แตกต่างจะถูกส่งกลับใน `Class.PartOperation` ของมันเอง.
- ชิ้นส่วนที่ถูกส่งกลับทั้งหมดอยู่ในพื้นที่พิกัดของชิ้นส่วนหลัก, ดังนั้นตำแหน่ง `Class.PVInstance.Origin` ของมันจะเหมือนกับของชิ้นส่วนหลัก ซึ่งรักษาจุดยอดของเมชในตำแหน่งเดียวกันสัมพันธ์กับวัตถุตามก่อนการดำเนินการ แต่มันยังหมายความว่า `(0, 0, 0)` ของชิ้นส่วนที่ส่งกลับอาจไม่อยู่ที่ศูนย์กลางของร่างกาย.

        สร้างการดำเนินการ `Class.UnionOperation` ใหม่จากชิ้นส่วน, รวมเรขาคณิตที่ถูกครอบครองโดยชิ้นส่วนในอาเรย์ที่กำหนด.


BasePart

ตัวอย่างโค้ดนี้จะอนุญาตให้คลิกที่ส่วนเพื่อเปลี่ยนคุณสมบัติ anchored
ของมัน เมื่อตั้งค่าแล้ว ลักษณะทางกายภาพของส่วนจะถูกปรับปรุง (สีแดง
หมายถึง anchored, สีเหลืองหมายถึงอิสระ).


คุณสมบัติ `Anchored` กำหนดว่าส่วนจะไม่สามารถเคลื่อนที่ได้โดย
ฟิสิกส์เมื่อมีการเปิดใช้ เมื่อเปิดใช้งานแล้วส่วนนี้จะไม่เปลี่ยนตำแหน่ง
เนื่องจากแรงดึงดูด การชนกับส่วนอื่น ๆ การซ้อนทับกับส่วนอื่น ๆ หรือสาเหตุ
ที่เกี่ยวข้องกับฟิสิกส์อื่น ๆ ด้วยเหตุนี้สองส่วนที่ถูกยึดจะไม่เคย
สร้างเหตุการณ์ `Class.BasePart.Touched|Touched` บนกันและกัน

ส่วนที่ถูกยึดอาจยังคงถูกเคลื่อนที่ได้โดยการเปลี่ยน
`Class.BasePart.CFrame|CFrame` หรือ `Class.BasePart.Position|Position` และ
มันยังอาจมีค่าที่ไม่เป็นศูนย์ใน
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` และ
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity`.

สุดท้ายหากส่วนที่ไม่ได้ยึดถูกเชื่อมโยงกับส่วนที่ถูกยึดผ่าน
วัตถุเช่น `Class.Weld` มันก็จะทำหน้าที่เหมือนยึด หากการเชื่อมต่อ
เช่นนั้นแตก จะทำให้ส่วนนี้อาจได้รับผลกระทบจากฟิสิกส์อีกครั้ง ดู
[Assemblies](/physics/assemblies) สำหรับรายละเอียดเพิ่มเติม

การเป็นเจ้าของเครือข่ายไม่สามารถตั้งค่าได้ในส่วนที่ถูกยึด หากสถานะการยึด
ของส่วนเปลี่ยนแปลงในเซิร์ฟเวอร์ การเป็นเจ้าของเครือข่ายของส่วนนี้จะได้รับผล


BasePart.Anchored

กำหนดว่าส่วนจะไม่สามารถเคลื่อนที่ได้โดยฟิสิกส์หรือไม่。


เวกเตอร์ความเร็วเชิงมุมของการประกอบของส่วนนี้ เป็นอัตราที่
การเปลี่ยนแปลงของการหันในเรเดียนต่อวินาที。

ความเร็วเชิงมุมจะเหมือนกันทุกจุดในที่ประกอบ。

การตั้งค่าความเร็วโดยตรงอาจทำให้เกิดการเคลื่อนไหวที่ไม่สมจริง การใช้
`Class.Torque` หรือ `Class.AngularVelocity` เป็นสิ่งที่แนะนำ หรือใช้
`Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` หากคุณต้องการ
การเปลี่ยนแปลงความเร็วทันที

หากส่วนเป็น [owned](/physics/network-ownership) โดยเซิร์ฟเวอร์
คุณสมบัตินี้ต้องถูกเปลี่ยนแปลงจาก `Class.Script` ของเซิร์ฟเวอร์ (ไม่ใช่
จาก `Class.LocalScript` หรือ `Class.Script` ที่มี
`Class.BaseScript.RunContext|RunContext` ตั้งค่าเป็น `Enum.RunContext.Client`).
หากส่วนนี้ถูกเป็นเจ้าของโดยลูกค้าผ่านการเป็นเจ้าของ **อัตโนมัติ**
คุณสมบัตินี้สามารถถูกเปลี่ยนแปลงจากสคริปต์ของลูกค้า **หรือ** สคริปต์
ของเซิร์ฟเวอร์ การเปลี่ยนแปลงจากสคริปต์ของลูกค้าสำหรับส่วนที่เป็นเจ้าของโดยเซิร์ฟเวอร์จะไม่มีผล


BasePart.AssemblyAngularVelocity

ความเร็วเชิงมุมของการประกอบของส่วน。


ตำแหน่งที่คำนวณผ่าน `Class.BasePart.Mass|Mass` และ
`Class.BasePart.Position|Position` ของส่วนทั้งหมดในที่ประกอบ。

หากที่ประกอบมีส่วนที่ถูกยึด จุดกึ่งกลางของมวลของส่วนนี้จะเป็น
จุดกึ่งกลางของมวลของที่ประกอบ และที่ประกอบจะมีมวลไม่สิ้นสุด。

การรู้จุดกึ่งกลางของมวลสามารถช่วยให้ที่ประกอบคงความเสถียร จุด
แรงที่กระทำที่กึ่งกลางมวลจะไม่ทำให้เกิดการเร่งเชิงมุม เท่านั้นจะทำให้เกิดการเร่งเชิงเส้น
ที่ประกอบที่มีจุดกึ่งกลางมวลต่ำจะคงความตั้งได้ดีขึ้นเมื่อต้องมีแรงของแรงดึงดูด


BasePart.AssemblyCenterOfMass

จุดกึ่งกลางของมวลของการประกอบของส่วนในพื้นที่โลก。


เวกเตอร์ความเร็วเชิงเส้นของการประกอบของส่วนนี้ เป็นอัตราที่
การเปลี่ยนแปลงในตำแหน่งของ
`Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` ในสตั๊ดต่อวินาที。

หากคุณต้องการรู้ความเร็วที่จุดอื่นนอกจากจุดกึ่งกลางของมวลให้ใช้
`Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

การตั้งค่าความเร็วโดยตรงอาจทำให้เกิดการเคลื่อนไหวที่ไม่สมจริง การใช้
`Class.VectorForce` เป็นสิ่งที่แนะนำ หรือใช้
`Class.BasePart:ApplyImpulse()|ApplyImpulse()` หากคุณต้องการการ
เปลี่ยนแปลงความเร็วทันที

หากส่วนนี้เป็น [owned](/physics/network-ownership) โดยเซิร์ฟเวอร์
คุณสมบัตินี้ต้องถูกเปลี่ยนแปลงจาก `Class.Script` ของเซิร์ฟเวอร์ (ไม่ใช่
จาก `Class.LocalScript` หรือ `Class.Script` ที่มี
`Class.BaseScript.RunContext|RunContext` ตั้งค่าเป็น `Enum.RunContext.Client`).
หากส่วนนี้ถูกเป็นเจ้าของโดยลูกค้าผ่านการเป็นเจ้าของ **อัตโนมัติ**
คุณสมบัตินี้สามารถถูกเปลี่ยนแปลงจากสคริปต์ของลูกค้า **หรือ** สคริปต์
ของเซิร์ฟเวอร์ การเปลี่ยนแปลงจากสคริปต์ของลูกค้าสำหรับส่วนที่เป็นเจ้าของโดยเซิร์ฟเวอร์จะไม่มีผล


BasePart.AssemblyLinearVelocity

ความเร็วเชิงเส้นของการประกอบของส่วน。


ผลรวมของมวลของ `Class.BasePart|BaseParts` ทั้งหมดในที่ประกอบของส่วนนี้
ส่วนที่เป็น `Class.BasePart.Massless|Massless` และไม่ใช่
ส่วนรากของที่ประกอบจะไม่ถือว่าเป็นมวลรวมของ `AssemblyMass`.

หากที่ประกอบมีส่วนที่ถูกยึด มวลของที่ประกอบจะถือว่ามีมวลไม่สิ้นสุด
ข้อจำกัดและปฏิสัมพันธ์ทางฟิสิกส์อื่น ๆ ระหว่างที่ประกอบที่ไม่ถูกยึดที่มีความแตกต่างในมวลขนาดใหญ่\, อาจทำให้เกิดเสถียรภาพไม่แน่นอน


BasePart.AssemblyMass

มวลรวมของการประกอบของส่วน。


คุณสมบัตินี้บ่งบอกถึง `Class.BasePart` ที่ถูกเลือกโดยอัตโนมัติเพื่อ
เป็นตัวแทนของส่วนรากของที่ประกอบ หากส่วนไม่เป็นพ่อแม่ใน
`Class.Workspace` คุณสมบัตินี้จะเป็น `nil`.

ส่วนรากสามารถเปลี่ยนแปลงได้โดยการเปลี่ยน
`Class.BasePart.RootPriority|RootPriority` ของส่วนในที่ประกอบ.

ส่วนทั้งหมดที่แชร์ `AssemblyRootPart` เดียวกันจะอยู่ในที่ประกอบเดียวกัน.

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับส่วนราก ดูที่
[Assemblies](/physics/assemblies).


BasePart.AssemblyRootPart

อ้างอิงไปยังส่วนรากของที่ประกอบ。


`AudioCanCollide` กำหนดว่าหรือไม่ที่จะให้ส่วนมีปฏิสัมพันธ์ทางกายภาพ
กับการจำลองเสียง น้ำเสียงคล้ายกับ `Class.BasePart.CastShadow|CastShadow`
สำหรับแสง。

เมื่อปิดการใช้งาน เสียงจะผ่านส่วน; ไม่ถูกรบกวนหรือ
สะท้อนกลับ。


BasePart.AudioCanCollide

กำหนดว่าหรือไม่ที่จะให้ส่วนมีปฏิสัมพันธ์ทางกายภาพกับการ
จำลองเสียง น้ำเสียงคล้ายกับ `Class.BasePart.CastShadow|CastShadow` สำหรับ
แสง。


คลาสพื้นฐานแบบป Abstract สำหรับวัตถุในโลกที่มีปฏิสัมพันธ์ทางกายภาพ。


/reference/engine/classes/IntersectOperation.yaml