#include "raylib_bridge.h" #include "raylib.h" #include "rlgl.h" #include "raymath.h" #include #include #include #include #include static int sr_width = 1; static int sr_height = 1; // Render configuration supplied by the application (see renderConst.swift). static sr_config sr_cfg = { 0 }; // Cube transform (driven by the application, Euler degrees). static float sr_rot_x = 0.0f; static float sr_rot_y = 0.0f; static float sr_rot_z = 0.0f; static int sr_ready = 0; static Model sr_model = { 0 }; static int sr_has_model = 0; static Material sr_cube_material = { 0 }; static Material sr_cube_shadow_material = { 0 }; static Texture2D sr_cube_normal = { 0 }; static Model sr_ground_model = { 0 }; static Material sr_ground_material = { 0 }; static Material sr_ground_shadow_material = { 0 }; static Shader sr_main_shader = { 0 }; static Shader sr_shadow_shader = { 0 }; static int sr_shadow_fbo = 0; static unsigned int sr_shadow_color = 0; static unsigned int sr_shadow_depth = 0; static Matrix sr_light_view = { 0 }; static Matrix sr_light_proj = { 0 }; static Vector3 sr_light_pos = { 0.0f, 0.0f, 0.0f }; // Main shader uniform locations static int loc_light_pos = -1; static int loc_light_color = -1; static int loc_ambient = -1; static int loc_light_enabled = -1; static int loc_emissive = -1; static int loc_albedo_color = -1; static int loc_shadow_map = -1; static int loc_shadow_bias = -1; static int loc_shadow_softness = -1; static int loc_normal_map = -1; static int loc_normal_strength = -1; static int loc_light_mvp = -1; static int loc_is_ground = -1; static int loc_grid_color = -1; static int loc_camera_pos = -1; static int loc_fog_color = -1; static int loc_fog_start = -1; static int loc_fog_end = -1; // raylib is built as a static/dynamic library with GLFW baked in, but we never // call InitWindow(). Instead we render into an OpenGL context owned by the // macOS app, so we must supply the OpenGL entry point loader ourselves. static void *sr_gl_loader(const char *name) { static void *handle = NULL; if (handle == NULL) { handle = dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY | RTLD_LOCAL); } if (handle == NULL) return NULL; return dlsym(handle, name); } // Compose a model transform exactly like raylib's DrawModel() does, so the // matrices we feed to DrawMesh() match what rlgl computes internally. static Matrix sr_transform(Vector3 pos, float scale, float rx, float ry, float rz) { Matrix mat_scale = MatrixScale(scale, scale, scale); Matrix mat_rotation = MatrixRotateXYZ((Vector3){ rx * DEG2RAD, ry * DEG2RAD, rz * DEG2RAD }); Matrix mat_translation = MatrixTranslate(pos.x, pos.y, pos.z); return MatrixMultiply(MatrixMultiply(mat_scale, mat_rotation), mat_translation); } static void sr_load_shaders(const char *main_vs, const char *main_fs, const char *shadow_vs, const char *shadow_fs) { sr_main_shader = LoadShaderFromMemory(main_vs, main_fs); sr_shadow_shader = LoadShaderFromMemory(shadow_vs, shadow_fs); loc_light_pos = GetShaderLocation(sr_main_shader, "u_lightPos"); loc_light_color = GetShaderLocation(sr_main_shader, "u_lightColor"); loc_ambient = GetShaderLocation(sr_main_shader, "u_ambient"); loc_light_enabled = GetShaderLocation(sr_main_shader, "u_lightEnabled"); loc_emissive = GetShaderLocation(sr_main_shader, "u_emissive"); loc_albedo_color = GetShaderLocation(sr_main_shader, "u_albedoColor"); loc_shadow_map = GetShaderLocation(sr_main_shader, "u_shadowMap"); loc_shadow_bias = GetShaderLocation(sr_main_shader, "u_shadowBias"); loc_shadow_softness = GetShaderLocation(sr_main_shader, "u_shadowSoftness"); loc_normal_map = GetShaderLocation(sr_main_shader, "u_normalMap"); loc_normal_strength = GetShaderLocation(sr_main_shader, "u_normalStrength"); loc_light_mvp = GetShaderLocation(sr_main_shader, "u_lightMVP"); loc_is_ground = GetShaderLocation(sr_main_shader, "u_isGround"); loc_grid_color = GetShaderLocation(sr_main_shader, "u_gridColor"); loc_camera_pos = GetShaderLocation(sr_main_shader, "u_cameraPos"); loc_fog_color = GetShaderLocation(sr_main_shader, "u_fogColor"); loc_fog_start = GetShaderLocation(sr_main_shader, "u_fogStart"); loc_fog_end = GetShaderLocation(sr_main_shader, "u_fogEnd"); // Build a framebuffer whose depth attachment is a sampleable TEXTURE (raylib's // LoadRenderTexture() uses a non-sampleable renderbuffer, so we build it by hand). sr_shadow_fbo = rlLoadFramebuffer(); sr_shadow_color = rlLoadTexture(NULL, sr_cfg.shadow_size, sr_cfg.shadow_size, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1); sr_shadow_depth = rlLoadTextureDepth(sr_cfg.shadow_size, sr_cfg.shadow_size, false); rlEnableFramebuffer(sr_shadow_fbo); rlFramebufferAttach(sr_shadow_fbo, sr_shadow_color, RL_ATTACHMENT_COLOR_CHANNEL0, RL_ATTACHMENT_TEXTURE2D, 0); rlFramebufferAttach(sr_shadow_fbo, sr_shadow_depth, RL_ATTACHMENT_DEPTH, RL_ATTACHMENT_TEXTURE2D, 0); int shadow_ok = rlFramebufferComplete(sr_shadow_fbo); fprintf(stderr, "SR: shadow framebuffer %s\n", shadow_ok ? "complete" : "INCOMPLETE"); rlDisableFramebuffer(); } static void sr_build_ground(void) { Mesh ground_mesh = GenMeshPlane(sr_cfg.ground_size, sr_cfg.ground_size, 1, 1); sr_ground_model = LoadModelFromMesh(ground_mesh); sr_ground_material = LoadMaterialDefault(); sr_ground_material.shader = sr_main_shader; sr_ground_shadow_material = LoadMaterialDefault(); sr_ground_shadow_material.shader = sr_shadow_shader; } void sr_init(int width, int height, const char *main_vs, const char *main_fs, const char *shadow_vs, const char *shadow_fs, sr_config config) { if (width > 0) sr_width = width; if (height > 0) sr_height = height; sr_cfg = config; // raylib's default INFO logging is noisy; keep warnings and errors only. SetTraceLogLevel(LOG_WARNING); rlLoadExtensions(sr_gl_loader); rlglInit(sr_width, sr_height); sr_load_shaders(main_vs, main_fs, shadow_vs, shadow_fs); sr_build_ground(); sr_ready = 1; } void sr_load_model(const char *gltf_path) { if (!sr_ready || gltf_path == NULL) return; sr_model = LoadModel(gltf_path); sr_has_model = (sr_model.meshCount > 0); // The matching normal map sits next to the glTF; load it separately. char asset_dir[1024]; const char *slash = strrchr(gltf_path, '/'); size_t dir_len = (slash != NULL) ? (size_t)(slash - gltf_path + 1) : 0; snprintf(asset_dir, sizeof(asset_dir), "%.*s", (int)dir_len, gltf_path); if (sr_has_model) { int cube_mat_index = (sr_model.materialCount > 0) ? sr_model.meshMaterial[0] : 0; sr_cube_material = sr_model.materials[cube_mat_index]; sr_cube_material.shader = sr_main_shader; Texture2D base_tex = sr_cube_material.maps[MATERIAL_MAP_DIFFUSE].texture; SetTextureFilter(base_tex, TEXTURE_FILTER_BILINEAR); SetTextureWrap(base_tex, TEXTURE_WRAP_CLAMP); char normal_path[1024]; snprintf(normal_path, sizeof(normal_path), "%scube_normal.png", asset_dir); if (FileExists(normal_path)) { sr_cube_normal = LoadTexture(normal_path); SetTextureFilter(sr_cube_normal, TEXTURE_FILTER_BILINEAR); SetTextureWrap(sr_cube_normal, TEXTURE_WRAP_CLAMP); } sr_cube_shadow_material = sr_cube_material; sr_cube_shadow_material.shader = sr_shadow_shader; } else { fprintf(stderr, "SR: failed to load model: %s\n", gltf_path); } } void sr_resize(int width, int height) { if (width > 0) sr_width = width; if (height > 0) sr_height = height; } void sr_set_rotation(float x_deg, float y_deg, float z_deg) { sr_rot_x = x_deg; sr_rot_y = y_deg; sr_rot_z = z_deg; } static Matrix sr_cube_transform(void) { return sr_transform((Vector3){ 0.0f, 1.1f, 0.0f }, 1.0f, sr_rot_x, sr_rot_y, sr_rot_z); } static void sr_draw_object(Model model, Material material, Matrix model_mat, Texture2D normal, float is_ground, float emissive); static void sr_render_main_pass(void) { // --- Main pass: camera --- rlViewport(0, 0, sr_width, sr_height); rlSetFramebufferWidth(sr_width); rlSetFramebufferHeight(sr_height); rlClearColor(24, 26, 34, 255); rlClearScreenBuffers(); rlMatrixMode(RL_PROJECTION); rlPushMatrix(); rlLoadIdentity(); float aspect = (float)sr_width / (float)sr_height; double top = (double)sr_cfg.near_plane * tan((double)sr_cfg.fov_y * 0.5 * DEG2RAD); double right = top * (double)aspect; rlFrustum(-right, right, -top, top, (double)sr_cfg.near_plane, (double)sr_cfg.far_plane); rlMatrixMode(RL_MODELVIEW); rlLoadIdentity(); Vector3 eye = { 0.0f, 2.6f, 5.6f }; Vector3 target = { 0.0f, 1.0f, 0.0f }; Vector3 up = { 0.0f, 1.0f, 0.0f }; Matrix view = MatrixLookAt(eye, target, up); rlMultMatrixf(MatrixToFloat(view)); rlEnableDepthTest(); rlEnableBackfaceCulling(); rlSetCullFace(RL_CULL_FACE_BACK); rlEnableShader(sr_main_shader.id); Vector3 light_color = { 1.15f, 1.08f, 0.98f }; Vector3 ambient = { 0.30f, 0.32f, 0.38f }; Vector3 grid_color = { 0.45f, 0.62f, 0.95f }; Vector3 fog_color = { 24.0f / 255.0f, 26.0f / 255.0f, 34.0f / 255.0f }; float light_amount = 1.0f; float shadow_bias = 0.0025f; float shadow_softness = 4.0f; float fog_start = 10.0f; float fog_end = 34.0f; SetShaderValue(sr_main_shader, loc_light_pos, &sr_light_pos, SHADER_UNIFORM_VEC3); SetShaderValue(sr_main_shader, loc_light_color, &light_color, SHADER_UNIFORM_VEC3); SetShaderValue(sr_main_shader, loc_ambient, &ambient, SHADER_UNIFORM_VEC3); SetShaderValue(sr_main_shader, loc_light_enabled, &light_amount, SHADER_UNIFORM_FLOAT); SetShaderValue(sr_main_shader, loc_shadow_bias, &shadow_bias, SHADER_UNIFORM_FLOAT); SetShaderValue(sr_main_shader, loc_shadow_softness, &shadow_softness, SHADER_UNIFORM_FLOAT); SetShaderValue(sr_main_shader, loc_grid_color, &grid_color, SHADER_UNIFORM_VEC3); SetShaderValue(sr_main_shader, loc_camera_pos, &eye, SHADER_UNIFORM_VEC3); SetShaderValue(sr_main_shader, loc_fog_color, &fog_color, SHADER_UNIFORM_VEC3); SetShaderValue(sr_main_shader, loc_fog_start, &fog_start, SHADER_UNIFORM_FLOAT); SetShaderValue(sr_main_shader, loc_fog_end, &fog_end, SHADER_UNIFORM_FLOAT); int shadow_unit = 1; SetShaderValue(sr_main_shader, loc_shadow_map, &shadow_unit, SHADER_UNIFORM_INT); rlActiveTextureSlot(1); rlEnableTexture(sr_shadow_depth); rlActiveTextureSlot(0); // --- Ground (procedural grid floor) --- sr_draw_object(sr_ground_model, sr_ground_material, MatrixTranslate(0.0f, 0.0f, 0.0f), (Texture2D){ 0 }, 1.0f, 0.0f); // --- Cubes --- if (sr_has_model) { sr_draw_object(sr_model, sr_cube_material, sr_cube_transform(), sr_cube_normal, 0.0f, 0.0f); } // Flush while the projection/modelview matrices are still active, otherwise // rlgl draws the pending batch with the restored (2D) projection. rlDrawRenderBatchActive(); // --- Restore matrices (equivalent to raylib's EndMode3D) --- rlMatrixMode(RL_PROJECTION); rlPopMatrix(); rlMatrixMode(RL_MODELVIEW); rlLoadIdentity(); rlDisableDepthTest(); rlDisableBackfaceCulling(); } static void sr_render_shadow_pass(void) { rlViewport(0, 0, sr_cfg.shadow_size, sr_cfg.shadow_size); rlSetFramebufferWidth(sr_cfg.shadow_size); rlSetFramebufferHeight(sr_cfg.shadow_size); rlEnableFramebuffer(sr_shadow_fbo); rlClearColor(255, 255, 255, 255); rlClearScreenBuffers(); rlEnableDepthTest(); rlEnableBackfaceCulling(); rlSetCullFace(RL_CULL_FACE_FRONT); rlMatrixMode(RL_PROJECTION); rlPushMatrix(); rlLoadIdentity(); rlMultMatrixf(MatrixToFloat(sr_light_proj)); rlMatrixMode(RL_MODELVIEW); rlLoadIdentity(); rlMultMatrixf(MatrixToFloat(sr_light_view)); if (sr_has_model) { DrawMesh(sr_model.meshes[0], sr_cube_shadow_material, sr_cube_transform()); } rlDrawRenderBatchActive(); rlMatrixMode(RL_PROJECTION); rlPopMatrix(); rlSetCullFace(RL_CULL_FACE_BACK); rlDisableFramebuffer(); rlViewport(0, 0, sr_width, sr_height); rlSetFramebufferWidth(sr_width); rlSetFramebufferHeight(sr_height); rlDisableDepthTest(); } static void sr_set_light_mvp(Matrix model) { Matrix light_mvp = MatrixMultiply(MatrixMultiply(model, sr_light_view), sr_light_proj); SetShaderValueMatrix(sr_main_shader, loc_light_mvp, light_mvp); } static void sr_bind_normal(Texture2D tex) { int unit = 2; SetShaderValue(sr_main_shader, loc_normal_map, &unit, SHADER_UNIFORM_INT); rlActiveTextureSlot(2); if (tex.id > 0) rlEnableTexture(tex.id); rlActiveTextureSlot(0); } static void sr_draw_object(Model model, Material material, Matrix model_mat, Texture2D normal, float is_ground, float emissive) { sr_set_light_mvp(model_mat); float albedo[3] = { 1.0f, 1.0f, 1.0f }; float normal_strength = (normal.id > 0) ? 1.0f : 0.0f; SetShaderValue(sr_main_shader, loc_albedo_color, albedo, SHADER_UNIFORM_VEC3); SetShaderValue(sr_main_shader, loc_emissive, &emissive, SHADER_UNIFORM_FLOAT); SetShaderValue(sr_main_shader, loc_is_ground, &is_ground, SHADER_UNIFORM_FLOAT); SetShaderValue(sr_main_shader, loc_normal_strength, &normal_strength, SHADER_UNIFORM_FLOAT); sr_bind_normal(normal); DrawMesh(model.meshes[0], material, model_mat); } void sr_render(void) { if (!sr_ready) return; rlDrawRenderBatchActive(); // --- Light (point light above the scene) --- sr_light_pos = (Vector3){ 0.0f, 4.2f, 0.0f }; Vector3 light_target = (Vector3){ 0.0f, -2.0f, 0.0f }; Vector3 light_up = (Vector3){ 0.0f, 0.0f, -1.0f }; sr_light_view = MatrixLookAt(sr_light_pos, light_target, light_up); sr_light_proj = MatrixPerspective(90.0 * DEG2RAD, 1.0, 1.5, 16.0); sr_render_shadow_pass(); sr_render_main_pass(); } void sr_shutdown(void) { if (!sr_ready) return; if (sr_has_model) { UnloadModel(sr_model); sr_has_model = 0; } UnloadModel(sr_ground_model); if (sr_cube_normal.id > 0) { UnloadTexture(sr_cube_normal); sr_cube_normal.id = 0; } if (sr_shadow_color > 0) rlUnloadTexture(sr_shadow_color); if (sr_shadow_depth > 0) rlUnloadTexture(sr_shadow_depth); if (sr_shadow_fbo > 0) rlUnloadFramebuffer(sr_shadow_fbo); if (sr_main_shader.id > 0) UnloadShader(sr_main_shader); if (sr_shadow_shader.id > 0) UnloadShader(sr_shadow_shader); rlglClose(); sr_ready = 0; }