MLX42_Int.h File Reference

#include "MLX42/MLX42.h"
#include "lodepng/lodepng.h"
#include "glad/glad.h"
#include "KHR/khrplatform.h"
#include <GLFW/glfw3.h>
#include <stdlib.h>
#include <memory.h>
#include <stdio.h>
#include <limits.h>
#include <ctype.h>
#include <string.h>
#include <stdarg.h>
#include <assert.h>

Include dependency graph for MLX42_Int.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	vertex
struct	mlx_list
struct	mlx_srcoll
struct	mlx_mouse
struct	mlx_cursor
struct	mlx_close
struct	mlx_resize
struct	mlx_key
struct	mlx_hook
struct	mlx_ctx
struct	draw_queue
struct	mlx_image_ctx

Macros
#define	LODEPNG_NO_COMPILE_ALLOCATORS
#define	MLX_SWAP_INTERVAL   1
#define	MLX_BATCH_SIZE   12000
#define	BPP   sizeof(int32_t) /* Only support RGBA */
#define	GETLINE_BUFF   1280
#define	MLX_MAX_STRING   512 /* Arbitrary string limit */
#define	MLX_ASSERT(cond, msg)   assert(cond && msg);
#define	MLX_NONNULL(var)   MLX_ASSERT(var, "Value can't be null"); /* Assert instead of attribute */

Typedefs
typedef struct vertex	vertex_t
typedef struct mlx_list	mlx_list_t
typedef struct mlx_srcoll	mlx_scroll_t
typedef struct mlx_mouse	mlx_mouse_t
typedef struct mlx_cursor	mlx_cursor_t
typedef struct mlx_close	mlx_close_t
typedef struct mlx_resize	mlx_resize_t
typedef struct mlx_key	mlx_key_t
typedef struct mlx_hook	mlx_hook_t
typedef struct mlx_ctx	mlx_ctx_t
typedef struct draw_queue	draw_queue_t
typedef struct mlx_image_ctx	mlx_image_ctx_t

Functions
mlx_list_t *	mlx_lstnew (void *content)
mlx_list_t *	mlx_lstlast (mlx_list_t *lst)
int32_t	mlx_lstsize (mlx_list_t *lst)
void	mlx_lstclear (mlx_list_t **lst, void(*del)(void *))
void	mlx_lstadd_back (mlx_list_t **lst, mlx_list_t *new)
void	mlx_lstadd_front (mlx_list_t **lst, mlx_list_t *new)
mlx_list_t *	mlx_lstremove (mlx_list_t **lst, void *value, bool(*comp)(void *, void *))
void	mlx_sort_renderqueue (mlx_list_t **lst)
bool	mlx_equal_image (void *lstcontent, void *value)
bool	mlx_equal_inst (void *lstcontent, void *value)
void	mlx_draw_pixel (uint8_t *pixel, uint32_t color)
bool	mlx_error (mlx_errno_t val)
bool	mlx_freen (int32_t count,...)
void	mlx_update_matrix (const mlx_t *mlx)
void	mlx_draw_instance (mlx_ctx_t *mlx, mlx_image_t *img, mlx_instance_t *instance)
void	mlx_flush_batch (mlx_ctx_t *mlx)
bool	mlx_getline (char **out, size_t *out_size, FILE *file)
uint32_t	mlx_rgba_to_mono (uint32_t color)
int32_t	mlx_atoi_base (const char *str, int32_t base)
uint64_t	mlx_fnv_hash (char *str, size_t len)

Variables
const char *	vert_shader
const char *	frag_shader
bool	sort_queue
int32_t	mlx_settings [MLX_SETTINGS_MAX]

Macro Definition Documentation

BPP

#define BPP   sizeof(int32_t) /* Only support RGBA */

Definition at line 42 of file MLX42_Int.h.

GETLINE_BUFF

#define GETLINE_BUFF   1280

Definition at line 43 of file MLX42_Int.h.

LODEPNG_NO_COMPILE_ALLOCATORS

#define LODEPNG_NO_COMPILE_ALLOCATORS

Definition at line 15 of file MLX42_Int.h.

MLX_ASSERT

#define MLX_ASSERT	(		cond,
			msg
	)		assert(cond && msg);

Definition at line 45 of file MLX42_Int.h.

MLX_BATCH_SIZE

#define MLX_BATCH_SIZE   12000

Definition at line 40 of file MLX42_Int.h.

MLX_MAX_STRING

