Lưu trữ voxels cho Công cụ voxel trong C ++

Tôi đang cố gắng viết một công cụ voxel nhỏ vì nó thú vị, nhưng đấu tranh để tìm ra cách tốt nhất để lưu trữ các voxels thực tế. Tôi nhận thức được rằng tôi sẽ cần một số loại vì vậy tôi không cần phải có toàn bộ thế giới trong bộ nhớ và tôi nhận thức được rằng tôi cần kết xuất chúng với hiệu suất hợp lý.

Tôi đã đọc về octrees và từ những gì tôi hiểu, nó bắt đầu bằng 1 khối lập phương và trong khối đó có thể có thêm 8 khối nữa, và trong tất cả 8 khối đó có thể là 8 khối khác, v.v. Nhưng tôi không nghĩ rằng nó phù hợp với động cơ voxel của tôi bởi vì khối / vật phẩm voxel của tôi tất cả sẽ có cùng kích thước.

Vì vậy, một lựa chọn khác là chỉ cần tạo một mảng có kích thước 16 * 16 * 16 và có một mảng, và bạn điền nó với các mục. Và những phần không có vật phẩm nào sẽ có 0 là giá trị (0 = không khí). Nhưng tôi sợ điều này sẽ lãng phí rất nhiều bộ nhớ và sẽ không nhanh lắm.

Sau đó, một tùy chọn khác là một vectơ cho mỗi khối, và điền nó với các hình khối. Và khối lập phương giữ vị trí của nó trong khối. Điều này giúp tiết kiệm bộ nhớ (không có khối không khí), nhưng làm cho việc tìm kiếm một khối ở một vị trí cụ thể chậm hơn rất nhiều.

Vì vậy, tôi thực sự không thể tìm thấy một giải pháp tốt và tôi hy vọng ai đó có thể giúp tôi với điều đó. Vậy bạn sẽ sử dụng cái gì và tại sao?

Nhưng một vấn đề khác là kết xuất. Chỉ cần đọc từng đoạn và gửi nó đến GPU bằng OpenGL thì dễ, nhưng rất chậm. Tạo một lưới trên mỗi khối sẽ tốt hơn, nhưng điều đó có nghĩa là mỗi lần tôi phá vỡ một khối, tôi phải xây dựng lại toàn bộ khối có thể mất một chút thời gian gây ra một tiếng nấc nhỏ nhưng đáng chú ý, điều mà rõ ràng tôi không muốn. Vì vậy, sẽ khó hơn. Vì vậy, làm thế nào tôi sẽ làm cho các hình khối? Chỉ cần tạo tất cả các hình khối trong một bộ đệm đỉnh trên mỗi đoạn và kết xuất nó và có thể thử đặt nó vào một luồng khác, hoặc có cách nào khác không?

Cảm ơn!

Lưu trữ các khối như các vị trí và các giá trị thực sự rất không hiệu quả. Ngay cả khi không có bất kỳ chi phí nào gây ra bởi cấu trúc hoặc đối tượng bạn sử dụng, bạn cần lưu trữ 4 giá trị riêng biệt cho mỗi khối. Sẽ chỉ có ý nghĩa khi sử dụng nó trong phương pháp "lưu trữ các khối trong các mảng cố định" (cách mà bạn đã mô tả trước đó) là khi chỉ một phần tư các khối là vững chắc và theo cách này, bạn thậm chí không áp dụng bất kỳ phương pháp tối ưu hóa nào khác vào tài khoản.

Octrees thực sự tuyệt vời cho các trò chơi dựa trên voxel, vì chúng chuyên lưu trữ dữ liệu với các tính năng lớn hơn (ví dụ: các bản vá của cùng một khối). Để minh họa điều này, tôi đã sử dụng một quadtree (về cơ bản là octrees trong 2d):

Đây là bộ bắt đầu của tôi chứa các ô 32x32, sẽ bằng 1024 giá trị:

Việc lưu trữ giá trị này là 1024 giá trị riêng biệt có vẻ không hiệu quả, nhưng một khi bạn đạt được kích thước bản đồ tương tự như các trò chơi, như Terraria , việc tải màn hình sẽ mất nhiều giây. Và nếu bạn tăng nó lên chiều thứ ba, nó bắt đầu sử dụng hết dung lượng trong hệ thống.

Quadtrees (hoặc octrees trong 3d) có thể giúp tình hình. Để tạo một cái, bạn có thể đi từ các ô và nhóm chúng lại với nhau hoặc đi từ một ô lớn và bạn chia nó cho đến khi bạn đạt được các ô. Tôi sẽ sử dụng cách tiếp cận đầu tiên, bởi vì nó dễ hình dung hơn.

