Danh hiệu: Administration
Nhóm:
Gia nhập: 19-08-2014(UTC)
Bài viết: 145
Được cảm ơn: 7 lần trong 6 bài viết
|
Dưới đây là bài viết của Anh Tuấn Anh gửi tới 3DVietPro liên quan tới các hàm của thư viện Mathf trong unity, các bạn chưa lắm chắc có thể đọc hiểu thêm nhé! MATHF
Trong Unity, lớp `Mathf` cung cấp nhiều phương thức hữu ích để thực hiện các tính toán số học và các hàm trên số. Dưới đây là một số phương thức quan trọng của lớp `Mathf`:
1. `Mathf.Abs()`: Trả về giá trị tuyệt đối của một số.
```
float result = Mathf.Abs(-5.3f); // Kết quả: 5.3
```
2. `Mathf.Clamp()`: Hạn chế một số để nằm trong một khoảng giá trị cụ thể.
```
float clampedValue = Mathf.Clamp(value, min, max);
```
3. `Mathf.Lerp()`: Lấy giá trị trung gian giữa hai số dựa trên một tham số alpha (nằm trong khoảng từ 0 đến 1).
```
float result = Mathf.Lerp(startValue, endValue, alpha);
```
4. `Mathf.LerpUnclamped()`: Tương tự như `Mathf.Lerp()` nhưng không bị giới hạn bởi tham số alpha (có thể nhỏ hơn 0 hoặc lớn hơn 1).
```
float result = Mathf.LerpUnclamped(startValue, endValue, alpha);
```
5. `Mathf.Clamp01()`: Hạn chế một số để nằm trong khoảng từ 0 đến 1.
```
float clampedValue = Mathf.Clamp01(value);
```
6. `Mathf.Round()`: Làm tròn một số đến số nguyên gần nhất.
```
float roundedValue = Mathf.Round(5.8f); // Kết quả: 6
```
7. `Mathf.Floor()`: Làm xuống một số, trả về số nguyên nhỏ nhất nhưng không lớn hơn số gốc.
```
float floorValue = Mathf.Floor(3.9f); // Kết quả: 3
```
8. `Mathf.Ceil()`: Làm lên một số, trả về số nguyên lớn nhất nhưng không nhỏ hơn số gốc.
```
float ceilValue = Mathf.Ceil(2.1f); // Kết quả: 3
```
9. `Mathf.Sin()`, `Mathf.Cos()`, `Mathf.Tan()`: Các hàm lượng giác tương ứng (sin, cos, tan) trong đơn vị radian.
```
float sinValue = Mathf.Sin(Mathf.PI / 2); // Kết quả: 1 (vì sin(π/2) = 1)
```
10. `Mathf.Rad2Deg`, `Mathf.Deg2Rad`: Các hằng số giúp chuyển đổi giữa radian và độ.
```
float radianValue = Mathf.PI; // Khoảng 3.14159
float degreeValue = 180f; // Kết quả: 180
```
Đây chỉ là một số ví dụ về các phương thức được cung cấp bởi lớp `Mathf` trong Unity. Bạn có thể tham khảo tài liệu chính thức của Unity để tìm hiểu thêm về tất cả các phương thức và hằng số khác mà lớp này cung cấp.
Dưới đây là tiếp tục danh sách một số phương thức quan trọng khác của lớp `Mathf` trong Unity:
11. `Mathf.Pow()`: Tính lũy thừa của một số với một số mũ cho trước.
```
float result = Mathf.Pow(baseValue, exponent); // Kết quả: baseValue ^ exponent
```
12. `Mathf.Sqrt()`: Tính căn bậc hai của một số.
```
float result = Mathf.Sqrt(25f); // Kết quả: 5
```
13. `Mathf.Sign()`: Trả về dấu của một số. Nếu số dương, trả về 1. Nếu số âm, trả về -1. Nếu số bằng 0, trả về 0.
```
int signValue = Mathf.Sign(-7f); // Kết quả: -1
```
14. `Mathf.Max()`, `Mathf.Min()`: Trả về giá trị lớn nhất hoặc nhỏ nhất trong một danh sách các số.
```
float maxValue = Mathf.Max(3f, 8f, 2f); // Kết quả: 8
float minValue = Mathf.Min(3f, 8f, 2f); // Kết quả: 2
```
15. `Mathf.RoundToInt()`: Làm tròn một số đến số nguyên gần nhất và trả về giá trị nguyên.
```
int roundedValue = Mathf.RoundToInt(5.8f); // Kết quả: 6
```
16. `Mathf.FloorToInt()`: Làm xuống một số và trả về giá trị nguyên nhỏ nhất nhưng không lớn hơn số gốc.
```
int floorValue = Mathf.FloorToInt(3.9f); // Kết quả: 3
```
17. `Mathf.CeilToInt()`: Làm lên một số và trả về giá trị nguyên lớn nhất nhưng không nhỏ hơn số gốc.
```
int ceilValue = Mathf.CeilToInt(2.1f); // Kết quả: 3
```
18. `Mathf.PerlinNoise()`: Trả về giá trị noise Perlin 2D tại vị trí cụ thể.
```
float perlinNoiseValue = Mathf.PerlinNoise(xCoord, yCoord);
```
Lớp `Mathf` trong Unity cung cấp nhiều phương thức hữu ích khác để thực hiện các tính toán số học và các phép toán trên số. Bạn có thể tìm hiểu thêm về các phương thức và hằng số trong tài liệu chính thức của Unity.
Trích dẫn:void Update()
{
Vector2 targetPosition = Vector2.zero;
if (Input.GetKey(KeyCode.LeftArrow))
{
AS.Play();
targetPosition = diem_1.position;
}
if (Input.GetKey(KeyCode.RightArrow))
{
AS.Play();
targetPosition = diem_2.position;
}
if (Input.GetKey(KeyCode.DownArrow))
{
AS.Play();
targetPosition = diem_3.position;
}
if (targetPosition != Vector2.zero)
{
Vector2 direction = targetPosition - (Vector2)transform.position;
float angle = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;
transform.rotation = Quaternion.AngleAxis(angle, Vector3.forward);
transform.position = Vector2.MoveTowards(transform.position, targetPosition, speedBird * Time.deltaTime);
}
XOAY ĐỐI TƯỢNG
Trong Unity, có nhiều cách để xoay đối tượng. Dưới đây là một số cách phổ biến:
1. **Sử dụng Quaternion.Euler:** Sử dụng hàm `Quaternion.Euler` để tạo một `Quaternion` xoay từ các góc x, y và z.
```csharp
float angle = 45f; // Góc xoay 45 độ
Quaternion rotation = Quaternion.Euler(0, angle, 0);
transform.rotation = rotation;
```
2. **Sử dụng transform.Rotate:** Sử dụng hàm `Rotate` của `transform` để thêm một góc xoay vào góc hiện tại của đối tượng.
```csharp
float rotationSpeed = 90f; // Tốc độ xoay 90 độ mỗi giây
transform.Rotate(Vector3.up * rotationSpeed * Time.deltaTime);
```
3. **Sử dụng Quaternion.LookRotation:** Đặt hướng nhìn của đối tượng tới một điểm cụ thể.
```csharp
Vector3 targetDirection = targetPosition - transform.position;
Quaternion targetRotation = Quaternion.LookRotation(targetDirection);
transform.rotation = targetRotation;
```
4. **Sử dụng transform.localRotation:** Xoay đối tượng theo hướng cục bộ (local) của nó.
```csharp
float angle = 45f; // Góc xoay 45 độ
transform.localRotation = Quaternion.Euler(0, angle, 0);
```
5. **Sử dụng transform.rotation = Quaternion.AngleAxis:** Xoay đối tượng quanh một trục với góc được chỉ định.
```csharp
float angle = 45f; // Góc xoay 45 độ
transform.rotation = Quaternion.AngleAxis(angle, Vector3.up);
```
Hãy chọn phương pháp phù hợp với mục tiêu cụ thể của bạn. Chú ý rằng việc xoay đối tượng có thể bị ảnh hưởng bởi cách đối tượng được cấu hình (pivot point, parent-child relationship, etc.).
|
