├── .gitattributes
├── .github
    └── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   ├── general-issue-or-feature-request.md
    │   └── mod-issues.md
├── .gitignore
├── .gitmodules
├── CMakeLists.txt
├── CMakeSettings.json
├── CONTRIBUTING.md
├── Info.plist.in
├── LICENSE
├── README.md
├── appveyor.yml
├── game
    ├── bink
    │   ├── README.md
    │   ├── frame.cpp
    │   ├── frame.h
    │   ├── video.cpp
    │   └── video.h
    ├── build.h
    ├── camera.cpp
    ├── camera.h
    ├── commandline.cpp
    ├── commandline.h
    ├── dmusic
    │   ├── band.cpp
    │   ├── band.h
    │   ├── directmusic.cpp
    │   ├── directmusic.h
    │   ├── dlscollection.cpp
    │   ├── dlscollection.h
    │   ├── hydra.cpp
    │   ├── hydra.h
    │   ├── info.cpp
    │   ├── info.h
    │   ├── mixer.cpp
    │   ├── mixer.h
    │   ├── music.cpp
    │   ├── music.h
    │   ├── pattern.cpp
    │   ├── pattern.h
    │   ├── patternlist.cpp
    │   ├── patternlist.h
    │   ├── reference.cpp
    │   ├── reference.h
    │   ├── riff.cpp
    │   ├── riff.h
    │   ├── segment.cpp
    │   ├── segment.h
    │   ├── soundfont.cpp
    │   ├── soundfont.h
    │   ├── structs.h
    │   ├── style.cpp
    │   ├── style.h
    │   ├── track.cpp
    │   ├── track.h
    │   ├── wave.cpp
    │   └── wave.h
    ├── game
    │   ├── aiouputpipe.cpp
    │   ├── aiouputpipe.h
    │   ├── aistate.cpp
    │   ├── aistate.h
    │   ├── compatibility
    │   │   ├── ikarus.cpp
    │   │   ├── ikarus.h
    │   │   ├── lego.cpp
    │   │   ├── lego.h
    │   │   ├── mem32.cpp
    │   │   ├── mem32.h
    │   │   ├── phoenix.cpp
    │   │   ├── phoenix.h
    │   │   ├── scriptplugin.cpp
    │   │   └── scriptplugin.h
    │   ├── constants.h
    │   ├── damagecalculator.cpp
    │   ├── damagecalculator.h
    │   ├── definitions
    │   │   ├── cameradefinitions.cpp
    │   │   ├── cameradefinitions.h
    │   │   ├── fightaidefinitions.cpp
    │   │   ├── fightaidefinitions.h
    │   │   ├── musicdefinitions.cpp
    │   │   ├── musicdefinitions.h
    │   │   ├── particlesdefinitions.cpp
    │   │   ├── particlesdefinitions.h
    │   │   ├── sounddefinitions.cpp
    │   │   ├── sounddefinitions.h
    │   │   ├── spelldefinitions.cpp
    │   │   ├── spelldefinitions.h
    │   │   ├── svmdefinitions.cpp
    │   │   ├── svmdefinitions.h
    │   │   ├── visualfxdefinitions.cpp
    │   │   └── visualfxdefinitions.h
    │   ├── fightalgo.cpp
    │   ├── fightalgo.h
    │   ├── gamescript.cpp
    │   ├── gamescript.h
    │   ├── gamesession.cpp
    │   ├── gamesession.h
    │   ├── gametime.h
    │   ├── globaleffects.cpp
    │   ├── globaleffects.h
    │   ├── inventory.cpp
    │   ├── inventory.h
    │   ├── movealgo.cpp
    │   ├── movealgo.h
    │   ├── perceptionmsg.h
    │   ├── playercontrol.cpp
    │   ├── playercontrol.h
    │   ├── questlog.cpp
    │   ├── questlog.h
    │   ├── savegameheader.cpp
    │   ├── savegameheader.h
    │   ├── serialize.cpp
    │   ├── serialize.h
    │   ├── worldstatestorage.cpp
    │   └── worldstatestorage.h
    ├── gamemusic.cpp
    ├── gamemusic.h
    ├── gothic.cpp
    ├── gothic.h
    ├── graphics
    │   ├── bounds.cpp
    │   ├── bounds.h
    │   ├── drawbuckets.cpp
    │   ├── drawbuckets.h
    │   ├── drawclusters.cpp
    │   ├── drawclusters.h
    │   ├── drawcommands.cpp
    │   ├── drawcommands.h
    │   ├── dynamic
    │   │   ├── frustrum.cpp
    │   │   └── frustrum.h
    │   ├── effect.cpp
    │   ├── effect.h
    │   ├── instancestorage.cpp
    │   ├── instancestorage.h
    │   ├── inventoryrenderer.cpp
    │   ├── inventoryrenderer.h
    │   ├── lightgroup.cpp
    │   ├── lightgroup.h
    │   ├── lightsource.cpp
    │   ├── lightsource.h
    │   ├── material.cpp
    │   ├── material.h
    │   ├── mdlvisual.cpp
    │   ├── mdlvisual.h
    │   ├── mesh
    │   │   ├── animation.cpp
    │   │   ├── animation.h
    │   │   ├── animationsolver.cpp
    │   │   ├── animationsolver.h
    │   │   ├── animmath.cpp
    │   │   ├── animmath.h
    │   │   ├── attachbinder.cpp
    │   │   ├── attachbinder.h
    │   │   ├── landscape.cpp
    │   │   ├── landscape.h
    │   │   ├── pose.cpp
    │   │   ├── pose.h
    │   │   ├── protomesh.cpp
    │   │   ├── protomesh.h
    │   │   ├── skeleton.cpp
    │   │   ├── skeleton.h
    │   │   └── submesh
    │   │   │   ├── animmesh.cpp
    │   │   │   ├── animmesh.h
    │   │   │   ├── packedmesh.cpp
    │   │   │   ├── packedmesh.h
    │   │   │   ├── pfxemittermesh.cpp
    │   │   │   ├── pfxemittermesh.h
    │   │   │   ├── staticmesh.cpp
    │   │   │   └── staticmesh.h
    │   ├── meshobjects.cpp
    │   ├── meshobjects.h
    │   ├── objvisual.cpp
    │   ├── objvisual.h
    │   ├── pfx
    │   │   ├── particlefx.cpp
    │   │   ├── particlefx.h
    │   │   ├── pfxbucket.cpp
    │   │   ├── pfxbucket.h
    │   │   ├── pfxobjects.cpp
    │   │   └── pfxobjects.h
    │   ├── renderer.cpp
    │   ├── renderer.h
    │   ├── rtscene.cpp
    │   ├── rtscene.h
    │   ├── sceneglobals.cpp
    │   ├── sceneglobals.h
    │   ├── shaders.cpp
    │   ├── shaders.h
    │   ├── sky
    │   │   ├── sky.cpp
    │   │   └── sky.h
    │   ├── visualfx.cpp
    │   ├── visualfx.h
    │   ├── visualobjects.cpp
    │   ├── visualobjects.h
    │   ├── worldview.cpp
    │   └── worldview.h
    ├── main.cpp
    ├── mainwindow.cpp
    ├── mainwindow.h
    ├── marvin.cpp
    ├── marvin.h
    ├── physics
    │   ├── collisionworld.cpp
    │   ├── collisionworld.h
    │   ├── dynamicworld.cpp
    │   ├── dynamicworld.h
    │   ├── physicmesh.cpp
    │   ├── physicmesh.h
    │   ├── physicmeshshape.cpp
    │   ├── physicmeshshape.h
    │   ├── physics.h
    │   ├── physicvbo.cpp
    │   └── physicvbo.h
    ├── resources.cpp
    ├── resources.h
    ├── sound
    │   ├── soundfx.cpp
    │   └── soundfx.h
    ├── ui
    │   ├── chapterscreen.cpp
    │   ├── chapterscreen.h
    │   ├── consolewidget.cpp
    │   ├── consolewidget.h
    │   ├── dialogmenu.cpp
    │   ├── dialogmenu.h
    │   ├── documentmenu.cpp
    │   ├── documentmenu.h
    │   ├── gamemenu.cpp
    │   ├── gamemenu.h
    │   ├── inventorymenu.cpp
    │   ├── inventorymenu.h
    │   ├── menuroot.cpp
    │   ├── menuroot.h
    │   ├── stacklayout.cpp
    │   ├── stacklayout.h
    │   ├── touchinput.cpp
    │   ├── touchinput.h
    │   ├── videowidget.cpp
    │   └── videowidget.h
    ├── utils
    │   ├── crashlog.cpp
    │   ├── crashlog.h
    │   ├── dbgpainter.cpp
    │   ├── dbgpainter.h
    │   ├── fileext.h
    │   ├── fileutil.cpp
    │   ├── fileutil.h
    │   ├── gthfont.cpp
    │   ├── gthfont.h
    │   ├── inifile.cpp
    │   ├── inifile.h
    │   ├── installdetect.cpp
    │   ├── installdetect.h
    │   ├── installdetect.mm
    │   ├── keycodec.cpp
    │   ├── keycodec.h
    │   ├── mouseutil.cpp
    │   ├── mouseutil.h
    │   ├── parser.cpp
    │   ├── parser.h
    │   ├── string_frm.h
    │   ├── versioninfo.h
    │   ├── workers.cpp
    │   └── workers.h
    └── world
    │   ├── aiqueue.cpp
    │   ├── aiqueue.h
    │   ├── bullet.cpp
    │   ├── bullet.h
    │   ├── collisionzone.cpp
    │   ├── collisionzone.h
    │   ├── focus.cpp
    │   ├── focus.h
    │   ├── fplock.cpp
    │   ├── fplock.h
    │   ├── objects
    │       ├── fireplace.cpp
    │       ├── fireplace.h
    │       ├── globalfx.cpp
    │       ├── globalfx.h
    │       ├── interactive.cpp
    │       ├── interactive.h
    │       ├── item.cpp
    │       ├── item.h
    │       ├── itemtorchburning.cpp
    │       ├── itemtorchburning.h
    │       ├── npc.cpp
    │       ├── npc.h
    │       ├── pfxemitter.cpp
    │       ├── pfxemitter.h
    │       ├── sound.cpp
    │       ├── sound.h
    │       ├── staticobj.cpp
    │       ├── staticobj.h
    │       ├── vob.cpp
    │       ├── vob.h
    │       ├── vobbundle.cpp
    │       └── vobbundle.h
    │   ├── spaceindex.cpp
    │   ├── spaceindex.h
    │   ├── triggers
    │       ├── abstracttrigger.cpp
    │       ├── abstracttrigger.h
    │       ├── codemaster.cpp
    │       ├── codemaster.h
    │       ├── cscamera.cpp
    │       ├── cscamera.h
    │       ├── earthquake.cpp
    │       ├── earthquake.h
    │       ├── messagefilter.cpp
    │       ├── messagefilter.h
    │       ├── movercontroler.cpp
    │       ├── movercontroler.h
    │       ├── movetrigger.cpp
    │       ├── movetrigger.h
    │       ├── pfxcontroller.cpp
    │       ├── pfxcontroller.h
    │       ├── touchdamage.cpp
    │       ├── touchdamage.h
    │       ├── trigger.cpp
    │       ├── trigger.h
    │       ├── triggerlist.cpp
    │       ├── triggerlist.h
    │       ├── triggerscript.cpp
    │       ├── triggerscript.h
    │       ├── triggerworldstart.cpp
    │       ├── triggerworldstart.h
    │       ├── zonetrigger.cpp
    │       └── zonetrigger.h
    │   ├── waymatrix.cpp
    │   ├── waymatrix.h
    │   ├── waypath.cpp
    │   ├── waypath.h
    │   ├── waypoint.cpp
    │   ├── waypoint.h
    │   ├── world.cpp
    │   ├── world.h
    │   ├── worldlight.cpp
    │   ├── worldlight.h
    │   ├── worldobjects.cpp
    │   ├── worldobjects.h
    │   ├── worldsound.cpp
    │   └── worldsound.h
├── icon.ico
├── icon.rc
├── lib
    ├── edd-dbg
    │   ├── CMakeLists.txt
    │   ├── include
    │   │   └── dbg
    │   │   │   ├── assert.hpp
    │   │   │   ├── config.hpp
    │   │   │   ├── debugger.hpp
    │   │   │   ├── fatality.hpp
    │   │   │   ├── frames.hpp
    │   │   │   ├── impl
    │   │   │       ├── format.hpp
    │   │   │       ├── quality_infraction.hpp
    │   │   │       └── raise.hpp
    │   │   │   ├── log.hpp
    │   │   │   ├── logstream.hpp
    │   │   │   ├── note.hpp
    │   │   │   ├── static_assert.hpp
    │   │   │   ├── symbols.hpp
    │   │   │   ├── symlog.hpp
    │   │   │   ├── throw.hpp
    │   │   │   ├── unusual.hpp
    │   │   │   └── version.hpp
    │   └── src
    │   │   ├── assert.cpp
    │   │   ├── envvar.hpp
    │   │   ├── format.cpp
    │   │   ├── frames_common.cpp
    │   │   ├── log.cpp
    │   │   ├── logstream.cpp
    │   │   ├── memcpy_cast.hpp
    │   │   ├── note.cpp
    │   │   ├── osx
    │   │       ├── debugger.cpp
    │   │       ├── envvar.cpp
    │   │       ├── frames.cpp
    │   │       ├── symbols.cpp
    │   │       ├── throw_state.cpp
    │   │       └── timestamp.cpp
    │   │   ├── quality_infraction.cpp
    │   │   ├── spin_mutex.hpp
    │   │   ├── symlog.cpp
    │   │   ├── throw.cpp
    │   │   ├── throw_state.hpp
    │   │   ├── timestamp.hpp
    │   │   ├── timestamp_common.cpp
    │   │   ├── unusual.cpp
    │   │   └── windows
    │   │       ├── dbghelp.cpp
    │   │       ├── dbghelp.hpp
    │   │       ├── debugger.cpp
    │   │       ├── dll.cpp
    │   │       ├── dll.hpp
    │   │       ├── envvar.cpp
    │   │       ├── frames.cpp
    │   │       ├── mingw
    │   │           ├── file.cpp
    │   │           ├── file.hpp
    │   │           ├── pe.cpp
    │   │           ├── pe.hpp
    │   │           ├── pe_symtab.cpp
    │   │           ├── pe_symtab.hpp
    │   │           └── symbols.cpp
    │   │       ├── ms_symdb.cpp
    │   │       ├── ms_symdb.hpp
    │   │       ├── msvc
    │   │           └── symbols.cpp
    │   │       ├── symsink.cpp
    │   │       ├── throw_state.cpp
    │   │       └── timestamp.cpp
    └── miniz
    │   ├── ChangeLog.md
    │   ├── LICENSE
    │   ├── miniz.c
    │   ├── miniz.h
    │   └── readme.md
├── packaging
    └── opengothic.appdata.xml
├── scr0.png
├── scripts
    ├── Gothic2Notr.bat
    └── Gothic2Notr.sh
└── shader
    ├── CMakeLists.txt
    ├── antialiasing
        └── cmaa2
        │   ├── cmaa2_common.glsl
        │   ├── deferred_color_apply_2x2.frag
        │   ├── deferred_color_apply_2x2.vert
        │   ├── edge_color2x2.comp
        │   └── process_candidates.comp
    ├── common.glsl
    ├── copy.comp
    ├── copy.frag
    ├── copy.vert
    ├── copy_img.comp
    ├── epipolar
        ├── epipolar_common.glsl
        ├── fog_epipolar.comp
        ├── fog_epipolar_occlusion.comp
        └── fog_shadow_sample.comp
    ├── hiz
        ├── hiz_mip.comp
        └── hiz_pot.comp
    ├── inventory
        ├── item.frag
        └── item.vert
    ├── lighting
        ├── ambient_light.frag
        ├── direct_light.frag
        ├── irradiance.comp
        ├── light.frag
        ├── light.vert
        ├── purkinje_shift.glsl
        ├── rt
        │   ├── probe_allocation.comp
        │   ├── probe_ambient.frag
        │   ├── probe_aux.comp
        │   ├── probe_common.glsl
        │   ├── probe_dbg.frag
        │   ├── probe_dbg.vert
        │   ├── probe_hit_dbg.frag
        │   ├── probe_hit_dbg.vert
        │   ├── probe_lighting.comp
        │   ├── probe_trace.comp
        │   └── rt_common.glsl
        ├── shadow_sampling.glsl
        ├── sky_exposure.comp
        ├── tonemapping.frag
        └── tonemapping.glsl
    ├── link_shaders.cmake
    ├── materials
        ├── cluster_init.comp
        ├── cluster_patch.comp
        ├── main.frag
        ├── main.tesc
        ├── main.tese
        ├── main.vert
        ├── materials_common.glsl
        ├── pfx.vert
        ├── vertex_process.glsl
        └── visibility_pass.comp
    ├── patch.comp
    ├── rtsm
        ├── rtsm_clear.comp
        ├── rtsm_clear_omni.comp
        ├── rtsm_common.glsl
        ├── rtsm_cull_lights.comp
        ├── rtsm_culling.comp
        ├── rtsm_culling_omni.comp
        ├── rtsm_dbg.frag
        ├── rtsm_direct_light.frag
        ├── rtsm_hiz_pages.comp
        ├── rtsm_mark_fog_pages.comp
        ├── rtsm_mark_pages.comp
        ├── rtsm_meshlet_complex.comp
        ├── rtsm_meshlet_cull.comp
        ├── rtsm_meshlet_omni.comp
        ├── rtsm_position.comp
        ├── rtsm_primitive_cull.comp
        ├── rtsm_raster.comp
        ├── rtsm_raster_omni.comp
        ├── rtsm_rendering.comp
        ├── rtsm_sample_cull.comp
        ├── rtsm_scratch.glsl
        └── rtsm_tile_bboxes.glsl
    ├── scalar_ops.glsl
    ├── scene.glsl
    ├── sky
        ├── clouds.glsl
        ├── clouds_lut.comp
        ├── fog.frag
        ├── fog_epipolar.frag
        ├── fog_view_lut.comp
        ├── shadow_downsample.comp
        ├── sky.frag
        ├── sky_common.glsl
        ├── sky_multi_scattering.frag
        ├── sky_pathtrace.frag
        ├── sky_transmittance.frag
        ├── sky_view_clouds_lut.frag
        ├── sky_view_lut.frag
        ├── sun.frag
        └── sun.vert
    ├── software_rendering
        ├── sw_light.comp
        ├── sw_rendering_imm.comp
        ├── sw_rendering_tbr.comp
        └── vbuffer_blit.frag
    ├── ssao
        ├── ssao.comp
        └── ssao_blur.comp
    ├── stash.frag
    ├── upscale
        └── lanczos.glsl
    ├── virtual_shadow
        ├── vsm_alloc_pages.comp
        ├── vsm_alloc_pages2.comp
        ├── vsm_clear.comp
        ├── vsm_clear_omni.comp
        ├── vsm_clump_pages.comp
        ├── vsm_common.glsl
        ├── vsm_cull_lights.comp
        ├── vsm_direct_light.frag
        ├── vsm_fog_shadow.comp
        ├── vsm_fog_trace.comp
        ├── vsm_list_pages.comp
        ├── vsm_mark_omni_pages.comp
        ├── vsm_mark_pages.comp
        ├── vsm_merge_pages.comp
        ├── vsm_pack_draws.comp
        ├── vsm_postprocess_omni.comp
        ├── vsm_rendering.comp
        ├── vsm_sort_pages.comp
        ├── vsm_trim_pages.comp
        └── vsm_visibility_pass.comp
    └── water
        ├── gerstner_wave.glsl
        ├── underwater.frag
        ├── water_reflection.frag
        └── water_reflection.mesh


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: bug
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug**
11 | A clear and concise description of what the bug is.
12 | 
13 | **Save-game/Log-file/Screenshots/Video**
14 | If applicable, add screenshots or save-game file to help explain your problem.
15 | 
16 | **Application log**
17 | If relevant attach `log.txt` file or, in case of game-crash, `crash.log`
18 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/general-issue-or-feature-request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: General issue or feature request
 3 | about: Some general request
 4 | title: ''
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | 
11 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/mod-issues.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Mod issues
 3 | about: Issue with modded gothic2
 4 | title: ''
 5 | labels: mod
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Describe the issue**
11 | A clear and concise description of what the bug is.
12 | 
13 | **Information about the mod**
14 | Please provide mod name and download link.
15 | 
16 | **Save-game/Log-file/Screenshots/Video**
17 | If applicable, add screenshots or save-game file to help explain your problem.
18 | 
19 | **Application log**
20 | If relevant attach `log.txt` file or, in case of game-crash, `crash.log`
21 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Dynamic libraries
 2 | *.so
 3 | *.dylib
 4 | *.dll
 5 | 
 6 | # Executables
 7 | *.exe
 8 | *.out
 9 | *.app
10 | 
11 | # IDE
12 | CMakeLists.txt.user*
13 | .idea
14 | 
15 | # Build-dir
16 | build/
17 | build-*/
18 | bin/log.txt
19 | bin/crash.log
20 | bin/dbg.bin
21 | bin/*.sav
22 | bin/Gothic.ini
23 | out/*
24 | 
25 | # internal
26 | .vs/
27 | internal/
28 | 
29 | #os
30 | .DS_Store
31 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
 1 | [submodule "lib/Tempest"]
 2 | 	path = lib/Tempest
 3 | 	url = https://github.com/Try/Tempest.git
 4 | [submodule "lib/bullet3"]
 5 | 	path = lib/bullet3
 6 | 	url = https://github.com/bulletphysics/bullet3.git
 7 | [submodule "lib/TinySoundFont"]
 8 | 	path = lib/TinySoundFont
 9 | 	url = https://github.com/schellingb/TinySoundFont.git
10 | [submodule "lib/ZenKit"]
11 | 	path = lib/ZenKit
12 |   url = https://github.com/GothicKit/ZenKit.git
13 | [submodule "lib/dmusic"]
14 | 	path = lib/dmusic
15 | 	url = https://github.com/GothicKit/dmusic.git
16 | 


--------------------------------------------------------------------------------
/CMakeSettings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "configurations": [
 3 |     {
 4 |       "name": "x64-Debug",
 5 |       "generator": "Ninja",
 6 |       "configurationType": "Debug",
 7 |       "inheritEnvironments": [ "msvc_x64_x64" ],
 8 |       "buildRoot": "${projectDir}\\out\\build\\${name}",
 9 |       "installRoot": "${projectDir}\\out\\install\\${name}",
10 |       "cmakeCommandArgs": "",
11 |       "buildCommandArgs": "",
12 |       "ctestCommandArgs": ""
13 |     },
14 |     {
15 |       "name": "x64-Profile",
16 |       "generator": "Ninja",
17 |       "configurationType": "RelWithDebInfo",
18 |       "buildRoot": "${projectDir}\\out\\build\\${name}",
19 |       "installRoot": "${projectDir}\\out\\install\\${name}",
20 |       "cmakeCommandArgs": "",
21 |       "buildCommandArgs": "",
22 |       "ctestCommandArgs": "",
23 |       "inheritEnvironments": [ "msvc_x64_x64" ],
24 |       "variables": []
25 |     }
26 |   ]
27 | }


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | ## Contributing
 2 | 
 3 | This page design to help you contribute to this project.
 4 | 
 5 | ### Project structure
 6 | - OpenGothic
 7 |   - Game - game itself
 8 |   - shader - glsl shaders
 9 |   - lib
10 |     - MoltenTempest - graphics engine
11 |     - bullet3 - physic engine
12 |     - ZenLib - gothic-asset loading library
13 |     - TinySoundFont - midi sound support library
14 |     - edd-dbg - crashlog library
15 | 
16 | ### Tracking of progress and bug reporting
17 | Those guidlined are not strict, just a recomandations rather.  
18 | This project uses wiki to track not implemented features and issues to track bugs:
19 | 
20 | * Features:  
21 |   [Detailed list of features](https://github.com/Try/OpenGothic/wiki/Feature-list)  
22 |   You can create a issue, if you want to work on a feature and want to notify everyone.
23 |   
24 | * Script-api:  
25 |   [Detailed list of implemented api functions](https://github.com/Try/OpenGothic/wiki/Daedalus-scripts)
26 |   
27 | * Bugs in already implemented stuff:  
28 |   This is a good case for issue
29 |   
30 | * Bugs in partially implemented feature:  
31 |   You can submit a issue, if this bug causes crash, or makes game unplayable somehow.
32 |   
33 | * Renderer:  
34 |   At this moment I'm looking forward to rewrite it - not much need in issues here
35 | 
36 | 


--------------------------------------------------------------------------------
/Info.plist.in:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 | 	<key>CFBundleDevelopmentRegion</key>
 6 | 	<string>English</string>
 7 | 	<key>CFBundleExecutable</key>
 8 | 	<string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
 9 | 	<key>CFBundleGetInfoString</key>
10 | 	<string>${MACOSX_BUNDLE_INFO_STRING}</string>
11 | 	<key>CFBundleIconFile</key>
12 | 	<string>${MACOSX_BUNDLE_ICON_FILE}</string>
13 | 	<key>CFBundleIdentifier</key>
14 | 	<string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
15 | 	<key>CFBundleInfoDictionaryVersion</key>
16 | 	<string>6.0</string>
17 | 	<key>CFBundleLongVersionString</key>
18 | 	<string>${MACOSX_BUNDLE_LONG_VERSION_STRING}</string>
19 | 	<key>CFBundleName</key>
20 | 	<string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
21 | 	<key>CFBundlePackageType</key>
22 | 	<string>APPL</string>
23 | 	<key>CFBundleShortVersionString</key>
24 | 	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
25 | 	<key>CFBundleSignature</key>
26 | 	<string>????</string>
27 | 	<key>CFBundleVersion</key>
28 | 	<string>${MACOSX_BUNDLE_BUNDLE_VERSION}</string>
29 | 	<key>CSResourcesFileMapped</key>
30 | 	<true/>
31 | 	<key>NSHumanReadableCopyright</key>
32 | 	<string>${MACOSX_BUNDLE_COPYRIGHT}</string>
33 |   <key>UIFileSharingEnabled</key>
34 |   <true/>
35 |   <key>LSSupportsOpeningDocumentsInPlace</key>
36 |   <true/>
37 |   <key>com.apple.developer.kernel.increased-memory-limit</key>
38 |   <true/>
39 |   <key>UILaunchScreen</key>
40 |   <dict>
41 |     <key>UIColorName</key>
42 |     <string>black</string>
43 |   </dict>
44 | </dict>
45 | </plist>
46 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Try
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/game/bink/README.md:
--------------------------------------------------------------------------------
 1 | ### This folder contains a Bink-video codec
 2 | 
 3 | Implementation is based on ffmpeg library source code (LGPLv2.1+).
 4 | Codec itself is completely independent unit, which does not require any other OpenGothic parts in order to work - fell free to use it for your open-source game remake.
 5 | 
 6 | Classes:
 7 | * Bink::Video - video codec
 8 | * Bink::Frame - frame image
 9 | * Bink::Video::Input - data input adapter
10 | * Bink::Frame::Plane - one of YUV planes
11 | 
12 | Usage example:
13 | ```c++
14 | #include <bink/video.h>
15 | 
16 | MyInput     fin(filename); // see Bink::Video::Input
17 | Bink::Video vid(&fin);
18 | for(size_t i=0; i<vid.frameCount(); ++i) {
19 |   auto& f = vid.nextFrame();
20 | 
21 |   char buf[256]={};
22 |   std::snprintf(buf,sizeof(buf),"%s_%d.tga",savename,i);
23 |   saveImage(f,buf);
24 |   }
25 | ```
26 | 


--------------------------------------------------------------------------------
/game/bink/frame.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <cstdint>
 5 | #include <cstddef>
 6 | 
 7 | namespace Bink {
 8 | 
 9 | class Video;
10 | 
11 | class Frame final {
12 |   public:
13 |     Frame();
14 |     Frame(Frame&&) = default;
15 |     Frame& operator = (Frame&&) = default;
16 | 
17 |     class Plane final {
18 |       public:
19 |         void getPixels8x8  (uint32_t rx, uint32_t ry, uint8_t* out) const;
20 | 
21 |         void getBlock8x8   (uint32_t x, uint32_t y, uint8_t* out) const;
22 |         void putBlock8x8   (uint32_t x, uint32_t y, const uint8_t* in);
23 |         void putScaledBlock(uint32_t x, uint32_t y, const uint8_t* in);
24 |         void fill          (uint8_t v);
25 | 
26 |         uint8_t        at(uint32_t x, uint32_t y) const;
27 |         const uint8_t* data() const { return dat.data(); }
28 | 
29 |       private:
30 |         void setSize(uint32_t w, uint32_t h);
31 | 
32 |         std::vector<uint8_t> dat;
33 |         uint32_t             w = 0;
34 |         uint32_t             h = 0;
35 |         uint32_t             stride = 0;
36 | 
37 |       friend class Frame;
38 |       };
39 | 
40 |     class Audio final {
41 |       public:
42 |         std::vector<float> samples;
43 |       };
44 | 
45 |     uint32_t width()  const { return planes[0].w;      }
46 |     uint32_t stride() const { return planes[0].stride; }
47 |     uint32_t height() const { return planes[0].h;      }
48 | 
49 |     const Plane& plane(uint8_t id) const { return planes[id]; }
50 |     const Audio& audio(uint8_t id) const;
51 |     size_t       audioCount()      const { return aud.size(); }
52 | 
53 |   private:
54 |     Plane              planes[4];
55 |     std::vector<Audio> aud;
56 | 
57 |     void  setSize(uint32_t w, uint32_t h);
58 |     void  setAudioChannels(uint8_t count);
59 | 
60 |   friend class Video;
61 |   };
62 | 
63 | }
64 | 
65 | 


--------------------------------------------------------------------------------
/game/build.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | static const char* appBuild = "OpenGothic v1.0 dev";
4 | 


--------------------------------------------------------------------------------
/game/dmusic/band.cpp:
--------------------------------------------------------------------------------
 1 | #include "band.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | #include <stdexcept>
 5 | 
 6 | using namespace Dx8;
 7 | 
 8 | Band::Instrument::Instrument(Riff &input) {
 9 |   if(!input.isListId("lbin"))
10 |     throw std::runtime_error("not a band instrument");
11 | 
12 |   input.read([this](Riff& c){
13 |     if(c.is("bins"))
14 |       c.read(&header,sizeof(header));
15 |     else if(c.is("LIST")) {
16 |       if(c.isListId("DMRF"))
17 |         reference = Reference(c);
18 |       }
19 |     });
20 |   }
21 | 
22 | Band::Band(Riff& input) {
23 |   input.read([this](Riff& c){
24 |     implRead(c);
25 |     });
26 |   }
27 | 
28 | void Band::implRead(Riff &input) {
29 |   if(input.is("guid"))
30 |     input.read(&guid,sizeof(guid));
31 |   else if(input.is("vers"))
32 |     input.read(&vers,sizeof(vers));
33 |   else if(input.is("LIST")){
34 |     if(input.isListId("lbil")) {
35 |       input.read([this](Riff& c){
36 |         intrument.emplace_back(c);
37 |         });
38 |       }
39 |     else if(input.isListId("UNFO"))
40 |       info = Unfo(input);
41 |     }
42 |   }
43 | 


--------------------------------------------------------------------------------
/game/dmusic/band.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "info.h"
 4 | #include "reference.h"
 5 | #include "riff.h"
 6 | #include "structs.h"
 7 | 
 8 | #include <vector>
 9 | 
10 | namespace Dx8 {
11 | 
12 | class Band final {
13 |   public:
14 |     Band(Riff &input);
15 | 
16 |     struct Instrument final {
17 |       Instrument(Riff &input);
18 | 
19 |       DMUS_IO_INSTRUMENT header;
20 |       Reference          reference;
21 |       };
22 | 
23 |     GUID                    guid;
24 |     DMUS_IO_VERSION         vers;
25 |     Unfo                    info;
26 |     std::vector<Instrument> intrument;
27 | 
28 |   private:
29 |     void implRead(Riff &input);
30 |   };
31 | 
32 | }
33 | 


--------------------------------------------------------------------------------
/game/dmusic/directmusic.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "dlscollection.h"
 4 | #include "patternlist.h"
 5 | #include "segment.h"
 6 | #include "style.h"
 7 | 
 8 | #include <Tempest/File>
 9 | #include <vector>
10 | 
11 | namespace Dx8 {
12 | 
13 | /**
14 |  * http://doc.51windows.net/Directx9_SDK/htm/directmusicfilestructures.htm
15 |  */
16 | class DirectMusic final {
17 |   public:
18 |     DirectMusic();
19 | 
20 |     using StyleList = std::vector<std::pair<std::u16string,Style>>;
21 |     using DlsList   = std::vector<std::unique_ptr<std::pair<std::u16string,DlsCollection>>>;
22 | 
23 |     PatternList          load(const Segment& s);
24 |     PatternList          load(const char16_t* fsgt);
25 | 
26 |     void addPath(std::u16string path);
27 | 
28 |     const Style&         style        (const Reference &id);
29 |     const DlsCollection& dlsCollection(const Reference &id);
30 |     const DlsCollection& dlsCollection(const std::u16string &file);
31 | 
32 |     const StyleList&     stlList() const { return styles; }
33 |     const DlsList&       dlsCollection() { return dls;    }
34 | 
35 |   private:
36 |     StyleList                   styles;
37 |     DlsList                     dls;
38 |     std::vector<std::u16string> path;
39 | 
40 |     Tempest::RFile              implOpen(const char16_t* file);
41 |   };
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/game/dmusic/info.cpp:
--------------------------------------------------------------------------------
 1 | #include "info.h"
 2 | 
 3 | #include <stdexcept>
 4 | 
 5 | using namespace  Dx8;
 6 | 
 7 | Info::Info(Riff& input) {
 8 |   if(!input.is("LIST"))
 9 |     throw std::runtime_error("not a LIST");
10 |   input.readListId("INFO");
11 |   input.read([this](Riff& c){
12 |     implRead(c);
13 |     });
14 |   }
15 | 
16 | void Info::implRead(Riff &input) {
17 |   if(input.is("INAM"))
18 |     input.read(inam);
19 |   }
20 | 
21 | 
22 | Unfo::Unfo(Riff& input) {
23 |   if(!input.is("LIST"))
24 |     throw std::runtime_error("not a LIST");
25 |   input.readListId("UNFO");
26 |   input.read([this](Riff& c){
27 |     implRead(c);
28 |     });
29 |   }
30 | 
31 | void Unfo::implRead(Riff &input) {
32 |   if(input.is("UNAM"))
33 |     input.read(unam);
34 |   }
35 | 


