`Class.Actor` เป็นตัวเก็บข้อมูลสำหรับโค้ดที่สามารถแบ่งออกเป็นเธรด
ของตัวเองได้อย่างปลอดภัยโดยใช้ `Library.task.desynchronize()` นอกจากนี้
ยังควรมีอินสแตนซ์ที่ใช้โดยสคริปต์ของมันด้วย

เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับการใช้หลาย Actors เพื่อเพิ่มประสิทธิภาพ
ของสคริปต์ ให้ดูที่
[Parallel Luau](/scripting/multithreading).

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

- แต่ละ `Actor` ทำงานใน Luau VM ของตัวเอง `Class.ModuleScript|ModuleScripts`
  ที่จำเป็นต่อ `Actor` จะ **ไม่** ถูกแชร์หรือแคชข้าม `Actors` หรือ
  กับเธรดหลัก แต่ละ VM จะดำเนินการสำเนาของโมดูลของตัวเอง ดังนั้น
  สถานะระดับโมดูลจะถูกแยกออกต่อ `Actor` ออกแบบให้เหมาะสมหากโมดูล
  ของคุณมีสถานะที่คุณตั้งใจจะแบ่งปัน
- `script:GetActor()` จะส่งกลับ `nil` เมื่อถูกเรียกจาก `Class.ModuleScript`
  เว้นแต่ `ModuleScript` จะเป็นลูกหลานของ `Actor` `ModuleScripts`
  ที่เก็บไว้ที่อื่น (เช่น `Class.ReplicatedStorage`) และจำเป็นต้องใช้โดย
  `Actor` จะไม่ถือว่าเป็นลูกหลานของ `Actor`.


วิธีนี้ใช้เพื่อผูกคอลแบ็ก Luau กับข้อความที่มีหัวข้อที่กำหนด เมื่อข้อความถูกส่ง (โดยใช้
`Class.Actor:SendMessage()|SendMessage()`) ไปยังหัวข้อที่กำหนด คอลแบ็กที่ให้ไว้จะถูกเรียกในบริบทการประมวลผลแบบ _ลำดับ_ 

คอลแบ็ก Luau หลายตัวสามารถถูกผูกเข้ากับนักแสดงตัวเดียวและแม้กระทั่งกับหัวข้อข้อความเดียว

หมายเหตุ: เฉพาะสคริปต์ที่เป็นลูกหลานของ Actor เท่านั้นที่สามารถผูกเข้ากับข้อความของมัน

```lua
local actor = script:GetActor()

-- แสดงข้อความเมื่อข้อความทักทายถูกส่งไปยัง Actor
-- สคริปต์นี้เป็นลูกหลานของ Actor นี้
local connection = actor:BindToMessage("Greeting", function(message)
  print("รับข้อความทักทาย:", message)
end)
```

Actor:BindToMessage

topic

หัวข้อที่ใช้เพื่อระบุประเภทของข้อความ

function

วัตถุการเชื่อมต่อนี้สามารถใช้เพื่อยกเลิกการเชื่อมต่อคอลแบ็ก Luau
จากการรับข้อความ

ผูกคอลแบ็ก Luau กับข้อความที่มีหัวข้อที่กำหนด

วิธีนี้ใช้เพื่อผูกคอลแบ็ก Luau กับข้อความที่มีหัวข้อที่กำหนด เมื่อข้อความถูกส่ง (โดยใช้
`Class.Actor:SendMessage()|SendMessage()`) ไปยังหัวข้อที่กำหนด คอลแบ็กที่ให้ไว้จะถูกเรียกในบริบทการประมวลผลแบบ _ขนาน_ 

คอลแบ็ก Luau หลายตัวสามารถถูกผูกเข้ากับนักแสดงตัวเดียวและแม้กระทั่งกับหัวข้อข้อความเดียว

หมายเหตุ: เฉพาะสคริปต์ที่เป็นลูกหลานของ Actor เท่านั้นที่สามารถผูกเข้ากับข้อความของมัน

```lua
local actor = script:GetActor()

-- แสดงข้อความเมื่อข้อความทักทายถูกส่งไปยัง Actor
-- สคริปต์นี้เป็นลูกหลานของ Actor นี้
local connection = actor:BindToMessageParallel("Greeting", function(message)
  print("รับข้อความทักทาย:", message)
end)
```

Actor:BindToMessageParallel

ส่งข้อความไปยัง Actor ข้อความจะถูกส่งแบบอะซิงโครนัส ดังนั้นผู้ส่งจะไม่
ถูกบล็อกหรือหยุดเมื่อเรียกวิธีการ
`Class.Actor:SendMessage()|SendMessage()`.

เนื่องจาก Actor เดียวสามารถรับข้อความที่แตกต่างกันได้หลายประเภท
พารามิเตอร์ `topic` จึงถูกใช้เพื่อแยกแยะระหว่างข้อความที่แตกต่างกัน.

ดูที่ `Class.Actor:BindToMessage()|BindToMessage()` สำหรับรายละเอียดในการรับ
ข้อความที่ส่งโดยใช้ `Class.Actor:SendMessage()|SendMessage()`.

หมายเหตุว่าพารามิเตอร์ข้อความจะ **ถูกส่งโดยสำเนา** ข้ามขอบเขต
ของ Luau VM ไม่ใช่โดยอ้างอิง การส่งตารางขนาดใหญ่จะมีการทำสำเนาทั้งหมดใน
แต่ละครั้ง ฟังก์ชันจะถูกผูกกับ VM ที่เฉพาะเจาะจงและไม่สามารถส่งใน
ข้อความได้.

```lua
-- สมมติว่า `actor` เป็นตัวแปรท้องถิ่นที่อ้างถึงอินสแตนซ์ของ Actor
actor:SendMessage("Greeting", "Hello World")
```


Actor:SendMessage

หัวข้อที่ใช้เพื่อระบุข้อความที่ถูกส่ง

message

เนื้อหาของข้อความที่จะส่งไปยัง Actor

ส่งข้อความไปยัง Actor

Actor

`Class.Actor` เป็นตัวเก็บข้อมูลสำหรับโค้ดที่สามารถแยกออกได้อย่างปลอดภัยไปยัง
เธรดของตนเอง

ตัวอย่างต่อไปนี้รวมฟังก์ชันพื้นฐานที่รับตารางของออบเจ็กต์
และทำให้พวกมันเป็นพ่อแม่ในโมเดลใหม่ โดยส่งคืนโมเดลนั้น

โมเดลเป็นวัตถุที่ใช้เป็นตัวเก็บข้อมูล ซึ่งหมายถึงการรวบรวมวัตถุเข้าด้วยกัน พวกเขา
เหมาะที่สุดสำหรับการเก็บรวมกลุ่มของ `Class.BasePart|BaseParts` และมีฟังก์ชันมากมาย
ที่เพิ่มความสามารถของพวกเขา。

โมเดลมีวัตถุประสงค์เพื่อแสดงถึงการจัดกลุ่ม **เชิงเรขาคณิต** หากการจัดกลุ่มของคุณไม่มีการตีความเชิงเรขาคณิต เช่น การรวมกลุ่มของ
`Class.Script|Scripts` ให้ใช้ `Class.Folder` แทน。

โมเดลที่มีส่วนประกอบประกอบร่วมกันด้วยข้อต่อ (เพื่อให้พวกเขาสามารถเคลื่อนที่หรือลดก๊าซผ่านการจำลองฟิสิกส์) มักจะมี
`Class.Model.PrimaryPart|PrimaryPart` กำหนดไว้ เนื่องจากมันระบุว่าส่วนใดภายในโมเดลจะ "ตาม" เมื่อโมเดลเคลื่อนที่ กลุ่ม
โมเดลที่อยู่กับที่ซึ่งอยู่กับที่ไม่สามารถรับประโยชน์จากการตั้งค่าชิ้นส่วนหลักได้。

โมเดลมีการใช้งานในช่วงกว้าง รวมถึงตัวละครผู้เล่นใน Roblox。
พวกเขายังมีพฤติกรรมที่ไม่ซ้ำกันมากมายที่สำคัญให้คำนึงถึง:

- เมื่อมี `Class.Humanoid` และ `Class.Part` ที่ชื่อ **Head** ถูกพาเข้ามาใน
  โมเดล GUI ชื่อ/สุขภาพจะปรากฏขึ้นเหนือโมเดล; ดู
  [การแสดงชื่อ/สุขภาพของตัวละคร](/characters/name-health-display)
  สำหรับรายละเอียด。
- หากตำแหน่งของส่วนบนแกน **Y** แตะค่า
  `Class.Workspace.FallenPartsDestroyHeight` และมันเป็นวัตถุสุดท้ายภายใน `Class.Model`
  โมเดลจะถูกทำลายด้วย。
- เมื่อใช้ในที่ที่ `Class.Workspace.StreamingEnabled` เปิดใช้งานอยู่
  ค่า `Class.Model.ModelStreamingMode|ModelStreamingMode` จะควบคุม
  พฤติกรรมต่างๆ เกี่ยวกับวิธีที่โมเดลและบุตรหลานจะถูกทำซ้ำ
  และ/หรือนำออกจากลูกค้า นอกจากนี้แล้วค่า
  `Class.Model.LevelOfDetail|LevelOfDetail` มีผลต่อการเรนเดอร์ของโมเดล。

