#include #include #include #include "../headers/rasteriver.h" #define STB_IMAGE_IMPLEMENTATION #include "../headers/stb_image.h" #include "stdint.h" #include #include RasterIver ri = {NULL}; void debug(char *string, ...){ va_list args; va_start(args, string); char message[500]; strcpy(message, ri.prefix); strcat(message, string); vprintf(message, args); printf("\n"); va_end(args); } RasterIver* RI_get_ri(){ return &ri; } #define RI_realloc(__ptr, __size) written_RI_realloc(__ptr, __size, __func__, __LINE__) #define RI_malloc(__size) written_RI_malloc(__size, __func__, __LINE__) #define RI_calloc(__nmemb, __size) written_RI_calloc(__nmemb, __size, __func__, __LINE__) #define RI_free(__ptr) written_RI_free(__ptr, __func__, __LINE__) void* written_RI_realloc(void *__ptr, size_t __size, const char *caller, int line){ void *pointer = realloc(__ptr, __size); if (ri.debug_memory) { int current_allocation_index = 0; int checking = 1; while (checking){ if (!ri.allocation_table[current_allocation_index].reallocated_free && ri.allocation_table[current_allocation_index].pointer == __ptr){ ri.allocation_table[current_allocation_index].reallocated_free = 1; checking = 0; } current_allocation_index++; if (current_allocation_index >= ri.allocation_search_limit){ checking = 0; } } debug("[Memory Manager] Allocated (realloc) %zu bytes (func \"%s\":%d)", __size, caller, line); if (ri.current_allocation_index >= ri.allocation_table_length){ ri.allocation_table_length += 50; ri.allocation_search_limit += 50; ri.allocation_table = RI_realloc(ri.allocation_table, sizeof(RI_memory_allocation) * ri.allocation_table_length); } ri.allocation_table[ri.current_allocation_index].allocated = 1; ri.allocation_table[ri.current_allocation_index].reallocated_alloc = 1; ri.allocation_table[ri.current_allocation_index].reallocated_free = 0; ri.allocation_table[ri.current_allocation_index].freed = 0; ri.allocation_table[ri.current_allocation_index].line = line; ri.allocation_table[ri.current_allocation_index].pointer = pointer; ri.allocation_table[ri.current_allocation_index].size = __size; ri.current_allocation_index++; } return pointer; } void* written_RI_malloc(size_t __size, const char *caller, int line){ void *pointer = malloc(__size); if (ri.debug_memory) { debug("[Memory Manager] Allocated (malloc) %zu bytes (func \"%s\":%d)", __size, caller, line); if (ri.current_allocation_index >= ri.allocation_table_length){ ri.allocation_table_length += 50; ri.allocation_search_limit += 50; ri.allocation_table = RI_realloc(ri.allocation_table, sizeof(RI_memory_allocation) * ri.allocation_table_length); } ri.allocation_table[ri.current_allocation_index].allocated = 1; ri.allocation_table[ri.current_allocation_index].reallocated_free = 0; ri.allocation_table[ri.current_allocation_index].reallocated_alloc = 0; ri.allocation_table[ri.current_allocation_index].freed = 0; ri.allocation_table[ri.current_allocation_index].line = line; ri.allocation_table[ri.current_allocation_index].pointer = pointer; ri.allocation_table[ri.current_allocation_index].size = __size; ri.current_allocation_index++; } return pointer; } void* written_RI_calloc(size_t __nmemb, size_t __size, const char *caller, int line){ void *pointer = calloc(__nmemb, __size); if (ri.debug_memory) { debug("[Memory Manager] Allocated (calloc) %zu bytes (func \"%s\":%d)", __size * __nmemb, caller, line); if (ri.current_allocation_index >= ri.allocation_table_length){ ri.allocation_table_length += 50; ri.allocation_search_limit += 50; ri.allocation_table = RI_realloc(ri.allocation_table, sizeof(RI_memory_allocation) * ri.allocation_table_length); } ri.allocation_table[ri.current_allocation_index].allocated = 1; ri.allocation_table[ri.current_allocation_index].reallocated_free = 0; ri.allocation_table[ri.current_allocation_index].reallocated_alloc = 0; ri.allocation_table[ri.current_allocation_index].freed = 0; ri.allocation_table[ri.current_allocation_index].line = line; ri.allocation_table[ri.current_allocation_index].pointer = pointer; ri.allocation_table[ri.current_allocation_index].size = __size * __nmemb; ri.current_allocation_index++; } return pointer; } void written_RI_free(void *__ptr, const char *caller, int line){ if (ri.debug_memory) { size_t size = 0; int current_allocation_index = 0; int checking = 1; while (checking){ if (!ri.allocation_table[current_allocation_index].reallocated_free && ri.allocation_table[current_allocation_index].pointer == __ptr){ size = ri.allocation_table[current_allocation_index].size; ri.allocation_table[current_allocation_index].freed = 1; checking = 0; } current_allocation_index++; if (current_allocation_index >= ri.allocation_search_limit){ checking = 0; } } debug("[Memory Manager] Freed %zu bytes (func \"%s\":%d)", size, caller, line); } free(__ptr); } RI_texture* RI_request_empty_texture(RI_vector_2 resolution){ RI_texture *new_texture = RI_malloc(sizeof(RI_texture)); new_texture->image_buffer = RI_malloc(sizeof(uint32_t) * resolution.x * resolution.y); new_texture->resolution = resolution; return new_texture; } void RI_clear_texture(RI_texture *target_texture){ for (int i = 0; i < target_texture->resolution.x * target_texture->resolution.y; ++i){ target_texture->image_buffer[i] = 0x00000000; } } void RI_draw_line(RI_texture *target_texture, RI_vector_2 point_a, RI_vector_2 point_b, uint32_t color){ int num_pixels = distance_2(point_a, point_b); for (int i = 0; i < num_pixels; ++i){ RI_vector_2 point_2_draw; vector_2_lerp(point_a, point_b, &point_2_draw, (double)i / (double)num_pixels); if (point_2_draw.x < 0 || point_2_draw.x >= target_texture->resolution.x || point_2_draw.y < 0 || point_2_draw.y >= target_texture->resolution.y) continue; target_texture->image_buffer[point_2_draw.y * target_texture->resolution.x + point_2_draw.x] = color; } } int ccw(RI_vector_2f a, RI_vector_2f b, RI_vector_2f c) { return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x); } int intersects_segments(RI_vector_2f a, RI_vector_2f b, RI_vector_2f c, RI_vector_2f d) { return (ccw(a, c, d) != ccw(b, c, d)) && (ccw(a, b, c) != ccw(a, b, d)); } int intersects(RI_vector_2f a, RI_vector_2f b, RI_vector_2f c){ RI_vector_2f d = {10000, c.y}; return intersects_segments(a, b, c, d); } void render_glyph(RI_texture *target_texture, RI_vector_2f position, float size, uint32_t color, int bezier_resolution, float units_per_em, SP_glyph *glyph){ // estimate int new_point_count = 0; int allocated_new_points = glyph->number_of_points * 3; RI_vector_2f *new_points = RI_malloc(sizeof(RI_vector_2f) * allocated_new_points); int *contour_ends = RI_malloc(sizeof(int) * glyph->number_of_contours); for (int contour = 0; contour < glyph->number_of_contours; ++contour){ // if we are at contour 0, point_start is 0. // if contour is > 0 but != 0, point_start is equal to the previous index int point_start = contour > 0 ? (glyph->contour_end_indicies[contour - 1] + 1) : 0; int point_offset = point_start; // find first on-curve point because the first point isn't always on the curves // while (!(glyph->flags[point_offset] & 1)){ // point_offset++; // } for (int point = 0; point <= glyph->contour_end_indicies[contour] + 1 - point_start; ++point){ if (new_point_count + 1 >= allocated_new_points){ allocated_new_points += 20; new_points = RI_realloc(new_points, sizeof(RI_vector_2f) * allocated_new_points); } int cur = (point % (glyph->contour_end_indicies[contour] + 1 - point_start) + point_offset); int next = ((point + 1) % (glyph->contour_end_indicies[contour] + 1 - point_start) + point_offset); new_points[new_point_count].x = (float)glyph->x_coords[cur] / units_per_em * size + position.x; new_points[new_point_count].y = (float)glyph->y_coords[cur] / units_per_em * size + position.y; new_point_count++; // if current and next glyph are both on or off the curve, add a point between them- if ((glyph->flags[cur] & 1) == (glyph->flags[next] & 1)){ vector_2f_lerp((RI_vector_2f){(float)glyph->x_coords[cur] / units_per_em * size + position.x, (float)glyph->y_coords[cur] / units_per_em * size + position.y}, (RI_vector_2f){(float)glyph->x_coords[next] / units_per_em * size + position.x, (float)glyph->y_coords[next] / units_per_em * size + position.y}, &new_points[new_point_count], 0.5); new_point_count++; } } contour_ends[contour] = new_point_count; } allocated_new_points = new_point_count; // maybe make multiple arrays that are lists of lines in increments of y values so that we dont have to check every line even if its above the pixel (the ray only goes to the right) RI_vector_2f *lines = RI_malloc(sizeof(RI_vector_2f) * (new_point_count / 2) * (bezier_resolution <= 1 ? 2 : bezier_resolution) + 30); for (int contour = 0; contour < glyph->number_of_contours; ++contour){ int p_start = (contour > 0 ? contour_ends[contour - 1] : 0); int p_end = contour_ends[contour]; for (int point = p_start; point < p_end - 2; point += 2){ RI_vector_2f point_a = new_points[point]; RI_vector_2f point_b = new_points[(point + 1)]; RI_vector_2f point_c = new_points[(point + 2)]; RI_vector_2f prev_point = new_points[point]; for (int i = 0; i < bezier_resolution; ++i){ float w = (float)(i + 1) / (float)bezier_resolution; RI_vector_2f bez_point; if (bezier_resolution <= 1) bez_point = point_c; else vector_2f_bezier_interpolate(point_a, point_b, point_c, &bez_point, w); lines[point + i] = prev_point; lines[point + i + 1] = bez_point; prev_point = bez_point; } } } for (int y = fmax((int)((float)glyph->y_min / (float)units_per_em * size) + position.y, 0.0); y < fmin((int)((float)glyph->y_max / (float)units_per_em * size) + position.y, target_texture->resolution.y); ++y){ for (int x = fmax((int)((float)glyph->x_min / (float)units_per_em * size) + position.x, 0.0); x < fmin((int)((float)glyph->x_max / (float)units_per_em * size) + position.x, target_texture->resolution.x); ++x){ int intersections = 0; for (int contour = 0; contour < glyph->number_of_contours; ++contour){ int p_start = (contour > 0 ? contour_ends[contour - 1] : 0); int p_end = contour_ends[contour]; for (int point = p_start; point < p_end - 2; point += 2){ for (int i = 0; i < bezier_resolution; ++i){ if(intersects(lines[point + i], lines[point + i + 1], (RI_vector_2f){x, y})) intersections++; } } } if (intersections % 2 != 0) target_texture->image_buffer[y * target_texture->resolution.x + x] = color; } } RI_free(new_points); RI_free(contour_ends); } void RI_render_text(SP_font *font, RI_texture *target_texture, RI_vector_2f position, uint32_t color, int bezier_resolution, float size, char *text){ int character_count = strlen(text); int current_advance_width = 0; RI_vector_2f glyph_position = position; for (int character_i = 0; character_i < character_count; ++character_i){ int glyph = font->unicode_to_glyph_indicies[text[character_i]]; if (glyph >= font->number_of_glyphs) glyph = 0; SP_glyph *current_glyph = &font->glyphs[glyph]; glyph_position.x = position.x + font->h_metrics[glyph].left_side_bearing / font->units_per_em * size; if (current_glyph->number_of_contours > 0){ render_glyph(target_texture, glyph_position, size, color, bezier_resolution, font->units_per_em, current_glyph); } else if (current_glyph->number_of_contours == 0){ // do nothing, glyph is empty } else { for (int k = 0; k < current_glyph->number_of_components; k++){ int c_glyph = current_glyph->components[k].glyph_index; float offset_x = (float)current_glyph->components[k].arg1; float offset_y = (float)current_glyph->components[k].arg2; glyph_position.x += offset_x / font->units_per_em * size; glyph_position.y += offset_y / font->units_per_em * size; render_glyph(target_texture, glyph_position, size, color, bezier_resolution, font->units_per_em, &font->glyphs[c_glyph]); glyph_position.x -= offset_x / font->units_per_em * size; glyph_position.y -= offset_y / font->units_per_em * size; } } position.x += (float)font->h_metrics[glyph].advance_width / font->units_per_em * size; } } int RI_add_actors_to_scene(int RI_number_of_actors_to_add_to_scene, RI_actor *actors, RI_scene *scene){ int previous_actor_count = scene->actor_count; scene->actor_count += RI_number_of_actors_to_add_to_scene; scene->actors = RI_realloc(scene->actors, sizeof(RI_actor *) * scene->actor_count); for (int i = 0; i < RI_number_of_actors_to_add_to_scene; ++i){ scene->actors[i + previous_actor_count] = &actors[i]; } return 0; } RI_scene* RI_request_scenes(int RI_number_of_requested_scenes){ int previous_scene_count = ri.scene_count; ri.scene_count += RI_number_of_requested_scenes; ri.scenes = RI_realloc(ri.scenes, sizeof(RI_scene) * ri.scene_count); for (int i = 0; i < RI_number_of_requested_scenes; ++i){ RI_scene new_scene = {0}; new_scene.actor_count = 0; new_scene.actors = NULL; new_scene.faces_to_render = NULL; new_scene.antialiasing_subsample_resolution = 4; ri.scenes[i + previous_scene_count] = new_scene; } return ri.scenes; } RI_actor* RI_request_actors(int RI_number_of_requested_actors){ int previous_actor_count = ri.actor_count; ri.actor_count += RI_number_of_requested_actors; ri.actors = RI_realloc(ri.actors, sizeof(RI_actor) * ri.actor_count); for (int i = 0; i < RI_number_of_requested_actors; ++i){ RI_actor new_actor = {0}; new_actor.mesh_reference = NULL; new_actor.material_reference = NULL; ri.actors[i + previous_actor_count] = new_actor; } return ri.actors; } RI_material* RI_request_materials(int RI_number_of_requested_materials){ ri.material_count += RI_number_of_requested_materials; ri.materials = RI_realloc(ri.materials, sizeof(RI_material) * ri.material_count); return ri.materials; } RI_texture* RI_request_textures(int RI_number_of_requested_textures, RI_texture_creation_data *texture_creation_data){ int previous_loaded_texture_count = ri.loaded_texture_count; ri.loaded_texture_count += RI_number_of_requested_textures; ri.loaded_textures = RI_realloc(ri.loaded_textures, sizeof(RI_texture) * ri.loaded_texture_count); for (int i = 0; i < RI_number_of_requested_textures; i++){ RI_texture new_texture = {0}; char *current_texture_filename = texture_creation_data[i].filename; unsigned char* temp_texture = stbi_load(current_texture_filename, &new_texture.resolution.x, &new_texture.resolution.y, NULL, 4); if(stbi_failure_reason()){ new_texture = ri.error_texture; } else { new_texture.image_buffer = RI_malloc(sizeof(uint32_t) * new_texture.resolution.x * new_texture.resolution.y); for (int i = 0; i < new_texture.resolution.x * new_texture.resolution.y; ++i){ unsigned char r = temp_texture[i * 4]; unsigned char g = temp_texture[i * 4 + 1]; unsigned char b = temp_texture[i * 4 + 2]; unsigned char a = temp_texture[i * 4 + 3]; new_texture.image_buffer[i] = (a << 24 | r << 16 | g << 8 | b); } } ri.loaded_textures[previous_loaded_texture_count + i] = new_texture; stbi_image_free(temp_texture); } return ri.loaded_textures; } RI_mesh* RI_request_meshes(int RI_number_of_requested_meshes, char **filenames, int RI_return_just_mesh){ int meshes_already_loaded_count = ri.loaded_mesh_count; RI_mesh* mesh; if (!RI_return_just_mesh) { ri.loaded_mesh_count += RI_number_of_requested_meshes; ri.loaded_meshes = RI_realloc(ri.loaded_meshes, sizeof(RI_mesh) * ri.loaded_mesh_count); } else { mesh = RI_malloc(sizeof(RI_mesh)); } for (int i = 0; i < RI_number_of_requested_meshes; i++){ RI_mesh new_mesh_data_struct = {0}; FILE *file = fopen(filenames[i], "r"); if (!file){ debug("[Mesh Loader] Error! File \"%s\" not found", filenames[i]); RI_stop(1); } char line[512]; while (fgets(line, sizeof(line), file)) { if (line[0] == 'f' && line[1] == ' ') { // face new_mesh_data_struct.face_count++; } else if (line[0] == 'v' && line[1] == ' ') { // vertex new_mesh_data_struct.vertex_count++; } else if (line[0] == 'v' && line[1] == 'n') { // normal new_mesh_data_struct.normal_count++; } else if (line[0] == 'v' && line[1] == 't') { // UV new_mesh_data_struct.uv_count++; } } fclose(file); new_mesh_data_struct.faces = RI_malloc(sizeof(RI_face) * new_mesh_data_struct.face_count); new_mesh_data_struct.vertex_positions = RI_malloc(sizeof(RI_vector_3f) * new_mesh_data_struct.vertex_count); new_mesh_data_struct.normals = RI_malloc(sizeof(RI_vector_3f) * new_mesh_data_struct.normal_count); new_mesh_data_struct.uvs = RI_malloc(sizeof(RI_vector_2f) * new_mesh_data_struct.uv_count); FILE *file_again = fopen(filenames[i], "r"); int current_face_index = 0; int current_vertex_index = 0; int current_normal_index = 0; int current_uv_index = 0; int has_normals, has_uvs; has_normals = has_uvs = 0; while (fgets(line, sizeof(line), file_again)) { if (line[0] == 'f' && line[1] == ' ') { int vertex_0_index, vertex_1_index, vertex_2_index, normal_0_index, normal_1_index, normal_2_index, uv_0_index, uv_1_index, uv_2_index; int matches = sscanf(line, "f %d/%d/%d %d/%d/%d %d/%d/%d/", &vertex_0_index, &uv_0_index, &normal_0_index, &vertex_1_index, &uv_1_index, &normal_1_index, &vertex_2_index, &uv_2_index, &normal_2_index); if (matches != 9){ vertex_0_index = -1; vertex_1_index = -1; vertex_2_index = -1; normal_0_index = -1; normal_1_index = -1; normal_2_index = -1; uv_0_index = -1; uv_1_index = -1; uv_2_index = -1; if (strchr(line, '/')){ sscanf(line, "f %d//%d %d//%d %d//%d", &vertex_0_index, &normal_0_index, &vertex_1_index, &normal_1_index, &vertex_2_index, &normal_2_index); has_normals = 1; } else { sscanf(line, "f %d %d %d", &vertex_0_index, &vertex_1_index, &vertex_2_index); } } else { has_normals = has_uvs = 1; } new_mesh_data_struct.faces[current_face_index].position_0_index = vertex_0_index - 1; new_mesh_data_struct.faces[current_face_index].position_1_index = vertex_1_index - 1; new_mesh_data_struct.faces[current_face_index].position_2_index = vertex_2_index - 1; new_mesh_data_struct.faces[current_face_index].normal_0_index = normal_0_index - 1; new_mesh_data_struct.faces[current_face_index].normal_1_index = normal_1_index - 1; new_mesh_data_struct.faces[current_face_index].normal_2_index = normal_2_index - 1; new_mesh_data_struct.faces[current_face_index].uv_0_index = uv_0_index - 1; new_mesh_data_struct.faces[current_face_index].uv_1_index = uv_1_index - 1; new_mesh_data_struct.faces[current_face_index].uv_2_index = uv_2_index - 1; new_mesh_data_struct.faces[current_face_index].should_render = 1; ++current_face_index; } else if (line[0] == 'v' && line[1] == ' ') { double x, y, z; sscanf(line, "v %lf %lf %lf", &x, &y, &z); new_mesh_data_struct.vertex_positions[current_vertex_index].x = x; new_mesh_data_struct.vertex_positions[current_vertex_index].y = y; new_mesh_data_struct.vertex_positions[current_vertex_index].z = z; ++current_vertex_index; } else if (line[0] == 'v' && line[1] == 'n') { double x, y, z; sscanf(line, "vn %lf %lf %lf", &x, &y, &z); new_mesh_data_struct.normals[current_normal_index].x = x; new_mesh_data_struct.normals[current_normal_index].y = y; new_mesh_data_struct.normals[current_normal_index].z = z; ++current_normal_index; } else if (line[0] == 'v' && line[1] == 't') { double x, y, z; sscanf(line, "vt %lf %lf %lf", &x, &y, &z); new_mesh_data_struct.uvs[current_uv_index].x = x; new_mesh_data_struct.uvs[current_uv_index].y = y; // UVS are almost always 2D so we don't need Z (the type itself is a vector 2f, not 3f) ++current_uv_index; } } char* loading_mesh_notice_string; if (has_normals && !has_uvs) loading_mesh_notice_string = "normals"; else if (!has_normals && has_uvs) loading_mesh_notice_string = "UVs"; else if (!has_normals && !has_uvs) loading_mesh_notice_string = "normals and UVs"; if (!has_normals || !has_uvs) debug("[Mesh Loader] Notice! Mesh \"%s\" is missing %s", filenames[i], loading_mesh_notice_string); new_mesh_data_struct.has_normals = has_normals; new_mesh_data_struct.has_uvs = has_uvs; // fclose(file_again); if (!RI_return_just_mesh) { ri.loaded_meshes[meshes_already_loaded_count + i] = new_mesh_data_struct; debug("[Mesh Loader] Loaded mesh \"%s\"! %d faces, %d verticies, %d normals, %d uvs", filenames[i], current_face_index, current_vertex_index, current_normal_index, current_uv_index); } else { *mesh = new_mesh_data_struct; } } if (!RI_return_just_mesh) return ri.loaded_meshes; else return mesh; } void quaternion_rotate(RI_vector_3f *position, RI_vector_4f rotation){ RI_vector_4f pos_quat = {0, position->x, position->y, position->z}; RI_vector_4f rotation_conjugation = rotation; quaternion_conjugate(&rotation_conjugation); quaternion_multiply(&rotation, pos_quat); quaternion_multiply(&rotation, rotation_conjugation); *position = (RI_vector_3f){rotation.x, rotation.y, rotation.z}; } void RI_euler_rotation_to_quaternion(RI_vector_4f *quaternion, RI_vector_3f euler_rotation){ double cx = cosf(euler_rotation.x * 0.5f); double sx = sinf(euler_rotation.x * 0.5f); double cy = cosf(euler_rotation.y * 0.5f); double sy = sinf(euler_rotation.y * 0.5f); double cz = cosf(euler_rotation.z * 0.5f); double sz = sinf(euler_rotation.z * 0.5f); quaternion->w = cx * cy * cz + sx * sy * sz; quaternion->x = sx * cy * cz - cx * sy * sz; quaternion->y = cx * sy * cz + sx * cy * sz; quaternion->z = cx * cy * sz - sx * sy * cz; } double mod(double a, double b){ if(b < 0.0) return -mod(-a, -b); double ret = fmod(a, b); if(ret < 0.0) ret+=b; return ret; } uint32_t multiply_rgb(uint32_t color, float factor) { uint8_t a = (color >> 24) & 0xFF; uint8_t r = (color >> 16) & 0xFF; uint8_t g = (color >> 8) & 0xFF; uint8_t b = color & 0xFF; r = (uint8_t)fminf(fmaxf(r * factor, 0.0f), 255.0f); g = (uint8_t)fminf(fmaxf(g * factor, 0.0f), 255.0f); b = (uint8_t)fminf(fmaxf(b * factor, 0.0f), 255.0f); return (a << 24) | (r << 16) | (g << 8) | b; } int RI_render(RI_scene *scene, RI_texture *target_texture, int clear_texture){ // do rendering stuff if (ri.running){ double horizontal_fov_factor = target_texture->resolution.x / tanf(0.5 * scene->FOV); double vertical_fov_factor = target_texture->resolution.y / tanf(0.5 * scene->FOV); scene->min_clip = scene->minimum_clip_distance; if (!scene->faces_to_render){ int total_faces = 0; for (int actor_index = 0; actor_index < scene->actor_count; ++actor_index){ total_faces += scene->actors[actor_index]->mesh_reference->face_count; } scene->faces_to_render = RI_malloc(sizeof(RI_renderable_face) * total_faces * 2); // x2 because faces can be split scene->face_count = total_faces; } memset(scene->faces_to_render, 0, sizeof(RI_renderable_face) * scene->face_count * 2); int current_renderable_face_index = 0; int current_split_renderable_face_index = 0; for (int actor_index = 0; actor_index < scene->actor_count; ++actor_index){ RI_actor *current_actor = scene->actors[actor_index]; for (int face_index = 0; face_index < current_actor->mesh_reference->face_count; ++face_index){ RI_face *cur_face = ¤t_actor->mesh_reference->faces[face_index]; if (!cur_face->should_render){ continue; } int vert_pos_0_index = cur_face->position_0_index; int vert_pos_1_index = cur_face->position_1_index; int vert_pos_2_index = cur_face->position_2_index; int normal_0_index = cur_face->normal_0_index; int normal_1_index = cur_face->normal_1_index; int normal_2_index = cur_face->normal_2_index; int uv_0_index = cur_face->uv_0_index; int uv_1_index = cur_face->uv_1_index; int uv_2_index = cur_face->uv_2_index; RI_renderable_face *cur_r_face = &scene->faces_to_render[current_renderable_face_index]; cur_r_face->parent_actor = current_actor; cur_r_face->shrunk = 0; cur_r_face->split = 0; cur_r_face->material_reference = current_actor->material_reference; cur_r_face->position_0 = current_actor->mesh_reference->vertex_positions[vert_pos_0_index]; cur_r_face->position_1 = current_actor->mesh_reference->vertex_positions[vert_pos_1_index]; cur_r_face->position_2 = current_actor->mesh_reference->vertex_positions[vert_pos_2_index]; if (current_actor->mesh_reference->has_uvs){ cur_r_face->uv_0 = current_actor->mesh_reference->uvs[uv_0_index]; cur_r_face->uv_1 = current_actor->mesh_reference->uvs[uv_1_index]; cur_r_face->uv_2 = current_actor->mesh_reference->uvs[uv_2_index]; } // scale vector_3f_hadamard(&cur_r_face->position_0, current_actor->transform.scale); vector_3f_hadamard(&cur_r_face->position_1, current_actor->transform.scale); vector_3f_hadamard(&cur_r_face->position_2, current_actor->transform.scale); // actor rotation quaternion_rotate(&cur_r_face->position_0, current_actor->transform.rotation); quaternion_rotate(&cur_r_face->position_1, current_actor->transform.rotation); quaternion_rotate(&cur_r_face->position_2, current_actor->transform.rotation); // object position vector_3f_element_wise_add(&cur_r_face->position_0, current_actor->transform.position); vector_3f_element_wise_add(&cur_r_face->position_1, current_actor->transform.position); vector_3f_element_wise_add(&cur_r_face->position_2, current_actor->transform.position); // camera rotation vector_3f_element_wise_subtract(&cur_r_face->position_0, scene->camera_position); vector_3f_element_wise_subtract(&cur_r_face->position_1, scene->camera_position); vector_3f_element_wise_subtract(&cur_r_face->position_2, scene->camera_position); quaternion_rotate(&cur_r_face->position_0, scene->camera_rotation); quaternion_rotate(&cur_r_face->position_1, scene->camera_rotation); quaternion_rotate(&cur_r_face->position_2, scene->camera_rotation); // camera position // vector_3f_element_wise_subtract(&cur_r_face->position_0, scene->camera_position); // vector_3f_element_wise_subtract(&cur_r_face->position_1, scene->camera_position); // vector_3f_element_wise_subtract(&cur_r_face->position_2, scene->camera_position); RI_vector_3f *pos_0 = &cur_r_face->position_0; RI_vector_3f *pos_1 = &cur_r_face->position_1; RI_vector_3f *pos_2 = &cur_r_face->position_2; int is_0_clipped = pos_0->z < scene->min_clip; int is_1_clipped = pos_1->z < scene->min_clip; int is_2_clipped = pos_2->z < scene->min_clip; int clip_count = is_0_clipped + is_1_clipped + is_2_clipped; cur_r_face->should_render = 1; switch(clip_count){ case 3: // ignore polygon, it's behind the camera continue; break; case 2:{ // shrink poylgon RI_vector_3f *unclipped_point, *point_a, *point_b; RI_vector_3f *unclipped_normal, *normal_a, *normal_b; RI_vector_2f *unclipped_uv, *uv_a, *uv_b; if (!is_0_clipped){ unclipped_point = &cur_r_face->position_0; point_a = &cur_r_face->position_1; point_b = &cur_r_face->position_2; unclipped_normal = &cur_r_face->normal_0; normal_a = &cur_r_face->normal_1; normal_b = &cur_r_face->normal_2; unclipped_uv = &cur_r_face->uv_0; uv_a = &cur_r_face->uv_1; uv_b = &cur_r_face->uv_2; } else if (!is_1_clipped){ unclipped_point = &cur_r_face->position_1; point_a = &cur_r_face->position_2; point_b = &cur_r_face->position_0; unclipped_normal = &cur_r_face->normal_1; normal_a = &cur_r_face->normal_2; normal_b = &cur_r_face->normal_0; unclipped_uv = &cur_r_face->uv_1; uv_a = &cur_r_face->uv_2; uv_b = &cur_r_face->uv_0; } else if (!is_2_clipped){ unclipped_point = &cur_r_face->position_2; point_a = &cur_r_face->position_0; point_b = &cur_r_face->position_1; unclipped_normal = &cur_r_face->normal_2; normal_a = &cur_r_face->normal_0; normal_b = &cur_r_face->normal_1; unclipped_uv = &cur_r_face->uv_2; uv_a = &cur_r_face->uv_0; uv_b = &cur_r_face->uv_1; } double fraction_a_to_unclip = (scene->min_clip - unclipped_point->z) / (point_a->z - unclipped_point->z); double fraction_b_to_unclip = (scene->min_clip - unclipped_point->z) / (point_b->z - unclipped_point->z); vector_3f_lerp(*unclipped_point, *point_a, point_a, fraction_a_to_unclip); vector_3f_lerp(*unclipped_point, *point_b, point_b, fraction_b_to_unclip); vector_3f_lerp(*unclipped_normal, *normal_a, normal_a, fraction_a_to_unclip); vector_3f_lerp(*unclipped_normal, *normal_b, normal_b, fraction_b_to_unclip); vector_2f_lerp(*unclipped_uv, *uv_a, uv_a, fraction_a_to_unclip); vector_2f_lerp(*unclipped_uv, *uv_b, uv_b, fraction_b_to_unclip); cur_r_face->shrunk = 1; break;} case 1: // split polygon RI_vector_3f clipped_point, point_a, point_b; RI_vector_3f clipped_normal, normal_a, normal_b; RI_vector_2f clipped_uv, uv_a, uv_b; cur_r_face->split = 1; if (is_0_clipped){ clipped_point = cur_r_face->position_0; point_a = cur_r_face->position_1; point_b = cur_r_face->position_2; clipped_normal = cur_r_face->normal_0; normal_a = cur_r_face->normal_1; normal_b = cur_r_face->normal_2; clipped_uv = cur_r_face->uv_0; uv_a = cur_r_face->uv_1; uv_b = cur_r_face->uv_2; } else if (is_1_clipped){ clipped_point = cur_r_face->position_1; point_a = cur_r_face->position_2; point_b = cur_r_face->position_0; clipped_normal = cur_r_face->normal_1; normal_a = cur_r_face->normal_2; normal_b = cur_r_face->normal_0; clipped_uv = cur_r_face->uv_1; uv_a = cur_r_face->uv_2; uv_b = cur_r_face->uv_0; } else if (is_2_clipped){ clipped_point = cur_r_face->position_2; point_a = cur_r_face->position_0; point_b = cur_r_face->position_1; clipped_normal = cur_r_face->normal_2; normal_a = cur_r_face->normal_0; normal_b = cur_r_face->normal_1; clipped_uv = cur_r_face->uv_2; uv_a = cur_r_face->uv_0; uv_b = cur_r_face->uv_1; } double fraction_a_to_clip = (scene->min_clip - clipped_point.z) / (point_a.z - clipped_point.z); double fraction_b_to_clip = (scene->min_clip - clipped_point.z) / (point_b.z - clipped_point.z); RI_vector_3f new_point_a, new_point_b; // the new points that move along the polygon's edge to match the z value of min_clip. RI_vector_3f new_normal_a, new_normal_b; // they come from the clipped point which was originally only 1 RI_vector_2f new_uv_a, new_uv_b; vector_3f_lerp(clipped_point, point_a, &new_point_a, fraction_a_to_clip); vector_3f_lerp(clipped_point, point_b, &new_point_b, fraction_b_to_clip); vector_3f_lerp(clipped_normal, normal_a, &new_normal_a, fraction_a_to_clip); vector_3f_lerp(clipped_normal, normal_b, &new_normal_b, fraction_b_to_clip); vector_2f_lerp(clipped_uv, uv_a, &new_uv_a, fraction_a_to_clip); vector_2f_lerp(clipped_uv, uv_b, &new_uv_b, fraction_b_to_clip); // okay, now we have a quad (in clockwise order, point a, point b, new point b, new point a) // quads are easy to turn into tris >w< RI_renderable_face *cur_r_split_face = &scene->faces_to_render[scene->face_count + current_split_renderable_face_index]; cur_r_split_face->parent_actor = current_actor; cur_r_split_face->should_render = 1; cur_r_split_face->material_reference = cur_r_face->material_reference; cur_r_face->position_0 = point_a; cur_r_face->position_1 = point_b; cur_r_face->position_2 = new_point_a; cur_r_face->normal_0 = normal_a; cur_r_face->normal_1 = normal_b; cur_r_face->normal_2 = new_normal_a; cur_r_face->uv_0 = uv_a; cur_r_face->uv_1 = uv_b; cur_r_face->uv_2 = new_uv_a; cur_r_split_face->position_0 = point_b; cur_r_split_face->position_1 = new_point_b; cur_r_split_face->position_2 = new_point_a; cur_r_split_face->normal_0 = normal_b; cur_r_split_face->normal_1 = new_normal_b; cur_r_split_face->normal_2 = new_normal_a; cur_r_split_face->uv_0 = uv_b; cur_r_split_face->uv_1 = new_uv_b; cur_r_split_face->uv_2 = new_uv_a; cur_r_split_face->position_0.x = cur_r_split_face->position_0.x / cur_r_split_face->position_0.z * horizontal_fov_factor; cur_r_split_face->position_0.y = cur_r_split_face->position_0.y / cur_r_split_face->position_0.z * vertical_fov_factor; cur_r_split_face->position_1.x = cur_r_split_face->position_1.x / cur_r_split_face->position_1.z * horizontal_fov_factor; cur_r_split_face->position_1.y = cur_r_split_face->position_1.y / cur_r_split_face->position_1.z * vertical_fov_factor; cur_r_split_face->position_2.x = cur_r_split_face->position_2.x / cur_r_split_face->position_2.z * horizontal_fov_factor; cur_r_split_face->position_2.y = cur_r_split_face->position_2.y / cur_r_split_face->position_2.z * vertical_fov_factor; cur_r_split_face->min_screen_x = cur_r_split_face->position_0.x; if (cur_r_split_face->position_1.x < cur_r_split_face->min_screen_x) cur_r_split_face->min_screen_x = cur_r_split_face->position_1.x; if (cur_r_split_face->position_2.x < cur_r_split_face->min_screen_x) cur_r_split_face->min_screen_x = cur_r_split_face->position_2.x; cur_r_split_face->min_screen_x = fmax(cur_r_split_face->min_screen_x, -target_texture->resolution.x / 2); cur_r_split_face->max_screen_x = cur_r_split_face->position_0.x; if (cur_r_split_face->position_1.x > cur_r_split_face->max_screen_x) cur_r_split_face->max_screen_x = cur_r_split_face->position_1.x; if (cur_r_split_face->position_2.x > cur_r_split_face->max_screen_x) cur_r_split_face->max_screen_x = cur_r_split_face->position_2.x; cur_r_split_face->max_screen_x = fmin(cur_r_split_face->max_screen_x, target_texture->resolution.x / 2); cur_r_split_face->min_screen_y = cur_r_split_face->position_0.y; if (cur_r_split_face->position_1.y < cur_r_split_face->min_screen_y) cur_r_split_face->min_screen_y = cur_r_split_face->position_1.y; if (cur_r_split_face->position_2.y < cur_r_split_face->min_screen_y) cur_r_split_face->min_screen_y = cur_r_split_face->position_2.y; cur_r_split_face->min_screen_y = fmax(cur_r_split_face->min_screen_y, -target_texture->resolution.y / 2); cur_r_split_face->max_screen_y = cur_r_split_face->position_0.y; if (cur_r_split_face->position_1.y > cur_r_split_face->max_screen_y) cur_r_split_face->max_screen_y = cur_r_split_face->position_1.y; if (cur_r_split_face->position_2.y > cur_r_split_face->max_screen_y) cur_r_split_face->max_screen_y = cur_r_split_face->position_2.y; cur_r_split_face->max_screen_y = fmin(cur_r_split_face->max_screen_y, target_texture->resolution.y / 2); ++current_split_renderable_face_index; break; case 0: // no issues, ignore break; } cur_r_face->position_0.x = cur_r_face->position_0.x / cur_r_face->position_0.z * horizontal_fov_factor; cur_r_face->position_0.y = cur_r_face->position_0.y / cur_r_face->position_0.z * vertical_fov_factor; cur_r_face->position_1.x = cur_r_face->position_1.x / cur_r_face->position_1.z * horizontal_fov_factor; cur_r_face->position_1.y = cur_r_face->position_1.y / cur_r_face->position_1.z * vertical_fov_factor; cur_r_face->position_2.x = cur_r_face->position_2.x / cur_r_face->position_2.z * horizontal_fov_factor; cur_r_face->position_2.y = cur_r_face->position_2.y / cur_r_face->position_2.z * vertical_fov_factor; cur_r_face->min_screen_x = pos_0->x; if (pos_1->x < cur_r_face->min_screen_x) cur_r_face->min_screen_x = pos_1->x; if (pos_2->x < cur_r_face->min_screen_x) cur_r_face->min_screen_x = pos_2->x; cur_r_face->min_screen_x = fmax(cur_r_face->min_screen_x, -target_texture->resolution.x / 2); cur_r_face->max_screen_x = pos_0->x; if (pos_1->x > cur_r_face->max_screen_x) cur_r_face->max_screen_x = pos_1->x; if (pos_2->x > cur_r_face->max_screen_x) cur_r_face->max_screen_x = pos_2->x; cur_r_face->max_screen_x = fmin(cur_r_face->max_screen_x, target_texture->resolution.x / 2); cur_r_face->min_screen_y = pos_0->y; if (pos_1->y < cur_r_face->min_screen_y) cur_r_face->min_screen_y = pos_1->y; if (pos_2->y < cur_r_face->min_screen_y) cur_r_face->min_screen_y = pos_2->y; cur_r_face->min_screen_y = fmax(cur_r_face->min_screen_y, -target_texture->resolution.y / 2); cur_r_face->max_screen_y = pos_0->y; if (pos_1->y > cur_r_face->max_screen_y) cur_r_face->max_screen_y = pos_1->y; if (pos_2->y > cur_r_face->max_screen_y) cur_r_face->max_screen_y = pos_2->y; cur_r_face->max_screen_y = fmin(cur_r_face->max_screen_y, target_texture->resolution.y / 2); ++current_renderable_face_index; } } if (ri.z_buffer_resolution.x * ri.z_buffer_resolution.y < target_texture->resolution.x * target_texture->resolution.y){ ri.z_buffer = RI_realloc(ri.z_buffer, sizeof(double) * target_texture->resolution.x * target_texture->resolution.y); } for (int pixel_index = 0; pixel_index < target_texture->resolution.x * target_texture->resolution.y; ++pixel_index){ if (clear_texture) target_texture->image_buffer[pixel_index] = 0xFF333333; ri.z_buffer[pixel_index] = 999999999; } for (int face_index = 0; face_index < current_renderable_face_index * 2; ++face_index){ RI_renderable_face *current_face = &scene->faces_to_render[face_index]; if (!current_face->should_render) continue; RI_material *mat = current_face->material_reference; RI_vector_2f *uv_0 = ¤t_face->uv_0; RI_vector_2f *uv_1 = ¤t_face->uv_1; RI_vector_2f *uv_2 = ¤t_face->uv_2; RI_vector_3f *normal_0 = ¤t_face->normal_0; RI_vector_3f *normal_1 = ¤t_face->normal_1; RI_vector_3f *normal_2 = ¤t_face->normal_2; if (mat == NULL){ mat = &ri.error_material; } if(mat->flags & RI_MATERIAL_HAS_TEXTURE && mat->texture_reference == NULL){ mat->texture_reference = &ri.error_texture; } if(mat->flags & RI_MATERIAL_HAS_BUMP_MAP && mat->bump_map_reference == NULL){ mat->bump_map_reference = &ri.error_bump_map; } if(mat->flags & RI_MATERIAL_HAS_NORMAL_MAP && mat->normal_map_reference == NULL){ mat->normal_map_reference = &ri.error_normal_map; } RI_vector_3f *pos_0 = ¤t_face->position_0; RI_vector_3f *pos_1 = ¤t_face->position_1; RI_vector_3f *pos_2 = ¤t_face->position_2; for (int pixel_y_index = current_face->min_screen_y; pixel_y_index < current_face->max_screen_y; ++pixel_y_index){ for (int pixel_x_index = current_face->min_screen_x; pixel_x_index < current_face->max_screen_x; ++pixel_x_index){ int x = pixel_x_index + target_texture->resolution.x / 2; int y = pixel_y_index + target_texture->resolution.y / 2; if (x < 0 || x >= target_texture->resolution.x || y < 0 || y >= target_texture->resolution.y) continue; double denominator, w0, w1, w2; denominator = (pos_1->y - pos_2->y) * (pos_0->x - pos_2->x) + (pos_2->x - pos_1->x) * (pos_0->y - pos_2->y); w0 = ((pos_1->y - pos_2->y) * (pixel_x_index - pos_2->x) + (pos_2->x - pos_1->x) * (pixel_y_index - pos_2->y)) / denominator; w1 = ((pos_2->y - pos_0->y) * (pixel_x_index - pos_0->x) + (pos_0->x - pos_2->x) * (pixel_y_index - pos_0->y)) / denominator; w2 = 1.0 - w0 - w1; if (!(mat->flags & RI_MATERIAL_DOUBLE_SIDED || scene->flags & RI_SCENE_DOUBLE_SIDED) && denominator > 0){ continue; } double w_over_z = (w0 / pos_0->z + w1 / pos_1->z + w2 / pos_2->z); double interpolated_z = 1.0 / w_over_z; if (scene->flags & RI_SCENE_DEBUG_AABB) { target_texture->image_buffer[y * target_texture->resolution.x + x] += 0x0F0F0707; continue; } if (!(w0 >= 0 && w1 >= 0 && w2 >= 0) || ((mat->flags & RI_MATERIAL_WIREFRAME || scene->flags & RI_SCENE_WIREFRAME) && (w0 >= mat->wireframe_width && w1 >= mat->wireframe_width && w2 >= mat->wireframe_width))){ continue; } if (!(mat->flags & RI_MATERIAL_DONT_DEPTH_TEST) && interpolated_z >= ri.z_buffer[y * target_texture->resolution.x + x]){ continue; } if (scene->flags & RI_SCENE_DEBUG_OVERDRAW) { target_texture->image_buffer[y * target_texture->resolution.x + x] += 0x0F070F07; continue; } double alpha = 1; if (!(scene->flags & RI_SCENE_DONT_USE_AA) || !(mat->flags & RI_MATERIAL_DONT_USE_AA)){ float total_inside = 0; for (float sub_y = 1.0 / (-scene->antialiasing_subsample_resolution / 2.0) - 0.5; sub_y < 1.0 / (scene->antialiasing_subsample_resolution / 2.0) - 0.5; sub_y += 1.0 / (scene->antialiasing_subsample_resolution / 2.0)){ for (float sub_x = 1.0 / (-scene->antialiasing_subsample_resolution / 2.0) - 0.5; sub_x < 1.0 / (scene->antialiasing_subsample_resolution / 2.0) - 0.5; sub_x += 1.0 / (scene->antialiasing_subsample_resolution / 2.0)){ w0 = ((pos_1->y - pos_2->y) * (pixel_x_index + sub_x - pos_2->x) + (pos_2->x - pos_1->x) * (pixel_y_index + sub_y - pos_2->y)) / denominator; w1 = ((pos_2->y - pos_0->y) * (pixel_x_index + sub_x - pos_0->x) + (pos_0->x - pos_2->x) * (pixel_y_index + sub_y - pos_0->y)) / denominator; w2 = 1.0 - w0 - w1; if(!(w0 >= 0 && w1 >= 0 && w2 >= 0)) total_inside++; } } alpha = 1.0 - total_inside / (scene->antialiasing_subsample_resolution * scene->antialiasing_subsample_resolution); } uint32_t pixel_color = 0x00000000; double ux, uy; ux = uy = -1; RI_vector_3f normal = {0}; if (normal_0){ normal.x = (w0 * (normal_0->x / pos_0->z) + w1 * (normal_1->x / pos_1->z) + w2 * (normal_2->x / pos_2->z)) / w_over_z; normal.y = (w0 * (normal_0->y / pos_0->z) + w1 * (normal_1->y / pos_1->z) + w2 * (normal_2->y / pos_2->z)) / w_over_z; normal.z = (w0 * (normal_0->z / pos_0->z) + w1 * (normal_1->z / pos_1->z) + w2 * (normal_2->z / pos_2->z)) / w_over_z; } if (mat->flags & RI_MATERIAL_HAS_TEXTURE && uv_0 && uv_1 && uv_2){ ux = (w0 * (uv_0->x / pos_0->z) + w1 * (uv_1->x / pos_1->z) + w2 * (uv_2->x / pos_2->z)) / w_over_z; uy = (w0 * (uv_0->y / pos_0->z) + w1 * (uv_1->y / pos_1->z) + w2 * (uv_2->y / pos_2->z)) / w_over_z; if (mat->flags & RI_MATERIAL_USE_UV_LOOP_MULTIPLIER){ ux *= mat->uv_loop_multiplier.x; uy *= mat->uv_loop_multiplier.y; } if (mat->flags & RI_MATERIAL_USE_UV_RENDER_RESOLUTION){ ux *= (current_face->parent_actor->transform.scale.x / mat->texture_render_size.x); uy *= (current_face->parent_actor->transform.scale.y / mat->texture_render_size.y); } if (mat->flags & RI_MATERIAL_USE_UV_LOOP_MULTIPLIER || mat->flags & RI_MATERIAL_USE_UV_RENDER_RESOLUTION){ ux = mod(ux, 1.0); uy = mod(-uy, 1.0); } else{ ux = fmax(fmin(ux, 1.0), 0.0); uy = fmax(fmin(1.0 - uy, 1.0), 0.0); } RI_vector_2 texel_position = {mat->texture_reference->resolution.x * ux, mat->texture_reference->resolution.y * uy}; if (texel_position.y * mat->texture_reference->resolution.x + texel_position.x < 0 || texel_position.y * mat->texture_reference->resolution.x + texel_position.x >= mat->texture_reference->resolution.x * mat->texture_reference->resolution.y) pixel_color = 0xFFFF00FF; else pixel_color = mat->texture_reference->image_buffer[texel_position.y * mat->texture_reference->resolution.x + texel_position.x]; } else { // must be only an albedo if (mat->albedo) pixel_color = mat->albedo; else pixel_color = 0xFFFF77FF; } // tri culling debug // if (face_index >= current_renderable_face_index) pixel_color = 0xFF7777FF; // if (face_index < scene->face_count) pixel_color = 0xFF77FF77; // flip the texture // x = target_texture->resolution.x - 1 - x; // y = target_texture->resolution.y - 1 - y; if (scene->flags & RI_SCENE_DEBUG_CULLS){ // show unchanged tris in grey, shrunk tris in blue, split triangles in green (old tri) and red (new tri) if (current_face->shrunk) pixel_color = 0xFF7777FF; else if (current_face->split) pixel_color = 0xFF77FF77; else if (face_index >= current_renderable_face_index) pixel_color = 0xFFFF7777; else pixel_color = 0xFF777777; } double shader_result = 1; if (current_face->material_reference->shader_function_pointer != NULL) shader_result = current_face->material_reference->shader_function_pointer(x, y, *pos_0, *pos_1, *pos_2, normal, (RI_vector_2f){ux, uy}, pixel_color); // set alpha after checking shader result becuase things with alpha 0 should still depth write if (shader_result <= 0) continue; alpha = shader_result; if (!(mat->flags & RI_MATERIAL_DONT_DEPTH_WRITE)){ ri.z_buffer[y * target_texture->resolution.x + x] = interpolated_z; } if (x >= 0 && y >= 0 && x < target_texture->resolution.x && y < target_texture->resolution.y){ target_texture->image_buffer[y * target_texture->resolution.x + x] = pixel_color; } } } } } else{ RI_stop(0); } return 0; } void RI_tick(int clear_window_texture_after_rendering){ SDL_UpdateTexture(ri.texture, NULL, ri.frame_buffer->image_buffer, ri.window_width * sizeof(uint32_t)); SDL_RenderClear(ri.renderer); SDL_RenderCopyEx(ri.renderer, ri.texture, NULL, NULL, 0, NULL, SDL_FLIP_VERTICAL); SDL_RenderPresent(ri.renderer); // handle SDL events while (SDL_PollEvent(&ri.event)){ switch (ri.event.type){ case SDL_QUIT: ri.running = 0; } } if (clear_window_texture_after_rendering){ RI_clear_texture(ri.frame_buffer); } ++ri.frame; } int opencl_init(){ cl_int cl_result; cl_result = clGetPlatformIDs(1, &ri.cl_platform, &ri.cl_number_of_platforms); if (cl_result != CL_SUCCESS || ri.cl_number_of_platforms == 0) { debug("[OpenCL Init] Error! No OpenCL platforms"); RI_stop(1); } cl_result = clGetDeviceIDs(ri.cl_platform, CL_DEVICE_TYPE_GPU, 1, &ri.cl_device, &ri.cl_number_of_devices); if (cl_result != CL_SUCCESS || ri.cl_number_of_devices == 0) { debug("[OpenCL Init] Error! No OpenCL devices"); RI_stop(1); } ri.cl_context = clCreateContext(NULL, 1, &ri.cl_device, NULL, NULL, &cl_result); ri.cl_command_queue = clCreateCommandQueue(ri.cl_context, ri.cl_device, 0, &cl_result); return 0; } int sdl_init(int RI_window_width, int RI_window_height, char *RI_window_title){ ri.window_width = RI_window_width; ri.window_height = RI_window_height; ri.window_title = RI_window_title; ri.frame_buffer = RI_malloc(sizeof(RI_texture)); ri.frame_buffer->image_buffer = RI_malloc(sizeof(uint32_t) * ri.window_width * ri.window_height); ri.frame_buffer->resolution = (RI_vector_2){ri.window_width, ri.window_height}; ri.z_buffer = RI_malloc(sizeof(double) * ri.window_width * ri.window_height); ri.z_buffer_resolution = (RI_vector_2){ri.window_width, ri.window_height}; SDL_Init(SDL_INIT_VIDEO); ri.window = SDL_CreateWindow(RI_window_title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, ri.window_width, ri.window_height, SDL_WINDOW_OPENGL); ri.renderer = SDL_CreateRenderer(ri.window, -1, SDL_RENDERER_ACCELERATED); ri.texture = SDL_CreateTexture(ri.renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, ri.window_width, ri.window_height); return 0; } int RI_stop(int result){ debug("[Notice] Stopping..."); for (int scene_index = 0; scene_index < ri.scene_count; ++scene_index){ RI_free(ri.scenes[scene_index].faces_to_render); RI_free(ri.scenes[scene_index].actors); } for (int mesh_index = 0; mesh_index < ri.loaded_mesh_count; ++mesh_index){ RI_free(ri.loaded_meshes[mesh_index].faces); RI_free(ri.loaded_meshes[mesh_index].vertex_positions); RI_free(ri.loaded_meshes[mesh_index].normals); RI_free(ri.loaded_meshes[mesh_index].uvs); } for (int texture_index = 0; texture_index < ri.loaded_texture_count; ++texture_index){ RI_free(ri.loaded_textures[texture_index].image_buffer); } RI_free(ri.loaded_meshes); RI_free(ri.loaded_textures); RI_free(ri.materials); RI_free(ri.actors); RI_free(ri.scenes); RI_free(ri.error_texture.image_buffer); RI_free(ri.frame_buffer->image_buffer); RI_free(ri.frame_buffer); RI_free(ri.z_buffer); RI_free(ri.error_mesh.faces); RI_free(ri.error_mesh.vertex_positions); RI_free(ri.error_mesh.normals); RI_free(ri.error_mesh.uvs); if (ri.debug_memory){ size_t total_allocated = 0; size_t allocated = 0; size_t alloc_realloc = 0; size_t total_freed = 0; size_t freed = 0; size_t reallocated = 0; for (int i = 1; i < ri.allocation_table_length; ++i) { if (ri.allocation_table[i].allocated != 1) continue; else if (ri.allocation_table[i].freed) freed += ri.allocation_table[i].size; else debug("[Memory Manager] Memory allocated at line %d wasn't freed (%zu bytes)", ri.allocation_table[i].line, ri.allocation_table[i].size); if (!ri.allocation_table[i].reallocated_free && !ri.allocation_table[i].reallocated_alloc) allocated += ri.allocation_table[i].size; else if (ri.allocation_table[i].reallocated_alloc) alloc_realloc += ri.allocation_table[i].size; else if (ri.allocation_table[i].reallocated_free) reallocated += ri.allocation_table[i].size; } total_allocated = allocated + alloc_realloc; total_freed = freed + reallocated; debug("[Memory Manager] [Total Bytes Allocated] M(c)alloc & Realloc(): %zu -- M(c)alloc(): %zu -- Realloc(): %zu", total_allocated, allocated, alloc_realloc); debug("[Memory Manager] [Total Bytes Freed] Free() & Realloc(): %zu -- Free(): %zu -- Realloc(): %zu", total_freed, freed, reallocated); if (total_allocated != total_freed){ debug("[Memory Manager] %zu bytes not freed", total_allocated - total_freed); } debug("[Memory Manager] Freeing allocation table..."); RI_free(ri.allocation_table); } return 0; } void signal_interupt_handler(int signal) { debug("Recieved SIGINT"); RI_stop(1); } int RI_init(int RI_window_width, int RI_window_height, char *RI_window_title){ signal(SIGINT, signal_interupt_handler); ri.running = 1; ri.prefix = "[RasterIver] "; if (ri.debug_memory){ ri.current_allocation_index = 0; ri.allocation_search_limit = 100; ri.allocation_table_length = 100; size_t __size = sizeof(RI_memory_allocation) * ri.allocation_table_length; ri.allocation_table = malloc(__size); debug("[Memory Manager] Allocated (malloc) %zu bytes", __size); ri.allocation_table[ri.current_allocation_index].allocated = 1; ri.allocation_table[ri.current_allocation_index].freed = 0; ri.allocation_table[ri.current_allocation_index].reallocated_alloc = 0; ri.allocation_table[ri.current_allocation_index].reallocated_free = 0; ri.allocation_table[ri.current_allocation_index].pointer = ri.allocation_table; ri.allocation_table[ri.current_allocation_index].size = __size; ri.current_allocation_index++; } // opencl_init(); sdl_init(RI_window_width, RI_window_height, RI_window_title); ri.loaded_mesh_count = 0; ri.loaded_texture_count = 0; ri.actor_count = 0; char **error_cube_file = RI_malloc(sizeof(char *)); error_cube_file[0] = "objects/unit_cube.obj"; RI_mesh* error_mesh = RI_request_meshes(1, error_cube_file, 1); ri.error_mesh = *error_mesh; RI_free(error_mesh); RI_free(error_cube_file); ri.error_texture.image_buffer = RI_malloc(sizeof(uint32_t)); ri.error_texture.image_buffer[0] = 0xFFFF00FF; ri.error_texture.resolution = (RI_vector_2){1, 1}; ri.error_material.texture_reference = &ri.error_texture; ri.error_material.albedo = 0xFF5522CC; ri.error_material.flags = RI_MATERIAL_UNLIT | RI_MATERIAL_DONT_DEPTH_TEST | RI_MATERIAL_DONT_RECEIVE_SHADOW | RI_MATERIAL_HAS_TEXTURE | RI_MATERIAL_DOUBLE_SIDED; return 0; }