There was confusion in the lighting code between light indexes and sun indexes. These are usually the same, but not always. This makes several changes to fix light/sun handling.
1. Clarify the distinction between lights and suns and add a `sun_index` field
2. Add a flags field and assign the `dual_cone` boolean to it, as well as a new glare flag
3. Determine light glare by checking the light flag, not the sun (which never worked in the first place as the `stars_sun_has_glare` function checked bitmaps rather than suns)
This adds several fixes to make the event and menu music more robust:
1. The game will now run with zero soundtracks. All accesses into a potentially empty vector should now have checks.
2. Soundtracks and menu music are now checked for validity before being played (not just when importing a FSM mission).
3. The parsing validity checks and the in-game event music now check for skippable patterns using the same function.
4. Zero measures and zero samples-per-measure now cause the game to skip a pattern. Negative values now trigger a warning.
5. Omitting some or all of the `$Name:` lines for a soundtrack will not cause an assert.
Fixes#5576. Follow-up to #5572.
* Applying directional brightness profile value, disconnected spec flags and made specular light always equal to diffuse light
* Switched over to new command line arguments
* Wire lab up to new lighting controls, and provide backwards-compatible defaults for emissive.
* cleanup unused new function
* make static some functions that can be static
* revise command-line and emissive handling
* handled specular sun depreciation and general removal of specular value handling
* Removed specular light color as a separate value in the uniform buffers.
* cleanup of leftover/post-rebase specular references
* further post-rebase repair of light flags command line and leftover specular
* move techroom/selection/breifing 'room' lights to a common function and
augment lighting setup for current rendering
* fixed some mishandling of lighting modifiers.
* Addressed code clarity and comments from review
* Documentation (+6 squashed commit)
Squashed commit:
[ea8550b54] Resolve errors
[9ab0a576d] Add way to count number of elements in the arrays
[eb74146cc] Correct this boolean check
[60fbc6008] Missed one
[78e65a4b7] Avoid naming collision
[4ea5ddead] Clean unneeded log print and compare like variables
* Adding simulator room here seems like a pretty safe option
* Scpui API to access to build the tech room cutscene list and a few methods to help playing the cutscene and return to the menu accurately
* Scpui API access for credits related data
* # This is a combination of 7 commits.
Clean unneeded log print and compare like variables
Avoid naming collision
Missed one
Correct this boolean check
Add way to count number of elements in the arrays
Resolve errors
Documentation
* Address feedback
* Address feedback
* Add virtvar isCampaignMission
1) Changes the submodel flags to use a flagset instead of several booleans
2) Adds `rotate_accel` to allow submodel rotation acceleration to be specified
Submodel acceleration can now be instant; dumb-rotating submodels always instantly accelerate (and have always done so)
- use standard ADD/GET macros
- better detection of size issues
- support SHRT_MAX ship types
- support SHRT_MAX weapon types
- use MAX_WSS_SLOTS & MAX_SHIP_WEAPONS safely
- support sound indexes higher than 254
The previous system was kind of hacky and made things a bit inflexible.
This improves that system quite a bit and also adds unit tests for the
hook variable functionality.
This is a system for storing arbitrary data in the config file and then
easily retrieving it later on. This has full Lua support for exposing
the available options in a custom UI and changing the values of the
options. This ported some of the existing command line options over to
the new system which is opt-in for the moment by using a mod_table flag.
This adds a new class which allows to create type safe resource handle
types. At the moment, the engine uses ints pretty much everywhere for
providing handles to resources created by the specific subsystems. Since
all ints are the same to the C/C++ typesystem it is perfectly legal to
pass a sound handle to the graphics API as a buffer handle which will
obviously cause issues.
This adds a new type called "ID" which is a wrapper class for a generic
handle but with added type safety. An instance of this class cannot be
passed to a function expecting another type of handle which provided
compile-time type safety for these APIs.
As an initial test I converted the game sound handles to this new type.
I already found a bug in the mainhall system thanks to this new type.
The mainhall used the game sound handles as sound instance handles which
probably meant that that specific code never really worked right. I
removed the code since there was no better alternative for fixing it.
All transformations are now handled by shaders so there is nothing
special going on in the graphics API specific code anymore. Since model
uniform buffers require access to these matrices I moved the matrix
handling out of the graphics API code.
This fixes a few of the bad design descisions of previous shader
iterations. This uses a dedicated class for managing the resources and
uniform locations of a shader program.
Uniforms are also stored in this object which makes a lot more sense
than storing them in the OpenGL state where they had to be reset every
time a new shader was used.
There are still a lot of possible enhancments to make, e.g. by using
uniform blocks and buffers instead of standard uniforms which would make
uniform location handling easier.
Another optimization that I will investigate is reducing the amount or
different compiled shaders by turning some of the current compile-time
defines into bool uniforms.
This introduces a new mechanism for handling bit flags. Instead of using an int (or two, or three) to write bits into, this uses the std::bitset in a wrapper class that accepts an enum class as input. This means that certain classes of errors we've had a few of in the engine, where a coder used the wrong set of flags or checked them against the wrong variable (SF_STEALTH vs SIF_STEALTH, for example) can now be detected at a compiler level rather than not at all.
Goober5000