เช่นเดียวกับทุกประเภท `Class.Instance` ข้อเท็จจริงที่ว่าพ่อแม่ `Class.Model`
ถูกทำซ้ำไปยังลูกค้าไม่ได้รับประกันว่าสิ่งที่อยู่ในนั้นทั้งหมด
จะถูกทำซ้ำ นี่เป็นสิ่งที่สำคัญอย่างยิ่งหากอินสแตนซ์เหล่านี้กำลังถูกเข้าถึงด้วยโค้ดที่ทำงานบนลูกค้า เช่น ใน `Class.LocalScript`。
การใช้ `Class.Model.ModelStreamingMode|ModelStreamingMode` กับค่าเช่น
`Enum.ModelStreamingMode|Atomic` สามารถรับรองได้ว่าโมเดลทั้งหมดและบุตรหลานทั้งหมด
มีอยู่ถ้าพ่อแม่โมเดลมีอยู่ในลูกค้า หรือคุณสามารถใช้ `Class.Instance:WaitForChild()|WaitForChild()` เมื่อไม่ต้องการให้เป็นอะตอม。

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

`Class.Model.ModelStreamingMode|ModelStreamingMode` ต้องตั้งเป็น
`Enum.ModelStreamingMode|PersistentPerPlayer` เพื่อให้เกิดการเปลี่ยนแปลงพฤติกรรม
จากการเพิ่มเติม。

Model:AddPersistentPlayer

playerInstance

ผู้เล่น `Class.Player` ที่ต้องทำให้โมเดลนี้คงอยู่สำหรับเขา。

ตั้งค่าโมเดลนี้ให้คงอยู่สำหรับผู้เล่นที่ระบุ。
`Class.Model.ModelStreamingMode|ModelStreamingMode` ต้องตั้งเป็น
`Enum.ModelStreamingMode|PersistentPerPlayer` เพื่อให้เกิดการเปลี่ยนแปลงพฤติกรรม
จากการเพิ่มเติม。

ในตัวอย่างนี้ ข้อต่อในโมเดลตัวละครของผู้เล่นแต่ละคนจะถูกทำลาย
3 วินาทีหลังจากเกิดขึ้น การทำลายข้อต่อเหล่านี้จะทำให้ Humanoid
ตาย.

ตัวอย่างรหัสนี้แสดงให้เห็นถึงการสร้างจุดเชื่อมด้วยตนเองบนสองชิ้นส่วนที่เป็นพี่น้องของสคริปต์ (PartA และ PartB) มันสร้างจุดเชื่อมบนสองชิ้นส่วนที่สัมผัสกันซึ่งมีประเภทพื้นผิวที่เข้ากันได้ (Studs และ Inlet).

ทำให้การเชื่อมต่อระหว่าง `BaseParts` หลุดออก รวมถึงการเชื่อมต่อพื้นผิวกับ
ส่วนที่อยู่ติดกัน `Class.WeldConstraint|WeldConstraints` และ `Class.Weld|Welds` อื่นๆ
และ `Class.JointInstance|JointInstances`。

เมื่อใช้ BreakJoints กับตัวละครผู้เล่น `Class.Model` `Class.Humanoid`
ของมันจะตายเพราะมันพึ่งพาข้อต่อคอ。

โปรดทราบว่าแม้ว่าจุดเชื่อมที่เกิดจากการเชื่อมต่อพื้นผิวกับส่วนติดกันสามารถ
สร้างขึ้นใหม่ด้วยเทคนิค `Class.Model:MakeJoints()` ได้ แต่จะสร้างจุดเชื่อม
ที่เกิดจากพื้นผิวเท่านั้น ผู้พัฒนาควรไม่พึ่งพา สิ่งนี้เพราะตามหลังการทำลายจุดเชื่อม
ส่วนอาจไม่มีการสัมผัสกันอีกต่อไป。

Model:BreakJoints

ทำให้การเชื่อมต่อระหว่าง `BaseParts` หลุดออก รวมถึงการเชื่อมต่อพื้นผิวกับ
ส่วนที่อยู่ติดกัน `Class.WeldConstraint|WeldConstraints` และ `Class.Weld|Welds` อื่นๆ
และ `Class.JointInstance|JointInstances` ทุกตัว。

Model:breakJoints

ฟังก์ชันนี้คืนค่าคำพูดของปริมาตรที่ประกอบด้วย `Class.BasePart` เด็กทั้งหมด
ภายใน `Class.Model` ทิศทางของปริมาตรขึ้นอยู่กับทิศทางของ `Class.Model.PrimaryPart|PrimaryPart` และตรงกับกล่องการเลือกที่เรนเดอร์ใน Studio
เมื่อโมเดลถูกเลือก การพิจารณาพฤติกรรมของ `Class.Terrain:FillBlock()` มัน
จะคืนค่า `Datatype.CFrame` ซึ่งแสดงถึงจุดศูนย์กลางของกล่องนั้นและ `Datatype.Vector3`
แสดงถึงขนาด เมื่อทำการบังคับทางกายภาพอาจมีข้อผิดพลาด📐ในการทำงานหากข้อจำกัดฟิสิกส์ทำงานต่อต้านส่วนภายใน `Class.Model`。

ทิศทางของกล่องตรงกับทิศทางของ
`Class.PVInstance.GetPivot|Pivot` - จุดหมุนของ `Class.Model.PrimaryPart|PrimaryPart`
(ถ้ามี) หรือ `Class.Model.WorldPivot|WorldPivot` ของโมเดล。