#define MLX_MAX_STRING   512 /* Arbitrary string limit */

Definition at line 44 of file MLX42_Int.h.

MLX_NONNULL

#define MLX_NONNULL

(

var

)

MLX_ASSERT(var, "Value can't be null"); /* Assert instead of attribute */

Definition at line 46 of file MLX42_Int.h.

MLX_SWAP_INTERVAL

#define MLX_SWAP_INTERVAL   1

Definition at line 37 of file MLX42_Int.h.

Typedef Documentation

draw_queue_t

typedef struct draw_queue draw_queue_t

mlx_close_t

typedef struct mlx_close mlx_close_t

mlx_ctx_t

typedef struct mlx_ctx mlx_ctx_t

For rendering we need to store most of OpenGL's stuff such as the vertex array object, vertex buffer object & the shader program as well as hooks and the zdepth level.

Additionally we represent draw calls with a linked list queue that points to the image and the index of its instance. Again, instances only carry XYZ data, so coupled with the image it lets us know where to draw a copy of the image.

Texture contexts are kept in a struct alongside the capacity of the array of instances, since the array is realloced like a vector.

mlx_cursor_t

typedef struct mlx_cursor mlx_cursor_t

mlx_hook_t

typedef struct mlx_hook mlx_hook_t

mlx_image_ctx_t

typedef struct mlx_image_ctx mlx_image_ctx_t

mlx_key_t

typedef struct mlx_key mlx_key_t

mlx_list_t

typedef struct mlx_list mlx_list_t

mlx_mouse_t

typedef struct mlx_mouse mlx_mouse_t

mlx_resize_t

typedef struct mlx_resize mlx_resize_t

mlx_scroll_t

typedef struct mlx_srcoll mlx_scroll_t

There are 2 types of hooks, special and generics.

Specials: Specials are specific callback functions to a specific action such as window resizing or key presses. These are attached to the callbacks of glfw. In case MLX itself needs the callback we call the specials in that callback since there can only ever be a single callback.

Generics: Generics are MLX42 specific hooks and can have multiple hooks at the same time, these are executed every frame and can be used as an alternative for keypresses or animations for instance.

NOTE: Hooks could be achieved with va_args to have any amount of args sized functor but we can't/don't want to let the user deal with va_args and having to look up what args are what, etc...

We want to keep it straightforward with functors already describing what params they have.

vertex_t

typedef struct vertex vertex_t

Function Documentation

mlx_atoi_base()

int32_t mlx_atoi_base	(	const char *	str,
		int32_t	base
	)

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_draw_pixel()

void mlx_draw_pixel	(	uint8_t *	pixel,
		uint32_t	color
	)

Definition at line 16 of file mlx_put_pixel.c.

{
    *(pixel++) = (uint8_t)(color >> 24);
    *(pixel++) = (uint8_t)(color >> 16);
    *(pixel++) = (uint8_t)(color >> 8);
    *(pixel++) = (uint8_t)(color & 0xFF);
}

Here is the caller graph for this function:

mlx_equal_image()

bool mlx_equal_image	(	void *	lstcontent,
		void *	value
	)

Definition at line 17 of file mlx_compare.c.

{
    const mlx_image_t* lcontent = lstcontent;
    const mlx_image_t* lvalue = value;
 
    return (lcontent == lvalue);
}

Here is the caller graph for this function:

mlx_equal_inst()

bool mlx_equal_inst	(	void *	lstcontent,
		void *	value
	)

Definition at line 25 of file mlx_compare.c.

{
    const draw_queue_t* lcontent = lstcontent;
    const mlx_image_t* lvalue = value;
 
    return (lcontent->image == lvalue);
}

Here is the caller graph for this function:

mlx_error()

bool mlx_error

(

mlx_errno_t

val

)

Functions to set the error number, simply for convenience.

Parameters

val	The error value.

Returns

Always false

Definition at line 43 of file mlx_error.c.

{
    mlx_errno = val;
#ifndef NDEBUG
    fprintf(stderr, "MLX42: %s", mlx_strerror(mlx_errno));
#endif
    return (false);
}

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_fnv_hash()

uint64_t mlx_fnv_hash	(	char *	str,
		size_t	len
	)

String hashing algorithm using FNV-1a. Source: https://bit.ly/3JcRGHa

Parameters

str	The string to hash
len	The length of the string.

Returns

The hashed output.

Definition at line 68 of file mlx_utils.c.

