Wiener234/game

Fork 0

Y-Axis rendering #3

New issue

Closed

opened 2025-05-28 16:26:54 +02:00 by Wiener234 · 1 comment

Wiener234 commented

2025-05-28 16:26:54 +02:00

Owner

Render the sprites sorted by y-Axis. A higher y-axis gets rendered on top.

Wiener234 self-assigned this

2025-05-28 16:26:54 +02:00

Wiener234 added this to the Renderer project

2025-05-28 16:26:54 +02:00

Wiener234 added the

Feature

Priority

High

labels

2025-05-28 16:43:41 +02:00

Wiener234 commented

2025-06-04 10:15:54 +02:00

Author

Owner

To sort a list of sprites (or entities) by their Y-axis, you need a clear and consistent data structure for your entities/sprites and a strategy to organize them in a list that can be sorted. Here's a straightforward way to approach this in C:

1. Define a Struct for Sprites/Entities

If your entities and sprites are different but both need to be sorted visually, they should share at least a common base: the Y-position.

You can either:

Use a union or a common struct field in both types
Or treat everything as a single "renderable" type for sorting

Here’s a possible struct definition:

typedef struct {
    float x, y;
    float width, height;
    float speed;
    Rectangle frameRec; // Assuming using raylib or similar
    int state;
} Entity;

typedef struct {
    float x, y;
    float width, height;
    Texture2D texture;
    Rectangle sourceRec;
} Sprite;

2. Define a Renderable Struct

To sort both Entity and Sprite, you can wrap them in a common type:

typedef enum {
    RENDERABLE_ENTITY,
    RENDERABLE_SPRITE
} RenderableType;

typedef struct {
    RenderableType type;
    void* data; // Pointer to either Entity or Sprite
    float y;    // Cached Y-value for sorting
} Renderable;

3. Populate the Renderable Array

You create an array of Renderable items before rendering, and cache their y position for sorting:

Renderable renderables[MAX_OBJECTS];
int renderableCount = 0;

// Example for adding an entity
renderables[renderableCount].type = RENDERABLE_ENTITY;
renderables[renderableCount].data = &entities[i];
renderables[renderableCount].y = entities[i].y;
renderableCount++;

// For sprite
renderables[renderableCount].type = RENDERABLE_SPRITE;
renderables[renderableCount].data = &sprites[i];
renderables[renderableCount].y = sprites[i].y;
renderableCount++;

4. Sort the List by Y

You can use qsort() from the C standard library:

int compareRenderableY(const void* a, const void* b) {
    float y1 = ((Renderable*)a)->y;
    float y2 = ((Renderable*)b)->y;
    return (y1 > y2) - (y1 < y2); // Equivalent to comparing float values
}

qsort(renderables, renderableCount, sizeof(Renderable), compareRenderableY);

5. Render in Sorted Order

After sorting:

for (int i = 0; i < renderableCount; i++) {
    if (renderables[i].type == RENDERABLE_ENTITY) {
        Entity* e = (Entity*)renderables[i].data;
        // draw your entity
    } else if (renderables[i].type == RENDERABLE_SPRITE) {
        Sprite* s = (Sprite*)renderables[i].data;
        // draw your sprite
    }
}

Summary

Use a Renderable wrapper struct to unify entities/sprites for sorting
Cache the y position to avoid multiple dereferences
Sort using qsort() and a float comparison
Render in sorted order

If your use case is more specific or you're using a library like raylib, let me know — I can tailor the solution to that.

To sort a list of sprites (or entities) by their **Y-axis**, you need a clear and consistent data structure for your entities/sprites and a strategy to organize them in a list that can be sorted. Here's a straightforward way to approach this in C: --- ### 1. **Define a Struct for Sprites/Entities** If your entities and sprites are different but both need to be sorted visually, they should share at least a common base: the Y-position. You can either: * Use a **union** or a **common struct field** in both types * Or treat everything as a single "renderable" type for sorting Here’s a possible struct definition: ```c typedef struct { float x, y; float width, height; float speed; Rectangle frameRec; // Assuming using raylib or similar int state; } Entity; typedef struct { float x, y; float width, height; Texture2D texture; Rectangle sourceRec; } Sprite; ``` --- ### 2. **Define a Renderable Struct** To sort both `Entity` and `Sprite`, you can wrap them in a common type: ```c typedef enum { RENDERABLE_ENTITY, RENDERABLE_SPRITE } RenderableType; typedef struct { RenderableType type; void* data; // Pointer to either Entity or Sprite float y; // Cached Y-value for sorting } Renderable; ``` --- ### 3. **Populate the Renderable Array** You create an array of `Renderable` items before rendering, and cache their `y` position for sorting: ```c Renderable renderables[MAX_OBJECTS]; int renderableCount = 0; // Example for adding an entity renderables[renderableCount].type = RENDERABLE_ENTITY; renderables[renderableCount].data = &entities[i]; renderables[renderableCount].y = entities[i].y; renderableCount++; // For sprite renderables[renderableCount].type = RENDERABLE_SPRITE; renderables[renderableCount].data = &sprites[i]; renderables[renderableCount].y = sprites[i].y; renderableCount++; ``` --- ### 4. **Sort the List by Y** You can use `qsort()` from the C standard library: ```c int compareRenderableY(const void* a, const void* b) { float y1 = ((Renderable*)a)->y; float y2 = ((Renderable*)b)->y; return (y1 > y2) - (y1 < y2); // Equivalent to comparing float values } ``` ```c qsort(renderables, renderableCount, sizeof(Renderable), compareRenderableY); ``` --- ### 5. **Render in Sorted Order** After sorting: ```c for (int i = 0; i < renderableCount; i++) { if (renderables[i].type == RENDERABLE_ENTITY) { Entity* e = (Entity*)renderables[i].data; // draw your entity } else if (renderables[i].type == RENDERABLE_SPRITE) { Sprite* s = (Sprite*)renderables[i].data; // draw your sprite } } ``` --- ### Summary * Use a `Renderable` wrapper struct to unify entities/sprites for sorting * Cache the `y` position to avoid multiple dereferences * Sort using `qsort()` and a float comparison * Render in sorted order If your use case is more specific or you're using a library like **raylib**, let me know — I can tailor the solution to that.

Wiener234 referenced this issue from a commit

2025-06-05 10:11:47 +02:00

feat: y axis rendering order

Wiener234 closed this issue

2025-06-05 10:11:47 +02:00

Wiener234 referenced this issue from a commit

2025-06-05 10:12:18 +02:00

feat: y axis rendering order

Wiener234 referenced this issue from a commit

2025-06-05 10:13:13 +02:00

feat: y axis rendering order