```lua
local Workspace = game:GetService("Workspace")

local model = Workspace.Model
local part = Workspace.Part
local orientation, size = model:GetBoundingBox()

-- ปรับขนาดและตำแหน่งของส่วนเท่ากับกล่องของโมเดล
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

A `Datatype.CFrame` แสดงถึงทิศทางของปริมาตร
ตามด้วย `Datatype.Vector3` แสดงถึงขนาดของปริมาตร。

คืนค่าคำพูดของปริมาตรที่ประกอบด้วยส่วนทั้งหมดของโมเดล。

ตัวอย่างโค้ดด้านล่างแสดงวิธีการใช้ Model.GetExtentsSize เพื่อรับ
ขนาดของกรอบที่มีวัตถุอยู่ภายใน.

คืนค่าขนาดของกล่องที่เล็กที่สุดซึ่งประกอบด้วยส่วนทั้งหมด
`Class.BasePart|BaseParts` ใน `Class.Model` ขนาดจะจัดเรียงตามทิศทางของ `Class.PVInstance.GetPivot|Pivot` - ไจ้ทิศทางที่พบของ `Class.Model.PrimaryPart|PrimaryPart` (ถ้ามี) หรือ `Class.Model.WorldPivot|WorldPivot` ของโมเดล。

โปรดทราบว่าฟังก์ชันนี้จะคืนค่าขนาดของกล่องที่เล็กที่สุดเท่านั้น และ
ผู้พัฒนาต้องใช้วิธีการของตนเองเพื่อให้ได้ตำแหน่งของกล่อง。

Model:GetExtentsSize

ขนาดของ `Datatype.Vector3` ของขนาดของ `Class.Model`。

คืนค่าขนาดของกล่องที่เล็กที่สุดซึ่งประกอบด้วยส่วนทั้งหมด
`Class.BasePart|BaseParts` ใน `Class.Model` โดยจัดเรียงกับ `Class.Model.PrimaryPart` หากตั้งไว้。

ค่าตัวนี้ในอดีตจะคืนค่า CFrame ของตำแหน่งศูนย์กลางในโมเดล。

Model:GetModelCFrame

โค้ดนี้จะสร้างโมเดล ใส่บางส่วนลงในนั้น วางตำแหน่งแบบสุ่ม,
แล้วพิมพ์ขนาดของมัน:

ฟังก์ชัน GetModelSize คืนค่าขนาด `Datatype.Vector3` ของ
`Class.Model`。

Model:GetModelSize

คืนค่าขนาด `Vector3` ของโมเดล。

เมื่อเรียกใช้นี้จาก `Class.Script` จะคืนค่าทุก `Class.Player` ออบเจ็กต์ที่โมเดลนี้\คงอยู่ართสำหรับพวกเขา เมื่อเรียกจาก `Class.LocalScript` ฟังกชันนี้จะตรวจสอบเพียงว่ามีโมเดลนี้คงอยู่สำหรับ
`Class.Players.LocalPlayer|LocalPlayer`。

Model:GetPersistentPlayers

เป็นตารางที่มีออบเจ็กต์ของ `Class.Player` ทั้งหมดที่โมเดลนี้คงอยู่สำหรับพวกเขา。

คืนค่าทุก `Class.Player` ออบเจ็กต์ที่โมเดลนี้คงอยู่สำหรับพวกเขา พฤติกรรมจะแตกต่างกันไป也取决于该方法是从 `Class.Script` 还是 `Class.LocalScript` 被调用。

โค้ดต่อไปนี้จะแสดงให้เห็นว่า GetPrimaryPartCFrame และ
SetPrimaryPartCFrame สามารถใช้ในการหมุนโมเดลได้อย่างไร

โมเดลดั้งเดิมจะถูกสร้างขึ้นใน Workspace และมีการเริ่มลูปที่จะ
หมุนโมเดล 10 องศารอบแกน Y ทุกๆ 0.2 วินาที


ฟังก์ชันนี้ถูกแทนที่ด้วย `Class.PVInstance:GetPivot()` ซึ่งทำหน้าที่แทนที่และไม่เปลี่ยนแปลงพฤติกรรมของโค้ดคุณ ใช้
`Class.PVInstance:GetPivot()` สำหรับการทำงานใหม่ และเปลี่ยนโค้ดที่มีอยู่ `Class.Model:GetPrimaryPartCFrame()` 当方便地。

คืนค่าค่า `Datatype.CFrame` ของ `Class.Model.PrimaryPart` ของโมเดล。

ฟังก์ชันนี้เทียบเท่ากับสิ่งต่อไปนี้。

    Model.PrimaryPart.CFrame

โปรดทราบว่าฟังก์ชันนี้จะโยนข้อผิดพลาดหากไม่มีชิ้นส่วนหลักสำหรับ `Class.Model` หากพฤติกรรมนี้ไม่ต้องการนักพัฒนาสามารถทำตามนี้ ซึ่งองค์ประกอบจะเท่ากับ `nil` หากไม่มีชิ้นส่วนหลัก。

    local cFrame = Model.PrimaryPart and Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

คืนค่า `Datatype.CFrame` ของ `Class.Model.PrimaryPart` ของโมเดล。
ฟังก์ชันนี้จะโยนข้อผิดพลาดหากไม่มีชิ้นส่วนหลักสำหรับ
`Class.Model`。

โค้ดตัวอย่างนี้แสดงให้เห็นการแทนที่ในการแทนที่สำเนาทั้งหมด
ของโมเดลต้นไม้โดยใช้ `Class.Model:PivotTo()` และ `Class.Model:ScaleTo()` การ
หมุนและขนาดของโมเดลจะถูกใช้เป็นข้อมูลอ้างอิงเพื่อให้แน่ใจว่าขนาดและตำแหน่ง
สัมพัทธ์ของโมเดลที่แทนที่ตรงกับต้นฉบับ


โมเดลมีปัจจัยมาตรฐานที่คงอยู่ ซึ่งเริ่มต้นที่ 1 สำหรับโมเดลที่เพิ่งสร้างขึ้น
และเปลี่ยนแปลงเมื่อโมเดลได้รับการปรับขนาดโดยการเรียกใช้
`Class.Model:ScaleTo()` ฟังก์ชันนี้จะคืนค่าปัจจัยมาตรฐานปัจจุบันของโมเดล。

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

ในระยะการใช้งาน โมเดลจะจัดเก็บข้อมูลขนาดดั้งเดิมที่แน่นอนของ
อินสแตนซ์ที่ตั้งอยู่ภายหลังการเรียกใช้ `Class.Model:ScaleTo()` ครั้งแรก สิ่งนี้หมายความว่าเมื่อเรียกใช้งาน
`Class.Model:ScaleTo()|ScaleTo(x)` ตามด้วย
`Class.Model:ScaleTo()|ScaleTo(1)` คุณจะสามารถย้อนกลับไป依旧ที่เป็นต้นฉบับอย่างชัดเจน
โดยไม่ต้องมีการลอยตัวของจุดลอยน้ำ หลีกเลี่ยงการหลุดลอยเป็นแรงจูงใจในการใช้ฟังก์ชัน Scale**To** แทนที่ฟังก์ชัน Scale**By**。

ปัจจัยการปรับขนาดส่งผลต่อพฤติกรรมของเครื่องยนต์ในทางเดียว: ปัจจัยการปรับขนาด
ของโมเดลจะถูกนำไปใช้กับการย้ายข้อต่อของ
`Class.Animation|Animations` ที่เล่นใน `Class.AnimationController`
ภายใต้โมเดลนั้นเพื่อให้การเคลื่อนไหวที่สร้างขึ้นจะเล่นกลับถูกต้องแม้จะมีการปรับขนาดอยู่

Model:GetScale

ปัจจัยมาตรฐานปัจจุบันของโมเดล。

คืนค่าขนาดมาตรฐานของโมเดล ซึ่งค่าเริ่มต้นคือ 1 สำหรับโมเดลที่สร้างขึ้นใหม่
และจะเปลี่ยนแปลงเมื่อมันถูกปรับขนาดโดยการเรียกใช้
`Class.Model:ScaleTo()`。

ตัวอย่างโค้ดนี้แสดงให้เห็นว่าจุดเชื่อมสามารถทำได้อย่างไรโดยใช้ฟังก์ชัน
Model:MakeJoints

โมเดลถูกสร้างขึ้น โดยมีสองส่วนซ้อนทับกัน ส่วนด้านบนถูก
ยึดและส่วนด้านล่างไม่ถูกยึด ตามปกติแล้วเมื่ออยู่ภายใน Workspace
ส่วนล่างจะตกไปที่ Baseplate

อย่างไรก็ตาม เนื่องจากคุณสมบัติ TopSurface ของส่วนล่างถูกตั้งค่าเป็น
Enum.SurfaceType.Weld ซึ่งหมายความว่าเมื่อเรียกใช้ Model:MakeJoints
จะมีการเชื่อมต่อกัน

ดังนั้นส่วนล่างจึงไม่ตกจนกว่าจุดเชื่อมในโมเดลจะถูกทำลาย ซึ่งมักจะทำโดยใช้
Model:BreakJoints แต่ในตัวอย่างนี้การเชื่อมต่อจะถูกทำลายโดยการระเบิด

ตัวอย่างโค้ดนี้จะแสดงการสร้างจุดเชื่อมบนสองชิ้นส่วนที่เป็นพี่น้องกันของสคริปต์ (PartA และ PartB). มันใช้ MakeJoints กับสองชิ้นส่วนที่สัมผัสกันซึ่งมีประเภทพื้นผิวที่เข้ากันได้ (Studs และ Inlet).

การเข้าร่วมตาม Surfacetype ถูกยกเลิกการใช้งาน ห้ามใช้ MakeJoints สำหรับโปรเจ็กต์ใหม่ ใช้
`Class.WeldConstraint|WeldConstraints` และ
`Class.HingeConstraint|HingeConstraints` แทน。

ดำเนินการผ่าน `Class.BasePart|Parts` ทั้งหมดใน `Class.Model` และสร้าง
จุดเชื่อมโยงระหว่างส่วนที่กำหนดและพื้นผิวที่ติดกันตามพื้นผิวของส่วน。

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

ฟังก์ชันนี้ใช้ไม่ได้ถ้าส่วนไม่ใช่บุตรหลานของ `Class.Workspace` ดังนั้นคุณต้องมั่นใจ
ก่อนว่าโมเดลอยู่ใน Workspace ก่อนที่จะใช้ MakeJoints。

Model:MakeJoints

ดำเนินการผ่าน `Class.BasePart|BaseParts` ทั้งหมดใน `Class.Model` หากใด ๆ
ข้างหนึ่งมี Surfacetype ที่สามารถสามารถสร้างจุดเชื่อมต่อได้มันจะสร้างจุดเชื่อมต่อกับ
ส่วนที่อยู่ติดกัน。

Model:makeJoints

Model:move

location

ตัวอย่างนี้แสดงให้เห็นว่า `Class.Model:MoveTo()` หลีกเลี่ยงการชนกันอย่างไร

มีการสร้าง `Class.Model` สองส่วนอย่างง่าย และตั้งค่า `Class.Model.PrimaryPart`
ส่วนใหญ่ของมัน มีการวางชิ้นส่วนอุปสรรคขนาดใหญ่ข้างๆ มัน

หลังจาก 5 วินาที `Class.Model:MoveTo()` ถูกใช้เพื่อกำหนดให้โมเดลย้าย
เข้าไปในชิ้นส่วนอุปสรรค อย่างไรก็ตาม เนื่องจาก MoveTo จะไม่ย้ายโมเดลไปยัง
อุปสรรค `Class.Model` จึงถูกย้ายขึ้นตามแกน Y และวางอยู่เหนือ
the obstruction.


เคลื่อนที่ `Class.Model.PrimaryPart|PrimaryPart` ไปยังตำแหน่งที่กำหนด หาก
ยังไม่ได้ระบุชิ้นส่วนหลักจะใช้ชิ้นส่วนหลักของโมเดล แต่ชิ้นส่วนหลักไม่ได้ทำนายและควรตั้ง
ชิ้นส่วนหลักเสมอเมื่อใช้งาน `Class.Model:MoveTo()|MoveTo()`。

หากมีอุปสรรคที่โมเดลจะถูกเคลื่อนที่ เช่น
`Class.Terrain` หรือ `Class.BasePart|BaseParts` โมเดลจะถูกเคลื่อนที่ขึ้นไปในแนวตั้งจนกระทั่งไม่มีอะไรอยู่ในทาง
หากพฤติกรรมนี้ไม่ต้องการ ควรใช้ `Class.PVInstance:PivotTo()` แทน。

โปรดทราบว่าการหมุนจะไม่ถูกเก็บรักษาไว้เมื่อเคลื่อนที่โมเดลด้วย `Class.Model:MoveTo()|MoveTo()` ควรใช้งาน
`Class.Model:TranslateBy()|TranslateBy()` หรือ `Class.PVInstance:PivotTo()`
หากต้องการเก็บรักษาหมุนปัจจุบันของโมเดลให้คงอยู่

Model:MoveTo

position

ตำแหน่ง `Datatype.Vector3` ซึ่งโมเดล `Class.Model` จะถูกเคลื่อน。

เคลื่อนที่ `Class.Model.PrimaryPart|PrimaryPart` ไปยังตำแหน่งที่กำหนด หาก
ยังไม่ได้ระบุชิ้นส่วนหลัก จะใช้ชิ้นส่วนหลักของโมเดล。

Model:moveTo

ทำให้โมเดลนี้ไม่คงอยู่สำหรับผู้เล่นที่ระบุ สิ่งนี้ไม่รับประกันว่าโมเดลจะถูกนำออกทันทีสำหรับผู้เล่น; หลังจากเรียกใช้งานฟังก์ชันนี้ โมเดลจะถูกปฏิบัติเสมือน
`Enum.ModelStreamingMode|Atomic` สำหรับผู้เล่นนั้นและจะยังคงมีอยู่ตราบใดที่อยู่ภายในรัศมีการสตรีมมิ่งเป้าหมาย。

`Class.Model.ModelStreamingMode|ModelStreamingMode` ต้องตั้งเป็น
`Enum.ModelStreamingMode|PersistentPerPlayer` เพื่อให้เกิดการเปลี่ยนแปลงพฤติกรรม
จากคุณสมบัติที่ถูกลบ。

Model:RemovePersistentPlayer

ผู้เล่น `Class.Player` ที่ต้องทำให้โมเดลนี้ไม่คงอยู่สำหรับเขา。

ทำให้โมเดลนี้ไม่คงอยู่สำหรับผู้เล่นที่ระบุ。
`Class.Model.ModelStreamingMode|ModelStreamingMode` ต้องตั้งเป็น
`Enum.ModelStreamingMode|PersistentPerPlayer` เพื่อให้เกิดการเปลี่ยนแปลงพฤติกรรม
จากการลบ。

รีเซ็ตการหมุนของส่วนของโมเดลกลับไปที่การหมุนระบุเริ่มต้นที่ตั้งค่าไว้ ซึ่งทำได้ผ่าน
ฟังก์ชัน `Class.Model:SetIdentityOrientation()`。

Model:ResetOrientationToIdentity

โมเดลมีปัจจัยมาตรฐานที่คงอยู่ ซึ่งเริ่มต้นที่ 1 สำหรับโมเดลที่สร้างขึ้นใหม่ ฟังก์ชันนี้จะปรับขนาดโมเดล รอบตำแหน่งจุดหมุน ที่สัมพันธ์กับจะมีลักษณะด้วยปัจจัยการปรับขนาดของ 1 สำหรับ
การทำได้สองสิ่ง:

- ตั้งค่าปัจจัยการปรับขนาดของโมเดลในปัจจุบันเป็นค่าที่ยังระบุ
- ปรับขนาดและจัดตำแหน่งอินสแตนซ์ที่เป็นบุตรหลานทั้งหมดตามนั้น

การปรับขนาดตำแหน่งจะเกิดขึ้นรอบตำแหน่งจุดหมุน。

คุณสมบัติทั้งหมดที่ "เชิงเรขาคณิต" ของอินสแตนซ์ที่เป็นบุตรหลานจะถูกปรับขนาด ซึ่ง
แน่นอนรวมถึงขนาดของส่วน แต่ยังมีตัวอย่างของ
คุณสมบัติอื่นๆ ที่ถูกปรับขนาด:

- ความยาวของข้อต่อ เช่น `Class.WeldConstraint|WeldConstraints` และ
  `Class.RopeConstraint`
- ความเร็วและแรงทางกายภาพเช่น `Class.HingeConstraint`
- คุณสมบัติทางมองเห็นเช่นขนาดของเอมิตเตอร์อนุภาค
- คุณสมบัติความยาวอื่นๆ เช่น `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