{
    const uint64_t fnv_prime = 0x100000001b3;
    const uint64_t fnv_offset = 0xcbf29ce484222325;
    uint64_t hash = fnv_offset;
 
    for (size_t i = 0; i < len; i++)
    {
        hash ^= str[i];
        hash *= fnv_prime;
    }
    return (hash);
}

Here is the caller graph for this function:

mlx_freen()

bool mlx_freen	(	int32_t	count,
			...
	)

Utility function that lets you free x amount of pointers.

Parameters

count	The amount of args provided.
...	Any form of pointer.

Returns

False, this is simply for convenience when necessary.

Definition at line 89 of file mlx_utils.c.

{
    va_list args;
 
    va_start(args, count);
    for (int32_t i = 0; i < count; i++)
        free(va_arg(args, void*));
    va_end(args);
    return (false);
}

Here is the caller graph for this function:

mlx_getline()

bool mlx_getline	(	char **	out,
		size_t *	out_size,
		FILE *	file
	)

Function to read a file stream line by line, reusing the same output pointer. Since the same output pointer is reused it should only be freed once, either on success or failure. This function is made to be somewhat similar to getline. Getline can't be used directly since it's not standard and therefore not available on all platforms.

Parameters

out	Pointer to store output string.
out_size	Pointer to store output strings length.
file	File stream to read from.

Returns

True if line was read, false if EOF was reached or an error occurred.

Definition at line 28 of file mlx_utils.c.

{
    MLX_NONNULL(out);
    MLX_NONNULL(out_size);
    MLX_NONNULL(file);
 
    size_t size = 0;
    char* temp = NULL;
    static char BUFF[GETLINE_BUFF + 1]; // Add space for '\0'
 
    if (*out) *out[0] = '\0';
 
    while (fgets(BUFF, sizeof(BUFF), file))
    {
        size += strlen(BUFF);
        if (!(temp = realloc(*out, sizeof(char) * size + 1)))
            return (false);
        if (*out == NULL)
            memset(temp, '\0', size);
        temp[size] = '\0';
 
        *out = temp;
        *out_size = size;
 
        strncat(*out, BUFF, size);
        if (strrchr(BUFF, '\n'))
            return (true);
        memset(BUFF, '\0', sizeof(BUFF));
    }
    return (size);
}

Here is the caller graph for this function:

mlx_lstadd_back()

void mlx_lstadd_back	(	mlx_list_t **	lst,
		mlx_list_t *	new
	)

Definition at line 67 of file mlx_list.c.

