Efficiently passing data to the GPU corresponding to a collection of objects

Question

I am beginning to work on a physics system, where there are multiple objects in the world that get rendered. The current approach I am considering consists of pseudo-OOP in C where each object has data that is used for rendering, and data that is not used for rendering.

Quick example:

double Object_update(Object *this, double now) {
    double delta = now - this->last_update;
    this->position[0] += this->velocity[0];
    this->position[1] += this->velocity[1];
    this->position[2] += this->velocity[2];
    // Check for collisions etc.
}
struct Class {
    size_t size;
    const struct Class *super;
    double (*update)(double);
} Object = {
    
};
struct Object {
    struct Class *class;
    double last_update;
    float position[3], rotation[3][3], velocity[3], mass;
    // Others might be added later, e.g., bounding_box, angular_velocity, force, torque, etc.
};

So here is the problem. If these objects have their position and rotation embedded in them, then how could I efficiently pass those (and not the other properties) to the GPU for rendering?

I have considered storing those specifically in a parallel array in GPU-accessible memory but that will get complicated when I encounter the age old problem of keeping said array contiguous, i.e., removing gaps when objects are destroyed, etc. And gets even more complicated when I add 'subclasses' with extra data that is relevant for rendering, such as texture IDs or meshes, meaning the elements are no longer homogeneous in size.

How can I best maintain GPU-accessible data in my Object along with properties that do not need to be GPU accessible?

I could loop through them in the render loop and then setVertexBytes to the position/rotation data of each object, but that would incur one draw call per object, which is not efficient for a large number of objects.

Have you looked into structure-of-arrays storage layout, and the "archetype" pattern used in some data-oriented Entity Component System implementations? These avoid subclassing by forming new behaviours via composition instead of inheritance, and can be set up to support dense, contiguous storage of component data. — DMGregory
– DMGregory ♦, Commented Feb 1 at 14:18
@DMGregory The current challenge I am facing with the structure-of-arrays style (parallel arrays?) is keeping the array contiguous when an object is destroyed. Is there a good solution for that? — CPlus
– CPlus, Commented Feb 1 at 15:40
The best I know is to swap the destroyed item with the last non-destroyed item, then destroy from the end. Some discussion of that approach and its benefits/drawbacks here. The trick is that during this swap-and-delete step, you also need to update any mapping information used address the swapped item, so it points to its new location. So usually you'd defer deletions to the end of frame, and forbid any system from holding an index to an item between frames. — DMGregory
– DMGregory ♦, Commented Feb 1 at 15:44

Kevin Reid · Accepted Answer · 2025-02-01 16:56:45Z

I have considered storing those specifically in a parallel array in GPU-accessible memory but that will get complicated…

I could loop through them in the render loop and then setVertexBytes to the position/rotation data of each object, but that would incur one draw call per object, which is not efficient for a large number of objects.

One simple thing you can do is fill your parallel arrays from scratch every frame, skipping all the deleted objects. Thus you get contiguous data in arrays, and can use few draw calls.

This is of course not as efficient as only partially updating the arrays, but something to keep in mind is that there is always work to be done per object per frame, in your physics simulation if nothing else; all you are doing is slightly increasing the CPU load per object. It's not the theoretically ideal solution, but it is a simple, robust interim solution which you can use until you have a more final idea of how your program is going to manage its objects and you need to scale up.

Better yet, instead of rebuilding every frame, I could rebuild on every change. Only on frames when an object is created or destroyed. — CPlus
– CPlus, Commented Feb 2 at 21:11

Stack Exchange Network

Efficiently passing data to the GPU corresponding to a collection of objects

1 Answer 1

You must log in to answer this question.

Linked

Hot Network Questions

Efficiently passing data to the GPU corresponding to a collection of objects

1 Answer 1

You must log in to answer this question.

Linked

Related

Hot Network Questions