ตั้งค่าปัจจัยการปรับขนาดของโมเดล โดยปรับขนาดและตำแหน่งของ
อินสแตนซ์ที่เป็นบุตรหลานทั้งหมดเพื่อให้พวกเขามีปัจจัยการปรับขนาดนั้นสัมพันธ์กับ
ขนาดเริ่มต้นและตำแหน่งเมื่อปัจจัยการปรับขนาดคือ 1。

ตั้งค่าการหมุนที่ระบุตัวตนของโมเดลจากที่กำหนด ซึ่งจะทำให้คุณสามารถรีเซ็ตการหมุนของ
โมเดลทั้งหมดในภายหลังได้โดยใช้ฟังก์ชัน
`ResetOrientationToIdentity`。

Model:SetIdentityOrientation

ตั้งค่าการหมุนที่ระบุตัวตนของโมเดลที่ให้ ซึ่งจะทำให้คุณสามารถรีเซ็ตการหมุนของ
โมเดลทั้งหมดในภายหลัง ได้โดยใช้ฟังก์ชัน
`ResetOrientationToIdentity`。

ฟังก์ชันนี้ถูกแทนที่ด้วย `Class.PVInstance:PivotTo()` ซึ่งทำหน้าที่แทนที่และมีประสิทธิภาพกว่าซึ่งไม่เปลี่ยนแปลงพฤติกรรมของโค้ดคุณ ใช้
`Class.PVInstance:PivotTo()` สำหรับการทำงานใหม่และเปลี่ยนโค้ดที่มีอยู่ `Class.Model:SetPrimaryPartCFrame()` เมื่อสะดวก。

ตั้งค่า `Class.BasePart.CFrame` ของ `Class.Model.PrimaryPart` ของโมเดล。
ส่วนอื่น ๆ ในโมเดลจะถูกย้ายด้วยและจะรักษาทิศทางและการเลื่อนที่สัมพันธ์กับ `Class.Model.PrimaryPart`。

โปรดทราบว่าฟังก์ชันนี้จะโยนข้อผิดพลาดหากไม่มี `Class.Model.PrimaryPart`
อยู่สำหรับโมเดล สิ่งนี้อาจทำให้เกิดปัญหาเช่น หากชิ้นส่วนหลักไม่เคยถูกตั้งค่าหรือถูกทำลายไปแล้ว。

Model:SetPrimaryPartCFrame

cframe

ค่าที่ `Datatype.CFrame` ที่จะตั้งค่า。

ตั้งค่า `Class.BasePart.CFrame` ของ `Class.Model.PrimaryPart` ของโมเดล。
ส่วนอื่น ๆ ในโมเดลจะถูกย้ายด้วยและจะรักษาทิศทางและการเลื่อนที่สัมพันธ์กับ `Class.Model.PrimaryPart`。

ตัวอย่างนี้แสดงให้เห็นว่า `Class.Model:TranslateBy()` ไม่สนใจการชนกัน
และเคารพการหันของโมเดล

สร้าง `Class.Model` ที่ประกอบด้วยสองส่วนง่าย ๆ หมุน 45 องศาบนแกน Y
และตั้งค่า `Class.Model.PrimaryPart` ของมัน ส่วนที่มีอุปสรรคขนาดใหญ่
ถูกวางอยู่ข้าง ๆ

หลังจาก 5 วินาที `Class.Model:TranslateBy()` จะถูกใช้เพื่อชี้นำโมเดลให้
เคลื่อนที่เข้าไปในส่วนที่มีอุปสรรค โมเดลจะเคลื่อนเข้าไปใน
สิ่งกีดขวางและรักษาทิศทางปัจจุบันของมันไว้

เคลื่อนที่ `Class.Model` โดยการเลื่อน `Datatype.Vector3` ที่ให้โดยการรักษาทิศทางของโมเดลไว้ หากมี `Class.BasePart` หรือ `Class.Terrain`
อยู่แล้วที่ตำแหน่งใหม่จะทำให้ `Class.Model` ซ้อนทับกับวัตถุที่กล่าวถึง。

การแปลจะถูกนำไปใช้ในโลกแทนที่จะเป็นพื้นที่วัตถุ ทำให้แม้ว่าส่วนภายในของโมเดลจะถูกกำหนดทิศทางแตกต่างกัน มันจะยังคงเคลื่อนที่ตามแกนมาตรฐาน。

Model:TranslateBy

delta

ค่าที่ `Datatype.Vector3` จะเลื่อน `Class.Model`。