{
    if (!lst || !new)
        return;
    if (!*lst)
        *lst = new;
    else
    {
        mlx_list_t* temp = mlx_lstlast(*lst);
        new->prev = temp;
        temp->next = new;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_lstadd_front()

void mlx_lstadd_front	(	mlx_list_t **	lst,
		mlx_list_t *	new
	)

Definition at line 81 of file mlx_list.c.

{
    if (!lst || !new)
        return;
    if ((*lst) != NULL)
        (*lst)->prev = new;
    new->next = *lst;
    new->prev = NULL;
    *lst = new;
}

Here is the caller graph for this function:

mlx_lstclear()

void mlx_lstclear	(	mlx_list_t **	lst,
		void(*)(void *)	del
	)

Definition at line 33 of file mlx_list.c.

{
    mlx_list_t* next_lst;
 
    while (*lst != NULL)
    {
        next_lst = (*lst)->next;
        mlx_lstdelone(*lst, del);
        *lst = next_lst;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_lstlast()

mlx_list_t * mlx_lstlast

(

mlx_list_t *

lst

)

Definition at line 58 of file mlx_list.c.

{
    if (!lst)
        return (NULL);
    while (lst->next)
        lst = lst->next;
    return (lst);
}

Here is the caller graph for this function:

mlx_lstnew()

mlx_list_t * mlx_lstnew

(

void *

content

)

All sorts of internal functions shared in the library that should not be accessible to the user! No touch!

Definition at line 45 of file mlx_list.c.

{
    mlx_list_t* out = NULL;
 
    if ((out = malloc(sizeof(mlx_list_t))))
    {
        out->content = content;
        out->next = NULL;
        out->prev = NULL;
    }
    return (out);
}

Here is the caller graph for this function:

mlx_lstremove()

mlx_list_t * mlx_lstremove	(	mlx_list_t **	lst,
		void *	value,
		bool(*)(void *, void *)	comp
	)

Removes the specified content from the list, if found. Also fixes any relinking that might be needed.

Parameters

[in]	lst	The list
[in]	comp	Function to check if the content and value are the same.

Returns

The removed element, clean up as you wish.

Definition at line 100 of file mlx_list.c.

{
    mlx_list_t* lstcpy = *lst;
 
    while (lstcpy && !comp(lstcpy->content, value))
        lstcpy = lstcpy->next;
    if (lstcpy == NULL)
        return (NULL);
    if (lstcpy == *lst)
        *lst = lstcpy->next;
    if (lstcpy->next != NULL)
        lstcpy->next->prev = lstcpy->prev;
    if (lstcpy->prev != NULL)
        lstcpy->prev->next = lstcpy->next;
    return (lstcpy);
}

Here is the caller graph for this function:

mlx_lstsize()

int32_t mlx_lstsize

(

mlx_list_t *

lst

)

Definition at line 17 of file mlx_list.c.

{
    int32_t i;
 
    for (i = 0; lst != NULL; i++)
        lst = lst->next;
    return (i);
}

mlx_rgba_to_mono()

uint32_t mlx_rgba_to_mono

(

uint32_t

color

)

Converts an RGBA value to a monochrome/grayscale value. It does so using specific weights for each channel.

See also

https://goodcalculators.com/rgb-to-grayscale-conversion-calculator/

Parameters

color

The input RGBA value.

Returns

The rgba value converted to a grayscale color.

Definition at line 109 of file mlx_utils.c.

{
    const uint8_t r = 0.299f * ((color >> 24) & 0xFF);
    const uint8_t g = 0.587f * ((color >> 16) & 0xFF);
    const uint8_t b = 0.114f * ((color >> 8) & 0xFF);
    const uint8_t y = r + g + b;
 
    return (y << 24 | y << 16 | y << 8 | (color & 0xFF));
}

Here is the caller graph for this function:

mlx_sort_renderqueue()

void mlx_sort_renderqueue

(

mlx_list_t **

lst

)

Okay-ish sorting algorithm to sort the render queue / doubly linked list. We need to do this to fix transparency.

Parameters

lst	The render queue.

Definition at line 161 of file mlx_list.c.

{
    mlx_list_t* sorted = NULL;
    mlx_list_t* lstcpy = *lst;
 
    while (lstcpy != NULL)
    {
        mlx_list_t* next = lstcpy->next;
 
        // Separate entry out of list and insert it back but sorted.
        lstcpy->prev = lstcpy->next = NULL;
        mlx_insertsort(&sorted, lstcpy);
        lstcpy = next;
    }
    *lst = sorted;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_update_matrix()

void mlx_update_matrix

(

const mlx_t *

mlx

)

Recalculate the view projection matrix, used by images for screen pos Reference: https://bit.ly/3KuHOu1 (Matrix View Projection)

In case the setting to stretch the image is set, we maintain the width and height but not the depth.

Definition at line 21 of file mlx_window.c.

{
    const mlx_ctx_t* mlxctx = mlx->context;
    const float depth = mlxctx->zdepth;
 
    /**
     * In case the setting to stretch the image is set, we maintain the width and height but not
     * the depth.
     */
    const float width = mlx_settings[MLX_STRETCH_IMAGE] ? mlxctx->initialWidth : mlx->width;
    const float height = mlx_settings[MLX_STRETCH_IMAGE] ? mlxctx->initialHeight : mlx->height;
 
    const float matrix[16] = {
        2.f / width, 0, 0, 0,
        0, 2.f / -(height), 0, 0,
        0, 0, -2.f / (depth - -depth), 0,
        -1, -(height / -height),
        -((depth + -depth) / (depth - -depth)), 1
    };
 
    glUniformMatrix4fv(glGetUniformLocation(mlxctx->shaderprogram, "ProjMatrix"), 1, GL_FALSE, matrix);
}

Here is the caller graph for this function:

Variable Documentation

frag_shader

const char* frag_shader

extern

mlx_settings

int32_t mlx_settings[MLX_SETTINGS_MAX]

extern

Definition at line 160 of file mlx_init.c.

{false, false, false, true, false};

sort_queue

bool sort_queue

extern

Definition at line 162 of file mlx_init.c.

vert_shader

const char* vert_shader

extern

The shader code is extracted from the shader files and converted to a .c file as a single string at compile time. This keeps shader files external but still integrated into the program letting you use the executable anywhere without having to take the shaders with you.

Most modern frameworks like .NET do this by having resource files instead.

See: https://bit.ly/3LJYG0r