transfered from codeberg

source_code/block_module/block/block.c

@@ -0,0 +1,94 @@
+#include "block.h"
+#include "_internal/private_block.h"
+
+#include "texture_atlas_mapper.h"
+
+/**
+ * Retrieves the rendering data and metadata for a specific block identifier.
+ * * This function acts as a safe accessor for the global block library. It 
+ * performs bounds checking on the provided identifier to ensure it exists 
+ * within the library's memory range. If the identifier is invalid or 
+ * out of bounds, it returns the data for 'block_air' as a safe default 
+ * to prevent segmentation faults or undefined rendering behavior.
+ * * @param id_to_look_up The unique identifier of the block to retrieve.
+ * @return The rendering data structure corresponding to the block identifier.
+ */
+block_render_data_struct get_block_data(block_id_struct id_to_look_up) 
+{
+    if (id_to_look_up < 0 || 
+        id_to_look_up >= block_type_count) 
+    {
+        return _block_library[block_air];
+    }
+    
+    return _block_library[id_to_look_up];
+}
+
+/**
+ * Calculates the texture coordinates (UVs) for a specific face of a block.
+ * This function maps a block's texture index to a 2D position within a 16x16 
+ * texture atlas and handles the V-axis inversion required for OpenGL.
+ */
+void get_block_face_texture_coordinates(block_id_struct block_id, 
+                                        int32_t face_direction, 
+                                        float texture_coordinates[4][2])
+{
+        const int32_t texture_atlas_size = 16;
+        int32_t texture_index = 0;
+
+        /* Retrieve the specific texture index for the requested face */
+        switch (face_direction)
+        {
+                case face_top:    
+                        texture_index = get_block_data(block_id).texture.top;    
+                        break;
+                case face_bottom: 
+                        texture_index = get_block_data(block_id).texture.bottom; 
+                        break;
+                case face_front:  
+                        texture_index = get_block_data(block_id).texture.front;  
+                        break;
+                case face_back:   
+                        texture_index = get_block_data(block_id).texture.back;   
+                        break;
+                case face_left:   
+                        texture_index = get_block_data(block_id).texture.left;   
+                        break;
+                case face_right:  
+                        texture_index = get_block_data(block_id).texture.right;  
+                        break;
+        }
+
+        /* Determine the grid position within the atlas */
+        const int32_t atlas_column = texture_index % texture_atlas_size;
+        const int32_t atlas_row    = texture_index / texture_atlas_size;
+
+        /* Calculate the normalized coordinate steps */
+        const float coordinate_step = 1.0f / (float)texture_atlas_size;
+
+        const float horizontal_start = (float)atlas_column * coordinate_step;
+        const float vertical_start   = (float)atlas_row    * coordinate_step;
+
+        /* Invert the vertical axis to align with OpenGL's bottom-left origin */
+        const float vertical_minimum = 1.0f - (vertical_start + coordinate_step);
+        const float vertical_maximum = 1.0f - vertical_start;
+
+        const float horizontal_end = horizontal_start + coordinate_step;
+
+        /* Assign coordinates to the four vertices of the face quad */
+        // Top-Left vertex
+        texture_coordinates[0][0] = horizontal_start;
+        texture_coordinates[0][1] = vertical_maximum;
+
+        // Top-Right vertex
+        texture_coordinates[1][0] = horizontal_end;
+        texture_coordinates[1][1] = vertical_maximum;
+
+        // Bottom-Right vertex
+        texture_coordinates[2][0] = horizontal_end;
+        texture_coordinates[2][1] = vertical_minimum;
+
+        // Bottom-Left vertex
+        texture_coordinates[3][0] = horizontal_start;
+        texture_coordinates[3][1] = vertical_minimum;
+}