เคลื่อนที่ `Class.Model` โดยการเลื่อน `Datatype.Vector3` ที่ให้ โดยการรักษาทิศทางของโมเดลไว้ หากมี `Class.BasePart` หรือ `Class.Terrain` อื่น ๆ อยู่แล้วที่ตำแหน่งใหม่จะทำให้ `Class.Model` ซ้อนทับกับวัตถุที่กล่าวถึง。

Model

ตั้งค่าระดับรายละเอียดของโมเดลสำหรับประสบการณ์ที่เปิดใช้งาน
[การสตรีม](/workspace/streaming) อยู่ Composite หรือ
Imposter meshes ไม่รองรับฟิสิกส์ การตรวจจับการชนกัน หรือ
การเรย์แคสต์

เมื่อตั้งค่าเป็น `Enum.ModelLevelOfDetail|StreamingMesh` โมเดล "imposter"
ที่มีความละเอียดต่ำ (โมเดลที่มีสีและมีผิวพรรณ粗ที่ห่อหุ้มทุกชิ้นส่วนภายในของโมเดล)
จะเรนเดอร์นอกระยะการสตรีม ไม่รองรับ
พื้นผิว

เมื่อตั้งเป็น `Enum.ModelLevelOfDetail|SLIM` โมเดล **SLIM** (โมเดลเชิงโต้ตอบที่สามารถ
ปรับขนาดได้) จะเรนเดอร์ Composite ของทุกชิ้นส่วนเด็กในระดับความละเอียดที่
ต่ำกว่าอย่างค่อยเป็นค่อยไปตามระยะที่อิงจากระยะการสตรีม
สิ่งนี้ช่วยปรับปรุงคุณภาพภาพมากขึ้นเมื่อเปรียบเทียบกับ
`Enum.ModelLevelOfDetail|StreamingMesh`

เมื่อตั้งค่าเป็น `Enum.ModelLevelOfDetail|Disabled` หรือ
`Enum.ModelLevelOfDetail|Automatic` โมเดลที่มีความละเอียดต่ำจะไม่ถูก
แสดง

Model.LevelOfDetail

ตั้งระดับรายละเอียดบนโมเดลสำหรับประสบการณ์ที่มีการสตรีมอินสแตนซ์
เปิดใช้งาน。

ควบคุมวิธีการที่ `Class.Model|Models` จะถูกสตรีมเข้าและออกเมื่อการ
[สตรีมมิ่ง](/workspace/streaming) ถูกเปิดใช้งาน พฤติกรรมขึ้นอยู่กับอีโนมที่เลือก ไม่มีผลเมื่อไม่มีการสตรีมมิ่ง。

ควรเปลี่ยนโปรพอร์ตี้นี้เฉพาะใน Studio ผ่านหน้าต่าง
[Properties](/studio/properties) เมื่อมีการเปิดใช้งานการสตรีมมิ่ง หรือใน `Class.Script|Scripts` แต่ไม่ควรทำใน
`Class.LocalScript|LocalScripts` (การกระทำนี้อาจทำให้เกิดพฤติกรรมที่ไม่ชัดเจนได้)

Model.ModelStreamingMode

ควบคุมพฤติกรรมการสตรีมโมเดลใน `Class.Model|Models` เมื่อ
การสตรีมอินสแตนซ์ถูกเปิดใช้งาน。

ตัวอย่างโค้ดนี้สร้างและโยนแบบจำลองลูกเต๋า จากนั้นแสดงผลว่ามัน
ตกลงมาข้างที่มีสีฟ้าขึ้นบนหรือไม่ หาก `Class.Model.PrimaryPart` ไม่ถูกตั้งค่า
pivot / bounding box ของลูกเต๋าจะหมุน เนื่องจากชิ้นส่วนข้างในนั้น
ถูกจำลองทางกายภาพระหว่างการโยน

ชี้ไปยังชิ้นส่วนหลักของ `Class.Model` ชิ้นส่วนหลักคือ
`Class.BasePart` ที่ทำหน้าที่เป็นการอ้างอิงทางกายภาพสำหรับจุดหมุนของ
โมเดล นั่นหมายความว่า เมื่อส่วนภายในโมเดลถูกเคลื่อนที่เนื่องจากการจำลองฟิสิกส์หรือวิธีการอื่นๆ จุดหมุนจะเคลื่อนที่ตามซิงค์กับชิ้นส่วนหลัก。

โปรดทราบว่า `Class.Model|Models` จะไม่มีการตั้งค่า `PrimaryPart` โดยค่าเริ่มต้น。
หากคุณกำลังสร้างโมเดลที่จำเป็นต้องได้รับความคุ้มครองจากฟิสิกส์ คุณ
ควรตั้งค่านี้ด้วยตนเองใน Studio หรือภายในสคริปต์ หากชิ้นส่วนหลัก **ไม่ได้** ถูกตั้งค่า จุดหมุนจะอยู่ที่ตำแหน่งเดียวใน
โลกถึงแม้ว่าส่วนภายในโมเดลจะเคลื่อนที่。

นอกจากนี้ โปรดทราบว่าการตั้งค่าโปรพอร์ตี้นี้ต้องเป็น `Class.BasePart`
ที่เป็นบุตรหลานของโมเดล หากคุณพยายามตั้งค่า
`Class.Model.PrimaryPart` เป็น `Class.BasePart` ที่ **ไม่** เป็นบุตรหลานของโมเดล เนื่องจากจะถูกตั้งเป็นส่วนที่นั้น แต่จะถูกรีเซ็ตเป็น `nil`
ในระหว่างขั้นตอนการจำลองถัดไป &mdash; นี่คือพฤติกรรมเก่าที่สนับสนุน
สคริปต์ที่สมมุติว่าพวกเขาสามารถตั้งค่าชิ้นส่วนหลักไปที่
`Class.BasePart` ที่ไม่ได้เป็นบุตรหลานของโมเดลชั่วคราวได้。

กฎทั่วไปสำหรับโมเดลคือ:

- โมเดลที่มีส่วนประกอบที่เชื่อมโยงกันผ่านข้อต่อทางกายภาพ เช่น
  `Class.WeldConstraint|WeldConstraints` หรือ `Class.Motor6D|Motor6Ds`
  ควรมีการกำหนดชิ้นส่วนหลัก สำหรับตัวอย่าง เช่น โมเดลตัวละครใน Roblox
  มีการตั้ง `Class.Model.PrimaryPart` ไปที่
  **HumanoidRootPart** โดยค่าเริ่มต้น。
- โมเดลที่นิ่ง (โดยปกติคือ `Class.BasePart.Anchored|Anchored`) ซึ่งอยู่ใน
  ที่เดียวเว้นแต่สคริปต์จะเคลื่อนที่พวกมัน ไม่จำเป็นต้องมี
  `Class.Model.PrimaryPart` และมักจะไม่เกิดประโยชน์จากการมีหนึ่ง。

Model.PrimaryPart

ชิ้นส่วนหลักของ `Class.Model` หรือ `nil` หากไม่ได้ตั้งค่าอย่างชัดเจน。

การตั้งค่าโปรพอร์ตี้นี้ในหน้าต่าง Properties จะปรับขนาดโมเดลเหมือน
กับว่า `Class.Model:ScaleTo()` ถูกเรียกใช้งานบนมัน ปรับขนาดของทุกอินสแตนซ์
ที่เป็นบุตรหลานในโมเดล เช่น วัสดุ รูปภาพ และเรขาคณิต 3D ของ
ส่วน เพื่อให้โมเดลมีปัจจัยการปรับขนาดตามที่กำหนดสัมพันธ์กับขนาด
ดั้งเดิมของมัน。

โปรพอร์ตี้นี้มีเฉพาะใน Studio และจะทำให้เกิดข้อผิดพลาดหากใช้ใน
`Class.Script` หรือ `Class.LocalScript` ควรใช้ `Class.Model:ScaleTo()` และ
`Class.Model:GetScale()` จากสคริปต์。

Model.Scale

โปรพอร์ตี้เฉพาะสำหรับผู้แก้ไขที่ใช้ในการปรับขนาดโมเดลรอบจุดหมุน การตั้ง
โปรพอร์ตี้นี้จะเคลื่อนที่การปรับขนาดเสมือนกับว่า `Class.Model:ScaleTo()` ถูก
เรียกใช้งานบนมัน。

ตัวอย่างโค้ดนี้แสดงฟังก์ชันที่กำหนดเองสำหรับการรีเซ็ตพิวทของโมเดล
กลับไปยังศูนย์กลางของกล่องขอบเขตของโมเดลนั้น


โปรพอร์ตี้นี้กำหนดว่าจุดหมุนของ `Class.Model` ที่ **ไม่มี** การตั้ง
`Class.Model.PrimaryPart` อยู่ที่ไหน หาก
`Class.Model` **มี** `Class.Model.PrimaryPart|PrimaryPart` จุดหมุนของ
`Class.Model` จะเท่ากับจุดหมุนของชิ้นส่วนหลัก และโปรพอร์ตี้นี้
`Class.Model.WorldPivot|WorldPivot` จะถูกละเลย。

