Techneck/code/source-c/world/chunk_pool.c

#include "world.h"

#include <stdlib.h>
#include <string.h>

tc_chunk_pool_s        *tc_chunk_pool_g     = NULL;

void tc_reset_chunk_pool(tc_chunk_pool_s *chunk_pool)
{
    chunk_pool->used_entries        = 0;
    chunk_pool->first_free          = chunk_pool->entries;
    
    uint32_t                entry_index     = 0;
    while(entry_index < chunk_pool->capacity)
    {
        chunk_pool->entries[entry_index].next       = &chunk_pool->entries[entry_index+1];
        chunk_pool->entries[entry_index].previous   = &chunk_pool->entries[entry_index-1];
        ++entry_index;
    }
    chunk_pool->continuation                            = NULL;
    chunk_pool->entries[0].previous                     = NULL;
    chunk_pool->entries[chunk_pool->capacity-1].next    = NULL;
}

tc_chunk_pool_s * tc_internal_new_chunk_pool(uint32_t capacity)
{
    tc_chunk_pool_s        *pool            = malloc(sizeof(tc_chunk_pool_s));
    pool->capacity              = capacity;
    pool->entries               = calloc(sizeof(tc_chunk_pool_entry_s), pool->capacity);
    tc_reset_chunk_pool(pool);
    
    return pool;
}

void tc_init_chunk_pool(uint32_t capacity)
{
    tc_chunk_pool_g             = tc_internal_new_chunk_pool(capacity);
}

void tc_internal_free_chunk_pool(tc_chunk_pool_s *pool)
{
    if(pool->continuation != NULL) tc_internal_free_chunk_pool(pool->continuation);
    free(pool->entries);
    free(pool);
}

void tc_cleanup_chunk_pool()
{
    tc_internal_free_chunk_pool(tc_chunk_pool_g);
}

tc_chunk_pool_entry_s * tc_allocate_chunk_pool_entry(tc_chunk_pool_s *pool)
{
    if(pool->first_free == NULL)
    {
        if(pool->continuation == NULL)
            pool->continuation          = tc_internal_new_chunk_pool(pool->capacity * 2);
        return tc_allocate_chunk_pool_entry(pool->continuation);
    }
    tc_chunk_pool_entry_s  *allocated       = pool->first_free;
    pool->first_free            = allocated->next;
    
    return allocated;
}

tc_chunk_s * tc_allocate_chunk()
{
    tc_chunk_pool_entry_s *entry = tc_allocate_chunk_pool_entry(tc_chunk_pool_g);
    entry->chunk.pool_entry  = entry;
    
    return &entry->chunk;
}

void tc_deallocate_chunk(tc_chunk_s *chunk)
{
    if(chunk->vao != 0)
    {
        glDeleteVertexArrays(1, &chunk->vbo);
        chunk->vao      = 0;
    }
    
    if(chunk->vbo != 0)
    {
        glDeleteBuffers(1, &chunk->vbo);
        chunk->vbo = 0;
    }
    
    tc_chunk_pool_entry_s      *entry   = chunk->pool_entry;
    entry->next                         = tc_chunk_pool_g->first_free;
    tc_chunk_pool_g->first_free         = entry;
    memset(chunk, 0x00, sizeof(tc_chunk_s));
    chunk->pool_entry                   = entry;
}