--------------------------------------------------------------------------------
/game/dmusic/info.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "riff.h"
 4 | 
 5 | namespace Dx8 {
 6 | 
 7 | class Info final {
 8 |   public:
 9 |     Info()=default;
10 |     Info(Dx8::Riff &input);
11 | 
12 |     std::string inam;
13 | 
14 |   private:
15 |     void implRead(Dx8::Riff &input);
16 |   };
17 | 
18 | class Unfo final {
19 |   public:
20 |     Unfo()=default;
21 |     Unfo(Dx8::Riff &input);
22 | 
23 |     std::u16string unam;
24 | 
25 |   private:
26 |     void implRead(Dx8::Riff &input);
27 |   };
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/game/dmusic/music.cpp:
--------------------------------------------------------------------------------
 1 | #include "music.h"
 2 | 
 3 | using namespace Dx8;
 4 | 
 5 | Music::Internal::Internal(const Music::Internal& other)
 6 |   :pptn(other.pptn), groove(other.groove) {
 7 |   volume = other.volume.load();
 8 |   }
 9 | 
10 | void Music::addPattern(const PatternList& list) {
11 |   for(size_t i=0;i<list.size();++i)
12 |     addPattern(list,i);
13 |   }
14 | 
15 | void Music::addPattern(const PatternList& list, size_t id) {
16 |   auto ptr = std::shared_ptr<PatternList::PatternInternal>(list.intern,&list.intern->pptn[id]);
17 |   if(impl.use_count()>1) {
18 |     impl = std::make_shared<Internal>(*impl);
19 |     }
20 |   impl->pptn.push_back(ptr);
21 |   impl->groove = list.intern->groove;
22 | 
23 |   impl->timeTotal += ptr->timeTotal;
24 |   }
25 | 
26 | void Music::setVolume(float v) {
27 |   impl->volume.store(v);
28 |   }
29 | 
30 | 


--------------------------------------------------------------------------------
/game/dmusic/music.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <vector>
 5 | 
 6 | #include "patternlist.h"
 7 | 
 8 | namespace Dx8 {
 9 | 
10 | class PatternList;
11 | 
12 | class Music final {
13 |   public:
14 |     Music()=default;
15 | 
16 |     void   addPattern(const PatternList& list);
17 |     void   addPattern(const PatternList& list,size_t id);
18 | 
19 |     void   clear() { impl->pptn.clear(); }
20 |     size_t size() const { return impl->pptn.size(); }
21 | 
22 |     void   setVolume(float v);
23 | 
24 |   private:
25 |     using Pattern = std::shared_ptr<PatternList::PatternInternal>;
26 |     using Groove  = PatternList::Groove;
27 | 
28 |     struct Internal {
29 |       Internal()=default;
30 |       Internal(const Internal& other);
31 | 
32 |       std::vector<Pattern> pptn;
33 |       std::vector<Groove>  groove;
34 | 
35 |       std::atomic<float>   volume{1.f};
36 |       uint64_t             timeTotal=0;
37 |       };
38 |     std::shared_ptr<Internal> impl = std::make_shared<Internal>();
39 | 
40 |   friend class Mixer;
41 |   };
42 | }
43 | 


--------------------------------------------------------------------------------
/game/dmusic/pattern.cpp:
--------------------------------------------------------------------------------
 1 | #include "pattern.h"
 2 | 
 3 | #include <stdexcept>
 4 | 
 5 | using namespace Dx8;
 6 | 
 7 | Pattern::PartRef::PartRef(Riff &input) {
 8 |   if(!input.is("LIST") || !input.isListId("pref"))
 9 |     throw std::runtime_error("not a partref");
10 |   input.read([this](Riff& input){
11 |     if(input.is("prfc"))
12 |       input.read(&io,sizeof(io));
13 |     else if(input.is("LIST") && input.isListId("UNFO"))
14 |      unfo = Unfo(input);
15 |     });
16 |   }
17 | 
18 | Pattern::Pattern(Riff& input) {
19 |   input.read([this](Riff& c){
20 |     implRead(c);
21 |     });
22 |   }
23 | 
24 | uint32_t Pattern::timeLength(double tempo) const {
25 |   const uint32_t PulsesPerQuarterNote  = uint32_t(600*(100.0/tempo));
26 |   uint32_t mul = (header.timeSig.bBeatsPerMeasure*PulsesPerQuarterNote*4)/header.timeSig.bBeat;
27 |   return header.wNbrMeasures * mul;
28 |   }
29 | 
30 | void Pattern::implRead(Riff &input) {
31 |   if(input.is("ptnh"))
32 |     input.read(&header,sizeof(header));
33 |   else if(input.is("LIST")){
34 |     if(input.isListId("pref"))
35 |       partref.emplace_back(input);
36 |     else if(input.isListId("UNFO"))
37 |       info = Unfo(input);
38 |     }
39 |   }
40 | 
41 | 


--------------------------------------------------------------------------------
/game/dmusic/pattern.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "info.h"
 4 | #include "riff.h"
 5 | #include "structs.h"
 6 | 
 7 | namespace Dx8 {
 8 | 
 9 | class Pattern final {
10 |   public:
11 |     Pattern(Riff &riff);
12 | 
13 |     struct PartRef final {
14 |       PartRef(Riff &input);
15 |       DMUS_IO_PARTREF io;
16 |       Unfo            unfo;
17 |       };
18 | 
19 |     DMUS_IO_PATTERN      header;
20 |     Unfo                 info;
21 |     std::vector<PartRef> partref;
22 | 
23 |     uint32_t             timeLength(double tempo) const;
24 | 
25 |   private:
26 |     void                 implRead(Riff &riff);
27 |   };
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/game/dmusic/reference.cpp:
--------------------------------------------------------------------------------
 1 | #include "reference.h"
 2 | 
 3 | using namespace Dx8;
 4 | 
 5 | Reference::Reference(Riff &input) {
 6 |   input.read([&](Riff& ch){
 7 |     if(ch.is("refh"))
 8 |       ch.read(&header,sizeof(header));
 9 |     else if(ch.is("guid"))
10 |       ch.read(&guid,sizeof(guid));
11 |     else if(ch.is("name"))
12 |       ch.read(name);
13 |     else if(ch.is("file"))
14 |       ch.read(file);
15 |     else if(ch.is("catg"))
16 |       ch.read(category);
17 |     else if(ch.is("vers"))
18 |       ch.read(&version,sizeof(version));
19 |     });
20 |   }
21 | 


--------------------------------------------------------------------------------
/game/dmusic/reference.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "riff.h"
 4 | #include "structs.h"
 5 | 
 6 | namespace Dx8 {
 7 | 
 8 | struct Reference final {
 9 |   Reference()=default;
10 |   Reference(Riff &chunk);
11 | 
12 |   DMUS_IO_REFERENCE header;
13 |   GUID              guid;
14 |   std::u16string    name, file, category;
15 |   DMUS_IO_VERSION   version;
16 |   };
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/game/dmusic/riff.cpp:
--------------------------------------------------------------------------------
 1 | #include "riff.h"
 2 | 
 3 | #include <algorithm>
 4 | 
 5 | using namespace Dx8;
 6 | 
 7 | Riff::Riff(const uint8_t *data, size_t size)
 8 |   :data(data), sz(size) {
 9 |   readHdr(head);
10 |   sz = std::min(sz,head.size+at);
11 |   }
12 | 
13 | void Riff::readListId() {
14 |   if(std::memcmp(listId,"\0\0\0\0",4)==0)
15 |     read(&listId,4);
16 |   }
17 | 
18 | void Riff::readListId(const char *id) {
19 |   readListId();
20 |   if(std::memcmp(listId,id,4)!=0)
21 |     throw std::runtime_error("invalid track");
22 |   }
23 | 
24 | bool Riff::isListId(const char *id) {
25 |   readListId();
26 |   return (std::memcmp(listId,id,4)!=0)==0;
27 |   }
28 | 
29 | void Riff::read(std::u16string &str) {
30 |   size_t len = (sz-at)/2;
31 |   if(len<=1){
32 |     str.clear();
33 |     return;
34 |     }
35 |   str.resize(len-1);
36 |   read(&str[0],2*str.size());
37 |   }
38 | 
39 | void Riff::read(std::string &str) {
40 |   size_t len = (sz-at);
41 |   if(len<=1){
42 |     str.clear();
43 |     return;
44 |     }
45 |   str.resize(len-1);
46 |   read(&str[0],str.size());
47 |   }
48 | 
49 | void Riff::read(std::vector<uint8_t> &vec) {
50 |   size_t len = (sz-at);
51 |   vec.resize(len);
52 |   if(len>0)
53 |     read(&vec[0],vec.size());
54 |   }
55 | 
56 | void Riff::read(void *ctx, Riff::Callback cb) {
57 |   while(hasData()) {
58 |     Riff chunk(data+at,sz-at);
59 |     cb(ctx,chunk);
60 |     at+=chunk.head.size+8+(chunk.head.size%2);
61 |     }
62 |   }
63 | 
64 | void Riff::readHdr(Riff::ChunkHeader &h) {
65 |   read(h.id,   4);
66 |   read(&h.size,4);
67 |   }
68 | 
69 | void Riff::read(void *dest, size_t s) {
70 |   if(at+s>sz)
71 |     onError("read err");
72 |   std::memcpy(dest,data+at,s);
73 |   at+=s;
74 |   }
75 | 
76 | void Riff::skip(size_t s) {
77 |   if(at+s>sz)
78 |     onError("read err");
79 |   at+=s;
80 |   }
81 | 
82 | void Riff::onError(const char *msg) {
83 |   throw std::runtime_error(msg);
84 |   }
85 | 


--------------------------------------------------------------------------------
/game/dmusic/segment.cpp:
--------------------------------------------------------------------------------
 1 | #include "segment.h"
 2 | 
 3 | #include <stdexcept>
 4 | #include <iostream>
 5 | 
 6 | using namespace Dx8;
 7 | 
 8 | Segment::Segment(Riff &input) {
 9 |   if(!input.is("RIFF"))
10 |     throw std::runtime_error("not a riff");
11 | 
12 |   char listId[5]={};
13 |   input.read(&listId,4);
14 |   input.read([this](Riff& ch){
15 |     if(ch.is("LIST")){
16 |       implReadList(ch);
17 |       }
18 |     });
19 |   }
20 | 
21 | void Segment::implReadList(Riff& input) {
22 |   if(input.isListId("trkl")){
23 |     input.read([&](Riff& ch){
24 |       track.emplace_back(ch);
25 |       });
26 |     }
27 |   }
28 | 


--------------------------------------------------------------------------------
/game/dmusic/segment.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include "riff.h"
 5 | #include "track.h"
 6 | 
 7 | namespace Dx8 {
 8 | 
 9 | class Segment final {
10 |   public:
11 |     Segment()=default;
12 |     Segment(Riff& input);
13 | 
14 |     std::vector<Track> track;
15 | 
16 |   private:
17 |     void implReadList(Riff &ch);
18 |   };
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/game/dmusic/soundfont.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | #include <vector>
 5 | 
 6 | namespace Dx8 {
 7 | 
 8 | class DlsCollection;
 9 | class Wave;
10 | 
11 | class SoundFont final {
12 |   private:
13 |     struct Impl;
14 |     struct Instance;
15 | 
16 |   public:
17 |     enum  {
18 |       SampleRate = 44100,
19 |       BitsPerSec = SampleRate*2*16
20 |       };
21 |     struct Data;
22 | 
23 |     class Ticket final {
24 |       private:
25 |         std::shared_ptr<Instance> impl;
26 |         uint8_t                   note=0;
27 | 
28 |       public:
29 |         bool operator==(const std::nullptr_t&) const {
30 |           return impl==nullptr;
31 |           }
32 | 
33 |       friend class SoundFont;
34 |       };
35 | 
36 |     SoundFont();
37 |     SoundFont(std::shared_ptr<Data> &sh, uint32_t dwPatch);
38 |     ~SoundFont();
39 | 
40 |     static std::shared_ptr<Data> shared(const DlsCollection& dls, const std::vector<Wave>& wave);
41 | 
42 |     bool hasNotes() const;
43 |     void setVolume(float v);
44 |     void setPan(float p);
45 |     void mix(float* samples,size_t count);
46 | 
47 |     Ticket      noteOn(uint8_t note, uint8_t velosity);
48 |     static void noteOff(Ticket& t);
49 | 
50 |   private:
51 |     std::shared_ptr<Impl> impl;
52 |   };
53 | 
54 | }
55 | 


--------------------------------------------------------------------------------
/game/dmusic/style.cpp:
--------------------------------------------------------------------------------
 1 | #include "mixer.h"
 2 | #include "style.h"
 3 | 
 4 | #include <stdexcept>
 5 | #include <Tempest/Log>
 6 | 
 7 | using namespace Tempest;
 8 | using namespace Dx8;
 9 | 
10 | Style::Part::Part(Riff &input) {
11 |   input.read([this](Riff& c){
12 |     if(c.is("prth"))
13 |       c.read(&header,sizeof(header));
14 |     else if(c.is("note"))
15 |       c.readAll(notes);
16 |     else if(c.is("crve"))
17 |       c.readAll(curves);
18 |     });
19 |   }
20 | 
21 | Style::Style(Riff &input) {
22 |   if(!input.is("RIFF"))
23 |     throw std::runtime_error("not a riff");
24 |   input.readListId("DMST");
25 |   input.read([this](Riff& c){
26 |     implRead(c);
27 |     });
28 |   }
29 | 
30 | void Style::implRead(Riff &input) {
31 |   if(input.is("RIFF")){
32 |     if(input.isListId("DMBD"))
33 |       band.emplace_back(input);
34 |     }
35 |   else if(input.is("guid")){
36 |     input.read(&guid,sizeof(guid));
37 |     }
38 |   else if(input.is("styh")){
39 |     input.read(&styh,sizeof(styh));
40 |     }
41 |   else if(input.is("LIST")){
42 |     if(input.isListId("pttn"))
43 |       patterns.emplace_back(input);
44 |     else if(input.isListId("part"))
45 |       parts.emplace_back(Part(input));
46 |     }
47 |   }
48 | 
49 | const Style::Part* Style::findPart(const GUID &guid) const {
50 |   for(auto& i:parts)
51 |     if(i.header.guidPartID==guid)
52 |       return &i;
53 |   return nullptr;
54 |   }
55 | 


--------------------------------------------------------------------------------
/game/dmusic/style.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "band.h"
 4 | #include "info.h"
 5 | #include "pattern.h"
 6 | #include "riff.h"
 7 | #include "structs.h"
 8 | 
 9 | #include <vector>
10 | 
11 | namespace Dx8 {
12 | 
13 | class Mixer;
14 | 
15 | class Style final {
16 |   public:
17 |     Style(Riff& riff);
18 | 
19 |     struct Part final {
20 |       Part(Riff& riff);
21 | 
22 |       DMUS_IO_STYLEPART               header;
23 |       std::vector<DMUS_IO_STYLENOTE>  notes;
24 |       std::vector<DMUS_IO_STYLECURVE> curves;
25 |       };
26 | 
27 |     GUID                 guid;
28 |     DMUS_IO_STYLE        styh;
29 |     std::vector<Band>    band;
30 |     std::vector<Part>    parts;
31 |     std::vector<Pattern> patterns;
32 | 
33 |     const Part *findPart(const GUID& guid) const;
34 | 
35 |   private:
36 |     void implRead(Riff &input);
37 |   };
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/game/dmusic/track.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | #include <vector>
 5 | 
 6 | #include "reference.h"
 7 | #include "riff.h"
 8 | #include "structs.h"
 9 | 
10 | namespace Dx8 {
11 | 
12 | class Track final {
13 |   public:
14 |     Track(Riff& input);
15 | 
16 |     struct StyleRef  {
17 |       StyleRef(Riff &chunk);
18 | 
19 |       uint16_t  stmp=0;
20 |       Reference reference;
21 |       };
22 | 
23 |     struct StyleTrack {
24 |       StyleTrack(Riff &chunk);
25 |       std::vector<StyleRef> styles;
26 |       };
27 | 
28 |     class Chord {
29 |       public:
30 |         Chord(Riff &chunk);
31 | 
32 |         uint32_t                      header=0;
33 |         DMUS_IO_CHORD                 ioChord;
34 |         std::vector<DMUS_IO_SUBCHORD> subchord;
35 |       private:
36 |         void implReadList(Riff &input);
37 |       };
38 | 
39 |     class CommandTrack {
40 |       public:
41 |         CommandTrack(Riff &chunk);
42 | 
43 |         std::vector<DMUS_IO_COMMAND> commands;
44 |       };
45 | 
46 |     DMUS_IO_TRACK_HEADER          head;
47 |     std::shared_ptr<StyleTrack>   sttr;
48 |     std::shared_ptr<Chord>        cord;
49 |     std::shared_ptr<CommandTrack> cmnd;
50 | 
51 |   private:
52 |     void implReadList(Riff &input);
53 |   };
54 | 
55 | }
56 | 


--------------------------------------------------------------------------------
/game/game/aiouputpipe.cpp:
--------------------------------------------------------------------------------
1 | #include "aiouputpipe.h"
2 | 


--------------------------------------------------------------------------------
/game/game/aiouputpipe.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string_view>
 3 | 
 4 | class Npc;
 5 | 
 6 | class AiOuputPipe {
 7 |   public:
 8 |     virtual ~AiOuputPipe()=default;
 9 | 
10 |     virtual bool output   (Npc& npc, std::string_view text)=0;
11 |     virtual bool outputSvm(Npc& npc, std::string_view text)=0;
12 |     virtual bool outputOv (Npc& npc, std::string_view text)=0;
13 |     virtual bool printScr (Npc& npc, int time, std::string_view msg, int x,int y, std::string_view font)=0;
14 | 
15 |     virtual bool isFinished()=0;
16 |     virtual bool close()=0;
17 |   };
18 | 


--------------------------------------------------------------------------------
/game/game/aistate.cpp:
--------------------------------------------------------------------------------
 1 | #include "aistate.h"
 2 | 
 3 | #include "game/gamescript.h"
 4 | 
 5 | AiState::AiState(GameScript& owner,size_t id) {
 6 |   auto* fn = owner.findSymbol(id);
 7 |   if (fn != nullptr) {
 8 |     mname    = fn->name().c_str();
 9 | 
10 |     funcIni  = id;
11 |     funcLoop = owner.findSymbolIndex(fn->name() + "_Loop");
12 |     funcEnd  = owner.findSymbolIndex(fn->name() + "_End");
13 |     } else {
14 |     mname    = "";
15 | 
16 |     funcIni  = id;
17 |     funcLoop = uint32_t(-1);
18 |     funcEnd  = uint32_t(-1);
19 |     }
20 |   }
21 | 


--------------------------------------------------------------------------------
/game/game/aistate.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdlib>
 4 | #include <string>
 5 | 
 6 | class GameScript;
 7 | 
 8 | class AiState final {
 9 |   public:
10 |     AiState(GameScript &owner, size_t id);
11 | 
12 |     size_t funcIni =0;
13 |     size_t funcLoop=0;
14 |     size_t funcEnd =0;
15 | 
16 |     const char* name() const { return mname; }
17 |   private:
18 |     const char* mname=""; //for debugging
19 |   };
20 | 


--------------------------------------------------------------------------------
/game/game/compatibility/lego.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/DaedalusVm.hh>
 4 | 
 5 | #include "scriptplugin.h"
 6 | 
 7 | class GameScript;
 8 | class Ikarus;
 9 | 
10 | class LeGo : public ScriptPlugin {
11 |   public:
12 |     LeGo(GameScript& owner, Ikarus& ikarus, zenkit::DaedalusVm& vm);
13 | 
14 |     static bool isRequired(zenkit::DaedalusVm& vm);
15 | 
16 |   private:
17 |     int  create(int inst);
18 |     void tick(uint64_t dt) override;
19 | 
20 |     // ## FRAMEFUNCTIONS
21 |     void _FF_Create   (zenkit::DaedalusFunction function, int delay, int cycles, int hasData, int data, bool gametime);
22 |     void FF_Remove    (zenkit::DaedalusFunction function);
23 |     void FF_RemoveAll (zenkit::DaedalusFunction function);
24 |     void FF_RemoveData(zenkit::DaedalusFunction function, int data);
25 |     bool FF_ActiveData(zenkit::DaedalusFunction function, int data);
26 |     bool FF_Active    (zenkit::DaedalusFunction function);
27 |     struct FFItem {
28 |       uint32_t fncID    = 0;
29 |       uint64_t next     = 0;
30 |       int      delay    = 0;
31 |       int      cycles   = 0;
32 |       int      data     = 0;
33 |       bool     hasData  = 0;
34 |       bool     gametime = 0;
35 |       };
36 | 
37 |     GameScript&         owner;
38 |     Ikarus&             ikarus;
39 |     zenkit::DaedalusVm& vm;
40 | 
41 |     std::vector<FFItem> frameFunc;
42 |   };
43 | 
44 | 


--------------------------------------------------------------------------------
/game/game/compatibility/mem32.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <functional>
 4 | #include <vector>
 5 | #include <memory>
 6 | 
 7 | class Mem32 {
 8 |   public:
 9 |     Mem32();
10 |     ~Mem32();
11 | 
12 |     using                     ptr32_t  = uint32_t;
13 |     static constexpr uint32_t memAlign = 8;
14 | 
15 |     ptr32_t pin  (void* mem, ptr32_t address, uint32_t size, const char* comment = nullptr);
16 |     ptr32_t pin  (void* mem, uint32_t size, const char* comment = nullptr);
17 | 
18 |     ptr32_t alloc(uint32_t size);
19 |     ptr32_t alloc(ptr32_t address, uint32_t size, const char* comment = nullptr);
20 | 
21 |     void    free (ptr32_t at);
22 | 
23 |     ptr32_t realloc(ptr32_t address, uint32_t size);
24 | 
25 |     void    writeInt (ptr32_t address, int32_t v);
26 |     int32_t readInt  (ptr32_t address);
27 |     void    copyBytes(ptr32_t src, ptr32_t dst, uint32_t size);
28 | 
29 |   private:
30 |     enum Status:uint8_t {
31 |       S_Unused,
32 |       S_Allocated,
33 |       S_Pin,
34 |       };
35 | 
36 |     struct Region {
37 |       Region();
38 |       Region(ptr32_t b, uint32_t sz):address(b),size(sz){}
39 | 
40 |       //std::function<void(ptr32_t offset)> callback;
41 |       ptr32_t                             address = 0;
42 |       uint32_t                            size    = 0;
43 |       void*                               real    = nullptr;
44 |       const char*                         comment = nullptr;
45 |       Status                              status  = S_Unused;
46 |       };
47 | 
48 |     Region*  implAlloc(uint32_t size);
49 |     Region*  implAllocAt(ptr32_t address, uint32_t size);
50 |     bool     implRealloc(ptr32_t address, uint32_t size);
51 |     Region*  translate(ptr32_t address);
52 |     void     compactage();
53 | 
54 |     std::vector<Region> region;
55 |   };
56 | 
57 | 


--------------------------------------------------------------------------------
/game/game/compatibility/phoenix.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Vec>
 4 | 
 5 | #include <zenkit/Material.hh>
 6 | #include <zenkit/SoftSkinMesh.hh>
 7 | 
 8 | namespace phoenix_compat {
 9 |   struct SkeletalVertex
10 |   {
11 |     Tempest::Vec3 Normal;
12 |     Tempest::Vec2 TexCoord;
13 |     uint32_t Color;
14 |     Tempest::Vec3 LocalPositions[4];
15 |     unsigned char BoneIndices[4];
16 |     float Weights[4];
17 |   };
18 | 
19 |   struct PackedSkeletalMesh
20 |   {
21 |     struct SubMesh
22 |     {
23 |       zenkit::Material material;
24 |       size_t           indexOffset = 0;
25 |       size_t           indexSize   = 0;
26 |     };
27 | 
28 |     Tempest::Vec3               bbox[2];
29 |     std::vector<SkeletalVertex> vertices;
30 |     std::vector<uint32_t>       indices;
31 |     std::vector<SubMesh>        subMeshes;
32 |   };
33 |   
34 |   zenkit::AxisAlignedBoundingBox get_total_aabb(const zenkit::SoftSkinMesh&);
35 |   
36 |   PackedSkeletalMesh pack_softskin_mesh(const zenkit::SoftSkinMesh&);
37 | }
38 | 


--------------------------------------------------------------------------------
/game/game/compatibility/scriptplugin.cpp:
--------------------------------------------------------------------------------
1 | #include "scriptplugin.h"
2 | 
3 | void ScriptPlugin::tick(uint64_t dt) {
4 |   (void)dt;
5 |   }
6 | 


--------------------------------------------------------------------------------
/game/game/compatibility/scriptplugin.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | class ScriptPlugin {
 6 |   public:
 7 |     ScriptPlugin() = default;
 8 |     virtual ~ScriptPlugin() = default;
 9 | 
10 |     virtual void tick(uint64_t dt);
11 |   };
12 | 
13 | 


--------------------------------------------------------------------------------
/game/game/damagecalculator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/addon/daedalus.hh>
 4 | 
 5 | #include "game/constants.h"
 6 | 
 7 | class Npc;
 8 | class Bullet;
 9 | 
10 | class DamageCalculator {
11 |   public:
12 |     enum {
13 |       MinDamage = 5,
14 |       };
15 | 
16 |     struct Val final {
17 |       Val()=default;
18 |       Val(int32_t v,bool b):value(v),hasHit(b){}
19 |       Val(int32_t v,bool b,bool i):value(v),hasHit(b),invincible(i){}
20 | 
21 |       int32_t value      = 0;
22 |       bool    hasHit     = false;
23 |       bool    invincible = false;
24 |       };
25 | 
26 |     struct Damage final {
27 |       int32_t  val[zenkit::DamageType::NUM] = {};
28 |       int32_t& operator[](size_t i) { return val[i]; }
29 |       void     operator *= (int32_t v) { for(auto& i:val) i*=v; }
30 |       void     operator /= (int32_t v) { for(auto& i:val) i/=v; }
31 |       };
32 | 
33 |     static Val     damageValue(Npc& src, Npc& other, const Bullet* b, bool isSpell, const DamageCalculator::Damage& splDmg, const CollideMask bMsk);
34 |     static Val     damageFall(Npc& src, float speed);
35 |     static auto    rangeDamageValue(Npc& src) -> Damage;
36 |     static int32_t damageTypeMask(Npc& npc);
37 | 
38 |   private:
39 |     static bool    checkDamageMask(Npc& src, Npc& other, const Bullet* b);
40 | 
41 |     static Val     rangeDamage(Npc& src, Npc& other, const Bullet& b, const CollideMask bMsk);
42 |     static Val     rangeDamage(Npc& src, Npc& other, Damage dmg, const CollideMask bMsk);
43 |     static Val     swordDamage(Npc& src, Npc& other);
44 |   };
45 | 
46 | 


--------------------------------------------------------------------------------
/game/game/definitions/cameradefinitions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/addon/daedalus.hh>
 4 | 
 5 | class CameraDefinitions final {
 6 |   public:
 7 |     CameraDefinitions();
 8 | 
 9 |     const zenkit::ICamera& dialogCam()    const { return camModDialog;    }
10 |     const zenkit::ICamera& inventoryCam() const { return camModInventory; }
11 |     const zenkit::ICamera& stdCam()       const { return camModNormal; }
12 |     const zenkit::ICamera& fpCam()        const { return camModFp;     }
13 |     const zenkit::ICamera& backCam()      const { return camModBack;   }
14 |     const zenkit::ICamera& meleeCam()     const { return camModMelee;  }
15 |     const zenkit::ICamera& rangeCam()     const { return camModRange;  }
16 |     const zenkit::ICamera& mageCam()      const { return camModMage;   }
17 |     const zenkit::ICamera& deathCam()     const { return camModDeath;  }
18 |     const zenkit::ICamera& swimCam()      const { return camModSwim;   }
19 |     const zenkit::ICamera& diveCam()      const { return camModDive;   }
20 |     const zenkit::ICamera& fallCam()      const { return camModFall;   }
21 |     const zenkit::ICamera& mobsiCam(std::string_view tag, std::string_view pos) const;
22 | 
23 |   private:
24 |     zenkit::ICamera getCam(std::string_view name);
25 | 
26 |     std::vector<std::pair<std::string, zenkit::ICamera>> cameras;
27 |     const zenkit::ICamera* find(std::string_view name) const;
28 | 
29 |     zenkit::ICamera camModNormal, camModFp, camModBack;
30 |     zenkit::ICamera camModDialog, camModInventory, camModDeath, camModSwim, camModDive, camModFall;
31 |     zenkit::ICamera camModMelee, camModRange, camModMage;
32 |   };
33 | 


--------------------------------------------------------------------------------
/game/game/definitions/musicdefinitions.cpp:
--------------------------------------------------------------------------------
 1 | #include "musicdefinitions.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | 
 5 | #include "gothic.h"
 6 | 
 7 | using namespace Tempest;
 8 | 
 9 | MusicDefinitions::MusicDefinitions() {
10 |   vm = Gothic::inst().createPhoenixVm("Music.dat");
11 | 
12 |   vm->enumerate_instances_by_class_name("C_MusicTheme", [this](zenkit::DaedalusSymbol& s) {
13 |     themes.push_back(vm->init_instance<zenkit::IMusicTheme>(&s));
14 |     });
15 |   }
16 | 
17 | MusicDefinitions::~MusicDefinitions() {
18 |   }
19 | 
20 | const zenkit::IMusicTheme* MusicDefinitions::operator [](std::string_view name) const {
21 |   if(!vm)
22 |     return nullptr;
23 | 
24 |   auto id = vm->find_symbol_by_name(name);
25 |   if(id==nullptr)
26 |     return nullptr;
27 |   for(auto& i:themes) {
28 |     auto* sym = vm->find_symbol_by_instance(i);
29 |     if(sym->index() == id->index())
30 |       return i.get();
31 |     }
32 |   return nullptr;
33 |   }
34 | 


--------------------------------------------------------------------------------
/game/game/definitions/musicdefinitions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/DaedalusVm.hh>
 4 | #include <zenkit/addon/daedalus.hh>
 5 | 
 6 | #include <memory>
 7 | 
 8 | class MusicDefinitions final {
 9 |   public:
10 |     MusicDefinitions();
11 |     ~MusicDefinitions();
12 | 
13 |     const zenkit::IMusicTheme* operator[](std::string_view name) const;
14 | 
15 |   private:
16 |     std::unique_ptr<zenkit::DaedalusVm>  vm;
17 |     std::vector<std::shared_ptr<zenkit::IMusicTheme>> themes;
18 |   };
19 | 


--------------------------------------------------------------------------------
/game/game/definitions/particlesdefinitions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/DaedalusVm.hh>
 4 | #include <zenkit/addon/daedalus.hh>
 5 | 
 6 | #include <unordered_map>
 7 | #include <memory>
 8 | #include <mutex>
 9 | 
10 | #include "graphics/visualfx.h"
11 | 
12 | class ParticleFx;
13 | 
14 | class ParticlesDefinitions final {
15 |   public:
16 |     ParticlesDefinitions();
17 |     ~ParticlesDefinitions();
18 | 
19 |     const ParticleFx* get(std::string_view name, bool relaxed);
20 |     const ParticleFx* get(const ParticleFx* base, const VisualFx::Key* key);
21 | 
22 |   private:
23 |     std::recursive_mutex                sync;
24 |     std::unique_ptr<zenkit::DaedalusVm> vm;
25 | 
26 |     std::unordered_map<std::string,          std::unique_ptr<ParticleFx>> pfx;
27 |     std::unordered_map<const VisualFx::Key*, std::unique_ptr<ParticleFx>> pfxKey;
28 | 
29 |     const ParticleFx* implGet(std::string_view name, bool relaxed);
30 |     const ParticleFx* implGet(const ParticleFx& base, const VisualFx::Key& key);
31 | 
32 |     std::shared_ptr<zenkit::IParticleEffect> implGetDirect(std::string_view name, bool relaxed);
33 |   };
34 | 


--------------------------------------------------------------------------------
/game/game/definitions/sounddefinitions.cpp:
--------------------------------------------------------------------------------
 1 | #include "sounddefinitions.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | #include <gothic.h>
 5 | 
 6 | using namespace Tempest;
 7 | 
 8 | SoundDefinitions::SoundDefinitions() {
 9 |   auto vm = Gothic::inst().createPhoenixVm("Sfx.dat");
10 | 
11 |   vm->enumerate_instances_by_class_name("C_SFX", [this, &vm](zenkit::DaedalusSymbol& s) {
12 |     try {
13 |       this->sfx[s.name()] = vm->init_instance<zenkit::ISoundEffect>(&s);
14 |       }
15 |     catch(const zenkit::DaedalusScriptError&) {
16 |       // There was an error during initialization. Ignore it.
17 |       }
18 |   });
19 |   }
20 | 
21 | const zenkit::ISoundEffect& SoundDefinitions::operator[](std::string_view name) const {
22 |   std::string buf(name); // FIXME
23 |   auto i = sfx.find(buf);
24 |   if(i!=sfx.end())
25 |     return *i->second;
26 |   static const zenkit::ISoundEffect s {};
27 |   return s;
28 |   }
29 | 
30 | 


--------------------------------------------------------------------------------
/game/game/definitions/sounddefinitions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/addon/daedalus.hh>
 4 | 
 5 | #include <unordered_map>
 6 | 
 7 | class SoundDefinitions final {
 8 |   public:
 9 |     SoundDefinitions();
10 | 
11 |     const zenkit::ISoundEffect& operator [](std::string_view name) const;
12 | 
13 |   private:
14 |     std::unordered_map<std::string, std::shared_ptr<zenkit::ISoundEffect>> sfx;
15 |   };
16 | 
17 | 


--------------------------------------------------------------------------------
/game/game/definitions/spelldefinitions.cpp:
--------------------------------------------------------------------------------
 1 | #include "spelldefinitions.h"
 2 | #include "utils/string_frm.h"
 3 | 
 4 | #include <Tempest/Log>
 5 | #include <cctype>
 6 | 
 7 | using namespace Tempest;
 8 | 
 9 | SpellDefinitions::SpellDefinitions(zenkit::DaedalusVm& vm) : vm(vm) {
10 |   vm.enumerate_instances_by_class_name("C_Spell", [this, &vm](zenkit::DaedalusSymbol& sym){
11 |     spl.push_back(vm.init_instance<zenkit::ISpell>(&sym));
12 |     });
13 |   }
14 | 
15 | SpellDefinitions::~SpellDefinitions() {
16 |   }
17 | 
18 | const zenkit::ISpell& SpellDefinitions::find(std::string_view instanceName) const {
19 |   string_frm format("SPELL_",instanceName);
20 |   for(auto& i:format)
21 |     i = char(std::toupper(i));
22 | 
23 |   for(auto& i:spl) { // TODO: optimize
24 |     auto sym = vm.find_symbol_by_instance(i);
25 |     if(sym->name()==format)
26 |       return *i;
27 |     }
28 |   Log::d("invalid spell [",instanceName.data(),"]");
29 |   static zenkit::ISpell szero={};
30 |   return szero;
31 |   }
32 | 


--------------------------------------------------------------------------------
/game/game/definitions/spelldefinitions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/DaedalusVm.hh>
 4 | #include <zenkit/addon/daedalus.hh>
 5 | 
 6 | class SpellDefinitions final {
 7 |   public:
 8 |     SpellDefinitions(zenkit::DaedalusVm &vm);
 9 |     ~SpellDefinitions();
10 | 
11 |     const zenkit::ISpell& find(std::string_view instanceName) const;
12 | 
13 |   private:
14 |     zenkit::DaedalusVm&                          vm;
15 |     std::vector<std::shared_ptr<zenkit::ISpell>> spl;
16 |   };
17 | 


--------------------------------------------------------------------------------
/game/game/definitions/svmdefinitions.cpp:
--------------------------------------------------------------------------------
 1 | #include "svmdefinitions.h"
 2 | #include "utils/string_frm.h"
 3 | 
 4 | SvmDefinitions::SvmDefinitions(zenkit::DaedalusVm& vm):vm(vm) {
 5 |     vm.register_as_opaque("C_SVM");
 6 |   }
 7 | 
 8 | SvmDefinitions::~SvmDefinitions() {
 9 |   }
10 | 
11 | std::string_view SvmDefinitions::find(std::string_view speech, int intId) {
12 |   if(!speech.empty() && speech[0]=='$' && intId>=0) {
13 |     const size_t id=size_t(intId);
14 | 
15 |     string_frm name("SVM_",int(id));
16 |     if(svm.size()<=id)
17 |       svm.resize(id+1);
18 | 
19 |     if(svm[id] == nullptr) {
20 |       auto* i = vm.find_symbol_by_name(name);
21 |       if (i == nullptr)
22 |           return "";
23 |       svm[id] = vm.init_opaque_instance(i);
24 |       }
25 | 
26 |     speech = speech.substr(1);
27 |     name = string_frm("C_SVM.",speech);
28 | 
29 |     auto* i = vm.find_symbol_by_name(name);
30 |     if(i==nullptr)
31 |       return "";
32 |     return i->get_string(0,svm[size_t(id)].get());
33 |     }
34 | 
35 |   return "";
36 |   }
37 | 


--------------------------------------------------------------------------------
/game/game/definitions/svmdefinitions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/DaedalusVm.hh>
 4 | #include <zenkit/addon/daedalus.hh>
 5 | 
 6 | #include <memory>
 7 | 
 8 | class SvmDefinitions final {
 9 |   public:
10 |     SvmDefinitions(zenkit::DaedalusVm& vm);
11 |     ~SvmDefinitions();
12 | 
13 |     std::string_view find(std::string_view speech, int id);
14 | 
15 |   private:
16 |     zenkit::DaedalusVm&                                    vm;
17 |     std::vector<std::shared_ptr<zenkit::DaedalusInstance>> svm;
18 |   };
19 | 
20 | 


--------------------------------------------------------------------------------
/game/game/definitions/visualfxdefinitions.cpp:
--------------------------------------------------------------------------------
 1 | #include "visualfxdefinitions.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | 
 5 | #include "graphics/visualfx.h"
 6 | #include "gothic.h"
 7 | 
 8 | using namespace Tempest;
 9 | 
10 | VisualFxDefinitions::VisualFxDefinitions() {
11 |   vm = Gothic::inst().createPhoenixVm("VisualFx.dat");
12 |   }
13 | 
14 | VisualFxDefinitions::~VisualFxDefinitions() {
15 |   }
16 | 
17 | const VisualFx* VisualFxDefinitions::get(std::string_view name) {
18 |   std::string cname = std::string(name);
19 |   auto it = vfx.find(cname);
20 |   if(it!=vfx.end())
21 |     return it->second.get();
22 | 
23 |   auto def = implGet(cname);
24 |   if(def == nullptr)
25 |     return nullptr;
26 | 
27 |   auto ret = vfx.insert(std::make_pair<std::string,std::unique_ptr<VisualFx>>(std::move(cname),nullptr));
28 |   ret.first->second.reset(new VisualFx(*def,*vm,name));
29 | 
30 |   auto& vfx = *ret.first->second;
31 |   vfx.dbgName = name.data();
32 | 
33 |   return &vfx;
34 |   }
35 | 
36 | std::shared_ptr<zenkit::IEffectBase> VisualFxDefinitions::implGet(std::string_view name) {
37 |   if(!vm || name.empty())
38 |     return nullptr;
39 | 
40 |   auto id = vm->find_symbol_by_name(name);
41 |   if(id==nullptr) {
42 |     Log::e("invalid visual effect: \"",name,"\"");
43 |     return nullptr;
44 |     }
45 | 
46 |   try {
47 |     return vm->init_instance<zenkit::IEffectBase>(id);
48 |     }
49 |   catch (const zenkit::DaedalusScriptError&) {
50 |     return nullptr;
51 |     }
52 |   }
53 | 


--------------------------------------------------------------------------------
/game/game/definitions/visualfxdefinitions.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/DaedalusVm.hh>
 4 | #include <zenkit/addon/daedalus.hh>
 5 | 
 6 | #include <unordered_map>
 7 | #include <memory>
 8 | 
 9 | class VisualFx;
10 | 
11 | class VisualFxDefinitions final {
12 |   public:
13 |     VisualFxDefinitions();
14 |     ~VisualFxDefinitions();
15 | 
16 |     const VisualFx *get(std::string_view name);
17 | 
18 |   private:
19 |     std::unique_ptr<zenkit::DaedalusVm>                       vm;
20 |     std::unordered_map<std::string,std::unique_ptr<VisualFx>> vfx;
21 | 
22 |     std::shared_ptr<zenkit::IEffectBase> implGet(std::string_view name);
23 |   };
24 | 


--------------------------------------------------------------------------------
/game/game/gametime.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <limits>
 5 | #include <time.h>
 6 | 
 7 | class gtime final {
 8 |   public:
 9 |     gtime()=default;
10 |     gtime(int32_t hour,int32_t min):time(hour*hourMilis+min*minMilis){}
11 |     gtime(int64_t day,int32_t hour,int32_t min):time(day*dayMilis+hour*hourMilis+min*minMilis){}
12 |     gtime(int64_t day,int64_t hour,int64_t min):time(day*dayMilis+hour*hourMilis+min*minMilis){}
13 | 
14 |     int64_t toInt() const { return time; }
15 |     void    addMilis(uint64_t t){ time+=t; }
16 | 
17 |     int64_t day()       const { return time/dayMilis; }
18 |     gtime   timeInDay() const { return gtime(time%dayMilis); }
19 | 
20 |     int64_t hour()      const { return (time/hourMilis)%24; }
21 |     int64_t minute()    const { return (time/minMilis )%60; }
22 | 
23 |     static const gtime endOfTime() { return gtime(std::numeric_limits<int64_t>::max()); }
24 | 
25 |   private:
26 |     explicit gtime(int64_t milis):time(milis){}
27 | 
28 |     int64_t time=0;
29 |     static const int64_t dayMilis =24*60*60*1000;
30 |     static const int64_t hourMilis=60*60*1000;
31 |     static const int64_t minMilis =60*1000;
32 | 
33 |   friend bool operator == (gtime a,gtime b);
34 |   friend bool operator != (gtime a,gtime b);
35 |   friend bool operator <  (gtime a,gtime b);
36 |   friend bool operator <= (gtime a,gtime b);
37 |   };
38 | 
39 | inline bool operator == (gtime a,gtime b){
40 |   return a.time==b.time;
41 |   }
42 | 
43 | inline bool operator != (gtime a,gtime b){
44 |   return a.time!=b.time;
45 |   }
46 | 
47 | inline bool operator < (gtime a,gtime b){
48 |   return a.time<b.time;
49 |   }
50 | 
51 | inline bool operator <=(gtime a,gtime b){
52 |   return a.time<=b.time;
53 |   }
54 | 


--------------------------------------------------------------------------------
/game/game/perceptionmsg.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Point>
 4 | #include <cstdint>
 5 | 
 6 | class Npc;
 7 | 
 8 | class PerceptionMsg final {
 9 |   public:
10 |     int32_t       what=0;
11 |     Tempest::Vec3 pos;
12 |     Npc*          self  =nullptr;
13 |     Npc*          other =nullptr;
14 |     Npc*          victim=nullptr;
15 |     size_t        item  =size_t(-1);
16 |   };
17 | 


--------------------------------------------------------------------------------
/game/game/questlog.cpp:
--------------------------------------------------------------------------------
 1 | #include "questlog.h"
 2 | #include "serialize.h"
 3 | 
 4 | QuestLog::QuestLog() {
 5 |   }
 6 | 
 7 | QuestLog::Quest &QuestLog::add(std::string_view name, Section s) {
 8 |   if(auto m = find(name))
 9 |     return *m;
10 |   Quest q;
11 |   q.name    = name;
12 |   q.section = s;
13 |   quests.emplace_back(q);
14 |   return quests.back();
15 |   }
16 | 
17 | void QuestLog::setStatus(std::string_view name, QuestLog::Status s) {
18 |   auto m = find(name);
19 |   if(m==nullptr && s==Status::Obsolete)
20 |     return;
21 |   auto& q  = add(name,Mission);
22 |   q.status = s;
23 |   }
24 | 
25 | void QuestLog::addEntry(std::string_view name, std::string_view entry) {
26 |   if(auto m = find(name))
27 |     m->entry.emplace_back(entry);
28 |   }
29 | 
30 | QuestLog::Quest *QuestLog::find(std::string_view name) {
31 |   for(auto& i:quests)
32 |     if(i.name==name)
33 |       return &i;
34 |   return nullptr;
35 |   }
36 | 
37 | void QuestLog::save(Serialize &fout) {
38 |   uint32_t sz=uint32_t(quests.size());
39 |   fout.write(sz);
40 |   for(auto& i:quests){
41 |     fout.write(i.name,uint8_t(i.section),uint8_t(i.status),i.entry);
42 |     }
43 |   }
44 | 
45 | void QuestLog::load(Serialize &fin) {
46 |   uint32_t sz=0;
47 |   fin.read(sz);
48 |   quests.resize(sz);
49 | 
50 |   for(auto& i:quests){
51 |     fin.read(i.name,reinterpret_cast<uint8_t&>(i.section),reinterpret_cast<uint8_t&>(i.status),i.entry);
52 |     }
53 |   }
54 | 


--------------------------------------------------------------------------------
/game/game/questlog.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <string>
 5 | #include <cstdint>
 6 | 
 7 | class Serialize;
 8 | 
 9 | class QuestLog final {
10 |   public:
11 |     QuestLog();
12 | 
13 |     enum class Status : uint8_t {
14 |       Running  = 1,
15 |       Success  = 2,
16 |       Failed   = 3,
17 |       Obsolete = 4
18 |       };
19 | 
20 |     enum Section : uint8_t {
21 |       Mission = 0,
22 |       Note    = 1
23 |       };
24 | 
25 |     struct Quest {
26 |       std::string name;
27 |       Section     section=Section::Mission;
28 |       Status      status =Status::Running;
29 | 
30 |       std::vector<std::string> entry;
31 |       };
32 | 
33 |     Quest& add      (std::string_view name, Section s);
34 |     void   setStatus(std::string_view name, Status  s);
35 |     void   addEntry (std::string_view name, std::string_view entry);
36 | 
37 |     void   save(Serialize &fout);
38 |     void   load(Serialize &fin);
39 | 
40 |     size_t questCount() const { return quests.size(); }
41 |     auto   quest(size_t i) const -> const Quest& { return quests[i]; }
42 | 
43 | 
44 |   private:
45 |     Quest* find(std::string_view name);
46 | 
47 |     std::vector<Quest> quests;
48 |   };
49 | 


--------------------------------------------------------------------------------
/game/game/savegameheader.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Pixmap>
 4 | #include <string>
 5 | 
 6 | #include "gametime.h"
 7 | 
 8 | class Serialize;
 9 | 
10 | class SaveGameHeader final {
11 |   public:
12 |     SaveGameHeader() = default;
13 |     SaveGameHeader(Serialize& fin);
14 | 
15 |     void save(Serialize& fout) const;
16 | 
17 |     uint16_t        version = 0;
18 |     std::string     name;
19 |     std::string     world;
20 |     tm              pcTime = {};
21 |     gtime           wrldTime;
22 |     uint64_t        playTime  = 0;
23 |     uint8_t         isGothic2 = 0;
24 | 
25 |   private:
26 |     static const char tag[];
27 |   };
28 | 
29 | 


--------------------------------------------------------------------------------
/game/game/worldstatestorage.cpp:
--------------------------------------------------------------------------------
 1 | #include "worldstatestorage.h"
 2 | 
 3 | #include <Tempest/MemWriter>
 4 | #include <Tempest/MemReader>
 5 | 
 6 | #include "gamesession.h"
 7 | #include "world/world.h"
 8 | #include "serialize.h"
 9 | 
10 | WorldStateStorage::WorldStateStorage(World &w)
11 |   :name(w.name()){
12 |   Tempest::MemWriter wr{storage};
13 |   Serialize          sr{wr};
14 |   w.save(sr);
15 |   }
16 | 
17 | void WorldStateStorage::save(Serialize &fout) const {
18 |   fout.setEntry("worlds/",name,".zip");
19 |   fout.write(storage);
20 |   }
21 | 
22 | void WorldStateStorage::load(Serialize& fin) {
23 |   fin.setEntry("worlds/",name,".zip");
24 |   fin.read(storage);
25 |   }
26 | 
27 | bool WorldStateStorage::compareName(std::string_view n) const {
28 |   if(n.size()!=name.size())
29 |     return false;
30 |   for(size_t i=0; i<n.size(); ++i) {
31 |     auto a = std::tolower(n[i]);
32 |     auto b = std::tolower(name[i]);
33 |     if(a!=b)
34 |       return false;
35 |     }
36 |   return true;
37 |   }
38 | 


--------------------------------------------------------------------------------
/game/game/worldstatestorage.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/ODevice>
 4 | 
 5 | #include <string>
 6 | #include <vector>
 7 | #include <cstdint>
 8 | #include <memory>
 9 | 
10 | class World;
11 | class GameSession;
12 | class Serialize;
13 | 
14 | class WorldStateStorage final {
15 |   public:
16 |     WorldStateStorage()=default;
17 |     WorldStateStorage(World &w);
18 |     WorldStateStorage(const WorldStateStorage&)=delete;
19 |     WorldStateStorage(WorldStateStorage&&)=default;
20 |     WorldStateStorage& operator = (WorldStateStorage&&)=default;
21 | 
22 |     bool                 isEmpty() const { return storage.empty(); }
23 |     void                 save(Serialize& fout) const;
24 |     void                 load(Serialize& fin);
25 | 
26 |     bool                 compareName(std::string_view name) const;
27 | 
28 |     std::string          name;
29 |     std::vector<uint8_t> storage;
30 |   };
31 | 


--------------------------------------------------------------------------------
/game/gamemusic.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/addon/daedalus.hh>
 4 | 
 5 | #include <Tempest/SoundDevice>
 6 | #include <Tempest/SoundEffect>
 7 | 
 8 | class GameMusic final {
 9 |   public:
10 |     GameMusic();
11 |     GameMusic(const GameMusic&)=delete;
12 |     ~GameMusic();
13 | 
14 |     static GameMusic& inst();
15 | 
16 |     enum Music : uint8_t {
17 |       SysLoading
18 |       };
19 | 
20 |     enum Tags : uint8_t {
21 |       Day = 0,
22 |       Ngt = 1<<0,
23 | 
24 |       Std = 0,
25 |       Fgt = 1<<1,
26 |       Thr = 1<<2
27 |       };
28 | 
29 |     static Tags mkTags(Tags daytime,Tags mode);
30 | 
31 |     void      setEnabled(bool e);
32 |     bool      isEnabled() const;
33 |     void      setMusic(Music m);
34 |     void      setMusic(const zenkit::IMusicTheme &theme, Tags t);
35 |     void      stopMusic();
36 | 
37 |   private:
38 |     struct MusicProvider;
39 |     struct OpenGothicMusicProvider;
40 |     struct GothicKitMusicProvider;
41 | 
42 |     void      setupSettings();
43 | 
44 |     static GameMusic* instance;
45 | 
46 |     struct {
47 |       zenkit::IMusicTheme theme = {};
48 |       Tags                tags  = Tags::Std;
49 |       } currentMusic;
50 | 
51 |     int                  provider = -1;
52 |     Tempest::SoundDevice device;
53 |     Tempest::SoundEffect sound;
54 |     MusicProvider*       impl = nullptr;
55 |   };
56 | 


--------------------------------------------------------------------------------
/game/graphics/bounds.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Matrix4x4>
 4 | #include <Tempest/Point>
 5 | 
 6 | #include <vector>
 7 | 
 8 | #include "resources.h"
 9 | 
10 | class Bounds final {
11 |   public:
12 |     Bounds();
13 | 
14 |     void assign(const Tempest::Vec3& cen, float sizeSz);
15 |     void assign(const Bounds& a, const Bounds& b);
16 |     void assign(const Tempest::Vec3* bbox);
17 |     void assign(const std::pair<Tempest::Vec3, Tempest::Vec3>& bbox);
18 |     void assign(const std::vector<Resources::Vertex>& vbo);
19 |     void assign(const std::vector<Resources::Vertex>& vbo, const std::vector<uint32_t>& ibo, size_t iboOffset, size_t iboLenght);
20 |     void setObjMatrix(const Tempest::Matrix4x4& m);
21 | 
22 |     Tempest::Vec3 bbox[2];
23 |     Tempest::Vec3 midTr;
24 |     float         r = 0, rConservative = 0;
25 | 
26 |   private:
27 |     void transformBbox(const Tempest::Matrix4x4& m);
28 |     void calcR();
29 | 
30 |     Tempest::Vec3 mid;
31 |   };
32 | 
33 | 


--------------------------------------------------------------------------------
/game/graphics/dynamic/frustrum.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Matrix4x4>
 4 | 
 5 | class Frustrum {
 6 |   public:
 7 |     void make(const Tempest::Matrix4x4& m, int32_t w, int32_t h);
 8 |     void clear();
 9 | 
10 |     bool testPoint(float x, float y, float z) const;
11 |     bool testPoint(float x, float y, float z, float R) const;
12 |     bool testPoint(const Tempest::Vec3& p, float R) const;
13 |     bool testPoint(const Tempest::Vec3& p, float R, float& dist) const;
14 | 
15 |     enum Ret:uint8_t {
16 |       T_Invisible,
17 |       T_Partial,
18 |       T_Full,
19 |       };
20 |     Ret  testBbox (const Tempest::Vec3& min, const Tempest::Vec3& max) const;
21 | 
22 |     float              f[6][4] = {};
23 |     Tempest::Matrix4x4 mat;
24 |     uint32_t           width  = 0;
25 |     uint32_t           height = 0;
26 |   };
27 | 
28 | 


--------------------------------------------------------------------------------
/game/graphics/inventoryrenderer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Device>
 4 | #include <Tempest/Matrix4x4>
 5 | 
 6 | #include "meshobjects.h"
 7 | #include "sceneglobals.h"
 8 | #include "visualobjects.h"
 9 | 
10 | class Item;
11 | 
12 | class InventoryRenderer {
13 |   public:
14 |     InventoryRenderer();
15 | 
16 |     void draw(Tempest::Encoder<Tempest::CommandBuffer>& cmd);
17 | 
18 |     void reset(bool full=false);
19 |     void drawItem(int x, int y, int w, int h, const Item &item);
20 | 
21 |   private:
22 |     struct PerFrame {
23 |       Tempest::Matrix4x4 mvp;
24 |       };
25 | 
26 |     struct Itm {
27 |       MeshObjects::Mesh mesh;
28 |       int x=0,y=0,w=0,h=0;
29 |       };
30 | 
31 |     SceneGlobals           scene;
32 |     VisualObjects          visual;
33 |     MeshObjects            itmGroup;
34 |     std::vector<Itm>       items;
35 |     std::vector<Itm>       prevItems; // reseve previous to avoid bucket reallocation
36 |   };
37 | 
38 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/animmath.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Matrix4x4>
 4 | #include <Tempest/Point>
 5 | 
 6 | #include <zenkit/ModelAnimation.hh>
 7 | 
 8 | zenkit::AnimationSample mix(const zenkit::AnimationSample& x, const zenkit::AnimationSample& y, float a);
 9 | Tempest::Matrix4x4      mkMatrix(const zenkit::AnimationSample& s);
10 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/attachbinder.cpp:
--------------------------------------------------------------------------------
 1 | #include "attachbinder.h"
 2 | 
 3 | #include "protomesh.h"
 4 | #include "skeleton.h"
 5 | 
 6 | AttachBinder::AttachBinder(const Skeleton &s, const ProtoMesh &m) {
 7 |   bind.resize(m.submeshId.size());
 8 | 
 9 |   for(size_t i=0;i<m.submeshId.size();++i){
10 |     auto& att = m.attach[m.submeshId[i].id];
11 |     bind[i] = s.findNode(att.name);
12 |     }
13 |   }
14 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/attachbinder.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdlib>
 4 | #include <vector>
 5 | #include <string>
 6 | 
 7 | class ProtoMesh;
 8 | class Skeleton;
 9 | 
10 | class AttachBinder final {
11 |   public:
12 |     AttachBinder()=default;
13 |     AttachBinder(const Skeleton& s,const ProtoMesh& m);
14 | 
15 |     std::vector<size_t> bind;
16 |   };
17 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/landscape.cpp:
--------------------------------------------------------------------------------
 1 | #include "landscape.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | #include <cstddef>
 5 | 
 6 | #include "graphics/mesh/submesh/packedmesh.h"
 7 | #include "graphics/shaders.h"
 8 | #include "gothic.h"
 9 | 
10 | using namespace Tempest;
11 | 
12 | Landscape::Landscape(VisualObjects& visual, const PackedMesh &packed)
13 |   :mesh(packed) {
14 |   auto& device = Resources::device();
15 | 
16 |   meshletDesc = Resources::ssbo(packed.meshletBounds.data(),packed.meshletBounds.size()*sizeof(packed.meshletBounds[0]));
17 | 
18 |   blocks.reserve(packed.subMeshes.size());
19 |   for(size_t i=0; i<packed.subMeshes.size(); ++i) {
20 |     auto& sub      = packed.subMeshes[i];
21 |     auto  id       = uint32_t(sub.iboOffset/PackedMesh::MaxInd);
22 |     auto  material = Resources::loadMaterial(sub.material,true);
23 | 
24 |     if(material.alpha==Material::AdditiveLight || sub.iboLength==0) {
25 |       continue;
26 |       }
27 | 
28 |     if(Gothic::options().doRayQuery) {
29 |       mesh.sub[i].blas = device.blas(mesh.vbo,mesh.ibo,sub.iboOffset,sub.iboLength);
30 |       }
31 | 
32 |     Block b;
33 |     b.mesh = visual.get(mesh,material,sub.iboOffset,sub.iboLength,&packed.meshletBounds[id],DrawCommands::Landscape);
34 |     b.mesh.setObjMatrix(Matrix4x4::mkIdentity());
35 |     blocks.emplace_back(std::move(b));
36 |     }
37 |   }
38 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/landscape.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Device>
 4 | #include <Tempest/Matrix4x4>
 5 | #include <Tempest/UniformBuffer>
 6 | 
 7 | #include "graphics/visualobjects.h"
 8 | #include "graphics/meshobjects.h"
 9 | 
10 | class PackedMesh;
11 | 
12 | class Landscape final {
13 |   public:
14 |     Landscape(VisualObjects& visual, const PackedMesh& wmesh);
15 | 
16 |   private:
17 |     using Item = VisualObjects::Item;
18 | 
19 |     struct Block {
20 |       Item mesh;
21 |       };
22 | 
23 |     std::vector<Block>     blocks;
24 |     StaticMesh             mesh;
25 |     Tempest::StorageBuffer meshletDesc;
26 |   };
27 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/skeleton.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Matrix4x4>
 4 | 
 5 | #include <zenkit/ModelHierarchy.hh>
 6 | 
 7 | #include <vector>
 8 | 
 9 | #include "animation.h"
10 | 
11 | class Skeleton final {
12 |   public:
13 |     Skeleton(const zenkit::ModelHierarchy& src, const Animation* anim, std::string_view name);
14 | 
15 |     struct Node final {
16 |       size_t             parent=size_t(-1);
17 |       Tempest::Matrix4x4 tr;
18 |       std::string        name;
19 |       };
20 | 
21 |     bool                            ordered=true;
22 |     std::vector<Node>               nodes;
23 |     std::vector<size_t>             rootNodes;
24 |     std::vector<Tempest::Matrix4x4> tr;
25 |     Tempest::Vec3                   rootTr={};
26 | 
27 |     size_t                          BIP01_HEAD = size_t(-1);
28 | 
29 |     Tempest::Vec3                   bboxCol[2]={};
30 | 
31 |     size_t                          findNode(std::string_view name, size_t def=size_t(-1)) const;
32 |     size_t                          findRootNode() const;
33 | 
34 |     std::string_view                name() const { return fileName; }
35 |     const Animation::Sequence*      sequence(std::string_view name) const;
36 |     const Animation*                animation() const { return anim; }
37 |     std::string_view                defaultMesh() const;
38 | 
39 |     float                           colisionHeight() const;
40 | 
41 |     void                            debug() const;
42 | 
43 |   private:
44 |     std::string      fileName;
45 |     const Animation* anim=nullptr;
46 | 
47 |     void mkSkeleton();
48 |     void mkSkeleton(const Tempest::Matrix4x4& mt,size_t parent);
49 |   };
50 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/submesh/animmesh.cpp:
--------------------------------------------------------------------------------
 1 | #include "animmesh.h"
 2 | #include "packedmesh.h"
 3 | 
 4 | #include <Tempest/Log>
 5 | 
 6 | static size_t countBones(const Resources::VertexA* v, size_t n) {
 7 |   if(n==0)
 8 |     return 0;
 9 |   uint8_t ret = 0;
10 |   for(size_t i=0; i<n; ++i) {
11 |     ret = std::max(ret, v[i].boneId[0]);
12 |     ret = std::max(ret, v[i].boneId[1]);
13 |     ret = std::max(ret, v[i].boneId[2]);
14 |     ret = std::max(ret, v[i].boneId[3]);
15 |     }
16 |   return ret+1;
17 |   }
18 | 
19 | AnimMesh::AnimMesh(const PackedMesh& mesh)
20 |   : bonesCount(countBones(mesh.verticesA.data(),mesh.verticesA.size())) {
21 |   vbo  = Resources::vbo (mesh.verticesA.data(),mesh.verticesA.size());
22 |   ibo  = Resources::ibo (mesh.indices.data(),  mesh.indices.size());
23 |   ibo8 = Resources::ssbo(mesh.indices8.data(), mesh.indices8.size());
24 | 
25 |   sub.resize(mesh.subMeshes.size());
26 |   for(size_t i=0;i<mesh.subMeshes.size();++i) {
27 |     sub[i].texName   = mesh.subMeshes[i].material.texture;
28 |     sub[i].material  = Resources::loadMaterial(mesh.subMeshes[i].material,true);
29 |     sub[i].iboOffset = mesh.subMeshes[i].iboOffset;
30 |     sub[i].iboSize   = mesh.subMeshes[i].iboLength;
31 |     }
32 | 
33 |   // compact similar sub-meshes. not a big deal, but helps in graphics debugging
34 |   size_t cnt = 1;
35 |   for(size_t i=1;i<mesh.subMeshes.size();++i) {
36 |     auto& a = sub[cnt-1];
37 |     auto& b = sub[i];
38 |     if(a.iboOffset+a.iboSize==b.iboOffset &&
39 |        a.texName==b.texName &&
40 |        a.material==b.material) {
41 |       a.iboSize += b.iboSize;
42 |       } else {
43 |       sub[cnt] = b;
44 |       ++cnt;
45 |       }
46 |     }
47 |   sub.resize(cnt);
48 | 
49 |   bbox.assign(mesh.bbox());
50 |   }
51 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/submesh/animmesh.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/VertexBuffer>
 4 | #include <Tempest/IndexBuffer>
 5 | #include <Tempest/Device>
 6 | #include <Tempest/Matrix4x4>
 7 | 
 8 | #include "resources.h"
 9 | #include "staticmesh.h"
10 | 
11 | class AnimMesh {
12 |   public:
13 |     using VertexA=Resources::VertexA;
14 | 
15 |     AnimMesh(const PackedMesh& data);
16 | 
17 |     struct SubMesh {
18 |       Material                       material;
19 |       std::string                    texName;
20 |       size_t                         iboOffset = 0;
21 |       size_t                         iboSize   = 0;
22 |       };
23 | 
24 |     Tempest::VertexBuffer<VertexA> vbo;
25 |     Tempest::IndexBuffer<uint32_t> ibo;
26 |     Tempest::StorageBuffer         ibo8;
27 |     std::vector<SubMesh>           sub;
28 |     Bounds                         bbox;
29 |     const size_t                   bonesCount = 0;
30 |   };
31 | 


--------------------------------------------------------------------------------
/game/graphics/mesh/submesh/pfxemittermesh.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | #include <zenkit/ModelMesh.hh>
 6 | 
 7 | #include <Tempest/Point>
 8 | 
 9 | class PackedMesh;
10 | class Pose;
11 | 
12 | class PfxEmitterMesh {
13 |   public:
14 |     PfxEmitterMesh(const PackedMesh& src);
15 |     PfxEmitterMesh(const zenkit::ModelMesh& src);
16 | 
17 |     Tempest::Vec3 randCoord(float rnd, const Pose* pose) const;
18 | 
19 |   private:
20 |     struct Triangle {
21 |       uint32_t id[3]  = {};
22 |       float    sz     = 0;
23 |       float    prefix = 0;
24 |       };
25 | 
26 |     struct AnimData {
27 |       Tempest::Vec3 v[4];
28 |       uint8_t       id[4] = {};
29 |       float         weights[4] = {};
30 |       };
31 | 
32 |     Tempest::Vec3 randCoord(const Triangle& t, float rnd, const Pose* pose) const;
33 |     Tempest::Vec3 animCoord(const Pose& pose, uint32_t index) const;
34 |     void          mkIndex();
35 | 
36 |     static float area(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3);
37 | 
38 |     std::vector<Triangle>      triangle;
39 |     std::vector<Tempest::Vec3> vertices;
40 |     std::vector<AnimData>      vertAnim;
41 |   };
42 | 
43 | 


--------------------------------------------------------------------------------
/game/physics/physicmesh.cpp:
--------------------------------------------------------------------------------
 1 | #include "physicmesh.h"
 2 | 
 3 | #include "graphics/mesh/attachbinder.h"
 4 | #include "graphics/mesh/skeleton.h"
 5 | #include "graphics/mesh/pose.h"
 6 | #include "graphics/mesh/protomesh.h"
 7 | 
 8 | PhysicMesh::PhysicMesh(const ProtoMesh& proto, DynamicWorld& owner, bool movable)
 9 |   :ani(&proto) {
10 |   Tempest::Matrix4x4 pos;
11 |   pos.identity();
12 | 
13 |   for(auto& i:proto.attach) {
14 |     DynamicWorld::Item physic;
15 |     if(movable)
16 |       physic = owner.movableObj(i.shape.get(),pos); else
17 |       physic = owner.staticObj (i.shape.get(),pos);
18 |     sub.emplace_back(std::move(physic));
19 |     }
20 |   }
21 | 
22 | bool PhysicMesh::isEmpty() const {
23 |   return sub.empty();
24 |   }
25 | 
26 | void PhysicMesh::setObjMatrix(const Tempest::Matrix4x4& obj) {
27 |   implSetObjMatrix(obj,skeleton==nullptr ? nullptr : skeleton->tr.data());
28 |   }
29 | 
30 | void PhysicMesh::setSkeleton(const Skeleton* sk) {
31 |   skeleton = sk;
32 |   if(ani!=nullptr && skeleton!=nullptr)
33 |     binder=Resources::bindMesh(*ani,*skeleton);
34 |   }
35 | 
36 | void PhysicMesh::setPose(const Pose& p) {
37 |   implSetObjMatrix(Tempest::Matrix4x4::mkIdentity(),p.transform());
38 |   }
39 | 
40 | void PhysicMesh::implSetObjMatrix(const Tempest::Matrix4x4 &mt, const Tempest::Matrix4x4* tr) {
41 |   const size_t binds = (binder==nullptr ? 0 : binder->bind.size());
42 |   for(size_t i=0; i<binds; ++i) {
43 |     if(ani->submeshId[i].subId!=0)
44 |       continue;
45 |     auto id  = binder->bind[i];
46 |     auto mat = mt;
47 |     if(id<skeleton->tr.size())
48 |       mat = tr[id];
49 |     sub[ani->submeshId[i].id].setObjMatrix(mat);
50 |     }
51 |   for(size_t i=binds; i<sub.size(); ++i)
52 |     sub[i].setObjMatrix(mt);
53 |   }
54 | 
55 | void PhysicMesh::setInteractive(Interactive* it) {
56 |   for(auto& i:sub)
57 |     i.setInteractive(it);
58 |   }
59 | 


--------------------------------------------------------------------------------
/game/physics/physicmesh.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "dynamicworld.h"
 4 | 
 5 | class Pose;
 6 | class ProtoMesh;
 7 | class Skeleton;
 8 | class AttachBinder;
 9 | 
10 | class PhysicMesh final {
11 |   public:
12 |     PhysicMesh()=default;
13 |     PhysicMesh(const ProtoMesh& proto, DynamicWorld& owner, bool movable);
14 | 
15 |     bool   isEmpty() const;
16 | 
17 |     void   setObjMatrix  (const Tempest::Matrix4x4& m);
18 |     void   setSkeleton   (const Skeleton* sk);
19 |     void   setPose       (const Pose&      p);
20 |     void   setInteractive(Interactive* it);
21 | 
22 |   private:
23 |     void   implSetObjMatrix(const Tempest::Matrix4x4& mt, const Tempest::Matrix4x4* tr);
24 | 
25 |     std::vector<DynamicWorld::Item> sub;
26 |     const ProtoMesh*                ani=nullptr;
27 |     const Skeleton*                 skeleton=nullptr;
28 |     const AttachBinder*             binder=nullptr;
29 |   };
30 | 


--------------------------------------------------------------------------------
/game/physics/physicmeshshape.cpp:
--------------------------------------------------------------------------------
 1 | #include "physicmeshshape.h"
 2 | 
 3 | #include "graphics/mesh/submesh/packedmesh.h"
 4 | #include "dynamicworld.h"
 5 | 
 6 | float PhysicMeshShape::friction() const {
 7 |   return frict;
 8 |   }
 9 | 
10 | PhysicMeshShape* PhysicMeshShape::load(PackedMesh&& packed) {
11 |   uint32_t count = 0;
12 |   for (auto& i : packed.subMeshes)
13 |     if (!i.material.disable_collision && i.iboLength > 0) {
14 |       count++;
15 |     }
16 |   if (count == 0)
17 |     return nullptr;
18 |   return new PhysicMeshShape(std::move(packed));
19 | }
20 | 
21 | PhysicMeshShape::PhysicMeshShape(PackedMesh&& sPacked)
22 |   :mesh(std::move(sPacked)), shape(&mesh,true,true) {
23 |   for(auto& i:sPacked.subMeshes)
24 |     frict += DynamicWorld::materialFriction(i.material.group);
25 |   frict = frict/float(sPacked.subMeshes.size());
26 |   }
27 | 


--------------------------------------------------------------------------------
/game/physics/physicmeshshape.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "physics/physics.h"
 4 | #include "physicvbo.h"
 5 | 
 6 | class PhysicMeshShape final {
 7 |   public:
 8 |     PhysicMeshShape(const PhysicMeshShape&)=delete;
 9 | 
10 |     float friction() const;
11 | 
12 |     static PhysicMeshShape* load(PackedMesh&& packed);
13 | 
14 |   private:
15 |     PhysicMeshShape(PackedMesh&& packed);
16 | 
17 |     PhysicVbo                      mesh;
18 |     mutable btBvhTriangleMeshShape shape;
19 |     float                          frict = 0;
20 | 
21 |   friend class DynamicWorld;
22 |   };
23 | 


--------------------------------------------------------------------------------
/game/physics/physics.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Platform>
 4 | 
 5 | #ifdef __GNUC__
 6 | #pragma GCC diagnostic push
 7 | #pragma GCC diagnostic ignored "-Wconversion"
 8 | #pragma GCC diagnostic ignored "-Wfloat-conversion"
 9 | #if defined(__clang__)
10 | #pragma GCC diagnostic ignored "-Wunknown-warning-option"
11 | #pragma GCC diagnostic ignored "-Wargument-outside-range"
12 | #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
13 | #endif
14 | #endif
15 | 
16 | #include <BulletCollision/CollisionDispatch/btCollisionDispatcher.h>
17 | #include <BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h>
18 | #include <BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h>
19 | #include <BulletCollision/CollisionDispatch/btGhostObject.h>
20 | #include <BulletCollision/BroadphaseCollision/btDbvtBroadphase.h>
21 | #include <BulletCollision/BroadphaseCollision/btSimpleBroadphase.h>
22 | #include <BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h>
23 | #include <BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h>
24 | #include <BulletDynamics/Dynamics/btSimpleDynamicsWorld.h>
25 | #include <BulletCollision/CollisionShapes/btBoxShape.h>
26 | #include <BulletCollision/CollisionShapes/btCapsuleShape.h>
27 | #include <BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h>
28 | #include <BulletCollision/CollisionShapes/btTriangleMesh.h>
29 | #include <BulletCollision/CollisionShapes/btConeShape.h>
30 | #include <BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h>
31 | #include <BulletCollision/CollisionDispatch/btCollisionWorld.h>
32 | #include <BulletCollision/CollisionDispatch/btSimulationIslandManager.h>
33 | #include <BulletCollision/NarrowPhaseCollision/btRaycastCallback.h>
34 | #include <LinearMath/btDefaultMotionState.h>
35 | #include <LinearMath/btScalar.h>
36 | 
37 | #ifdef __GNUC__
38 | #pragma GCC diagnostic pop
39 | #endif
40 | 


--------------------------------------------------------------------------------
/game/physics/physicvbo.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <cstdint>
 5 | 
 6 | #include <zenkit/Material.hh>
 7 | 
 8 | #include "physics/physics.h"
 9 | #include "resources.h"
10 | 
11 | class PackedMesh;
12 | 
13 | class PhysicVbo : public btTriangleIndexVertexArray {
14 |   public:
15 |     using Vertex = Resources::Vertex;
16 | 
17 |     PhysicVbo(PackedMesh&& packed);
18 |     PhysicVbo(const std::vector<btVector3>* v);
19 | 
20 |     PhysicVbo(const PhysicVbo&)=delete;
21 |     PhysicVbo(PhysicVbo&&)=delete;
22 | 
23 |     void                    addIndex(const std::vector<uint32_t>& index, size_t iboOff, size_t iboLen, zenkit::MaterialGroup material);
24 |     void                    addIndex(const std::vector<uint32_t>& index, size_t iboOff, size_t iboLen, zenkit::MaterialGroup material, const char* sector);
25 |     zenkit::MaterialGroup   materialId(size_t segment) const;
26 |     auto                    sectorName(size_t segment) const -> const char*;
27 |     bool                    useQuantization() const;
28 |     bool                    isEmpty() const;
29 | 
30 |     void                    adjustMesh();
31 | 
32 |     std::string_view        validateSectorName(std::string_view name) const;
33 | 
34 |   private:
35 |     PhysicVbo(const std::vector<Vertex>& v);
36 | 
37 |     void addSegment(size_t indexSize,size_t offset, zenkit::MaterialGroup material, const char* sector);
38 | 
39 |     struct Segment {
40 |       size_t                off;
41 |       int                   size;
42 |       zenkit::MaterialGroup mat;
43 |       const char*           sector=nullptr;
44 |       };
45 | 
46 |     std::vector<btVector3>        vStorage;
47 |     const std::vector<btVector3>& vert;
48 |     std::vector<uint32_t>         id;
49 |     std::vector<Segment>          segments;
50 |   };
51 | 


--------------------------------------------------------------------------------
/game/sound/soundfx.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/SoundEffect>
 4 | #include <Tempest/Sound>
 5 | #include <vector>
 6 | 
 7 | #include <zenkit/addon/daedalus.hh>
 8 | 
 9 | class GSoundEffect;
10 | 
11 | class SoundFx {
12 |   public:
13 |     SoundFx(std::string_view tagname);
14 |     SoundFx(Tempest::Sound &&raw);
15 |     SoundFx(SoundFx&&)=default;
16 |     SoundFx& operator=(SoundFx&&)=default;
17 | 
18 |     Tempest::SoundEffect load(Tempest::SoundDevice& dev, bool& loop) const;
19 | 
20 |   private:
21 |     struct SoundVar {
22 |       SoundVar()=default;
23 |       SoundVar(const zenkit::ISoundEffect& sfx,Tempest::Sound&& snd);
24 |       SoundVar(const float vol,Tempest::Sound&& snd);
25 | 
26 |       Tempest::Sound snd;
27 |       float          vol  = 0.5f;
28 |       bool           loop = false;
29 |       };
30 | 
31 |     std::vector<SoundVar> inst;
32 |     void implLoad    (std::string_view name);
33 |     void loadVariants(std::string_view name);
34 |   };
35 | 
36 | 


--------------------------------------------------------------------------------
/game/ui/chapterscreen.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Widget>
 4 | #include <Tempest/Texture2d>
 5 | #include <Tempest/Timer>
 6 | 
 7 | class ChapterScreen : public Tempest::Widget {
 8 |   public:
 9 |     ChapterScreen();
10 | 
11 |     struct Show {
12 |       std::string title;
13 |       std::string subtitle;
14 |       std::string img;
15 |       std::string sound;
16 |       int         time=0;
17 |       };
18 | 
19 |     void show(const Show& image);
20 |     bool isActive() const { return active; }
21 | 
22 |     void keyDownEvent(Tempest::KeyEvent &e);
23 |     void keyUpEvent  (Tempest::KeyEvent &e);
24 | 
25 |   protected:
26 |     void paintEvent(Tempest::PaintEvent& e);
27 | 
28 |   private:
29 |     const Tempest::Texture2d* back=nullptr;
30 |     bool                      active=false;
31 |     Tempest::Timer            timer;
32 | 
33 |     std::string               title, subTitle;
34 | 
35 |     void                      close();
36 |   };
37 | 


--------------------------------------------------------------------------------
/game/ui/consolewidget.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Widget>
 4 | #include <Tempest/Dialog>
 5 | #include <Tempest/Shortcut>
 6 | 
 7 | #include "marvin.h"
 8 | 
 9 | class MainWindow;
10 | 
11 | class ConsoleWidget : public Tempest::Widget {
12 |   public:
13 |     ConsoleWidget(const MainWindow& owner);
14 |     ~ConsoleWidget();
15 | 
16 |     void close();
17 |     int  exec();
18 | 
19 |   protected:
20 |     void paintEvent    (Tempest::PaintEvent& e) override;
21 |     void keyDownEvent  (Tempest::KeyEvent&   e) override;
22 |     void keyRepeatEvent(Tempest::KeyEvent&   e) override;
23 |     using Tempest::Widget::keyUpEvent;
24 | 
25 |     void printLine(std::string_view s);
26 |     void updateSizeHint();
27 | 
28 |   private:
29 |     struct Overlay;
30 | 
31 |     const MainWindow&         mainWindow;
32 |     Tempest::UiOverlay*       overlay    = nullptr;
33 |     const Tempest::Texture2d* background = nullptr;
34 |     Tempest::Shortcut         closeSk;
35 |     std::vector<std::string>  log, cmdHist;
36 |     std::string               currCmd;
37 |     size_t                    histPos = size_t(-1);
38 |     size_t                    cursPos = 0;
39 |     Marvin                    marvin;
40 |   };
41 | 
42 | 


--------------------------------------------------------------------------------
/game/ui/documentmenu.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Widget>
 4 | #include <Tempest/Texture2d>
 5 | #include <Tempest/Timer>
 6 | 
 7 | class KeyCodec;
 8 | 
 9 | class DocumentMenu : public Tempest::Widget {
10 |   public:
11 |     DocumentMenu(const KeyCodec& key);
12 | 
13 |     enum Flags : uint8_t {
14 |       F_None,
15 |       F_Margin=1,
16 |       F_Backgr=2,
17 |       F_Font  =4
18 |       };
19 | 
20 |     struct Page {
21 |       std::string     img;
22 |       std::string     text;
23 |       std::string     font;
24 |       Tempest::Margin margins;
25 |       Flags           flg=F_None;
26 |       };
27 | 
28 |     // TODO: set default values for these
29 |     struct Show {
30 |       std::vector<Page> pages;
31 |       std::string       font;
32 |       Tempest::Margin   margins;
33 |       std::string       img;
34 |       // map
35 |       bool              showPlayer=false;
36 |       Tempest::Rect     wbounds;
37 |       };
38 | 
39 |     void show(const Show& doc);
40 |     bool isActive() const { return active; }
41 |     void close();
42 |     void tick(uint64_t dt);
43 | 
44 |     void keyDownEvent(Tempest::KeyEvent &e);
45 |     void keyUpEvent  (Tempest::KeyEvent &e);
46 | 
47 |   protected:
48 |     void paintEvent(Tempest::PaintEvent& e);
49 | 
50 |   private:
51 |     DocumentMenu::Show        document;
52 |     const KeyCodec&           keycodec;
53 |     const Tempest::Texture2d* cursor = nullptr;
54 |     bool                      active = false;
55 |   };
56 | 
57 | 


--------------------------------------------------------------------------------
/game/ui/menuroot.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Widget>
 4 | 
 5 | #include <zenkit/DaedalusVm.hh>
 6 | #include <zenkit/addon/daedalus.hh>
 7 | 
 8 | #include "utils/keycodec.h"
 9 | 
10 | class GameMenu;
11 | class Npc;
12 | 
13 | class MenuRoot : public Tempest::Widget {
14 |   public:
15 |     MenuRoot(KeyCodec& keyCodec);
16 |     ~MenuRoot() override;
17 | 
18 |     void setMainMenu();
19 |     void setMenu(const char* menu, KeyCodec::Action key = KeyCodec::Escape);
20 |     void setMenu(GameMenu* w);
21 |     void pushMenu(GameMenu* w);
22 |     void popMenu();
23 |     void closeAll();
24 |     bool isActive() const;
25 |     void setPlayer(const Npc& pl);
26 |     void processMusicTheme();
27 | 
28 |     void showVersion(bool s);
29 |     bool hasVersionLine() const;
30 | 
31 |     void mouseWheelEvent(Tempest::MouseEvent& event) override;
32 |     void keyRepeatEvent (Tempest::KeyEvent&   event) override;
33 |     void keyDownEvent   (Tempest::KeyEvent&   event) override;
34 | 
35 |   protected:
36 |     void mouseDownEvent (Tempest::MouseEvent& event) override;
37 |     void mouseUpEvent   (Tempest::MouseEvent& event) override;
38 | 
39 |   private:
40 |     void initSettings();
41 | 
42 |     std::unique_ptr<zenkit::DaedalusVm>    vm;
43 |     int32_t                                vmLang = -1;
44 | 
45 |     GameMenu*                              current=nullptr;
46 |     std::vector<std::unique_ptr<GameMenu>> menuStack;
47 |     KeyCodec&                              keyCodec;
48 | 
49 |     Tempest::Event::KeyType                cheatCode[6] = {};
50 |     bool                                   showVersionHint = false;
51 |   };
52 | 


--------------------------------------------------------------------------------
/game/ui/stacklayout.cpp:
--------------------------------------------------------------------------------
 1 | #include "stacklayout.h"
 2 | 
 3 | #include <Tempest/Widget>
 4 | 
 5 | StackLayout::StackLayout() {  
 6 |   }
 7 | 
 8 | void StackLayout::applyLayout() {
 9 |   auto& w = *owner();
10 |   size_t count=w.widgetsCount();
11 | 
12 |   for(size_t i=0;i<count;++i){
13 |     auto& wx=w.widget(i);
14 |     wx.setGeometry(0,0,w.w(),w.h());
15 |     }
16 |   }
17 | 


--------------------------------------------------------------------------------
/game/ui/stacklayout.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Layout>
 4 | 
 5 | class StackLayout : public Tempest::Layout {
 6 |   public:
 7 |     StackLayout();
 8 | 
 9 |   private:
10 |     void applyLayout() override;
11 |   };
12 | 


--------------------------------------------------------------------------------
/game/ui/touchinput.cpp:
--------------------------------------------------------------------------------
 1 | #include "touchinput.h"
 2 | 
 3 | #include <Tempest/Painter>
 4 | 
 5 | #include "game/playercontrol.h"
 6 | 
 7 | using namespace Tempest;
 8 | 
 9 | TouchInput::TouchInput(PlayerControl& ctrl) : ctrl(ctrl) {
10 |   }
11 | 
12 | void TouchInput::paintEvent(Tempest::PaintEvent& e) {
13 |   Painter p(e);
14 | 
15 |   p.setBrush(Color(1,1,1, 0.2f));
16 |   p.drawRect(10, h()-10 - 100, 100, 100);
17 |   }
18 | 
19 | void TouchInput::mouseDownEvent(Tempest::MouseEvent& e) {
20 |   auto r = Rect(10, h()-10-100, 100, 100);
21 |   if(!r.contains(e.pos())) {
22 |     e.ignore();
23 |     return;
24 |     }
25 | 
26 |   mpos = e.pos();
27 |   ctrl.onKeyPressed(KeyCodec::Forward, KeyEvent::K_NoKey);
28 |   }
29 | 
30 | void TouchInput::mouseDragEvent(Tempest::MouseEvent& e) {
31 |   auto dp = e.pos() - mpos;
32 |   mpos = e.pos();
33 |   if(std::abs(dp.x)>0) {
34 |     const float scale = 4.f;
35 |     ctrl.onRotateMouse(float(-dp.x) * scale);
36 |     }
37 |   }
38 | 
39 | void TouchInput::mouseUpEvent(Tempest::MouseEvent& e) {
40 |   ctrl.onKeyReleased(KeyCodec::Forward);
41 |   }
42 | 


--------------------------------------------------------------------------------
/game/ui/touchinput.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Widget>
 4 | 
 5 | class PlayerControl;
 6 | 
 7 | class TouchInput : public Tempest::Widget {
 8 |   public:
 9 |     TouchInput(PlayerControl& ctrl);
10 | 
11 |     void paintEvent(Tempest::PaintEvent& e);
12 |     void mouseDownEvent(Tempest::MouseEvent& e);
13 |     void mouseDragEvent(Tempest::MouseEvent& e);
14 |     void mouseUpEvent(Tempest::MouseEvent& e);
15 | 
16 |   private:
17 |     PlayerControl& ctrl;
18 | 
19 |     Tempest::Point mpos;
20 |   };
21 | 
22 | 


--------------------------------------------------------------------------------
/game/ui/videowidget.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Widget>
 4 | 
 5 | #include <queue>
 6 | 
 7 | #include "resources.h"
 8 | 
 9 | class VideoWidget : public Tempest::Widget {
10 |   public:
11 |     VideoWidget();
12 |     ~VideoWidget();
13 | 
14 |     void pushVideo(std::string_view filename);
15 |     bool isActive() const;
16 | 
17 |     void tick();
18 |     void paint(Tempest::Device& device, uint8_t fId);
19 |     void paintEvent(Tempest::PaintEvent &event) override;
20 | 
21 |     void keyDownEvent(Tempest::KeyEvent&   event) override;
22 |     void keyUpEvent  (Tempest::KeyEvent&   event) override;
23 | 
24 |     void mouseDownEvent(Tempest::MouseEvent& event) override;
25 | 
26 |   private:
27 |     struct Input;
28 |     struct Sound;
29 |     struct SoundContext;
30 |     struct Context;
31 | 
32 |     void  stopVideo();
33 | 
34 |     std::unique_ptr<Context>      ctx;
35 |     Tempest::Texture2d            tex[Resources::MaxFramesInFlight];
36 |     Tempest::Texture2d*           frame  = nullptr;
37 |     bool                          active = false;
38 |     bool                          restoreMusic = false;
39 | 
40 |     std::atomic_bool              hasPendingVideo{false};
41 |     std::mutex                    syncVideo;
42 |     std::queue<std::string>       pendingVideo;
43 |   };
44 | 
45 | 


--------------------------------------------------------------------------------
/game/utils/crashlog.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | #include <ostream>
 5 | 
 6 | class CrashLog final {
 7 |   public:
 8 |     static void setup();
 9 |     static void setGpu(std::string_view name);
10 | 
11 |     static void dumpStack(const char* sig, const char* extGpuLog);
12 | 
13 |   private:
14 |     static void tracebackLinux(std::ostream &out);
15 |     static void tracebackGpu(std::ostream &out, const char* extGpuLog);
16 |     static void writeSysInfo(std::ostream& fout);
17 |   };
18 | 
19 | 


--------------------------------------------------------------------------------
/game/utils/dbgpainter.cpp:
--------------------------------------------------------------------------------
 1 | #include "dbgpainter.h"
 2 | 
 3 | #include "utils/gthfont.h"
 4 | #include "resources.h"
 5 | 
 6 | using namespace Tempest;
 7 | 
 8 | DbgPainter::DbgPainter(Painter& painter, const Tempest::Matrix4x4& mvp, int w, int h)
 9 |   :painter(painter), mvp(mvp), w(w), h(h) {
10 |   }
11 | 
12 | void DbgPainter::setBrush(const Brush& brush) {
13 |   painter.setBrush(brush);
14 |   }
15 | 
16 | void DbgPainter::setPen(const Pen& pen) {
17 |   painter.setPen(pen);
18 |   }
19 | 
20 | void DbgPainter::drawText(int x, int y, std::string_view txt) {
21 |   auto& fnt = Resources::font(1.0);
22 |   fnt.drawText(painter,x,y,txt);
23 |   }
24 | 
25 | void DbgPainter::drawLine(const Vec3& a, const Vec3& b) {
26 |   Vec3 pa = a, pb = b;
27 |   mvp.project(pa.x,pa.y,pa.z);
28 |   mvp.project(pb.x,pb.y,pb.z);
29 | 
30 |   int x0 = int((pa.x+1.f)*0.5f*float(w));
31 |   int y0 = int((pa.y+1.f)*0.5f*float(h));
32 | 
33 |   int x1 = int((pb.x+1.f)*0.5f*float(w));
34 |   int y1 = int((pb.y+1.f)*0.5f*float(h));
35 | 
36 |   painter.drawLine(x0,y0,x1,y1);
37 |   }
38 | 


--------------------------------------------------------------------------------
/game/utils/dbgpainter.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Matrix4x4>
 4 | #include <Tempest/Painter>
 5 | 
 6 | class DbgPainter {
 7 |   public:
 8 |     DbgPainter(Tempest::Painter& painter, const Tempest::Matrix4x4& mvp, int w, int h);
 9 | 
10 |     void setBrush(const Tempest::Brush& brush);
11 |     void setPen  (const Tempest::Pen&   pen);
12 | 
13 |     void drawText(int x, int y, std::string_view txt);
14 |     void drawLine(const Tempest::Vec3& a, const Tempest::Vec3& b);
15 |     void drawPoint();
16 | 
17 |     Tempest::Painter&        painter;
18 |     const Tempest::Matrix4x4 mvp;
19 |     const int                w;
20 |     const int                h;
21 |   };
22 | 
23 | 


--------------------------------------------------------------------------------
/game/utils/fileutil.cpp:
--------------------------------------------------------------------------------
 1 | #include "fileutil.h"
 2 | 
 3 | #include <Tempest/Platform>
 4 | #include <Tempest/TextCodec>
 5 | 
 6 | #ifdef __WINDOWS__
 7 | #include <windows.h>
 8 | #include <shlwapi.h>
 9 | #else
10 | #include <sys/stat.h>
11 | #endif
12 | 
13 | using namespace Tempest;
14 | 
15 | bool FileUtil::exists(const std::u16string &path) {
16 | #ifdef __WINDOWS__
17 |   return PathFileExistsW(reinterpret_cast<const WCHAR*>(path.c_str()));
18 | #else
19 |   std::string p=Tempest::TextCodec::toUtf8(path);
20 |   struct stat  buffer={};
21 |   return stat(p.c_str(),&buffer)==0;
22 | #endif
23 |   }
24 | 
25 | std::u16string FileUtil::caseInsensitiveSegment(std::u16string_view pathv,const char16_t* segment,Dir::FileType type) {
26 |   auto path = std::u16string(pathv);
27 |   std::u16string next = path+segment;
28 |   if(FileUtil::exists(next)) {
29 |     if(type==Dir::FT_File)
30 |       return next;
31 |     return next+u"/";
32 |     }
33 | 
34 |   Dir::scan(path,[&path,&next,&segment,type](const std::u16string& p, Dir::FileType t){
35 |     if(t!=type)
36 |       return;
37 |     for(size_t i=0;;++i) {
38 |       char16_t cs = segment[i];
39 |       char16_t cp = p[i];
40 |       if('A'<=cs && cs<='Z')
41 |         cs = char16_t(cs-'A'+'a');
42 |       if('A'<=cp && cp<='Z')
43 |         cp = char16_t(cp-'A'+'a');
44 | 
45 |       if(cs!=cp)
46 |         return;
47 |       if(cs=='\0')
48 |         break;
49 |       }
50 | 
51 |     next = path+p;
52 |     });
53 |   if(type==Dir::FT_File)
54 |     return next;
55 |   return next+u"/";
56 |   }
57 | 
58 | std::u16string FileUtil::nestedPath(std::u16string_view gpath, const std::initializer_list<const char16_t*> &name, Dir::FileType type) {
59 |   std::u16string path = std::u16string(gpath);
60 |   for(auto& segment:name)
61 |     path = caseInsensitiveSegment(path,segment, (segment==*(name.end()-1)) ? type : Dir::FT_Dir);
62 |   return path;
63 |   }
64 | 


--------------------------------------------------------------------------------
/game/utils/fileutil.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Dir>
 4 | #include <string>
 5 | 
 6 | namespace FileUtil {
 7 |   bool exists(const std::u16string& path);
 8 |   std::u16string caseInsensitiveSegment(std::u16string_view path, const char16_t* segment, Tempest::Dir::FileType type);
 9 |   std::u16string nestedPath(std::u16string_view gpath, const std::initializer_list<const char16_t*> &name, Tempest::Dir::FileType type);
10 |   }
11 | 


--------------------------------------------------------------------------------
/game/utils/gthfont.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/Font.hh>
 4 | 
 5 | #include <Tempest/Painter>
 6 | 
 7 | class GthFont final {
 8 |   public:
 9 |     GthFont();
10 |     GthFont(zenkit::Read& data, std::string_view ftex, const Tempest::Color &cl);
11 |     GthFont(const GthFont&) = default;
12 |     GthFont(GthFont&&)      = default;
13 | 
14 |     GthFont& operator = (const GthFont&) = default;
15 |     GthFont& operator = (GthFont&&)      = default;
16 | 
17 |     int  pixelSize() const;
18 |     void setScale(float s);
19 | 
20 |     void drawText(Tempest::Painter& p, int x, int y, int w, int h, std::string_view txt, Tempest::AlignFlag align, int firstLine=0) const;
21 |     void drawText(Tempest::Painter& p, int x, int y, std::string_view txt) const;
22 | 
23 |     auto textSize(const std::string_view txt) const -> Tempest::Size;
24 |     auto textSize(const char*    b, const char* e) const -> Tempest::Size;
25 |     auto textSize(const uint8_t* b, const uint8_t* e) const -> Tempest::Size;
26 |     auto textSize(int w, std::string_view txt) const -> Tempest::Size;
27 |     auto lineCount(int w, std::string_view txt) const -> int32_t;
28 | 
29 |   private:
30 |     std::shared_ptr<zenkit::Font>  pfnt;
31 |     const Tempest::Texture2d*      tex       = nullptr;
32 |     uint32_t                       fntHeight = 0;
33 |     float                          scale     = 0;
34 |     Tempest::Color                 color;
35 | 
36 |     const uint8_t* getLine(const uint8_t* txt, int bw, int &width) const;
37 |     const uint8_t* getWord(const uint8_t* txt, int &width, int &space) const;
38 | 
39 |     static bool    isSpace(uint8_t ch);
40 |     Tempest::Size  processText(Tempest::Painter* p, int x, int y, int w, int h, std::string_view txt, Tempest::AlignFlag align, int firstLine) const;
41 |   };
42 | 
43 | 


--------------------------------------------------------------------------------
/game/utils/installdetect.cpp:
--------------------------------------------------------------------------------
 1 | #include "installdetect.h"
 2 | 
 3 | #include <Tempest/Platform>
 4 | 
 5 | #ifdef __WINDOWS__
 6 | #include "windows.h"
 7 | #include "shlobj.h"
 8 | #include "shlwapi.h"
 9 | #endif
10 | 
11 | #include <cstring>
12 | #include "utils/fileutil.h"
13 | 
14 | InstallDetect::InstallDetect() {
15 | #ifdef __WINDOWS__
16 |   pfiles    = programFiles(false);
17 |   pfilesX86 = programFiles(true);
18 | #endif
19 | #if defined(__OSX__) || defined(__IOS__)
20 |   appDir    = applicationSupportDirectory();
21 | #endif
22 |   }
23 | 
24 | std::u16string InstallDetect::detectG2() {
25 | #if defined(__WINDOWS__)
26 |   auto ret = detectG2(pfiles);
27 |   if(ret.empty())
28 |     ret = detectG2(pfilesX86);
29 |   return ret;
30 | #elif defined(__OSX__) || defined(__IOS__)
31 |   if(FileUtil::exists(appDir))
32 |     return appDir;
33 |   return u"";
34 | #else
35 |   return u"";
36 | #endif
37 |   }
38 | 
39 | std::u16string InstallDetect::detectG2(std::u16string pfiles) {
40 |   if(pfiles.empty())
41 |     return u"";
42 |   auto steam = pfiles+u"/Steam/steamapps/common/Gothic II/";
43 |   if(FileUtil::exists(steam))
44 |     return steam;
45 |   auto akela = pfiles+u"/Akella Games/Gothic II/";
46 |   if(FileUtil::exists(akela))
47 |     return akela;
48 |   return u"";
49 |   }
50 | 
51 | #ifdef __WINDOWS__
52 | std::u16string InstallDetect::programFiles(bool x86) {
53 |   WCHAR path[MAX_PATH]={};
54 |   if(FAILED(SHGetFolderPathW(NULL, (x86 ? CSIDL_PROGRAM_FILESX86 : CSIDL_PROGRAM_FILES), NULL, 0, path)))
55 |     return u"";
56 |   std::u16string ret;
57 |   size_t len=0;
58 |   for(;path[len];++len);
59 | 
60 |   ret.resize(len);
61 |   std::memcpy(&ret[0],path,len*sizeof(char16_t));
62 |   return ret;
63 |   }
64 | #endif
65 | 


--------------------------------------------------------------------------------
/game/utils/installdetect.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Platform>
 4 | #include <string>
 5 | 
 6 | class InstallDetect final {
 7 |   public:
 8 |     InstallDetect();
 9 | 
10 |     std::u16string detectG2();
11 | #if defined(__OSX__) || defined(__IOS__)
12 |     static std::u16string applicationSupportDirectory();
13 | #endif
14 | 
15 |   private:
16 |     std::u16string detectG2(std::u16string pfiles);
17 | 
18 | #ifdef __WINDOWS__
19 |     static std::u16string programFiles(bool x86);
20 |     std::u16string pfiles, pfilesX86;
21 | #endif
22 | 
23 | #if defined(__OSX__) || defined(__IOS__)
24 |     std::u16string appDir;
25 | #endif
26 |   };
27 | 


--------------------------------------------------------------------------------
/game/utils/installdetect.mm:
--------------------------------------------------------------------------------
 1 | #include "installdetect.h"
 2 | 
 3 | #if __has_feature(objc_arc)
 4 | #error "Objective C++ ARC is not supported"
 5 | #endif
 6 | 
 7 | #include <Tempest/TextCodec>
 8 | 
 9 | #import <Foundation/Foundation.h>
10 | 
11 | #if defined(OSX)
12 | #import <Cocoa/Cocoa.h>
13 | #endif
14 | 
15 | std::u16string InstallDetect::applicationSupportDirectory() {
16 |   std::string ret;
17 | 
18 | #if defined(__OSX__)
19 |   NSArray* paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES);
20 | #else
21 |   NSArray* paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
22 | #endif
23 |   if(paths!=nil && [paths count]>0) {
24 | #if defined(__OSX__)
25 |     NSString* app = [[paths firstObject] stringByAppendingPathComponent:@"OpenGothic"];
26 | #else
27 |     NSString* app = [[paths firstObject] stringByAppendingPathComponent:@""];
28 | #endif
29 |     if(app!=nil) {
30 |       ret = [app cStringUsingEncoding:NSUTF8StringEncoding];
31 |       [app release];
32 |       }
33 |     }
34 | 
35 |   if(paths!=nil)
36 |     [paths release];
37 | 
38 |   return Tempest::TextCodec::toUtf16(ret);
39 |   }
40 | 


--------------------------------------------------------------------------------
/game/utils/mouseutil.cpp:
--------------------------------------------------------------------------------
 1 | #include "mouseutil.h"
 2 | 
 3 | #include <Tempest/Platform>
 4 | 
 5 | #ifdef __WINDOWS__
 6 | #include <windows.h>
 7 | #include <shlwapi.h>
 8 | #else
 9 | #include <sys/stat.h>
10 | #endif
11 | 
12 | float MouseUtil::mouseSysSpeed() {
13 | #ifdef __WINDOWS__
14 |   int mouseSpeed = 10;
15 |   if(SystemParametersInfoA(SPI_GETMOUSESPEED, 0, &mouseSpeed, 0)) {
16 |     return float(mouseSpeed)/10.f;
17 |     }
18 |   return 1.f;
19 | #else
20 |   return 1.f;
21 | #endif
22 |   }
23 | 


--------------------------------------------------------------------------------
/game/utils/mouseutil.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | namespace MouseUtil {
4 |   float mouseSysSpeed();
5 |   };
6 | 
7 | 


--------------------------------------------------------------------------------
/game/utils/parser.cpp:
--------------------------------------------------------------------------------
 1 | #include "parser.h"
 2 | #include "utils/string_frm.h"
 3 | 
 4 | using namespace Tempest;
 5 | 
 6 | Vec2 Parser::loadVec2(std::string_view src) {
 7 |   if(src=="=")
 8 |     return Vec2();
 9 | 
10 |   float v[2] = {};
11 |   string_frm str(src);
12 |   for(int i=0; i<2; ++i) {
13 |     char* next = nullptr;
14 |     v[i] = std::strtof(str.c_str(),&next);
15 |     if(str==next) {
16 |       if(i==1)
17 |         return Vec2(v[0],v[0]);
18 |       }
19 |     str = next;
20 |     }
21 |   return Vec2(v[0],v[1]);
22 |   }
23 | 
24 | Vec3 Parser::loadVec3(std::string_view src) {
25 |   if(src=="=")
26 |     return Vec3();
27 | 
28 |   float v[3] = {};
29 |   string_frm str(src);
30 |   for(int i=0; i<3; ++i) {
31 |     char* next=nullptr;
32 |     v[i] = std::strtof(str.c_str(),&next);
33 |     if(str==next) {
34 |       if(i==1)
35 |         return Vec3(v[0],v[0],v[0]);
36 |       if(i==2)
37 |         return Vec3(v[0],v[1],0.f);
38 |       }
39 |     str = next;
40 |     }
41 |   return Vec3(v[0],v[1],v[2]);
42 |   }
43 | 
44 | Material::AlphaFunc Parser::loadAlpha(std::string_view src) {
45 |   if(src=="NONE")
46 |     return Material::AlphaTest;
47 |   if(src=="BLEND")
48 |     return Material::Transparent;
49 |   if(src=="ADD")
50 |     return Material::AdditiveLight;
51 |   if(src=="MUL")
52 |     return Material::Multiply;
53 |   return Material::Solid;
54 |   }
55 | 


--------------------------------------------------------------------------------
/game/utils/parser.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Vec>
 4 | #include "graphics/material.h"
 5 | 
 6 | namespace Parser {
 7 |   Tempest::Vec2       loadVec2 (std::string_view         src);
 8 |   Tempest::Vec3       loadVec3 (std::string_view         src);
 9 |   Material::AlphaFunc loadAlpha(std::string_view         src);
10 |   }
11 | 
12 | 


--------------------------------------------------------------------------------
/game/utils/versioninfo.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdint>
 4 | 
 5 | class VersionInfo final {
 6 |   public:
 7 |     uint8_t game =2;
 8 |     int32_t patch=0;
 9 | 
10 |     bool     hasZSStateLoop()     const { return game==2 && patch>=5; }
11 |     uint16_t dialogGestureCount() const { return game==2 ? 11 : 21;   }
12 |   };
13 | 
14 | 


--------------------------------------------------------------------------------
/game/world/collisionzone.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Vec>
 4 | 
 5 | #include <functional>
 6 | #include <vector>
 7 | 
 8 | class World;
 9 | class ParticleFx;
10 | class Serialize;
11 | class Npc;
12 | 
13 | class CollisionZone final {
14 |   public:
15 |     CollisionZone();
16 |     CollisionZone(World& owner, const Tempest::Vec3& pos, const ParticleFx& pfx);
17 |     CollisionZone(World& owner, const Tempest::Vec3& pos, const Tempest::Vec3& size);
18 |     CollisionZone(CollisionZone&& other);
19 |     CollisionZone& operator = (CollisionZone&& other);
20 |     ~CollisionZone();
21 | 
22 |     void          save(Serialize& fout) const;
23 |     void          load(Serialize &fin);
24 | 
25 |     void          setCallback(std::function<void(Npc& npc)> f);
26 | 
27 |     Tempest::Vec3 position() const { return pos; }
28 |     void          setPosition(const Tempest::Vec3& p);
29 | 
30 |     const std::vector<Npc*>& intersections() const { return intersect; }
31 | 
32 |     bool          checkPos(const Tempest::Vec3& pos) const;
33 |     void          onIntersect(Npc& npc);
34 |     void          tick(uint64_t dt);
35 | 
36 |   private:
37 |     World*                    owner = nullptr;
38 |     std::function<void(Npc&)> cb;
39 | 
40 |     enum Type:uint8_t {
41 |       T_BBox,
42 |       T_Capsule,
43 |       };
44 |     uint64_t          time0 = 0;
45 |     Type              type = T_BBox;
46 |     Tempest::Vec3     pos, size;
47 |     const ParticleFx* pfx = nullptr;
48 | 
49 |     std::vector<Npc*> intersect;
50 |   };
51 | 
52 | 


--------------------------------------------------------------------------------
/game/world/focus.cpp:
--------------------------------------------------------------------------------
 1 | #include "focus.h"
 2 | 
 3 | #include "world/objects/npc.h"
 4 | #include "world/objects/interactive.h"
 5 | #include "world/objects/item.h"
 6 | 
 7 | Focus::Focus(Interactive &i):interactive(&i){
 8 |   }
 9 | 
10 | Focus::Focus(Npc &i):npc(&i){
11 |   }
12 | 
13 | Focus::Focus(Item &i):item(&i){
14 |   }
15 | 
16 | Focus::operator bool() const {
17 |   return interactive || npc || item;
18 |   }
19 | 
20 | Tempest::Vec3 Focus::displayPosition() const {
21 |   if(interactive)
22 |     return interactive->displayPosition();
23 |   if(npc)
24 |     return npc->displayPosition();
25 |   if(item)
26 |     return item->position();
27 |   return {};
28 |   }
29 | 
30 | std::string_view Focus::displayName() const {
31 |   if(interactive)
32 |     return interactive->displayName();
33 |   if(npc)
34 |     return npc->displayName();
35 |   if(item)
36 |     return item->displayName();
37 |   return "";
38 |   }
39 | 


--------------------------------------------------------------------------------
/game/world/focus.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Point>
 4 | #include <string_view>
 5 | 
 6 | class Interactive;
 7 | class Npc;
 8 | class Item;
 9 | 
10 | class Focus final {
11 |   public:
12 |     Focus()=default;
13 |     Focus(Interactive& i);
14 |     Focus(Npc& i);
15 |     Focus(Item& i);
16 | 
17 |     operator bool() const;
18 |     Tempest::Vec3    displayPosition() const;
19 |     std::string_view displayName() const;
20 | 
21 |     Interactive* interactive=nullptr;
22 |     Npc*         npc        =nullptr;
23 |     Item*        item       =nullptr;
24 |   };
25 | 


--------------------------------------------------------------------------------
/game/world/fplock.cpp:
--------------------------------------------------------------------------------
 1 | #include "fplock.h"
 2 | #include "waypoint.h"
 3 | 
 4 | #include "game/serialize.h"
 5 | 
 6 | FpLock::FpLock() {
 7 |   }
 8 | 
 9 | FpLock::FpLock(const WayPoint &p)
10 |   :pt(&p){
11 |   pt->useCount++;
12 |   }
13 | 
14 | FpLock::FpLock(const WayPoint *p)
15 |   :pt(p){
16 |   if(pt)
17 |     pt->useCount++;
18 |   }
19 | 
20 | FpLock::FpLock(FpLock &&other)
21 |   :pt(other.pt){
22 |   other.pt=nullptr;
23 |   }
24 | 
25 | FpLock::~FpLock() {
26 |   if(pt)
27 |     pt->useCount--;
28 |   }
29 | 
30 | FpLock &FpLock::operator=(FpLock &&other) {
31 |   if(pt)
32 |     pt->useCount--;
33 |   pt = other.pt;
34 |   other.pt=nullptr;
35 |   return *this;
36 |   }
37 | 
38 | void FpLock::load(Serialize &fin) {
39 |   fin.read(pt);
40 |   if(pt)
41 |     pt->useCount++;
42 |   }
43 | 
44 | void FpLock::save(Serialize &fout) const {
45 |   fout.write(pt);
46 |   }
47 | 


--------------------------------------------------------------------------------
/game/world/fplock.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | class WayPoint;
 4 | class Serialize;
 5 | 
 6 | class FpLock final {
 7 |   public:
 8 |     FpLock();
 9 |     FpLock(const WayPoint& p);
10 |     FpLock(const WayPoint* p);
11 |     FpLock(FpLock&& other);
12 |     ~FpLock();
13 | 
14 |     FpLock& operator=(FpLock&& other);
15 | 
16 |     void load(Serialize& fin);
17 |     void save(Serialize& fout) const;
18 | 
19 |   private:
20 |     const WayPoint* pt=nullptr;
21 |   };
22 | 


--------------------------------------------------------------------------------
/game/world/objects/fireplace.cpp:
--------------------------------------------------------------------------------
 1 | #include "fireplace.h"
 2 | 
 3 | #include <zenkit/vobs/MovableObject.hh>
 4 | 
 5 | FirePlace::FirePlace(Vob* parent, World& world, const zenkit::VFire& vob, Flags flags)
 6 |   : Interactive(parent,world,vob,flags){
 7 |   fireVobtreeName = vob.vob_tree;
 8 |   fireSlot        = vob.slot;
 9 |   }
10 | 
11 | void FirePlace::load(Serialize& fin) {
12 |   Interactive::load(fin);
13 |   onStateChanged();
14 |   }
15 | 
16 | void FirePlace::moveEvent() {
17 |   Interactive::moveEvent();
18 | 
19 |   auto at = this->nodeTranform(fireSlot);
20 |   fireVobtree.setObjMatrix(at);
21 |   }
22 | 
23 | void FirePlace::onStateChanged() {
24 |   if(stateId()>0) {
25 |     auto at = this->nodeTranform(fireSlot);
26 |     fireVobtree = VobBundle(world,fireVobtreeName,Vob::Startup);
27 |     fireVobtree.setObjMatrix(at);
28 |     } else {
29 |     fireVobtree = VobBundle();
30 |     }
31 |   }
32 | 


--------------------------------------------------------------------------------
/game/world/objects/fireplace.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "interactive.h"
 4 | #include "vobbundle.h"
 5 | 
 6 | class FirePlace : public Interactive {
 7 |   public:
 8 |     FirePlace(Vob* parent, World& world, const zenkit::VFire& vob, Flags flags);
 9 | 
10 |   protected:
11 |     void  load(Serialize& fin) override;
12 |     void  moveEvent() override;
13 |     void  onStateChanged() override;
14 | 
15 |   private:
16 |     VobBundle   fireVobtree;
17 |     std::string fireVobtreeName;
18 |     std::string fireSlot;
19 |   };
20 | 
21 | 


--------------------------------------------------------------------------------
/game/world/objects/globalfx.cpp:
--------------------------------------------------------------------------------
 1 | #include "globalfx.h"
 2 | 
 3 | GlobalFx::GlobalFx() {
 4 |   }
 5 | 
 6 | GlobalFx::GlobalFx(const std::shared_ptr<GlobalEffects::Effect>& h)
 7 |   :h(h) {
 8 |   }
 9 | 
10 | GlobalFx::GlobalFx(GlobalFx&& other)
11 |   :h(other.h) {
12 |   other.h = nullptr;
13 |   }
14 | 
15 | GlobalFx& GlobalFx::operator =(GlobalFx&& other) {
16 |   std::swap(h,other.h);
17 |   return *this;
18 |   }
19 | 
20 | GlobalFx::~GlobalFx() {
21 |   if(h!=nullptr)
22 |     h->stop();
23 |   }
24 | 
25 | uint64_t GlobalFx::effectPrefferedTime() const {
26 |   if(h==nullptr)
27 |     return 0;
28 |   uint64_t ret = h->timeLen;
29 |   if(ret==uint64_t(-1))
30 |     return h->timeLoop;
31 |   return ret;
32 |   }
33 | 


--------------------------------------------------------------------------------
/game/world/objects/globalfx.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | #include "game/globaleffects.h"
 5 | 
 6 | class GlobalFx {
 7 |   public:
 8 |     GlobalFx();
 9 |     GlobalFx(GlobalFx&& other);
10 |     GlobalFx& operator = (GlobalFx&& other);
11 |     ~GlobalFx();
12 | 
13 |     uint64_t effectPrefferedTime() const;
14 | 
15 |   private:
16 |     GlobalFx(const std::shared_ptr<GlobalEffects::Effect>& h);
17 |     std::shared_ptr<GlobalEffects::Effect> h;
18 |   friend class GlobalEffects;
19 |   };
20 | 
21 | 


--------------------------------------------------------------------------------
/game/world/objects/itemtorchburning.cpp:
--------------------------------------------------------------------------------
 1 | #include "itemtorchburning.h"
 2 | 
 3 | #include "world/world.h"
 4 | 
 5 | ItemTorchBurning::ItemTorchBurning(World& owner, size_t inst, Item::Type type)
 6 |   :Item(owner,inst,type) {
 7 |   auto& sc = owner.script();
 8 | 
 9 |   auto hitem = std::make_shared<zenkit::IItem>();
10 |   sc.initializeInstanceItem(hitem, inst);
11 |   view.setVisual(*hitem,owner,false);
12 | 
13 |   size_t torchId = sc.findSymbolIndex("ItLsTorchburned");
14 |   if(torchId!=size_t(-1)) {
15 |     auto hitem = std::make_shared<zenkit::IItem>();
16 |     sc.initializeInstanceItem(hitem, torchId);
17 |     auto m = Resources::loadMesh(hitem->visual);
18 |     setPhysicsEnable(m);
19 |     }
20 |   }
21 | 
22 | void ItemTorchBurning::clearView() {
23 |   Item::clearView();
24 |   view = ObjVisual();
25 |   }
26 | 
27 | bool ItemTorchBurning::isTorchBurn() const {
28 |   return true;
29 |   }
30 | 
31 | void ItemTorchBurning::moveEvent() {
32 |   Item::moveEvent();
33 |   view.setObjMatrix(transform());
34 |   }
35 | 


--------------------------------------------------------------------------------
/game/world/objects/itemtorchburning.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "item.h"
 4 | 
 5 | class ItemTorchBurning : public Item {
 6 |   public:
 7 |     ItemTorchBurning(World& owner, size_t inst, Item::Type type);
 8 | 
 9 |     void      clearView() override;
10 |     bool      isTorchBurn() const override;
11 | 
12 |   protected:
13 |     void      moveEvent() override;
14 | 
15 |   private:
16 |     ObjVisual view;
17 |   };
18 | 
19 | 


--------------------------------------------------------------------------------
/game/world/objects/pfxemitter.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <Tempest/Matrix4x4>
 4 | #include <Tempest/Vec>
 5 | 
 6 | #include "world/collisionzone.h"
 7 | #include "physics/dynamicworld.h"
 8 | #include "graphics/meshobjects.h"
 9 | 
10 | class World;
11 | class ParticleFx;
12 | class PfxBucket;
13 | class PfxObjects;
14 | class PfxEmitterMesh;
15 | 
16 | class PfxEmitter {
17 |   public:
18 |     PfxEmitter()=default;
19 |     PfxEmitter(World& world, std::string_view name);
20 |     PfxEmitter(World& world, const ParticleFx* decl);
21 |     PfxEmitter(PfxObjects& obj, const ParticleFx* vob);
22 |     PfxEmitter(World& world, const zenkit::VirtualObject& vob);
23 |     ~PfxEmitter();
24 |     PfxEmitter(PfxEmitter&&);
25 |     PfxEmitter& operator=(PfxEmitter&& b);
26 |     PfxEmitter(const PfxEmitter&)=delete;
27 | 
28 |     bool     isEmpty() const { return bucket==nullptr; }
29 |     void     setPosition (float x,float y,float z);
30 |     void     setPosition (const Tempest::Vec3& pos);
31 |     void     setDirection(const Tempest::Matrix4x4& pos);
32 |     void     setObjMatrix(const Tempest::Matrix4x4& mt);
33 |     void     setActive(bool act);
34 |     bool     isActive() const;
35 |     void     setLooped(bool loop);
36 |     void     setMesh(const MeshObjects::Mesh* mesh, const Pose* pose);
37 | 
38 |     void     setTarget(const Npc* tg);
39 | 
40 |     void     setPhysicsEnable (World& physic, std::function<void(Npc& npc)> cb);
41 |     void     setPhysicsDisable();
42 | 
43 |     uint64_t effectPrefferedTime() const;
44 |     bool     isAlive() const;
45 | 
46 |   private:
47 |     PfxEmitter(PfxBucket &b,size_t id);
48 | 
49 |     PfxBucket* bucket = nullptr;
50 |     size_t     id     = size_t(-1);
51 | 
52 |     CollisionZone      zone;
53 |     MeshObjects::Mesh  shpMesh;
54 | 
55 |   friend class PfxBucket;
56 |   friend class PfxObjects;
57 |   };
58 | 
59 | 


--------------------------------------------------------------------------------
/game/world/objects/sound.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "world/worldsound.h"
 4 | 
 5 | class Sound final {
 6 |   public:
 7 |     enum Type : uint8_t {
 8 |       T_Regular,
 9 |       T_3D,
10 |       };
11 |     Sound();
12 |     Sound(World& owner, Type t, std::string_view s, const Tempest::Vec3& pos, float range, bool freeSlot);
13 | 
14 |     Sound(Sound&& other);
15 |     Sound& operator = (Sound&& other);
16 |     ~Sound();
17 | 
18 |     Tempest::Vec3 position()   const;
19 |     bool          isEmpty()    const;
20 |     bool          isFinished() const;
21 | 
22 |     void          setOcclusion(float occ);
23 |     void          setVolume(float v);
24 |     float         volume() const;
25 | 
26 |     void          setPosition(const Tempest::Vec3& pos);
27 |     void          setPosition(float x,float y,float z);
28 | 
29 |     void          setLooping(bool l);
30 |     void          setAmbient(bool a);
31 |     void          setActive(bool a);
32 |     void          play();
33 | 
34 |     uint64_t      effectPrefferedTime() const;
35 | 
36 |   private:
37 |     Sound(const std::shared_ptr<WorldSound::Effect>& val);
38 | 
39 |     std::shared_ptr<WorldSound::Effect> val;
40 |     Tempest::Vec3                       pos;
41 | 
42 |   friend class WorldSound;
43 |   };
44 | 
45 | 


--------------------------------------------------------------------------------
/game/world/objects/staticobj.cpp:
--------------------------------------------------------------------------------
 1 | #include "staticobj.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | 
 5 | #include "world/world.h"
 6 | #include "utils/string_frm.h"
 7 | 
 8 | using namespace Tempest;
 9 | 
10 | StaticObj::StaticObj(Vob* parent, World& world, const zenkit::VirtualObject& vob, Flags flags)
11 |   : Vob(parent, world, vob, flags) {
12 |   visual.setVisual(vob,world,(flags & Flags::Static));
13 |   visual.setObjMatrix(transform());
14 | 
15 |   scheme = vob.visual->name;
16 |   }
17 | 
18 | void StaticObj::moveEvent() {
19 |   Vob::moveEvent();
20 |   visual.setObjMatrix(transform());
21 |   }
22 | 
23 | bool StaticObj::setMobState(std::string_view sc, int32_t st) {
24 |   const bool ret = Vob::setMobState(sc,st);
25 | 
26 |   if(scheme.find(sc)!=0)
27 |     return ret;
28 |   string_frm name("S_S",st);
29 |   if(visual.startAnimAndGet(name,world.tickCount())!=nullptr) {
30 |     // state = st;
31 |     return ret;
32 |     }
33 |   return false;
34 |   }
35 | 


--------------------------------------------------------------------------------
/game/world/objects/staticobj.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "graphics/objvisual.h"
 4 | #include "vob.h"
 5 | 
 6 | class StaticObj : public Vob {
 7 |   public:
 8 |     StaticObj(Vob* parent, World& world, const zenkit::VirtualObject& vob, Flags flags);
 9 | 
10 |   private:
11 |     void  moveEvent() override;
12 |     bool  setMobState(std::string_view scheme,int32_t st) override;
13 | 
14 |     ObjVisual   visual;
15 |     std::string scheme;
16 |   };
17 | 
18 | 


--------------------------------------------------------------------------------
/game/world/objects/vobbundle.cpp:
--------------------------------------------------------------------------------
 1 | #include "vobbundle.h"
 2 | 
 3 | #include "world/world.h"
 4 | #include "resources.h"
 5 | 
 6 | VobBundle::VobBundle(World& owner, std::string_view filename, Vob::Flags flags) {
 7 |   auto* bundle = Resources::loadVobBundle(filename);
 8 |   for(auto& vob:*bundle)
 9 |     rootVobs.emplace_back(Vob::load(nullptr,owner,*vob,(flags | Vob::Startup)));
10 |   }
11 | 
12 | void VobBundle::setObjMatrix(const Tempest::Matrix4x4& obj) {
13 |   for(auto& i:rootVobs)
14 |     i->setLocalTransform(obj);
15 |   }
16 | 


--------------------------------------------------------------------------------
/game/world/objects/vobbundle.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | 
 5 | #include "vob.h"
 6 | 
 7 | class VobBundle {
 8 |   public:
 9 |     VobBundle() = default;
10 |     VobBundle(World& owner, std::string_view filename, Vob::Flags flags);
11 | 
12 |     void setObjMatrix(const Tempest::Matrix4x4& obj);
13 | 
14 |   private:
15 |     std::vector<std::unique_ptr<Vob>> rootVobs;
16 |   };
17 | 
18 | 


--------------------------------------------------------------------------------
/game/world/triggers/codemaster.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class World;
 6 | 
 7 | class CodeMaster : public AbstractTrigger {
 8 |   public:
 9 |     CodeMaster(Vob* parent, World &world, const zenkit::VCodeMaster& data, Flags flags);
10 | 
11 |     void onTrigger(const TriggerEvent& evt) override;
12 | 
13 |   private:
14 |     void save(Serialize& fout) const override;
15 |     void load(Serialize &fin) override;
16 | 
17 |     void onFailure();
18 |     void onSuccess();
19 |     void zeroState();
20 | 
21 |     std::vector<bool>        keys;
22 |     std::vector<std::string> slaves;
23 |     uint32_t                 count               = 0;
24 |     bool                     ordered             = false;
25 |     bool                     firstFalseIsFailure = false;
26 |     std::string              failureTarget;
27 |     bool                     untriggeredCancels  = false;
28 |   };
29 | 
30 | 


--------------------------------------------------------------------------------
/game/world/triggers/cscamera.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/vobs/Camera.hh>
 4 | 
 5 | #include "abstracttrigger.h"
 6 | 
 7 | class World;
 8 | 
 9 | class CsCamera : public AbstractTrigger {
10 |   public:
11 |     CsCamera(Vob* parent, World& world, const zenkit::VCutsceneCamera& data, Flags flags);
12 | 
13 |     bool isPlayerMovable() const;
14 | 
15 |   private:
16 |     struct KeyFrame {
17 |       float         time = 0;
18 |       Tempest::Vec3 c[4] = {};
19 |       };
20 | 
21 |     struct KbSpline {
22 |       float                 c[3]     = {};
23 |       float                 splTime  = 0;
24 |       std::vector<KeyFrame> keyframe;
25 |       size_t size() const { return keyframe.size(); }
26 |       auto   position() const -> Tempest::Vec3;
27 |       void   setSplTime(float t);
28 |       float  applyMotionScaling(float t) const;
29 |       };
30 | 
31 |     void onTrigger(const TriggerEvent& evt) override;
32 |     void onUntrigger(const TriggerEvent& evt) override;
33 |     void tick(uint64_t dt) override;
34 | 
35 |     auto position() -> Tempest::Vec3;
36 |     auto spin(Tempest::Vec3& d) -> Tempest::PointF;
37 | 
38 |     bool     active        = false;
39 |     bool     godMode       = false;
40 |     bool     playerMovable = false;
41 |     bool     autoUntrigger = false;
42 |     float    durationF     = 0;
43 |     uint64_t duration      = 0;
44 |     uint64_t delay         = 0;
45 |     uint64_t time          = 0;
46 |     KbSpline posSpline     = {};
47 |     KbSpline targetSpline  = {};
48 |   };
49 | 


--------------------------------------------------------------------------------
/game/world/triggers/earthquake.cpp:
--------------------------------------------------------------------------------
 1 | #include "earthquake.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | 
 5 | using namespace Tempest;
 6 | 
 7 | Earthquake::Earthquake(Vob* parent, World& world, const zenkit::VEarthquake& data, Flags flags)
 8 |   : AbstractTrigger(parent,world,data,flags) {
 9 |   }
10 | 
11 | void Earthquake::onTrigger(const TriggerEvent& evt) {
12 |   Log::d("TODO: earthquake, \"", name() , "\"");
13 |   }
14 | 


--------------------------------------------------------------------------------
/game/world/triggers/earthquake.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class World;
 6 | 
 7 | class Earthquake : public AbstractTrigger {
 8 |   public:
 9 |     Earthquake(Vob* parent, World& world, const zenkit::VEarthquake& data, Flags flags);
10 | 
11 |     void onTrigger(const TriggerEvent& evt) override;
12 | 
13 |   private:
14 | 
15 |   };
16 | 


--------------------------------------------------------------------------------
/game/world/triggers/messagefilter.cpp:
--------------------------------------------------------------------------------
 1 | #include "messagefilter.h"
 2 | 
 3 | #include "world/world.h"
 4 | 
 5 | MessageFilter::MessageFilter(Vob* parent, World &world, const zenkit::VMessageFilter& filt, Flags flags)
 6 |   :AbstractTrigger(parent,world,filt,flags) {
 7 |   target = filt.target;
 8 |   onUntriggerA = filt.on_untrigger;
 9 |   onTriggerA = filt.on_trigger;
10 |   }
11 | 
12 | void MessageFilter::onTrigger(const TriggerEvent&) {
13 |   exec(onTriggerA);
14 |   }
15 | 
16 | void MessageFilter::onUntrigger(const TriggerEvent&) {
17 |   exec(onUntriggerA);
18 |   }
19 | 
20 | void MessageFilter::exec(zenkit::MessageFilterAction eval) {
21 |   switch(eval) {
22 |     case zenkit::MessageFilterAction::NONE:
23 |       break;
24 |     case zenkit::MessageFilterAction::TRIGGER: {
25 |       TriggerEvent e(target,vobName,TriggerEvent::T_Trigger);
26 |       world.execTriggerEvent(e);
27 |       break;
28 |       }
29 |     case zenkit::MessageFilterAction::UNTRIGGER: {
30 |       TriggerEvent e(target,vobName,TriggerEvent::T_Untrigger);
31 |       world.execTriggerEvent(e);
32 |       break;
33 |       }
34 |     case zenkit::MessageFilterAction::ENABLE: {
35 |       TriggerEvent e(target,vobName,TriggerEvent::T_Enable);
36 |       world.execTriggerEvent(e);
37 |       break;
38 |       }
39 |     case zenkit::MessageFilterAction::DISABLE:{
40 |       TriggerEvent e(target,vobName,TriggerEvent::T_Disable);
41 |       world.execTriggerEvent(e);
42 |       break;
43 |       }
44 |     case zenkit::MessageFilterAction::TOGGLE:{
45 |       TriggerEvent e(target,vobName,TriggerEvent::T_ToggleEnable);
46 |       world.execTriggerEvent(e);
47 |       break;
48 |       }
49 |     }
50 |   }
51 | 


--------------------------------------------------------------------------------
/game/world/triggers/messagefilter.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class MessageFilter : public AbstractTrigger {
 6 |   public:
 7 |     MessageFilter(Vob* parent, World& world, const zenkit::VMessageFilter& data, Flags flags);
 8 | 
 9 |   private:
10 |     void onTrigger(const TriggerEvent& evt) override;
11 |     void onUntrigger(const TriggerEvent& evt) override;
12 | 
13 |     void exec(zenkit::MessageFilterAction type);
14 | 
15 |     zenkit::MessageFilterAction onUntriggerA;
16 |     zenkit::MessageFilterAction onTriggerA;
17 |   };
18 | 


--------------------------------------------------------------------------------
/game/world/triggers/movercontroler.cpp:
--------------------------------------------------------------------------------
 1 | #include "movercontroler.h"
 2 | 
 3 | #include "world/world.h"
 4 | 
 5 | MoverControler::MoverControler(Vob* parent, World &world, const zenkit::VMoverController& ctrl, Flags flags)
 6 |   :AbstractTrigger(parent,world,ctrl,flags) {
 7 |   target = ctrl.target;
 8 |   message = ctrl.message;
 9 |   key = uint32_t(ctrl.key);
10 |   }
11 | 
12 | void MoverControler::onUntrigger(const TriggerEvent&) {
13 |   }
14 | 
15 | void MoverControler::onTrigger(const TriggerEvent&) {
16 |   TriggerEvent ex(target,vobName,0,TriggerEvent::T_Move);
17 |   ex.move.msg = message;
18 |   ex.move.key = int(key);
19 |   world.execTriggerEvent(ex);
20 |   }
21 | 


--------------------------------------------------------------------------------
/game/world/triggers/movercontroler.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class MoverControler : public AbstractTrigger {
 6 |   public:
 7 |     MoverControler(Vob* parent, World& world, const zenkit::VMoverController& data, Flags flags);
 8 | 
 9 |   private:
10 |     void onTrigger(const TriggerEvent& evt) override;
11 |     void onUntrigger(const TriggerEvent& evt) override;
12 | 
13 |   public:
14 |     zenkit::MoverMessageType message;
15 |     uint32_t                 key;
16 |   };
17 | 
18 | 
19 | 


--------------------------------------------------------------------------------
/game/world/triggers/pfxcontroller.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | #include "world/objects/pfxemitter.h"
 5 | 
 6 | class World;
 7 | 
 8 | class PfxController : public AbstractTrigger {
 9 |   public:
10 |     PfxController(Vob* parent, World& world, const zenkit::VParticleEffectController& data, Flags flags);
11 | 
12 |     void save(Serialize &fout) const override;
13 |     void load(Serialize &fin) override;
14 | 
15 |   private:
16 |     void onTrigger(const TriggerEvent& evt) override;
17 |     void onUntrigger(const TriggerEvent& evt) override;
18 |     void moveEvent() override;
19 |     void tick(uint64_t dt) override;
20 | 
21 |     PfxEmitter visual;
22 |     PfxEmitter pfx;
23 |     uint64_t   killed   = std::numeric_limits<uint64_t>::max();
24 |     uint64_t   lifeTime = 0;
25 |     bool       killWhenDone;
26 |   };
27 | 


--------------------------------------------------------------------------------
/game/world/triggers/touchdamage.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class World;
 6 | 
 7 | class TouchDamage : public AbstractTrigger {
 8 |   public:
 9 |     TouchDamage(Vob* parent, World &world, const zenkit::VTouchDamage& data, Flags flags);
10 | 
11 |   private:
12 |     void onTrigger(const TriggerEvent &evt) override;
13 |     void onIntersect(Npc& n) override;
14 |     void tick(uint64_t dt) override;
15 |     void takeDamage(Npc& npc, int32_t val, int32_t prot);
16 | 
17 |     uint64_t repeatTimeout = 0;
18 |     bool     barrier = false;
19 |     bool     blunt = false;
20 |     bool     edge = false;
21 |     bool     fire = false;
22 |     bool     fly = false;
23 |     bool     magic = false;
24 |     bool     point = false;
25 |     bool     fall = false;
26 |     float    damage = 0;
27 |     float    repeatDelaySec = 0;
28 |   };
29 | 


--------------------------------------------------------------------------------
/game/world/triggers/trigger.cpp:
--------------------------------------------------------------------------------
 1 | #include "trigger.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | 
 5 | #include "world/world.h"
 6 | 
 7 | using namespace Tempest;
 8 | 
 9 | Trigger::Trigger(Vob* parent, World &world, const zenkit::VirtualObject& d, Flags flags)
10 |   :AbstractTrigger(parent,world,d,flags) {
11 |   }
12 | 
13 | void Trigger::onTrigger(const TriggerEvent&) {
14 |   TriggerEvent e(target,vobName,TriggerEvent::T_Trigger);
15 |   world.triggerEvent(e);
16 |   }
17 | 


--------------------------------------------------------------------------------
/game/world/triggers/trigger.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class Trigger : public AbstractTrigger {
 6 |   public:
 7 |     Trigger(Vob* parent, World& world, const zenkit::VirtualObject& data, Flags flags);
 8 | 
 9 |     void onTrigger(const TriggerEvent& evt) override;
10 |   };
11 | 


--------------------------------------------------------------------------------
/game/world/triggers/triggerlist.cpp:
--------------------------------------------------------------------------------
 1 | #include "triggerlist.h"
 2 | 
 3 | #include <Tempest/Log>
 4 | 
 5 | #include "world/world.h"
 6 | #include "game/serialize.h"
 7 | 
 8 | using namespace Tempest;
 9 | 
10 | TriggerList::TriggerList(Vob* parent, World &world, const zenkit::VTriggerList& list, Flags flags)
11 |   :AbstractTrigger(parent,world,list,flags) {
12 |   targets = list.targets;
13 |   listProcess = list.mode;
14 |   }
15 | 
16 | void TriggerList::onTrigger(const TriggerEvent&) {
17 |   if(targets.empty())
18 |     return;
19 | 
20 |   switch(listProcess) {
21 |     case zenkit::TriggerBatchMode::ALL: {
22 |       uint64_t offset = 0;
23 |       for(auto& i:targets) {
24 |         offset += uint64_t(i.delay*1000);
25 |         uint64_t time = world.tickCount()+offset;
26 |         TriggerEvent ex(i.name,vobName,time,TriggerEvent::T_Trigger);
27 |         world.execTriggerEvent(ex);
28 |         }
29 |       break;
30 |       }
31 |     case zenkit::TriggerBatchMode::NEXT: {
32 |       auto& i = targets[next];
33 |       next = (next+1)%uint32_t(targets.size());
34 | 
35 |       uint64_t time = world.tickCount()+uint64_t(i.delay*1000);
36 |       TriggerEvent ex(i.name,vobName,time,TriggerEvent::T_Trigger);
37 |       world.execTriggerEvent(ex);
38 |       break;
39 |       }
40 |     case zenkit::TriggerBatchMode::RANDOM: {
41 |       auto& i = targets[world.script().rand(uint32_t(targets.size()))];
42 | 
43 |       uint64_t time = world.tickCount()+uint64_t(i.delay*1000);
44 |       TriggerEvent ex(i.name,vobName,time,TriggerEvent::T_Trigger);
45 |       world.execTriggerEvent(ex);
46 |       break;
47 |       }
48 |     }
49 |   }
50 | 
51 | void TriggerList::save(Serialize& fout) const {
52 |   AbstractTrigger::save(fout);
53 |   fout.write(next);
54 |   }
55 | 
56 | void TriggerList::load(Serialize& fin) {
57 |   AbstractTrigger::load(fin);
58 |   fin.read(next);
59 |   }
60 | 


--------------------------------------------------------------------------------
/game/world/triggers/triggerlist.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/vobs/Trigger.hh>
 4 | 
 5 | #include "abstracttrigger.h"
 6 | 
 7 | class World;
 8 | 
 9 | class TriggerList : public AbstractTrigger {
10 |   public:
11 |     TriggerList(Vob* parent, World &world, const zenkit::VTriggerList& data, Flags flags);
12 | 
13 |     void onTrigger(const TriggerEvent& evt) override;
14 | 
15 |   private:
16 |     void save(Serialize &fout) const override;
17 |     void load(Serialize &fin) override;
18 | 
19 |     enum ProcessMode : uint8_t {
20 |       LP_ALL  = 0,
21 |       LP_NEXT = 1,
22 |       LP_RAND = 2
23 |       };
24 |     uint32_t next=0;
25 |     std::vector<zenkit::VTriggerList::Target> targets;
26 |     zenkit::TriggerBatchMode                  listProcess;
27 |   };
28 | 


--------------------------------------------------------------------------------
/game/world/triggers/triggerscript.cpp:
--------------------------------------------------------------------------------
 1 | #include "triggerscript.h"
 2 | 
 3 | #include <zenkit/vobs/Trigger.hh>
 4 | #include <Tempest/Log>
 5 | 
 6 | #include "world/world.h"
 7 | 
 8 | TriggerScript::TriggerScript(Vob* parent, World &world, const zenkit::VTriggerScript& data, Flags flags)
 9 |   :AbstractTrigger(parent,world,data,flags) {
10 |   function = data.function;
11 |   }
12 | 
13 | void TriggerScript::onTrigger(const TriggerEvent &) {
14 |   try {
15 |     world.script().getVm().call_function(function);
16 |     }
17 |   catch(const std::exception& e){
18 |     Tempest::Log::e("exception in trigger-script: ",e.what());
19 |     }
20 |   }
21 | 


--------------------------------------------------------------------------------
/game/world/triggers/triggerscript.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class World;
 6 | 
 7 | class TriggerScript : public AbstractTrigger {
 8 |   public:
 9 |     TriggerScript(Vob* parent, World& world, const zenkit::VTriggerScript& data, Flags flags);
10 | 
11 |     void onTrigger(const TriggerEvent& evt) override;
12 | 
13 |   private:
14 |     std::string function;
15 |   };
16 | 


--------------------------------------------------------------------------------
/game/world/triggers/triggerworldstart.cpp:
--------------------------------------------------------------------------------
 1 | #include "triggerworldstart.h"
 2 | 
 3 | #include <zenkit/vobs/Trigger.hh>
 4 | 
 5 | #include "world/world.h"
 6 | 
 7 | TriggerWorldStart::TriggerWorldStart(Vob* parent, World &world, const zenkit::VTriggerWorldStart& trg, Flags flags)
 8 |   :AbstractTrigger(parent,world,trg,flags){
 9 |   fireOnlyFirstTime = trg.fire_once;
10 |   target = trg.target;
11 |   }
12 | 
13 | void TriggerWorldStart::onTrigger(const TriggerEvent &ev) {
14 |   if(fireOnlyFirstTime && ev.type!=TriggerEvent::T_StartupFirstTime)
15 |     return;
16 | 
17 |   TriggerEvent e(target,vobName,TriggerEvent::T_Trigger);
18 |   world.execTriggerEvent(e);
19 |   }
20 | 


--------------------------------------------------------------------------------
/game/world/triggers/triggerworldstart.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class World;
 6 | 
 7 | class TriggerWorldStart : public AbstractTrigger {
 8 |   public:
 9 |     TriggerWorldStart(Vob* parent, World& world, const zenkit::VTriggerWorldStart& data, Flags flags);
10 | 
11 |     void onTrigger(const TriggerEvent& evt) override;
12 | 
13 |   private:
14 |     bool fireOnlyFirstTime;
15 |   };
16 | 


--------------------------------------------------------------------------------
/game/world/triggers/zonetrigger.cpp:
--------------------------------------------------------------------------------
 1 | #include "zonetrigger.h"
 2 | 
 3 | #include <zenkit/vobs/Trigger.hh>
 4 | 
 5 | #include "world/objects/npc.h"
 6 | #include "world/world.h"
 7 | 
 8 | ZoneTrigger::ZoneTrigger(Vob* parent, World &world, const zenkit::VTriggerChangeLevel& trig, Flags flags)
 9 |   :AbstractTrigger(parent,world,trig,flags){
10 |   levelName = trig.level_name;
11 |   startVobName = trig.start_vob;
12 |   }
13 | 
14 | void ZoneTrigger::onIntersect(Npc &n) {
15 |   if(n.isPlayer())
16 |     world.triggerChangeWorld(levelName, startVobName);
17 |   }
18 | 


--------------------------------------------------------------------------------
/game/world/triggers/zonetrigger.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "abstracttrigger.h"
 4 | 
 5 | class ZoneTrigger : public AbstractTrigger {
 6 |   public:
 7 |     ZoneTrigger(Vob* parent, World& world, const zenkit::VTriggerChangeLevel& data, Flags flags);
 8 | 
 9 |     void onIntersect(Npc& n) override;
10 | 
11 |   private:
12 |     std::string levelName;
13 |     std::string startVobName;
14 |   };
15 | 


--------------------------------------------------------------------------------
/game/world/waypath.cpp:
--------------------------------------------------------------------------------
 1 | #include "waypath.h"
 2 | 
 3 | #include "game/serialize.h"
 4 | #include <cstdint>
 5 | 
 6 | WayPath::WayPath() {
 7 |   }
 8 | 
 9 | void WayPath::load(Serialize &fin) {
10 |   uint32_t sz=0;
11 |   fin.read(sz);
12 |   dat.resize(sz);
13 | 
14 |   for(auto& i:dat)
15 |     fin.read(i);
16 |   }
17 | 
18 | void WayPath::save(Serialize &fout) {
19 |   fout.write(uint32_t(dat.size()));
20 | 
21 |   for(auto& i:dat)
22 |     fout.write(i);
23 |   }
24 | 
25 | void WayPath::clear() {
26 |   dat.clear();
27 |   }
28 | 
29 | void WayPath::reverse() {
30 |   for(size_t i=0; i<dat.size()/2; ++i) {
31 |     std::swap(dat[i], dat[dat.size()-i-1]);
32 |     }
33 |   }
34 | 
35 | const WayPoint *WayPath::pop() {
36 |   if(dat.size()==0)
37 |     return nullptr;
38 |   auto ret = dat[dat.size()-1];
39 |   dat.pop_back();
40 |   return ret;
41 |   }
42 | 
43 | const WayPoint *WayPath::first() const {
44 |   if(dat.size()==0)
45 |     return nullptr;
46 |   return dat[dat.size()-1];
47 |   }
48 | 
49 | const WayPoint *WayPath::last() const {
50 |   if(dat.size()==0)
51 |     return nullptr;
52 |   return dat[0];
53 |   }
54 | 


--------------------------------------------------------------------------------
/game/world/waypath.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | 
 5 | class WayPoint;
 6 | class Serialize;
 7 | 
 8 | class WayPath final {
 9 |   public:
10 |     WayPath();
11 | 
12 |     void load(Serialize& fin);
13 |     void save(Serialize& fout);
14 | 
15 |     void add(const WayPoint& p){ dat.push_back(&p); }
16 |     void clear();
17 |     void reverse();
18 | 
19 |     const WayPoint* pop();
20 |     const WayPoint* first() const;
21 |     const WayPoint* last()  const;
22 | 
23 |   private:
24 |     std::vector<const WayPoint*> dat;
25 |   };
26 | 


--------------------------------------------------------------------------------
/game/world/waypoint.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <zenkit/world/WayNet.hh>
 4 | 
 5 | #include <limits>
 6 | #include <Tempest/Vec>
 7 | 
 8 | class FpLock;
 9 | class Interactive;
10 | 
11 | class WayPoint final {
12 |   public:
13 |     WayPoint();
14 |     WayPoint(const zenkit::WayPoint& dat);
15 |     WayPoint(const Tempest::Vec3& pos, std::string_view name);
16 |     WayPoint(const Tempest::Vec3& pos, const Tempest::Vec3& dir, std::string_view name);
17 |     WayPoint(const WayPoint&)=default;
18 |     WayPoint(WayPoint&&)=default;
19 | 
20 |     WayPoint& operator = (WayPoint&&)=default;
21 |     bool isLocked() const { return useCount!=0; }
22 |     bool isFreePoint() const;
23 | 
24 |     uint32_t useCounter() const { return useCount; }
25 |     bool checkName(std::string_view name) const;
26 | 
27 |     Tempest::Vec3 position() const;
28 | 
29 |     float x=0;
30 |     float y=0;
31 |     float z=0;
32 | 
33 |     float dirX=0;
34 |     float dirY=0;
35 |     float dirZ=0;
36 | 
37 |     bool  underWater = false;
38 | 
39 |     std::string name;
40 | 
41 |     Interactive* ladder = nullptr;
42 | 
43 |     struct Conn final {
44 |       WayPoint* point=nullptr;
45 |       int32_t   len  =0;
46 |       };
47 | 
48 |     // TODO: beautify
49 |     mutable int32_t  pathLen=std::numeric_limits<int32_t>::max();
50 |     mutable uint16_t pathGen=0;
51 | 
52 |     float qDistTo(float x,float y,float z) const;
53 | 
54 |     void connect(WayPoint& w);
55 |     const std::vector<Conn>& connections() const { return conn; }
56 |     bool hasLadderConn(const WayPoint* w) const;
57 | 
58 |   private:
59 |     mutable uint32_t useCount=0;
60 | 
61 |     std::vector<Conn> conn;
62 | 
63 |     static std::string upcaseof(std::string_view src);
64 | 
65 |   friend class FpLock;
66 |   };
67 | 


--------------------------------------------------------------------------------
/game/world/worldlight.cpp:
--------------------------------------------------------------------------------
 1 | #include "worldlight.h"
 2 | 
 3 | #include "world.h"
 4 | 
 5 | WorldLight::WorldLight(Vob* parent, World& world, const zenkit::VLight& vob, Flags flags)
 6 |   : Vob(parent,world,vob,flags) {
 7 |   light = world.addLight(vob);
 8 |   if(!vob.is_static && !vob.on)
 9 |     light.setEnabled(false);
10 | 
11 |   if(vob.is_static && vob.quality==zenkit::LightQuality::LOW && vob.preset=="NW_STANDART_DARKBLUE") {
12 |     // crazy light-spam in many caves
13 |     light.setEnabled(false);
14 |     }
15 |   if(vob.is_static && vob.range>3000.0) {
16 |     // unmotivated light blobs in old-mine ("MINE_DARK"/"MINE_DARKLIGHT")
17 |     light.setEnabled(false);
18 |     }
19 |   }
20 | 
21 | void WorldLight::moveEvent() {
22 |   light.setPosition(position());
23 |   }
24 | 


--------------------------------------------------------------------------------
/game/world/worldlight.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "world/objects/vob.h"
 4 | #include "graphics/lightgroup.h"
 5 | 
 6 | class WorldLight : public Vob {
 7 |   public:
 8 |     WorldLight(Vob* parent, World& world, const zenkit::VLight& vob, Flags flags);
 9 | 
10 |   private:
11 |     void  moveEvent() override;
12 | 
13 |     LightGroup::Light light;
14 |   };
15 | 
16 | 


--------------------------------------------------------------------------------
/icon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Try/OpenGothic/df960680fe0e14a013f353767b6794caaff5b288/icon.ico


--------------------------------------------------------------------------------
/icon.rc:
--------------------------------------------------------------------------------
1 | #include <windows.h>
2 | 
3 | IDI_ICON1	ICON	DISCARDABLE	"icon.ico"
4 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.4)
 2 | project(edd_dbg)
 3 | 
 4 | set(CMAKE_CXX_STANDARD 14)
 5 | 
 6 | file(GLOB SOURCES
 7 |     "src/*.h"
 8 |     "src/*.cpp")
 9 | 
10 | if(MINGW)
11 |   file(GLOB SOURCES_WINDOWS
12 |       "src/windows/*.hpp"
13 |       "src/windows/*.cpp"
14 |       "src/windows/mingw/*.hpp"
15 |       "src/windows/mingw/*.cpp")
16 | elseif(MSVC)
17 |   file(GLOB SOURCES_WINDOWS
18 |       "src/windows/*.hpp"
19 |       "src/windows/*.cpp"
20 |       "src/windows/msvc/*.hpp"
21 |       "src/windows/msvc/*.cpp")
22 | endif(MINGW)
23 | 
24 | file(GLOB SOURCES_OSX
25 |     "src/osx/*.hpp"
26 |     "src/osx/*.cpp")
27 | 
28 | add_definitions("-DDBG_DONT_USE_FUNGO")
29 | 
30 | if(APPLE)
31 |   add_library(edd_dbg STATIC ${SOURCES} ${SOURCES_OSX})
32 | elseif(WIN32)
33 |   add_library(edd_dbg STATIC ${SOURCES} ${SOURCES_WINDOWS})
34 | endif(APPLE)
35 | 
36 | 
37 | include_directories(include)
38 | include_directories(src)
39 | include_directories(src/windows)
40 | 
41 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/include/dbg/debugger.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef DEBUGGER_HPP_0330_15072012
 7 | #define DEBUGGER_HPP_0330_15072012
 8 | 
 9 | namespace dbg 
10 | {
11 |     bool debugger_attached();
12 | 
13 |     // Break in to the debugger. This should only be called if it has been determined
14 |     // that a debugger is attached.
15 |     void debugger_break();
16 | 
17 | } // dbg
18 | 
19 | #endif // DEBUGGER_HPP_0330_15072012
20 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/include/dbg/fatality.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef FATALITY_HPP_2041_25082012
 7 | #define FATALITY_HPP_2041_25082012
 8 | 
 9 | namespace dbg 
10 | {
11 |     typedef void (*fatality_handler)(void);
12 | 
13 |     // Set the function called when a fatal condition is encountered.
14 |     // By default this function is std::abort.
15 |     // The old handler is returned.
16 |     // Typically called at the start of a program.
17 |     fatality_handler set_fatality_handler(fatality_handler handler);
18 | 
19 |     // Get the current fatality handler.
20 |     fatality_handler get_fatality_handler();
21 | 
22 | } // dbg
23 | 
24 | #endif // FATALITY_HPP_2041_25082012
25 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/include/dbg/log.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef LOG_HPP_1456_18072012
 7 | #define LOG_HPP_1456_18072012
 8 | 
 9 | #include <cstddef>
10 | 
11 | namespace dbg 
12 | {
13 |     class logsink
14 |     {
15 |         public:
16 |             logsink() { }
17 |             virtual ~logsink() { }
18 | 
19 |             // Derived implementations should override this to write the specified
20 |             // number of characters from text to the underlying sink.
21 |             // Any synchronization required for multithreaded logging should be
22 |             // performed by the derived implementation.
23 |             virtual void write(const char *text, std::size_t n) = 0;
24 | 
25 |         private:
26 |             logsink(const logsink &);
27 |             logsink &operator= (const logsink &);
28 |     };
29 | 
30 |     // Sets the currently active sink. The specified sink must exist for as long as
31 |     // it is active.
32 |     // Returns the old sink.
33 |     logsink &set_logsink(logsink &sink);
34 | 
35 |     // Returns the active logsink.
36 |     logsink &get_logsink();
37 | 
38 |     // Writes to the currently active sink.
39 |     // Used by the library for logging assertions, notes, etc.
40 |     void log_write(const char *text, std::size_t n);
41 | 
42 | 
43 | } // dbg
44 | 
45 | #endif // LOG_HPP_1456_18072012
46 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/include/dbg/logstream.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef LOGSTREAM_HPP_1309_18072012
 7 | #define LOGSTREAM_HPP_1309_18072012
 8 | 
 9 | #include <ostream>
10 | #include <streambuf>
11 | 
12 | namespace dbg 
13 | {
14 |     // Used in logstream. Ultimately writes data to the currently active log_sink
15 |     // through dbg::log_write().
16 |     class logbuf : public std::streambuf
17 |     {
18 |         public:
19 |             logbuf();
20 |             ~logbuf() { flush(); }
21 | 
22 |             void flush();
23 | 
24 |         private:
25 |             virtual int_type overflow(int_type ch);
26 |             virtual int sync() { flush(); return 0; }
27 | 
28 |         private:
29 |             // Stack traces can get pretty large (template functions, long module paths). 
30 |             // It would be nice to be able to write them all in one go (under the same 
31 |             // lock). So the internal buffer is relatively large.
32 |             char buffer[4096];
33 |     };
34 | 
35 |     // Ultimately writes data to the currently active log_sink through dbg::log_write().
36 |     class logstream : public std::ostream
37 |     {
38 |         public:
39 |             logstream() : std::ostream(0) { rdbuf(&buff); }
40 | 
41 |         private:
42 |             logbuf buff;
43 |     };
44 | 
45 | } // dbg
46 | 
47 | #endif // LOGSTREAM_HPP_1309_18072012
48 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/include/dbg/static_assert.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef STATIC_ASSERT_HPP_1634_14072012
 7 | #define STATIC_ASSERT_HPP_1634_14072012
 8 | 
 9 | #include "dbg/config.hpp"
10 | 
11 | namespace dbg 
12 | {
13 |     template<bool> struct static_assertion_check;
14 |     template<> struct static_assertion_check<true> { static const int value = 1; };
15 | 
16 | } // dbg
17 | 
18 | #define DBG_STATIC_ASSERT(condition) \
19 |     enum DBG_TOKEN_JOIN(dbg_static_assertion_, DBG_UNIQUENESS_TOKEN) \
20 |     { \
21 |         DBG_TOKEN_JOIN(dbg_static_assertion_value, DBG_UNIQUENESS_TOKEN) = \
22 |             ::dbg::static_assertion_check<(condition)>::value \
23 |     }
24 | 
25 | #endif // STATIC_ASSERT_HPP_1634_14072012
26 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/include/dbg/symlog.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef SYMLOG_HPP_2357_23062012
 7 | #define SYMLOG_HPP_2357_23062012
 8 | 
 9 | #include "dbg/symbols.hpp"
10 | #include <iosfwd>
11 | 
12 | namespace dbg 
13 | {
14 |     // Implements the symsink interface to log function and module names.
15 |     class symlog : public symsink
16 |     {
17 |         public:
18 |             symlog(std::ostream &out, const char *prefix = "", const char *suffix = "");
19 | 
20 |         private:
21 |             // Writes "<prefix><program_counter>: <name> in <module><suffix>".
22 |             virtual void process_function(const void *program_counter, const char *name, const char *module);
23 |         
24 |         private:
25 |             std::ostream &out;
26 |             const char *prefix;
27 |             const char *suffix;
28 |     };
29 | 
30 | } // dbg
31 | 
32 | #endif // SYMLOG_HPP_2357_23062012
33 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/include/dbg/version.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef VERSION_HPP_1922_02092012
 7 | #define VERSION_HPP_1922_02092012
 8 | 
 9 | #define DBG_VERSION_MAJOR 0
10 | #define DBG_VERSION_MINOR 2
11 | #define DBG_VERSION_TWEAK 1
12 | 
13 | #define DBG_VERSION (DBG_VERSION_MAJOR * 10000 + DBG_VERSION_MINOR * 100 + DBG_VERSION_TWEAK)
14 | 
15 | #endif // VERSION_HPP_1922_02092012
16 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/assert.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #define DBG_ENABLE_ASSERT 1
 7 | #include "dbg/assert.hpp"
 8 | 
 9 | namespace dbg 
10 | {
11 |     namespace impl 
12 |     {
13 |         assertion::assertion(bool pass, const char *file, unsigned line, const char *function, unsigned skip_frames) :
14 |             quality_infraction(pass, true, "An assertion has been triggered:", file, line, function, skip_frames)
15 |         {
16 |         }
17 | 
18 |         assertion::~assertion() 
19 |         {
20 |             finish();
21 |         }
22 | 
23 |         unreachable::unreachable(const char *file, unsigned line, const char *function) :
24 |             quality_infraction(false, true, "Unreachable code path encountered:", file, line, function, 0)
25 |         {
26 |         }
27 | 
28 |         unreachable::~unreachable() 
29 |         {
30 |             finish();
31 |         }
32 |     
33 |     } // impl
34 | 
35 | } // dbg
36 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/envvar.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef ENVVAR_HPP_2223_03092012
 7 | #define ENVVAR_HPP_2223_03092012
 8 | 
 9 | namespace dbg 
10 | {
11 |     bool envvar_is_set(const char *name);
12 | 
13 | } // dbg
14 | 
15 | #endif // ENVVAR_HPP_2223_03092012
16 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/format.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dbg/impl/format.hpp"
 7 | 
 8 | #include <ostream>
 9 | 
10 | namespace dbg 
11 | {
12 |     namespace impl 
13 |     {
14 |         void format(std::ostream &out, char x) { out << x; }
15 |         void format(std::ostream &out, signed char x) { out << x; }
16 |         void format(std::ostream &out, unsigned char x) { out << x; }
17 |         void format(std::ostream &out, wchar_t x) { out << x; }
18 |         void format(std::ostream &out, short x) { out << x; }
19 |         void format(std::ostream &out, unsigned short x) { out << x; }
20 |         void format(std::ostream &out, int x) { out << x; }
21 |         void format(std::ostream &out, unsigned int x) { out << x; }
22 |         void format(std::ostream &out, long x) { out << x; }
23 |         void format(std::ostream &out, unsigned long x) { out << x; }
24 |         void format(std::ostream &out, bool x) { out << x; }
25 |         void format(std::ostream &out, float x) { out << x; }
26 |         void format(std::ostream &out, double x) { out << x; }
27 |         void format(std::ostream &out, long double x) { out << x; }
28 |         void format(std::ostream &out, const void *x) { out << x; }
29 |         void format(std::ostream &out, const char *x) { out << x; }
30 |         void format(std::ostream &out, const signed char *x) { out << x; }
31 |         void format(std::ostream &out, const unsigned char *x) { out << x; }
32 |     
33 |     } // impl
34 | 
35 | } // dbg
36 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/log.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dbg/log.hpp"
 7 | 
 8 | #include <cstdio>
 9 | #include <cassert>
10 | 
11 | namespace dbg 
12 | {
13 |     namespace
14 |     {
15 |         struct default_logsink : logsink
16 |         {
17 |             virtual void write(const char *text, std::size_t n)
18 |             {
19 |                 std::fwrite(text, n, 1, stderr);
20 |             }
21 |         };
22 | 
23 |         default_logsink default_sink;
24 | 
25 |         logsink *current_sink = &default_sink;
26 | 
27 |     } // anonymous
28 | 
29 |     logsink &set_logsink(logsink &sink)
30 |     {
31 |         assert(current_sink);
32 |         logsink *old = current_sink;
33 |         current_sink = &sink;
34 |         return *old;
35 |     }
36 | 
37 |     logsink &get_logsink()
38 |     {
39 |         assert(current_sink);
40 |         return *current_sink;
41 |     }
42 | 
43 |     void log_write(const char *text, std::size_t n)
44 |     {
45 |         assert(current_sink);
46 |         current_sink->write(text, n);
47 |     }
48 | 
49 | } // dbg
50 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/logstream.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dbg/logstream.hpp"
 7 | #include "dbg/log.hpp"
 8 | 
 9 | namespace dbg 
10 | {
11 |     logbuf::logbuf()
12 |     {
13 |         setp(buffer, buffer + (sizeof buffer) - 1); // -1 to make overflow() simpler
14 |     }
15 | 
16 |     void logbuf::flush()
17 |     {
18 |         const std::ptrdiff_t n = pptr() - pbase();
19 |         if (n)
20 |         {
21 |             log_write(pbase(), n);
22 |             pbump(-n);
23 |         }
24 |     }
25 | 
26 |     logbuf::int_type logbuf::overflow(logbuf::int_type ch)
27 |     {
28 |         if (ch != traits_type::eof())
29 |         {
30 |             // We always have space for one more character at the back due to our
31 |             // having specified a pointer one position before 'end' in the setp()
32 |             // call in the constructor.
33 |             *pptr() = traits_type::to_char_type(ch);
34 | 
35 |             pbump(1);
36 |             flush();
37 |         }
38 | 
39 |         return ch;
40 |     }
41 | 
42 | } // dbg
43 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/memcpy_cast.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef MEMCPY_CAST_HPP_1127_27082012
 7 | #define MEMCPY_CAST_HPP_1127_27082012
 8 | 
 9 | #include "dbg/static_assert.hpp"
10 | 
11 | #include <cstring>
12 | 
13 | namespace dbg 
14 | {
15 |     template<typename To, typename From>
16 |     To memcpy_cast(const From &x)
17 |     {
18 |         To ret;
19 |         DBG_STATIC_ASSERT(sizeof ret == sizeof x);
20 |         std::memcpy(&ret, &x, sizeof ret);
21 |         return ret;
22 |     }
23 | 
24 | } // dbg
25 | 
26 | #endif // MEMCPY_CAST_HPP_1127_27082012
27 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/osx/debugger.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dbg/debugger.hpp"
 7 | 
 8 | #include <cstddef>
 9 | #include <cstdlib>
10 | #include <cstring>
11 | 
12 | #include <unistd.h>
13 | 
14 | #include <sys/sysctl.h>
15 | #include <sys/types.h>
16 | 
17 | namespace dbg 
18 | {
19 |     bool debugger_attached()
20 |     {
21 |         int mib_name[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid() };
22 | 
23 |         kinfo_proc info;
24 |         std::memset(&info, 0, sizeof info);
25 | 
26 |         std::size_t size = sizeof(info);
27 |         return 
28 |             sysctl(mib_name, sizeof(mib_name) / sizeof(*mib_name), &info, &size, 0, 0) == 0 &&
29 |             (info.kp_proc.p_flag & P_TRACED) != 0;
30 |     }
31 | 
32 |     void debugger_break()
33 |     {
34 |         //Debugger();
35 |         __builtin_trap();
36 |     }
37 | 
38 | } // dbg
39 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/osx/envvar.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "envvar.hpp"
 7 | 
 8 | #include <cassert>
 9 | #include <cstdlib>
10 | 
11 | namespace dbg 
12 | {
13 |     bool envvar_is_set(const char *name)
14 |     {
15 |         assert(name);
16 |         const char *var = std::getenv(name);
17 |         return var && *var != '\0' && *var != '0';
18 |     }
19 | 
20 | } // dbg
21 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/osx/throw_state.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "throw_state.hpp"
 7 | #include "spin_mutex.hpp"
 8 | 
 9 | #include <new>
10 | #include <cstring>
11 | 
12 | #include <pthread.h>
13 | 
14 | namespace dbg 
15 | {
16 |     namespace  
17 |     {
18 |         spin_mutex tls_creation_mutex = SPIN_MUTEX_INITIALIZER;
19 |         pthread_key_t key;
20 |         bool key_created = false;
21 | 
22 | 
23 |         void delete_throw_state(void *p) { delete static_cast<throw_state *>(p); }
24 | 
25 |         bool get_key(pthread_key_t &out)
26 |         {
27 |             scoped_spin_lock lk(tls_creation_mutex);
28 | 
29 |             if (!key_created)
30 |             {
31 |                 if (pthread_key_create(&key, &delete_throw_state) != 0) return false;
32 |                 key_created = true;
33 |             }
34 | 
35 |             out = key;
36 | 
37 |             return true;
38 |         }
39 |     } 
40 | 
41 |     throw_state *throw_state::get()
42 |     {
43 |         pthread_key_t k;
44 |         std::memset(&k, 0x00, sizeof k);
45 |         if (!get_key(k)) return 0;
46 | 
47 |         throw_state *value = static_cast<throw_state *>(pthread_getspecific(key));
48 |         if (value == 0)
49 |         {
50 |             value = new (std::nothrow) throw_state();
51 |             if (!value) return 0;
52 |             if (pthread_setspecific(k, value) != 0) { delete value; return 0; }
53 |         }
54 | 
55 |         return value;
56 |     }
57 | 
58 | } // dbg
59 | 
60 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/osx/timestamp.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "timestamp.hpp"
 7 | 
 8 | #include <ctime>
 9 | #include <cstdio>
10 | #include <cstring>
11 | 
12 | #include <sys/time.h>
13 | 
14 | namespace dbg 
15 | {
16 |     void generate_timestamp(stamp_buff &buff)
17 |     {
18 |         timeval tv;
19 |         std::memset(&tv, 0, sizeof tv);
20 | 
21 |         (void)gettimeofday(&tv, 0);
22 | 
23 |         std::tm now_tm;
24 |         ::localtime_r(&tv.tv_sec, &now_tm);
25 |         std::strftime(buff, sizeof buff, "%H:%M:%S", &now_tm);
26 | 
27 |         std::sprintf(buff + 8, ".%06d", static_cast<int>(tv.tv_usec));
28 |     }
29 | 
30 | } // dbg
31 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/symlog.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dbg/symlog.hpp"
 7 | #include "memcpy_cast.hpp"
 8 | 
 9 | #include <ostream>
10 | #include <cstddef>
11 | #include <cstring>
12 | 
13 | namespace dbg 
14 | {
15 |     symlog::symlog(std::ostream &out, const char *prefix, const char *suffix) :
16 |         out(out),
17 |         prefix(prefix ? prefix : ""),
18 |         suffix(suffix ? suffix : "")
19 |     {
20 |     }
21 | 
22 |     void symlog::process_function(const void *program_counter, const char *name, const char *module)
23 |     {
24 |         const std::size_t pc = memcpy_cast<std::size_t>(program_counter);
25 | 
26 |         out << prefix << "0x";
27 | 
28 |         for (unsigned n = 0; n != 2 * sizeof(pc); ++n)
29 |         {
30 |             const std::size_t shift = (sizeof(pc) * 8) - 4 * (n + 1);
31 |             const std::size_t mask = std::size_t(0xF) << shift;
32 |             const std::size_t nibble = (pc & mask) >> shift;
33 | 
34 |             out << "0123456789abcdef"[nibble];
35 |         }
36 | 
37 |         out << ": " << name << " in " << module << suffix;
38 |     }
39 |         
40 | } // dbg
41 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/throw_state.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef THROW_STATE_HPP_1530_23062012
 7 | #define THROW_STATE_HPP_1530_23062012
 8 | 
 9 | #include "dbg/throw.hpp"
10 | #include "dbg/frames.hpp"
11 | 
12 | #include <cstddef>
13 | 
14 | namespace dbg 
15 | {
16 |     struct throw_state
17 |     {
18 |         throw_state() : exception_ref_count(0) { what_buffer[0] = 0; }
19 | 
20 |         char what_buffer[2048];
21 |         throw_info current_exception;
22 | 
23 |         call_stack<256> trace;
24 | 
25 |         std::size_t exception_ref_count;
26 | 
27 |         // Returns throw_state for the calling thread, null if unavailable.
28 |         static throw_state *get();
29 |     };
30 | 
31 | } // dbg
32 | 
33 | #endif // THROW_STATE_HPP_1530_23062012
34 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/timestamp.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef TIMESTAMP_HPP_1727_16072012
 7 | #define TIMESTAMP_HPP_1727_16072012
 8 | 
 9 | #include <iosfwd>
10 | 
11 | namespace dbg 
12 | {
13 |     typedef char stamp_buff[16];
14 | 
15 |     // Fills buff with null terminated string containing the current time.
16 |     void generate_timestamp(stamp_buff &buff);
17 | 
18 |     struct timestamp
19 |     {
20 |         timestamp() { generate_timestamp(buff); }
21 |         stamp_buff buff;
22 |     };
23 | 
24 |     std::ostream &operator << (std::ostream &out, const timestamp &stamp);
25 | 
26 | } // dbg
27 | 
28 | #endif // TIMESTAMP_HPP_1727_16072012
29 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/timestamp_common.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "timestamp.hpp"
 7 | 
 8 | #include <ostream>
 9 | 
10 | namespace dbg 
11 | {
12 |     std::ostream &operator << (std::ostream &out, const timestamp &stamp)
13 |     {
14 |         return out << stamp.buff;
15 |     }
16 | 
17 | } // dbg
18 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/unusual.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #define DBG_ENABLE_UNUSUAL 1
 7 | #include "dbg/unusual.hpp"
 8 | 
 9 | namespace dbg 
10 | {
11 |     namespace impl 
12 |     {
13 |         unusual::unusual(bool predicate, const char *filename, unsigned line, const char *function, unsigned skip_frames) :
14 |             quality_infraction(!predicate, 
15 |                                false,
16 |                                "An unusual condition has been encountered:",
17 |                                filename, line, function,
18 |                                skip_frames)
19 |         {
20 |         }
21 |             
22 |         unusual::~unusual()
23 |         {
24 |             finish();
25 |         }
26 |     
27 |     } // impl
28 | 
29 | } // dbg
30 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/debugger.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dbg/assert.hpp"
 7 | 
 8 | #include <windows.h>
 9 | 
10 | namespace dbg 
11 | {
12 |     bool debugger_attached()
13 |     {
14 |         return IsDebuggerPresent() == TRUE;
15 |     }
16 | 
17 |     void debugger_break()
18 |     {
19 | #if defined(_MSC_VER)
20 |         __debugbreak();
21 | #else
22 |         // __builtin_trap doesn't behave nicely with MinGW's GDB.
23 |         // This seems to do what's required.
24 |         DebugBreak(); 
25 | #endif
26 |     }
27 | 
28 | } // dbg
29 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/dll.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dll.hpp"
 7 | #include "memcpy_cast.hpp"
 8 | 
 9 | #include <algorithm>
10 | 
11 | #include <windows.h>
12 | 
13 | namespace dbg 
14 | {
15 |     dll::dll() :
16 |         module(0)
17 |     {
18 |     }
19 | 
20 |     dll::dll(const char *name) :
21 |         module(LoadLibraryA(name))
22 |     {
23 |     }
24 | 
25 |     dll::~dll()
26 |     {
27 |         if (module)
28 |             FreeLibrary(static_cast<HMODULE>(module));
29 |     }
30 | 
31 |     bool dll::loaded() const
32 |     {
33 |         return module != 0;
34 |     }
35 | 
36 |     dll::opaque_func_ptr dll::find_function(const char *name) const
37 |     {
38 |         if (!module)
39 |             return opaque_func_ptr(0);
40 | 
41 |         return opaque_func_ptr(
42 |             memcpy_cast<void (*)(void)>(GetProcAddress(static_cast<HMODULE>(module), name))
43 |         );
44 |     }
45 | 
46 |     void dll::swap(dll &other)
47 |     {
48 |         std::swap(module, other.module);
49 |     }
50 | 
51 | } // dbg
52 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/envvar.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "envvar.hpp"
 7 | 
 8 | #include <cassert>
 9 | 
10 | #include <windows.h>
11 | 
12 | namespace dbg 
13 | {
14 |     bool envvar_is_set(const char *name)
15 |     {
16 |         assert(name);
17 |         char buffer[2] = "";
18 | 
19 |         if (GetEnvironmentVariableA(name, buffer, sizeof buffer) == 0)
20 |             return false;
21 | 
22 |         return *buffer != '\0' && *buffer != '0';
23 |     }
24 | 
25 | } // dbg
26 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/mingw/pe.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PE_HPP_0129_29062012
 7 | #define PE_HPP_0129_29062012
 8 | 
 9 | #include <cstddef>
10 | 
11 | namespace dbg 
12 | {
13 |     class file;
14 | 
15 |     struct pe_sink
16 |     {
17 |         virtual ~pe_sink() { }
18 | 
19 |         // Implementations should take a copy of name if needed, as the storage only
20 |         // exists for the duration of the on_symbol() call.
21 |         virtual void on_symbol(const char *name, std::size_t image_offset) = 0;
22 |     };
23 | 
24 |     void scan_mingw_pe_file(file &pe, pe_sink &sink);
25 | 
26 | } // dbg
27 | 
28 | #endif // PE_HPP_0129_29062012
29 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/mingw/pe_symtab.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2013
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef PE_SYMTAB_HPP_1210_17022013
 7 | #define PE_SYMTAB_HPP_1210_17022013
 8 | 
 9 | #include <vector>
10 | 
11 | namespace dbg 
12 | {
13 |     class file;
14 | 
15 |     struct pe_symbol
16 |     {
17 |         pe_symbol() : address(0), name_offset(0) { }
18 |         std::size_t address;
19 |         std::size_t name_offset;
20 |     };
21 | 
22 |     inline bool operator< (const pe_symbol &lhs, const pe_symbol &rhs)
23 |     {
24 |         return lhs.address < rhs.address;
25 |     }
26 | 
27 |     class pe_symtab
28 |     {
29 |         public:
30 |             pe_symtab();
31 |             pe_symtab(const void *module, file &pe);
32 | 
33 |             const char *function_spanning(const void *address) const;
34 | 
35 |             void swap(pe_symtab &other);
36 | 
37 |         private:
38 |             pe_symtab(const pe_symtab &);
39 |             pe_symtab &operator= (const pe_symtab &);
40 | 
41 |         private:
42 |             std::vector<char> strtab;
43 |             std::vector<pe_symbol> symbols;
44 |     };
45 | 
46 | } // dbg
47 | 
48 | #endif // PE_SYMTAB_HPP_1210_17022013
49 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/ms_symdb.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #ifndef MS_SYMBOL_DATABASE_HPP_0056_10072012
 7 | #define MS_SYMBOL_DATABASE_HPP_0056_10072012
 8 | 
 9 | #include <cstddef>
10 | 
11 | #include <windows.h>
12 | 
13 | namespace dbg 
14 | {
15 |     class symsink;
16 | 
17 |     // Used to access symbols from Microsoft's own debug-information formats (typically
18 |     // PDB files).
19 |     // This is used by the MinGW and MSVC implementations if dbg::symdb.
20 |     class ms_symdb
21 |     {
22 |         public:
23 |             ms_symdb();
24 |             ~ms_symdb();
25 | 
26 |             // If a function can be found spanning the specified program_counter, its
27 |             // details are emitted through sink and true is returned.
28 |             // Nothing is emitted if such a function cannot be found.
29 |             bool try_lookup_function(const void *program_counter, symsink &sink);
30 | 
31 |         private:
32 |             ms_symdb(const ms_symdb &);
33 |             ms_symdb &operator= (const ms_symdb &);
34 | 
35 |         private:
36 |             const HANDLE process;
37 |     };
38 | 
39 | } // dbg
40 | 
41 | #endif // MS_SYMBOL_DATABASE_HPP_0056_10072012
42 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/msvc/symbols.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dbg/symbols.hpp"
 7 | #include "ms_symdb.hpp"
 8 | 
 9 | #include <new>
10 | 
11 | namespace dbg 
12 | {
13 |     struct symdb::impl
14 |     {
15 |         ms_symdb msdb;
16 |     };
17 |     
18 |     symdb::symdb() :
19 |         p(new (std::nothrow) impl)
20 |     {
21 |     }
22 | 
23 |     symdb::~symdb()
24 |     {
25 |         delete p;
26 |     }
27 | 
28 |     bool symdb::lookup_function(const void *program_counter, symsink &sink) const
29 |     {
30 |         if (p && p->msdb.try_lookup_function(program_counter, sink))
31 |             return true;
32 | 
33 |         sink.on_function(program_counter, 0, 0);
34 |         return false;
35 |     }
36 | 
37 | } // dbg
38 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/symsink.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "dbg/symbols.hpp"
 7 | 
 8 | namespace dbg 
 9 | {
10 |     void symsink::on_function(const void *program_counter, const char *name, const char *module)
11 |     {
12 |         process_function(
13 |             program_counter,
14 |             (name && name[0]) ? name : "[unknown function]",
15 |             (module && module[0]) ? module : "[unknown module]"
16 |         );
17 |     }
18 | 
19 | } // dbg
20 | 


--------------------------------------------------------------------------------
/lib/edd-dbg/src/windows/timestamp.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright Edd Dawson 2012
 2 | // Distributed under the Boost Software License, Version 1.0.
 3 | // (See accompanying file LICENSE_1_0.txt or copy at
 4 | // http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include "timestamp.hpp"
 7 | 
 8 | #include <cstring>
 9 | #include <cstdio>
10 | 
11 | #include <windows.h>
12 | 
13 | namespace dbg 
14 | {
15 |     void generate_timestamp(stamp_buff &buff)
16 |     {
17 |         SYSTEMTIME st;
18 |         std::memset(&st, 0, sizeof st);
19 | 
20 |         GetLocalTime(&st);
21 | 
22 |         std::sprintf(
23 |             buff, 
24 |             "%02d:%02d:%02d.%03d",
25 |             static_cast<int>(st.wHour),
26 |             static_cast<int>(st.wMinute),
27 |             static_cast<int>(st.wSecond),
28 |             static_cast<int>(st.wMilliseconds)
29 |         );
30 |     }
31 | 
32 | } // dbg
33 | 


--------------------------------------------------------------------------------
/lib/miniz/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright 2013-2014 RAD Game Tools and Valve Software
 2 | Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
 3 | 
 4 | All Rights Reserved.
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/scr0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Try/OpenGothic/df960680fe0e14a013f353767b6794caaff5b288/scr0.png


--------------------------------------------------------------------------------
/scripts/Gothic2Notr.bat:
--------------------------------------------------------------------------------
1 | Gothic2Notr.exe -g "C:\Program Files (x86)\Steam\steamapps\common\Gothic II"
2 | 


--------------------------------------------------------------------------------
/scripts/Gothic2Notr.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 3 | export LD_LIBRARY_PATH="$DIR:$LD_LIBRARY_PATH"
 4 | export DYLD_LIBRARY_PATH="$DIR:$DYLD_LIBRARY_PATH"
 5 | if [[ $DEBUGGER != "" ]]; then
 6 |   exec $DEBUGGER --args "$DIR/Gothic2Notr" "$@"
 7 | else
 8 |   exec "$DIR/Gothic2Notr" "$@"
 9 | fi
10 | 


--------------------------------------------------------------------------------
/shader/antialiasing/cmaa2/deferred_color_apply_2x2.frag:
--------------------------------------------------------------------------------
 1 | #version 460
 2 | 
 3 | #extension GL_ARB_separate_shader_objects       : enable
 4 | #extension GL_GOOGLE_include_directive          : enable
 5 | #extension GL_EXT_control_flow_attributes       : enable
 6 | 
 7 | #include "common.glsl"
 8 | #include "cmaa2_common.glsl"
 9 | #include "lighting/tonemapping.glsl"
10 | 
11 | layout(push_constant, std140) uniform PushConstant {
12 |   VideoSettings settings;
13 |   } push;
14 | 
15 | layout(location = 0) out vec4 result;
16 | 
17 | layout(location = 0) in flat uint  currentQuadOffsetXY;
18 | layout(location = 1) in flat uint  inCounterIndexWithHeader;
19 | 
20 | void main() {
21 |   uint counterIndexWithHeader = inCounterIndexWithHeader;
22 | 
23 |   vec4 outColors = vec4(0);
24 |   const uint maxLoops = 32u;
25 |   for(uint i = 0; (counterIndexWithHeader != 0xFFFFFFFF) && (i < maxLoops); i++) {
26 |     uint  offsetXY       = (counterIndexWithHeader >> 30) & 0x03;
27 |     bool  isComplexShape = bool((counterIndexWithHeader >> 26) & 0x01);
28 |     uvec2 val            = deferredBlendItemList[counterIndexWithHeader & ((1u << 26) - 1)];
29 | 
30 |     counterIndexWithHeader = val.x;
31 | 
32 |     if(offsetXY == currentQuadOffsetXY) {
33 |       vec3  color  = internalUnpackColor(val.y);
34 |       float weight = 0.8 + 1.0 * float(isComplexShape);
35 |       outColors += vec4(color * weight, weight);
36 |       }
37 |     }
38 | 
39 |   if(outColors.a == 0)
40 |     discard;
41 | 
42 |   vec3 color = gameTonemap(outColors.rgb/outColors.a, push.settings);
43 |   result = vec4(color, 1);
44 |   }
45 | 


--------------------------------------------------------------------------------
/shader/antialiasing/cmaa2/deferred_color_apply_2x2.vert:
--------------------------------------------------------------------------------
 1 | #version 460
 2 | 
 3 | #extension GL_ARB_separate_shader_objects       : enable
 4 | #extension GL_GOOGLE_include_directive          : enable
 5 | 
 6 | #include "common.glsl"
 7 | #include "cmaa2_common.glsl"
 8 | 
 9 | out gl_PerVertex {
10 |   vec4 gl_Position;
11 |   float gl_PointSize;
12 |   };
13 | 
14 | layout(location = 0) out flat uint  currentQuadOffsetXY;
15 | layout(location = 1) out flat uint  counterIndexWithHeader;
16 | 
17 | void main() {
18 |   const uint  currentCandidate = gl_VertexIndex/4;
19 |   currentQuadOffsetXY          = gl_VertexIndex%4;
20 | 
21 |   const ivec2 viewportSize = textureSize(sceneTonemapped, 0);
22 |   const uint  pixelID      = deferredBlendLocationList[currentCandidate];
23 |   const ivec2 quadPos      = ivec2((pixelID >> 16), pixelID & 0xFFFF);
24 |   const ivec2 qeOffsets[4] = ivec2[4](ivec2(0, 0), ivec2(1, 0), ivec2(0, 1), ivec2(1, 1));
25 |   const uvec2 pixelPos     = quadPos * 2 + qeOffsets[currentQuadOffsetXY];
26 | 
27 |   counterIndexWithHeader = imageLoad(deferredBlendItemListHeads, quadPos).r;
28 |   gl_Position            = vec4((vec2(pixelPos+0.5)/vec2(viewportSize))*2.0-1.0, 0, 1);
29 |   gl_PointSize           = 1;
30 |   }
31 | 


--------------------------------------------------------------------------------
/shader/copy.comp:
--------------------------------------------------------------------------------
 1 | #version 460
 2 | 
 3 | layout(local_size_x = 64) in;
 4 | 
 5 | layout(binding = 0, std430) writeonly buffer Output {
 6 |   uint dst[];
 7 |   };
 8 | 
 9 | layout(binding = 1, std430) readonly buffer Input {
10 |   uint src[];
11 |   };
12 | 
13 | void main() {
14 |   const uint lane = gl_GlobalInvocationID.x;
15 |   if(lane>=dst.length())
16 |     return;
17 |   dst[lane] = src[lane];
18 |   }
19 | 


--------------------------------------------------------------------------------
/shader/copy.frag:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | #extension GL_ARB_separate_shader_objects : enable
 3 | 
 4 | layout(binding = 0) uniform sampler2D src;
 5 | 
 6 | layout(location = 0) out vec4 outColor;
 7 | 
 8 | void main() {
 9 |   outColor = texelFetch(src, ivec2(gl_FragCoord.xy), 0);
10 |   }
11 | 


--------------------------------------------------------------------------------
/shader/copy.vert:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | #extension GL_ARB_separate_shader_objects : enable
 3 | 
 4 | out gl_PerVertex {
 5 |   vec4 gl_Position;
 6 |   };
 7 | 
 8 | layout(location = 0) in  vec2 inPos;
 9 | 
10 | #if defined(HAS_UV)
11 | layout(location = 0) out vec2 UV;
12 | #endif
13 | 
14 | void main() {
15 | #if defined(HAS_UV)
16 |   UV          = inPos*vec2(0.5)+vec2(0.5);
17 | #endif
18 |   gl_Position = vec4(inPos.xy, 1.0, 1.0);
19 |   }
20 | 


--------------------------------------------------------------------------------
/shader/copy_img.comp:
--------------------------------------------------------------------------------
 1 | #version 460
 2 | 
 3 | #extension GL_EXT_samplerless_texture_functions : enable
 4 | 
 5 | layout(local_size_x = 8, local_size_y = 8) in;
 6 | 
 7 | layout(binding = 0) uniform writeonly image2D   dst;
 8 | layout(binding = 1) uniform           texture2D src;
 9 | 
10 | void main() {
11 |   ivec2 fragCoord = ivec2(gl_GlobalInvocationID.xy);
12 |   ivec2 dstSize   = ivec2(imageSize(dst));
13 | 
14 |   const bool valid = all(lessThan(fragCoord, dstSize));
15 |   if(!valid)
16 |     return;
17 | 
18 |   ivec2 srcUV = fragCoord % textureSize(src,0);
19 |   vec4  s     = texelFetch(src, srcUV, 0);
20 |   imageStore(dst, fragCoord, s);
21 |   }
22 | 


--------------------------------------------------------------------------------
/shader/epipolar/fog_shadow_sample.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | #extension GL_EXT_samplerless_texture_functions : enable
 6 | #extension GL_EXT_control_flow_attributes : enable
 7 | 
 8 | #include "epipolar/epipolar_common.glsl"
 9 | #include "scene.glsl"
10 | #include "common.glsl"
11 | 
12 | layout(local_size_x = 128) in;
13 | 
14 | const uint NumThreads = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;
15 | 
16 | layout(binding = 0, rgba8)  uniform image2D rayData;
17 | layout(binding = 1, std140) uniform UboScene {
18 |   SceneDesc scene;
19 |   };
20 | layout(binding = 2, std430) readonly buffer Ep0 { Epipole epipole[]; };
21 | layout(binding = 3) uniform sampler2D textureSm1;
22 | 
23 | 
24 | uint  NumSamples = imageSize(rayData).x;
25 | uint  NumSlices  = imageSize(rayData).y;
26 | 
27 | float shadowTexelFetch(vec2 shPos0) {
28 |   return textureLod(textureSm1, shPos0, 0).r;
29 |   }
30 | 
31 | void main() {
32 |   const uint i       = gl_GlobalInvocationID.x;
33 |   const uint sliceId = gl_GlobalInvocationID.y;
34 | 
35 |   if(i>=NumSamples)
36 |     return;
37 | 
38 |   vec2  rayOrig = epipole[sliceId].rayOrig;
39 |   vec2  rayDir  = epipole[sliceId].rayDir;
40 |   float tMin    = epipole[sliceId].tMin;
41 |   float tMax    = epipole[sliceId].tMax;
42 |   float dBegin  = epipole[sliceId].dBegin;
43 |   float dEnd    = epipole[sliceId].dEnd;
44 | 
45 |   const float a     = (i+0.5)/float(NumSamples);
46 |   const float t     = tMin    + a*(tMax-tMin);
47 |   const float depth = min(dBegin, dEnd);
48 |   const vec2  shPos = rayOrig + t*rayDir;
49 | 
50 |   const float sh    = shadowTexelFetch(shPos);
51 |   imageStore(rayData, ivec2(i, sliceId), vec4(sh<depth ? 0 : sh));
52 |   }
53 | 
54 | 


--------------------------------------------------------------------------------
/shader/hiz/hiz_pot.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive : enable
 4 | 
 5 | #include "common.glsl"
 6 | 
 7 | layout(binding = 0)      uniform sampler2D         zbuffer;
 8 | layout(binding = 1, r16) uniform writeonly image2D hiZ;
 9 | 
10 | layout(local_size_x = 8, local_size_y = 8) in;
11 | 
12 | uint nextPot(uint x) {
13 |   x--;
14 |   x |= x >> 1;
15 |   x |= x >> 2;
16 |   x |= x >> 4;
17 |   x |= x >> 8;
18 |   x |= x >> 16;
19 |   x++;
20 |   return x;
21 |   }
22 | 
23 | uvec2 nextPot(uvec2 v) {
24 |   return uvec2(nextPot(v.x), nextPot(v.y));
25 |   }
26 | 
27 | shared uint depthSh;
28 | 
29 | void main() {
30 |   depthSh = 0;
31 |   barrier();
32 | 
33 |   const uvec2 srcSz  = textureSize(zbuffer,0);
34 |   const uvec2 potSz  = nextPot(srcSz);
35 |   const ivec2 dstSz  = imageSize(hiZ);
36 |   const ivec2 tileSz = ivec2(potSz)/dstSz;
37 | 
38 |   // const ivec2 tileCnt = tileSz/ivec2(gl_WorkGroupSize.xy); // 4x4, for shadows
39 | 
40 |   float z = 0;
41 |   const ivec2 at0 = ivec2(gl_WorkGroupID.xy) * tileSz;
42 |   const ivec2 xy0 = ivec2(gl_LocalInvocationID.xy);
43 |   for(int x=xy0.x; x<tileSz.x; x+=int(gl_WorkGroupSize.x)) {
44 |     for(int y=xy0.y; y<tileSz.y; y+=int(gl_WorkGroupSize.y)) {
45 |       ivec2 at = at0 + ivec2(x,y);
46 |       if(any(greaterThanEqual(at,srcSz)))
47 |         continue;
48 |       float zv = texelFetch(zbuffer, at, 0).r;
49 |       z = max(z, zv);
50 |       }
51 |     }
52 |   atomicMax(depthSh, floatBitsToUint(z));
53 |   barrier();
54 | 
55 |   if(gl_LocalInvocationID.xy == uvec2(0)) {
56 |     z = uintBitsToFloat(depthSh);
57 |     z = packHiZ(z);
58 |     imageStore(hiZ, ivec2(gl_WorkGroupID.xy), vec4(z + 1.0/32768.0));
59 |     }
60 |   }
61 | 


--------------------------------------------------------------------------------
/shader/inventory/item.frag:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | #extension GL_ARB_separate_shader_objects : enable
 3 | 
 4 | layout(binding = 0) uniform sampler2D textureD;
 5 | 
 6 | layout(location = 0) in  vec2 UV;
 7 | layout(location = 0) out vec4 outColor;
 8 | 
 9 | void main() {
10 |   vec4 t = texture(textureD,UV);
11 |   if(t.a<0.5)
12 |     discard;
13 |   outColor = t;
14 |   }
15 | 


--------------------------------------------------------------------------------
/shader/inventory/item.vert:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | #extension GL_ARB_separate_shader_objects : enable
 3 | 
 4 | out gl_PerVertex {
 5 |   vec4 gl_Position;
 6 |   };
 7 | layout(location = 0) out vec2 UV;
 8 | 
 9 | layout(location = 0) in vec3 inPos;
10 | layout(location = 1) in vec3 inNormal;
11 | layout(location = 2) in vec2 inUV;
12 | layout(location = 3) in uint inColor;
13 | 
14 | layout(push_constant, std430) uniform UboPush {
15 |   mat4 viewProject;
16 |   };
17 | 
18 | void main() {
19 |   UV          = inUV;
20 |   gl_Position = viewProject*vec4(inPos,1.0);
21 |   }
22 | 


--------------------------------------------------------------------------------
/shader/lighting/purkinje_shift.glsl:
--------------------------------------------------------------------------------
 1 | #ifndef PURKINJE_SHIFT_GLSL
 2 | #define PURKINJE_SHIFT_GLSL
 3 | 
 4 | // https://advances.realtimerendering.com/s2021/jpatry_advances2021/index.html#/167/0/1
 5 | vec3 purkinjeShift(vec3 rgbLightHdr) {
 6 |   const mat4x3 matLmsrFromRgb = mat4x3(
 7 |         0.31670331, 0.70299344, 0.08120592,
 8 |         0.10129085, 0.72118661, 0.12041039,
 9 |         0.01451538, 0.05643031, 0.53416779,
10 |         0.01724063, 0.60147464, 0.40056206);
11 | 
12 |   const mat3 matRgbFromLmsGain = mat3(
13 |         4.57829597, -4.48749114,  0.31554848,
14 |         -0.63342362,  2.03236026, -0.36183302,
15 |         -0.05749394, -0.09275939,  1.90172089);
16 | 
17 |   vec4 lmsr    = rgbLightHdr * matLmsrFromRgb;
18 |   vec3 lmsGain = 1.0/sqrt(1.0 + lmsr.xyz);
19 |   return (lmsGain * matRgbFromLmsGain) * lmsr.w;
20 |   }
21 | 
22 | #endif
23 | 


--------------------------------------------------------------------------------
/shader/lighting/rt/probe_dbg.vert:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_ARB_separate_shader_objects : enable
 4 | #extension GL_GOOGLE_include_directive    : enable
 5 | 
 6 | #include "lighting/rt/probe_common.glsl"
 7 | #include "scene.glsl"
 8 | 
 9 | layout(binding = 0, std140) uniform UboScene {
10 |   SceneDesc scene;
11 |   };
12 | layout(binding = 2, std430) readonly buffer Pbo  { ProbesHeader probeHeader; Probe probe[]; };
13 | layout(binding = 3, std430) readonly buffer Hbo0 { uint hashTable[]; };
14 | 
15 | layout(location = 0) out vec3      center;
16 | layout(location = 1) out float     radius;
17 | layout(location = 2) out flat uint instanceIndex;
18 | layout(location = 3) out flat uint isHashed;
19 | 
20 | 
21 | const vec3 v[8] = {
22 |   {-1,-1,-1},
23 |   { 1,-1,-1},
24 |   { 1, 1,-1},
25 |   {-1, 1,-1},
26 | 
27 |   {-1,-1, 1},
28 |   { 1,-1, 1},
29 |   { 1, 1, 1},
30 |   {-1, 1, 1},
31 |   };
32 | 
33 | const uint index[36] = {
34 |   0, 1, 3, 3, 1, 2,
35 |   1, 5, 2, 2, 5, 6,
36 |   5, 4, 6, 6, 4, 7,
37 |   4, 0, 7, 7, 0, 3,
38 |   3, 2, 7, 7, 2, 6,
39 |   4, 5, 0, 0, 5, 1
40 |   };
41 | 
42 | void main() {
43 |   const uint probeId = gl_InstanceIndex;
44 |   if(probeId>=probeHeader.count) {
45 |     gl_Position = vec4(0);
46 |     return;
47 |     }
48 | 
49 |   Probe p = probe[probeId];
50 |   if((p.bits & UNUSED_BIT)!=0){
51 |     gl_Position = vec4(0);
52 |     return;
53 |     }
54 | 
55 |   const vec3 vert = v[index[gl_VertexIndex]];
56 |   const vec4 pp = scene.viewProject * vec4(p.pos, 1.0);
57 | 
58 |   radius        = dbgViewRadius;// * pp.w;
59 |   gl_Position   = scene.viewProject * vec4(p.pos + vert * radius, 1.0);
60 |   center        = p.pos;
61 |   instanceIndex = probeId;
62 | 
63 |   const vec3 gridPos = probe[probeId].pos/probeGridStep;
64 |   const uint h       = probeGridPosHash(ivec3(gridPos)) % hashTable.length();
65 |   const uint cursor  = hashTable[h];
66 |   isHashed = (cursor==probeId) ? 1 : 0;
67 |   }
68 | 


--------------------------------------------------------------------------------
/shader/lighting/rt/probe_hit_dbg.frag:
--------------------------------------------------------------------------------
 1 | #version 460
 2 | 
 3 | #extension GL_ARB_separate_shader_objects : enable
 4 | #extension GL_GOOGLE_include_directive    : enable
 5 | 
 6 | #include "lighting/rt/probe_common.glsl"
 7 | #include "scene.glsl"
 8 | #include "common.glsl"
 9 | 
10 | layout(binding = 0, std140) uniform UboScene {
11 |   SceneDesc scene;
12 |   };
13 | layout(binding = 1) uniform sampler2D probesLighting;
14 | layout(binding = 4, std430) readonly buffer Pbo { ProbesHeader probeHeader; Probe probe[]; };
15 | 
16 | layout(location = 0) in  vec3  center;
17 | layout(location = 1) in  float radius;
18 | layout(location = 2) in  flat uint instanceIndex;
19 | 
20 | layout(location = 0) out vec4 outColor;
21 | 
22 | vec3 unprojectDepth(float z) {
23 |   const vec2 fragCoord = (gl_FragCoord.xy*scene.screenResInv)*2.0-vec2(1.0);
24 |   const vec4 pos       = vec4(fragCoord.xy, z, 1.0);///gl_FragCoord.w);
25 |   const vec4 ret       = scene.viewProjectInv*pos;
26 |   return (ret.xyz/ret.w);
27 |   }
28 | 
29 | void main(void) {
30 |   vec3 pos1 = unprojectDepth(gl_FragCoord.z);
31 |   vec3 pos0 = unprojectDepth(0);
32 |   vec3 view = normalize(pos1-pos0);
33 | 
34 |   vec4 sp = scene.viewProject * vec4(center, 1.0);
35 |   sp.xyz /= sp.w;
36 | 
37 |   float t = rayIntersect(pos0-center, view, radius);
38 |   if(t<0)
39 |     discard;
40 | 
41 |   Probe p    = probe[instanceIndex];
42 |   //vec3  norm = normalize((pos0+view*t) - p.pos);
43 |   //vec3  clr  = probeReadAmbient(probesLighting, instanceIndex, norm, p.normal) * scene.exposure;
44 |   vec3 clr = vec3(0);
45 |   clr = debugColors[instanceIndex%debugColors.length()];
46 | 
47 |   if((p.bits & BAD_BIT)!=0)
48 |     clr = vec3(1,0,0);
49 |   if((p.bits & NEW_BIT)!=0 )
50 |     clr = vec3(0,1,0);
51 | 
52 |   outColor = vec4(clr,1.0);
53 |   // outColor = vec4(1,0,0,1.0);
54 |   }
55 | 


--------------------------------------------------------------------------------
/shader/materials/cluster_init.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive : enable
 4 | 
 5 | #include "scene.glsl"
 6 | 
 7 | layout(local_size_x = 32) in;
 8 | 
 9 | layout(push_constant, std430) uniform UboPush {
10 |   uint isMeshShader;
11 |   };
12 | 
13 | layout(binding = 4, std430) buffer IndirectBuf  { IndirectCmd cmd[];         };
14 | 
15 | void main() {
16 |   const uint i = gl_GlobalInvocationID.x;
17 |   if(i>=cmd.length())
18 |     return;
19 | 
20 |   cmd[i].vertexCount   = 64*3;
21 |   cmd[i].instanceCount = 0;
22 |   // cmd[i].firstVertex   = isMeshShader;
23 |   // cmd[i].firstInstance = isMeshShader;
24 |   }
25 | 


--------------------------------------------------------------------------------
/shader/materials/cluster_patch.comp:
--------------------------------------------------------------------------------
 1 | #version 460
 2 | 
 3 | #extension GL_ARB_separate_shader_objects : enable
 4 | #extension GL_GOOGLE_include_directive : enable
 5 | 
 6 | layout(local_size_x = 64) in;
 7 | 
 8 | struct Cluster {
 9 |   vec4  sphere;
10 |   uint  bucketId_commandId;
11 |   uint  firstMeshlet;
12 |   int   meshletCount;
13 |   uint  instanceId;
14 |   };
15 | 
16 | layout(binding = 0, std430) writeonly buffer Dst { Cluster dst[];     };
17 | layout(binding = 1, std430) readonly  buffer Src { Cluster src[];     };
18 | layout(binding = 2, std430) readonly  buffer Idx { uint    indices[]; };
19 | 
20 | layout(push_constant, std430) uniform UboPush {
21 |   uint clusterCount;
22 |   };
23 | 
24 | void main() {
25 |   if(gl_GlobalInvocationID.x >= clusterCount)
26 |     return;
27 |   const uint id = indices[gl_GlobalInvocationID.x];
28 |   dst[id] = src[gl_GlobalInvocationID.x];
29 |   }
30 | 


--------------------------------------------------------------------------------
/shader/materials/main.tesc:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | #extension GL_ARB_separate_shader_objects : enable
 3 | #extension GL_GOOGLE_include_directive : enable
 4 | 
 5 | layout(vertices = 3) out;
 6 | 
 7 | #include "materials_common.glsl"
 8 | 
 9 | in gl_PerVertex {
10 |   vec4 gl_Position;
11 |   } gl_in[gl_MaxPatchVertices];
12 | 
13 | layout(location = 0) in  flat uint bucketIdIn[];
14 | layout(location = 1) in  Varyings  shInp[];
15 | 
16 | layout(location = 0) out flat uint bucketId[];
17 | layout(location = 1) out Varyings  shOut[];
18 | 
19 | const int MAX_INNER = 16;
20 | const int MAX_OUTER = 16;
21 | 
22 | float tessFactor(vec3 a, vec3 b) {
23 |   float l = length(a-b)+0.5;
24 |   return l*MAX_OUTER+1;
25 |   }
26 | 
27 | float tessInnerFactor(vec2 a, vec2 b, vec2 c) {
28 |   a -= c;
29 |   b -= c;
30 |   float z = a.x*b.y - b.x*a.y;
31 |   return (abs(z)+0.5)*MAX_INNER;
32 |   }
33 | 
34 | float tessFactor(in vec4 a, in vec4 b) {
35 |   return tessFactor(a.xyz/a.w, b.xyz/b.w);
36 |   }
37 | 
38 | float tessInnerFactor(in vec4 a, in vec4 b, in vec4 c) {
39 |   return tessInnerFactor(a.xy/a.w, b.xy/b.w, c.xy/c.w);
40 |   }
41 | 
42 | void main() {
43 |   if(gl_InvocationID==0) {
44 |     vec4 pos0 = gl_in[0].gl_Position;
45 |     vec4 pos1 = gl_in[1].gl_Position;
46 |     vec4 pos2 = gl_in[2].gl_Position;
47 | 
48 |     gl_TessLevelInner[0] = tessInnerFactor(pos0,pos1,pos2);
49 | 
50 |     gl_TessLevelOuter[0] = tessFactor(pos1,pos2);
51 |     gl_TessLevelOuter[1] = tessFactor(pos0,pos2);
52 |     gl_TessLevelOuter[2] = tessFactor(pos0,pos1);
53 |     }
54 | 
55 |   bucketId[gl_InvocationID]           = bucketIdIn[gl_InvocationID];
56 | 
57 |   gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
58 |   shOut[gl_InvocationID]              = shInp[gl_InvocationID];
59 |   }
60 | 


--------------------------------------------------------------------------------
/shader/patch.comp:
--------------------------------------------------------------------------------
 1 | #version 460
 2 | 
 3 | layout(local_size_x = 32) in;
 4 | 
 5 | struct Path {
 6 |   uint dst;
 7 |   uint src;
 8 |   uint size;
 9 |   };
10 | 
11 | layout(binding = 0, std430) writeonly buffer Output {
12 |   uint dst[];
13 |   };
14 | 
15 | layout(binding = 1, std430) readonly buffer Input {
16 |   uint src[];
17 |   };
18 | 
19 | void main() {
20 |   Path p;
21 |   p.dst  = src[gl_WorkGroupID.x*3+0];
22 |   p.src  = src[gl_WorkGroupID.x*3+1];
23 |   p.size = src[gl_WorkGroupID.x*3+2];
24 | 
25 |   // p.src  = src[gl_WorkGroupID.x*2+0];
26 |   // p.dst  = src[gl_WorkGroupID.x*2+1];
27 |   // p.size = p.src & 0xFFFF0000;
28 |   // p.src  &= 0x0000FFFF;
29 | 
30 |   for(uint i=gl_LocalInvocationID.x; i<p.size; i+=gl_WorkGroupSize.x) {
31 |     dst[p.dst + i] = src[p.src + i];
32 |     }
33 |   }
34 | 


--------------------------------------------------------------------------------
/shader/rtsm/rtsm_clear.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | #extension GL_EXT_samplerless_texture_functions : enable
 6 | 
 7 | #include "rtsm_common.glsl"
 8 | #include "scene.glsl"
 9 | 
10 | layout(local_size_x = 8, local_size_y = 8) in;
11 | 
12 | layout(binding = 0, r32ui)  uniform uimage3D    pageTbl;
13 | layout(binding = 1, std430)         buffer Rt   { RtsmHeader header; uvec2 visList[]; } rtsm;
14 | layout(binding = 2, std430)         buffer Pos  { uint alloc; uint data[];            } pos;
15 | layout(binding = 3, std430)         buffer Cbuf { uvec4 cmd; uint tiles[];            } largeTile;
16 | 
17 | void main() {
18 |   if(gl_GlobalInvocationID==ivec3(0)) {
19 |     rtsm.header.visCount = 0;
20 |     rtsm.header.one1     = 1;
21 |     rtsm.header.one2     = 1;
22 | 
23 |     pos.alloc            = 1; // reserve 0, for nullptr and meshlet-counter
24 |     pos.data[0]          = 0; // num meshelts
25 | 
26 |     largeTile.cmd        = uvec4(0,1,1,0);
27 |     }
28 | 
29 |   const ivec3 at   = ivec3(gl_GlobalInvocationID);
30 |   const ivec3 size = imageSize(pageTbl);
31 |   if(any(greaterThanEqual(at, size)))
32 |     return;
33 | 
34 |   imageStore(pageTbl, at, uvec4(0xFFFFFFFF));
35 |   }
36 | 


--------------------------------------------------------------------------------
/shader/rtsm/rtsm_clear_omni.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | #extension GL_EXT_samplerless_texture_functions : enable
 6 | 
 7 | #include "rtsm_common.glsl"
 8 | #include "scene.glsl"
 9 | 
10 | layout(local_size_x = 1) in;
11 | 
12 | layout(binding = 0, std430) buffer Pos  { uint       alloc;  uint data[];     } pos;
13 | layout(binding = 1, std430) buffer VId  { uvec4      count;  LightId data[];  } vLights;
14 | layout(binding = 2, std430) buffer Rt   { RtsmHeader header; uvec2 visList[]; } rtsm;
15 | 
16 | void main() {
17 |   if(gl_GlobalInvocationID==ivec3(0)) {
18 |     rtsm.header.visCount = 0;
19 |     rtsm.header.one1     = 1;
20 |     rtsm.header.one2     = 1;
21 | 
22 |     pos.alloc     = 1; // reserve 0, for nullptr and meshlet-counter
23 |     pos.data[0]   = 0; // num meshelts
24 |     vLights.count = uvec4(0,1,1,0);
25 |     }
26 |   }
27 | 


--------------------------------------------------------------------------------
/shader/rtsm/rtsm_direct_light.frag:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | #extension GL_EXT_samplerless_texture_functions : enable
 6 | 
 7 | #include "lighting/tonemapping.glsl"
 8 | #include "scene.glsl"
 9 | #include "common.glsl"
10 | 
11 | layout(binding  = 0, std140) uniform UboScene {
12 |   SceneDesc scene;
13 |   };
14 | layout(binding = 1)         uniform texture2D   gbufDiffuse;
15 | layout(binding = 2)         uniform utexture2D  gbufNormal;
16 | layout(binding = 3)         uniform texture2D   depth;
17 | layout(binding = 4)         uniform texture2D   shadowmask;
18 | layout(binding = 5)         uniform texture2D   directLight;
19 | 
20 | layout(location = 0) out vec4 outColor;
21 | 
22 | float lambert(vec3 normal) {
23 |   return max(0.0, dot(scene.sunDir,normal));
24 |   }
25 | 
26 | void main() {
27 |   outColor = vec4(0,0,0, 1);
28 | 
29 |   const ivec2 fragCoord = ivec2(gl_FragCoord.xy);
30 | 
31 |   const vec4  diff        = texelFetch(gbufDiffuse, fragCoord, 0);
32 |   const float shadow      = texelFetch(shadowmask, fragCoord, 0).r;
33 |   const vec3  localLights = texelFetch(directLight, fragCoord, 0).rgb;
34 |   const float light       = 1;
35 | 
36 |   const vec3  illuminance = scene.sunColor * light * shadow;
37 |   const vec3  linear      = textureAlbedo(diff.rgb);
38 |   const vec3  luminance   = linear * Fd_Lambert * illuminance;
39 | 
40 |   const vec3  local       = linear * localLights;
41 | 
42 |   outColor = vec4(luminance * scene.exposure + local, 1);
43 |   }
44 | 


--------------------------------------------------------------------------------
/shader/rtsm/rtsm_hiz_pages.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | #extension GL_EXT_samplerless_texture_functions : enable
 6 | 
 7 | #include "scene.glsl"
 8 | 
 9 | //NOTE: assume 32x32 table
10 | layout(local_size_x = 16, local_size_y = 16) in;
11 | 
12 | layout(binding = 0, r32ui) uniform uimage3D pageTbl;
13 | 
14 | void main() {
15 |   const ivec2 at   = ivec2(gl_GlobalInvocationID);
16 |   const ivec3 size = imageSize(pageTbl);
17 | 
18 |   for(uint i=1; i<size.z; ++i) {
19 |     const ivec3 dst = ivec3(ivec2(gl_GlobalInvocationID) + ivec2(8), i);
20 |     const ivec3 src = ivec3(ivec2(gl_GlobalInvocationID)*2, i-1);
21 | 
22 |     const uint  m  = i-1;
23 |     const uint  a  = imageLoad(pageTbl, src + ivec3(0,0,0)).x;
24 |     const uint  b  = imageLoad(pageTbl, src + ivec3(1,0,0)).x;
25 |     const uint  c  = imageLoad(pageTbl, src + ivec3(1,1,0)).x;
26 |     const uint  d  = imageLoad(pageTbl, src + ivec3(0,1,0)).x;
27 | 
28 |     const uint  h  = min(min(a,b), min(c,d));
29 |     const uint  t  = imageLoad(pageTbl, dst).x;
30 |     imageStore(pageTbl, dst, uvec4(min(h,t)));
31 | 
32 |     memoryBarrierImage();
33 |     barrier();
34 |     }
35 | 
36 |   // imageStore(pageTbl, at, uvec4(0xFFFFFFFF));
37 |   }
38 | 


--------------------------------------------------------------------------------
/shader/scalar_ops.glsl:
--------------------------------------------------------------------------------
 1 | #ifndef SCALAR_OPS_GLSL
 2 | #define SCALAR_OPS_GLSL
 3 | 
 4 | #if (VULKAN >= 110) && defined(GL_KHR_shader_subgroup_basic)
 5 | #extension GL_KHR_shader_subgroup_basic : enable
 6 | #endif
 7 | 
 8 | #if (VULKAN >= 110) && defined(GL_KHR_shader_subgroup_vote)
 9 | #extension GL_KHR_shader_subgroup_vote : enable
10 | #endif
11 | 
12 | shared bool workgroup_bool;
13 | 
14 | bool workgroupAny(bool b) {
15 | #if (VULKAN >= 110) && defined(GL_KHR_shader_subgroup_vote)
16 |   const uint wgSize = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;
17 |   if(wgSize<=gl_SubgroupSize)
18 |     return subgroupAny(b);
19 | #endif
20 |   workgroup_bool = false;
21 |   barrier();
22 |   if(b)
23 |     workgroup_bool = true;
24 |   memoryBarrierShared();
25 |   barrier();
26 |   return workgroup_bool;
27 |   }
28 | 
29 | bool workgroupAll(bool b) {
30 | #if (VULKAN >= 110) && defined(GL_KHR_shader_subgroup_vote)
31 |   const uint wgSize = gl_WorkGroupSize.x*gl_WorkGroupSize.y*gl_WorkGroupSize.z;
32 |   if(wgSize<=gl_SubgroupSize)
33 |     return subgroupAll(b);
34 | #endif
35 |   workgroup_bool = true;
36 |   barrier();
37 |   if(!b)
38 |     workgroup_bool = false;
39 |   memoryBarrierShared();
40 |   barrier();
41 |   return workgroup_bool;
42 |   }
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/shader/sky/clouds_lut.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_EXT_control_flow_attributes : enable
 4 | #extension GL_GOOGLE_include_directive    : enable
 5 | 
 6 | #include "sky_common.glsl"
 7 | 
 8 | layout(local_size_x = 2) in;
 9 | 
10 | layout(binding = 0) uniform writeonly image2D result;
11 | 
12 | layout(binding = 5) uniform sampler2D textureDayL0;
13 | layout(binding = 6) uniform sampler2D textureDayL1;
14 | layout(binding = 7) uniform sampler2D textureNightL0;
15 | layout(binding = 8) uniform sampler2D textureNightL1;
16 | 
17 | vec4 clouds(vec3 at, float nightPhase,
18 |             in sampler2D dayL1,   in sampler2D dayL0,
19 |             in sampler2D nightL1, in sampler2D nightL0) {
20 |   vec3  cloudsAt = normalize(at);
21 |   vec2  texc     = 2000.0*vec2(atan(cloudsAt.z,cloudsAt.y), atan(cloudsAt.x,cloudsAt.y));
22 | 
23 |   vec4  cloudDL1 = textureLod(dayL1,   texc*0.3, textureQueryLevels(dayL1)  );
24 |   vec4  cloudDL0 = textureLod(dayL0,   texc*0.3, textureQueryLevels(dayL0)  );
25 |   vec4  cloudNL1 = textureLod(nightL1, texc*0.3, textureQueryLevels(nightL1));
26 |   vec4  cloudNL0 = vec4(0); // stars
27 | 
28 |   vec4 day       = (cloudDL0+cloudDL1)*0.5;
29 |   vec4 night     = (cloudNL0+cloudNL1)*0.5;
30 | 
31 |   // Clouds (LDR textures from original game) - need to adjust
32 |   day.a     = day.a*(1.0-nightPhase);
33 |   night.a   = night.a*(nightPhase);
34 | 
35 |   vec4 color = mixClr(day,night);
36 |   return color;
37 |   }
38 | 
39 | void main() {
40 |   const ivec2 dstUV = ivec2(gl_GlobalInvocationID.xy);
41 |   float night = gl_GlobalInvocationID.x==0 ? 0.0 : 1.0;
42 | 
43 |   vec4  ret   = clouds(vec3(0,1,0), night, textureDayL1,textureDayL0, textureNightL1,textureNightL0);
44 |   imageStore(result, dstUV, ret);
45 |   }
46 | 


--------------------------------------------------------------------------------
/shader/sky/shadow_downsample.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_EXT_control_flow_attributes : enable
 4 | #extension GL_GOOGLE_include_directive    : enable
 5 | 
 6 | layout(local_size_x = 8, local_size_y = 8) in;
 7 | 
 8 | layout(binding = 0) uniform writeonly image2D shadowLq;
 9 | layout(binding = 1) uniform sampler2D textureSm1;
10 | 
11 | void main() {
12 |   const ivec2 srcSz = textureSize(textureSm1,0);
13 |   const ivec2 dstSz = imageSize(shadowLq);
14 |   const ivec2 dstUV = ivec2(gl_GlobalInvocationID.xy);
15 |   if(dstUV.x>=dstSz.x || dstUV.y>=dstSz.y)
16 |     return;
17 | 
18 |   const int sX = ((dstUV.x+0)*srcSz.x)/dstSz.x;
19 |   const int eX = ((dstUV.x+1)*srcSz.x)/dstSz.x;
20 | 
21 |   const int sY = ((dstUV.y+0)*srcSz.y)/dstSz.y;
22 |   const int eY = ((dstUV.y+1)*srcSz.y)/dstSz.y;
23 | 
24 |   float maxS = 0, cnt = 0;
25 |   for(int y=sY; y<eY; ++y)
26 |     for(int x=sX; x<eX; ++x) {
27 |       // NOTE: this is not strictly correct, as depth buffer values are non-linear
28 |       vec4 sh = texelFetch(textureSm1, ivec2(x,y), 0);
29 |       //maxS = max(maxS, sh.x);
30 |       maxS += sh.x;
31 |       if(sh.x>0)
32 |         cnt++;
33 |       }
34 | 
35 |   maxS = maxS/max(1,cnt);
36 |   imageStore(shadowLq, dstUV, vec4(maxS));
37 |   }
38 | 


--------------------------------------------------------------------------------
/shader/sky/sky_transmittance.frag:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | #extension GL_ARB_separate_shader_objects : enable
 3 | #extension GL_GOOGLE_include_directive : enable
 4 | 
 5 | #include "sky_common.glsl"
 6 | 
 7 | layout(std140, push_constant) uniform Push {
 8 |   vec2 viewportSize;
 9 |   };
10 | layout(binding = 5) uniform sampler2D textureDayL0;
11 | layout(binding = 6) uniform sampler2D textureDayL1;
12 | layout(binding = 7) uniform sampler2D textureNightL0;
13 | layout(binding = 8) uniform sampler2D textureNightL1;
14 | 
15 | layout(location = 0) out vec4 outColor;
16 | 
17 | const int sunTransmittanceSteps = 40;
18 | 
19 | vec3 sunTransmittance(vec3 pos, vec3 sunDir) {
20 |   if(rayIntersect(pos, sunDir, RPlanet) > 0.0)
21 |     return vec3(0.0);
22 | 
23 |   float atmoDist = rayIntersect(pos, sunDir, RAtmos);
24 |   float t = 0.0;
25 | 
26 |   vec3 transmittance = vec3(1.0);
27 |   for(int i=1; i<=sunTransmittanceSteps; ++i) {
28 |     float t  = (float(i)/sunTransmittanceSteps)*atmoDist;
29 |     float dt = atmoDist/sunTransmittanceSteps;
30 | 
31 |     vec3 newPos = pos + t*sunDir;
32 | 
33 |     const ScatteringValues sc = scatteringValues(newPos, 0);
34 |     transmittance *= exp(-dt*sc.extinction);
35 |     }
36 |   return transmittance;
37 |   }
38 | 
39 | void main() {
40 |   vec2  uv          = vec2(gl_FragCoord.xy)/vec2(viewportSize);
41 |   float sunCosTheta = 2.0*uv.x - 1.0;
42 |   float sunTheta    = safeacos(sunCosTheta);
43 |   float height      = mix(RPlanet, RAtmos, uv.y);
44 | 
45 |   vec3  pos         = vec3(0.0, height, 0.0);
46 |   vec3  sunDir      = normalize(vec3(0.0, sunCosTheta, -sin(sunTheta)));
47 | 
48 |   outColor          = vec4(sunTransmittance(pos, sunDir), 1.0);
49 |   }
50 | 


--------------------------------------------------------------------------------
/shader/sky/sun.frag:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_ARB_separate_shader_objects : enable
 4 | #extension GL_GOOGLE_include_directive    : enable
 5 | 
 6 | #include "scene.glsl"
 7 | #include "common.glsl"
 8 | 
 9 | layout(binding = 0, std140) uniform UboScene {
10 |   SceneDesc scene;
11 |   };
12 | layout(binding = 1) uniform sampler2D sunSprite;
13 | layout(binding = 2) uniform sampler2D tLUT;
14 | 
15 | layout(push_constant, std430) uniform UboPush {
16 |   vec2  sunPos;
17 |   vec2  sunSz;
18 |   vec3  sunDir;
19 |   float GSunIntensity;
20 |   mat4  viewProjectInv;
21 |   uint  isSun;
22 |   } push;
23 | 
24 | layout(location = 0) in  vec2 uv;
25 | layout(location = 1) in  vec2 inPos;
26 | 
27 | layout(location = 0) out vec4 outColor;
28 | 
29 | vec3 project(mat4 m, vec3 pos) {
30 |   vec4 p = m*vec4(pos,1);
31 |   return p.xyz/p.w;
32 |   }
33 | 
34 | // 5.5.2. LUT parameterization
35 | vec3 textureLUT(sampler2D tex, vec3 pos, vec3 sunDir) {
36 |   float height   = length(pos);
37 |   vec3  up       = pos / height;
38 |   float cosAngle = dot(sunDir, up);
39 | 
40 |   vec2 uv;
41 |   uv.x = 0.5 + 0.5*cosAngle;
42 |   uv.y = (height - RPlanet)/(RAtmos - RPlanet);
43 |   return texture(tex, uv).rgb;
44 |   }
45 | 
46 | void main() {
47 |   const vec3 pos  = vec3(0, RPlanet+1, 0);
48 |   const vec3 pos0 = project(push.viewProjectInv, vec3(inPos,0.0));
49 |   const vec3 pos1 = project(push.viewProjectInv, vec3(inPos,1.0));
50 |   const vec3 view = normalize(pos1);
51 | 
52 |   const vec4 clr = texture(sunSprite, uv);
53 |   vec3 lum = clr.rgb;
54 |   if(push.isSun!=0) {
55 |     lum *= textureLUT(tLUT, pos, push.sunDir).rgb;
56 |     }
57 | 
58 |   lum *= push.GSunIntensity;
59 |   lum *= scene.exposure;
60 | 
61 |   if(rayIntersect(pos, view, RPlanet)>=0.0) {
62 |     lum = vec3(0.0);
63 |     }
64 | 
65 |   outColor = vec4(lum, clr.a);
66 |   }
67 | 


--------------------------------------------------------------------------------
/shader/sky/sun.vert:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_ARB_separate_shader_objects : enable
 4 | #extension GL_GOOGLE_include_directive    : enable
 5 | 
 6 | out gl_PerVertex {
 7 |   vec4 gl_Position;
 8 |   };
 9 | 
10 | layout(push_constant, std430) uniform UboPush {
11 |   vec2  sunPos;
12 |   vec2  sunSz;
13 |   vec3  sunDir;
14 |   float GSunIntensity;
15 |   mat4  viewProjectInv;
16 |   uint  isSun;
17 |   } push;
18 | 
19 | layout(location = 0) out vec2 uv;
20 | layout(location = 1) out vec2 outPos;
21 | 
22 | const vec2 vert[] = {
23 |    {-1,-1},{ 1,1},{1,-1},
24 |    {-1,-1},{-1,1},{1, 1}
25 | };
26 | 
27 | void main() {
28 |   const bool isSun = push.isSun!=0;
29 | 
30 |   vec2 v = vert[gl_VertexIndex];
31 |   uv = v*0.5 + vec2(0.5);
32 | 
33 |   float scale = 1.0 - (isSun ? length(push.sunPos)*0.25 : 0);
34 |   vec2  pos   = v*(push.sunSz*scale) + push.sunPos;
35 | 
36 |   outPos      = pos;
37 |   gl_Position = vec4(pos, 1.0, 1.0);
38 |   }
39 | 


--------------------------------------------------------------------------------
/shader/stash.frag:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | #extension GL_ARB_separate_shader_objects : enable
 3 | 
 4 | layout(binding = 0) uniform sampler2D src;
 5 | layout(binding = 1) uniform sampler2D zs;
 6 | 
 7 | layout(location = 0) out vec4 outColor;
 8 | layout(location = 1) out vec4 outDepth;
 9 | 
10 | void main() {
11 |   outColor = texelFetch(src, ivec2(gl_FragCoord.xy), 0);
12 |   outDepth = texelFetch(zs,  ivec2(gl_FragCoord.xy), 0);
13 |   }
14 | 


--------------------------------------------------------------------------------
/shader/upscale/lanczos.glsl:
--------------------------------------------------------------------------------
 1 | #ifndef LANCZOS_GLSL
 2 | #define LANCZOS_GLSL
 3 | 
 4 | float lanczosWeight(float x, float r) {
 5 |   const float PI_SQ = 9.8696044010893586188344910;
 6 |   if(x == 0.0)
 7 |     return 1.;
 8 |   return (r * sin(M_PI * x) * sin(M_PI * (x / r) )) / (PI_SQ * x*x);
 9 |   }
10 | 
11 | float lanczosWeight(vec2 x, float r) {
12 |   return lanczosWeight(x.x, r) * lanczosWeight(x.y, r);
13 |   }
14 | 
15 | vec3 lanczosUpscale(in sampler2D img, vec2 coord) {
16 |   const int r = 2;
17 | 
18 |   vec2 res    = vec2(textureSize(img, 0));
19 |   vec2 resInv = 1.0 / res;
20 |   coord      += -0.5 * resInv;
21 |   vec2 ccoord = floor(coord * res) * resInv;
22 | 
23 |   vec3 total = vec3(0);
24 |   [[unroll]]
25 |   for(int x = -r; x <= r; x++) {
26 |     [[unroll]]
27 |     for(int y = -r; y <= r; y++) {
28 |       if(abs(x)==r && abs(y)==r)
29 |         continue;
30 | 
31 |       vec2  offs   = vec2(x,y);
32 |       vec2  sco    = offs * resInv + ccoord;
33 |       vec2  d      = ((sco - coord) * res);
34 | 
35 |       vec3  val    = textureLod(img, sco+0.5*resInv, 0.0).rgb;
36 |       float weight = lanczosWeight(d, float(r));
37 | 
38 |       total     += val * weight;
39 |       }
40 |     }
41 | 
42 |   return total;
43 |   }
44 | 
45 | #endif
46 | 


--------------------------------------------------------------------------------
/shader/virtual_shadow/vsm_clear.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | #extension GL_EXT_samplerless_texture_functions : enable
 6 | 
 7 | #include "virtual_shadow/vsm_common.glsl"
 8 | #include "scene.glsl"
 9 | 
10 | layout(local_size_x = 8, local_size_y = 8) in;
11 | 
12 | layout(binding = 0, std430) buffer CB0 {
13 |   VsmHeader header;
14 |   uint      pageList[];
15 |   };
16 | layout(binding = 1, r32ui) uniform uimage3D pageTbl;
17 | layout(binding = 2, r32ui) uniform uimage3D pageTblDepth;
18 | 
19 | void main() {
20 |   const ivec3 at   = ivec3(gl_GlobalInvocationID);
21 |   const ivec3 size = imageSize(pageTbl);
22 |   if(any(greaterThanEqual(at, size)))
23 |     return;
24 | 
25 |   imageStore(pageTbl, at, uvec4(0));
26 |   // imageStore(pageTblDepth, at, uvec4(floatBitsToUint(1)));
27 |   imageStore(pageTblDepth, at, uvec4(0xFFFFFFFF));
28 | 
29 |   if(at==ivec3(0)) {
30 |     header.pageCount    = 0;
31 |     header.meshletCount = 0;
32 |     header.counterM     = 0;
33 |     header.counterV     = 0;
34 |     }
35 | 
36 |   if(gl_LocalInvocationIndex<16) {
37 |     header.pagePerMip[gl_LocalInvocationIndex] = 0;
38 |     header.pageBbox  [gl_LocalInvocationIndex] = ivec4(0xFF, 0xFF, 0, 0);
39 |     header.pageOmniCount = 0;
40 |     }
41 |   }
42 | 


--------------------------------------------------------------------------------
/shader/virtual_shadow/vsm_clear_omni.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | 
 6 | #include "virtual_shadow/vsm_common.glsl"
 7 | #include "scene.glsl"
 8 | 
 9 | layout(local_size_x = 64) in;
10 | 
11 | layout(binding = 0, std430) buffer Omni { uint pageTblOmni[]; };
12 | layout(binding = 1, std430) buffer VId  { uint visLightCount; uvec4 visLights[]; };
13 | 
14 | void main() {
15 |   if(gl_GlobalInvocationID.x<pageTblOmni.length()) {
16 |     pageTblOmni[gl_GlobalInvocationID.x] = 0;
17 |     }
18 |   if(gl_GlobalInvocationID.x==0)
19 |     visLightCount = 0;
20 |   }
21 | 


--------------------------------------------------------------------------------
/shader/virtual_shadow/vsm_postprocess_omni.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | 
 6 | #include "virtual_shadow/vsm_common.glsl"
 7 | #include "scene.glsl"
 8 | #include "common.glsl"
 9 | 
10 | layout(local_size_x = 64) in;
11 | 
12 | layout(push_constant, std140) uniform Push {
13 |   uint lightsTotal;
14 |   };
15 | layout(binding = 0, std430) buffer Omni { uint pageTblOmni[]; };
16 | 
17 | bool hasPages(uint id) {
18 |   for(uint i=0; i<6; ++i) {
19 |     if(pageTblOmni[id+i]>1)
20 |       return true;
21 |     }
22 |   return false;
23 |   }
24 | 
25 | void main() {
26 |   const uint id = gl_GlobalInvocationID.x;
27 |   if(id >= lightsTotal)
28 |     return;
29 | 
30 |   if(!hasPages(id*6))
31 |     return;
32 | 
33 |   for(uint i=0; i<6; ++i) {
34 |     uint v  = pageTblOmni[id*6+i];
35 |     uint pg = v>0 ? max(v-1, 1) : 0;
36 |     pageTblOmni[id*6+i] = pg;
37 |     }
38 |   }
39 | 


--------------------------------------------------------------------------------
/shader/virtual_shadow/vsm_trim_pages.comp:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_GOOGLE_include_directive    : enable
 4 | #extension GL_ARB_separate_shader_objects : enable
 5 | #extension GL_EXT_samplerless_texture_functions : enable
 6 | 
 7 | #include "virtual_shadow/vsm_common.glsl"
 8 | #include "scene.glsl"
 9 | #include "common.glsl"
10 | 
11 | layout(local_size_x = 32, local_size_y = 32) in;
12 | 
13 | layout(binding = 0, std430) buffer Pages { VsmHeader header; uint  pageList[]; } vsm;
14 | layout(binding = 1, r32ui)  uniform uimage3D pageTbl;
15 | 
16 | void trimPage(int mip) {
17 |   const ivec3 size = imageSize(pageTbl);
18 |   const ivec3 id   = ivec3(gl_LocalInvocationID);
19 | 
20 |   const ivec2 b = ivec2(VSM_PAGE_TBL_SIZE/4);
21 |   const ivec2 h = ivec2(VSM_PAGE_TBL_SIZE/2);
22 | 
23 |   for(int i=id.x; i<h.x; i+=int(gl_WorkGroupSize.x)) {
24 |     for(int r=id.y; r<h.y; r+=int(gl_WorkGroupSize.y)) {
25 |       ivec3 ax = ivec3(i+b.x, r+b.y, mip);
26 |       uint  st = imageLoad(pageTbl, ax).r;
27 |       if(st==0)
28 |         continue;
29 | 
30 |       ivec3 at = ivec3(i*2, r*2, mip-1);
31 |       uint  a  = imageLoad(pageTbl, at+ivec3(0,0,0)).r;
32 |       uint  b  = imageLoad(pageTbl, at+ivec3(1,0,0)).r;
33 |       uint  c  = imageLoad(pageTbl, at+ivec3(0,1,0)).r;
34 |       uint  d  = imageLoad(pageTbl, at+ivec3(1,1,0)).r;
35 |       if(a+b+c+d == 4) {
36 |         imageStore(pageTbl, ax, uvec4(0));
37 |         }
38 |       }
39 |     }
40 |   }
41 | 
42 | void main() {
43 |   const ivec3 size = imageSize(pageTbl);
44 |   for(int i=0; i<size.z; ++i)
45 |     trimPage(i);
46 |   }
47 | 


--------------------------------------------------------------------------------
/shader/water/underwater.frag:
--------------------------------------------------------------------------------
 1 | #version 460
 2 | #extension GL_ARB_separate_shader_objects : enable
 3 | #extension GL_GOOGLE_include_directive : enable
 4 | 
 5 | #include "scene.glsl"
 6 | #include "common.glsl"
 7 | 
 8 | layout(location = 0) out vec4 outColor;
 9 | 
10 | layout(binding = 0, std140) uniform UboScene {
11 |   SceneDesc scene;
12 |   };
13 | layout(binding = 1) uniform sampler2D zbuffer;
14 | 
15 | // fixme: copy-paste
16 | vec4 waterScatter(vec3 back, vec3 normal, const float len) {
17 |   const float depth         = len / 5000.0; // 50 meters
18 |   const vec3  transmittance = exp(-depth * vec3(4,2,1) * 1.25);
19 | #if defined(SCATTERING)
20 |   const float f       = fresnel(scene.sunDir,normal,IorWater);
21 |   const vec3  scatter = f * scene.sunColor * (1-exp(-len/20000.0)) * scene.exposure;
22 |   return vec4(scatter*transmittance, 1);
23 | #else
24 |   return vec4(transmittance, 1);
25 | #endif
26 |   }
27 | 
28 | vec3 unproject(vec4 screen) {
29 |   const vec4 pos4 = scene.viewProjectInv * screen;
30 |   return pos4.xyz/pos4.w;
31 |   }
32 | 
33 | void main() {
34 |   const vec2  fragCoord = (gl_FragCoord.xy*scene.screenResInv)*2.0-vec2(1.0);
35 |   const float depth     = texelFetch(zbuffer,  ivec2(gl_FragCoord.xy), 0).r;
36 | 
37 |   const vec3  camPos    = unproject(vec4(0,0,0, 1.0));
38 |   const vec3  wPos      = unproject(vec4(fragCoord.x, fragCoord.y, depth, 1.0));
39 | 
40 |   const float len = length(wPos-camPos);
41 |   outColor = waterScatter(vec3(1),vec3(0,1,0),len);
42 |   }
43 | 


--------------------------------------------------------------------------------
/shader/water/water_reflection.mesh:
--------------------------------------------------------------------------------
 1 | #version 450
 2 | 
 3 | #extension GL_ARB_separate_shader_objects : enable
 4 | #extension GL_GOOGLE_include_directive : enable
 5 | #extension GL_EXT_control_flow_attributes : enable
 6 | 
 7 | #extension GL_EXT_mesh_shader : require
 8 | 
 9 | #include "scalar_ops.glsl"
10 | #include "common.glsl"
11 | 
12 | layout(local_size_x = 8, local_size_y = 8) in;
13 | layout(triangles, max_vertices = 4, max_primitives = 2) out;
14 | 
15 | out gl_MeshPerVertexEXT {
16 |   vec4 gl_Position;
17 |   } gl_MeshVerticesEXT[];
18 | 
19 | layout(binding = 2) uniform sampler2D gbufDiffuse;
20 | 
21 | bool isWater() {
22 |   const ivec2 size = textureSize(gbufDiffuse,0);
23 |   if(any(greaterThanEqual(gl_GlobalInvocationID.xy,size)))
24 |     return false;
25 |   const vec4 diff  = texelFetch(gbufDiffuse, ivec2(gl_GlobalInvocationID.xy), 0);
26 |   return isGBufWater(diff.a);
27 |   }
28 | 
29 | void main() {
30 |   const vec2 size  = textureSize(gbufDiffuse,0);
31 |   const bool water = isWater();
32 |   const bool any   = workgroupAny(water);
33 | 
34 |   SetMeshOutputsEXT(any ? 4 : 0,
35 |                     any ? 2 : 0);
36 | 
37 |   if(any && gl_LocalInvocationID.xy==uvec2(0)) {
38 |     const vec2 tsize = 2.0*(gl_WorkGroupSize.xy)/size;
39 |     const vec2 at    = 2.0*(gl_GlobalInvocationID.xy/size) - vec2(1);
40 | 
41 |     gl_MeshVerticesEXT[0].gl_Position = vec4(vec2(      0,       0) + at, 0, 1);
42 |     gl_MeshVerticesEXT[1].gl_Position = vec4(vec2(      0, tsize.y) + at, 0, 1);
43 |     gl_MeshVerticesEXT[2].gl_Position = vec4(vec2(tsize.x, tsize.y) + at, 0, 1);
44 |     gl_MeshVerticesEXT[3].gl_Position = vec4(vec2(tsize.x,       0) + at, 0, 1);
45 | 
46 |     gl_PrimitiveTriangleIndicesEXT[0] = uvec3(0,1,2);
47 |     gl_PrimitiveTriangleIndicesEXT[1] = uvec3(0,2,3);
48 |     }
49 |   }
50 | 


--------------------------------------------------------------------------------