สำหรับ `Class.Model` ที่สร้างขึ้นใหม่ จุดหมุนของมันจะถือเป็นจุดศูนย์กลาง
ของกล่องที่มีเนื้อหาจนกระทั่ง **ครั้งแรก** ที่การตั้งค่าของ
`Class.Model.WorldPivot` ถูกตั้งค่า เมื่อตั้งค่าจุดหมุนโลกเป็นครั้งแรกแล้วจะไม่สามารถคืนค่าพฤติกรรมเริ่มต้นนี้ได้

โดยทั่วไป การเคลื่อนที่โมเดลด้วยเครื่องมือใน Studio หรือฟังก์ชันการเคลื่อนที่ของโมเดลเช่น `Class.PVInstance:PivotTo()` และ
`Class.Model:MoveTo()` จะตั้งค่าจุดหมุนโลกและจึงสิ้นสุดพฤติกรรมโมเดลใหม่นี้。

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

```
local Workspace = game:GetService("Workspace")

local model = Instance.new("Model")
Workspace.BluePart.Parent = model
Workspace.RedPart.Parent = model
model.Parent = Workspace

print(model:GetPivot())  -- เท่ากับจุดศูนย์กลางของกล่องที่ประกอบด้วย "BluePart" และ "RedPart"

model:PivotTo(CFrame.new(0, 10, 0))  -- ฟังก์ชันนี้ทำงานโดยไม่ต้องตั้งค่า "model.WorldPivot" อย่างชัดเจน
```

Model.WorldPivot

กำหนดว่า จุดหมุนของ `Class.Model` ที่ **ไม่มี** การตั้งค่า
`Class.Model.PrimaryPart` อยู่ที่ไหน。

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

คลาส `Class.PVInstance` เป็นคลาสนามที่เป็นนามธรรมที่ไม่สามารถสร้างได้ มันคือ
ฐานสำหรับวัตถุทั้งหมดที่มีสถานที่จริงในโลก。


ตัวอย่างโค้ดนี้เป็นสคริปต์การเคลื่อนย้ายที่ง่ายซึ่งย้ายตัวละครของคุณ
10&nbsp;สตูดไปข้างหน้าในทิศทางที่คุณกำลังเผชิญอยู่เมื่อคุณกด
the <kbd>F</kbd> key. มันทำได้โดยการดึงพีวิตปัจจุบันด้วย
`Class.PVInstance:GetPivot()` และเรียก `PVInstance|PivotTo` เพื่อย้าย
ตัวละครไปข้างหน้า.

ฟังก์ชันนี้ดึงจุดหมุนของ `Class.PVInstance` ซึ่งมักจะใช้ร่วมกับ
`Class.PVInstance:PivotTo()` เพื่อย้ายโมเดล。

`Class.Model|Models` และ `Class.BasePart|BaseParts` ต่างก็เป็น
`Class.PVInstance|PVInstances` ("ตำแหน่งความเร็วตัวแปร") และทั้งคู่
มีฟังก์ชันนี้。


PVInstance:GetPivot

ดึงจุดหมุนของ `Class.PVInstance`。


เปลี่ยนแปลง `Class.PVInstance` พร้อมกับ `Class.PVInstance|PVInstances` ทั้งหมดที่เป็นทายาท
โดยที่จุดหมุนจะอยู่ที่ `Datatype.CFrame` ที่ระบุ ฟังก์ชันนี้เป็นฟังก์ชันหลักที่ควรใช้
ในการย้าย `Class.Model|Models` ผ่านการเขียนสคริปต์。

`Class.BasePart|BaseParts` จะถูกย้ายในลักษณะนี้โดยการแปลง
`Datatype.CFrame` ด้วย offset ที่จำเป็น。
`Class.Model|Models` จะถูกย้ายในลักษณะนี้ด้วยการแปลง
`Class.Model.WorldPivot` ด้วย offset ที่จำเป็น。

โปรดทราบว่าเพื่อความมีประสิทธิภาพ เหตุการณ์ `Class.Object.Changed` จะไม่
ถูกเรียกสำหรับ `Class.BasePart.Position|Position` และ
`Class.BasePart.Orientation|Orientation` ของ `Class.BasePart|BaseParts`
ที่ถูกย้ายในลักษณะนี้; มันจะถูกเรียกเฉพาะสำหรับ `Datatype.CFrame`。

เมื่อเรียกใช้ `Class.PVInstance:PivotTo()|PivotTo` บน `Class.Model|Models`，
ค่า offset ของ Parts และ Models ที่เป็นทายาทจะถูกเก็บไว้，ทำให้การเรียกใช้
`Class.PVInstance:PivotTo()|PivotTo` ที่ตามหลังบนโมเดลเดียวกันไม่สะสมการลอยตัวของจุดระหว่าง
Parts ที่ประกอบเป็นโมเดล。 

`Class.Model|Models` และ `Class.BasePart|BaseParts` ทั้งคู่
เป็น `Class.PVInstance|PVInstances` ("ตำแหน่งความเร็วตัวแปร") และทั้งคู่
มีฟังก์ชันนี้。


PVInstance:PivotTo

targetCFrame

`Datatype.CFrame` ที่จุดหมุนของ `Class.PVInstance` ควรเท่ากับ
หลังจากการย้ายมัน。


เปลี่ยนแปลง `Class.PVInstance` พร้อมกับ `Class.PVInstance|PVInstances` ทั้งหมดที่เป็นทายาท
โดยที่จุดหมุนจะอยู่ที่ `Datatype.CFrame` ที่ระบุ。


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

คลาสนามที่เป็นนามธรรมสำหรับวัตถุทั้งหมดที่มีสถานที่จริงในโลก。


`Instance` เป็นคลาสพื้นฐานสำหรับคลาสทั้งหมดในลำดับชั้นคลาส Roblox
ซึ่งสามารถเป็นส่วนหนึ่งของต้นไม้ `Class.DataModel`.

ไม่สามารถสร้างวัตถุ `Instance` รากโดยตรงได้ แต่สร้างวัตถุผ่านโค้ด
ด้วยคอนสตรัคเตอร์พิเศษ `Datatype.Instance.new()` โดยใช้
ชื่อของคลาสเป็นพารามิเตอร์และส่งคืนวัตถุที่สร้างขึ้น.

แสดงให้เห็นถึงการตรวจจับการเปลี่ยนแปลงในเชิงสืบพรรณของอินสแตนซ์ โดยการเชื่อมต่อกับ
`Class.Instance.AncestryChanged` event.

พารต์ ChangingPart จะถูกตั้งค่า Parent เป็นค่าที่แตกต่างกันในช่วงเวลา พ่อแม่ของ
พารต์ คือบรรพบุรุษของพารต์ ดังนั้น `Class.Instance.AncestryChanged` event
จะถูกเรียกใช้เมื่อมันเปลี่ยนแปลง.

เกิดขึ้นเมื่อมีการเปลี่ยนสถานะของอินสแตนซ์นี้ หรือลูกหลานของมัน.

คุณสามารถใช้เหตุการณ์นี้เพื่อติดตามการลบของอินสแตนซ์ใน Studio,
เช่นการลบด้วยตนเองใน Explorer หรือผ่านโปรแกรมเสริม หากคุณต้องการตรวจจับเมื่อใดที่อินสแตนซ์ถูกทำลายโดยการเรียกใช้ `Class.Instance:Destroy()`,
ให้ใช้เหตุการณ์ `Class.Instance.Destroying` แทน.

Instance.AncestryChanged

child

อินสแตนซ์ที่มีการเปลี่ยนแปลงสมบัติ `Class.Instance.Parent|Parent`, ซึ่งอาจเป็นอินสแตนซ์นี้หรือบรรพบุรุษที่ไกลกว่านี้, **ไม่**จำเป็นต้องเป็นอินสแตนซ์ที่เชื่อมต่ออยู่.

parent

พ่อแม่ใหม่ของพารามิเตอร์ `child`.

เกิดขึ้นเมื่อมีการเปลี่ยนแปลงสมบัติ `Class.Instance.Parent` ของวัตถุหรือบรรพบุรุษของมัน.

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

ตัวอย่างเช่น โค้ดต่อไปนี้เชื่อมต่อฟังก์ชัน `attributeChanged()`
เพื่อให้ทำงานเมื่อมีการเปลี่ยนแปลงในคุณสมบัติต่างๆ ของชิ้นส่วน:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "changed")
end

part.AttributeChanged:Connect(attributeChanged)
```
ดูเพิ่มเติมที่ `Class.Instance:GetAttributeChangedSignal()` ซึ่งจะส่งคืนเหตุการณ์ที่เกิดขึ้นเมื่อคุณสมบัติที่เฉพาะเจาะจงเปลี่ยนแปลง.

Instance.AttributeChanged

attribute

ชื่อของคุณสมบัติที่มีการเปลี่ยนแปลง.

เกิดขึ้นเมื่อใดก็ตามที่มีการเปลี่ยนแปลงในคุณสมบัติของ `Class.Instance`.

โค้ดนี้จะแสดงชื่อของวัตถุเมื่อถูกเพิ่มเข้าไปใน Workspace:

เกิดขึ้นหลังจากที่วัตถุถูกเพิ่มเข้าไปใน `Class.Instance` นี้.

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

```
local Workspace = game:GetService("Workspace")