Vì vậy, trong lần lặp đầu tiên, bạn nhóm mọi thứ thành các ô 2x2 và nếu một ô chỉ chứa các ô cùng loại, bạn bỏ các ô đó và chỉ lưu trữ loại. Sau một lần lặp, bản đồ của chúng ta sẽ như thế này:

Các dòng màu đỏ đánh dấu những gì chúng tôi lưu trữ. Mỗi ô vuông chỉ là 1 giá trị. Điều này đã đưa kích thước giảm từ 1024 giá trị xuống còn 439, giảm 57%.

Nhưng bạn biết câu thần chú . Chúng ta hãy tiến thêm một bước và nhóm chúng vào các ô:

Điều này đã giảm lượng giá trị được lưu trữ xuống 367. Đó chỉ là 36% kích thước ban đầu.

Bạn rõ ràng cần phải thực hiện phân chia này cho đến khi mỗi 4 ô liền kề (8 khối liền kề trong 3d) bên trong một khối được lưu trữ bên trong một ô, về cơ bản là chuyển một khối thành một ô lớn.

Điều này cũng có một số lợi ích khác, chủ yếu là khi va chạm, nhưng bạn có thể muốn tạo một octree riêng cho điều đó, điều này chỉ quan tâm đến việc một khối duy nhất có rắn hay không. Bằng cách đó, thay vì kiểm tra chống va chạm cho mọi khối bên trong một khối, bạn chỉ có thể làm điều đó chống lại các tế bào.

Octrees tồn tại để giải quyết chính xác vấn đề bạn mô tả, cho phép lưu trữ dữ liệu thưa thớt mà không có thời gian tìm kiếm lớn.

Thực tế là các voxels của bạn có cùng kích thước chỉ có nghĩa là octree của bạn có độ sâu cố định. ví dụ. đối với một đoạn 16x16x16, bạn cần tối đa 5 cấp độ của cây:

• gốc chunk (16x16x16)
  • quãng tám đầu tiên (8x8x8)
    • quãng tám thứ hai (4x4x4)
      • octant tầng thứ ba (2x2x2)
        • voxel đơn (1x1x1)

Điều này có nghĩa là bạn có tối đa 5 bước để tìm hiểu xem có một voxel tại một vị trí cụ thể trong khối hay không:

• chunk root: toàn bộ chunk có cùng giá trị (ví dụ: tất cả không khí)? Nếu vậy, chúng ta đã xong. Nếu không...
  • Cấp thứ nhất: là octant chứa vị trí này có cùng giá trị không? Nếu không...
    • bậc thứ hai...
      • tầng thứ ba ...
        • bây giờ chúng tôi đang giải quyết một voxel duy nhất và có thể trả về giá trị của nó.

Ngắn hơn nhiều so với việc quét thậm chí 1% trên đường đi qua một mảng lên tới 4096 voxels!

Lưu ý rằng điều này cho phép chúng tôi nén dữ liệu ở bất cứ nơi nào có một quãng tám đầy đủ có cùng giá trị - cho dù giá trị đó là tất cả không khí hay tất cả đá hay bất cứ thứ gì khác. Đó chỉ là nơi các octant chứa các giá trị hỗn hợp mà chúng ta cần chia nhỏ hơn nữa, đến giới hạn của các nút lá đơn voxel.

Để giải quyết vấn đề con cái, thông thường chúng ta sẽ tiến hành theo thứ tự Morton , đại loại như thế này:

1. XYZ-
2. X- Y- Z +
3. X- Y + Z-
4. X- Y + Z +
5. X + Y- Z-
6. X + Y- Z +
7. X + Y + Z-
8. X + Y + Z +

Vì vậy, điều hướng nút Octree của chúng tôi có thể trông giống như thế này:

GetOctreeValue(OctreeNode node, int depth, int3 nodeOrigin, int3 queryPoint) {
    if(node.IsAllOneValue)
        return node.Value;

    int childIndex =  0;
    childIndex += (queryPoint.x > nodeOrigin.x) ? 4 : 0;
    childIndex += (queryPoint.y > nodeOrigin.y) ? 2 : 0;
    childIndex += (queryPoint.z > nodeOrigin.z) ? 1 : 0;

    OctreeNode child = node.GetChild(childIndex);

    return GetOctreeValue(
                child, 
                depth + 1,
                nodeOrigin + childOffset[depth, childIndex],
                queryPoint
    );
}