mlx_images.c File Reference

#include "MLX42/MLX42_Int.h"

Include dependency graph for mlx_images.c:

Go to the source code of this file.

Functions
void	mlx_flush_batch (mlx_ctx_t *mlx)
static int8_t	mlx_bind_texture (mlx_ctx_t *mlx, mlx_image_t *img)
void	mlx_draw_instance (mlx_ctx_t *mlx, mlx_image_t *img, mlx_instance_t *instance)
mlx_instance_t *	mlx_grow_instances (mlx_image_t *img, bool *did_realloc)
void	mlx_set_instance_depth (mlx_instance_t *instance, int32_t zdepth)
int32_t	mlx_image_to_window (mlx_t *mlx, mlx_image_t *img, int32_t x, int32_t y)
mlx_image_t *	mlx_new_image (mlx_t *mlx, uint32_t width, uint32_t height)
void	mlx_delete_image (mlx_t *mlx, mlx_image_t *image)
bool	mlx_resize_image (mlx_image_t *img, uint32_t nwidth, uint32_t nheight)

Function Documentation

mlx_bind_texture()

static int8_t mlx_bind_texture ( mlx_ctx_t *  mlx, mlx_image_t *  img  )

static

Definition at line 30 of file mlx_images.c.

{
    const GLint handle = (GLint)((mlx_image_ctx_t*)img->context)->texture;
 
    // Attempt to bind the texture, or obtain the index if it is already bound.
    for (int8_t i = 0; i < 16; i++)
    {
        if (mlx->bound_textures[i] == handle)
            return (i);
 
        if (mlx->bound_textures[i] == 0)
        {
            mlx->bound_textures[i] = handle;
 
            glActiveTexture(GL_TEXTURE0 + i);
            glBindTexture(GL_TEXTURE_2D, handle);
            return (i);
        }
    }
 
    // If no free slot was found, flush the batch and assign the texture to the first available slot
    mlx_flush_batch(mlx);
 
    mlx->bound_textures[0] = handle;
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, handle);
    return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_delete_image()

void mlx_delete_image	(	mlx_t *	mlx,
		mlx_image_t *	image
	)

Deleting an image will remove it from the render queue as well as any and all instances it might have. Additionally, just as extra measures sets all the data to NULL.

If you simply wish to stop rendering an image without de-allocation set the 'enabled' boolean in the image struct.

Parameters

[in]	mlx	The MLX instance handle.
[in]	image	The image to delete.