Workspace.ChildAdded:Connect(function(child)
	-- ใช้ WaitForChild() เนื่องจากลูกหลานอาจยังไม่ถูกทำซ้ำ
	local head = child:WaitForChild("Head")
end)
```
หมายเหตุ เหตุการณ์นี้ทำงานเฉพาะกับลูกหลานโดยตรงของ `Class.Instance` สำหรับเหตุการณ์ที่บันทึกลูกหลานทั้งหมด ให้ใช้ `Class.Instance.DescendantAdded`.

ดูเพิ่มเติมที่ `Class.Instance.ChildRemoved`.

Instance.ChildAdded

อินสแตนซ์ `Class.Instance` ที่ถูกเพิ่ม.

เกิดขึ้นหลังจากที่วัตถุถูกเพิ่มเข้าไปใน `Class.Instance` นี้.

Instance.childAdded

สคริปต์นี้จะแสดงชื่อของวัตถุเมื่อถูกลบออกจาก
Workspace:

เกิดขึ้นหลังจากที่ลูกหลานถูกลบออกจาก `Class.Instance` นี้.

'ได้ถูกลบ' หมายถึงเมื่อพ่อแม่ของวัตถุมีการเปลี่ยนจาก `Class.Instance` นี้เป็นสิ่งอื่นนอกจาก `Class.Instance` นี้ หมายเหตุ เหตุการณ์นี้จะเกิดขึ้นเมื่อมีการทำลายลูกหลานด้วย (การใช้
`Class.Instance:Destroy()`) เนื่องจากฟังก์ชันการทำลายจะตั้งค่าวัตถุให้มีพ่อแม่เป็น `nil`.

เหตุการณ์นี้ทำงานเฉพาะกับลูกหลานโดยตรงของ `Class.Instance` สำหรับเหตุการณ์ที่บันทึกลูกหลานทั้งหมด ให้ใช้ `Class.Instance.DescendantRemoving`.

ดูเพิ่มเติมที่ `Class.Instance.ChildAdded`.

Instance.ChildRemoved

อินสแตนซ์ `Class.Instance` ที่ถูกลบ.

เกิดขึ้นหลังจากที่ลูกหลานถูกลบออกจาก `Class.Instance` นี้.

ตัวอย่างต่อไปนี้จะแสดงชื่อของวัตถุใดๆ ที่ถูกเพิ่มเข้าไปใน
Workspace:

เหตุการณ์นี้เกิดขึ้นหลังจากที่มีการเพิ่มลูกหลานใน `Class.Instance`.

เนื่องจากเหตุการณ์นี้จะเกิดขึ้นสำหรับทุกลูกหลาน การตั้งค่าวัตถุให้เป็นลูกหลานของ `Class.Instance` จะทำให้เกิดเหตุการณ์นี้สำหรับวัตถุและลูกหลานของมันแต่ละตัว.

หากคุณสนใจเฉพาะ **ลูกหลานโดยตรง** ของ `Class.Instance` ให้ใช้ `Class.Instance.ChildAdded` แทน.

ดูเพิ่มเติมที่ `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

เกิดขึ้นหลังจากที่มีการเพิ่มลูกหลานใน `Class.Instance`.

ตัวอย่างต่อไปนี้แสดงผลชื่อของสิ่งที่ถูกลูกหลานเมื่อมันถูกลบออก
จาก Workspace:

เหตุการณ์นี้เกิดขึ้น **โดยทันที** ก่อนที่พ่อแม่ `Class.Instance`
จะมีการเปลี่ยนแปลงเช่นนั้นทำให้ **ลูกหลาน** ของอินสแตนซ์จะไม่เป็นลูกปัจจุบันอีกต่อไป `Class.Instance:Destroy()|Destroy()` จะเปลี่ยน `Class.Instance.Parent|Parent` ของอินสแตนซ์ให้เป็น `nil`, ดังนั้นการเรียกใช้วิธีนี้บนลูกหลานของพ่อแม่จะทำให้เหตุการณ์นี้เกิดขึ้น.

เนื่องจากเหตุการณ์นี้เกิดขึ้น **ก่อน** การลบลูกหลาน พ่อแม่ของลูกหลานจะไม่เปลี่ยนแปลงในช่วงเวลาของเหตุการณ์นี้ หากลูกหลานนั้นเป็น **ลูกโดยตรง** ของพ่อแม่ เหตุการณ์นี้จะเกิดขึ้นก่อน `Class.Instance.ChildRemoved`.

หากลูกหลานมีลูกของมันเอง เหตุการณ์นี้จะเกิดขึ้นเมื่อมีการเริ่มต้นลูกหลานก่อน,
ตามด้วยลูกหลานของมัน.

#### การเตือน

เหตุการณ์นี้จะเกิดขึ้นกับวัตถุลูกหลานที่ถูกลบ.
การตั้งค่า `Class.Instance.Parent|Parent` ของลูกหลานให้เป็นอย่างอื่นจะล้มเหลว ด้านล่างเป็นตัวอย่างที่แสดงสิ่งนี้:

```
local Workspace = game:GetService("Workspace")

Workspace.DescendantRemoving:Connect(function(descendant)
	-- อย่าปรับเปลี่ยนพ่อแม่ของลูกหลานในฟังก์ชันนี้!
	-- เหตุการณ์นี้เกิดขึ้นเพราะว่าพ่อแม่ถูกปรับเปลี่ยน, และการเปลี่ยนแปลงยังเกิดขึ้นไม่ได้
	-- ดังนั้นการเปลี่ยนแปลงพ่อแม่เช่นนี้จึงเป็นเรื่องที่ไม่เหมาะสม:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
ดูเพิ่มเติมที่ `Class.Instance.DescendantAdded|DescendantAdded`.

Instance.DescendantRemoving

อินสแตนซ์ `Class.Instance` ที่กำลังจะถูกลบ.

เกิดขึ้นโดยทันทีเมื่อมีการลบลูกหลานของ `Class.Instance`.

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

ตัวอย่างนี้แสดงให้เห็นว่าเมื่อใช้พฤติกรรมสัญญาณ Deferred\, อินสแตนซ์
จะถูกทำลายก่อนที่สัญญาณจะถูกเรียกใช้งาน


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

หากสมบัติ `Class.Workspace.SignalBehavior` ถูกตั้งค่าเป็น `Enum.SignalBehavior.Immediate`, เหตุการณ์นี้จะเกิดขึ้นโดยทันที ก่อนที่
`Class.Instance` หรือบรรพบุรุษของมันจะถูกทำลายด้วย `Class.Instance:Destroy()`.

หากสมบัติ `Class.Workspace.SignalBehavior` ถูกตั้งค่าเป็น `Enum.SignalBehavior.Deferred`, เหตุการณ์นี้จะเกิดขึ้นที่จุดการกลับคืนถัดไป,
ซึ่งจะอยู่หลังจาก `Class.Instance` หรือ มารดาของมันถูกทำลายด้วย `Class.Instance:Destroy()`.

ด้วยพฤติกรรม `Enum.SignalBehavior.Deferred|Deferred`, การเชื่อมต่อสคริปต์เข้ากับเหตุการณ์ `Class.Instance.Destroying` ของมันเองเป็นเรื่องที่น่ากังวล,
เพราะสคริปต์จะถูกทำลายก่อนที่การเรียกกลับจะถูกเรียกใช้ (หมายความว่ามันจะไม่ได้ถูกดำเนินการ).

เมื่อทำการลบ `Class.Instance` ใน Studio เช่นโดยการลบด้วยตนเองผ่าน
[Explorer](/studio/explorer) หรือผ่านปลั๊กอิน,
`Class.Instance` จะไม่ได้ถูกทำลาย. แทนที่จะถูกตั้งค่าเป็น `nil`
ที่คุณสามารถติดตามด้วย `Class.Instance.AncestryChanged`.

Instance.Destroying

เกิดขึ้นทันที (หรือถูกเลื่อนออกไปหลังจาก) ที่อินสแตนซ์ถูกทำลายผ่าน `Class.Instance:Destroy()`.

เหตุการณ์นี้เกิดขึ้นเมื่อมีการเปลี่ยนแปลงในคุณสมบัติสไตล์ใดๆ ของอินสแตนซ์,
รวมถึงเมื่อมีการตั้งค่าคุณสมบัติเป็น `nil`.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Styled properties changed")
end

meterBar:StyledPropertiesChanged():Connect(stylePropertyChanged)
```

Instance.StyledPropertiesChanged

เกิดขึ้นเมื่อมีการเปลี่ยนแปลงในคุณสมัติสไตล์ใดๆ ของอินสแตนซ์ รวมถึงเมื่อมีการตั้งค่าคุณสมบัติเป็น `nil`.

