├── .circleci └── config.yml ├── .clang-format ├── .editorconfig ├── .gitattributes ├── .gitignore ├── .gitlab-ci.yml ├── .gitlab └── ci │ ├── jobs │ ├── alpine-3-gcc-dedicated.yml │ ├── alpine-3-gcc.yml │ ├── batocera-arm64.yml │ ├── debian-oldstable-amd64.yml │ ├── debian-oldstable-arm64.yml │ ├── debian-stable-amd64.yml │ ├── debian-stable-arm64.yml │ ├── debian-stable-clang-amd64.yml │ ├── debian-stable-i386.yml │ ├── debian-testing-clang-amd64.yml │ ├── debian-testing-gcc-amd64.yml │ ├── macos-arm64.yml │ ├── macos-x86_64.yml │ ├── osxccross-universal.yml │ ├── windows-x64.yml │ └── windows-x86.yml │ └── templates │ └── srb2ci.yml ├── .travis.yml ├── Android.mk ├── CMakeLists.txt ├── CMakePresets.json ├── LICENSE ├── LICENSE-3RD-PARTY.txt ├── README.md ├── alias-bootstrap.sh ├── android ├── .classpath ├── .project ├── .settings │ └── org.eclipse.jdt.core.prefs ├── Android.mk ├── AndroidManifest.xml ├── default.properties ├── gen │ └── org │ │ └── srb2 │ │ └── R.java ├── res │ ├── drawable-hdpi │ │ └── icon.png │ ├── drawable-ldpi │ │ └── icon.png │ ├── drawable-mdpi │ │ └── icon.png │ ├── layout │ │ └── main.xml │ └── values │ │ └── strings.xml └── src │ └── org │ └── srb2 │ ├── GameThread.java │ ├── SRB2Game.java │ └── nativecode │ ├── Main.java │ ├── SRB2.java │ └── Video.java ├── appveyor.yml ├── assets ├── .gitignore ├── CMakeLists.txt ├── HISTORY.txt ├── LICENSE-3RD-PARTY.txt ├── LICENSE.txt ├── README.txt └── debian-template │ ├── README.Debian │ ├── README.source │ ├── changelog │ ├── compat │ ├── control │ ├── copyright │ ├── rules │ └── source │ ├── format │ └── options ├── cmake ├── Comptime.cmake └── Modules │ ├── CMakeASM_YASMInformation.cmake │ ├── CMakeDetermineASM_YASMCompiler.cmake │ ├── CMakeTestASM_YASMCompiler.cmake │ ├── FindGME.cmake │ ├── FindOgg.cmake │ ├── FindSDL2.cmake │ ├── FindSDL2_main.cmake │ ├── FindVPX.cmake │ ├── FindVorbis.cmake │ ├── FindVorbisEnc.cmake │ ├── FindYUV.cmake │ ├── GitUtilities.cmake │ └── LibFindMacros.cmake ├── comptime.bat ├── comptime.sh ├── custom-git-commands └── git-build ├── debian-template ├── README.Debian ├── README.source ├── changelog ├── compat ├── control ├── copyright ├── docs ├── rules ├── source │ ├── format │ └── options └── srb2.desktop ├── debian_template.sh ├── deployer ├── appveyor │ └── deployer.bat └── travis │ ├── deployer.sh │ ├── deployer_build.sh │ ├── deployer_defaults.sh │ ├── deployer_dput.sh │ └── deployer_ftp.sh ├── docs ├── logo.png └── udmf.txt ├── scripts ├── arm64-osx-1015.cmake ├── make-macos-universal.sh └── x64-osx-1015.cmake ├── srb2.png ├── srb2banner.png ├── src ├── .gitignore ├── Android.mk ├── CMakeLists.txt ├── Makefile.d │ ├── detect.mk │ ├── dummy.mk │ ├── features.mk │ ├── nix.mk │ ├── old.mk │ ├── platform.mk │ ├── sdl.mk │ ├── util.mk │ ├── versions.mk │ └── win32.mk ├── acs │ ├── CMakeLists.txt │ ├── acsvm.hpp │ ├── call-funcs.cpp │ ├── call-funcs.hpp │ ├── environment.cpp │ ├── environment.hpp │ ├── interface.cpp │ ├── interface.h │ ├── stream.cpp │ ├── stream.hpp │ ├── thread.cpp │ ├── thread.hpp │ └── vm │ │ ├── ACSVM │ │ ├── Action.cpp │ │ ├── Action.hpp │ │ ├── Array.cpp │ │ ├── Array.hpp │ │ ├── BinaryIO.cpp │ │ ├── BinaryIO.hpp │ │ ├── CMakeLists.txt │ │ ├── CallFunc.cpp │ │ ├── CallFunc.hpp │ │ ├── Code.hpp │ │ ├── CodeData.cpp │ │ ├── CodeData.hpp │ │ ├── CodeList.hpp │ │ ├── Environment.cpp │ │ ├── Environment.hpp │ │ ├── Error.cpp │ │ ├── Error.hpp │ │ ├── Function.cpp │ │ ├── Function.hpp │ │ ├── HashMap.hpp │ │ ├── HashMapFixed.hpp │ │ ├── ID.hpp │ │ ├── Init.cpp │ │ ├── Init.hpp │ │ ├── Jump.cpp │ │ ├── Jump.hpp │ │ ├── List.hpp │ │ ├── Module.cpp │ │ ├── Module.hpp │ │ ├── ModuleACS0.cpp │ │ ├── ModuleACSE.cpp │ │ ├── PrintBuf.cpp │ │ ├── PrintBuf.hpp │ │ ├── Scope.cpp │ │ ├── Scope.hpp │ │ ├── Script.cpp │ │ ├── Script.hpp │ │ ├── Serial.cpp │ │ ├── Serial.hpp │ │ ├── Stack.hpp │ │ ├── Store.hpp │ │ ├── String.cpp │ │ ├── String.hpp │ │ ├── Thread.cpp │ │ ├── Thread.hpp │ │ ├── ThreadExec.cpp │ │ ├── Tracer.cpp │ │ ├── Tracer.hpp │ │ ├── Types.hpp │ │ └── Vector.hpp │ │ ├── CMakeLists.txt │ │ ├── COPYING │ │ ├── README │ │ ├── Util │ │ ├── CMakeLists.txt │ │ ├── Floats.cpp │ │ └── Floats.hpp │ │ └── doc │ │ └── ACSVM.txt ├── am_map.c ├── am_map.h ├── android │ ├── README │ ├── i_cdmus.c │ ├── i_main.c │ ├── i_net.c │ ├── i_sound.c │ ├── i_system.c │ ├── i_video.c │ ├── i_video.h │ └── jni_main.h ├── apng.c ├── apng.h ├── archive_wrapper.hpp ├── asm_defs.inc ├── audio │ ├── CMakeLists.txt │ ├── chunk_load.cpp │ ├── chunk_load.hpp │ ├── expand_mono.cpp │ ├── expand_mono.hpp │ ├── filter.cpp │ ├── filter.hpp │ ├── gain.cpp │ ├── gain.hpp │ ├── mixer.cpp │ ├── mixer.hpp │ ├── music_player.cpp │ ├── music_player.hpp │ ├── ogg.cpp │ ├── ogg.hpp │ ├── ogg_player.cpp │ ├── ogg_player.hpp │ ├── resample.cpp │ ├── resample.hpp │ ├── sample.hpp │ ├── sound_chunk.hpp │ ├── sound_effect_player.cpp │ ├── sound_effect_player.hpp │ ├── source.hpp │ ├── wav.cpp │ ├── wav.hpp │ ├── wav_player.cpp │ ├── wav_player.hpp │ ├── xmp.cpp │ ├── xmp.hpp │ ├── xmp_player.cpp │ └── xmp_player.hpp ├── blua │ ├── BLUA.htm │ ├── CMakeLists.txt │ ├── lapi.c │ ├── lapi.h │ ├── lauxlib.c │ ├── lauxlib.h │ ├── lbaselib.c │ ├── lcode.c │ ├── lcode.h │ ├── ldebug.c │ ├── ldebug.h │ ├── ldo.c │ ├── ldo.h │ ├── ldump.c │ ├── lfunc.c │ ├── lfunc.h │ ├── lgc.c │ ├── lgc.h │ ├── linit.c │ ├── liolib.c │ ├── llex.c │ ├── llex.h │ ├── llimits.h │ ├── lmem.c │ ├── lmem.h │ ├── lobject.c │ ├── lobject.h │ ├── lopcodes.c │ ├── lopcodes.h │ ├── lparser.c │ ├── lparser.h │ ├── lstate.c │ ├── lstate.h │ ├── lstring.c │ ├── lstring.h │ ├── lstrlib.c │ ├── ltable.c │ ├── ltable.h │ ├── ltablib.c │ ├── ltm.c │ ├── ltm.h │ ├── lua.h │ ├── luaconf.h │ ├── lualib.h │ ├── lundump.c │ ├── lundump.h │ ├── lvm.c │ ├── lvm.h │ ├── lzio.c │ └── lzio.h ├── byteptr.h ├── command.c ├── command.h ├── comptime.c ├── config.h.in ├── console.c ├── console.h ├── core │ ├── CMakeLists.txt │ ├── memory.cpp │ ├── memory.h │ ├── spmc_queue.hpp │ ├── static_vec.hpp │ ├── thread_pool.cpp │ └── thread_pool.h ├── cvars.cpp ├── cxxutil.hpp ├── d_clisrv.c ├── d_clisrv.h ├── d_event.h ├── d_main.cpp ├── d_main.h ├── d_net.c ├── d_net.h ├── d_netcmd.c ├── d_netcmd.h ├── d_netfil.c ├── d_netfil.h ├── d_player.h ├── d_think.h ├── d_ticcmd.h ├── deh_lua.c ├── deh_lua.h ├── deh_soc.c ├── deh_soc.h ├── deh_tables.c ├── deh_tables.h ├── dehacked.c ├── dehacked.h ├── discord.c ├── discord.h ├── doomdata.h ├── doomdef.h ├── doomstat.h ├── doomtype.h ├── dummy │ ├── Sourcefile │ ├── i_cdmus.c │ ├── i_main.c │ ├── i_net.c │ ├── i_sound.c │ ├── i_system.c │ └── i_video.c ├── endian.h ├── f_finale.c ├── f_finale.h ├── f_wipe.cpp ├── fastcmp.h ├── filesrch.c ├── filesrch.h ├── font.c ├── font.h ├── g_build_ticcmd.cpp ├── g_demo.cpp ├── g_demo.h ├── g_game.c ├── g_game.h ├── g_gamedata.cpp ├── g_gamedata.h ├── g_input.c ├── g_input.h ├── g_party.cpp ├── g_party.h ├── g_state.h ├── hardware │ ├── CMakeLists.txt │ ├── hw3dsdrv.h │ ├── hw3sound.c │ ├── hw3sound.h │ ├── hw_batching.c │ ├── hw_batching.h │ ├── hw_bsp.c │ ├── hw_cache.c │ ├── hw_clip.c │ ├── hw_clip.h │ ├── hw_data.h │ ├── hw_defs.h │ ├── hw_dll.h │ ├── hw_draw.c │ ├── hw_drv.h │ ├── hw_glob.h │ ├── hw_light.c │ ├── hw_light.h │ ├── hw_main.c │ ├── hw_main.h │ ├── hw_md2.c │ ├── hw_md2.h │ ├── hw_md2load.c │ ├── hw_md2load.h │ ├── hw_md3load.c │ ├── hw_md3load.h │ ├── hw_model.c │ ├── hw_model.h │ ├── hws_data.h │ ├── r_minigl │ │ └── r_minigl.c │ ├── r_opengl │ │ ├── ogl_win.c │ │ ├── r_opengl-vc10.vcxproj │ │ ├── r_opengl-vc9.vcproj │ │ ├── r_opengl.c │ │ ├── r_opengl.dev │ │ ├── r_opengl.dsp │ │ ├── r_opengl.h │ │ └── r_vbo.h │ ├── s_ds3d │ │ ├── s_ds3d.c │ │ ├── s_ds3d.dev │ │ └── s_ds3d.dsp │ ├── s_fmod │ │ ├── s_fmod.c │ │ ├── s_fmod.dev │ │ └── s_fmod.dsp │ ├── s_openal │ │ ├── s_openal-vc10.vcxproj │ │ ├── s_openal-vc9.vcproj │ │ ├── s_openal.c │ │ ├── s_openal.dev │ │ └── s_openal.dsp │ ├── u_list.c │ └── u_list.h ├── http-mserv.c ├── hu_stuff.c ├── hu_stuff.h ├── hud │ ├── CMakeLists.txt │ ├── emerald-win.cpp │ ├── input-display.cpp │ ├── powerup.cpp │ ├── spectator.cpp │ └── timer.cpp ├── hwr2 │ ├── CMakeLists.txt │ ├── blendmode.hpp │ ├── blit_postimg_screens.cpp │ ├── blit_postimg_screens.hpp │ ├── blit_rect.cpp │ ├── blit_rect.hpp │ ├── hardware_state.hpp │ ├── pass.cpp │ ├── pass.hpp │ ├── pass_imgui.cpp │ ├── pass_imgui.hpp │ ├── pass_manager.cpp │ ├── pass_manager.hpp │ ├── pass_resource_managers.cpp │ ├── pass_resource_managers.hpp │ ├── patch_atlas.cpp │ ├── patch_atlas.hpp │ ├── postprocess_wipe.cpp │ ├── postprocess_wipe.hpp │ ├── resource_management.cpp │ ├── resource_management.hpp │ ├── screen_capture.cpp │ ├── screen_capture.hpp │ ├── software_screen_renderer.cpp │ ├── software_screen_renderer.hpp │ ├── twodee.cpp │ ├── twodee.hpp │ ├── twodee_renderer.cpp │ ├── twodee_renderer.hpp │ ├── upscale_backbuffer.cpp │ └── upscale_backbuffer.hpp ├── i_addrinfo.c ├── i_addrinfo.h ├── i_joy.h ├── i_net.h ├── i_sound.h ├── i_system.h ├── i_tcp.c ├── i_tcp.h ├── i_tcp_detail.h ├── i_threads.h ├── i_time.c ├── i_time.h ├── i_video.h ├── i_video_common.cpp ├── info.c ├── info.h ├── io │ ├── CMakeLists.txt │ ├── streams.cpp │ └── streams.hpp ├── k_bans.cpp ├── k_bans.h ├── k_battle.c ├── k_battle.h ├── k_bheap.c ├── k_bheap.h ├── k_boss.c ├── k_boss.h ├── k_bot.cpp ├── k_bot.h ├── k_botitem.cpp ├── k_botsearch.cpp ├── k_brightmap.c ├── k_brightmap.h ├── k_collide.cpp ├── k_collide.h ├── k_color.c ├── k_color.h ├── k_credits.cpp ├── k_credits.h ├── k_dialogue.cpp ├── k_dialogue.h ├── k_dialogue.hpp ├── k_director.cpp ├── k_director.h ├── k_endcam.cpp ├── k_endcam.h ├── k_follower.c ├── k_follower.h ├── k_grandprix.c ├── k_grandprix.h ├── k_hitlag.c ├── k_hitlag.h ├── k_hud.cpp ├── k_hud.h ├── k_hud_track.cpp ├── k_kart.c ├── k_kart.h ├── k_mapuser.c ├── k_mapuser.h ├── k_menu.h ├── k_menudraw.c ├── k_menufunc.c ├── k_objects.h ├── k_pathfind.c ├── k_pathfind.h ├── k_podium.cpp ├── k_podium.h ├── k_powerup.cpp ├── k_powerup.h ├── k_profiles.cpp ├── k_profiles.h ├── k_pwrlv.c ├── k_pwrlv.h ├── k_race.c ├── k_race.h ├── k_rank.cpp ├── k_rank.h ├── k_respawn.c ├── k_respawn.h ├── k_roulette.c ├── k_roulette.h ├── k_serverstats.c ├── k_serverstats.h ├── k_specialstage.c ├── k_specialstage.h ├── k_tally.cpp ├── k_tally.h ├── k_terrain.c ├── k_terrain.h ├── k_vote.c ├── k_vote.h ├── k_waypoint.cpp ├── k_waypoint.h ├── k_zvote.c ├── k_zvote.h ├── keys.h ├── libdivide.h ├── locale │ ├── en.po │ └── srb2.pot ├── lua_baselib.c ├── lua_blockmaplib.c ├── lua_consolelib.c ├── lua_followerlib.c ├── lua_hook.h ├── lua_hooklib.c ├── lua_hud.h ├── lua_hudlib.c ├── lua_hudlib_drawlist.c ├── lua_hudlib_drawlist.h ├── lua_infolib.c ├── lua_libs.h ├── lua_maplib.c ├── lua_mathlib.c ├── lua_mobjlib.c ├── lua_playerlib.c ├── lua_polyobjlib.c ├── lua_profile.cpp ├── lua_profile.h ├── lua_script.c ├── lua_script.h ├── lua_skinlib.c ├── lua_taglib.c ├── lua_thinkerlib.c ├── lzf.c ├── lzf.h ├── m_aatree.c ├── m_aatree.h ├── m_anigif.c ├── m_anigif.h ├── m_argv.c ├── m_argv.h ├── m_avrecorder.cpp ├── m_avrecorder.h ├── m_avrecorder.hpp ├── m_bbox.c ├── m_bbox.h ├── m_cheat.c ├── m_cheat.h ├── m_cond.c ├── m_cond.h ├── m_dllist.h ├── m_easing.c ├── m_easing.h ├── m_fixed.c ├── m_fixed.h ├── m_memcpy.c ├── m_misc.cpp ├── m_misc.h ├── m_perfstats.c ├── m_perfstats.h ├── m_pw.cpp ├── m_pw.h ├── m_pw_hash.c ├── m_pw_hash.h ├── m_queue.c ├── m_queue.h ├── m_random.c ├── m_random.h ├── m_swap.h ├── math │ ├── fixed.hpp │ ├── line_equation.hpp │ ├── line_segment.hpp │ ├── traits.hpp │ └── vec.hpp ├── md5.c ├── md5.h ├── media │ ├── CMakeLists.txt │ ├── audio_encoder.hpp │ ├── avrecorder.cpp │ ├── avrecorder.hpp │ ├── avrecorder_feedback.cpp │ ├── avrecorder_impl.hpp │ ├── avrecorder_indexed.cpp │ ├── avrecorder_queue.cpp │ ├── cfile.cpp │ ├── cfile.hpp │ ├── container.hpp │ ├── encoder.hpp │ ├── options.cpp │ ├── options.hpp │ ├── options_values.cpp │ ├── video_encoder.hpp │ ├── video_frame.hpp │ ├── vorbis.cpp │ ├── vorbis.hpp │ ├── vorbis_error.hpp │ ├── vp8.cpp │ ├── vp8.hpp │ ├── vpx_error.hpp │ ├── webm.hpp │ ├── webm_container.cpp │ ├── webm_container.hpp │ ├── webm_encoder.hpp │ ├── webm_vorbis.hpp │ ├── webm_vorbis_lace.cpp │ ├── webm_vp8.hpp │ ├── webm_writer.hpp │ ├── yuv420p.cpp │ └── yuv420p.hpp ├── menus │ ├── CMakeLists.txt │ ├── class-egg-tv │ │ ├── CMakeLists.txt │ │ ├── EggTV.cpp │ │ ├── EggTV.hpp │ │ ├── EggTVData.cpp │ │ ├── EggTVData.hpp │ │ └── EggTVGraphics.hpp │ ├── extras-1.c │ ├── extras-addons.c │ ├── extras-challenges.c │ ├── extras-egg-tv.cpp │ ├── extras-statistics.cpp │ ├── extras-wrong.c │ ├── main-1.c │ ├── main-goner.cpp │ ├── main-profile-select.c │ ├── options-1.c │ ├── options-data-1.c │ ├── options-data-advanced-1.c │ ├── options-data-advanced-addon.c │ ├── options-data-erase-1.c │ ├── options-data-erase-profile.c │ ├── options-data-screenshots.c │ ├── options-gameplay-1.c │ ├── options-gameplay-item-toggles.c │ ├── options-hud-1.c │ ├── options-hud-online.c │ ├── options-profiles-1.c │ ├── options-profiles-edit-1.c │ ├── options-profiles-edit-accessibility.cpp │ ├── options-profiles-edit-controls.c │ ├── options-server-1.c │ ├── options-server-advanced.c │ ├── options-sound.cpp │ ├── options-video-1.c │ ├── options-video-advanced.c │ ├── options-video-modes.c │ ├── play-1.c │ ├── play-char-select.c │ ├── play-local-1.c │ ├── play-local-race-1.c │ ├── play-local-race-difficulty.c │ ├── play-local-race-time-attack.c │ ├── play-online-1.c │ ├── play-online-host.c │ ├── play-online-join-ip.c │ ├── play-online-room-select.c │ ├── play-online-server-browser.c │ └── transient │ │ ├── CMakeLists.txt │ │ ├── cup-select.c │ │ ├── discord-requests.c │ │ ├── explosions.c │ │ ├── gametype.c │ │ ├── level-select.c │ │ ├── manual.c │ │ ├── message-box.c │ │ ├── pause-addonoptions.cpp │ │ ├── pause-cheats.cpp │ │ ├── pause-game.c │ │ ├── pause-kick.c │ │ ├── pause-replay.c │ │ ├── sound-test.c │ │ └── virtual-keyboard.c ├── mobj.hpp ├── mobj_list.hpp ├── mobj_list_view.hpp ├── modp_b64 │ ├── CMakeLists.txt │ ├── LICENSE │ ├── config.h │ ├── extern_c_begin.h │ ├── extern_c_end.h │ ├── modp_b64.c │ ├── modp_b64.h │ ├── modp_b64_data.h │ └── modp_stdint.h ├── monocypher │ ├── CMakeLists.txt │ ├── monocypher.c │ └── monocypher.h ├── mserv.c ├── mserv.h ├── music.cpp ├── music.h ├── music_detail.hpp ├── music_manager.cpp ├── music_manager.hpp ├── music_tune.hpp ├── nds │ ├── i_video.c │ └── r_nds3d.c ├── objects │ ├── CMakeLists.txt │ ├── adventure-air-booster.c │ ├── ark-arrow.c │ ├── audience.c │ ├── ball-switch.cpp │ ├── battle-ufo.cpp │ ├── block.c │ ├── broly.cpp │ ├── broly.hpp │ ├── bungee.c │ ├── charge.c │ ├── checkpoint.cpp │ ├── cloud.c │ ├── crate.cpp │ ├── dash-rings.c │ ├── destroyed-kart.cpp │ ├── dlzothers.c │ ├── dlzrocket.c │ ├── dlzseasaw.c │ ├── drop-target.c │ ├── duel-bomb.c │ ├── eggball.c │ ├── emerald.c │ ├── emz-faucet.cpp │ ├── frost-thrower.cpp │ ├── fuel.cpp │ ├── gachabom-rebound.cpp │ ├── gardentop.c │ ├── gpzseasaw.c │ ├── hyudoro.c │ ├── instawhip.c │ ├── item-debris.c │ ├── item-spot.c │ ├── ivoball.cpp │ ├── jawz.c │ ├── loops.cpp │ ├── manta-ring.c │ ├── mega-barrier.cpp │ ├── monitor.c │ ├── objects.hpp │ ├── orbinaut.c │ ├── powerup-aura.cpp │ ├── powerup-spinner.cpp │ ├── pulley.cpp │ ├── random-item.c │ ├── rideroid.c │ ├── ring-shooter.c │ ├── rocks.cpp │ ├── sealed-star.c │ ├── servant-hand.c │ ├── shadow.cpp │ ├── shrink.c │ ├── sneaker-panel.c │ ├── spb.c │ ├── spear.cpp │ ├── super-flicky.cpp │ ├── talk-point.cpp │ ├── trick-balloon.c │ ├── ufo.c │ ├── versus │ │ ├── CMakeLists.txt │ │ ├── arena.c │ │ └── blendeye.c │ ├── waterfall-particle.c │ ├── wpzothers.c │ └── wpzturbine.c ├── p5prof.h ├── p_ceilng.c ├── p_enemy.c ├── p_floor.c ├── p_inter.c ├── p_lights.c ├── p_link.cpp ├── p_link.h ├── p_local.h ├── p_loop.c ├── p_map.c ├── p_mapthing.cpp ├── p_maputl.c ├── p_maputl.h ├── p_mobj.c ├── p_mobj.h ├── p_polyobj.c ├── p_polyobj.h ├── p_pspr.h ├── p_saveg.c ├── p_saveg.h ├── p_setup.cpp ├── p_setup.h ├── p_sight.c ├── p_slopes.c ├── p_slopes.h ├── p_spec.c ├── p_spec.h ├── p_sweep.cpp ├── p_sweep.hpp ├── p_telept.c ├── p_test.cpp ├── p_tick.c ├── p_tick.h ├── p_user.c ├── r_bbox.c ├── r_bsp.cpp ├── r_bsp.h ├── r_data.c ├── r_data.h ├── r_debug.cpp ├── r_debug.hpp ├── r_debug_detail.hpp ├── r_debug_parser.cpp ├── r_debug_printer.cpp ├── r_defs.h ├── r_draw.cpp ├── r_draw.h ├── r_draw_column.cpp ├── r_draw_span.cpp ├── r_fps.c ├── r_fps.h ├── r_local.h ├── r_main.cpp ├── r_main.h ├── r_patch.cpp ├── r_patch.h ├── r_patchrotation.c ├── r_patchrotation.h ├── r_picformats.c ├── r_picformats.h ├── r_plane.cpp ├── r_plane.h ├── r_portal.c ├── r_portal.h ├── r_segs.cpp ├── r_segs.h ├── r_skins.c ├── r_skins.h ├── r_sky.c ├── r_sky.h ├── r_splats.c ├── r_splats.h ├── r_spritefx.cpp ├── r_state.h ├── r_textures.c ├── r_textures.h ├── r_textures_dups.cpp ├── r_things.cpp ├── r_things.h ├── rhi │ ├── CMakeLists.txt │ ├── gl2 │ │ ├── CMakeLists.txt │ │ ├── gl2_rhi.cpp │ │ └── gl2_rhi.hpp │ ├── gles2 │ │ ├── CMakeLists.txt │ │ ├── gles2_rhi.cpp │ │ └── gles2_rhi.hpp │ ├── handle.hpp │ ├── rhi.cpp │ ├── rhi.hpp │ ├── shader_load_context.cpp │ └── shader_load_context.hpp ├── s_sound.c ├── s_sound.h ├── sanitize.cpp ├── sanitize.h ├── screen.c ├── screen.h ├── sdl │ ├── CMakeLists.txt │ ├── IMG_xpm.c │ ├── MakeCYG.cfg │ ├── SDL_icon.xpm │ ├── SDL_main │ │ ├── SDL_dummy_main.c │ │ ├── SDL_macosx_main.h │ │ ├── SDL_macosx_main.m │ │ ├── SDL_openxdk_main.c │ │ └── SDL_windows_main.c │ ├── SRB2Pandora │ │ ├── Makefile.cfg │ │ ├── PXML.xml │ │ └── icon.png │ ├── Srb2SDL-vc10.vcxproj │ ├── Srb2SDL-vc10.vcxproj.filters │ ├── Srb2SDL-vc9.vcproj │ ├── Srb2SDL.dsp │ ├── Srb2SDL.dsw │ ├── Srb2SDL.ico │ ├── Srb2SDL.props │ ├── dosstr.c │ ├── endtxt.c │ ├── endtxt.h │ ├── hwsym_sdl.c │ ├── hwsym_sdl.h │ ├── i_main.cpp │ ├── i_net.c │ ├── i_system.cpp │ ├── i_threads.c │ ├── i_ttf.c │ ├── i_ttf.h │ ├── i_video.cpp │ ├── macosx │ │ ├── English.lproj │ │ │ └── InfoPlist.strings │ │ ├── Info.plist │ │ ├── Srb2mac.icns │ │ ├── Srb2mac.pbproj │ │ │ └── project.pbxproj │ │ ├── Srb2mac.xcodeproj │ │ │ └── project.pbxproj │ │ ├── mac_alert.c │ │ ├── mac_alert.h │ │ ├── mac_resources.c │ │ └── mac_resources.h │ ├── mixer_sound.c │ ├── new_sound.cpp │ ├── ogl_sdl.c │ ├── ogl_sdl.h │ ├── rhi_gl2_platform.cpp │ ├── rhi_gl2_platform.hpp │ ├── rhi_gles2_platform.cpp │ ├── rhi_gles2_platform.hpp │ ├── sdl_sound.c │ ├── sdlmain.h │ ├── srb2.ttf │ └── srb2icon.png ├── sdl12 │ ├── Srb2SDL-vc10.vcxproj │ ├── Srb2SDL-vc9.vcproj │ ├── Srb2SDL.dsp │ ├── Srb2SDL.ico │ ├── hwsym_sdl.c │ ├── i_main.c │ ├── i_system.c │ ├── i_video.c │ ├── macosx │ │ ├── Srb2mac.icns │ │ ├── Srb2mac.pbproj │ │ │ └── project.pbxproj │ │ └── Srb2mac.xcodeproj │ │ │ └── project.pbxproj │ └── sdl_sound.c ├── slope_anchors.c ├── sounds.c ├── sounds.h ├── st_stuff.c ├── st_stuff.h ├── strcasestr.c ├── string.c ├── stun.cpp ├── stun.h ├── t_facon.c ├── t_fsin.c ├── t_ftan.c ├── t_tan2a.c ├── tables.c ├── tables.h ├── taglist.c ├── taglist.h ├── tmap.nas ├── tmap.s ├── tmap_asm.s ├── tmap_mmx.nas ├── tmap_vc.nas ├── typedef.h ├── v_draw.cpp ├── v_draw.hpp ├── v_draw_setter.hpp ├── v_video.cpp ├── v_video.h ├── version.h ├── vid_copy.s ├── w_wad.cpp ├── w_wad.h ├── win32 │ ├── Srb2win.ico │ ├── Srb2win.rc │ ├── afxres.h │ ├── resource.h │ ├── srb2kart.exe.manifest │ ├── srb2win.exe.manifest │ ├── win_dbg.c │ └── win_dbg.h ├── win32ce │ ├── Srb2win.ico │ ├── win_dbg.c │ ├── win_dll.c │ ├── win_dll.h │ ├── win_main.c │ ├── win_sys.c │ └── win_vid.c ├── y_inter.cpp ├── y_inter.h ├── z_zone.c └── z_zone.h ├── thirdparty ├── CMakeLists.txt ├── discord-rpc │ ├── CMakeLists.txt │ ├── LICENSE │ ├── README.md │ ├── include │ │ ├── discord_register.h │ │ └── discord_rpc.h │ ├── rapidjson │ │ ├── CHANGELOG.md │ │ ├── include │ │ │ └── rapidjson │ │ │ │ ├── allocators.h │ │ │ │ ├── cursorstreamwrapper.h │ │ │ │ ├── document.h │ │ │ │ ├── encodedstream.h │ │ │ │ ├── encodings.h │ │ │ │ ├── error │ │ │ │ ├── en.h │ │ │ │ └── error.h │ │ │ │ ├── filereadstream.h │ │ │ │ ├── filewritestream.h │ │ │ │ ├── fwd.h │ │ │ │ ├── internal │ │ │ │ ├── biginteger.h │ │ │ │ ├── clzll.h │ │ │ │ ├── diyfp.h │ │ │ │ ├── dtoa.h │ │ │ │ ├── ieee754.h │ │ │ │ ├── itoa.h │ │ │ │ ├── meta.h │ │ │ │ ├── pow10.h │ │ │ │ ├── regex.h │ │ │ │ ├── stack.h │ │ │ │ ├── strfunc.h │ │ │ │ ├── strtod.h │ │ │ │ └── swap.h │ │ │ │ ├── istreamwrapper.h │ │ │ │ ├── memorybuffer.h │ │ │ │ ├── memorystream.h │ │ │ │ ├── msinttypes │ │ │ │ ├── inttypes.h │ │ │ │ └── stdint.h │ │ │ │ ├── ostreamwrapper.h │ │ │ │ ├── pointer.h │ │ │ │ ├── prettywriter.h │ │ │ │ ├── rapidjson.h │ │ │ │ ├── reader.h │ │ │ │ ├── schema.h │ │ │ │ ├── stream.h │ │ │ │ ├── stringbuffer.h │ │ │ │ ├── uri.h │ │ │ │ └── writer.h │ │ ├── license.txt │ │ └── readme.md │ └── src │ │ ├── CMakeLists.txt │ │ ├── backoff.h │ │ ├── connection.h │ │ ├── connection_unix.cpp │ │ ├── connection_win.cpp │ │ ├── discord_register_linux.cpp │ │ ├── discord_register_osx.m │ │ ├── discord_register_win.cpp │ │ ├── discord_rpc.cpp │ │ ├── dllmain.cpp │ │ ├── msg_queue.h │ │ ├── rpc_connection.cpp │ │ ├── rpc_connection.h │ │ ├── serialization.cpp │ │ └── serialization.h ├── fmt │ ├── CMakeLists.txt │ └── include │ │ └── fmt │ │ ├── args.h │ │ ├── base.h │ │ ├── chrono.h │ │ ├── color.h │ │ ├── compile.h │ │ ├── core.h │ │ ├── format-inl.h │ │ ├── format.h │ │ ├── os.h │ │ ├── ostream.h │ │ ├── printf.h │ │ ├── ranges.h │ │ ├── std.h │ │ └── xchar.h ├── glad │ ├── CMakeLists.txt │ ├── include │ │ ├── KHR │ │ │ └── khrplatform.h │ │ └── glad │ │ │ ├── gl.h │ │ │ └── gles2.h │ └── src │ │ ├── gl.c │ │ └── gles2.c ├── glm │ ├── CMakeLists.txt │ └── include │ │ └── glm │ │ ├── CMakeLists.txt │ │ ├── common.hpp │ │ ├── detail │ │ ├── _features.hpp │ │ ├── _fixes.hpp │ │ ├── _noise.hpp │ │ ├── _swizzle.hpp │ │ ├── _swizzle_func.hpp │ │ ├── _vectorize.hpp │ │ ├── compute_common.hpp │ │ ├── compute_vector_relational.hpp │ │ ├── func_common.inl │ │ ├── func_common_simd.inl │ │ ├── func_exponential.inl │ │ ├── func_exponential_simd.inl │ │ ├── func_geometric.inl │ │ ├── func_geometric_simd.inl │ │ ├── func_integer.inl │ │ ├── func_integer_simd.inl │ │ ├── func_matrix.inl │ │ ├── func_matrix_simd.inl │ │ ├── func_packing.inl │ │ ├── func_packing_simd.inl │ │ ├── func_trigonometric.inl │ │ ├── func_trigonometric_simd.inl │ │ ├── func_vector_relational.inl │ │ ├── func_vector_relational_simd.inl │ │ ├── glm.cpp │ │ ├── qualifier.hpp │ │ ├── setup.hpp │ │ ├── type_float.hpp │ │ ├── type_half.hpp │ │ ├── type_half.inl │ │ ├── type_mat2x2.hpp │ │ ├── type_mat2x2.inl │ │ ├── type_mat2x3.hpp │ │ ├── type_mat2x3.inl │ │ ├── type_mat2x4.hpp │ │ ├── type_mat2x4.inl │ │ ├── type_mat3x2.hpp │ │ ├── type_mat3x2.inl │ │ ├── type_mat3x3.hpp │ │ ├── type_mat3x3.inl │ │ ├── type_mat3x4.hpp │ │ ├── type_mat3x4.inl │ │ ├── type_mat4x2.hpp │ │ ├── type_mat4x2.inl │ │ ├── type_mat4x3.hpp │ │ ├── type_mat4x3.inl │ │ ├── type_mat4x4.hpp │ │ ├── type_mat4x4.inl │ │ ├── type_mat4x4_simd.inl │ │ ├── type_quat.hpp │ │ ├── type_quat.inl │ │ ├── type_quat_simd.inl │ │ ├── type_vec1.hpp │ │ ├── type_vec1.inl │ │ ├── type_vec2.hpp │ │ ├── type_vec2.inl │ │ ├── type_vec3.hpp │ │ ├── type_vec3.inl │ │ ├── type_vec4.hpp │ │ ├── type_vec4.inl │ │ └── type_vec4_simd.inl │ │ ├── exponential.hpp │ │ ├── ext.hpp │ │ ├── ext │ │ ├── matrix_clip_space.hpp │ │ ├── matrix_clip_space.inl │ │ ├── matrix_common.hpp │ │ ├── matrix_common.inl │ │ ├── matrix_double2x2.hpp │ │ ├── matrix_double2x2_precision.hpp │ │ ├── matrix_double2x3.hpp │ │ ├── matrix_double2x3_precision.hpp │ │ ├── matrix_double2x4.hpp │ │ ├── matrix_double2x4_precision.hpp │ │ ├── matrix_double3x2.hpp │ │ ├── matrix_double3x2_precision.hpp │ │ ├── matrix_double3x3.hpp │ │ ├── matrix_double3x3_precision.hpp │ │ ├── matrix_double3x4.hpp │ │ ├── matrix_double3x4_precision.hpp │ │ ├── matrix_double4x2.hpp │ │ ├── matrix_double4x2_precision.hpp │ │ ├── matrix_double4x3.hpp │ │ ├── matrix_double4x3_precision.hpp │ │ ├── matrix_double4x4.hpp │ │ ├── matrix_double4x4_precision.hpp │ │ ├── matrix_float2x2.hpp │ │ ├── matrix_float2x2_precision.hpp │ │ ├── matrix_float2x3.hpp │ │ ├── matrix_float2x3_precision.hpp │ │ ├── matrix_float2x4.hpp │ │ ├── matrix_float2x4_precision.hpp │ │ ├── matrix_float3x2.hpp │ │ ├── matrix_float3x2_precision.hpp │ │ ├── matrix_float3x3.hpp │ │ ├── matrix_float3x3_precision.hpp │ │ ├── matrix_float3x4.hpp │ │ ├── matrix_float3x4_precision.hpp │ │ ├── matrix_float4x2.hpp │ │ ├── matrix_float4x2_precision.hpp │ │ ├── matrix_float4x3.hpp │ │ ├── matrix_float4x3_precision.hpp │ │ ├── matrix_float4x4.hpp │ │ ├── matrix_float4x4_precision.hpp │ │ ├── matrix_int2x2.hpp │ │ ├── matrix_int2x2_sized.hpp │ │ ├── matrix_int2x3.hpp │ │ ├── matrix_int2x3_sized.hpp │ │ ├── matrix_int2x4.hpp │ │ ├── matrix_int2x4_sized.hpp │ │ ├── matrix_int3x2.hpp │ │ ├── matrix_int3x2_sized.hpp │ │ ├── matrix_int3x3.hpp │ │ ├── matrix_int3x3_sized.hpp │ │ ├── matrix_int3x4.hpp │ │ ├── matrix_int3x4_sized.hpp │ │ ├── matrix_int4x2.hpp │ │ ├── matrix_int4x2_sized.hpp │ │ ├── matrix_int4x3.hpp │ │ ├── matrix_int4x3_sized.hpp │ │ ├── matrix_int4x4.hpp │ │ ├── matrix_int4x4_sized.hpp │ │ ├── matrix_projection.hpp │ │ ├── matrix_projection.inl │ │ ├── matrix_relational.hpp │ │ ├── matrix_relational.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── matrix_uint2x2.hpp │ │ ├── matrix_uint2x2_sized.hpp │ │ ├── matrix_uint2x3.hpp │ │ ├── matrix_uint2x3_sized.hpp │ │ ├── matrix_uint2x4.hpp │ │ ├── matrix_uint2x4_sized.hpp │ │ ├── matrix_uint3x2.hpp │ │ ├── matrix_uint3x2_sized.hpp │ │ ├── matrix_uint3x3.hpp │ │ ├── matrix_uint3x3_sized.hpp │ │ ├── matrix_uint3x4.hpp │ │ ├── matrix_uint3x4_sized.hpp │ │ ├── matrix_uint4x2.hpp │ │ ├── matrix_uint4x2_sized.hpp │ │ ├── matrix_uint4x3.hpp │ │ ├── matrix_uint4x3_sized.hpp │ │ ├── matrix_uint4x4.hpp │ │ ├── matrix_uint4x4_sized.hpp │ │ ├── quaternion_common.hpp │ │ ├── quaternion_common.inl │ │ ├── quaternion_common_simd.inl │ │ ├── quaternion_double.hpp │ │ ├── quaternion_double_precision.hpp │ │ ├── quaternion_exponential.hpp │ │ ├── quaternion_exponential.inl │ │ ├── quaternion_float.hpp │ │ ├── quaternion_float_precision.hpp │ │ ├── quaternion_geometric.hpp │ │ ├── quaternion_geometric.inl │ │ ├── quaternion_relational.hpp │ │ ├── quaternion_relational.inl │ │ ├── quaternion_transform.hpp │ │ ├── quaternion_transform.inl │ │ ├── quaternion_trigonometric.hpp │ │ ├── quaternion_trigonometric.inl │ │ ├── scalar_common.hpp │ │ ├── scalar_common.inl │ │ ├── scalar_constants.hpp │ │ ├── scalar_constants.inl │ │ ├── scalar_int_sized.hpp │ │ ├── scalar_integer.hpp │ │ ├── scalar_integer.inl │ │ ├── scalar_packing.hpp │ │ ├── scalar_packing.inl │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── scalar_uint_sized.hpp │ │ ├── scalar_ulp.hpp │ │ ├── scalar_ulp.inl │ │ ├── vector_bool1.hpp │ │ ├── vector_bool1_precision.hpp │ │ ├── vector_bool2.hpp │ │ ├── vector_bool2_precision.hpp │ │ ├── vector_bool3.hpp │ │ ├── vector_bool3_precision.hpp │ │ ├── vector_bool4.hpp │ │ ├── vector_bool4_precision.hpp │ │ ├── vector_common.hpp │ │ ├── vector_common.inl │ │ ├── vector_double1.hpp │ │ ├── vector_double1_precision.hpp │ │ ├── vector_double2.hpp │ │ ├── vector_double2_precision.hpp │ │ ├── vector_double3.hpp │ │ ├── vector_double3_precision.hpp │ │ ├── vector_double4.hpp │ │ ├── vector_double4_precision.hpp │ │ ├── vector_float1.hpp │ │ ├── vector_float1_precision.hpp │ │ ├── vector_float2.hpp │ │ ├── vector_float2_precision.hpp │ │ ├── vector_float3.hpp │ │ ├── vector_float3_precision.hpp │ │ ├── vector_float4.hpp │ │ ├── vector_float4_precision.hpp │ │ ├── vector_int1.hpp │ │ ├── vector_int1_sized.hpp │ │ ├── vector_int2.hpp │ │ ├── vector_int2_sized.hpp │ │ ├── vector_int3.hpp │ │ ├── vector_int3_sized.hpp │ │ ├── vector_int4.hpp │ │ ├── vector_int4_sized.hpp │ │ ├── vector_integer.hpp │ │ ├── vector_integer.inl │ │ ├── vector_packing.hpp │ │ ├── vector_packing.inl │ │ ├── vector_relational.hpp │ │ ├── vector_relational.inl │ │ ├── vector_uint1.hpp │ │ ├── vector_uint1_sized.hpp │ │ ├── vector_uint2.hpp │ │ ├── vector_uint2_sized.hpp │ │ ├── vector_uint3.hpp │ │ ├── vector_uint3_sized.hpp │ │ ├── vector_uint4.hpp │ │ ├── vector_uint4_sized.hpp │ │ ├── vector_ulp.hpp │ │ └── vector_ulp.inl │ │ ├── fwd.hpp │ │ ├── geometric.hpp │ │ ├── glm.hpp │ │ ├── gtc │ │ ├── bitfield.hpp │ │ ├── bitfield.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── constants.hpp │ │ ├── constants.inl │ │ ├── epsilon.hpp │ │ ├── epsilon.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── matrix_access.hpp │ │ ├── matrix_access.inl │ │ ├── matrix_integer.hpp │ │ ├── matrix_inverse.hpp │ │ ├── matrix_inverse.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── noise.hpp │ │ ├── noise.inl │ │ ├── packing.hpp │ │ ├── packing.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── quaternion_simd.inl │ │ ├── random.hpp │ │ ├── random.inl │ │ ├── reciprocal.hpp │ │ ├── reciprocal.inl │ │ ├── round.hpp │ │ ├── round.inl │ │ ├── type_aligned.hpp │ │ ├── type_precision.hpp │ │ ├── type_precision.inl │ │ ├── type_ptr.hpp │ │ ├── type_ptr.inl │ │ ├── ulp.hpp │ │ ├── ulp.inl │ │ └── vec1.hpp │ │ ├── gtx │ │ ├── associated_min_max.hpp │ │ ├── associated_min_max.inl │ │ ├── bit.hpp │ │ ├── bit.inl │ │ ├── closest_point.hpp │ │ ├── closest_point.inl │ │ ├── color_encoding.hpp │ │ ├── color_encoding.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── color_space_YCoCg.hpp │ │ ├── color_space_YCoCg.inl │ │ ├── common.hpp │ │ ├── common.inl │ │ ├── compatibility.hpp │ │ ├── compatibility.inl │ │ ├── component_wise.hpp │ │ ├── component_wise.inl │ │ ├── dual_quaternion.hpp │ │ ├── dual_quaternion.inl │ │ ├── easing.hpp │ │ ├── easing.inl │ │ ├── euler_angles.hpp │ │ ├── euler_angles.inl │ │ ├── extend.hpp │ │ ├── extend.inl │ │ ├── extended_min_max.hpp │ │ ├── extended_min_max.inl │ │ ├── exterior_product.hpp │ │ ├── exterior_product.inl │ │ ├── fast_exponential.hpp │ │ ├── fast_exponential.inl │ │ ├── fast_square_root.hpp │ │ ├── fast_square_root.inl │ │ ├── fast_trigonometry.hpp │ │ ├── fast_trigonometry.inl │ │ ├── float_notmalize.inl │ │ ├── functions.hpp │ │ ├── functions.inl │ │ ├── gradient_paint.hpp │ │ ├── gradient_paint.inl │ │ ├── handed_coordinate_space.hpp │ │ ├── handed_coordinate_space.inl │ │ ├── hash.hpp │ │ ├── hash.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── intersect.hpp │ │ ├── intersect.inl │ │ ├── io.hpp │ │ ├── io.inl │ │ ├── log_base.hpp │ │ ├── log_base.inl │ │ ├── matrix_cross_product.hpp │ │ ├── matrix_cross_product.inl │ │ ├── matrix_decompose.hpp │ │ ├── matrix_decompose.inl │ │ ├── matrix_factorisation.hpp │ │ ├── matrix_factorisation.inl │ │ ├── matrix_interpolation.hpp │ │ ├── matrix_interpolation.inl │ │ ├── matrix_major_storage.hpp │ │ ├── matrix_major_storage.inl │ │ ├── matrix_operation.hpp │ │ ├── matrix_operation.inl │ │ ├── matrix_query.hpp │ │ ├── matrix_query.inl │ │ ├── matrix_transform_2d.hpp │ │ ├── matrix_transform_2d.inl │ │ ├── mixed_product.hpp │ │ ├── mixed_product.inl │ │ ├── norm.hpp │ │ ├── norm.inl │ │ ├── normal.hpp │ │ ├── normal.inl │ │ ├── normalize_dot.hpp │ │ ├── normalize_dot.inl │ │ ├── number_precision.hpp │ │ ├── number_precision.inl │ │ ├── optimum_pow.hpp │ │ ├── optimum_pow.inl │ │ ├── orthonormalize.hpp │ │ ├── orthonormalize.inl │ │ ├── perpendicular.hpp │ │ ├── perpendicular.inl │ │ ├── polar_coordinates.hpp │ │ ├── polar_coordinates.inl │ │ ├── projection.hpp │ │ ├── projection.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── range.hpp │ │ ├── raw_data.hpp │ │ ├── raw_data.inl │ │ ├── rotate_normalized_axis.hpp │ │ ├── rotate_normalized_axis.inl │ │ ├── rotate_vector.hpp │ │ ├── rotate_vector.inl │ │ ├── scalar_multiplication.hpp │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── spline.hpp │ │ ├── spline.inl │ │ ├── std_based_type.hpp │ │ ├── std_based_type.inl │ │ ├── string_cast.hpp │ │ ├── string_cast.inl │ │ ├── texture.hpp │ │ ├── texture.inl │ │ ├── transform.hpp │ │ ├── transform.inl │ │ ├── transform2.hpp │ │ ├── transform2.inl │ │ ├── type_aligned.hpp │ │ ├── type_aligned.inl │ │ ├── type_trait.hpp │ │ ├── type_trait.inl │ │ ├── vec_swizzle.hpp │ │ ├── vector_angle.hpp │ │ ├── vector_angle.inl │ │ ├── vector_query.hpp │ │ ├── vector_query.inl │ │ ├── wrap.hpp │ │ └── wrap.inl │ │ ├── integer.hpp │ │ ├── mat2x2.hpp │ │ ├── mat2x3.hpp │ │ ├── mat2x4.hpp │ │ ├── mat3x2.hpp │ │ ├── mat3x3.hpp │ │ ├── mat3x4.hpp │ │ ├── mat4x2.hpp │ │ ├── mat4x3.hpp │ │ ├── mat4x4.hpp │ │ ├── matrix.hpp │ │ ├── packing.hpp │ │ ├── simd │ │ ├── common.h │ │ ├── exponential.h │ │ ├── geometric.h │ │ ├── integer.h │ │ ├── matrix.h │ │ ├── neon.h │ │ ├── packing.h │ │ ├── platform.h │ │ ├── trigonometric.h │ │ └── vector_relational.h │ │ ├── trigonometric.hpp │ │ ├── vec2.hpp │ │ ├── vec3.hpp │ │ ├── vec4.hpp │ │ └── vector_relational.hpp ├── imgui │ ├── CMakeLists.txt │ ├── LICENSE.txt │ ├── imconfig.h │ ├── imgui.cpp │ ├── imgui.h │ ├── imgui_demo.cpp │ ├── imgui_draw.cpp │ ├── imgui_internal.h │ ├── imgui_tables.cpp │ ├── imgui_widgets.cpp │ ├── imstb_rectpack.h │ ├── imstb_textedit.h │ └── imstb_truetype.h ├── imgui_config │ └── srb2_imconfig.h ├── libwebm │ ├── CMakeLists.txt │ ├── common │ │ ├── common.sh │ │ ├── file_util.cc │ │ ├── file_util.h │ │ ├── hdr_util.cc │ │ ├── hdr_util.h │ │ ├── indent.cc │ │ ├── indent.h │ │ ├── libwebm_util.cc │ │ ├── libwebm_util.h │ │ ├── video_frame.cc │ │ ├── video_frame.h │ │ ├── vp9_header_parser.cc │ │ ├── vp9_header_parser.h │ │ ├── vp9_header_parser_tests.cc │ │ ├── vp9_level_stats.cc │ │ ├── vp9_level_stats.h │ │ ├── vp9_level_stats_tests.cc │ │ ├── webm_constants.h │ │ ├── webm_endian.cc │ │ ├── webm_endian.h │ │ └── webmids.h │ ├── mkvmuxer │ │ ├── mkvmuxer.cc │ │ ├── mkvmuxer.h │ │ ├── mkvmuxertypes.h │ │ ├── mkvmuxerutil.cc │ │ ├── mkvmuxerutil.h │ │ ├── mkvwriter.cc │ │ └── mkvwriter.h │ └── mkvparser │ │ ├── mkvparser.cc │ │ ├── mkvparser.h │ │ ├── mkvreader.cc │ │ └── mkvreader.h ├── nlohmann-json │ ├── CMakeLists.txt │ └── include │ │ └── nlohmann │ │ ├── json.hpp │ │ └── json_fwd.hpp ├── stb │ ├── CMakeLists.txt │ ├── include │ │ ├── stb_rect_pack.h │ │ └── stb_vorbis.h │ ├── stb_rect_pack.c │ └── stb_vorbis.c ├── tcbrindle_span │ ├── CMakeLists.txt │ └── include │ │ └── tcb │ │ └── span.hpp ├── tracy │ ├── CMakeLists.txt │ └── include │ │ └── tracy │ │ ├── TracyClient.cpp │ │ ├── client │ │ ├── TracyAlloc.cpp │ │ ├── TracyArmCpuTable.hpp │ │ ├── TracyCallstack.cpp │ │ ├── TracyCallstack.h │ │ ├── TracyCallstack.hpp │ │ ├── TracyCpuid.hpp │ │ ├── TracyDebug.hpp │ │ ├── TracyDxt1.cpp │ │ ├── TracyDxt1.hpp │ │ ├── TracyFastVector.hpp │ │ ├── TracyLock.hpp │ │ ├── TracyOverride.cpp │ │ ├── TracyProfiler.cpp │ │ ├── TracyProfiler.hpp │ │ ├── TracyRingBuffer.hpp │ │ ├── TracyScoped.hpp │ │ ├── TracyStringHelpers.hpp │ │ ├── TracySysPower.cpp │ │ ├── TracySysPower.hpp │ │ ├── TracySysTime.cpp │ │ ├── TracySysTime.hpp │ │ ├── TracySysTrace.cpp │ │ ├── TracySysTrace.hpp │ │ ├── TracyThread.hpp │ │ ├── tracy_SPSCQueue.h │ │ ├── tracy_concurrentqueue.h │ │ ├── tracy_rpmalloc.cpp │ │ └── tracy_rpmalloc.hpp │ │ ├── common │ │ ├── TracyAlign.hpp │ │ ├── TracyAlloc.hpp │ │ ├── TracyApi.h │ │ ├── TracyColor.hpp │ │ ├── TracyForceInline.hpp │ │ ├── TracyMutex.hpp │ │ ├── TracyProtocol.hpp │ │ ├── TracyQueue.hpp │ │ ├── TracySocket.cpp │ │ ├── TracySocket.hpp │ │ ├── TracyStackFrames.cpp │ │ ├── TracyStackFrames.hpp │ │ ├── TracySystem.cpp │ │ ├── TracySystem.hpp │ │ ├── TracyUwp.hpp │ │ ├── TracyVersion.hpp │ │ ├── TracyYield.hpp │ │ ├── tracy_lz4.cpp │ │ ├── tracy_lz4.hpp │ │ ├── tracy_lz4hc.cpp │ │ └── tracy_lz4hc.hpp │ │ ├── libbacktrace │ │ ├── LICENSE │ │ ├── alloc.cpp │ │ ├── backtrace.hpp │ │ ├── config.h │ │ ├── dwarf.cpp │ │ ├── elf.cpp │ │ ├── fileline.cpp │ │ ├── filenames.hpp │ │ ├── internal.hpp │ │ ├── macho.cpp │ │ ├── mmapio.cpp │ │ ├── posix.cpp │ │ ├── sort.cpp │ │ └── state.cpp │ │ └── tracy │ │ ├── Tracy.hpp │ │ ├── TracyC.h │ │ ├── TracyD3D11.hpp │ │ ├── TracyD3D12.hpp │ │ ├── TracyLua.hpp │ │ ├── TracyOpenCL.hpp │ │ ├── TracyOpenGL.hpp │ │ └── TracyVulkan.hpp └── xmp-lite │ ├── CMakeLists.txt │ ├── Changelog │ ├── README │ ├── include │ └── libxmp-lite │ │ ├── Makefile │ │ └── xmp.h │ └── src │ ├── Makefile │ ├── callbackio.h │ ├── common.h │ ├── control.c │ ├── dataio.c │ ├── effects.c │ ├── effects.h │ ├── filetype.c │ ├── filter.c │ ├── format.c │ ├── format.h │ ├── hio.c │ ├── hio.h │ ├── lfo.c │ ├── lfo.h │ ├── list.h │ ├── load.c │ ├── load_helpers.c │ ├── loaders │ ├── Makefile │ ├── common.c │ ├── it.h │ ├── it_load.c │ ├── itsex.c │ ├── loader.h │ ├── mod.h │ ├── mod_load.c │ ├── s3m.h │ ├── s3m_load.c │ ├── sample.c │ ├── xm.h │ └── xm_load.c │ ├── md5.c │ ├── md5.h │ ├── mdataio.h │ ├── memio.c │ ├── memio.h │ ├── misc.c │ ├── mix_all.c │ ├── mixer.c │ ├── mixer.h │ ├── period.c │ ├── period.h │ ├── player.c │ ├── player.h │ ├── precomp_lut.h │ ├── read_event.c │ ├── scan.c │ ├── smix.c │ ├── tempfile.h │ ├── virtual.c │ ├── virtual.h │ └── win32.c ├── tools └── export-drpc-faces.c ├── vcpkg-configuration.json └── vcpkg.json /.editorconfig: -------------------------------------------------------------------------------- 1 | root = true 2 | 3 | [*] 4 | charset = utf-8 5 | insert_final_newline = true 6 | trim_trailing_whitespace = true 7 | 8 | [.editorconfig] 9 | indent_size = 4 10 | indent_style = tab 11 | tab_width = 4 12 | 13 | [src/**.{c,h,cpp,hpp}] 14 | indent_style = tab 15 | indent_size = 4 16 | tab_width = 4 17 | 18 | [{CMakeLists.txt,*.cmake}] 19 | indent_size = 4 20 | indent_style = tab 21 | tab_width = 4 22 | 23 | [{Makefile,*.mk}] 24 | indent_size = 8 25 | indent_style = tab 26 | tab_width = 8 27 | 28 | [*{.yml,.yaml}] 29 | indent_size = 2 30 | indent_style = space 31 | tab_width = 8 32 | 33 | [*.sh] 34 | indent_size = 4 35 | indent_style = tab 36 | tab_width = 4 37 | end_of_line = lf 38 | 39 | [*.bat] 40 | indent_size = 4 41 | indent_style = tab 42 | tab_width = 4 43 | end_of_line = crlf 44 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | #Source code 2 | /src/*.c text=auto 3 | /src/*.h text=auto 4 | /src/*.s text=auto 5 | /src/*.m text=auto 6 | /src/*.xpm text=auto 7 | /src/Makefile text=auto 8 | /src/Make*.cfg text=auto 9 | /src/CMakeLists.txt text=auto 10 | # Windows EOL 11 | *.cs -crlf -whitespace 12 | *.mk -crlf -whitespace 13 | *.bat -crlf -whitespace 14 | *.dev -crlf -whitespace 15 | *.dsp -crlf -whitespace 16 | *.dsw -crlf -whitespace 17 | *.sln -crlf -whitespace 18 | *.resx -crlf -whitespace 19 | *.vcproj -crlf -whitespace 20 | *.csproj* -crlf -whitespace 21 | *.vcxproj* -crlf -whitespace 22 | *.manifest -crlf -whitespace 23 | # vcpkg 24 | /vcpkg.json text=auto 25 | /vcpkg-configuration.json text=auto 26 | # Patches 27 | /tools/SDL-1.2.14-gc/SDL-1.2.14-gc.patch -whitespace 28 | #Appveyor 29 | /appveyor.yml -crlf -whitespace 30 | # Other 31 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /data 2 | *.ncb 3 | *.opt 4 | *.plg 5 | *.suo 6 | *.vcproj.*.*.user 7 | Win32_LIB_ASM_Debug 8 | Win32_LIB_ASM_Release 9 | *.bsc 10 | /SRB2.layout 11 | /SRB2.depend 12 | /src/comptime.h 13 | *.dgb 14 | *.debug 15 | *.debug.txt 16 | *.user 17 | *.db 18 | *.opendb 19 | /.vs 20 | /debian 21 | /assets/debian 22 | /make 23 | /bin 24 | /build 25 | /CMakeUserPresets.json 26 | -------------------------------------------------------------------------------- /.gitlab-ci.yml: -------------------------------------------------------------------------------- 1 | include: 2 | - '.gitlab/ci/templates/*.yml' 3 | - '.gitlab/ci/jobs/*.yml' 4 | 5 | workflow: 6 | auto_cancel: 7 | on_new_commit: interruptible 8 | 9 | variables: 10 | GIT_CLONE_PATH: $CI_BUILDS_DIR/$CI_CONCURRENT_ID/$CI_PROJECT_PATH 11 | GIT_DEPTH: 20 12 | 13 | stages: 14 | - build 15 | - osxcross 16 | 17 | default: 18 | interruptible: true 19 | artifacts: 20 | expire_in: 1 day 21 | -------------------------------------------------------------------------------- /.gitlab/ci/jobs/debian-testing-clang-amd64.yml: -------------------------------------------------------------------------------- 1 | Debian testing Clang: 2 | extends: Debian stable Clang 3 | 4 | when: manual 5 | 6 | allow_failure: true 7 | 8 | image: debian:testing-slim 9 | 10 | artifacts: 11 | paths: 12 | - "build.cmake/bin/" 13 | - "build.cmake/src/config.h" 14 | expose_as: "testing-clang" 15 | name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-clang" 16 | -------------------------------------------------------------------------------- /Android.mk: -------------------------------------------------------------------------------- 1 | # Build both the native piece of SRB2 for Android, and the Java frontend. 2 | LOCAL_PATH:= $(call my-dir) 3 | 4 | include $(CLEAR_VARS) 5 | 6 | include $(call all-makefiles-under,$(LOCAL_PATH)) 7 | -------------------------------------------------------------------------------- /alias-bootstrap.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env sh 2 | 3 | # All these commands can be run from anywhere in the git 4 | # tree, not just the top level. 5 | 6 | # Usage: git cmake 7 | # 8 | # Same usage as standard CMake command. 9 | # 10 | git config 'alias.cmake' '!cmake' 11 | 12 | # Usage: git build [options] 13 | # Usage: git build [options] 14 | # 15 | # In the second usage, when no preset is given, the 16 | # "default" build preset is used. 17 | # 18 | # Available options can be found by running: 19 | # 20 | # git cmake --build 21 | # 22 | git config 'alias.build' '!./custom-git-commands/git-build' 23 | 24 | # Usage: git crossmake 25 | # 26 | # Shortcut to i686-w64-mingw32-cmake-static (CMake cross 27 | # compiler) 28 | # 29 | git config 'alias.crossmake' '!i686-w64-mingw32-cmake-static' 30 | -------------------------------------------------------------------------------- /android/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /android/.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | SRB2 4 | 5 | 6 | 7 | 8 | 9 | com.android.ide.eclipse.adt.ResourceManagerBuilder 10 | 11 | 12 | 13 | 14 | com.android.ide.eclipse.adt.PreCompilerBuilder 15 | 16 | 17 | 18 | 19 | org.eclipse.jdt.core.javabuilder 20 | 21 | 22 | 23 | 24 | com.android.ide.eclipse.adt.ApkBuilder 25 | 26 | 27 | 28 | 29 | 30 | com.android.ide.eclipse.adt.AndroidNature 31 | org.eclipse.jdt.core.javanature 32 | 33 | 34 | -------------------------------------------------------------------------------- /android/.settings/org.eclipse.jdt.core.prefs: -------------------------------------------------------------------------------- 1 | #Mon Nov 09 14:38:16 EST 2009 2 | eclipse.preferences.version=1 3 | org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 4 | org.eclipse.jdt.core.compiler.compliance=1.5 5 | org.eclipse.jdt.core.compiler.source=1.5 6 | -------------------------------------------------------------------------------- /android/Android.mk: -------------------------------------------------------------------------------- 1 | LOCAL_PATH:= $(call my-dir) 2 | include $(CLEAR_VARS) 3 | 4 | LOCAL_MODULE_TAGS := user 5 | 6 | LOCAL_SRC_FILES := $(call all-java-files-under, src) 7 | 8 | LOCAL_PACKAGE_NAME := SRB2 9 | LOCAL_CERTIFICATE := media 10 | 11 | LOCAL_REQUIRED_MODULES := libsrb2 12 | LOCAL_JNI_SHARED_LIBRARIES := libsrb2 13 | 14 | include $(BUILD_PACKAGE) 15 | 16 | # Use the following include to make our test apk. 17 | include $(call all-makefiles-under,$(LOCAL_PATH)) 18 | -------------------------------------------------------------------------------- /android/AndroidManifest.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /android/default.properties: -------------------------------------------------------------------------------- 1 | # This file is automatically generated by Android Tools. 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED! 3 | # 4 | # This file must be checked in Version Control Systems. 5 | # 6 | # To customize properties used by the Ant build system use, 7 | # "build.properties", and override values to adapt the script to your 8 | # project structure. 9 | 10 | # Project target. 11 | target=android-4 12 | # Indicates whether an apk should be generated for each density. 13 | split.density=false 14 | -------------------------------------------------------------------------------- /android/gen/org/srb2/R.java: -------------------------------------------------------------------------------- 1 | /* AUTO-GENERATED FILE. DO NOT MODIFY. 2 | * 3 | * This class was automatically generated by the 4 | * aapt tool from the resource data it found. It 5 | * should not be modified by hand. 6 | */ 7 | 8 | package org.srb2; 9 | 10 | public final class R { 11 | public static final class attr { 12 | } 13 | public static final class drawable { 14 | public static final int icon=0x7f020000; 15 | } 16 | public static final class id { 17 | public static final int SoftwareRendererDisplay=0x7f050000; 18 | } 19 | public static final class layout { 20 | public static final int main=0x7f030000; 21 | } 22 | public static final class string { 23 | public static final int app_name=0x7f040001; 24 | public static final int hello=0x7f040000; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /android/res/drawable-hdpi/icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/android/res/drawable-hdpi/icon.png -------------------------------------------------------------------------------- /android/res/drawable-ldpi/icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/android/res/drawable-ldpi/icon.png -------------------------------------------------------------------------------- /android/res/drawable-mdpi/icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/android/res/drawable-mdpi/icon.png -------------------------------------------------------------------------------- /android/res/layout/main.xml: -------------------------------------------------------------------------------- 1 | 2 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /android/res/values/strings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | Hello World, SRB2Game! 4 | SRB2 5 | 6 | -------------------------------------------------------------------------------- /android/src/org/srb2/GameThread.java: -------------------------------------------------------------------------------- 1 | package org.srb2; 2 | 3 | import org.srb2.nativecode.SRB2; 4 | 5 | import android.graphics.Canvas; 6 | import android.util.Log; 7 | import android.view.SurfaceHolder; 8 | 9 | public class GameThread extends Thread { 10 | public static String TAG = "SRB2-GameThread"; 11 | private SurfaceHolder sh; 12 | private SRB2 srb2; 13 | 14 | public GameThread(SurfaceHolder h) { 15 | super(); 16 | this.srb2 = new SRB2(h); 17 | this.sh = h; 18 | } 19 | 20 | @Override 21 | public void run() { 22 | Log.d(TAG, "Starting thread!"); 23 | this.srb2.run(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /android/src/org/srb2/nativecode/Main.java: -------------------------------------------------------------------------------- 1 | package org.srb2.nativecode; 2 | 3 | import java.nio.ByteBuffer; 4 | 5 | public class Main { 6 | private SRB2 srb2; 7 | 8 | public Main(SRB2 srb2) { 9 | this.srb2 = srb2; 10 | } 11 | 12 | public native int main(Video v); 13 | } 14 | -------------------------------------------------------------------------------- /assets/.gitignore: -------------------------------------------------------------------------------- 1 | *.srb 2 | *.pk3 3 | *.dta 4 | *.wad 5 | *.txt 6 | *.kart 7 | !README.txt 8 | !HISTORY.txt 9 | !LICENSE.txt 10 | !LICENSE-3RD-PARTY.txt 11 | !CMakeLists.txt 12 | !debian-template/* 13 | -------------------------------------------------------------------------------- /assets/debian-template/README.source: -------------------------------------------------------------------------------- 1 | srb2-data for Debian 2 | --------------- 3 | 4 | Look in main SRB2 README.source for more information. 5 | -------------------------------------------------------------------------------- /assets/debian-template/changelog: -------------------------------------------------------------------------------- 1 | ${PACKAGE_NAME}-data (${PACKAGE_VERSION}${PACKAGE_SUBVERSION}${PACKAGE_REVISION}) ${PACKAGE_DISTRO}; urgency=${PACKAGE_URGENCY} 2 | 3 | * ${PROGRAM_NAME} v${PROGRAM_VERSION} asset data 4 | 5 | -- ${PACKAGE_NAME_EMAIL} ${__PACKAGE_DATETIME} 6 | -------------------------------------------------------------------------------- /assets/debian-template/compat: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /assets/debian-template/control: -------------------------------------------------------------------------------- 1 | # SRB2-data Debian package control file. 2 | 3 | Source: ${PACKAGE_NAME}-data 4 | Section: games 5 | Priority: extra 6 | Maintainer: ${PACKAGE_GROUP_NAME_EMAIL} 7 | Build-Depends: debhelper (>= 7.0.50~), 8 | wget 9 | Standards-Version: 3.8.4 10 | Homepage: ${PACKAGE_WEBSITE} 11 | 12 | Package: ${PACKAGE_NAME}-data 13 | Architecture: all 14 | Description: A cross-platform 3D Sonic fangame 15 | Sonic Robo Blast 2 is a 3D open-source Sonic the Hedgehog 16 | fangame built using a modified version of the Doom Legacy 17 | port of Doom. SRB2 is closely inspired by the original 18 | Sonic games from the Sega Genesis, and attempts to recreate 19 | the design in 3D. It features tons of levels, enemies, speed, 20 | and quite a lot of the fun that the original Sonic games provided. 21 | This is the data package that provides the data files that 22 | SRB2 requires to run; it will not work without it. 23 | -------------------------------------------------------------------------------- /assets/debian-template/copyright: -------------------------------------------------------------------------------- 1 | This work was packaged for Debian by: 2 | 3 | ${PACKAGE_NAME_EMAIL} ${__PACKAGE_DATETIME} 4 | 5 | It was downloaded from: 6 | 7 | ${PACKAGE_WEBSITE} 8 | 9 | Upstream Author(s): 10 | 11 | ${PACKAGE_GROUP_NAME_EMAIL} 12 | 13 | Copyright: 14 | 15 | Copyright (C) 1998-2018 by Sonic Team Junior 16 | 17 | License: 18 | 19 | GNU General Public License, version 2 20 | 21 | The Debian packaging is: 22 | 23 | Copyright (C) 2010 Callum Dickinson 24 | Copyright (C) 2010-2018 by Sonic Team Junior 25 | 26 | and is licensed under the GPL version 2, 27 | see "/usr/share/common-licenses/GPL-2". 28 | -------------------------------------------------------------------------------- /assets/debian-template/source/format: -------------------------------------------------------------------------------- 1 | 3.0 (native) 2 | -------------------------------------------------------------------------------- /assets/debian-template/source/options: -------------------------------------------------------------------------------- 1 | tar-ignore = "tmp/*" 2 | -------------------------------------------------------------------------------- /cmake/Comptime.cmake: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.5 FATAL_ERROR) 2 | 3 | set(CMAKE_BINARY_DIR "${BINARY_DIR}") 4 | set(CMAKE_CURRENT_BINARY_DIR "${BINARY_DIR}") 5 | 6 | # Set up CMAKE path 7 | set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/") 8 | 9 | include(GitUtilities) 10 | 11 | git_current_branch(SRB2_COMP_BRANCH) 12 | git_working_tree_dirty(SRB2_COMP_UNCOMMITTED) 13 | 14 | git_latest_commit(SRB2_COMP_REVISION) 15 | git_subject(subject) 16 | string(REGEX REPLACE "([\"\\])" "\\\\\\1" SRB2_COMP_NOTE "${subject}") 17 | 18 | if("${CMAKE_BUILD_TYPE}" STREQUAL "") 19 | set(CMAKE_BUILD_TYPE None) 20 | endif() 21 | 22 | # These build types enable optimizations of some kind by default. 23 | set(optimized_build_types "MINSIZEREL;RELEASE;RELWITHDEBINFO") 24 | 25 | string(TOUPPER "${CMAKE_BUILD_TYPE}" build_type) 26 | if("${build_type}" IN_LIST optimized_build_types) 27 | set(SRB2_COMP_OPTIMIZED TRUE) 28 | else() 29 | set(SRB2_COMP_OPTIMIZED FALSE) 30 | endif() 31 | 32 | configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in" "${CMAKE_CURRENT_BINARY_DIR}/src/config.h") 33 | -------------------------------------------------------------------------------- /cmake/Modules/CMakeTestASM_YASMCompiler.cmake: -------------------------------------------------------------------------------- 1 | 2 | #============================================================================= 3 | # Copyright 2010 Kitware, Inc. 4 | # 5 | # Distributed under the OSI-approved BSD License (the "License"); 6 | # see accompanying file Copyright.txt for details. 7 | # 8 | # This software is distributed WITHOUT ANY WARRANTY; without even the 9 | # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 10 | # See the License for more information. 11 | #============================================================================= 12 | # (To distribute this file outside of CMake, substitute the full 13 | # License text for the above reference.) 14 | 15 | # This file is used by EnableLanguage in cmGlobalGenerator to 16 | # determine that the selected ASM_NASM "compiler" works. 17 | # For assembler this can only check whether the compiler has been found, 18 | # because otherwise there would have to be a separate assembler source file 19 | # for each assembler on every architecture. 20 | 21 | set(ASM_DIALECT "_YASM") 22 | include(CMakeTestASMCompiler) 23 | set(ASM_DIALECT) 24 | -------------------------------------------------------------------------------- /cmake/Modules/FindGME.cmake: -------------------------------------------------------------------------------- 1 | include(LibFindMacros) 2 | 3 | libfind_pkg_check_modules(GME_PKGCONF QUIET gme libgme) 4 | 5 | find_path(GME_INCLUDE_DIR 6 | NAMES gme.h 7 | PATHS 8 | ${GME_PKGCONF_INCLUDE_DIRS} 9 | /usr/include 10 | /usr/local/include 11 | PATH_SUFFIXES 12 | gme 13 | ) 14 | 15 | find_library(GME_LIBRARY 16 | NAMES gme 17 | PATHS 18 | ${GME_PKGCONF_LIBRARY_DIRS} 19 | /usr/lib 20 | /usr/local/lib 21 | ) 22 | 23 | include(FindPackageHandleStandardArgs) 24 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(GME 25 | REQUIRED_VARS GME_LIBRARY GME_INCLUDE_DIR) 26 | 27 | if(GME_FOUND AND NOT TARGET gme) 28 | add_library(gme UNKNOWN IMPORTED) 29 | set_target_properties( 30 | gme 31 | PROPERTIES 32 | IMPORTED_LOCATION "${GME_LIBRARY}" 33 | INTERFACE_INCLUDE_DIRECTORIES "${GME_INCLUDE_DIR}" 34 | ) 35 | add_library(gme::gme ALIAS gme) 36 | endif() 37 | 38 | mark_as_advanced(GME_LIBRARY GME_INCLUDE_DIR) 39 | -------------------------------------------------------------------------------- /cmake/Modules/FindOgg.cmake: -------------------------------------------------------------------------------- 1 | include(LibFindMacros) 2 | 3 | libfind_pkg_check_modules(Ogg_PKGCONF ogg) 4 | 5 | find_path(Ogg_INCLUDE_DIR 6 | NAMES ogg/ogg.h 7 | PATHS 8 | ${Ogg_PKGCONF_INCLUDE_DIRS} 9 | "/usr/include" 10 | "/usr/local/include" 11 | ) 12 | 13 | find_library(Ogg_LIBRARY 14 | NAMES ogg 15 | PATHS 16 | ${Ogg_PKGCONF_LIBRARY_DIRS} 17 | "/usr/lib" 18 | "/usr/local/lib" 19 | ) 20 | 21 | include(FindPackageHandleStandardArgs) 22 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(Ogg 23 | REQUIRED_VARS Ogg_LIBRARY Ogg_INCLUDE_DIR) 24 | 25 | if(Ogg_FOUND AND NOT TARGET Ogg::ogg) 26 | add_library(Ogg::ogg UNKNOWN IMPORTED) 27 | set_target_properties( 28 | Ogg::ogg 29 | PROPERTIES 30 | IMPORTED_LOCATION "${Ogg_LIBRARY}" 31 | INTERFACE_INCLUDE_DIRECTORIES "${Ogg_INCLUDE_DIR}" 32 | ) 33 | endif() 34 | 35 | mark_as_advanced(Ogg_LIBRARY Ogg_INCLUDE_DIR) 36 | -------------------------------------------------------------------------------- /cmake/Modules/FindSDL2.cmake: -------------------------------------------------------------------------------- 1 | # Find SDL2 2 | # Once done, this will define 3 | # 4 | # SDL2_FOUND - system has SDL2 5 | # SDL2_INCLUDE_DIRS - SDL2 include directories 6 | # SDL2_LIBRARIES - link libraries 7 | 8 | include(LibFindMacros) 9 | 10 | libfind_pkg_check_modules(SDL2_PKGCONF SDL2) 11 | 12 | # includes 13 | find_path(SDL2_INCLUDE_DIR 14 | NAMES SDL.h 15 | PATHS 16 | ${SDL2_PKGCONF_INCLUDE_DIRS} 17 | "/usr/include/SDL2" 18 | "/usr/local/include/SDL2" 19 | ) 20 | 21 | # library 22 | find_library(SDL2_LIBRARY 23 | NAMES SDL2 24 | PATHS 25 | ${SDL2_PKGCONF_LIBRARY_DIRS} 26 | "/usr/lib" 27 | "/usr/local/lib" 28 | ) 29 | 30 | # set include dir variables 31 | set(SDL2_PROCESS_INCLUDES SDL2_INCLUDE_DIR) 32 | set(SDL2_PROCESS_LIBS SDL2_LIBRARY) 33 | libfind_process(SDL2) 34 | 35 | if(SDL2_FOUND AND NOT TARGET SDL2::SDL2) 36 | add_library(SDL2::SDL2 UNKNOWN IMPORTED) 37 | set_target_properties( 38 | SDL2::SDL2 39 | PROPERTIES 40 | IMPORTED_LOCATION "${SDL2_LIBRARY}" 41 | INTERFACE_INCLUDE_DIRECTORIES "${SDL2_INCLUDE_DIR}" 42 | ) 43 | endif() 44 | -------------------------------------------------------------------------------- /cmake/Modules/FindSDL2_main.cmake: -------------------------------------------------------------------------------- 1 | # Find SDL2 2 | # Once done, this will define 3 | # 4 | # SDL2_MAIN_FOUND - system has SDL2 5 | # SDL2_MAIN_INCLUDE_DIRS - SDL2 include directories 6 | # SDL2_MAIN_LIBRARIES - link libraries 7 | 8 | include(LibFindMacros) 9 | 10 | libfind_pkg_check_modules(SDL2_MAIN_PKGCONF SDL2) 11 | 12 | # includes 13 | find_path(SDL2_MAIN_INCLUDE_DIR 14 | NAMES SDL.h 15 | PATHS 16 | ${SDL2_MAIN_PKGCONF_INCLUDE_DIRS} 17 | "/usr/include/SDL2" 18 | "/usr/local/include/SDL2" 19 | ) 20 | 21 | # library 22 | find_library(SDL2_MAIN_LIBRARY 23 | NAMES SDL2_main 24 | PATHS 25 | ${SDL2_MAIN_PKGCONF_LIBRARY_DIRS} 26 | "/usr/lib" 27 | "/usr/local/lib" 28 | ) 29 | 30 | 31 | # set include dir variables 32 | set(SDL2_MAIN_PROCESS_INCLUDES SDL2_MAIN_INCLUDE_DIR) 33 | set(SDL2_MAIN_PROCESS_LIBS SDL2_MAIN_LIBRARY) 34 | libfind_process(SDL2_MAIN) 35 | -------------------------------------------------------------------------------- /cmake/Modules/FindVPX.cmake: -------------------------------------------------------------------------------- 1 | include(LibFindMacros) 2 | 3 | libfind_pkg_check_modules(VPX_PKGCONF VPX) 4 | 5 | find_path(VPX_INCLUDE_DIR 6 | NAMES vpx/vp8.h 7 | PATHS 8 | ${VPX_PKGCONF_INCLUDE_DIRS} 9 | "/usr/include" 10 | "/usr/local/include" 11 | ) 12 | 13 | find_library(VPX_LIBRARY 14 | NAMES vpx 15 | PATHS 16 | ${VPX_PKGCONF_LIBRARY_DIRS} 17 | "/usr/lib" 18 | "/usr/local/lib" 19 | ) 20 | 21 | set(VPX_PROCESS_INCLUDES VPX_INCLUDE_DIR) 22 | set(VPX_PROCESS_LIBS VPX_LIBRARY) 23 | libfind_process(VPX) 24 | 25 | if(VPX_FOUND AND NOT TARGET libvpx::libvpx) 26 | add_library(libvpx::libvpx UNKNOWN IMPORTED) 27 | set_target_properties( 28 | libvpx::libvpx 29 | PROPERTIES 30 | IMPORTED_LOCATION "${VPX_LIBRARY}" 31 | INTERFACE_INCLUDE_DIRECTORIES "${VPX_INCLUDE_DIR}" 32 | ) 33 | endif() 34 | -------------------------------------------------------------------------------- /cmake/Modules/FindVorbis.cmake: -------------------------------------------------------------------------------- 1 | include(LibFindMacros) 2 | 3 | libfind_pkg_check_modules(Vorbis_PKGCONF Vorbis) 4 | 5 | find_path(Vorbis_INCLUDE_DIR 6 | NAMES vorbis/codec.h 7 | PATHS 8 | ${Vorbis_PKGCONF_INCLUDE_DIRS} 9 | "/usr/include" 10 | "/usr/local/include" 11 | ) 12 | 13 | find_library(Vorbis_LIBRARY 14 | NAMES vorbis 15 | PATHS 16 | ${Vorbis_PKGCONF_LIBRARY_DIRS} 17 | "/usr/lib" 18 | "/usr/local/lib" 19 | ) 20 | 21 | set(Vorbis_PROCESS_INCLUDES Vorbis_INCLUDE_DIR) 22 | set(Vorbis_PROCESS_LIBS Vorbis_LIBRARY) 23 | libfind_process(Vorbis) 24 | 25 | if(Vorbis_FOUND AND NOT TARGET Vorbis::vorbis) 26 | add_library(Vorbis::vorbis UNKNOWN IMPORTED) 27 | set_target_properties( 28 | Vorbis::vorbis 29 | PROPERTIES 30 | IMPORTED_LOCATION "${Vorbis_LIBRARY}" 31 | INTERFACE_INCLUDE_DIRECTORIES "${Vorbis_INCLUDE_DIR}" 32 | ) 33 | endif() 34 | -------------------------------------------------------------------------------- /cmake/Modules/FindVorbisEnc.cmake: -------------------------------------------------------------------------------- 1 | include(LibFindMacros) 2 | 3 | libfind_pkg_check_modules(VorbisEnc_PKGCONF VorbisEnc) 4 | 5 | find_path(VorbisEnc_INCLUDE_DIR 6 | NAMES vorbis/vorbisenc.h 7 | PATHS 8 | ${VorbisEnc_PKGCONF_INCLUDE_DIRS} 9 | "/usr/include" 10 | "/usr/local/include" 11 | ) 12 | 13 | find_library(VorbisEnc_LIBRARY 14 | NAMES vorbisenc 15 | PATHS 16 | ${VorbisEnc_PKGCONF_LIBRARY_DIRS} 17 | "/usr/lib" 18 | "/usr/local/lib" 19 | ) 20 | 21 | set(VorbisEnc_PROCESS_INCLUDES VorbisEnc_INCLUDE_DIR) 22 | set(VorbisEnc_PROCESS_LIBS VorbisEnc_LIBRARY) 23 | libfind_process(VorbisEnc) 24 | 25 | if(VorbisEnc_FOUND AND NOT TARGET Vorbis::vorbisenc) 26 | add_library(Vorbis::vorbisenc UNKNOWN IMPORTED) 27 | set_target_properties( 28 | Vorbis::vorbisenc 29 | PROPERTIES 30 | IMPORTED_LOCATION "${VorbisEnc_LIBRARY}" 31 | INTERFACE_INCLUDE_DIRECTORIES "${VorbisEnc_INCLUDE_DIR}" 32 | ) 33 | endif() 34 | -------------------------------------------------------------------------------- /cmake/Modules/FindYUV.cmake: -------------------------------------------------------------------------------- 1 | include(LibFindMacros) 2 | 3 | libfind_pkg_check_modules(YUV_PKGCONF YUV) 4 | 5 | find_path(YUV_INCLUDE_DIR 6 | NAMES libyuv.h 7 | PATHS 8 | ${YUV_PKGCONF_INCLUDE_DIRS} 9 | "/usr/include" 10 | "/usr/local/include" 11 | ) 12 | 13 | find_library(YUV_LIBRARY 14 | NAMES yuv 15 | PATHS 16 | ${YUV_PKGCONF_LIBRARY_DIRS} 17 | "/usr/lib" 18 | "/usr/local/lib" 19 | ) 20 | 21 | set(YUV_PROCESS_INCLUDES YUV_INCLUDE_DIR) 22 | set(YUV_PROCESS_LIBS YUV_LIBRARY) 23 | libfind_process(YUV) 24 | 25 | if(YUV_FOUND AND NOT TARGET libyuv::libyuv) 26 | add_library(libyuv::libyuv UNKNOWN IMPORTED) 27 | set_target_properties( 28 | libyuv::libyuv 29 | PROPERTIES 30 | IMPORTED_LOCATION "${YUV_LIBRARY}" 31 | INTERFACE_INCLUDE_DIRECTORIES "${YUV_INCLUDE_DIR}" 32 | ) 33 | endif() 34 | -------------------------------------------------------------------------------- /comptime.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | set BRA=Unknown 3 | set REV=illegal 4 | 5 | copy nul: /b +%1\comptime.c tmp.$$$ > nul 6 | move tmp.$$$ %1\comptime.c > nul 7 | 8 | if exist .git goto gitrev 9 | if exist ..\.git goto gitrev 10 | if exist .svn goto svnrev 11 | goto filwri 12 | 13 | :gitrev 14 | set GIT=%2 15 | if "%GIT%"=="" set GIT=git 16 | for /f "usebackq" %%s in (`%GIT% rev-parse --abbrev-ref HEAD`) do @set BRA=%%s 17 | for /f "usebackq" %%s in (`%GIT% rev-parse HEAD`) do @set REV=%%s 18 | set REV=%REV:~0,8% 19 | goto filwri 20 | 21 | :svnrev 22 | set BRA=Subversion 23 | for /f "usebackq" %%s in (`svnversion .`) do @set REV=%%s 24 | set REV=r%REV% 25 | goto filwri 26 | 27 | :filwri 28 | echo // Do not edit! This file was autogenerated > %1\comptime.h 29 | echo // by the %0 batch file >> %1\comptime.h 30 | echo // >> %1\comptime.h 31 | echo const char* compbranch = "%BRA%"; >> %1\comptime.h 32 | echo const char* comprevision = "%REV%"; >> %1\comptime.h 33 | -------------------------------------------------------------------------------- /debian-template/changelog: -------------------------------------------------------------------------------- 1 | ${PACKAGE_NAME} (${PACKAGE_VERSION}${PACKAGE_SUBVERSION}${PACKAGE_REVISION}) ${PACKAGE_DISTRO}; urgency=${PACKAGE_URGENCY} 2 | 3 | * ${PROGRAM_NAME} v${PROGRAM_VERSION} program build 4 | 5 | -- ${PACKAGE_NAME_EMAIL} ${__PACKAGE_DATETIME} 6 | -------------------------------------------------------------------------------- /debian-template/compat: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /debian-template/copyright: -------------------------------------------------------------------------------- 1 | This work was packaged for Debian by: 2 | 3 | ${PACKAGE_NAME_EMAIL} ${__PACKAGE_DATETIME} 4 | 5 | It was downloaded from: 6 | 7 | ${PACKAGE_WEBSITE} 8 | 9 | Upstream Author(s): 10 | 11 | ${PACKAGE_GROUP_NAME_EMAIL} 12 | 13 | Copyright: 14 | 15 | Copyright (C) 1998-2018 by Sonic Team Junior 16 | 17 | License: 18 | 19 | GNU General Public License, version 2 20 | 21 | The Debian packaging is: 22 | 23 | Copyright (C) 2010 Callum Dickinson 24 | Copyright (C) 2010-2018 by Sonic Team Junior 25 | 26 | and is licensed under the GPL version 2, 27 | see "/usr/share/common-licenses/GPL-2". 28 | -------------------------------------------------------------------------------- /debian-template/docs: -------------------------------------------------------------------------------- 1 | README.md 2 | assets/README.txt 3 | assets/LICENSE.txt 4 | assets/LICENSE-3RD-PARTY.txt 5 | -------------------------------------------------------------------------------- /debian-template/source/format: -------------------------------------------------------------------------------- 1 | 3.0 (native) 2 | -------------------------------------------------------------------------------- /debian-template/source/options: -------------------------------------------------------------------------------- 1 | tar-ignore = "assets/*.srb" 2 | tar-ignore = "assets/*.pk3" 3 | tar-ignore = "assets/*.dta" 4 | tar-ignore = "assets/*.wad" 5 | tar-ignore = "assets/*.kart" 6 | tar-ignore = "assets/debian/${PACKAGE_NAME}-data/*" 7 | tar-ignore = "assets/debian/tmp/*" 8 | tar-ignore = "*.obj" 9 | tar-ignore = "*.dep" 10 | tar-ignore = ".git/*" 11 | tar-ignore = ".git*" 12 | -------------------------------------------------------------------------------- /debian-template/srb2.desktop: -------------------------------------------------------------------------------- 1 | [Desktop Entry] 2 | Name=${PROGRAM_NAME} 3 | Comment=${PROGRAM_DESCRIPTION} 4 | Encoding=UTF-8 5 | Exec=${PACKAGE_INSTALL_PATH}/${PROGRAM_FILENAME} 6 | Icon=/usr/share/pixmaps/${PROGRAM_FILENAME}.png 7 | Terminal=false 8 | Type=Application 9 | StartupNotify=false 10 | Categories=Application;Game; 11 | -------------------------------------------------------------------------------- /docs/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/docs/logo.png -------------------------------------------------------------------------------- /scripts/arm64-osx-1015.cmake: -------------------------------------------------------------------------------- 1 | set(VCPKG_TARGET_ARCHITECTURE arm64) 2 | set(VCPKG_OSX_DEPLOYMENT_TARGET 10.15) 3 | set(VCPKG_CRT_LINKAGE dynamic) 4 | set(VCPKG_LIBRARY_LINKAGE static) 5 | 6 | set(VCPKG_CMAKE_SYSTEM_NAME Darwin) 7 | set(VCPKG_OSX_ARCHITECTURES arm64) 8 | -------------------------------------------------------------------------------- /scripts/x64-osx-1015.cmake: -------------------------------------------------------------------------------- 1 | set(VCPKG_TARGET_ARCHITECTURE x64) 2 | set(VCPKG_OSX_DEPLOYMENT_TARGET 10.15) 3 | set(VCPKG_CRT_LINKAGE dynamic) 4 | set(VCPKG_LIBRARY_LINKAGE static) 5 | 6 | set(VCPKG_CMAKE_SYSTEM_NAME Darwin) 7 | set(VCPKG_OSX_ARCHITECTURES x86_64) 8 | -------------------------------------------------------------------------------- /srb2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/srb2.png -------------------------------------------------------------------------------- /srb2banner.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/srb2banner.png -------------------------------------------------------------------------------- /src/.gitignore: -------------------------------------------------------------------------------- 1 | /cscope.out 2 | /srb2wii 3 | -------------------------------------------------------------------------------- /src/Makefile.d/dummy.mk: -------------------------------------------------------------------------------- 1 | makedir:=$(makedir)/Dummy 2 | 3 | sources+=$(call List,dummy/Sourcefile) 4 | 5 | NOHW=1 6 | -------------------------------------------------------------------------------- /src/Makefile.d/nix.mk: -------------------------------------------------------------------------------- 1 | # 2 | # Makefile options for unices (linux, bsd...) 3 | # 4 | 5 | opts+=-DUNIXCOMMON -DLUA_USE_POSIX 6 | libs+=-lm 7 | 8 | ifndef nasm_format 9 | nasm_format:=elf -DLINUX 10 | endif 11 | 12 | ifndef NOHW 13 | opts+=-I/usr/X11R6/include 14 | libs+=-L/usr/X11R6/lib 15 | endif 16 | 17 | SDL?=1 18 | 19 | # In common usage. 20 | ifdef LINUX 21 | libs+=-lrt 22 | passthru_opts+=NOTERMIOS 23 | endif 24 | 25 | # Tested by Steel, as of release 2.2.8. 26 | ifdef FREEBSD 27 | opts+=-I/usr/X11R6/include -DLINUX -DFREEBSD 28 | libs+=-L/usr/X11R6/lib -lipx -lkvm 29 | endif 30 | 31 | # FIXME: UNTESTED 32 | #ifdef SOLARIS 33 | #NOIPX=1 34 | #NOASM=1 35 | #opts+=-I/usr/local/include -I/opt/sfw/include \ 36 | # -DSOLARIS -DINADDR_NONE=INADDR_ANY -DBSD_COMP 37 | #libs+=-L/opt/sfw/lib -lsocket -lnsl 38 | #endif 39 | -------------------------------------------------------------------------------- /src/Makefile.d/old.mk: -------------------------------------------------------------------------------- 1 | # 2 | # Warn about old build directories and offer to purge. 3 | # 4 | 5 | _old:=$(wildcard $(addprefix ../bin/,FreeBSD Linux \ 6 | Linux64 Mingw Mingw64 SDL dummy) ../objs ../dep) 7 | 8 | ifdef _old 9 | $(foreach v,$(_old),$(info $(abspath $(v)))) 10 | $(info ) 11 | $(info These directories are no longer\ 12 | required and should be removed.) 13 | $(info You may remove them manually or\ 14 | by using 'make distclean') 15 | $(error ) 16 | endif 17 | -------------------------------------------------------------------------------- /src/acs/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | environment.cpp 3 | environment.hpp 4 | thread.cpp 5 | thread.hpp 6 | call-funcs.cpp 7 | call-funcs.hpp 8 | stream.cpp 9 | stream.hpp 10 | interface.cpp 11 | interface.h 12 | ) 13 | 14 | target_include_directories(SRB2SDL2 PRIVATE vm) # This sucks 15 | 16 | # This breaks Apple Clang 14 compile. It should be totally 17 | # unecessary since even though vm/CMakeLists.txt sets 18 | # CMAKE_CXX_FLAGS, it is in a lower scope. 19 | #set(ACSVM_NOFLAGS ON) 20 | 21 | set(ACSVM_SHARED OFF) 22 | add_subdirectory(vm) 23 | 24 | target_link_libraries(SRB2SDL2 PRIVATE acsvm) 25 | -------------------------------------------------------------------------------- /src/acs/vm/ACSVM/CallFunc.hpp: -------------------------------------------------------------------------------- 1 | //----------------------------------------------------------------------------- 2 | // 3 | // Copyright (C) 2015 David Hill 4 | // 5 | // See COPYING for license information. 6 | // 7 | //----------------------------------------------------------------------------- 8 | // 9 | // Internal CallFunc functions. 10 | // 11 | //----------------------------------------------------------------------------- 12 | 13 | #ifndef ACSVM__CallFunc_H__ 14 | #define ACSVM__CallFunc_H__ 15 | 16 | #include "Types.hpp" 17 | 18 | 19 | //----------------------------------------------------------------------------| 20 | // Extern Functions | 21 | // 22 | 23 | namespace ACSVM 24 | { 25 | #define ACSVM_FuncList(name) \ 26 | bool (CallFunc_Func_##name)(Thread *thread, Word const *argv, Word argc); 27 | #include "CodeList.hpp" 28 | } 29 | 30 | #endif//ACSVM__CallFunc_H__ 31 | 32 | -------------------------------------------------------------------------------- /src/acs/vm/ACSVM/Jump.hpp: -------------------------------------------------------------------------------- 1 | //----------------------------------------------------------------------------- 2 | // 3 | // Copyright (C) 2015 David Hill 4 | // 5 | // See COPYING for license information. 6 | // 7 | //----------------------------------------------------------------------------- 8 | // 9 | // Jump class. 10 | // 11 | //----------------------------------------------------------------------------- 12 | 13 | #ifndef ACSVM__Jump_H__ 14 | #define ACSVM__Jump_H__ 15 | 16 | #include "HashMapFixed.hpp" 17 | 18 | 19 | //----------------------------------------------------------------------------| 20 | // Types | 21 | // 22 | 23 | namespace ACSVM 24 | { 25 | // 26 | // Jump 27 | // 28 | // Dynamic jump target. 29 | // 30 | class Jump 31 | { 32 | public: 33 | Word codeIdx; 34 | }; 35 | 36 | // 37 | // JumpMap 38 | // 39 | class JumpMap 40 | { 41 | public: 42 | void loadJumps(Byte const *data, std::size_t count); 43 | 44 | HashMapFixed table; 45 | }; 46 | } 47 | 48 | #endif//ACSVM__Jump_H__ 49 | 50 | -------------------------------------------------------------------------------- /src/acs/vm/Util/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ##----------------------------------------------------------------------------- 2 | ## 3 | ## Copyright (C) 2015 David Hill 4 | ## 5 | ## See COPYING for license information. 6 | ## 7 | ##----------------------------------------------------------------------------- 8 | ## 9 | ## CMake file for acsvm-util. 10 | ## 11 | ##----------------------------------------------------------------------------- 12 | 13 | 14 | ##----------------------------------------------------------------------------| 15 | ## Environment Configuration | 16 | ## 17 | 18 | include_directories(.) 19 | 20 | 21 | ##----------------------------------------------------------------------------| 22 | ## Targets | 23 | ## 24 | 25 | ## 26 | ## acsvm-capi 27 | ## 28 | add_library(acsvm-util ${ACSVM_SHARED_DECL} 29 | Floats.cpp 30 | Floats.hpp 31 | ) 32 | 33 | target_link_libraries(acsvm-util acsvm) 34 | 35 | ACSVM_INSTALL_LIB(acsvm-util) 36 | 37 | ## EOF 38 | 39 | -------------------------------------------------------------------------------- /src/android/i_net.c: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #include "../i_net.h" 12 | 13 | boolean I_InitNetwork(void) 14 | { 15 | return false; 16 | } 17 | -------------------------------------------------------------------------------- /src/android/i_video.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef _SRB2_ANDROID_VIDEO_ 12 | #define _SRB2_ANDROID_VIDEO_ 13 | 14 | #include 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | UINT8 *android_surface; 21 | 22 | JNIEnv* jni_env; 23 | jobject androidVideo; 24 | jmethodID videoFrameCB; 25 | 26 | #ifdef __cplusplus 27 | } // extern "C" 28 | #endif 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/android/jni_main.h: -------------------------------------------------------------------------------- 1 | /* DO NOT EDIT THIS FILE - it is machine generated */ 2 | #include 3 | /* Header for class org_srb2_nativecode_Main */ 4 | 5 | #ifndef _Included_org_srb2_nativecode_Main 6 | #define _Included_org_srb2_nativecode_Main 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | /* 11 | * Class: org_srb2_nativecode_Main 12 | * Method: main 13 | * Signature: (Lorg/srb2/nativecode/Video;)I 14 | */ 15 | JNIEXPORT jint JNICALL Java_org_srb2_nativecode_Main_main 16 | (JNIEnv *, jobject, jobject); 17 | 18 | #ifdef __cplusplus 19 | } 20 | #endif 21 | #endif 22 | -------------------------------------------------------------------------------- /src/audio/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | chunk_load.cpp 3 | chunk_load.hpp 4 | expand_mono.cpp 5 | expand_mono.hpp 6 | filter.cpp 7 | filter.hpp 8 | gain.cpp 9 | gain.hpp 10 | mixer.cpp 11 | mixer.hpp 12 | music_player.cpp 13 | music_player.hpp 14 | ogg_player.cpp 15 | ogg_player.hpp 16 | ogg.cpp 17 | ogg.hpp 18 | resample.cpp 19 | resample.hpp 20 | sample.hpp 21 | sound_chunk.hpp 22 | sound_effect_player.cpp 23 | sound_effect_player.hpp 24 | source.hpp 25 | wav_player.cpp 26 | wav_player.hpp 27 | wav.cpp 28 | wav.hpp 29 | xmp_player.cpp 30 | xmp_player.hpp 31 | xmp.cpp 32 | xmp.hpp 33 | ) 34 | -------------------------------------------------------------------------------- /src/audio/chunk_load.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Ronald "Eidolon" Kinard 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __SRB2_AUDIO_CHUNK_LOAD_HPP__ 12 | #define __SRB2_AUDIO_CHUNK_LOAD_HPP__ 13 | 14 | #include 15 | #include 16 | 17 | #include 18 | 19 | #include "sound_chunk.hpp" 20 | 21 | namespace srb2::audio 22 | { 23 | 24 | /// @brief Try to load a chunk from the given byte span. 25 | std::optional try_load_chunk(tcb::span data); 26 | 27 | } // namespace srb2::audio 28 | 29 | #endif // __SRB2_AUDIO_CHUNK_LOAD_HPP__ 30 | -------------------------------------------------------------------------------- /src/audio/expand_mono.cpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Ronald "Eidolon" Kinard 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #include "expand_mono.hpp" 12 | 13 | #include 14 | 15 | using std::size_t; 16 | 17 | using namespace srb2::audio; 18 | 19 | ExpandMono::~ExpandMono() = default; 20 | 21 | size_t ExpandMono::filter(tcb::span> input_buffer, tcb::span> buffer) 22 | { 23 | for (size_t i = 0; i < std::min(input_buffer.size(), buffer.size()); i++) 24 | { 25 | buffer[i].amplitudes[0] = input_buffer[i].amplitudes[0]; 26 | buffer[i].amplitudes[1] = input_buffer[i].amplitudes[0]; 27 | } 28 | return std::min(input_buffer.size(), buffer.size()); 29 | } 30 | -------------------------------------------------------------------------------- /src/audio/expand_mono.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Ronald "Eidolon" Kinard 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __SRB2_AUDIO_EXPAND_MONO_HPP__ 12 | #define __SRB2_AUDIO_EXPAND_MONO_HPP__ 13 | 14 | #include 15 | 16 | #include "filter.hpp" 17 | 18 | namespace srb2::audio 19 | { 20 | 21 | class ExpandMono : public Filter<1, 2> 22 | { 23 | public: 24 | virtual ~ExpandMono(); 25 | virtual std::size_t filter(tcb::span> input_buffer, tcb::span> buffer) override final; 26 | }; 27 | 28 | } // namespace srb2::audio 29 | 30 | #endif // __SRB2_AUDIO_EXPAND_MONO_HPP__ 31 | -------------------------------------------------------------------------------- /src/audio/gain.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Ronald "Eidolon" Kinard 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __SRB2_AUDIO_GAIN_HPP__ 12 | #define __SRB2_AUDIO_GAIN_HPP__ 13 | 14 | #include 15 | 16 | #include "filter.hpp" 17 | 18 | namespace srb2::audio 19 | { 20 | 21 | template 22 | class Gain : public Filter 23 | { 24 | public: 25 | virtual std::size_t filter(tcb::span> input_buffer, tcb::span> buffer) override final; 26 | void gain(float new_gain); 27 | 28 | virtual ~Gain(); 29 | 30 | private: 31 | float new_gain_ {1.f}; 32 | float gain_ {1.f}; 33 | }; 34 | } // namespace srb2::audio 35 | 36 | #endif // __SRB2_AUDIO_GAIN_HPP__ 37 | -------------------------------------------------------------------------------- /src/audio/sound_chunk.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Ronald "Eidolon" Kinard 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __SRB2_AUDIO_SOUND_CHUNK_HPP__ 12 | #define __SRB2_AUDIO_SOUND_CHUNK_HPP__ 13 | 14 | #include 15 | 16 | #include "source.hpp" 17 | 18 | namespace srb2::audio 19 | { 20 | 21 | struct SoundChunk 22 | { 23 | std::vector> samples; 24 | }; 25 | 26 | } // namespace srb2::audio 27 | 28 | #endif // __SRB2_AUDIO_SOUND_CHUNK_HPP__ 29 | -------------------------------------------------------------------------------- /src/blua/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | lapi.c 3 | lbaselib.c 4 | ldo.c 5 | lfunc.c 6 | linit.c 7 | liolib.c 8 | llex.c 9 | lmem.c 10 | lobject.c 11 | lstate.c 12 | lstrlib.c 13 | ltablib.c 14 | lundump.c 15 | lzio.c 16 | lauxlib.c 17 | lcode.c 18 | ldebug.c 19 | ldump.c 20 | lgc.c 21 | lopcodes.c 22 | lparser.c 23 | lstring.c 24 | ltable.c 25 | ltm.c 26 | lvm.c 27 | ) 28 | -------------------------------------------------------------------------------- /src/blua/lapi.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Auxiliary functions from Lua API 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lapi_h 8 | #define lapi_h 9 | 10 | 11 | #include "lobject.h" 12 | 13 | 14 | LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o); 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /src/blua/linit.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Initialization of libraries for lua.c 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #define linit_c 9 | #define LUA_LIB 10 | 11 | #include "lua.h" 12 | 13 | #include "lualib.h" 14 | #include "lauxlib.h" 15 | 16 | 17 | static const luaL_Reg lualibs[] = { 18 | {"", luaopen_base}, 19 | {LUA_TABLIBNAME, luaopen_table}, 20 | {LUA_IOLIBNAME, luaopen_io}, 21 | {LUA_STRLIBNAME, luaopen_string}, 22 | {NULL, NULL} 23 | }; 24 | 25 | 26 | LUALIB_API void luaL_openlibs (lua_State *L) { 27 | const luaL_Reg *lib = lualibs; 28 | for (; lib->func; lib++) { 29 | lua_pushcfunction(L, lib->func); 30 | lua_pushstring(L, lib->name); 31 | lua_call(L, 1, 0); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/blua/lstring.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lstring.h,v 1.43.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** String table (keep all strings handled by Lua) 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lstring_h 8 | #define lstring_h 9 | 10 | 11 | #include "lgc.h" 12 | #include "lobject.h" 13 | #include "lstate.h" 14 | 15 | 16 | #define sizestring(s) (sizeof(union TString)+((s)->len+1)*sizeof(char)) 17 | 18 | #define sizeudata(u) (sizeof(union Udata)+(u)->len) 19 | 20 | #define luaS_new(L, s) (luaS_newlstr(L, s, strlen(s))) 21 | #define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ 22 | (sizeof(s)/sizeof(char))-1)) 23 | 24 | #define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT) 25 | 26 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize); 27 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e); 28 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); 29 | 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /src/blua/lualib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** Lua standard libraries 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #ifndef lualib_h 9 | #define lualib_h 10 | 11 | #include "lua.h" 12 | 13 | 14 | /* Key to file-handle type */ 15 | #define LUA_FILEHANDLE "FILE*" 16 | 17 | 18 | #define LUA_COLIBNAME "coroutine" 19 | LUALIB_API int (luaopen_base) (lua_State *L); 20 | 21 | #define LUA_TABLIBNAME "table" 22 | LUALIB_API int (luaopen_table) (lua_State *L); 23 | 24 | #define LUA_IOLIBNAME "io" 25 | LUALIB_API int (luaopen_io) (lua_State *L); 26 | 27 | #define LUA_STRLIBNAME "string" 28 | LUALIB_API int (luaopen_string) (lua_State *L); 29 | 30 | 31 | /* open all previous libraries */ 32 | LUALIB_API void (luaL_openlibs) (lua_State *L); 33 | 34 | 35 | 36 | #ifndef lua_assert 37 | #define lua_assert(x) ((void)0) 38 | #endif 39 | 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /src/blua/lundump.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lundump.h,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $ 3 | ** load precompiled Lua chunks 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lundump_h 8 | #define lundump_h 9 | 10 | #include "lobject.h" 11 | #include "lzio.h" 12 | 13 | #ifdef LUA_ALLOW_BYTECODE 14 | /* load one chunk; from lundump.c */ 15 | LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name); 16 | #endif 17 | 18 | /* make header; from lundump.c */ 19 | LUAI_FUNC void luaU_header (char* h); 20 | 21 | /* dump one chunk; from ldump.c */ 22 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip); 23 | 24 | #ifdef luac_c 25 | /* print one chunk; from print.c */ 26 | LUAI_FUNC void luaU_print (const Proto* f, int full); 27 | #endif 28 | 29 | /* for header of binary files -- this is Lua 5.1 */ 30 | #define LUAC_VERSION 0x51 31 | 32 | /* for header of binary files -- this is the official format */ 33 | #define LUAC_FORMAT 0 34 | 35 | /* size of header of binary files */ 36 | #define LUAC_HEADERSIZE 12 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /src/config.h.in: -------------------------------------------------------------------------------- 1 | /** SRB2 CMake Configuration */ 2 | 3 | #ifndef __CONFIG_H__ 4 | #define __CONFIG_H__ 5 | 6 | /* DO NOT MODIFY config.h DIRECTLY! It will be overwritten by cmake. 7 | * If you want to change a configuration option here, modify it in 8 | * your CMakeCache.txt. config.h.in is used as a template for CMake 9 | * variables, so you can insert them here too. 10 | */ 11 | 12 | #ifdef CMAKECONFIG 13 | 14 | #define SRB2_COMP_REVISION "${SRB2_COMP_REVISION}" 15 | #define SRB2_COMP_BRANCH "${SRB2_COMP_BRANCH}" 16 | #define SRB2_COMP_NOTE "${SRB2_COMP_NOTE}" 17 | // This is done with configure_file instead of defines in order to avoid 18 | // recompiling the whole target whenever the working directory state changes 19 | #cmakedefine SRB2_COMP_UNCOMMITTED 20 | #ifdef SRB2_COMP_UNCOMMITTED 21 | #define COMPVERSION_UNCOMMITTED 22 | #endif 23 | 24 | #define CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" 25 | #cmakedefine01 SRB2_COMP_OPTIMIZED 26 | 27 | #endif 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /src/core/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | memory.cpp 3 | memory.h 4 | spmc_queue.hpp 5 | static_vec.hpp 6 | thread_pool.cpp 7 | thread_pool.h 8 | ) 9 | -------------------------------------------------------------------------------- /src/deh_lua.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | /// \file deh_lua.h 12 | /// \brief Lua SOC library 13 | 14 | #ifndef __DEH_LUA_H__ 15 | #define __DEH_LUA_H__ 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | boolean LUA_SetLuaAction(void *state, const char *actiontocompare); 22 | const char *LUA_GetActionName(void *action); 23 | void LUA_SetActionByName(void *state, const char *actiontocompare); 24 | size_t LUA_GetActionNumByName(const char *actiontocompare); 25 | 26 | #ifdef __cplusplus 27 | } // extern "C" 28 | #endif 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/dummy/Sourcefile: -------------------------------------------------------------------------------- 1 | i_net.c 2 | i_system.c 3 | i_main.c 4 | i_video.c 5 | i_sound.c 6 | -------------------------------------------------------------------------------- /src/dummy/i_main.c: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // Copyright (C) 1996 by id Software, Inc. 7 | // 8 | // This program is free software distributed under the 9 | // terms of the GNU General Public License, version 2. 10 | // See the 'LICENSE' file for more details. 11 | //----------------------------------------------------------------------------- 12 | 13 | #include "../doomdef.h" 14 | #include "../d_main.h" 15 | #include "../m_argv.h" 16 | 17 | int main(int argc, char **argv) 18 | { 19 | myargc = argc; 20 | myargv = argv; /// \todo pull out path to exe from this string 21 | 22 | // startup SRB2 23 | CONS_Printf("Setting up SRB2...\n"); 24 | D_SRB2Main(); 25 | CONS_Printf("Entering main game loop...\n"); 26 | // never return 27 | D_SRB2Loop(); 28 | 29 | // return to OS 30 | #ifndef __GNUC__ 31 | return 0; 32 | #endif 33 | } 34 | -------------------------------------------------------------------------------- /src/dummy/i_net.c: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // Copyright (C) 1996 by id Software, Inc. 7 | // 8 | // This program is free software distributed under the 9 | // terms of the GNU General Public License, version 2. 10 | // See the 'LICENSE' file for more details. 11 | //----------------------------------------------------------------------------- 12 | 13 | #include "../i_net.h" 14 | 15 | boolean I_InitNetwork(void) 16 | { 17 | return false; 18 | } 19 | -------------------------------------------------------------------------------- /src/hardware/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | hw_bsp.c 3 | hw_draw.c 4 | hw_light.c 5 | hw_main.c 6 | hw_clip.c 7 | hw_md2.c 8 | hw_cache.c 9 | hw_md2load.c 10 | hw_md3load.c 11 | hw_model.c 12 | u_list.c 13 | hw_batching.c 14 | r_opengl/r_opengl.c 15 | ) 16 | -------------------------------------------------------------------------------- /src/hardware/hw_md2load.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2020 by Spaddlewit Inc. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | 12 | /* 13 | From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com ) 14 | An experimental work-in-progress. 15 | 16 | Donated to Sonic Team Junior and adapted to work with 17 | Sonic Robo Blast 2. 18 | */ 19 | 20 | #ifndef _HW_MD2LOAD_H_ 21 | #define _HW_MD2LOAD_H_ 22 | 23 | #include "hw_model.h" 24 | #include "../doomtype.h" 25 | 26 | #ifdef __cplusplus 27 | extern "C" { 28 | #endif 29 | 30 | // Load the Model 31 | model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat); 32 | 33 | #ifdef __cplusplus 34 | } // extern "C" 35 | #endif 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /src/hardware/hw_md3load.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2020 by Spaddlewit Inc. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | 12 | /* 13 | From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com ) 14 | An experimental work-in-progress. 15 | 16 | Donated to Sonic Team Junior and adapted to work with 17 | Sonic Robo Blast 2. 18 | */ 19 | 20 | #ifndef _HW_MD3LOAD_H_ 21 | #define _HW_MD3LOAD_H_ 22 | 23 | #include "hw_model.h" 24 | #include "../doomtype.h" 25 | 26 | #ifdef __cplusplus 27 | extern "C" { 28 | #endif 29 | 30 | // Load the Model 31 | model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat); 32 | 33 | #ifdef __cplusplus 34 | } // extern "C" 35 | #endif 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /src/hardware/r_minigl/r_minigl.c: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | /// \file 12 | /// \brief MiniGL API for Doom Legacy 13 | 14 | 15 | // tell r_opengl.cpp to compile for MiniGL Drivers 16 | #define MINI_GL_COMPATIBILITY 17 | 18 | // tell r_opengl.cpp to compile for ATI Rage Pro OpenGL driver 19 | //#define ATI_RAGE_PRO_COMPATIBILITY 20 | 21 | #define DRIVER_STRING "HWRAPI Init(): Ring Racers MiniGL renderer" 22 | 23 | // Include this at end 24 | #include "../r_opengl/r_opengl.c" 25 | #include "../r_opengl/ogl_win.c" 26 | 27 | // That's all ;-) 28 | // Just, be sure to do the right changes in r_opengl.cpp 29 | -------------------------------------------------------------------------------- /src/hud/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | powerup.cpp 3 | spectator.cpp 4 | timer.cpp 5 | emerald-win.cpp 6 | input-display.cpp 7 | ) 8 | -------------------------------------------------------------------------------- /src/hwr2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | blendmode.hpp 3 | blit_postimg_screens.cpp 4 | blit_postimg_screens.hpp 5 | blit_rect.cpp 6 | blit_rect.hpp 7 | hardware_state.hpp 8 | pass_imgui.cpp 9 | pass_imgui.hpp 10 | pass_manager.cpp 11 | pass_manager.hpp 12 | pass_resource_managers.cpp 13 | pass_resource_managers.hpp 14 | pass.cpp 15 | pass.hpp 16 | patch_atlas.cpp 17 | patch_atlas.hpp 18 | postprocess_wipe.cpp 19 | postprocess_wipe.hpp 20 | resource_management.cpp 21 | resource_management.hpp 22 | screen_capture.cpp 23 | screen_capture.hpp 24 | software_screen_renderer.cpp 25 | software_screen_renderer.hpp 26 | twodee.cpp 27 | twodee.hpp 28 | twodee_renderer.cpp 29 | twodee_renderer.hpp 30 | upscale_backbuffer.cpp 31 | upscale_backbuffer.hpp 32 | ) 33 | -------------------------------------------------------------------------------- /src/hwr2/blendmode.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Ronald "Eidolon" Kinard 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __SRB2_HWR2_BLENDMODE_HPP__ 12 | #define __SRB2_HWR2_BLENDMODE_HPP__ 13 | 14 | namespace srb2::hwr2 15 | { 16 | 17 | enum class BlendMode 18 | { 19 | kAlphaTransparent, 20 | kModulate, 21 | kAdditive, 22 | kSubtractive, 23 | kReverseSubtractive, 24 | kInvertDest 25 | }; 26 | 27 | } // namespace srb2::hwr2 28 | 29 | #endif // __SRB2_HWR2_BLENDMODE_HPP__ 30 | -------------------------------------------------------------------------------- /src/hwr2/pass.cpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Ronald "Eidolon" Kinard 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #include "pass.hpp" 12 | 13 | using namespace srb2; 14 | using namespace srb2::hwr2; 15 | 16 | Pass::~Pass() = default; 17 | -------------------------------------------------------------------------------- /src/io/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | streams.cpp 3 | streams.hpp 4 | ) 5 | -------------------------------------------------------------------------------- /src/k_dialogue.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Sally "TehRealSalt" Cochenour 4 | // Copyright (C) 2025 by Kart Krew 5 | // Copyright (C) 2020 by Sonic Team Junior 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | /// \file k_dialogue.h 12 | /// \brief Basic text prompts 13 | 14 | #ifndef __K_DIALOGUE__ 15 | #define __K_DIALOGUE__ 16 | 17 | #include "doomtype.h" 18 | #include "doomdef.h" 19 | 20 | #ifdef __cplusplus 21 | extern "C" { 22 | #endif 23 | 24 | void K_UnsetDialogue(void); 25 | void K_DrawDialogue(void); 26 | void K_TickDialogue(void); 27 | 28 | boolean K_DialogueFreeze(void); 29 | INT32 K_GetDialogueSlide(fixed_t multiplier); 30 | 31 | #ifdef __cplusplus 32 | } // extern "C" 33 | #endif 34 | 35 | #endif //__K_DIALOGUE__ 36 | -------------------------------------------------------------------------------- /src/k_powerup.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman. 4 | // Copyright (C) 2025 by Kart Krew. 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __K_POWERUP__ 12 | #define __K_POWERUP__ 13 | 14 | #include "doomtype.h" 15 | #include "d_player.h" 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | #define BATTLE_POWERUP_VFX_TIME (40) 22 | 23 | tic_t K_PowerUpRemaining(const player_t *player, kartitems_t powerup); 24 | UINT32 K_AnyPowerUpRemaining(const player_t *player); // returns POWERUP_BIT mask 25 | void K_GivePowerUp(player_t *player, kartitems_t powerup, tic_t timer); 26 | void K_DropPowerUps(player_t *player); 27 | 28 | #ifdef __cplusplus 29 | } // extern "C" 30 | #endif 31 | 32 | #endif // __K_POWERUP__ 33 | -------------------------------------------------------------------------------- /src/lua_profile.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef lua_profile_h 12 | #define lua_profile_h 13 | 14 | #include "blua/lua.h" 15 | #include "doomtype.h" 16 | #include "typedef.h" 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | struct lua_timer_t; 23 | 24 | void LUA_ResetTicTimers(void); 25 | 26 | lua_timer_t *LUA_BeginFunctionTimer(lua_State *L, int fn_idx, const char *name); 27 | void LUA_EndFunctionTimer(lua_timer_t *timer); 28 | 29 | void LUA_RenderTimers(void); 30 | 31 | #ifdef __cplusplus 32 | } // extern "C" 33 | #endif 34 | 35 | #endif/*lua_profile_h*/ 36 | -------------------------------------------------------------------------------- /src/m_avrecorder.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __M_AVRECORDER_HPP__ 12 | #define __M_AVRECORDER_HPP__ 13 | 14 | #include // shared_ptr 15 | 16 | #include "media/avrecorder.hpp" 17 | 18 | extern std::shared_ptr g_av_recorder; 19 | 20 | #endif // __M_AVRECORDER_HPP__ 21 | -------------------------------------------------------------------------------- /src/m_memcpy.c: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // Copyright (C) 1996 by id Software, Inc. 7 | // 8 | // This program is free software distributed under the 9 | // terms of the GNU General Public License, version 2. 10 | // See the 'LICENSE' file for more details. 11 | //----------------------------------------------------------------------------- 12 | /// \file m_memcpy.c 13 | /// \brief (formerly) X86 optimized implementations of M_Memcpy 14 | 15 | #include "doomdef.h" 16 | #include "m_misc.h" 17 | 18 | void *M_Memcpy(void* dest, const void* src, size_t n) 19 | { 20 | memcpy(dest, src, n); 21 | return dest; 22 | } 23 | -------------------------------------------------------------------------------- /src/m_pw.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef m_pw_H 12 | #define m_pw_H 13 | 14 | #include "doomtype.h" 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | typedef enum 21 | { 22 | M_PW_INVALID, 23 | M_PW_EXTRAS, 24 | M_PW_CHALLENGES, 25 | } 26 | try_password_e; 27 | 28 | void M_PasswordInit(void); 29 | try_password_e M_TryPassword(const char *password, boolean challenges); 30 | boolean M_TryExactPassword(const char *password, const char *encodedhash); 31 | 32 | #ifdef __cplusplus 33 | } // extern "C" 34 | #endif 35 | 36 | #endif/*m_pw_H*/ 37 | -------------------------------------------------------------------------------- /src/m_pw_hash.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef m_pw_hash_H 12 | #define m_pw_hash_H 13 | 14 | #include "doomtype.h" 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | #define M_PW_HASH_SIZE (64) 21 | #define M_PW_SALT_SIZE (16) 22 | #define M_PW_BUF_SIZE M_PW_HASH_SIZE 23 | 24 | UINT8 *M_HashPassword(UINT8 hash[M_PW_HASH_SIZE], const char *key, const UINT8 salt[M_PW_SALT_SIZE]); 25 | 26 | #ifdef __cplusplus 27 | } // extern "C" 28 | #endif 29 | 30 | #endif/*m_pw_hash_H*/ 31 | -------------------------------------------------------------------------------- /src/math/traits.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef math_traits_hpp 12 | #define math_traits_hpp 13 | 14 | #include 15 | #include 16 | 17 | namespace srb2::math 18 | { 19 | 20 | template 21 | struct Traits; 22 | 23 | template 24 | struct Traits>> 25 | { 26 | static constexpr T kZero = 0.0; 27 | static constexpr T kUnit = 1.0; 28 | 29 | static T copysign(T x, T y) { return std::copysign(x, y); } 30 | static T hypot(T x, T y) { return std::hypot(x, y); } 31 | }; 32 | 33 | }; // namespace srb2::math 34 | 35 | #endif/*math_traits_hpp*/ 36 | -------------------------------------------------------------------------------- /src/media/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | audio_encoder.hpp 3 | avrecorder.cpp 4 | avrecorder.hpp 5 | avrecorder_feedback.cpp 6 | avrecorder_impl.hpp 7 | avrecorder_indexed.cpp 8 | avrecorder_queue.cpp 9 | cfile.cpp 10 | cfile.hpp 11 | container.hpp 12 | encoder.hpp 13 | options.cpp 14 | options.hpp 15 | options_values.cpp 16 | video_encoder.hpp 17 | video_frame.hpp 18 | vorbis.cpp 19 | vorbis.hpp 20 | vorbis_error.hpp 21 | vp8.cpp 22 | vp8.hpp 23 | vpx_error.hpp 24 | webm.hpp 25 | webm_encoder.hpp 26 | webm_container.cpp 27 | webm_container.hpp 28 | webm_vorbis.hpp 29 | webm_vorbis_lace.cpp 30 | webm_vp8.hpp 31 | webm_writer.hpp 32 | yuv420p.cpp 33 | yuv420p.hpp 34 | ) 35 | -------------------------------------------------------------------------------- /src/media/cfile.cpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | #include 17 | 18 | #include "cfile.hpp" 19 | 20 | using namespace srb2::media; 21 | 22 | CFile::CFile(const std::string file_name) : name_(file_name) 23 | { 24 | file_ = std::fopen(name(), "wb"); 25 | 26 | if (file_ == nullptr) 27 | { 28 | throw std::invalid_argument(fmt::format("{}: {}", name(), std::strerror(errno))); 29 | } 30 | } 31 | 32 | CFile::~CFile() 33 | { 34 | std::fclose(file_); 35 | } 36 | -------------------------------------------------------------------------------- /src/media/cfile.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __SRB2_MEDIA_CFILE_HPP__ 12 | #define __SRB2_MEDIA_CFILE_HPP__ 13 | 14 | #include 15 | #include 16 | 17 | namespace srb2::media 18 | { 19 | 20 | class CFile 21 | { 22 | public: 23 | CFile(const std::string file_name); 24 | ~CFile(); 25 | 26 | operator std::FILE*() const { return file_; } 27 | 28 | const char* name() const { return name_.c_str(); } 29 | 30 | private: 31 | std::string name_; 32 | std::FILE* file_; 33 | }; 34 | 35 | }; // namespace srb2::media 36 | 37 | #endif // __SRB2_MEDIA_CFILE_HPP__ 38 | -------------------------------------------------------------------------------- /src/media/webm.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __SRB2_MEDIA_WEBM_HPP__ 12 | #define __SRB2_MEDIA_WEBM_HPP__ 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace srb2::media::webm 19 | { 20 | 21 | using track = uint64_t; 22 | using timestamp = uint64_t; 23 | using duration = std::chrono::duration; 24 | 25 | }; // namespace srb2::media::webm 26 | 27 | #endif // __SRB2_MEDIA_WEBM_HPP__ 28 | -------------------------------------------------------------------------------- /src/media/webm_writer.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __SRB2_MEDIA_WEBM_WRITER_HPP__ 12 | #define __SRB2_MEDIA_WEBM_WRITER_HPP__ 13 | 14 | #include 15 | #include 16 | 17 | #include 18 | 19 | #include "cfile.hpp" 20 | 21 | namespace srb2::media 22 | { 23 | 24 | class WebmWriter : public CFile, public mkvmuxer::MkvWriter 25 | { 26 | public: 27 | WebmWriter(const std::string file_name) : CFile(file_name), MkvWriter(static_cast(*this)) {} 28 | ~WebmWriter() { MkvWriter::Close(); } 29 | }; 30 | 31 | }; // namespace srb2::media 32 | 33 | #endif // __SRB2_MEDIA_WEBM_WRITER_HPP__ 34 | -------------------------------------------------------------------------------- /src/menus/class-egg-tv/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | EggTV.cpp 3 | EggTVData.cpp 4 | ) 5 | -------------------------------------------------------------------------------- /src/menus/main-profile-select.c: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // 5 | // This program is free software distributed under the 6 | // terms of the GNU General Public License, version 2. 7 | // See the 'LICENSE' file for more details. 8 | //----------------------------------------------------------------------------- 9 | /// \file menus/main-profile-select.c 10 | /// \brief Duplicate for main profile select. 11 | 12 | #include "../k_menu.h" 13 | 14 | menuitem_t MAIN_Profiles[] = { 15 | {IT_KEYHANDLER | IT_NOTHING, NULL, "Select a profile to use or create a new Profile.", 16 | NULL, {.routine = M_HandleProfileSelect}, 0, 0}, // dummy menuitem for the control func 17 | }; 18 | 19 | menu_t MAIN_ProfilesDef = { 20 | sizeof (MAIN_Profiles) / sizeof (menuitem_t), 21 | NULL, 22 | 0, 23 | MAIN_Profiles, 24 | 32, 80, 25 | SKINCOLOR_ULTRAMARINE, 0, 26 | MBF_DRAWBGWHILEPLAYING, 27 | "FILE", 28 | 2, 5, 29 | M_DrawProfileSelect, 30 | M_DrawOptionsCogs, 31 | M_OptionsTick, 32 | NULL, 33 | NULL, 34 | NULL, 35 | }; 36 | -------------------------------------------------------------------------------- /src/menus/transient/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | cup-select.c 3 | explosions.c 4 | level-select.c 5 | gametype.c 6 | manual.c 7 | sound-test.c 8 | message-box.c 9 | pause-game.c 10 | pause-kick.c 11 | pause-replay.c 12 | virtual-keyboard.c 13 | pause-cheats.cpp 14 | pause-addonoptions.cpp 15 | ) 16 | 17 | if(SRB2_CONFIG_ENABLE_DISCORDRPC) 18 | target_sources(SRB2SDL2 PRIVATE discord-requests.c) 19 | endif() 20 | -------------------------------------------------------------------------------- /src/modp_b64/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | modp_b64.c 3 | ) 4 | -------------------------------------------------------------------------------- /src/modp_b64/config.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | #include "../endian.h" 3 | #ifdef SRB2_BIG_ENDIAN 4 | #define WORDS_BIGENDIAN 1 5 | #endif 6 | #include "modp_stdint.h" 7 | -------------------------------------------------------------------------------- /src/modp_b64/extern_c_begin.h: -------------------------------------------------------------------------------- 1 | #ifdef __cplusplus 2 | extern "C" { 3 | #endif 4 | -------------------------------------------------------------------------------- /src/modp_b64/extern_c_end.h: -------------------------------------------------------------------------------- 1 | #ifdef __cplusplus 2 | } 3 | #endif 4 | -------------------------------------------------------------------------------- /src/monocypher/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | monocypher.c 3 | monocypher.h 4 | ) 5 | -------------------------------------------------------------------------------- /src/music_detail.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef MUSIC_DETAIL_HPP 12 | #define MUSIC_DETAIL_HPP 13 | 14 | #include "doomdef.h" 15 | #include "doomstat.h" 16 | #include "doomtype.h" 17 | 18 | namespace srb2::music::detail 19 | { 20 | 21 | inline constexpr tic_t msec_to_tics(int msec) 22 | { 23 | return msec * (TICRATE / 1000.f); 24 | } 25 | 26 | inline constexpr int tics_to_msec(tic_t tics) 27 | { 28 | return tics * (1000.f / TICRATE); 29 | } 30 | 31 | inline tic_t tic_time() 32 | { 33 | // Use gametic so it is synced with game logic. 34 | return gametic; 35 | } 36 | 37 | }; // namespace srb2::music::detail 38 | 39 | #endif // MUSIC_DETAIL_HPP 40 | -------------------------------------------------------------------------------- /src/objects/objects.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // 5 | // This program is free software distributed under the 6 | // terms of the GNU General Public License, version 2. 7 | // See the 'LICENSE' file for more details. 8 | //----------------------------------------------------------------------------- 9 | 10 | #ifndef objects_objects_hpp 11 | #define objects_objects_hpp 12 | 13 | #include "../math/fixed.hpp" 14 | #include "../math/vec.hpp" 15 | #include "../mobj.hpp" 16 | 17 | #include "../k_objects.h" 18 | 19 | namespace srb2::objects 20 | { 21 | 22 | using srb2::Mobj; 23 | using srb2::math::Fixed; 24 | using srb2::math::Vec2; 25 | 26 | }; // namespace srb2::objects 27 | 28 | #endif/*objects_objects_hpp*/ 29 | -------------------------------------------------------------------------------- /src/objects/versus/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | arena.c 3 | blendeye.c 4 | ) 5 | -------------------------------------------------------------------------------- /src/p_link.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef p_link_h 12 | #define p_link_h 13 | 14 | #include "typedef.h" 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | void P_InitMobjPointers(void); 21 | void P_SaveMobjPointers(void(*callback)(mobj_t*)); 22 | void P_LoadMobjPointers(void(*callback)(mobj_t**)); 23 | 24 | #ifdef __cplusplus 25 | } // extern "C" 26 | #endif 27 | 28 | #endif/*p_link_h*/ 29 | -------------------------------------------------------------------------------- /src/r_debug.hpp: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman. 4 | // Copyright (C) 2025 by Kart Krew. 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef r_debug_hpp 12 | #define r_debug_hpp 13 | 14 | #include "doomtype.h" 15 | 16 | namespace srb2::r_debug 17 | { 18 | 19 | void add_texture_to_frame_list(INT32 texnum); 20 | void clear_frame_list(); 21 | void draw_frame_list(); 22 | 23 | }; // namespace srb2::r_debug 24 | 25 | #endif/*r_debug_hpp*/ 26 | -------------------------------------------------------------------------------- /src/r_patchrotation.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Jaime "Lactozilla" Passos. 5 | // Copyright (C) 2020 by Sonic Team Junior. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | /// \file r_patchrotation.h 12 | /// \brief Patch rotation. 13 | 14 | #include "r_patch.h" 15 | #include "r_picformats.h" 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | #ifdef ROTSPRITE 22 | rotsprite_t *RotatedPatch_Create(INT32 numangles); 23 | void RotatedPatch_DoRotation(rotsprite_t *rotsprite, patch_t *patch, INT32 angle, INT32 xpivot, INT32 ypivot, boolean flip); 24 | 25 | extern fixed_t rollcosang[ROTANGLES]; 26 | extern fixed_t rollsinang[ROTANGLES]; 27 | 28 | #ifdef __cplusplus 29 | } // extern "C" 30 | #endif 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /src/r_segs.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // Copyright (C) 1996 by id Software, Inc. 7 | // 8 | // This program is free software distributed under the 9 | // terms of the GNU General Public License, version 2. 10 | // See the 'LICENSE' file for more details. 11 | //----------------------------------------------------------------------------- 12 | /// \file r_segs.h 13 | /// \brief Refresh module, drawing LineSegs from BSP 14 | 15 | #ifndef __R_SEGS__ 16 | #define __R_SEGS__ 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | transnum_t R_GetLinedefTransTable(fixed_t alpha); 23 | void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2); 24 | void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pffloor); 25 | void R_StoreWallRange(INT32 start, INT32 stop); 26 | 27 | #ifdef __cplusplus 28 | } // extern "C" 29 | #endif 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /src/rhi/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | handle.hpp 3 | rhi.cpp 4 | rhi.hpp 5 | shader_load_context.cpp 6 | shader_load_context.hpp 7 | ) 8 | 9 | add_subdirectory(gl2) 10 | -------------------------------------------------------------------------------- /src/rhi/gl2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | target_sources(SRB2SDL2 PRIVATE 2 | gl2_rhi.cpp 3 | gl2_rhi.hpp 4 | ) 5 | -------------------------------------------------------------------------------- /src/rhi/gles2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Backend not available yet :) 2 | -------------------------------------------------------------------------------- /src/sdl/MakeCYG.cfg: -------------------------------------------------------------------------------- 1 | # 2 | # sdl/makeCYG.cfg for SRB2/Cygwin 3 | # 4 | 5 | # 6 | #Cygwin, for debugging 7 | 8 | NOHW=1 9 | NOHS=1 10 | NOASM=1 11 | 12 | OPTS+=-DLINUX 13 | 14 | i_system_o+=$(OBJDIR)/SRB2.res 15 | 16 | # name of the exefile 17 | EXENAME?=lsdlsrb2.exe 18 | -------------------------------------------------------------------------------- /src/sdl/SDL_main/SDL_dummy_main.c: -------------------------------------------------------------------------------- 1 | /* Include the SDL main definition header */ 2 | #include "SDL_main.h" 3 | 4 | #ifdef main 5 | #undef main 6 | int main(int argc, char *argv[]) 7 | { 8 | return(SDL_main(argc, argv)); 9 | } 10 | #else 11 | /* Nothing to do on this platform */; 12 | #endif 13 | -------------------------------------------------------------------------------- /src/sdl/SDL_main/SDL_macosx_main.h: -------------------------------------------------------------------------------- 1 | /* SDLMain.m - main entry point for our Cocoa-ized SDL app 2 | Initial Version: Darrell Walisser 3 | Non-NIB-Code & other changes: Max Horn 4 | 5 | Feel free to customize this file to suit your needs 6 | */ 7 | 8 | #import 9 | 10 | @interface SDLMain : NSObject 11 | @end 12 | -------------------------------------------------------------------------------- /src/sdl/SDL_main/SDL_openxdk_main.c: -------------------------------------------------------------------------------- 1 | /* Include the SDL main definition header */ 2 | #include "SDL_main.h" 3 | 4 | void XBoxStartup() 5 | { 6 | SDL_main(0, NULL); /// \todo ? 7 | } 8 | -------------------------------------------------------------------------------- /src/sdl/SRB2Pandora/Makefile.cfg: -------------------------------------------------------------------------------- 1 | # Quick Pandora target to make a compliant SRB2 PND file. 2 | 3 | PNDNAME=SRB2.pnd 4 | PNDDIR=$(BIN)/pnd 5 | ICON=sdl/SRB2Pandora/icon.png 6 | PXML=sdl/SRB2Pandora/PXML.xml 7 | 8 | SED=sed 9 | CAT=cat 10 | CP=cp 11 | XARGS=xargs 12 | FOR=for 13 | WGET=wget -P $(PNDDIR) -c -nc 14 | 15 | SHXARGS:=$(XARGS) 16 | SHSED:=$(SED) 17 | 18 | ifndef ECHO 19 | CP:=@$(CP) 20 | CAT:=@$(CAT) 21 | SED:=@$(SED) 22 | XARGS:=@$(XARGS) 23 | FOR:=@(FOR) 24 | endif 25 | 26 | $(BIN)/$(PNDNAME): $(BIN)/$(EXENAME) 27 | @echo Linking $(PNDNAME)... 28 | $(MKDIR) $(PNDDIR) 29 | $(CP) $(BIN)/$(EXENAME) $(PNDDIR) 30 | $(CP) $(ICON) $(PNDDIR) 31 | $(CP) $(PXML) $(PNDDIR) 32 | ifdef WITHDATA 33 | $(FOR) datafile in $(shell echo $(D_FILES) | $(SHSED) 's/\.srb/\.wad/' | $(SHXARGS) -n 1 basename); do \ 34 | $(WGET) http://alam.srb2.org/SRB2/2.0.6-Final/Resources/$$datafile; \ 35 | done 36 | endif 37 | $(MKISOFS) -l -r -o $@ $(PNDDIR) 38 | $(CAT) $(PXML) >> $@ 39 | $(REMOVE) -r $(PNDDIR) 40 | -------------------------------------------------------------------------------- /src/sdl/SRB2Pandora/PXML.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Sonic Robo Blast 2 5 | ソニック・ロボ・ブラスト・２ 6 | A 3D Sonic fangame with a huge fanbase developing custom content, including characters, levels, and even large-scale modifications 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/sdl/SRB2Pandora/icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/sdl/SRB2Pandora/icon.png -------------------------------------------------------------------------------- /src/sdl/Srb2SDL.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/sdl/Srb2SDL.ico -------------------------------------------------------------------------------- /src/sdl/Srb2SDL.props: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | HAVE_ZLIB;HAVE_LIBGME;USE_WGL_SWAP;DIRECTFULLSCREEN;HAVE_SDL;HWRENDER;HW3SOUND;HAVE_FILTER;HAVE_MIXER;HAVE_OPENMPT;SDLMAIN;%(PreprocessorDefinitions) 10 | 11 | USE_WGL_SWAP;DIRECTFULLSCREEN;HAVE_SDL;HWRENDER;HW3SOUND;HAVE_FILTER;HAVE_MIXER;SDLMAIN;%(PreprocessorDefinitions) 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /src/sdl/dosstr.c: -------------------------------------------------------------------------------- 1 | // Emacs style mode select -*- C++ -*- 2 | //----------------------------------------------------------------------------- 3 | // 4 | // This file is in the public domain. 5 | // (Re)written by Graue in 2006. 6 | // 7 | //----------------------------------------------------------------------------- 8 | /// \file 9 | /// \brief String uppercasing/lowercasing functions for non-DOS non-Win32 10 | /// systems 11 | 12 | #include "../doomtype.h" 13 | 14 | #ifndef HAVE_DOSSTR_FUNCS 15 | 16 | #include 17 | 18 | int strupr(char *n) 19 | { 20 | while (*n != '\0') 21 | { 22 | *n = toupper(*n); 23 | n++; 24 | } 25 | return 1; 26 | } 27 | 28 | int strlwr(char *n) 29 | { 30 | while (*n != '\0') 31 | { 32 | *n = tolower(*n); 33 | n++; 34 | } 35 | return 1; 36 | } 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /src/sdl/endtxt.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | /// \file 12 | /// \brief Support to show ENDOOM text 13 | 14 | #ifndef __ENDTXT__ 15 | #define __ENDTXT__ 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | void ShowEndTxt (void); 22 | 23 | #ifdef __cplusplus 24 | } // extern "C" 25 | #endif 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /src/sdl/hwsym_sdl.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | /// \file 12 | /// \brief Tool for dynamic referencing of hardware rendering/3D sound functions 13 | 14 | #ifndef __SDL_HWSYM_SDL_H__ 15 | #define __SDL_HWSYM_SDL_H__ 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | void *hwSym(const char *funcName,void *handle); 22 | 23 | void *hwOpen(const char *hwfile); 24 | 25 | void hwClose(void *handle); 26 | 27 | #ifdef __cplusplus 28 | } // extern "C" 29 | #endif 30 | 31 | #endif // __SDL_HWSYM_SDL_H__ 32 | -------------------------------------------------------------------------------- /src/sdl/macosx/English.lproj/InfoPlist.strings: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/sdl/macosx/English.lproj/InfoPlist.strings -------------------------------------------------------------------------------- /src/sdl/macosx/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleExecutable 8 | ${EXECUTABLE_NAME} 9 | CFBundleIconFile 10 | Srb2mac.icns 11 | CFBundleIdentifier 12 | com.yourcompany.Srb2mac 13 | CFBundleInfoDictionaryVersion 14 | 6.0 15 | CFBundleName 16 | ${PRODUCT_NAME} 17 | CFBundlePackageType 18 | APPL 19 | CFBundleSignature 20 | ???? 21 | CFBundleVersion 22 | 2.2 23 | NSMainNibFile 24 | SDLMain 25 | NSPrincipalClass 26 | NSApplication 27 | 28 | 29 | -------------------------------------------------------------------------------- /src/sdl/macosx/Srb2mac.icns: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/sdl/macosx/Srb2mac.icns -------------------------------------------------------------------------------- /src/sdl/macosx/mac_alert.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // Copyright (C) 1996 by id Software, Inc. 7 | // 8 | // This program is free software distributed under the 9 | // terms of the GNU General Public License, version 2. 10 | // See the 'LICENSE' file for more details. 11 | //----------------------------------------------------------------------------- 12 | /// \file 13 | /// \brief Graphical Alerts for MacOSX 14 | /// 15 | /// Shows alerts, since we can't just print these to the screen when 16 | /// launched graphically on a mac. 17 | 18 | #ifdef __APPLE_CC__ 19 | 20 | extern int MacShowAlert(const char *title, const char *message, const char *button1, const char *button2, const char *button3); 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /src/sdl/macosx/mac_resources.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | 11 | #ifndef __MAC_RESOURCES_H__ 12 | #define __MAC_RESOURCES_H__ 13 | 14 | #ifdef __cplusplus 15 | extern "C" 16 | { 17 | #endif 18 | 19 | void OSX_GetResourcesPath(char * buffer); 20 | 21 | #ifdef __cplusplus 22 | } 23 | #endif 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /src/sdl/srb2.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/sdl/srb2.ttf -------------------------------------------------------------------------------- /src/sdl/srb2icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/sdl/srb2icon.png -------------------------------------------------------------------------------- /src/sdl12/Srb2SDL.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/sdl12/Srb2SDL.ico -------------------------------------------------------------------------------- /src/sdl12/macosx/Srb2mac.icns: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/sdl12/macosx/Srb2mac.icns -------------------------------------------------------------------------------- /src/stun.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by James Robert Roman 4 | // Copyright (C) 2025 by Kart Krew 5 | // 6 | // This program is free software distributed under the 7 | // terms of the GNU General Public License, version 2. 8 | // See the 'LICENSE' file for more details. 9 | //----------------------------------------------------------------------------- 10 | /// \file stun.h 11 | /// \brief RFC 5389 client implementation to fetch external IP address. 12 | 13 | #ifndef KART_STUN_H 14 | #define KART_STUN_H 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | typedef void (*stun_callback_t)(UINT32 address); 21 | 22 | void csprng (void * const buffer, const size_t size); 23 | 24 | void STUN_bind (stun_callback_t); 25 | boolean STUN_got_response (const char * const buffer, const size_t size); 26 | 27 | #ifdef __cplusplus 28 | } // extern "C" 29 | #endif 30 | 31 | #endif/*KART_STUN_H*/ 32 | -------------------------------------------------------------------------------- /src/version.h: -------------------------------------------------------------------------------- 1 | #define SRB2VERSION "2.4"/* this must be the first line, for cmake !! */ 2 | 3 | // The Modification Version, starting from 1. Do not follow your version string for this, 4 | // it's only for detection of the version the player is using so the MS can alert them of an update. 5 | // Only set it higher, not lower, obviously. 6 | // Note that we use this to help keep internal testing in check; this is why v2.0 is not version "2". 7 | #define MODVERSION 5 8 | 9 | // Define this as a prerelease version suffix 10 | // #define BETAVERSION "Alpha" 11 | -------------------------------------------------------------------------------- /src/win32/Srb2win.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/win32/Srb2win.ico -------------------------------------------------------------------------------- /src/win32/afxres.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | /// \file 12 | /// \brief needed if mfc not installed (if I remember well) 13 | -------------------------------------------------------------------------------- /src/win32/resource.h: -------------------------------------------------------------------------------- 1 | //{{NO_DEPENDENCIES}} 2 | // Microsoft Developer Studio generated include file. 3 | // Used by Srb2win.rc 4 | // 5 | #define IDI_DLICON1 101 6 | #define IDC_DLCURSOR1 103 7 | #define IDI_ICON1 106 8 | 9 | // Next default values for new objects 10 | // 11 | #ifdef APSTUDIO_INVOKED 12 | #ifndef APSTUDIO_READONLY_SYMBOLS 13 | #define _APS_NEXT_RESOURCE_VALUE 114 14 | #define _APS_NEXT_COMMAND_VALUE 40001 15 | #define _APS_NEXT_CONTROL_VALUE 1000 16 | #define _APS_NEXT_SYMED_VALUE 101 17 | #endif 18 | #endif 19 | -------------------------------------------------------------------------------- /src/win32/srb2win.exe.manifest: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /src/win32ce/Srb2win.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/src/win32ce/Srb2win.ico -------------------------------------------------------------------------------- /src/win32ce/win_dll.h: -------------------------------------------------------------------------------- 1 | // DR. ROBOTNIK'S RING RACERS 2 | //----------------------------------------------------------------------------- 3 | // Copyright (C) 2025 by Kart Krew. 4 | // Copyright (C) 2020 by Sonic Team Junior. 5 | // Copyright (C) 2000 by DooM Legacy Team. 6 | // 7 | // This program is free software distributed under the 8 | // terms of the GNU General Public License, version 2. 9 | // See the 'LICENSE' file for more details. 10 | //----------------------------------------------------------------------------- 11 | /// \file 12 | /// \brief load/unload a DLL at run-time 13 | 14 | //#define WIN32_LEAN_AND_MEAN 15 | #define RPC_NO_WINDOWS_H 16 | #include 17 | 18 | #ifdef HW3SOUND 19 | BOOL Init3DSDriver(LPCSTR dllName); 20 | VOID Shutdown3DSDriver(VOID); 21 | #endif 22 | -------------------------------------------------------------------------------- /thirdparty/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(glm) 2 | if(SRB2_CONFIG_ENABLE_DISCORDRPC) 3 | add_subdirectory(discord-rpc) 4 | endif() 5 | add_subdirectory(xmp-lite) 6 | add_subdirectory(imgui) 7 | 8 | add_subdirectory(nlohmann-json) 9 | 10 | add_subdirectory(tcbrindle_span) 11 | add_subdirectory(stb) 12 | add_subdirectory(glad) 13 | add_subdirectory(tracy) 14 | 15 | add_subdirectory(libwebm) 16 | 17 | add_subdirectory(fmt) 18 | -------------------------------------------------------------------------------- /thirdparty/discord-rpc/include/discord_register.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #if defined(DISCORD_DYNAMIC_LIB) 4 | #if defined(_WIN32) 5 | #if defined(DISCORD_BUILDING_SDK) 6 | #define DISCORD_EXPORT __declspec(dllexport) 7 | #else 8 | #define DISCORD_EXPORT __declspec(dllimport) 9 | #endif 10 | #else 11 | #define DISCORD_EXPORT __attribute__((visibility("default"))) 12 | #endif 13 | #else 14 | #define DISCORD_EXPORT 15 | #endif 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | DISCORD_EXPORT void Discord_Register(const char* applicationId, const char* command); 22 | DISCORD_EXPORT void Discord_RegisterSteamGame(const char* applicationId, const char* steamId); 23 | 24 | #ifdef __cplusplus 25 | } 26 | #endif 27 | -------------------------------------------------------------------------------- /thirdparty/discord-rpc/src/backoff.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | struct Backoff { 9 | int64_t minAmount; 10 | int64_t maxAmount; 11 | int64_t current; 12 | int fails; 13 | std::mt19937_64 randGenerator; 14 | std::uniform_real_distribution<> randDistribution; 15 | 16 | double rand01() { return randDistribution(randGenerator); } 17 | 18 | Backoff(int64_t min, int64_t max) 19 | : minAmount(min) 20 | , maxAmount(max) 21 | , current(min) 22 | , fails(0) 23 | , randGenerator((uint64_t)time(0)) 24 | { 25 | } 26 | 27 | void reset() 28 | { 29 | fails = 0; 30 | current = minAmount; 31 | } 32 | 33 | int64_t nextDelay() 34 | { 35 | ++fails; 36 | int64_t delay = (int64_t)((double)current * 2.0 * rand01()); 37 | current = std::min(current + delay, maxAmount); 38 | return current; 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /thirdparty/discord-rpc/src/connection.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // This is to wrap the platform specific kinds of connect/read/write. 4 | 5 | #include 6 | #include 7 | 8 | // not really connectiony, but need per-platform 9 | int GetProcessId(); 10 | 11 | struct BaseConnection { 12 | static BaseConnection* Create(); 13 | static void Destroy(BaseConnection*&); 14 | bool isOpen{false}; 15 | bool Open(); 16 | bool Close(); 17 | bool Write(const void* data, size_t length); 18 | bool Read(void* data, size_t length); 19 | }; 20 | -------------------------------------------------------------------------------- /thirdparty/discord-rpc/src/dllmain.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // outsmart GCC's missing-declarations warning 4 | BOOL WINAPI DllMain(HMODULE, DWORD, LPVOID); 5 | BOOL WINAPI DllMain(HMODULE, DWORD, LPVOID) 6 | { 7 | return TRUE; 8 | } 9 | -------------------------------------------------------------------------------- /thirdparty/discord-rpc/src/msg_queue.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | // A simple queue. No locks, but only works with a single thread as producer and a single thread as 6 | // a consumer. Mutex up as needed. 7 | 8 | template 9 | class MsgQueue { 10 | ElementType queue_[QueueSize]; 11 | std::atomic_uint nextAdd_{0}; 12 | std::atomic_uint nextSend_{0}; 13 | std::atomic_uint pendingSends_{0}; 14 | 15 | public: 16 | MsgQueue() {} 17 | 18 | ElementType* GetNextAddMessage() 19 | { 20 | // if we are falling behind, bail 21 | if (pendingSends_.load() >= QueueSize) { 22 | return nullptr; 23 | } 24 | auto index = (nextAdd_++) % QueueSize; 25 | return &queue_[index]; 26 | } 27 | void CommitAdd() { ++pendingSends_; } 28 | 29 | bool HavePendingSends() const { return pendingSends_.load() != 0; } 30 | ElementType* GetNextSendMessage() 31 | { 32 | auto index = (nextSend_++) % QueueSize; 33 | return &queue_[index]; 34 | } 35 | void CommitSend() { --pendingSends_; } 36 | }; 37 | -------------------------------------------------------------------------------- /thirdparty/fmt/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Update from https://github.com/fmtlib/fmt 2 | # fmt 11.1.3 3 | # License: MIT with object code exception 4 | 5 | add_library(fmt INTERFACE) 6 | target_include_directories(fmt INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include") 7 | target_compile_features(fmt INTERFACE cxx_std_11) 8 | target_compile_definitions(fmt INTERFACE -DFMT_HEADER_ONLY) 9 | add_library(fmt::fmt-header-only ALIAS fmt) 10 | -------------------------------------------------------------------------------- /thirdparty/fmt/include/fmt/core.h: -------------------------------------------------------------------------------- 1 | // This file is only provided for compatibility and may be removed in future 2 | // versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h 3 | // otherwise. 4 | 5 | #include "format.h" 6 | -------------------------------------------------------------------------------- /thirdparty/glad/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(glad STATIC src/gles2.c src/gl.c include/glad/gles2.h include/glad/gl.h include/KHR/khrplatform.h) 2 | add_library(glad::glad ALIAS glad) 3 | target_include_directories(glad PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include") 4 | -------------------------------------------------------------------------------- /thirdparty/glm/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Update from https://github.com/g-truc/glm/releases 2 | # glm 0.9.9.8 3 | # License: The Happy Bunny License or MIT License 4 | 5 | add_library(glm INTERFACE) 6 | target_include_directories(glm INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include") 7 | add_library(glm::glm ALIAS glm) 8 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/detail/_fixes.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //! Workaround for compatibility with other libraries 4 | #ifdef max 5 | #undef max 6 | #endif 7 | 8 | //! Workaround for compatibility with other libraries 9 | #ifdef min 10 | #undef min 11 | #endif 12 | 13 | //! Workaround for Android 14 | #ifdef isnan 15 | #undef isnan 16 | #endif 17 | 18 | //! Workaround for Android 19 | #ifdef isinf 20 | #undef isinf 21 | #endif 22 | 23 | //! Workaround for Chrone Native Client 24 | #ifdef log2 25 | #undef log2 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/detail/compute_vector_relational.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "compute_common.hpp" 4 | #include "setup.hpp" 5 | #include 6 | 7 | namespace glm{ 8 | namespace detail 9 | { 10 | template 11 | struct compute_equal 12 | { 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) 14 | { 15 | return a == b; 16 | } 17 | }; 18 | /* 19 | template 20 | struct compute_equal 21 | { 22 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) 23 | { 24 | return detail::compute_abs::is_signed>::call(b - a) <= static_cast(0); 25 | //return std::memcmp(&a, &b, sizeof(T)) == 0; 26 | } 27 | }; 28 | */ 29 | }//namespace detail 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/detail/func_exponential_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_exponential_simd.inl 3 | 4 | #include "../simd/exponential.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_sqrt<4, float, Q, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) 15 | { 16 | vec<4, float, Q> Result; 17 | Result.data = _mm_sqrt_ps(v.data); 18 | return Result; 19 | } 20 | }; 21 | 22 | # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE 23 | template<> 24 | struct compute_sqrt<4, float, aligned_lowp, true> 25 | { 26 | GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v) 27 | { 28 | vec<4, float, aligned_lowp> Result; 29 | Result.data = glm_vec4_sqrt_lowp(v.data); 30 | return Result; 31 | } 32 | }; 33 | # endif 34 | }//namespace detail 35 | }//namespace glm 36 | 37 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 38 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/thirdparty/glm/include/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/detail/type_half.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "setup.hpp" 4 | 5 | namespace glm{ 6 | namespace detail 7 | { 8 | typedef short hdata; 9 | 10 | GLM_FUNC_DECL float toFloat32(hdata value); 11 | GLM_FUNC_DECL hdata toFloat16(float const& value); 12 | 13 | }//namespace detail 14 | }//namespace glm 15 | 16 | #include "type_half.inl" 17 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_common.inl: -------------------------------------------------------------------------------- 1 | #include "../matrix.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, U a) 7 | { 8 | return mat(x) * (static_cast(1) - a) + mat(y) * a; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, mat const& a) 13 | { 14 | return matrixCompMult(mat(x), static_cast(1) - a) + matrixCompMult(mat(y), a); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 2, double, defaultp> dmat2x2; 16 | 17 | /// 2 columns of 2 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<2, 2, double, defaultp> dmat2; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 3, double, defaultp> dmat2x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 4, double, defaultp> dmat2x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 2, double, defaultp> dmat3x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 3, double, defaultp> dmat3x3; 16 | 17 | /// 3 columns of 3 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<3, 3, double, defaultp> dmat3; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 4, double, defaultp> dmat3x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 2, double, defaultp> dmat4x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 3, double, defaultp> dmat4x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_double4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 4, double, defaultp> dmat4x4; 16 | 17 | /// 4 columns of 4 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<4, 4, double, defaultp> dmat4; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 2, float, defaultp> mat2x2; 16 | 17 | /// 2 columns of 2 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<2, 2, float, defaultp> mat2; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 3, float, defaultp> mat2x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 4, float, defaultp> mat2x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 2, float, defaultp> mat3x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 3, float, defaultp> mat3x3; 16 | 17 | /// 3 columns of 3 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<3, 3, float, defaultp> mat3; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 4, float, defaultp> mat3x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 2, float, defaultp> mat4x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 3, float, defaultp> mat4x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_float4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @ingroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 4, float, defaultp> mat4x4; 16 | 17 | /// 4 columns of 4 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<4, 4, float, defaultp> mat4; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x2 2 | /// @file glm/ext/matrix_int2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x2 GLM_EXT_matrix_int2x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x2 25 | /// @{ 26 | 27 | /// Signed integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_int2x2 30 | typedef mat<2, 2, int, defaultp> imat2x2; 31 | 32 | /// Signed integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_int2x2 35 | typedef mat<2, 2, int, defaultp> imat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x3 2 | /// @file glm/ext/matrix_int2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_int2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x3 25 | /// @{ 26 | 27 | /// Signed integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_int2x3 30 | typedef mat<2, 3, int, defaultp> imat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x4 2 | /// @file glm/ext/matrix_int2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x4 25 | /// @{ 26 | 27 | /// Signed integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_int2x4 30 | typedef mat<2, 4, int, defaultp> imat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x2 2 | /// @file glm/ext/matrix_int3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_int3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x2 25 | /// @{ 26 | 27 | /// Signed integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_int3x2 30 | typedef mat<3, 2, int, defaultp> imat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x3 2 | /// @file glm/ext/matrix_int3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x3 GLM_EXT_matrix_int3x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x3 25 | /// @{ 26 | 27 | /// Signed integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_int3x3 30 | typedef mat<3, 3, int, defaultp> imat3x3; 31 | 32 | /// Signed integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_int3x3 35 | typedef mat<3, 3, int, defaultp> imat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x4 2 | /// @file glm/ext/matrix_int3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x4 GLM_EXT_matrix_int3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_int3x4 30 | typedef mat<3, 4, int, defaultp> imat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x2 2 | /// @file glm/ext/matrix_int4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x2 GLM_EXT_matrix_int4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x2 25 | /// @{ 26 | 27 | /// Signed integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_int4x2 30 | typedef mat<4, 2, int, defaultp> imat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x3 2 | /// @file glm/ext/matrix_int4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x3 GLM_EXT_matrix_int4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x3 25 | /// @{ 26 | 27 | /// Signed integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_int4x3 30 | typedef mat<4, 3, int, defaultp> imat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_int4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x4 2 | /// @file glm/ext/matrix_int4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x4 GLM_EXT_matrix_int4x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x4 25 | /// @{ 26 | 27 | /// Signed integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_int4x4 30 | typedef mat<4, 4, int, defaultp> imat4x4; 31 | 32 | /// Signed integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_int4x4 35 | typedef mat<4, 4, int, defaultp> imat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x2 2 | /// @file glm/ext/matrix_uint2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x2 GLM_EXT_matrix_uint2x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x2 25 | /// @{ 26 | 27 | /// Unsigned integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x2 30 | typedef mat<2, 2, uint, defaultp> umat2x2; 31 | 32 | /// Unsigned integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_uint2x2 35 | typedef mat<2, 2, uint, defaultp> umat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x3 2 | /// @file glm/ext/matrix_uint2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_uint2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x3 25 | /// @{ 26 | 27 | /// Unsigned integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x3 30 | typedef mat<2, 3, uint, defaultp> umat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x4 2 | /// @file glm/ext/matrix_uint2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x4 25 | /// @{ 26 | 27 | /// Unsigned integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x4 30 | typedef mat<2, 4, uint, defaultp> umat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x2 2 | /// @file glm/ext/matrix_uint3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_uint3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x2 25 | /// @{ 26 | 27 | /// Unsigned integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x2 30 | typedef mat<3, 2, uint, defaultp> umat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x3 2 | /// @file glm/ext/matrix_uint3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x3 GLM_EXT_matrix_uint3x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x3 25 | /// @{ 26 | 27 | /// Unsigned integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x3 30 | typedef mat<3, 3, uint, defaultp> umat3x3; 31 | 32 | /// Unsigned integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_uint3x3 35 | typedef mat<3, 3, uint, defaultp> umat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x4 2 | /// @file glm/ext/matrix_uint3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x4 GLM_EXT_matrix_uint3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x4 30 | typedef mat<3, 4, uint, defaultp> umat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x2 2 | /// @file glm/ext/matrix_uint4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x2 GLM_EXT_matrix_uint4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x2 25 | /// @{ 26 | 27 | /// Unsigned integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x2 30 | typedef mat<4, 2, uint, defaultp> umat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x3 2 | /// @file glm/ext/matrix_uint4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x3 GLM_EXT_matrix_uint4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x3 25 | /// @{ 26 | 27 | /// Unsigned integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x3 30 | typedef mat<4, 3, uint, defaultp> umat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/matrix_uint4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x4 2 | /// @file glm/ext/matrix_uint4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x4 GLM_EXT_matrix_uint4x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x4 25 | /// @{ 26 | 27 | /// Unsigned integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x4 30 | typedef mat<4, 4, uint, defaultp> umat4x4; 31 | 32 | /// Unsigned integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_uint4x4 35 | typedef mat<4, 4, uint, defaultp> umat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/quaternion_common_simd.inl: -------------------------------------------------------------------------------- 1 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 2 | 3 | namespace glm{ 4 | namespace detail 5 | { 6 | template 7 | struct compute_dot, float, true> 8 | { 9 | static GLM_FUNC_QUALIFIER float call(qua const& x, qua const& y) 10 | { 11 | return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); 12 | } 13 | }; 14 | }//namespace detail 15 | }//namespace glm 16 | 17 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 18 | 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/quaternion_transform.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER qua rotate(qua const& q, T const& angle, vec<3, T, Q> const& v) 5 | { 6 | vec<3, T, Q> Tmp = v; 7 | 8 | // Axis of rotation must be normalised 9 | T len = glm::length(Tmp); 10 | if(abs(len - static_cast(1)) > static_cast(0.001)) 11 | { 12 | T oneOverLen = static_cast(1) / len; 13 | Tmp.x *= oneOverLen; 14 | Tmp.y *= oneOverLen; 15 | Tmp.z *= oneOverLen; 16 | } 17 | 18 | T const AngleRad(angle); 19 | T const Sin = sin(AngleRad * static_cast(0.5)); 20 | 21 | return q * qua(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); 22 | } 23 | }//namespace glm 24 | 25 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/quaternion_trigonometric.inl: -------------------------------------------------------------------------------- 1 | #include "scalar_constants.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T angle(qua const& x) 7 | { 8 | if (abs(x.w) > cos_one_over_two()) 9 | { 10 | return asin(sqrt(x.x * x.x + x.y * x.y + x.z * x.z)) * static_cast(2); 11 | } 12 | 13 | return acos(x.w) * static_cast(2); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER vec<3, T, Q> axis(qua const& x) 18 | { 19 | T const tmp1 = static_cast(1) - x.w * x.w; 20 | if(tmp1 <= static_cast(0)) 21 | return vec<3, T, Q>(0, 0, 1); 22 | T const tmp2 = static_cast(1) / sqrt(tmp1); 23 | return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2); 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER qua angleAxis(T const& angle, vec<3, T, Q> const& v) 28 | { 29 | T const a(angle); 30 | T const s = glm::sin(a * static_cast(0.5)); 31 | 32 | return qua(glm::cos(a * static_cast(0.5)), v * s); 33 | } 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/scalar_constants.inl: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() 7 | { 8 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'epsilon' only accepts floating-point inputs"); 9 | return std::numeric_limits::epsilon(); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() 14 | { 15 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'pi' only accepts floating-point inputs"); 16 | return static_cast(3.14159265358979323846264338327950288); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType cos_one_over_two() 21 | { 22 | return genType(0.877582561890372716130286068203503191); 23 | } 24 | } //namespace glm 25 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/scalar_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_packing 2 | /// @file glm/ext/scalar_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_scalar_packing GLM_EXT_scalar_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert scalar values to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_scalar_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_scalar_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "scalar_packing.inl" 33 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/scalar_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/thirdparty/glm/include/glm/ext/scalar_packing.inl -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_bool1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_bool1 2 | /// @file glm/ext/vector_bool1.hpp 3 | /// 4 | /// @defgroup ext_vector_bool1 GLM_EXT_vector_bool1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes bvec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_bool1_precision extension. 12 | 13 | #pragma once 14 | 15 | #include "../detail/type_vec1.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_EXT_vector_bool1 extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup ext_vector_bool1 24 | /// @{ 25 | 26 | /// 1 components vector of boolean. 27 | typedef vec<1, bool, defaultp> bvec1; 28 | 29 | /// @} 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_bool1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_bool1_precision 2 | /// @file glm/ext/vector_bool1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_bool1_precision GLM_EXT_vector_bool1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_bvec1, mediump_bvec1 and lowp_bvec1 types. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | #include "../detail/type_vec1.hpp" 14 | 15 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 16 | # pragma message("GLM: GLM_EXT_vector_bool1_precision extension included") 17 | #endif 18 | 19 | namespace glm 20 | { 21 | /// @addtogroup ext_vector_bool1_precision 22 | /// @{ 23 | 24 | /// 1 component vector of bool values. 25 | typedef vec<1, bool, highp> highp_bvec1; 26 | 27 | /// 1 component vector of bool values. 28 | typedef vec<1, bool, mediump> mediump_bvec1; 29 | 30 | /// 1 component vector of bool values. 31 | typedef vec<1, bool, lowp> lowp_bvec1; 32 | 33 | /// @} 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_bool2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, bool, defaultp> bvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_bool3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, bool, defaultp> bvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_bool4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, bool, defaultp> bvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_double1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_double1 2 | /// @file glm/ext/vector_double1.hpp 3 | /// 4 | /// @defgroup ext_vector_double1 GLM_EXT_vector_double1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes double-precision floating point vector type with one component. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_double1_precision extension. 12 | /// @see ext_vector_float1 extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_double1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_double1 25 | /// @{ 26 | 27 | /// 1 components vector of double-precision floating-point numbers. 28 | typedef vec<1, double, defaultp> dvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_double2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, double, defaultp> dvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_double3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, double, defaultp> dvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_double4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, double, defaultp> dvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_float1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_float1 2 | /// @file glm/ext/vector_float1.hpp 3 | /// 4 | /// @defgroup ext_vector_float1 GLM_EXT_vector_float1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes single-precision floating point vector type with one component. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_float1_precision extension. 12 | /// @see ext_vector_double1 extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_float1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_float1 25 | /// @{ 26 | 27 | /// 1 components vector of single-precision floating-point numbers. 28 | typedef vec<1, float, defaultp> vec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_float2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, float, defaultp> vec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_float3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, float, defaultp> vec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_float4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, float, defaultp> vec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_int1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int1 2 | /// @file glm/ext/vector_int1.hpp 3 | /// 4 | /// @defgroup ext_vector_int1 GLM_EXT_vector_int1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes ivec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_uint1 extension. 12 | /// @see ext_vector_int1_precision extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_int1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_int1 25 | /// @{ 26 | 27 | /// 1 component vector of signed integer numbers. 28 | typedef vec<1, int, defaultp> ivec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_int2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, int, defaultp> ivec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_int3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, int, defaultp> ivec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_int4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, int, defaultp> ivec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_packing 2 | /// @file glm/ext/vector_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_vector_packing GLM_EXT_vector_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert vectors to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "vector_packing.inl" 33 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/thirdparty/glm/include/glm/ext/vector_packing.inl -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_uint1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint1 2 | /// @file glm/ext/vector_uint1.hpp 3 | /// 4 | /// @defgroup ext_vector_uint1 GLM_EXT_vector_uint1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes uvec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_int1 extension. 12 | /// @see ext_vector_uint1_precision extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_uint1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_uint1 25 | /// @{ 26 | 27 | /// 1 component vector of unsigned integer numbers. 28 | typedef vec<1, unsigned int, defaultp> uvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_uint2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, unsigned int, defaultp> uvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_uint3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, unsigned int, defaultp> uvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/ext/vector_uint4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, unsigned int, defaultp> uvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/thirdparty/glm/include/glm/gtc/quaternion_simd.inl -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtc/vec1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_vec1 2 | /// @file glm/gtc/vec1.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_vec1 GLM_GTC_vec1 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Add vec1, ivec1, uvec1 and bvec1 types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../ext/vector_bool1.hpp" 17 | #include "../ext/vector_bool1_precision.hpp" 18 | #include "../ext/vector_float1.hpp" 19 | #include "../ext/vector_float1_precision.hpp" 20 | #include "../ext/vector_double1.hpp" 21 | #include "../ext/vector_double1_precision.hpp" 22 | #include "../ext/vector_int1.hpp" 23 | #include "../ext/vector_int1_sized.hpp" 24 | #include "../ext/vector_uint1.hpp" 25 | #include "../ext/vector_uint1_sized.hpp" 26 | 27 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTC_vec1 extension included") 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/exterior_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_exterior_product 2 | 3 | #include 4 | 5 | namespace glm { 6 | namespace detail 7 | { 8 | template 9 | struct compute_cross_vec2 10 | { 11 | GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) 12 | { 13 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); 14 | 15 | return v.x * u.y - u.x * v.y; 16 | } 17 | }; 18 | }//namespace detail 19 | 20 | template 21 | GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 22 | { 23 | return detail::compute_cross_vec2::value>::call(x, y); 24 | } 25 | }//namespace glm 26 | 27 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/float_notmalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_float_normalize 2 | 3 | #include 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER vec floatNormalize(vec const& v) 9 | { 10 | return vec(v) / static_cast(std::numeric_limits::max()); 11 | } 12 | 13 | }//namespace glm 14 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/functions.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | 3 | #include "../exponential.hpp" 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER T gauss 9 | ( 10 | T x, 11 | T ExpectedValue, 12 | T StandardDeviation 13 | ) 14 | { 15 | return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER T gauss 20 | ( 21 | vec<2, T, Q> const& Coord, 22 | vec<2, T, Q> const& ExpectedValue, 23 | vec<2, T, Q> const& StandardDeviation 24 | ) 25 | { 26 | vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); 27 | return exp(-(Squared.x + Squared.y)); 28 | } 29 | }//namespace glm 30 | 31 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/gradient_paint.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T radialGradient 7 | ( 8 | vec<2, T, Q> const& Center, 9 | T const& Radius, 10 | vec<2, T, Q> const& Focal, 11 | vec<2, T, Q> const& Position 12 | ) 13 | { 14 | vec<2, T, Q> F = Focal - Center; 15 | vec<2, T, Q> D = Position - Focal; 16 | T Radius2 = pow2(Radius); 17 | T Fx2 = pow2(F.x); 18 | T Fy2 = pow2(F.y); 19 | 20 | T Numerator = (D.x * F.x + D.y * F.y) + sqrt(Radius2 * (pow2(D.x) + pow2(D.y)) - pow2(D.x * F.y - D.y * F.x)); 21 | T Denominator = Radius2 - (Fx2 + Fy2); 22 | return Numerator / Denominator; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER T linearGradient 27 | ( 28 | vec<2, T, Q> const& Point0, 29 | vec<2, T, Q> const& Point1, 30 | vec<2, T, Q> const& Position 31 | ) 32 | { 33 | vec<2, T, Q> Dist = Point1 - Point0; 34 | return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); 35 | } 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/handed_coordinate_space.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER bool rightHanded 7 | ( 8 | vec<3, T, Q> const& tangent, 9 | vec<3, T, Q> const& binormal, 10 | vec<3, T, Q> const& normal 11 | ) 12 | { 13 | return dot(cross(normal, tangent), binormal) > T(0); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER bool leftHanded 18 | ( 19 | vec<3, T, Q> const& tangent, 20 | vec<3, T, Q> const& binormal, 21 | vec<3, T, Q> const& normal 22 | ) 23 | { 24 | return dot(cross(normal, tangent), binormal) < T(0); 25 | } 26 | }//namespace glm 27 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/log_base.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) 7 | { 8 | return glm::log(x) / glm::log(base); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) 13 | { 14 | return glm::log(x) / glm::log(base); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/matrix_cross_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3 7 | ( 8 | vec<3, T, Q> const& x 9 | ) 10 | { 11 | mat<3, 3, T, Q> Result(T(0)); 12 | Result[0][1] = x.z; 13 | Result[1][0] = -x.z; 14 | Result[0][2] = -x.y; 15 | Result[2][0] = x.y; 16 | Result[1][2] = x.x; 17 | Result[2][1] = -x.x; 18 | return Result; 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4 23 | ( 24 | vec<3, T, Q> const& x 25 | ) 26 | { 27 | mat<4, 4, T, Q> Result(T(0)); 28 | Result[0][1] = x.z; 29 | Result[1][0] = -x.z; 30 | Result[0][2] = -x.y; 31 | Result[2][0] = x.y; 32 | Result[1][2] = x.x; 33 | Result[2][1] = -x.x; 34 | return Result; 35 | } 36 | 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KartKrewDev/RingRacers/294e60bf8d3807643d47964fcfacb081da2a4998/thirdparty/glm/include/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/mixed_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T mixedProduct 7 | ( 8 | vec<3, T, Q> const& v1, 9 | vec<3, T, Q> const& v2, 10 | vec<3, T, Q> const& v3 11 | ) 12 | { 13 | return dot(cross(v1, v2), v3); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/normal.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal 7 | ( 8 | vec<3, T, Q> const& p1, 9 | vec<3, T, Q> const& p2, 10 | vec<3, T, Q> const& p3 11 | ) 12 | { 13 | return normalize(cross(p1 - p2, p1 - p3)); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/normalize_dot.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) 7 | { 8 | return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) 13 | { 14 | return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/optimum_pow.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType pow2(genType const& x) 7 | { 8 | return x * x; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER genType pow3(genType const& x) 13 | { 14 | return x * x * x; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER genType pow4(genType const& x) 19 | { 20 | return (x * x) * (x * x); 21 | } 22 | }//namespace glm 23 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/orthonormalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m) 7 | { 8 | mat<3, 3, T, Q> r = m; 9 | 10 | r[0] = normalize(r[0]); 11 | 12 | T d0 = dot(r[0], r[1]); 13 | r[1] -= r[0] * d0; 14 | r[1] = normalize(r[1]); 15 | 16 | T d1 = dot(r[1], r[2]); 17 | d0 = dot(r[0], r[2]); 18 | r[2] -= r[0] * d0 + r[1] * d1; 19 | r[2] = normalize(r[2]); 20 | 21 | return r; 22 | } 23 | 24 | template 25 | GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y) 26 | { 27 | return normalize(x - y * dot(y, x)); 28 | } 29 | }//namespace glm 30 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/perpendicular.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) 7 | { 8 | return x - proj(x, Normal); 9 | } 10 | }//namespace glm 11 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/polar_coordinates.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> polar 7 | ( 8 | vec<3, T, Q> const& euclidean 9 | ) 10 | { 11 | T const Length(length(euclidean)); 12 | vec<3, T, Q> const tmp(euclidean / Length); 13 | T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); 14 | 15 | return vec<3, T, Q>( 16 | asin(tmp.y), // latitude 17 | atan(tmp.x, tmp.z), // longitude 18 | xz_dist); // xz distance 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean 23 | ( 24 | vec<2, T, Q> const& polar 25 | ) 26 | { 27 | T const latitude(polar.x); 28 | T const longitude(polar.y); 29 | 30 | return vec<3, T, Q>( 31 | cos(latitude) * sin(longitude), 32 | sin(latitude), 33 | cos(latitude) * cos(longitude)); 34 | } 35 | 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/projection.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) 7 | { 8 | return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; 9 | } 10 | }//namespace glm 11 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/scalar_relational.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_extend extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/texture.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | 3 | namespace glm 4 | { 5 | template 6 | inline T levels(vec const& Extent) 7 | { 8 | return glm::log2(compMax(Extent)) + static_cast(1); 9 | } 10 | 11 | template 12 | inline T levels(T Extent) 13 | { 14 | return vec<1, T, defaultp>(Extent).x; 15 | } 16 | }//namespace glm 17 | 18 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/transform.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v) 7 | { 8 | return translate(mat<4, 4, T, Q>(static_cast(1)), v); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) 13 | { 14 | return rotate(mat<4, 4, T, Q>(static_cast(1)), angle, v); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v) 19 | { 20 | return scale(mat<4, 4, T, Q>(static_cast(1)), v); 21 | } 22 | 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/wrap.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | /// @file glm/gtx/wrap.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_wrap GLM_GTX_wrap 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../ext/scalar_common.hpp" 18 | #include "../ext/vector_common.hpp" 19 | #include "../gtc/vec1.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # ifndef GLM_ENABLE_EXPERIMENTAL 23 | # pragma message("GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 24 | # else 25 | # pragma message("GLM: GLM_GTX_wrap extension included") 26 | # endif 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_wrap 32 | /// @{ 33 | 34 | /// @} 35 | }// namespace glm 36 | 37 | #include "wrap.inl" 38 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x2.hpp" 6 | #include "./ext/matrix_double2x2_precision.hpp" 7 | #include "./ext/matrix_float2x2.hpp" 8 | #include "./ext/matrix_float2x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x3.hpp" 6 | #include "./ext/matrix_double2x3_precision.hpp" 7 | #include "./ext/matrix_float2x3.hpp" 8 | #include "./ext/matrix_float2x3_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x4.hpp" 6 | #include "./ext/matrix_double2x4_precision.hpp" 7 | #include "./ext/matrix_float2x4.hpp" 8 | #include "./ext/matrix_float2x4_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x2.hpp" 6 | #include "./ext/matrix_double3x2_precision.hpp" 7 | #include "./ext/matrix_float3x2.hpp" 8 | #include "./ext/matrix_float3x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x3.hpp" 6 | #include "./ext/matrix_double3x3_precision.hpp" 7 | #include "./ext/matrix_float3x3.hpp" 8 | #include "./ext/matrix_float3x3_precision.hpp" 9 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x4.hpp" 6 | #include "./ext/matrix_double3x4_precision.hpp" 7 | #include "./ext/matrix_float3x4.hpp" 8 | #include "./ext/matrix_float3x4_precision.hpp" 9 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x2.hpp" 6 | #include "./ext/matrix_double4x2_precision.hpp" 7 | #include "./ext/matrix_float4x2.hpp" 8 | #include "./ext/matrix_float4x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x3.hpp" 6 | #include "./ext/matrix_double4x3_precision.hpp" 7 | #include "./ext/matrix_float4x3.hpp" 8 | #include "./ext/matrix_float4x3_precision.hpp" 9 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/mat4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x4.hpp" 6 | #include "./ext/matrix_double4x4_precision.hpp" 7 | #include "./ext/matrix_float4x4.hpp" 8 | #include "./ext/matrix_float4x4_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/simd/exponential.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/experimental.h 3 | 4 | #pragma once 5 | 6 | #include "platform.h" 7 | 8 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sqrt_lowp(glm_f32vec4 x) 11 | { 12 | return _mm_mul_ss(_mm_rsqrt_ss(x), x); 13 | } 14 | 15 | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sqrt_lowp(glm_f32vec4 x) 16 | { 17 | return _mm_mul_ps(_mm_rsqrt_ps(x), x); 18 | } 19 | 20 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 21 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/simd/packing.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/packing.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/simd/trigonometric.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/trigonometric.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/simd/vector_relational.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/vector_relational.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/vec2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec2.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool2.hpp" 6 | #include "./ext/vector_bool2_precision.hpp" 7 | #include "./ext/vector_float2.hpp" 8 | #include "./ext/vector_float2_precision.hpp" 9 | #include "./ext/vector_double2.hpp" 10 | #include "./ext/vector_double2_precision.hpp" 11 | #include "./ext/vector_int2.hpp" 12 | #include "./ext/vector_int2_sized.hpp" 13 | #include "./ext/vector_uint2.hpp" 14 | #include "./ext/vector_uint2_sized.hpp" 15 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/vec3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec3.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool3.hpp" 6 | #include "./ext/vector_bool3_precision.hpp" 7 | #include "./ext/vector_float3.hpp" 8 | #include "./ext/vector_float3_precision.hpp" 9 | #include "./ext/vector_double3.hpp" 10 | #include "./ext/vector_double3_precision.hpp" 11 | #include "./ext/vector_int3.hpp" 12 | #include "./ext/vector_int3_sized.hpp" 13 | #include "./ext/vector_uint3.hpp" 14 | #include "./ext/vector_uint3_sized.hpp" 15 | -------------------------------------------------------------------------------- /thirdparty/glm/include/glm/vec4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec4.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool4.hpp" 6 | #include "./ext/vector_bool4_precision.hpp" 7 | #include "./ext/vector_float4.hpp" 8 | #include "./ext/vector_float4_precision.hpp" 9 | #include "./ext/vector_double4.hpp" 10 | #include "./ext/vector_double4_precision.hpp" 11 | #include "./ext/vector_int4.hpp" 12 | #include "./ext/vector_int4_sized.hpp" 13 | #include "./ext/vector_uint4.hpp" 14 | #include "./ext/vector_uint4_sized.hpp" 15 | 16 | -------------------------------------------------------------------------------- /thirdparty/libwebm/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Update from https://github.com/webmproject/libwebm 2 | # libwebm version 1.0.0.31 3 | # License: BSD-3 4 | 5 | add_library(libwebm_mkvmuxer STATIC 6 | common/webmids.h 7 | 8 | common/file_util.cc 9 | common/file_util.h 10 | common/hdr_util.cc 11 | common/hdr_util.h 12 | 13 | mkvmuxer/mkvmuxer.h 14 | mkvmuxer/mkvmuxertypes.h 15 | mkvmuxer/mkvmuxerutil.h 16 | mkvmuxer/mkvwriter.h 17 | mkvmuxer/mkvmuxer.cc 18 | mkvmuxer/mkvmuxerutil.cc 19 | mkvmuxer/mkvwriter.cc 20 | ) 21 | target_include_directories(libwebm_mkvmuxer PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}") 22 | target_compile_features(libwebm_mkvmuxer PUBLIC cxx_std_11) 23 | target_compile_definitions(libwebm_mkvmuxer PRIVATE 24 | -D__STDC_CONSTANT_MACROS 25 | -D__STDC_FORMAT_MACROS 26 | -D__STDC_LIMIT_MACROS 27 | 28 | ) 29 | set_target_properties(libwebm_mkvmuxer PROPERTIES CXX_STANDARD 11) 30 | add_library(webm::libwebm_mkvmuxer ALIAS libwebm_mkvmuxer) 31 | -------------------------------------------------------------------------------- /thirdparty/libwebm/common/indent.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2012 The WebM project authors. All Rights Reserved. 3 | * 4 | * Use of this source code is governed by a BSD-style license 5 | * that can be found in the LICENSE file in the root of the source 6 | * tree. An additional intellectual property rights grant can be found 7 | * in the file PATENTS. All contributing project authors may 8 | * be found in the AUTHORS file in the root of the source tree. 9 | */ 10 | 11 | #include "common/indent.h" 12 | 13 | #include 14 | 15 | namespace libwebm { 16 | 17 | Indent::Indent(int indent) : indent_(indent), indent_str_() { Update(); } 18 | 19 | void Indent::Adjust(int indent) { 20 | indent_ += indent; 21 | if (indent_ < 0) 22 | indent_ = 0; 23 | 24 | Update(); 25 | } 26 | 27 | void Indent::Update() { indent_str_ = std::string(indent_, ' '); } 28 | 29 | } // namespace libwebm 30 | -------------------------------------------------------------------------------- /thirdparty/libwebm/common/webm_constants.h: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2012 The WebM project authors. All Rights Reserved. 2 | // 3 | // Use of this source code is governed by a BSD-style license 4 | // that can be found in the LICENSE file in the root of the source 5 | // tree. An additional intellectual property rights grant can be found 6 | // in the file PATENTS. All contributing project authors may 7 | // be found in the AUTHORS file in the root of the source tree. 8 | 9 | #ifndef LIBWEBM_COMMON_WEBM_CONSTANTS_H_ 10 | #define LIBWEBM_COMMON_WEBM_CONSTANTS_H_ 11 | 12 | namespace libwebm { 13 | 14 | const double kNanosecondsPerSecond = 1000000000.0; 15 | const int kNanosecondsPerSecondi = 1000000000; 16 | const int kNanosecondsPerMillisecond = 1000000; 17 | 18 | } // namespace libwebm 19 | 20 | #endif // LIBWEBM_COMMON_WEBM_CONSTANTS_H_ 21 | -------------------------------------------------------------------------------- /thirdparty/nlohmann-json/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Update from https://github.com/nlohmann/json/releases 2 | add_library(nlohmann_json INTERFACE) 3 | target_include_directories(nlohmann_json INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include") 4 | add_library(nlohmann_json::nlohmann_json ALIAS nlohmann_json) 5 | -------------------------------------------------------------------------------- /thirdparty/stb/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Update from https://github.com/nothings/stb 2 | add_library(Stb STATIC) 3 | target_sources(Stb PRIVATE stb_rect_pack.c stb_vorbis.c) 4 | target_sources(Stb PUBLIC include/stb_rect_pack.h include/stb_vorbis.h) 5 | target_include_directories(Stb PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include") 6 | add_library(Stb::Stb ALIAS Stb) 7 | -------------------------------------------------------------------------------- /thirdparty/stb/include/stb_vorbis.h: -------------------------------------------------------------------------------- 1 | #define STB_VORBIS_HEADER_ONLY 2 | #include "../stb_vorbis.c" 3 | -------------------------------------------------------------------------------- /thirdparty/stb/stb_rect_pack.c: -------------------------------------------------------------------------------- 1 | #define STB_RECT_PACK_IMPLEMENTATION 2 | #include "include/stb_rect_pack.h" 3 | -------------------------------------------------------------------------------- /thirdparty/tcbrindle_span/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # https://github.com/tcbrindle/span/ 2 | # Portable implementation of C++20 std::span 3 | # Boost License 1.0 4 | 5 | cmake_minimum_required(VERSION 3.14 FATAL_ERROR) 6 | 7 | add_library(tcbrindle_span INTERFACE) 8 | target_sources(tcbrindle_span INTERFACE include/tcb/span.hpp) 9 | target_include_directories(tcbrindle_span INTERFACE include) 10 | 11 | add_library(tcbrindle::span ALIAS tcbrindle_span) 12 | -------------------------------------------------------------------------------- /thirdparty/tracy/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Tracy Profiler Client 0.10.0 2 | # BSD 3-clause 3 | # Copyright (c) 2017-2023, Bartosz Taudul 4 | 5 | # includes libbacktrace 6 | # BSD 3-clause 7 | # Copyright (c) 2012-2016 Free Software Foundation, Inc. 8 | 9 | cmake_minimum_required(VERSION 3.14 FATAL_ERROR) 10 | 11 | 12 | add_library(TracyClient STATIC "${CMAKE_CURRENT_SOURCE_DIR}/include/tracy/TracyClient.cpp") 13 | target_compile_features(TracyClient PUBLIC cxx_std_11) 14 | target_include_directories(TracyClient PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include") 15 | 16 | if(WIN32 AND ${CMAKE_CXX_COMPILER_ID} MATCHES "GNU") 17 | target_link_libraries(TracyClient PUBLIC ws2_32 dbghelp) 18 | endif() 19 | 20 | if(SRB2_CONFIG_TRACY) 21 | target_compile_definitions(TracyClient PUBLIC TRACY_ENABLE) 22 | endif() 23 | target_compile_definitions(TracyClient PUBLIC -DTRACY_ON_DEMAND -DTRACY_DELAYED_INIT) 24 | 25 | add_library(Tracy::TracyClient ALIAS TracyClient) 26 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracyCallstack.h: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYCALLSTACK_H__ 2 | #define __TRACYCALLSTACK_H__ 3 | 4 | #ifndef TRACY_NO_CALLSTACK 5 | 6 | # if !defined _WIN32 7 | # include 8 | # endif 9 | 10 | # if defined _WIN32 11 | # include "../common/TracyUwp.hpp" 12 | # ifndef TRACY_UWP 13 | # define TRACY_HAS_CALLSTACK 1 14 | # endif 15 | # elif defined __ANDROID__ 16 | # if !defined __arm__ || __ANDROID_API__ >= 21 17 | # define TRACY_HAS_CALLSTACK 2 18 | # else 19 | # define TRACY_HAS_CALLSTACK 5 20 | # endif 21 | # elif defined __linux 22 | # if defined _GNU_SOURCE && defined __GLIBC__ 23 | # define TRACY_HAS_CALLSTACK 3 24 | # else 25 | # define TRACY_HAS_CALLSTACK 2 26 | # endif 27 | # elif defined __APPLE__ 28 | # define TRACY_HAS_CALLSTACK 4 29 | # elif defined BSD 30 | # define TRACY_HAS_CALLSTACK 6 31 | # endif 32 | 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracyCpuid.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYCPUID_HPP__ 2 | #define __TRACYCPUID_HPP__ 3 | 4 | // Prior to GCC 11 the cpuid.h header did not have any include guards and thus 5 | // including it more than once would cause a compiler error due to symbol 6 | // redefinitions. In order to support older GCC versions, we have to wrap this 7 | // include between custom include guards to prevent this issue. 8 | // See also https://github.com/wolfpld/tracy/issues/452 9 | 10 | #include 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracyDebug.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYPRINT_HPP__ 2 | #define __TRACYPRINT_HPP__ 3 | 4 | #ifdef TRACY_VERBOSE 5 | # include 6 | # define TracyDebug(...) fprintf( stderr, __VA_ARGS__ ); 7 | #else 8 | # define TracyDebug(...) 9 | #endif 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracyDxt1.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYDXT1_HPP__ 2 | #define __TRACYDXT1_HPP__ 3 | 4 | namespace tracy 5 | { 6 | 7 | void CompressImageDxt1( const char* src, char* dst, int w, int h ); 8 | 9 | } 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracyOverride.cpp: -------------------------------------------------------------------------------- 1 | #ifdef TRACY_ENABLE 2 | # ifdef __linux__ 3 | # include "TracyDebug.hpp" 4 | # ifdef TRACY_VERBOSE 5 | # include 6 | # include 7 | # endif 8 | 9 | extern "C" int dlclose( void* hnd ) 10 | { 11 | #ifdef TRACY_VERBOSE 12 | struct link_map* lm; 13 | if( dlinfo( hnd, RTLD_DI_LINKMAP, &lm ) == 0 ) 14 | { 15 | TracyDebug( "Overriding dlclose for %s\n", lm->l_name ); 16 | } 17 | else 18 | { 19 | TracyDebug( "Overriding dlclose for unknown object (%s)\n", dlerror() ); 20 | } 21 | #endif 22 | return 0; 23 | } 24 | 25 | # endif 26 | #endif 27 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracyStringHelpers.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYSTRINGHELPERS_HPP__ 2 | #define __TRACYSTRINGHELPERS_HPP__ 3 | 4 | #include 5 | #include 6 | 7 | #include "../common/TracyAlloc.hpp" 8 | #include "../common/TracyForceInline.hpp" 9 | 10 | namespace tracy 11 | { 12 | 13 | static tracy_force_inline char* CopyString( const char* src, size_t sz ) 14 | { 15 | auto dst = (char*)tracy_malloc( sz + 1 ); 16 | memcpy( dst, src, sz ); 17 | dst[sz] = '\0'; 18 | return dst; 19 | } 20 | 21 | static tracy_force_inline char* CopyString( const char* src ) 22 | { 23 | return CopyString( src, strlen( src ) ); 24 | } 25 | 26 | static tracy_force_inline char* CopyStringFast( const char* src, size_t sz ) 27 | { 28 | auto dst = (char*)tracy_malloc_fast( sz + 1 ); 29 | memcpy( dst, src, sz ); 30 | dst[sz] = '\0'; 31 | return dst; 32 | } 33 | 34 | static tracy_force_inline char* CopyStringFast( const char* src ) 35 | { 36 | return CopyStringFast( src, strlen( src ) ); 37 | } 38 | 39 | } 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracySysPower.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYSYSPOWER_HPP__ 2 | #define __TRACYSYSPOWER_HPP__ 3 | 4 | #if defined __linux__ 5 | # define TRACY_HAS_SYSPOWER 6 | #endif 7 | 8 | #ifdef TRACY_HAS_SYSPOWER 9 | 10 | #include 11 | #include 12 | 13 | #include "TracyFastVector.hpp" 14 | 15 | namespace tracy 16 | { 17 | 18 | class SysPower 19 | { 20 | struct Domain 21 | { 22 | uint64_t value; 23 | uint64_t overflow; 24 | FILE* handle; 25 | const char* name; 26 | }; 27 | 28 | public: 29 | SysPower(); 30 | ~SysPower(); 31 | 32 | void Tick(); 33 | 34 | private: 35 | void ScanDirectory( const char* path, int parent ); 36 | 37 | FastVector m_domains; 38 | uint64_t m_lastTime; 39 | }; 40 | 41 | } 42 | #endif 43 | 44 | #endif 45 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracySysTime.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYSYSTIME_HPP__ 2 | #define __TRACYSYSTIME_HPP__ 3 | 4 | #if defined _WIN32 || defined __linux__ || defined __APPLE__ 5 | # define TRACY_HAS_SYSTIME 6 | #else 7 | # include 8 | #endif 9 | 10 | #ifdef BSD 11 | # define TRACY_HAS_SYSTIME 12 | #endif 13 | 14 | #ifdef TRACY_HAS_SYSTIME 15 | 16 | #include 17 | 18 | namespace tracy 19 | { 20 | 21 | class SysTime 22 | { 23 | public: 24 | SysTime(); 25 | float Get(); 26 | 27 | void ReadTimes(); 28 | 29 | private: 30 | uint64_t idle, used; 31 | }; 32 | 33 | } 34 | #endif 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/client/TracySysTrace.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYSYSTRACE_HPP__ 2 | #define __TRACYSYSTRACE_HPP__ 3 | 4 | #if !defined TRACY_NO_SYSTEM_TRACING && ( defined _WIN32 || defined __linux__ ) 5 | # include "../common/TracyUwp.hpp" 6 | # ifndef TRACY_UWP 7 | # define TRACY_HAS_SYSTEM_TRACING 8 | # endif 9 | #endif 10 | 11 | #ifdef TRACY_HAS_SYSTEM_TRACING 12 | 13 | #include 14 | 15 | namespace tracy 16 | { 17 | 18 | bool SysTraceStart( int64_t& samplingPeriod ); 19 | void SysTraceStop(); 20 | void SysTraceWorker( void* ptr ); 21 | 22 | void SysTraceGetExternalName( uint64_t thread, const char*& threadName, const char*& name ); 23 | 24 | } 25 | 26 | #endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracyAlign.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYALIGN_HPP__ 2 | #define __TRACYALIGN_HPP__ 3 | 4 | #include 5 | 6 | #include "TracyForceInline.hpp" 7 | 8 | namespace tracy 9 | { 10 | 11 | template 12 | tracy_force_inline T MemRead( const void* ptr ) 13 | { 14 | T val; 15 | memcpy( &val, ptr, sizeof( T ) ); 16 | return val; 17 | } 18 | 19 | template 20 | tracy_force_inline void MemWrite( void* ptr, T val ) 21 | { 22 | memcpy( ptr, &val, sizeof( T ) ); 23 | } 24 | 25 | } 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracyApi.h: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYAPI_H__ 2 | #define __TRACYAPI_H__ 3 | 4 | #if defined _WIN32 5 | # if defined TRACY_EXPORTS 6 | # define TRACY_API __declspec(dllexport) 7 | # elif defined TRACY_IMPORTS 8 | # define TRACY_API __declspec(dllimport) 9 | # else 10 | # define TRACY_API 11 | # endif 12 | #else 13 | # define TRACY_API __attribute__((visibility("default"))) 14 | #endif 15 | 16 | #endif // __TRACYAPI_H__ 17 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracyForceInline.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYFORCEINLINE_HPP__ 2 | #define __TRACYFORCEINLINE_HPP__ 3 | 4 | #if defined(__GNUC__) 5 | # define tracy_force_inline __attribute__((always_inline)) inline 6 | #elif defined(_MSC_VER) 7 | # define tracy_force_inline __forceinline 8 | #else 9 | # define tracy_force_inline inline 10 | #endif 11 | 12 | #if defined(__GNUC__) 13 | # define tracy_no_inline __attribute__((noinline)) 14 | #elif defined(_MSC_VER) 15 | # define tracy_no_inline __declspec(noinline) 16 | #else 17 | # define tracy_no_inline 18 | #endif 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracyMutex.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYMUTEX_HPP__ 2 | #define __TRACYMUTEX_HPP__ 3 | 4 | #if defined _MSC_VER 5 | 6 | # include 7 | 8 | namespace tracy 9 | { 10 | using TracyMutex = std::shared_mutex; 11 | } 12 | 13 | #else 14 | 15 | #include 16 | 17 | namespace tracy 18 | { 19 | using TracyMutex = std::mutex; 20 | } 21 | 22 | #endif 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracyStackFrames.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYSTACKFRAMES_HPP__ 2 | #define __TRACYSTACKFRAMES_HPP__ 3 | 4 | #include 5 | 6 | namespace tracy 7 | { 8 | 9 | struct StringMatch 10 | { 11 | const char* str; 12 | size_t len; 13 | }; 14 | 15 | extern const char** s_tracyStackFrames; 16 | extern const StringMatch* s_tracySkipSubframes; 17 | 18 | static constexpr int s_tracySkipSubframesMinLen = 7; 19 | 20 | } 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracySystem.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYSYSTEM_HPP__ 2 | #define __TRACYSYSTEM_HPP__ 3 | 4 | #include 5 | 6 | #include "TracyApi.h" 7 | 8 | namespace tracy 9 | { 10 | 11 | namespace detail 12 | { 13 | TRACY_API uint32_t GetThreadHandleImpl(); 14 | } 15 | 16 | #ifdef TRACY_ENABLE 17 | TRACY_API uint32_t GetThreadHandle(); 18 | #else 19 | static inline uint32_t GetThreadHandle() 20 | { 21 | return detail::GetThreadHandleImpl(); 22 | } 23 | #endif 24 | 25 | TRACY_API void SetThreadName( const char* name ); 26 | TRACY_API const char* GetThreadName( uint32_t id ); 27 | 28 | TRACY_API const char* GetEnvVar(const char* name); 29 | 30 | } 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracyUwp.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYUWP_HPP__ 2 | #define __TRACYUWP_HPP__ 3 | 4 | #ifdef _WIN32 5 | # include 6 | # if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) 7 | # define TRACY_UWP 8 | # endif 9 | #endif 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracyVersion.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYVERSION_HPP__ 2 | #define __TRACYVERSION_HPP__ 3 | 4 | namespace tracy 5 | { 6 | namespace Version 7 | { 8 | enum { Major = 0 }; 9 | enum { Minor = 10 }; 10 | enum { Patch = 0 }; 11 | } 12 | } 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/common/TracyYield.hpp: -------------------------------------------------------------------------------- 1 | #ifndef __TRACYYIELD_HPP__ 2 | #define __TRACYYIELD_HPP__ 3 | 4 | #if defined __SSE2__ || defined _M_AMD64 || (defined _M_IX86_FP && _M_IX86_FP == 2) 5 | # include 6 | #else 7 | # include 8 | #endif 9 | 10 | #include "TracyForceInline.hpp" 11 | 12 | namespace tracy 13 | { 14 | 15 | static tracy_force_inline void YieldThread() 16 | { 17 | #if defined __SSE2__ || defined _M_AMD64 || (defined _M_IX86_FP && _M_IX86_FP == 2) 18 | _mm_pause(); 19 | #elif defined __aarch64__ 20 | asm volatile( "isb" : : ); 21 | #else 22 | std::this_thread::yield(); 23 | #endif 24 | } 25 | 26 | } 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /thirdparty/tracy/include/tracy/libbacktrace/config.h: -------------------------------------------------------------------------------- 1 | #include 2 | #if defined(__linux__) && !defined(__GLIBC__) && !defined(__WORDSIZE) 3 | // include __WORDSIZE headers for musl 4 | # include 5 | #endif 6 | #if __WORDSIZE == 64 7 | # define BACKTRACE_ELF_SIZE 64 8 | #else 9 | # define BACKTRACE_ELF_SIZE 32 10 | #endif 11 | 12 | #define HAVE_DLFCN_H 1 13 | #define HAVE_FCNTL 1 14 | #define HAVE_INTTYPES_H 1 15 | #define HAVE_LSTAT 1 16 | #define HAVE_READLINK 1 17 | #define HAVE_DL_ITERATE_PHDR 1 18 | #define HAVE_ATOMIC_FUNCTIONS 1 19 | #define HAVE_DECL_STRNLEN 1 20 | 21 | #ifdef __APPLE__ 22 | # define HAVE_MACH_O_DYLD_H 1 23 | #elif defined BSD 24 | # define HAVE_KERN_PROC 1 25 | # define HAVE_KERN_PROC_ARGS 1 26 | #endif 27 | -------------------------------------------------------------------------------- /thirdparty/xmp-lite/include/libxmp-lite/Makefile: -------------------------------------------------------------------------------- 1 | 2 | INCLUDE_DFILES = Makefile xmp.h 3 | 4 | INCLUDE_PATH = include/libxmp-lite 5 | 6 | install-include: 7 | $(INSTALL_DATA) xmp.h $(DESTDIR)$(INCLUDEDIR) 8 | 9 | dist-include: 10 | mkdir -p $(DIST)/$(INCLUDE_PATH) 11 | cp -RPp $(addprefix $(INCLUDE_PATH)/,$(INCLUDE_DFILES)) $(DIST)/$(INCLUDE_PATH) 12 | 13 | -------------------------------------------------------------------------------- /thirdparty/xmp-lite/src/Makefile: -------------------------------------------------------------------------------- 1 | 2 | SRC_OBJS = virtual.o format.o period.o player.o read_event.o \ 3 | misc.o dataio.o lfo.o scan.o control.o filter.o \ 4 | effects.o mixer.o mix_all.o load_helpers.o load.o \ 5 | filetype.o hio.o smix.o memio.o win32.o 6 | 7 | SRC_DFILES = Makefile $(SRC_OBJS:.o=.c) md5.c md5.h common.h effects.h \ 8 | format.h lfo.h list.h mixer.h period.h player.h virtual.h \ 9 | precomp_lut.h hio.h callbackio.h memio.h mdataio.h tempfile.h 10 | 11 | SRC_PATH = src 12 | 13 | OBJS += $(addprefix $(SRC_PATH)/,$(SRC_OBJS)) 14 | 15 | default-src:: 16 | $(MAKE) -C .. 17 | 18 | dist-src:: 19 | mkdir -p $(DIST)/$(SRC_PATH) 20 | cp -RPp $(addprefix $(SRC_PATH)/,$(SRC_DFILES)) $(DIST)/$(SRC_PATH) 21 | 22 | -------------------------------------------------------------------------------- /thirdparty/xmp-lite/src/lfo.h: -------------------------------------------------------------------------------- 1 | #ifndef LIBXMP_LFO_H 2 | #define LIBXMP_LFO_H 3 | 4 | #include "common.h" 5 | 6 | struct lfo { 7 | int type; 8 | int rate; 9 | int depth; 10 | int phase; 11 | }; 12 | 13 | int libxmp_lfo_get(struct context_data *, struct lfo *, int); 14 | void libxmp_lfo_update(struct lfo *); 15 | void libxmp_lfo_set_phase(struct lfo *, int); 16 | void libxmp_lfo_set_depth(struct lfo *, int); 17 | void libxmp_lfo_set_rate(struct lfo *, int); 18 | void libxmp_lfo_set_waveform(struct lfo *, int); 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /thirdparty/xmp-lite/src/loaders/Makefile: -------------------------------------------------------------------------------- 1 | 2 | LOADERS = xm_load.o mod_load.o s3m_load.o it_load.o 3 | 4 | LOADERS_OBJS = common.o itsex.o sample.o $(LOADERS) 5 | LOADERS_DFILES = Makefile $(LOADERS_OBJS:.o=.c) \ 6 | it.h loader.h mod.h s3m.h xm.h 7 | LOADERS_PATH = src/loaders 8 | 9 | OBJS += $(addprefix $(LOADERS_PATH)/,$(LOADERS_OBJS)) 10 | 11 | default: 12 | 13 | dist-loaders:: 14 | mkdir -p $(DIST)/$(LOADERS_PATH) 15 | cp -RPp $(addprefix $(LOADERS_PATH)/,$(LOADERS_DFILES)) $(DIST)/$(LOADERS_PATH) 16 | -------------------------------------------------------------------------------- /thirdparty/xmp-lite/src/memio.h: -------------------------------------------------------------------------------- 1 | #ifndef LIBXMP_MEMIO_H 2 | #define LIBXMP_MEMIO_H 3 | 4 | #include 5 | #include "common.h" 6 | 7 | typedef struct { 8 | const unsigned char *start; 9 | ptrdiff_t pos; 10 | ptrdiff_t size; 11 | int free_after_use; 12 | } MFILE; 13 | 14 | LIBXMP_BEGIN_DECLS 15 | 16 | MFILE *mopen(const void *, long, int); 17 | int mgetc(MFILE *stream); 18 | size_t mread(void *, size_t, size_t, MFILE *); 19 | int mseek(MFILE *, long, int); 20 | long mtell(MFILE *); 21 | int mclose(MFILE *); 22 | int meof(MFILE *); 23 | 24 | LIBXMP_END_DECLS 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /thirdparty/xmp-lite/src/period.h: -------------------------------------------------------------------------------- 1 | #ifndef LIBXMP_PERIOD_H 2 | #define LIBXMP_PERIOD_H 3 | 4 | #define PERIOD_BASE 13696.0 /* C0 period */ 5 | 6 | /* Macros for period conversion */ 7 | #define NOTE_B0 11 8 | #define NOTE_Bb0 (NOTE_B0 + 1) 9 | #define MAX_NOTE (NOTE_B0 * 8) 10 | #define MAX_PERIOD 0x1c56 11 | #define MIN_PERIOD_A 0x0071 12 | #define MAX_PERIOD_A 0x0358 13 | #define MIN_PERIOD_L 0x0000 14 | #define MAX_PERIOD_L 0x1e00 15 | #define MIN_NOTE_MOD 48 16 | #define MAX_NOTE_MOD 83 17 | 18 | double libxmp_note_to_period (struct context_data *, int, int, double); 19 | double libxmp_note_to_period_mix (int, int); 20 | int libxmp_period_to_note (int); 21 | int libxmp_period_to_bend (struct context_data *, double, int, double); 22 | void libxmp_c2spd_to_note (int, int *, int *); 23 | #ifndef LIBXMP_CORE_PLAYER 24 | double libxmp_gus_frequency_steps (int, int); 25 | #endif 26 | 27 | #endif /* LIBXMP_PERIOD_H */ 28 | -------------------------------------------------------------------------------- /thirdparty/xmp-lite/src/tempfile.h: -------------------------------------------------------------------------------- 1 | #ifndef XMP_PLATFORM_H 2 | #define XMP_PLATFORM_H 3 | 4 | FILE *make_temp_file(char **); 5 | void unlink_temp_file(char *); 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /thirdparty/xmp-lite/src/win32.c: -------------------------------------------------------------------------------- 1 | /* _[v]snprintf() from msvcrt.dll might not nul terminate */ 2 | /* OpenWatcom-provided versions seem to behave the same... */ 3 | 4 | #include "common.h" 5 | 6 | #if defined(USE_LIBXMP_SNPRINTF) 7 | 8 | #undef snprintf 9 | #undef vsnprintf 10 | 11 | int libxmp_vsnprintf(char *str, size_t sz, const char *fmt, va_list ap) 12 | { 13 | int rc = _vsnprintf(str, sz, fmt, ap); 14 | if (sz != 0) { 15 | if (rc < 0) rc = (int)sz; 16 | if ((size_t)rc >= sz) str[sz - 1] = '\0'; 17 | } 18 | return rc; 19 | } 20 | 21 | int libxmp_snprintf (char *str, size_t sz, const char *fmt, ...) 22 | { 23 | va_list ap; 24 | int rc; 25 | 26 | va_start (ap, fmt); 27 | rc = _vsnprintf(str, sz, fmt, ap); 28 | va_end (ap); 29 | 30 | return rc; 31 | } 32 | 33 | #endif 34 | 35 | /* Win32 debug message helper by Mirko Buffoni */ 36 | #if defined(_MSC_VER) && defined(DEBUG) 37 | void libxmp_msvc_dbgprint(const char *format, ...) 38 | { 39 | va_list argptr; 40 | 41 | /* do the output */ 42 | va_start(argptr, format); 43 | vprintf(format, argptr); 44 | printf("\n"); 45 | va_end(argptr); 46 | } 47 | #endif 48 | -------------------------------------------------------------------------------- /vcpkg-configuration.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg-configuration.schema.json" 3 | } 4 | -------------------------------------------------------------------------------- /vcpkg.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json", 3 | "name": "ringracers", 4 | "version": "1.0.0", 5 | "builtin-baseline": "d5ec528843d29e3a52d745a64b469f810b2cedbf", 6 | "dependencies": [ 7 | "curl", 8 | "libogg", 9 | "libpng", 10 | "libvorbis", 11 | "libvpx", 12 | "libyuv", 13 | "sdl2", 14 | "zlib" 15 | ] 16 | } 17 | --------------------------------------------------------------------------------