Definition at line 204 of file mlx_images.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(image);
 
    mlx_ctx_t* mlxctx = mlx->context;
 
    // Delete all instances in the render queue
    mlx_list_t* quelst;
    while ((quelst = mlx_lstremove(&mlxctx->render_queue, image, &mlx_equal_inst)))
        mlx_freen(2, quelst->content, quelst);
 
    mlx_list_t* imglst;
    if ((imglst = mlx_lstremove(&mlxctx->images, image, &mlx_equal_image)))
    {
        glDeleteTextures(1, &((mlx_image_ctx_t*)image->context)->texture);
        mlx_freen(5, image->pixels, image->instances, image->context, imglst, image);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_draw_instance()

void mlx_draw_instance	(	mlx_ctx_t *	mlx,
		mlx_image_t *	img,
		mlx_instance_t *	instance
	)

Internal function to draw a single instance of an image to the screen.

Definition at line 63 of file mlx_images.c.

{
    float w = (float) img->width;
    float h = (float) img->height;
    float x = (float) instance->x;
    float y = (float) instance->y;
    float z = (float) instance->z;
    int8_t tex = mlx_bind_texture(mlx, img);
 
    vertex_t vertices[6] = {
            (vertex_t){x, y, z, 0.f, 0.f, tex},
            (vertex_t){x + w, y + h, z, 1.f, 1.f, tex},
            (vertex_t){x + w, y, z, 1.f, 0.f, tex},
            (vertex_t){x, y, z, 0.f, 0.f, tex},
            (vertex_t){x, y + h, z, 0.f, 1.f, tex},
            (vertex_t){x + w, y + h, z, 1.f, 1.f, tex},
    };
    memmove(mlx->batch_vertices + mlx->batch_size, vertices, sizeof(vertices));
    mlx->batch_size += 6;
 
    if (mlx->batch_size >= MLX_BATCH_SIZE)
        mlx_flush_batch(mlx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_flush_batch()

void mlx_flush_batch

(

mlx_ctx_t *

mlx

)

Definition at line 17 of file mlx_images.c.

{
    if (mlx->batch_size <= 0)
        return;
 
    glBindBuffer(GL_ARRAY_BUFFER, mlx->vbo);
    glBufferData(GL_ARRAY_BUFFER, mlx->batch_size * sizeof(vertex_t), mlx->batch_vertices, GL_STATIC_DRAW);
    glDrawArrays(GL_TRIANGLES, 0, mlx->batch_size);
 
    mlx->batch_size = 0;
    memset(mlx->bound_textures, 0, sizeof(mlx->bound_textures));
}

Here is the caller graph for this function:

mlx_grow_instances()

mlx_instance_t * mlx_grow_instances	(	mlx_image_t *	img,
		bool *	did_realloc
	)

Definition at line 87 of file mlx_images.c.

{
    mlx_image_ctx_t* const ctx = img->context;
    if (img->count >= ctx->instances_capacity)
    {
        if (ctx->instances_capacity == 0)
            ctx->instances_capacity = img->count;
        else
            ctx->instances_capacity *= 2;
        *did_realloc = true;
        return realloc(img->instances, ctx->instances_capacity * sizeof(mlx_instance_t));
    }
    *did_realloc = false;
    return img->instances;
}

Here is the caller graph for this function:

mlx_image_to_window()

int32_t mlx_image_to_window	(	mlx_t *	mlx,
		mlx_image_t *	img,
		int32_t	x,
		int32_t	y
	)

Draws a new instance of an image, it will then share the same pixel buffer as the image.

NOTE: Keep in mind that the instance array gets reallocated, try to store the return value to the instance! NOT the pointer! It will become invalid!

WARNING: Try to display as few images on the window as possible, drawing too many images will cause a loss in performance!

Parameters

[in]	mlx	The MLX instance handle.
[in]	img	The image to draw on the screen.
[in]	x	The X position.
[in]	y	The Y position.

Returns

Index to the instance, or -1 on failure.

Definition at line 121 of file mlx_images.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(img);
 
    // Allocate buffers...
    img->count++;
    bool did_realloc;
    mlx_instance_t* instances = mlx_grow_instances(img, &did_realloc);
    draw_queue_t* queue = calloc(1, sizeof(draw_queue_t));
    if (!instances || !queue)
    {
        if (did_realloc)
            free(instances);
        return (free(queue), mlx_error(MLX_MEMFAIL), -1);
    }
 
    // Set data...
    queue->image = img;
    int32_t index = queue->instanceid = img->count - 1;
    img->instances = instances;
    img->instances[index].x = x;
    img->instances[index].y = y;
 
    // NOTE: We keep updating the Z for the convenience of the user.
    // Always update Z depth to prevent overlapping images by default.
    img->instances[index].z = ((mlx_ctx_t*)mlx->context)->zdepth++;
    img->instances[index].enabled = true;
 
    // Add draw call...
    sort_queue = true;
    mlx_list_t* templst;
    if ((templst = mlx_lstnew(queue)))
    {
        mlx_lstadd_front(&((mlx_ctx_t*)mlx->context)->render_queue, templst);
        return (index);
    }
    return (mlx_freen(2, instances, queue), mlx_error(MLX_MEMFAIL), -1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_new_image()

mlx_image_t * mlx_new_image	(	mlx_t *	mlx,
		uint32_t	width,
		uint32_t	height
	)

Creates and allocates a new image buffer.

Parameters

[in]	mlx	The MLX instance handle.
[in]	width	The desired width of the image.
[in]	height	The desired height of the image.

Returns

Pointer to the image buffer, if it failed to allocate then NULL.

Definition at line 161 of file mlx_images.c.

{
    MLX_NONNULL(mlx);
 
    if (!width || !height || width > INT16_MAX || height > INT16_MAX)
        return ((void*)mlx_error(MLX_INVDIM));
 
    const mlx_ctx_t* mlxctx = mlx->context;
    mlx_image_t* newimg = calloc(1, sizeof(mlx_image_t));
    mlx_image_ctx_t* newctx = calloc(1, sizeof(mlx_image_ctx_t));
    if (!newimg || !newctx)
    {
        mlx_freen(2, newimg, newctx);
        return ((void *)mlx_error(MLX_MEMFAIL));
    }
    newimg->enabled = true;
    newimg->context = newctx;
    (*(uint32_t*)&newimg->width) = width;
    (*(uint32_t*)&newimg->height) = height;
    if (!(newimg->pixels = calloc(width * height, sizeof(int32_t))))
    {
        mlx_freen(2, newimg, newctx);
        return ((void *)mlx_error(MLX_MEMFAIL));
    }
 
    mlx_list_t* newentry;
    if (!(newentry = mlx_lstnew(newimg)))
    {
        mlx_freen(3, newimg->pixels, newimg->context, newimg);
        return ((void *)mlx_error(MLX_MEMFAIL));
    }
 
    // Generate OpenGL texture
    glGenTextures(1, &newctx->texture);
    glBindTexture(GL_TEXTURE_2D, newctx->texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    mlx_lstadd_front((mlx_list_t**)(&mlxctx->images), newentry);
    return (newimg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_resize_image()

bool mlx_resize_image	(	mlx_image_t *	img,
		uint32_t	nwidth,
		uint32_t	nheight
	)

Allows you to resize an image, a new pixel buffer is allocated to fit & the previous data is scaled to fit the new size.

Parameters

[in]	img	The image to resize.
[in]	nwidth	The new width.
[in]	nheight	The new height.

Returns

True if image was resized or false on error.

Definition at line 224 of file mlx_images.c.

{
    MLX_NONNULL(img);
 
    if (!nwidth || !nheight || nwidth > INT16_MAX || nheight > INT16_MAX)
        return (mlx_error(MLX_INVDIM));
    if (nwidth != img->width || nheight != img->height)
    {
        uint32_t* origin = (uint32_t*)img->pixels;
        float wstep = (float)img->width / nwidth;
        float hstep = (float)img->height / nheight;
 
        uint8_t* tempbuff = calloc(nwidth * nheight, BPP);
        if (!tempbuff)
            return (mlx_error(MLX_MEMFAIL));
        img->pixels = tempbuff;
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, nwidth, nheight, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->pixels);
 
        uint32_t* destin = (uint32_t*)img->pixels;
        for (uint32_t j = 0; j < nheight; j++)
            for (uint32_t i = 0; i < nwidth; i++)
                destin[j * nwidth + i] = origin[(uint32_t)(j * hstep) * img->width + (uint32_t)(i * wstep)];
        (*(uint32_t*)&img->width) = nwidth;
        (*(uint32_t*)&img->height) = nheight;
        free(origin);
    }
    return (true);
}

Here is the call graph for this function:

mlx_set_instance_depth()

void mlx_set_instance_depth	(	mlx_instance_t *	instance,
		int32_t	zdepth
	)

Sets the depth / Z axis value of an instance.

NOTE: Keep in mind that images that are on the same Z layer cut each other off. so if you don't see your image anymore make sure it's not conflicting by being on the same layer as another image.

Parameters

[in]	instance	The instance on which to change the depth.
[in]	zdepth	The new depth value.

NOTE: The reason why we don't sort directly is that the user might call this function multiple times in a row and we don't want to sort for every change. Pre-loop wise that is.

Definition at line 105 of file mlx_images.c.

{
    MLX_NONNULL(instance);
 
    if (instance->z == zdepth)
        return;
    instance->z = zdepth;
 
    /**
     * NOTE: The reason why we don't sort directly is that
     * the user might call this function multiple times in a row and we don't
     * want to sort for every change. Pre-loop wise that is.
     */
    sort_queue = true;
}