วิธีการนี้นำแท็กไปใช้กับอินสแตนซ์, จะไม่มีผลหากแท็กนั้นถูกนำไปใช้แล้ว.
การเพิ่มแท็กสำเร็จจะส่งสัญญาณที่สร้างโดย
`Class.CollectionService:GetInstanceAddedSignal()` พร้อมแท็กที่กำหนด.

#### คำเตือน

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

- เมื่อแท็กอินสแตนซ์, เป็นเรื่องปกติว่าทรัพยากรบางอย่างจะถูกใช้เพื่อ
  ให้แท็กมีฟังก์ชัน, ตัวอย่างเช่นการเชื่อมต่อเหตุการณ์หรือตาราง.
  เพื่อป้องกันการรั่วไหลของหน่วยความจำ, เป็นความคิดที่ดีที่จะทำความสะอาด
  (ตัดการเชื่อมต่อ, ตั้งค่าเป็น `nil`, เป็นต้น) เมื่อไม่ต้องการใช้งานแล้ว
  สำหรับแท็กนี้. ทำเช่นนี้เมื่อเรียกใช้ `Class.Instance:RemoveTag()`, ทำการ
  `Class.Instance:Destroy()`, หรือในฟังก์ชันที่เชื่อมต่อกับสัญญาณที่ส่งกลับโดย
  `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

นำแท็กไปใช้กับอินสแตนซ์.

ฟังก์ชันลูกส่งคืนอาร์เรย์ของลูกของวัตถุ.

Instance:children

อาร์เรย์ของวัตถุ/อินสแตนซ์ลูก.

ส่งคืนอาร์เรย์ของลูกของวัตถุ.

วิธีการนี้ทำลายลูกทั้งหมดของอินสแตนซ์และทายาท.

```
local part = Instance.new("Part")

-- เพิ่มเลเวลเวชิก
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

  local sc = Instance.new("Sparkles")
  sc.Parent = sparkles
end

print("_children:", #part:GetChildren())  --> Children: 3

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```
หากคุณไม่ต้องการทำลาย **ทั้งหมด** ลูกและทายาท, ใช้
`Class.Instance:GetChildren()` หรือ `Class.Instance:GetDescendants()` เพื่อ
วนรอบลูก/ทายาทเหล่านั้นและเลือกสิ่งที่จะทำลาย. สำหรับตัวอย่างโค้ด,
โปรดดูโค้ดด้านล่างจะทำลาย `Class.BasePart|BaseParts` ทั้งหมดที่
ลงมาจาก `Class.Model`:

```
local Workspace = game:GetService("Workspace")

local model = Workspace:FindFirstChild("TestModel")

for _, descendant in model:GetDescendants() do
	if descendant:IsA("BasePart") then
		descendant:Destroy()
	end
end
```

Instance:ClearAllChildren

วิธีการนี้ทำลายลูกทั้งหมดของอินสแตนซ์.

แสดงการโคลนโมเดลโดยใช้ `Class.Instance:Clone()`.

`Clone()` สร้างสำเนาของอินสแตนซ์และทายาททั้งหมด,
โดยละเว้นอินสแตนซ์ทั้งหมดที่ไม่ใช่
`Class.Instance.Archivable|Archivable`. สำเนาของอินสแตนซ์รากจะ
ถูกส่งกลับโดยวิธีนี้และคุณสมัติ `Class.Instance.Parent|Parent` จะถูกตั้งเป็น
`nil`. หมายเหตุว่าหากอินสแตนซ์ดังกล่าวถูกตั้งค่า
`Class.Instance.Archivable|Archivable` เป็น `false`, วิธีนี้จะส่งคืน `nil`.

หากคุณสมบัติอ้างอิงเช่น `Class.ObjectValue.Value` ถูกตั้งค่าในอินสแตนซ์ที่ถูกโคลน,
ค่าของคุณสมบัติของการคัดลอกจะขึ้นอยู่กับค่าเดิม:

- หากคุณสมบัติอ้างอิงอ้างถึงอินสแตนซ์ที่ **ถูก** โคลน,
  การคัดลอกจะอ้างถึงการคัดลอก.
- หากคุณสมบัติอ้างอิงอ้างถึงอินสแตนซ์ที่ **ไม่** โคลน,
  ค่าจะถูกเก็บรักษาในคัดลอก.

Instance:Clone

สร้างสำเนาของอินสแตนซ์และทายาททั้งหมด, โดยละเว้นอินสแตนซ์
ที่ไม่ใช่ `Class.Instance.Archivable|Archivable`.

Instance:clone

แสดงให้เห็นถึงการทำลาย Part โดยใช้ฟังก์ชัน `Class.Instance:Destroy()`。

ฟังก์ชันนี้คือวิธีที่ถูกต้องในการกำจัดวัตถุที่ไม่ต้องการอีกต่อไป。


ตั้งค่าคุณสมัติ `Class.Instance.Parent` เป็น `nil`, ล็อค
คุณสมมิ `Class.Instance.Parent`, ตัดการเชื่อมต่อทั้งหมด, และเรียก
`Destroy()` บนลูกทั้งหมด. วิธีการนี้คือวิธีที่ถูกต้องในการกำจัด
วัตถุที่ไม่จำเป็นแล้ว.

การกำจัดวัตถุที่ไม่จำเป็นเป็นสิ่งสำคัญ, เนื่องจากวัตถุและ
การเชื่อมต่อที่ไม่จำเป็นในสถานที่ใช้หน่วยความจำซึ่งสามารถ
นำไปสู่ปัญหาด้านประสิทธิภาพที่รุนแรงเมื่อเวลาผ่านไป.

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

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- อย่าทำสิ่งนี้:
print(part.Name)  --> "Hello, world"
-- ทำเช่นนี้เพื่อป้องกันให้บรรทัดด้านบนไม่ทำงาน:
part = nil
```
เมื่อ `Class.Instance` ถูกทำลายโดยวิธีนี้, จะไม่สามารถใช้ใหม่ได้เพราะว่าคุณสมมิ `Class.Instance.Parent`
ถูกล็อค. เพื่อ **ชั่วคราว** ลบวัตถุแทนการทำลายมัน, ตั้งค่า
`Class.Instance.Parent|Parent` เป็น `nil`. ตัวอย่างเช่น:

```
local Workspace = game:GetService("Workspace")

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
เพื่อทำลายวัตถุหลังจากเวลาที่กำหนด, ใช้
`Class.Debris:AddItem()`.

Instance:Destroy

ตั้งค่าคุณสมัติ `Class.Instance.Parent` เป็น `nil`, ล็อค
คุณสมมิ `Class.Instance.Parent` , ตัดการเชื่อมต่อทั้งหมด, และเรียก
`Destroy()` บนลูกทั้งหมด.

Instance:destroy

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Instance.Name` มีค่าเท่ากับชื่อที่กำหนด.

วิธีนี้ทำงานไปข้างบน, หมายถึงมันเริ่มที่
`Class.Instance.Parent` ที่ใกล้ที่สุดของอินสแตนซ์และทำงานขึ้นไปยัง
`Class.DataModel`. หากไม่พบบรรพบุรุษที่ตรงกัน, จะส่งคืน `nil`.

โค้ดส่วนลดถัดไปจะค้นหาบรรพบุรุษแรกของวัตถุที่
มีชื่อว่า `Car`.

```
local car = object:FindFirstAncestor("Car")
```
สำหรับรุ่นของวิธีนี้ที่ค้นหาบรรพบุรุษของคลาสเฉพาะ,
โปรดดู `Class.Instance:FindFirstAncestorOfClass()` และ
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

ชื่อ `Class.Instance.Name` ที่จะถูกค้นหา.

คลาส `Class.Instance` ที่พบ.

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Instance.Name` มีค่าเท่ากับชื่อที่กำหนด.

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Object.ClassName` มีค่าเท่ากับ className ที่กำหนด.

วิธีนี้ทำงานไปข้างบน, หมายถึงมันเริ่มที่
`Class.Instance.Parent` ที่ใกล้ที่สุดและทำงานขึ้นไปยัง
`Class.DataModel`. หากไม่พบบรรพบุรุษที่ตรงกัน, จะส่งคืน `nil`.

การใช้งานทั่วไปของวิธีนี้คือการค้นหา `Class.Model` ที่
`Class.BasePart` เป็นของ. เช่น:

```
local model = part:FindFirstAncestorOfClass("Model")
```
วิธีนี้เป็นรูปแบบหนึ่งของ `Class.Instance:FindFirstAncestor()`
ที่ตรวจสอบคุณสมบัติ `Class.Object.ClassName` แทนที่จะใช้
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` ยังมี,
โดยใช้วิธี `Class.Object:IsA()` แทนเพื่อให้เคารพการสืบทอดคลาส.

Instance:FindFirstAncestorOfClass

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Object.ClassName` มีค่าเท่ากับ className ที่กำหนด.

Instance

`Instance` เป็นคลาสพื้นฐานสำหรับคลาสทั้งหมดในลำดับชั้นคลาส Roblox
ซึ่งสามารถเป็นส่วนหนึ่งของต้นไม้ `Class.DataModel`.